File Coverage

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

Criterion	Covered	Total	%
statement	43	43	100.0
branch	6	12	50.0
condition			n/a
subroutine			n/a
pod			n/a
total	49	55	89.0

/// \file
// Range v3 library
//
// Copyright Eric Niebler 2014-present
//
//  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_VIEW_ADAPTOR_HPP
#define RANGES_V3_VIEW_ADAPTOR_HPP

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

namespace ranges
{
    inline namespace v3
    {
        /// \cond
        namespace detail
        {
            template
            using begin_adaptor_t =
                detail::decay_t()))>;

            template
            using end_adaptor_t =
                detail::decay_t()))>;

            template
            using adapted_iterator_t =
                detail::decay_t>().begin(std::declval()))>;

            template
            using adapted_sentinel_t =
                detail::decay_t>().end(std::declval()))>;

            struct adaptor_base_current_mem_fn
            {};

            template
            struct adaptor_value_type_2_
              : compressed_pair
            {
                using compressed_pair::compressed_pair;
            };

            template
            struct adaptor_value_type_2_<
                BaseIter,
                Adapt,
                meta::void_(), adaptor_base_current_mem_fn{}))>>
              : compressed_pair
            {
                using compressed_pair::compressed_pair;
                using value_type = value_type_t;
            };

            template
            struct adaptor_value_type_
              : adaptor_value_type_2_
            {
                using adaptor_value_type_2_::adaptor_value_type_2_;
            };

            template
            struct adaptor_value_type_>
              : compressed_pair
            {
                using compressed_pair::compressed_pair;
#ifdef RANGES_WORKAROUND_MSVC_688606
                using value_type = value_type_t;
#else // ^^^ workaround ^^^ / vvv no workaround vvv
                using value_type = typename Adapt::value_type;
#endif // RANGES_WORKAROUND_MSVC_688606
            };
        }
        /// \endcond

        /// \addtogroup group-core
        /// @{
        template
        struct adaptor_cursor;

        template
        struct adaptor_sentinel;

        struct adaptor_base
        {
            adaptor_base() = default;
            adaptor_base(adaptor_base &&) = default;
            adaptor_base(adaptor_base const &) = default;
            adaptor_base &operator=(adaptor_base &&) = default;
            adaptor_base &operator=(adaptor_base const &) = default;

            adaptor_base(detail::any, detail::any = {}, detail::any = {})
            {}
            template
            static constexpr auto begin(Rng &rng)
            RANGES_DECLTYPE_AUTO_RETURN_NOEXCEPT
            (
                ranges::begin(rng.base())
            )
            template
            static constexpr auto end(Rng &rng)
            RANGES_DECLTYPE_AUTO_RETURN_NOEXCEPT
            (
                ranges::end(rng.base())
            )
            template())>
            static bool equal(I const &it0, I const &it1)
            {
                return it0 == it1;
            }
            template())>
            static reference_t read(I const &it,
                detail::adaptor_base_current_mem_fn = {})
                noexcept(noexcept(reference_t(*it)))
            {
                return *it;
            }
            template())>
            static void next(I &it)
            {
                ++it;
            }
            template())>
            static void prev(I &it)
            {
                --it;
            }
            template())>
            static void advance(I &it, difference_type_t n)
            {
                it += n;
            }
            template())>
            static difference_type_t distance_to(I const &it0, I const &it1)
            {
                return it1 - it0;
            }
            template())>
            static constexpr bool empty(I const &it, S const &end)
            {
                return it == end;
            }
        };

        // Build a sentinel out of a sentinel into the adapted range, and an
        // adaptor that customizes behavior.
        template
        struct adaptor_sentinel
          : private compressed_pair
        {
        private:
            template
            friend struct adaptor_cursor;

            using compressed_pair::first;
            using compressed_pair::second;
        public:
            using compressed_pair::compressed_pair;

            // All sentinels into adapted ranges have a base() member for fetching
            // the underlying sentinel.
            BaseSent base() const
            {
                return first();
            }
        };

        // Build a cursor out of an iterator into the adapted range, and an
        // adaptor that customizes behavior.
        template
        struct adaptor_cursor
          : private detail::adaptor_value_type_
        {
        private:
            friend range_access;
            using base_t = detail::adaptor_value_type_;
            using single_pass = meta::or_<
                range_access::single_pass_t,
                SinglePass>;
            struct mixin
              : basic_mixin
            {
                mixin() = default;
                using basic_mixin::basic_mixin;
                // All iterators into adapted ranges have a base() member for fetching
                // the underlying iterator.
                BaseIter base() const
                {
                    return this->get().first();
                }
            };

            using base_t::first;
            using base_t::second;

            template
                std::declval().read(std::declval()))>
            R read() const
                noexcept(noexcept(
                    std::declval().read(std::declval())))
            {
                using V = range_access::cursor_value_t;
                static_assert(
                    CommonReference(),
                    "In your adaptor, you've specified a value type that does not "
                    "share a common reference type with the return type of read.");
                return second().read(first());
            }
            template
                typename = decltype(std::declval().next(std::declval()))>
            void next()
            {
                second().next(first());
            }
            template
                std::declval().equal(
                    std::declval(),
                    std::declval(),
                    std::declval()))>
            bool equal_(adaptor_cursor const &that, int) const
            {
                return second().equal(first(), that.first(), that.second());
            }
            template
                std::declval().equal(
                    std::declval(),
                    std::declval()))>
            bool equal_(adaptor_cursor const &that, long) const
            {
                return second().equal(first(), that.first());
            }
            template
            auto equal(adaptor_cursor const &that) const ->
                decltype(std::declval().equal_(that, 42))
            {
                return this->equal_(that, 42);
            }
            template
                std::declval().empty(
                    std::declval(),
                    std::declval(),
                    std::declval()))>
            constexpr bool equal_(adaptor_sentinel const &that, int) const
            {
                return that.second().empty(first(), second(), that.first());
            }
            template
                std::declval().empty(
                    std::declval(),
                    std::declval()))>
            constexpr bool equal_(adaptor_sentinel const &that, long) const
            {
                return that.second().empty(first(), that.first());
            }
            template
            constexpr auto equal(adaptor_sentinel const &that) const ->
                decltype(std::declval().equal_(that, 42))
            {
                return this->equal_(that, 42);
            }
            template
                std::declval().prev(std::declval()))>
            void prev()
            {
                second().prev(first());
            }
            template
                std::declval().advance(std::declval(), 0))>
            void advance(difference_type_t n)
            {
                second().advance(first(), n);
            }
            template
                std::declval().distance_to(
                    std::declval(),
                    std::declval(),
                    std::declval()))>
            R distance_to_(adaptor_cursor const &that, int) const
            {
                return second().distance_to(first(), that.first(), that.second());
            }
            template
                std::declval().distance_to(
                    std::declval(),
                    std::declval()))>
            R distance_to_(adaptor_cursor const &that, long) const
            {
                return second().distance_to(first(), that.first());
            }
            template
            auto distance_to(adaptor_cursor const &that) const ->
                decltype(std::declval().distance_to_(that, 42))
            {
                return this->distance_to_(that, 42);
            }
            // If the adaptor has an iter_move function, use it.
            template
                std::declval().iter_move(
                    std::declval()))>
            X iter_move_(int) const
                noexcept(noexcept(std::declval().iter_move(
                    std::declval())))
            {
                using V = range_access::cursor_value_t;
                using R = decltype(second().read(first()));
                static_assert(
                    CommonReference(),
                    "In your adaptor, the result of your iter_move member function does "
                    "not share a common reference with your value type.");
                static_assert(
                    CommonReference(),
                    "In your adaptor, the result of your iter_move member function does "
                    "not share a common reference with the result of your read member "
                    "function.");
                return second().iter_move(first());
            }
            // If there is no iter_move member and the adaptor has not overridden the read
            // member function, then dispatch to the base iterator's iter_move function.
            template
                typename R = decltype(std::declval().read(
                    std::declval(), detail::adaptor_base_current_mem_fn{})),
                typename X = rvalue_reference_t>
            X iter_move_(long) const
                noexcept(noexcept(X(ranges::iter_move(std::declval()))))
            {
                return ranges::iter_move(first());
            }
            // If the adaptor does not have an iter_move function but overrides the read
            // member function, apply std::move to the result of calling read.
            template
                typename R = decltype(std::declval().read(std::declval())),
                typename X = aux::move_t>
            X iter_move_(detail::any) const
                noexcept(noexcept(X(static_cast(
                    std::declval().read(std::declval())))))
            {
                using V = range_access::cursor_value_t;
                static_assert(
                    CommonReference(),
                    "In your adaptor, you've specified a value type that does not share a common "
                    "reference type with the result of moving the result of the read member "
                    "function. Consider defining an iter_move function in your adaptor.");
                return static_cast(second().read(first()));
            }
            // Gives users a way to override the default iter_move function in their adaptors.
            auto move() const
                noexcept(noexcept(std::declval().iter_move_(42))) ->
                decltype(std::declval().iter_move_(42))
            {
                return iter_move_(42);
            }
        public:
            using base_t::base_t;
        };

        template
        using adaptor_cursor_t =
            adaptor_cursor, detail::begin_adaptor_t>;

        template
        using adaptor_sentinel_t =
            meta::if_<
                meta::and_<
                    Same, detail::adapted_sentinel_t>,
                    Same, detail::end_adaptor_t>>,
                adaptor_cursor_t,
                adaptor_sentinel, detail::end_adaptor_t>>;

        template
            cardinality Cardinality /*= range_cardinality::value*/>
        struct view_adaptor
          : view_facade
        {
        private:
            friend Derived;
            friend range_access;
            friend adaptor_base;
            using base_range_t = view::all_t;
            using view_facade::derived;

            base_range_t rng_;

            constexpr adaptor_base begin_adaptor() const noexcept
            {
                return {};
            }
            constexpr adaptor_base end_adaptor() const noexcept
            {
                return {};
            }

            template
            static RANGES_CXX14_CONSTEXPR adaptor_cursor_t begin_cursor_(D &d)
                noexcept(noexcept(adaptor_cursor_t{
                    std::declval &>().begin(d),
                    range_access::begin_adaptor(d)}))
            {
                auto adapt = range_access::begin_adaptor(d);
                auto pos = adapt.begin(d);
                return {std::move(pos), std::move(adapt)};
            }
            template())>
            RANGES_CXX14_CONSTEXPR auto begin_cursor()
            RANGES_DECLTYPE_NOEXCEPT(view_adaptor::begin_cursor_(std::declval()))
            {
                return view_adaptor::begin_cursor_(derived());
            }
            template
                CONCEPT_REQUIRES_(Same() && Range())>
            RANGES_CXX14_CONSTEXPR auto begin_cursor() const
            RANGES_DECLTYPE_NOEXCEPT(view_adaptor::begin_cursor_(std::declval()))
            {
                return view_adaptor::begin_cursor_(derived());
            }

            template
            static RANGES_CXX14_CONSTEXPR adaptor_sentinel_t end_cursor_(D &d)
                noexcept(noexcept(adaptor_sentinel_t{
                    std::declval &>().end(d),
                    range_access::end_adaptor(d)}))
            {
                auto adapt = range_access::end_adaptor(d);
                auto pos = adapt.end(d);
                return {std::move(pos), std::move(adapt)};
            }
            template())>
            RANGES_CXX14_CONSTEXPR auto end_cursor()
            RANGES_DECLTYPE_NOEXCEPT(view_adaptor::end_cursor_(std::declval()))
            {
                return view_adaptor::end_cursor_(derived());
            }
            template
                CONCEPT_REQUIRES_(Same() && Range())>
            RANGES_CXX14_CONSTEXPR auto end_cursor() const
            RANGES_DECLTYPE_NOEXCEPT(view_adaptor::end_cursor_(std::declval()))
            {
                return view_adaptor::end_cursor_(derived());
            }
        protected:
            ~view_adaptor() = default;
        public:
            view_adaptor() = default;
            view_adaptor(view_adaptor &&) = default;
            view_adaptor(view_adaptor const &) = default;
            view_adaptor &operator=(view_adaptor &&) = default;
            view_adaptor &operator=(view_adaptor const &) = default;
            explicit constexpr view_adaptor(BaseRng &&rng)
              : rng_(view::all(static_cast(rng)))
            {}
            RANGES_CXX14_CONSTEXPR base_range_t &base() noexcept
            {
                return rng_;
            }
            /// \overload
            constexpr base_range_t const &base() const noexcept
            {
                return rng_;
            }
        };

        /// @}
    }
}

#endif