File Coverage

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

Criterion	Covered	Total	%
statement	16	16	100.0
branch			n/a
condition			n/a
subroutine			n/a
pod			n/a
total	16	16	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_RANGE_ACCESS_HPP
#define RANGES_V3_RANGE_ACCESS_HPP

#include
#include
#include
#include
#include

namespace ranges
{
    inline namespace v3
    {
        /// \addtogroup group-core
        /// @{
        struct range_access
        {
            /// \cond
        private:
            template
            static std::false_type single_pass_2_(long);
            template
            static typename T::single_pass single_pass_2_(int);

            template
            struct single_pass_
            {
                using type = decltype(range_access::single_pass_2_(42));
            };

            template
            static meta::id> mixin_base_2_(long);
            template
            static meta::id mixin_base_2_(int);

            template
            struct mixin_base_
              : decltype(range_access::mixin_base_2_(42))
            {};

        public:
            template
            using single_pass_t = meta::_t>;

            template
            using mixin_base_t = meta::_t>;

            //
            // Concepts that the range cursor must model
            //
            struct Cursor
            {
                template
                auto requires_() -> decltype(
                    concepts::valid_expr(
                        concepts::model_of(),
                        concepts::model_of>(),
                        concepts::model_of, T>(),
                        concepts::model_of, T const &>()
                    ));
                    // Axiom: mixin_base_t has a member get(), accessible to derived classes,
                    //   which perfectly-returns the contained cursor object and does not throw
                    //   exceptions.
            };
            struct HasCursorNext
            {
                template
                auto requires_(T &t) -> decltype(
                    concepts::valid_expr(
                        (t.next(), concepts::void_)
                    ));
            };
            struct CursorSentinel
              : concepts::refines
            {
                template
                auto requires_(S &s, C &c) -> decltype(
                    concepts::valid_expr(
                        concepts::convertible_to(c.equal(s))
                    ));
            };
            struct ReadableCursor
            {
                template
                auto requires_(T &t) -> decltype(
                    concepts::valid_expr(
                        t.read()
                    ));
            };
            struct HasCursorArrow
            {
                template
                auto requires_(C const &c) -> decltype(
                    concepts::valid_expr(
                        c.arrow()
                    ));
            };
            struct WritableCursor
            {
                template
                auto requires_(T &t, U &&u) -> decltype(
                    concepts::valid_expr(
                        (t.write((U &&) u), 42)
                    ));
            };
            struct SizedCursorSentinel
              : concepts::refines
            {
                template
                auto requires_(S &s, C &c) -> decltype(
                    concepts::valid_expr(
                        concepts::model_of(c.distance_to(s))
                    ));
            };
            struct OutputCursor
              : concepts::refines
            {};
            struct InputCursor
              : concepts::refines
            {};
            struct ForwardCursor
              : concepts::refines
            {
                template
                auto requires_() -> decltype(
                    concepts::valid_expr(
                        concepts::is_false(single_pass_t>())
                    ));
            };
            struct BidirectionalCursor
              : concepts::refines
            {
                template
                auto requires_(T &t) -> decltype(
                    concepts::valid_expr(
                        (t.prev(), concepts::void_)
                    ));
            };
            struct RandomAccessCursor
              : concepts::refines
            {
                template
                auto requires_(T &t) -> decltype(
                    concepts::valid_expr(
                        (t.advance(t.distance_to(t)), concepts::void_)
                    ));
            };
            struct InfiniteCursor
            {
                template
                auto requires_() -> decltype(
                    concepts::valid_expr(
                        concepts::is_true(typename T::is_infinite{})
                    ));
            };

            template
            static RANGES_CXX14_CONSTEXPR auto begin_cursor(Rng &rng)
            RANGES_DECLTYPE_AUTO_RETURN_NOEXCEPT
            (
                rng.begin_cursor()
            )
            template
            static RANGES_CXX14_CONSTEXPR auto end_cursor(Rng &rng)
            RANGES_DECLTYPE_AUTO_RETURN_NOEXCEPT
            (
                rng.end_cursor()
            )

            template
            static RANGES_CXX14_CONSTEXPR auto begin_adaptor(Rng &rng)
            RANGES_DECLTYPE_AUTO_RETURN_NOEXCEPT
            (
                rng.begin_adaptor()
            )
            template
            static RANGES_CXX14_CONSTEXPR auto end_adaptor(Rng &rng)
            RANGES_DECLTYPE_AUTO_RETURN_NOEXCEPT
            (
                rng.end_adaptor()
            )

            template
            static RANGES_CXX14_CONSTEXPR auto read(Cur const &pos)
            RANGES_DECLTYPE_AUTO_RETURN_NOEXCEPT
            (
                pos.read()
            )
            template
            static RANGES_CXX14_CONSTEXPR auto arrow(Cur const &pos)
            RANGES_DECLTYPE_AUTO_RETURN_NOEXCEPT
            (
                pos.arrow()
            )
            template
            static RANGES_CXX14_CONSTEXPR auto move(Cur const &pos)
            RANGES_DECLTYPE_AUTO_RETURN_NOEXCEPT
            (
                pos.move()
            )
            template
            static RANGES_CXX14_CONSTEXPR auto write(Cur &pos, T && t)
            RANGES_DECLTYPE_AUTO_RETURN_NOEXCEPT
            (
                pos.write((T &&) t)
            )
            template
            static RANGES_CXX14_CONSTEXPR auto next(Cur & pos)
            RANGES_DECLTYPE_AUTO_RETURN
            (
                pos.next()
            )
            template
            static RANGES_CXX14_CONSTEXPR auto equal(Cur const &pos, O const &other)
            RANGES_DECLTYPE_AUTO_RETURN
            (
                pos.equal(other)
            )
            template
            static RANGES_CXX14_CONSTEXPR auto prev(Cur & pos)
            RANGES_DECLTYPE_AUTO_RETURN
            (
                pos.prev()
            )
            template
            static RANGES_CXX14_CONSTEXPR auto advance(Cur & pos, D n)
            RANGES_DECLTYPE_AUTO_RETURN
            (
                pos.advance(n)
            )
            template
            static RANGES_CXX14_CONSTEXPR auto distance_to(Cur const &pos, O const &other)
            RANGES_DECLTYPE_AUTO_RETURN
            (
                pos.distance_to(other)
            )

        private:
            template
            using sized_cursor_difference_t =
                decltype(range_access::distance_to(std::declval(), std::declval()));

            template
            static std::ptrdiff_t cursor_difference_2_(detail::any);
            template
            static sized_cursor_difference_t cursor_difference_2_(long);
            template
            static typename T::difference_type cursor_difference_2_(int);

            template
            using cursor_reference_t = decltype(std::declval().read());

            template
            static meta::id>> cursor_value_2_(long);
            template
            static meta::id cursor_value_2_(int);

#ifdef RANGES_WORKAROUND_CWG_1554
            template
            struct cursor_difference
            {
                using type = decltype(range_access::cursor_difference_2_(42));
            };

            template
            struct cursor_value
              : decltype(range_access::cursor_value_2_(42))
            {};
#endif // RANGES_WORKAROUND_CWG_1554
        public:
#ifdef RANGES_WORKAROUND_CWG_1554
            template
            using cursor_difference_t = meta::_t>;

            template
            using cursor_value_t = meta::_t>;
#else // ^^^ workaround ^^^ / vvv no workaround vvv
            template
            using cursor_difference_t = decltype(range_access::cursor_difference_2_(42));

            template
            using cursor_value_t = meta::_t(42))>;
#endif // RANGES_WORKAROUND_CWG_1554

            template
            static RANGES_CXX14_CONSTEXPR Cur &pos(basic_iterator &it) noexcept
            {
                return it.pos();
            }
            template
            static constexpr Cur const &pos(basic_iterator const &it) noexcept
            {
                return it.pos();
            }
            template
            static RANGES_CXX14_CONSTEXPR Cur &&pos(basic_iterator &&it) noexcept
            {
                return detail::move(it.pos());
            }

            template
            static RANGES_CXX14_CONSTEXPR Cur cursor(basic_iterator it)
            {
                return std::move(it.pos());
            }
            /// endcond
        };
        /// @}

        /// \cond
        namespace detail
        {
            template
            using Cursor =
                concepts::models;

            template
            using CursorSentinel =
                concepts::models;

            template
            using ReadableCursor =
                concepts::models;

            template
            using WritableCursor =
                concepts::models;

            template
            using HasCursorNext =
                concepts::models;

            template
            using HasCursorArrow =
                concepts::models;

            template
            using SizedCursorSentinel =
                concepts::models;

            template
            using OutputCursor =
                concepts::models;

            template
            using InputCursor =
                concepts::models;

            template
            using ForwardCursor =
                concepts::models;

            template
            using BidirectionalCursor =
                concepts::models;

            template
            using RandomAccessCursor =
                concepts::models;

            template
            using InfiniteCursor =
                concepts::models;

            template
            using cursor_concept =
                concepts::most_refined<
                    meta::list<
                        range_access::RandomAccessCursor,
                        range_access::BidirectionalCursor,
                        range_access::ForwardCursor,
                        range_access::InputCursor,
                        range_access::Cursor>, T>;

            template
            using cursor_concept_t = meta::_t>;

            template()>
            struct is_writable_cursor_
              : std::true_type
            {};

            template
            struct is_writable_cursor_
              : WritableCursor>
            {};

            template
            struct is_writable_cursor
              : detail::is_writable_cursor_
            {};
        }
        /// \endcond
    }
}

#endif