File Coverage

/usr/local/lib/perl5/site_perl/5.26.1/XS/librangeV3.x/i/range/v3/utility/basic_iterator.hpp

Criterion	Covered	Total	%
statement	19	19	100.0
branch			n/a
condition			n/a
subroutine			n/a
pod			n/a
total	19	19	100.0

/// \file
// Range v3 library
//
//  Copyright Eric Niebler 2014-present
//  Copyright Casey Carter 2016
//
//  Use, modification and distribution is subject to the
//  Boost Software License, Version 1.0. (See accompanying
//  file LICENSE_1_0.txt or copy at
//  http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#ifndef RANGES_V3_UTILITY_BASIC_ITERATOR_HPP
#define RANGES_V3_UTILITY_BASIC_ITERATOR_HPP

#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include

namespace ranges
{
    inline namespace v3
    {
        /// \addtogroup group-utility Utility
        /// @{
        ///
        template
        struct basic_mixin : private box
        {
            CONCEPT_REQUIRES(DefaultConstructible())
            constexpr basic_mixin()
                noexcept(std::is_nothrow_default_constructible::value)
              : box{}
            {}
            CONCEPT_REQUIRES(MoveConstructible())
            explicit constexpr basic_mixin(T &&t)
                noexcept(std::is_nothrow_move_constructible::value)
              : box(detail::move(t))
            {}
            CONCEPT_REQUIRES(CopyConstructible())
            explicit constexpr basic_mixin(T const &t)
                noexcept(std::is_nothrow_copy_constructible::value)
              : box(t)
            {}
        protected:
            using box::get;
        };

        /// \cond
        namespace detail
        {
            template
            using cursor_reference_t =
                decltype(range_access::read(std::declval()));

            // Compute the rvalue reference type of a cursor
            template
            auto cursor_move(Cur const &cur, int) ->
                decltype(range_access::move(cur));
            template
            auto cursor_move(Cur const &cur, long) ->
                aux::move_t>;

            template
            using cursor_rvalue_reference_t =
                decltype(detail::cursor_move(std::declval(), 42));

            // Define conversion operators from the proxy reference type
            // to the common reference types, so that basic_iterator can model Readable
            // even with getters/setters.
            template
            struct proxy_reference_conversion
            {
                operator Head() const
                    noexcept(noexcept(Head(Head(std::declval().read_()))))
                {
                    return Head(static_cast(this)->read_());
                }
            };

            // Collect the reference types associated with cursors
            template()>
            struct cursor_traits
            {
            private:
                struct private_ {};
            public:
                using value_t_ = private_;
                using reference_t_ = private_;
                using rvalue_reference_t_ = private_;
                using common_refs = meta::list<>;
            };

            template
            struct cursor_traits
            {
                using value_t_ = range_access::cursor_value_t;
                using reference_t_ = cursor_reference_t;
                using rvalue_reference_t_ = cursor_rvalue_reference_t;
            private:
                using R1 = reference_t_;
                using R2 = common_reference_t;
                using R3 = common_reference_t;
                using tmp1 = meta::list;
                using tmp2 =
                    meta::if_>, tmp1, meta::push_back>;
                using tmp3 =
                    meta::if_>, tmp2, meta::push_back>;
            public:
                using common_refs = meta::unique>;
            };

            // The One Proxy Reference type to rule them all. basic_iterator uses this
            // as the return type of operator* when the cursor type has a set() member
            // function of the correct signature (i.e., if it can accept a value_type &&).
            template()>
            struct RANGES_EMPTY_BASES basic_proxy_reference
              : cursor_traits
                // The following adds conversion operators to the common reference
                // types, so that basic_proxy_reference can model Readable
              , meta::inherit<
                    meta::transform<
                        typename cursor_traits::common_refs,
                        meta::bind_front<
                            meta::quote,
                            basic_proxy_reference>>>
            {
            private:
                Cur *cur_;
                template
                friend struct basic_proxy_reference;
                template
                friend struct proxy_reference_conversion;
                using typename cursor_traits::value_t_;
                using typename cursor_traits::reference_t_;
                using typename cursor_traits::rvalue_reference_t_;
                CONCEPT_ASSERT_MSG(CommonReference(),
                    "Your readable and writable cursor must have a value type and a reference "
                    "type that share a common reference type. See the ranges::common_reference "
                    "type trait.");
                RANGES_CXX14_CONSTEXPR
                reference_t_ read_() const
                    noexcept(noexcept(reference_t_(range_access::read(std::declval()))))
                {
                    return range_access::read(*cur_);
                }
                template
                RANGES_CXX14_CONSTEXPR
                void write_(T && t) const
                {
                    range_access::write(*cur_, (T &&) t);
                }
            public:
                basic_proxy_reference() = default;
                basic_proxy_reference(basic_proxy_reference const &) = default;
                template
                    CONCEPT_REQUIRES_(ConvertibleTo())>
                RANGES_CXX14_CONSTEXPR
                basic_proxy_reference(basic_proxy_reference const &that) noexcept
                  : cur_(that.cur_)
                {}
                RANGES_CXX14_CONSTEXPR
                explicit basic_proxy_reference(Cur &cur) noexcept
                  : cur_(&cur)
                {}
                CONCEPT_REQUIRES(ReadableCursor())
                RANGES_CXX14_CONSTEXPR
                basic_proxy_reference &operator=(basic_proxy_reference && that)
                {
                    return *this = that;
                }
                CONCEPT_REQUIRES(ReadableCursor())
                RANGES_CXX14_CONSTEXPR
                basic_proxy_reference &operator=(basic_proxy_reference const &that)
                {
                    this->write_(that.read_());
                    return *this;
                }
                CONCEPT_REQUIRES(ReadableCursor())
                RANGES_CXX14_CONSTEXPR
                basic_proxy_reference const &operator=(basic_proxy_reference && that) const
                {
                    return *this = that;
                }
                CONCEPT_REQUIRES(ReadableCursor())
                RANGES_CXX14_CONSTEXPR
                basic_proxy_reference const &operator=(basic_proxy_reference const &that) const
                {
                    this->write_(that.read_());
                    return *this;
                }
                template
                    CONCEPT_REQUIRES_(ReadableCursor() &&
                        WritableCursor>())>
                RANGES_CXX14_CONSTEXPR
                basic_proxy_reference &operator=(basic_proxy_reference && that)
                {
                    return *this = that;
                }
                template
                    CONCEPT_REQUIRES_(ReadableCursor() &&
                        WritableCursor>())>
                RANGES_CXX14_CONSTEXPR
                basic_proxy_reference &operator=(basic_proxy_reference const &that)
                {
                    this->write_(that.read_());
                    return *this;
                }
                template
                    CONCEPT_REQUIRES_(ReadableCursor() &&
                        WritableCursor>())>
                RANGES_CXX14_CONSTEXPR
                basic_proxy_reference const &operator=(basic_proxy_reference && that) const
                {
                    return *this = that;
                }
                template
                    CONCEPT_REQUIRES_(ReadableCursor() &&
                        WritableCursor>())>
                RANGES_CXX14_CONSTEXPR
                basic_proxy_reference const &operator=(basic_proxy_reference const &that) const
                {
                    this->write_(that.read_());
                    return *this;
                }
                template
                    CONCEPT_REQUIRES_(WritableCursor())>
                RANGES_CXX14_CONSTEXPR
                basic_proxy_reference &operator=(T && t)
                {
                    this->write_((T &&) t);
                    return *this;
                }
                template
                    CONCEPT_REQUIRES_(WritableCursor())>
                RANGES_CXX14_CONSTEXPR
                basic_proxy_reference const &operator=(T && t) const
                {
                    this->write_((T &&) t);
                    return *this;
                }
                template
                    CONCEPT_REQUIRES_(ReadableCursor() && EqualityComparable())>
                RANGES_CXX14_CONSTEXPR
                friend bool operator==(basic_proxy_reference const &x, value_t_ const &y)
                {
                    return x.read_() == y;
                }
                template
                    CONCEPT_REQUIRES_(ReadableCursor() && EqualityComparable())>
                RANGES_CXX14_CONSTEXPR
                friend bool operator!=(basic_proxy_reference const &x, value_t_ const &y)
                {
                    return !(x == y);
                }
                template
                    CONCEPT_REQUIRES_(ReadableCursor() && EqualityComparable())>
                RANGES_CXX14_CONSTEXPR
                friend bool operator==(value_t_ const &x, basic_proxy_reference const &y)
                {
                    return x == y.read_();
                }
                template
                    CONCEPT_REQUIRES_(ReadableCursor() && EqualityComparable())>
                RANGES_CXX14_CONSTEXPR
                friend bool operator!=(value_t_ const &x, basic_proxy_reference const &y)
                {
                    return !(x == y);
                }
                template
                    CONCEPT_REQUIRES_(ReadableCursor() && EqualityComparable())>
                RANGES_CXX14_CONSTEXPR
                friend bool operator==(basic_proxy_reference const &x, basic_proxy_reference const &y)
                {
                    return x.read_() == y.read_();
                }
                template
                    CONCEPT_REQUIRES_(ReadableCursor() && EqualityComparable())>
                RANGES_CXX14_CONSTEXPR
                friend bool operator!=(basic_proxy_reference const &x, basic_proxy_reference const &y)
                {
                    return !(x == y);
                }
            };

            auto iter_cat(range_access::InputCursor *) ->
                ranges::input_iterator_tag;
            auto iter_cat(range_access::ForwardCursor *) ->
                ranges::forward_iterator_tag;
            auto iter_cat(range_access::BidirectionalCursor *) ->
                ranges::bidirectional_iterator_tag;
            auto iter_cat(range_access::RandomAccessCursor *) ->
                ranges::random_access_iterator_tag;

            template()>
            struct iterator_associated_types_base
              : range_access::mixin_base_t
            {
            protected:
                using reference_t = basic_proxy_reference;
                using const_reference_t = basic_proxy_reference;
                using cursor_concept_t = range_access::OutputCursor;
            public:
                using reference = void;
                using difference_type = range_access::cursor_difference_t;

                using range_access::mixin_base_t::mixin_base_t;
            };

            template
            using cursor_arrow_t =
                decltype(range_access::arrow(std::declval()));

            template
            struct iterator_associated_types_base
              : range_access::mixin_base_t
            {
            protected:
                using cursor_concept_t = detail::cursor_concept_t;
                using reference_t =
                    meta::if_<
                        is_writable_cursor,
                        basic_proxy_reference,
                        meta::if_<
                            is_writable_cursor,
                            basic_proxy_reference,
                            cursor_reference_t>>;
                using const_reference_t =
                    meta::if_<
                        is_writable_cursor,
                        basic_proxy_reference,
                        cursor_reference_t>;
            public:
                using difference_type = range_access::cursor_difference_t;
                using value_type = range_access::cursor_value_t;
                using reference = reference_t;
                using iterator_category =
                    decltype(detail::iter_cat(_nullptr_v()));
                using pointer = meta::_t
                    HasCursorArrow,
                    meta::defer,
                    std::add_pointer>>;
                using common_reference = common_reference_t;

                using range_access::mixin_base_t::mixin_base_t;
            };
        }
        /// \endcond

#if RANGES_BROKEN_CPO_LOOKUP
        namespace _basic_iterator_ { template  struct adl_hook {}; }
#endif

        template
        struct RANGES_EMPTY_BASES basic_iterator
          : detail::iterator_associated_types_base
#if RANGES_BROKEN_CPO_LOOKUP
          , private _basic_iterator_::adl_hook>
#endif
        {
        private:
            template
            friend struct basic_iterator;
            friend range_access;
            using base_t = detail::iterator_associated_types_base;
            using mixin_t = range_access::mixin_base_t;
            CONCEPT_ASSERT(detail::Cursor());
            using assoc_types_ = detail::iterator_associated_types_base;
            using typename assoc_types_::cursor_concept_t;
            using typename assoc_types_::reference_t;
            using typename assoc_types_::const_reference_t;
            RANGES_CXX14_CONSTEXPR Cur &pos() noexcept
            {
                return this->mixin_t::get();
            }
            constexpr Cur const &pos() const noexcept
            {
                return this->mixin_t::get();
            }

        public:
            using typename assoc_types_::difference_type;
            constexpr basic_iterator() = default;
            template
                CONCEPT_REQUIRES_(ConvertibleTo() &&
                    Constructible())>
            RANGES_CXX14_CONSTEXPR
            basic_iterator(basic_iterator that)
              : base_t{std::move(that.pos())}
            {}
            // Mix in any additional constructors provided by the mixin
            using base_t::base_t;

            template
                CONCEPT_REQUIRES_(!Same, basic_iterator>() &&
                    !detail::HasCursorNext() && detail::WritableCursor())>
            RANGES_CXX14_CONSTEXPR
            basic_iterator &operator=(T && t)
            noexcept(noexcept(std::declval().write(static_cast(t))))
            {
                pos().write(static_cast(t));
                return *this;
            }

            template
                CONCEPT_REQUIRES_(!Same, basic_iterator>() &&
                    !detail::HasCursorNext() && detail::WritableCursor())>
            RANGES_CXX14_CONSTEXPR
            basic_iterator const &operator=(T && t) const
            noexcept(noexcept(std::declval().write(static_cast(t))))
            {
                pos().write(static_cast(t));
                return *this;
            }

            CONCEPT_REQUIRES(detail::ReadableCursor() &&
                !detail::is_writable_cursor())
            constexpr const_reference_t operator*() const
            noexcept(noexcept(range_access::read(std::declval())))
            {
                return range_access::read(pos());
            }
            CONCEPT_REQUIRES(detail::HasCursorNext() &&
                detail::is_writable_cursor())
            RANGES_CXX14_CONSTEXPR reference_t operator*()
            noexcept(noexcept(reference_t{std::declval()}))
            {
                return reference_t{pos()};
            }
            CONCEPT_REQUIRES(detail::HasCursorNext() &&
                detail::is_writable_cursor())
            constexpr const_reference_t operator*() const
            noexcept(noexcept(const_reference_t{std::declval()}))
            {
                return const_reference_t{pos()};
            }
            CONCEPT_REQUIRES(!detail::HasCursorNext())
            RANGES_CXX14_CONSTEXPR basic_iterator &operator*() noexcept
            {
                return *this;
            }

            // Use cursor's arrow() member, if any.
            template
                CONCEPT_REQUIRES_(detail::HasCursorArrow())>
            constexpr auto operator->() const
            noexcept(noexcept(range_access::arrow(std::declval())))
                -> detail::cursor_arrow_t
            {
                return range_access::arrow(pos());
            }
            // Otherwise, if reference_t is an lvalue reference to cv-qualified
            // value_type_t, return the address of **this.
            template
                CONCEPT_REQUIRES_(!detail::HasCursorArrow() &&
                    detail::ReadableCursor() &&
                    std::is_lvalue_reference::value &&
                    Same::value_type,
                        uncvref_t>())>
            constexpr meta::_t>
            operator->() const
            noexcept(noexcept(*std::declval()))
            {
                return std::addressof(**this);
            }

            CONCEPT_REQUIRES(detail::HasCursorNext())
            RANGES_CXX14_CONSTEXPR
            basic_iterator &operator++()
            {
                range_access::next(pos());
                return *this;
            }
            CONCEPT_REQUIRES(!detail::HasCursorNext())
            RANGES_CXX14_CONSTEXPR
            basic_iterator &operator++() noexcept
            {
                return *this;
            }

            CONCEPT_REQUIRES(!Same>())
            RANGES_CXX14_CONSTEXPR
            basic_iterator operator++(int)
            {
                basic_iterator tmp{*this};
                ++*this;
                return tmp;
            }
            CONCEPT_REQUIRES(Same>())
            RANGES_CXX14_CONSTEXPR
            void operator++(int)
            {
                ++*this;
            }

            template())>
            friend constexpr bool operator==(basic_iterator const &left,
                basic_iterator const &right)
            {
                return range_access::equal(left.pos(), range_access::pos(right));
            }
            template())>
            friend constexpr bool operator!=(basic_iterator const &left,
                basic_iterator const &right)
            {
                return !(left == right);
            }
            template())>
            friend constexpr bool operator==(basic_iterator const &left,
                S const &right)
            {
                return range_access::equal(left.pos(), right);
            }
            template())>
            friend constexpr bool operator!=(basic_iterator const &left,
                S const &right)
            {
                return !(left == right);
            }
            template())>
            friend constexpr bool operator==(S const &left,
                basic_iterator const &right)
            {
                return right == left;
            }
            template())>
            friend constexpr bool operator!=(S const &left,
                basic_iterator const &right)
            {
                return right != left;
            }
            CONCEPT_REQUIRES(detail::BidirectionalCursor())
            RANGES_CXX14_CONSTEXPR
            basic_iterator &operator--()
            {
                range_access::prev(pos());
                return *this;
            }
            CONCEPT_REQUIRES(detail::BidirectionalCursor())
            RANGES_CXX14_CONSTEXPR
            basic_iterator operator--(int)
            {
                basic_iterator tmp(*this);
                --*this;
                return tmp;
            }
            CONCEPT_REQUIRES(detail::RandomAccessCursor())
            RANGES_CXX14_CONSTEXPR
            basic_iterator &operator+=(difference_type n)
            {
                range_access::advance(pos(), n);
                return *this;
            }
            CONCEPT_REQUIRES(detail::RandomAccessCursor())
            RANGES_CXX14_CONSTEXPR
            friend basic_iterator operator+(basic_iterator left, difference_type n)
            {
                left += n;
                return left;
            }
            CONCEPT_REQUIRES(detail::RandomAccessCursor())
            RANGES_CXX14_CONSTEXPR
            friend basic_iterator operator+(difference_type n, basic_iterator right)
            {
                right += n;
                return right;
            }
            CONCEPT_REQUIRES(detail::RandomAccessCursor())
            RANGES_CXX14_CONSTEXPR
            basic_iterator &operator-=(difference_type n)
            {
                range_access::advance(pos(), -n);
                return *this;
            }
            CONCEPT_REQUIRES(detail::RandomAccessCursor())
            RANGES_CXX14_CONSTEXPR
            friend basic_iterator operator-(basic_iterator left, difference_type n)
            {
                left -= n;
                return left;
            }
            template
                CONCEPT_REQUIRES_(detail::SizedCursorSentinel())>
            RANGES_CXX14_CONSTEXPR
            friend difference_type operator-(basic_iterator const &left,
                basic_iterator const &right)
            {
                return range_access::distance_to(right.pos(), range_access::pos(left));
            }
            template
                CONCEPT_REQUIRES_(detail::SizedCursorSentinel())>
            RANGES_CXX14_CONSTEXPR
            friend difference_type operator-(S const &left,
                basic_iterator const &right)
            {
                return range_access::distance_to(right.pos(), left);
            }
            template
                CONCEPT_REQUIRES_(detail::SizedCursorSentinel())>
            RANGES_CXX14_CONSTEXPR
            friend difference_type operator-(basic_iterator const &left,
                S const &right)
            {
                return -(right - left);
            }
            // symmetric comparisons
            CONCEPT_REQUIRES(detail::SizedCursorSentinel())
            RANGES_CXX14_CONSTEXPR
            friend bool operator<(basic_iterator const &left, basic_iterator const &right)
            {
                return 0 < (right - left);
            }
            CONCEPT_REQUIRES(detail::SizedCursorSentinel())
            RANGES_CXX14_CONSTEXPR
            friend bool operator<=(basic_iterator const &left, basic_iterator const &right)
            {
                return 0 <= (right - left);
            }
            CONCEPT_REQUIRES(detail::SizedCursorSentinel())
            RANGES_CXX14_CONSTEXPR
            friend bool operator>(basic_iterator const &left, basic_iterator const &right)
            {
                return (right - left) < 0;
            }
            CONCEPT_REQUIRES(detail::SizedCursorSentinel())
            RANGES_CXX14_CONSTEXPR
            friend bool operator>=(basic_iterator const &left, basic_iterator const &right)
            {
                return (right - left) <= 0;
            }
            CONCEPT_REQUIRES(detail::RandomAccessCursor())
            RANGES_CXX14_CONSTEXPR
            const_reference_t operator[](difference_type n) const
            {
                return *(*this + n);
            }

#if !RANGES_BROKEN_CPO_LOOKUP
            // Optionally support hooking iter_move when the cursor sports a
            // move() member function.
            template
                CONCEPT_REQUIRES_(Same() && detail::InputCursor())>
            RANGES_CXX14_CONSTEXPR
            friend auto iter_move(basic_iterator const &it)
            RANGES_DECLTYPE_AUTO_RETURN_NOEXCEPT
            (
                range_access::move(static_cast const &>(it).pos())
            )
#endif
        };

#if RANGES_BROKEN_CPO_LOOKUP
        namespace _basic_iterator_
        {
            // Optionally support hooking iter_move when the cursor sports a
            // move() member function.
            template
                CONCEPT_REQUIRES_(detail::InputCursor())>
            RANGES_CXX14_CONSTEXPR
            auto iter_move(basic_iterator const &it)
            RANGES_DECLTYPE_AUTO_RETURN_NOEXCEPT
            (
                range_access::move(range_access::pos(it))
            )
        }
#endif

        /// Get a cursor from a basic_iterator
        struct get_cursor_fn
        {
            template
            RANGES_CXX14_CONSTEXPR
            Cur &operator()(basic_iterator &it) const noexcept
            {
                return range_access::pos(it);
            }
            template
            RANGES_CXX14_CONSTEXPR
            Cur const &operator()(basic_iterator const &it) const noexcept
            {
                return range_access::pos(it);
            }
            template
            RANGES_CXX14_CONSTEXPR
            Cur operator()(basic_iterator && it) const
                noexcept(std::is_nothrow_move_constructible::value)
            {
                return range_access::pos(std::move(it));
            }
        };

        /// \sa `get_cursor_fn`
        /// \ingroup group-utility
        RANGES_INLINE_VARIABLE(get_cursor_fn, get_cursor)
        /// @}
    }
}

/// \cond
namespace ranges
{
    inline namespace v3
    {
        // common_reference specializations for basic_proxy_reference
        template
        struct basic_common_reference, U, TQual, UQual>
          : basic_common_reference, U, TQual, UQual>
        {};
        template
        struct basic_common_reference, TQual, UQual>
          : basic_common_reference, TQual, UQual>
        {};
        template
        struct basic_common_reference, detail::basic_proxy_reference, TQual, UQual>
          : basic_common_reference, detail::cursor_reference_t, TQual, UQual>
        {};

        // common_type specializations for basic_proxy_reference
        template
        struct common_type, U>
          : common_type, U>
        {};
        template
        struct common_type>
          : common_type>
        {};
        template
        struct common_type, detail::basic_proxy_reference>
          : common_type, range_access::cursor_value_t>
        {};
    }
}

namespace ranges
{
    inline namespace v3
    {
        /// \cond
        namespace detail
        {
            template()>
            struct std_iterator_traits
            {
                using iterator_category = std::output_iterator_tag;
                using difference_type = typename iterator_associated_types_base::difference_type;
                using value_type = void;
                using reference = void;
                using pointer = void;
            };

            template
            struct std_iterator_traits
              : iterator_associated_types_base
            {
                using iterator_category =
                    ::meta::_t<
                        downgrade_iterator_category<
                            typename std_iterator_traits::iterator_category,
                            typename std_iterator_traits::reference>>;
            };
        }
        /// \endcond
    }
}

namespace std
{
    template
    struct iterator_traits< ::ranges::basic_iterator>
      : ::ranges::detail::std_iterator_traits
    {};
}
/// \endcond

#endif