Line data    Source code

       1             : //
       2             : // Copyright (c) 2019 Vinnie Falco (vinnie.falco@gmail.com)
       3             : // Copyright (c) 2022 Alan de Freitas (alandefreitas@gmail.com)
       4             : //
       5             : // Distributed under the Boost Software License, Version 1.0. (See accompanying
       6             : // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
       7             : //
       8             : // Official repository: https://github.com/boostorg/url
       9             : //
      10             : 
      11             : #ifndef BOOST_URL_IMPL_SEGMENTS_ENCODED_BASE_HPP
      12             : #define BOOST_URL_IMPL_SEGMENTS_ENCODED_BASE_HPP
      13             : 
      14             : #include <boost/url/detail/segments_iter_impl.hpp>
      15             : #include <boost/assert.hpp>
      16             : 
      17             : namespace boost {
      18             : namespace urls {
      19             : 
      20             : class segments_encoded_base::iterator
      21             : {
      22             :     detail::segments_iter_impl it_;
      23             : 
      24             :     friend class url_base;
      25             :     friend class segments_encoded_base;
      26             :     friend class segments_encoded_ref;
      27             : 
      28             :     iterator(detail::path_ref const&) noexcept;
      29             :     iterator(detail::path_ref const&, int) noexcept;
      30             : 
      31         387 :     iterator(
      32             :         detail::segments_iter_impl const& it) noexcept
      33         387 :         : it_(it)
      34             :     {
      35         387 :     }
      36             : 
      37             : public:
      38             :     using value_type =
      39             :         segments_encoded_base::value_type;
      40             :     using reference =
      41             :         segments_encoded_base::reference;
      42             :     using pointer = reference;
      43             :     using difference_type = std::ptrdiff_t;
      44             :     using iterator_category =
      45             :         std::bidirectional_iterator_tag;
      46             : 
      47             :     iterator() = default;
      48             :     iterator(iterator const&) = default;
      49             :     iterator& operator=(
      50             :         iterator const&) = default;
      51             : 
      52             :     reference
      53        3839 :     operator*() const noexcept
      54             :     {
      55        3839 :         return it_.dereference();
      56             :     }
      57             : 
      58             :     pointer
      59          21 :     operator->() const noexcept
      60             :     {
      61          21 :         return it_.dereference();
      62             :     }
      63             : 
      64             :     iterator&
      65        1951 :     operator++() noexcept
      66             :     {
      67        1951 :         it_.increment();
      68        1951 :         return *this;
      69             :     }
      70             : 
      71             :     iterator&
      72        1484 :     operator--() noexcept
      73             :     {
      74        1484 :         it_.decrement();
      75        1484 :         return *this;
      76             :     }
      77             : 
      78             :     iterator
      79         598 :     operator++(int) noexcept
      80             :     {
      81         598 :         auto tmp = *this;
      82         598 :         ++*this;
      83         598 :         return tmp;
      84             :     }
      85             : 
      86             :     iterator
      87          21 :     operator--(int) noexcept
      88             :     {
      89          21 :         auto tmp = *this;
      90          21 :         --*this;
      91          21 :         return tmp;
      92             :     }
      93             : 
      94             :     bool
      95         693 :     operator==(
      96             :         iterator const& other) const noexcept
      97             :     {
      98         693 :         return it_.equal(other.it_);
      99             :     }
     100             : 
     101             :     bool
     102        3425 :     operator!=(
     103             :         iterator const& other) const noexcept
     104             :     {
     105        3425 :         return ! it_.equal(other.it_);
     106             :     }
     107             : };
     108             : 
     109             : //------------------------------------------------
     110             : 
     111             : inline
     112             : pct_string_view
     113          97 : segments_encoded_base::
     114             : front() const noexcept
     115             : {
     116          97 :     BOOST_ASSERT(! empty());
     117          97 :     return *begin();
     118             : }
     119             : 
     120             : inline
     121             : pct_string_view
     122          16 : segments_encoded_base::
     123             : back() const noexcept
     124             : {
     125          16 :     BOOST_ASSERT(! empty());
     126          16 :     return *--end();
     127             : }
     128             : 
     129             : } // urls
     130             : } // boost
     131             : 
     132             : #endif