Line data    Source code

       1             : //
       2             : // Copyright (c) 2022 Alan de Freitas (alandefreitas@gmail.com)
       3             : //
       4             : // Distributed under the Boost Software License, Version 1.0. (See accompanying
       5             : // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
       6             : //
       7             : // Official repository: https://github.com/boostorg/url
       8             : //
       9             : 
      10             : #ifndef BOOST_URL_IMPL_PCT_ENCODED_VIEW_HPP
      11             : #define BOOST_URL_IMPL_PCT_ENCODED_VIEW_HPP
      12             : 
      13             : #include <boost/url/grammar/type_traits.hpp>
      14             : #include <boost/static_assert.hpp>
      15             : 
      16             : namespace boost {
      17             : namespace urls {
      18             : 
      19             : class decode_view::iterator
      20             : {
      21             :     char const* begin_ = nullptr;
      22             :     char const* pos_ = nullptr;
      23             :     bool space_as_plus_ = true;
      24             : 
      25             :     friend decode_view;
      26             : 
      27        6340 :     iterator(
      28             :         char const* str,
      29             :         bool space_as_plus) noexcept
      30        6340 :         : begin_(str)
      31             :         , pos_(str)
      32             :         , space_as_plus_(
      33        6340 :             space_as_plus)
      34             :     {
      35        6340 :     }
      36             : 
      37             :     // end ctor
      38         875 :     iterator(
      39             :         char const* str,
      40             :         size_type n,
      41             :         bool space_as_plus) noexcept
      42         875 :         : begin_(str)
      43         875 :         , pos_(str + n)
      44         875 :         , space_as_plus_(space_as_plus)
      45             :     {
      46         875 :     }
      47             : 
      48             : public:
      49             :     using value_type = char;
      50             :     using reference = char;
      51             :     using pointer = void const*;
      52             :     using const_reference = char;
      53             :     using size_type = std::size_t;
      54             :     using difference_type = std::ptrdiff_t;
      55             :     using iterator_category =
      56             :         std::bidirectional_iterator_tag;
      57             : 
      58           2 :     iterator() = default;
      59             : 
      60             :     iterator(iterator const&) = default;
      61             : 
      62             :     iterator&
      63             :     operator=(iterator const&) = default;
      64             : 
      65             :     BOOST_URL_DECL
      66             :     reference
      67             :     operator*() const noexcept;
      68             : 
      69             :     iterator&
      70        4827 :     operator++() noexcept
      71             :     {
      72        4827 :         BOOST_ASSERT(pos_ != nullptr);
      73        4827 :         if (*pos_ != '%')
      74        4538 :             ++pos_;
      75             :         else
      76         289 :             pos_ += 3;
      77        4827 :         return *this;
      78             :     }
      79             : 
      80             :     iterator&
      81        1178 :     operator--() noexcept
      82             :     {
      83        1178 :         BOOST_ASSERT(pos_ != begin_);
      84        1178 :         if (pos_ - begin_ < 3 ||
      85         675 :                 pos_[-3] != '%')
      86        1130 :             --pos_;
      87             :         else
      88          48 :             pos_ -= 3;
      89        1178 :         return *this;
      90             :     }
      91             : 
      92             :     iterator
      93        4660 :     operator++(int) noexcept
      94             :     {
      95        4660 :         auto tmp = *this;
      96        4660 :         ++*this;
      97        4660 :         return tmp;
      98             :     }
      99             : 
     100             :     iterator
     101             :     operator--(int) noexcept
     102             :     {
     103             :         auto tmp = *this;
     104             :         --*this;
     105             :         return tmp;
     106             :     }
     107             : 
     108             :     char const*
     109           7 :     base()
     110             :     {
     111           7 :         return pos_;
     112             :     }
     113             : 
     114             :     bool
     115        2984 :     operator==(
     116             :         iterator const& other) const noexcept
     117             :     {
     118        2984 :         return pos_ == other.pos_;
     119             :     }
     120             : 
     121             :     bool
     122        1954 :     operator!=(
     123             :         iterator const& other) const noexcept
     124             :     {
     125        1954 :         return !(*this == other);
     126             :     }
     127             : };
     128             : 
     129             : //------------------------------------------------
     130             : 
     131             : inline
     132             : auto
     133        6340 : decode_view::
     134             : begin() const noexcept ->
     135             :     const_iterator
     136             : {
     137        6340 :     return {p_, space_as_plus_};
     138             : }
     139             : 
     140             : inline
     141             : auto
     142         875 : decode_view::
     143             : end() const noexcept ->
     144             :     const_iterator
     145             : {
     146         875 :     return {p_, n_, space_as_plus_};
     147             : }
     148             : 
     149             : inline
     150             : auto
     151           3 : decode_view::
     152             : front() const noexcept ->
     153             :     const_reference
     154             : {
     155           3 :     BOOST_ASSERT( !empty() );
     156           3 :     return *begin();
     157             : }
     158             : 
     159             : inline
     160             : auto
     161           3 : decode_view::
     162             : back() const noexcept ->
     163             :     const_reference
     164             : {
     165           3 :     BOOST_ASSERT( !empty() );
     166           3 :     return *--end();
     167             : }
     168             : 
     169             : } // urls
     170             : } // boost
     171             : 
     172             : #endif