File Coverage

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

Criterion	Covered	Total	%
statement	11	11	100.0
branch	4	8	50.0
condition			n/a
subroutine			n/a
pod			n/a
total	15	19	78.9

/// \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_VIEW_HPP
#define RANGES_V3_VIEW_VIEW_HPP

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

namespace ranges
{
    inline namespace v3
    {
        /// \cond
        namespace detail
        {
            struct null_pipe
            {
                template
                void operator()(Rng &&) const
                {}
            };
        }
        /// \endcond

        struct SimpleView
        {
            template
            auto requires_() -> decltype(
                concepts::valid_expr(
                    concepts::model_of() &&
                    concepts::model_of() &&
                    concepts::model_of, iterator_t>() &&
                    concepts::model_of, sentinel_t>()
                ));
        };

        template
        constexpr bool simple_view()
        {
            return concepts::models::value;
        }

        template
        using ViewableRange = meta::and_<
            Range,
            meta::or_, View>>>;

        namespace view
        {
            /// \addtogroup group-views
            /// @{
            struct view_access
            {
                template
                struct impl
                {
                    template
                    static auto bind(Ts &&...ts)
                    RANGES_DECLTYPE_AUTO_RETURN
                    (
                        V::bind(static_cast(ts)...)
                    )
                };
            };

            struct make_view_fn
            {
                template
                view operator()(Fun fun) const
                {
                    return {std::move(fun)};
                }
            };

            /// \ingroup group-views
            /// \sa make_view_fn
            RANGES_INLINE_VARIABLE(make_view_fn, make_view)

            template
            struct view : pipeable>
            {
            private:
                View view_;
                friend pipeable_access;

                template
                using ViewConcept = meta::and_, Invocable>;

                // Piping requires range arguments or lvalue containers.
                template
                    CONCEPT_REQUIRES_(ViewConcept())>
                static auto pipe(Rng && rng, Vw && v)
                RANGES_DECLTYPE_AUTO_RETURN
                (
                    v.view_(static_cast(rng))
                )

            #ifndef RANGES_DOXYGEN_INVOKED
                // For better error messages:
                template
                    CONCEPT_REQUIRES_(!ViewConcept())>
                static void pipe(Rng &&, Vw &&)
                {
                    CONCEPT_ASSERT_MSG(Range(),
                        "The type Rng must be a model of the Range concept.");
                    // BUGBUG This isn't a very helpful message. This is probably the wrong place
                    // to put this check:
                    CONCEPT_ASSERT_MSG(Invocable(),
                        "This view is not callable with this range type.");
                    static_assert(ranges::View() || std::is_lvalue_reference(),
                        "You can't pipe an rvalue container into a view. First, save the container into "
                        "a named variable, and then pipe it to the view.");
                }
            #endif

            public:
                view() = default;
                view(View a)
                  : view_(std::move(a))
                {}

                // Calling directly requires View arguments or lvalue containers.
                template
                    CONCEPT_REQUIRES_(ViewConcept())>
                auto operator()(Rng && rng, Rest &&... rest) const
                RANGES_DECLTYPE_AUTO_RETURN
                (
                    view_(static_cast(rng), static_cast(rest)...)
                )

                // Currying overload.
                template
                auto operator()(Ts &&... ts) const
                RANGES_DECLTYPE_AUTO_RETURN
                (
                    make_view(view_access::impl::bind(view_,
                        static_cast(ts)...))
                )
            };
            /// \endcond
        }
    }
}

#endif