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_BASE_HPP
      12              : #define BOOST_URL_IMPL_SEGMENTS_BASE_HPP
      13              : 
      14              : #include <boost/url/detail/segments_iter_impl.hpp>
      15              : #include <boost/assert.hpp>
      16              : #include <iterator>
      17              : 
      18              : namespace boost {
      19              : namespace urls {
      20              : 
      21              : class segments_base::iterator
      22              : {
      23              :     detail::segments_iter_impl it_;
      24              : 
      25              :     friend class segments_base;
      26              :     friend class segments_ref;
      27              : 
      28              :     iterator(detail::path_ref const&) noexcept;
      29              :     iterator(detail::path_ref const&, int) noexcept;
      30              : 
      31          156 :     iterator(
      32              :         detail::segments_iter_impl const& it) noexcept
      33          156 :         : it_(it)
      34              :     {
      35          156 :     }
      36              : 
      37              : public:
      38              :     using value_type = segments_base::value_type;
      39              :     using reference = segments_base::reference;
      40              :     using pointer = reference;
      41              :     using difference_type =
      42              :         segments_base::difference_type;
      43              :     using iterator_category =
      44              :         std::bidirectional_iterator_tag;
      45              : 
      46              :     iterator() = default;
      47              :     iterator(iterator const&) = default;
      48              :     iterator& operator=(
      49              :         iterator const&) noexcept = default;
      50              : 
      51              :     BOOST_URL_DECL
      52              :     reference
      53              :     operator*() const;
      54              : 
      55              :     // the return value is too expensive
      56              :     pointer operator->() const = delete;
      57              : 
      58              :     iterator&
      59          802 :     operator++() noexcept
      60              :     {
      61          802 :         it_.increment();
      62          802 :         return *this;
      63              :     }
      64              : 
      65              :     iterator&
      66           69 :     operator--() noexcept
      67              :     {
      68           69 :         it_.decrement();
      69           69 :         return *this;
      70              :     }
      71              : 
      72              :     iterator
      73           30 :     operator++(int) noexcept
      74              :     {
      75           30 :         auto tmp = *this;
      76           30 :         ++*this;
      77           30 :         return tmp;
      78              :     }
      79              : 
      80              :     iterator
      81           21 :     operator--(int) noexcept
      82              :     {
      83           21 :         auto tmp = *this;
      84           21 :         --*this;
      85           21 :         return tmp;
      86              :     }
      87              : 
      88              :     bool
      89           56 :     operator==(
      90              :         iterator const& other) const noexcept
      91              :     {
      92           56 :         return it_.equal(other.it_);
      93              :     }
      94              : 
      95              :     bool
      96          906 :     operator!=(
      97              :         iterator const& other) const noexcept
      98              :     {
      99          906 :         return ! it_.equal(other.it_);
     100              :     }
     101              : };
     102              : 
     103              : //------------------------------------------------
     104              : 
     105              : inline
     106              : std::string
     107           27 : segments_base::
     108              : front() const noexcept
     109              : {
     110           27 :     BOOST_ASSERT(! empty());
     111           27 :     return *begin();
     112              : }
     113              : 
     114              : inline
     115              : std::string
     116           20 : segments_base::
     117              : back() const noexcept
     118              : {
     119           20 :     BOOST_ASSERT(! empty());
     120           20 :     return *--end();
     121              : }
     122              : 
     123              : } // urls
     124              : } // boost
     125              : 
     126              : #endif