File Coverage

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

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

/// \file
// Range v3 library
//
//  Copyright Eric Niebler 2013-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_FUNCTIONAL_HPP
#define RANGES_V3_UTILITY_FUNCTIONAL_HPP

#include  // std::reference_wrapper
#include
#include  // std::addressof
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include

RANGES_DISABLE_WARNINGS

namespace ranges
{
    inline namespace v3
    {
        /// \addtogroup group-utility
        /// @{
        struct equal_to
        {
            template
                CONCEPT_REQUIRES_(EqualityComparable())>
            constexpr bool operator()(T && t, U && u) const
            {
                return (T &&) t == (U &&) u;
            }
            using is_transparent = void;
        };

        struct not_equal_to
        {
            template
                CONCEPT_REQUIRES_(EqualityComparable())>
            constexpr bool operator()(T && t, U && u) const
            {
                return (T &&) t != (U &&) u;
            }
            using is_transparent = void;
        };

        struct less
        {
            template
                CONCEPT_REQUIRES_(WeaklyOrdered())>
            constexpr bool operator()(T && t, U && u) const
            {
                return (T &&) t < (U &&) u;
            }
            using is_transparent = void;
        };

        struct ordered_less
        {
            template
                CONCEPT_REQUIRES_(TotallyOrdered())>
            constexpr bool operator()(T && t, U && u) const
            {
                return (T &&) t < (U &&) u;
            }
            using is_transparent = void;
        };

        struct ident
        {
            template
            constexpr
            T && operator()(T && t) const noexcept
            {
                return (T &&) t;
            }
            using is_transparent = void;
        };

        struct plus
        {
            template
            constexpr
            auto operator()(T && t, U && u) const ->
                decltype((T &&) t + (U &&) u)
            {
                return (T &&) t + (U &&) u;
            }
            using is_transparent = void;
        };

        struct minus
        {
            template
            constexpr
            auto operator()(T && t, U && u) const ->
                decltype((T &&) t - (U &&) u)
            {
                return (T &&) t - (U &&) u;
            }
            using is_transparent = void;
        };

        struct multiplies
        {
            template
            constexpr
            auto operator()(T && t, U && u) const ->
                decltype((T &&) t * (U &&) u)
            {
                return (T &&) t * (U &&) u;
            }
            using is_transparent = void;
        };

        struct bitwise_or
        {
            template
            constexpr
            auto operator()(T && t, U && u) const ->
                decltype((T &&) t | (U &&) u)
            {
                return (T &&) t | (U &&) u;
            }
            using is_transparent = void;
        };

        template
        struct convert_to
        {
            template
            constexpr auto operator()(U && u) const
            RANGES_DECLTYPE_AUTO_RETURN_NOEXCEPT
            (
                static_cast((U &&) u)
            )
        };

        template
        struct coerce
        {
            constexpr
            T & operator()(T & t) const
            {
                return t;
            }
            /// \overload
            constexpr
            T const & operator()(T const & t) const
            {
                return t;
            }
            /// \overload
            constexpr
            T operator()(T && t) const
            {
                return (T &&) t;
            }
            T operator()(T const &&) const = delete;
        };

        template
        struct coerce
          : coerce
        {};

        template
        struct coerce
          : coerce
        {};

        template
        struct coerce
          : coerce
        {};

        struct dereference_fn
        {
            template
            constexpr auto operator()(I &i) const
            RANGES_DECLTYPE_AUTO_RETURN_NOEXCEPT
            (
                *i
            )
        };
        RANGES_INLINE_VARIABLE(dereference_fn, dereference)

        /// \addtogroup group-concepts
        /// @{
        namespace concepts
        {
            struct Invocable
            {
                template
                using result_t = invoke_result_t;

                template
                auto requires_() ->
                    meta::void_>;
            };

            struct RegularInvocable
              : refines
            {
                // Axiom: equality_preserving(invoke(f, args...))
            };

            struct Predicate
              : refines
            {
                template
                auto requires_() -> decltype(
                    concepts::valid_expr(
                        concepts::model_of, bool>()
                    ));
            };

            struct Relation
            {
                template
                auto requires_() -> decltype(
                    concepts::valid_expr(
                        concepts::model_of()
                    ));

                template
                auto requires_() -> decltype(
                    concepts::valid_expr(
                        concepts::is_true(std::is_same{}),
                        concepts::model_of()
                    ));

                template
                    typename C =
                        common_reference_t, detail::as_cref_t>>
                auto requires_() -> decltype(
                    concepts::valid_expr(
                        concepts::is_false(std::is_same{}),
                        concepts::model_of(),
                        concepts::model_of(),
                        concepts::model_of<
                            CommonReference, detail::as_cref_t, detail::as_cref_t>(),
                        concepts::model_of(),
                        concepts::model_of(),
                        concepts::model_of()
                    ));
            };
        }

        template
        using Invocable = concepts::models;

        template
        using RegularInvocable = concepts::models;

        template
        using Predicate = concepts::models;

        template
        using Relation = concepts::models;
        /// @}

        template
        struct logical_negate_
        {
        private:
            CONCEPT_ASSERT(Same>() && MoveConstructible());
            FD pred_;
        public:
            CONCEPT_REQUIRES(DefaultConstructible())
            constexpr logical_negate_()
                noexcept(std::is_nothrow_default_constructible::value)
            {}
            template
                typename U = meta::if_c, logical_negate_>(), T>,
                CONCEPT_REQUIRES_(Constructible())>
            explicit constexpr logical_negate_(T && pred)
              : pred_(static_cast(pred))
            {}

// HACKHACKHACK GCC 4.8 is extremely confused about && and const&& qualifiers.
// Luckily they are rare - we'll simply break them.
#if defined(__GNUC__) && !defined(__clang__) && __GNUC__ < 5 && __GNUC_MINOR__ < 9
            template
                CONCEPT_REQUIRES_(Predicate())>
            RANGES_CXX14_CONSTEXPR auto operator()(Args &&...args)
            RANGES_DECLTYPE_NOEXCEPT(
                !invoke(std::declval(), static_cast(args)...))
            {
                return !invoke(pred_, static_cast(args)...);
            }
            /// \overload
            template
                CONCEPT_REQUIRES_(Predicate())>
            constexpr auto operator()(Args &&...args) const
            RANGES_DECLTYPE_NOEXCEPT(
                !invoke(std::declval(), static_cast(args)...))
            {
                return !invoke(pred_, static_cast(args)...);
            }
#else // ^^^ GCC <= 4.8 / GCC > 4.8 vvvv
            template
                CONCEPT_REQUIRES_(Predicate())>
            RANGES_CXX14_CONSTEXPR auto operator()(Args &&...args) &
            RANGES_DECLTYPE_NOEXCEPT(
                !invoke(std::declval(), static_cast(args)...))
            {
                return !invoke(pred_, static_cast(args)...);
            }
            /// \overload
            template
                CONCEPT_REQUIRES_(Predicate())>
            constexpr auto operator()(Args &&...args) const &
            RANGES_DECLTYPE_NOEXCEPT(
                !invoke(std::declval(), static_cast(args)...))
            {
                return !invoke(pred_, static_cast(args)...);
            }
            /// \overload
            template
                CONCEPT_REQUIRES_(Predicate())>
            RANGES_CXX14_CONSTEXPR auto operator()(Args &&...args) &&
            RANGES_DECLTYPE_NOEXCEPT(
                !invoke(std::declval(), static_cast(args)...))
            {
                return !invoke(static_cast(pred_), static_cast(args)...);
            }
            /// \overload
            template
                CONCEPT_REQUIRES_(Predicate())>
            RANGES_CXX14_CONSTEXPR auto operator()(Args &&...args) const &&
            RANGES_DECLTYPE_NOEXCEPT(
                !invoke(std::declval(), static_cast(args)...))
            {
                return !invoke(static_cast(pred_), static_cast(args)...);
            }
#endif // GCC
        };

        struct not_fn_fn
        {
            template,
                CONCEPT_REQUIRES_(MoveConstructible() && Constructible())>
            constexpr logical_negate_ operator()(Pred && pred) const
            {
                return logical_negate_{(Pred &&) pred};
            }
        };

        /// \ingroup group-utility
        /// \sa `not_fn_fn`
        RANGES_INLINE_VARIABLE(not_fn_fn, not_fn)

        /// \cond
        inline namespace
        {
            RANGES_DEPRECATED("\"not_\" now uses the C++17 name \"not_fn\".")
            constexpr const auto& not_ = not_fn;
        }
        /// \endcond

        template
        struct composed
          : private compressed_pair
        {
        private:
            using composed::compressed_pair::first;
            using composed::compressed_pair::second;
            template
            static auto do_(A &a, B &b, std::false_type, Ts &&...ts)
            RANGES_DECLTYPE_AUTO_RETURN_NOEXCEPT
            (
                invoke(b, invoke(a, (Ts &&) ts...))
            )
            template
            static auto do_(A &a, B &b, std::true_type, Ts &&...ts)
            RANGES_DECLTYPE_AUTO_RETURN_NOEXCEPT
            (
                (invoke(a, (Ts &&) ts...),
                 invoke(b))
            )
        public:
            composed() = default;
            composed(Second second, First first)
              : composed::compressed_pair{std::move(first), std::move(second)}
            {}
            template
                typename FirstResultT = invoke_result_t>
            auto operator()(Ts &&...ts)
            RANGES_DECLTYPE_NOEXCEPT(composed::do_(
                std::declval(),
                std::declval(),
                std::is_void{},
                (Ts &&) ts...))
            {
                return composed::do_(
                    first(), second(),
                    std::is_void{},
                    (Ts &&) ts...);
            }
            template
                typename FirstResultT = invoke_result_t>
            auto operator()(Ts &&...ts) const
            RANGES_DECLTYPE_NOEXCEPT(composed::do_(
                std::declval(),
                std::declval(),
                std::is_void{},
                (Ts &&) ts...))
            {
                return composed::do_(
                    first(), second(),
                    std::is_void{},
                    (Ts &&) ts...);
            }
        };

        struct compose_fn
        {
            template
            composed operator()(Second second, First first) const
            {
                return {std::move(second), std::move(first)};
            }
        };

        /// \ingroup group-utility
        /// \sa `compose_fn`
        RANGES_INLINE_VARIABLE(compose_fn, compose)

        template<>
        struct overloaded<>
        {};

        template
        struct overloaded
          : private compressed_pair>
        {
        private:
            using base_t = compressed_pair>;
            using base_t::first;
            using base_t::second;
        public:
            overloaded() = default;
            constexpr overloaded(First first, Rest... rest)
              : overloaded::compressed_pair{
                    detail::move(first),
                    overloaded{detail::move(rest)...}}
            {}
            template
            auto operator()(Args&&...args)
            RANGES_DECLTYPE_NOEXCEPT(
                invoke(std::declval(),
                    static_cast(args)...))
            {
                return invoke(first(), static_cast(args)...);
            }
            template
            auto operator()(Args&&...args) const
            RANGES_DECLTYPE_NOEXCEPT(
                invoke(std::declval(),
                    static_cast(args)...))
            {
                return invoke(first(), static_cast(args)...);
            }
            template
            auto operator()(Args&&...args)
            RANGES_DECLTYPE_NOEXCEPT(
                std::declval &>()(
                    static_cast(args)...))
            {
                return second()(static_cast(args)...);
            }
            template
            auto operator()(Args&&...args) const
            RANGES_DECLTYPE_NOEXCEPT(
                std::declval const &>()(
                    static_cast(args)...))
            {
                return second()(static_cast(args)...);
            }
        };

        struct overload_fn
        {
            template
            constexpr Fn operator()(Fn fn) const
            {
                return fn;
            }

            template
            constexpr overloaded operator()(Fns... fns) const
            {
                return overloaded{detail::move(fns)...};
            }
        };

        /// \ingroup group-utility
        /// \sa `overload_fn`
        RANGES_INLINE_VARIABLE(overload_fn, overload)

        template
        struct indirected
          : private box>
        {
        private:
            using box>::get;
        public:
            indirected() = default;
            indirected(Fn fn)
              : indirected::box(std::move(fn))
            {}
            // value_type (needs no impl)
            template
            [[noreturn]] auto operator()(copy_tag, Its...) const ->
                invoke_result_t...>
            {
                RANGES_EXPECT(false);
            }

            // Reference
            template
            auto operator()(Its ...its)
            RANGES_DECLTYPE_NOEXCEPT(invoke(std::declval(), *its...))
            {
                return invoke(get(), *its...);
            }
            template
            auto operator()(Its ...its) const
            RANGES_DECLTYPE_NOEXCEPT(invoke(std::declval(), *its...))
            {
                return invoke(get(), *its...);
            }

            // Rvalue reference
            template
            auto operator()(move_tag, Its ...its)
                noexcept(noexcept(aux::move(invoke(std::declval(), *its...)))) ->
                aux::move_t(), *its...))>
            {
                return aux::move(invoke(get(), *its...));
            }
            template
            auto operator()(move_tag, Its ...its) const
                noexcept(noexcept(aux::move(invoke(std::declval(), *its...)))) ->
                aux::move_t(), *its...))>
            {
                return aux::move(invoke(get(), *its...));
            }
        };

        struct indirect_fn
        {
            template
            constexpr indirected operator()(Fn fn) const
            {
                return indirected{detail::move(fn)};
            }
        };

        /// \ingroup group-utility
        /// \sa `indirect_fn`
        RANGES_INLINE_VARIABLE(indirect_fn, indirect)

        template
        struct transformed
          : private compressed_pair
        {
        private:
            using transformed::compressed_pair::first;
            using transformed::compressed_pair::second;

        public:
            transformed() = default;
            constexpr transformed(Fn1 fn1, Fn2 fn2)
              : transformed::compressed_pair{detail::move(fn1), detail::move(fn2)}
            {}
            template
            auto operator()(Args &&... args)
            RANGES_DECLTYPE_NOEXCEPT(
                invoke(std::declval(), invoke(std::declval(), static_cast(args))...))
            {
                return invoke(first(), invoke(second(), static_cast(args)...));
            }
            template
            auto operator()(Args &&... args) const
            RANGES_DECLTYPE_NOEXCEPT(
                invoke(std::declval(), invoke(std::declval(), static_cast(args))...))
            {
                return invoke(first(), invoke(second(), static_cast(args)...));
            }
        };

        struct on_fn
        {
            template
            constexpr transformed operator()(Fn1 fn1, Fn2 fn2) const
            {
                return transformed{detail::move(fn1), detail::move(fn2)};
            }
        };

        /// \ingroup group-utility
        /// \sa `on_fn`
        RANGES_INLINE_VARIABLE(on_fn, on)

        /// \cond
        namespace detail
        {
            template
            struct RANGES_EMPTY_BASES pipeable_binder
              : Bind
              , pipeable>
            {
                pipeable_binder(Bind bind)
                  : Bind(std::move(bind))
                {}
            };

            template
            struct composed_pipe
            {
                Pipe0 pipe0_;
                Pipe1 pipe1_;
                template
                auto operator()(Arg && arg) const
                RANGES_DECLTYPE_AUTO_RETURN
                (
                    static_cast(arg) | pipe0_ | pipe1_
                )
            };
        }
        /// \endcond

        struct make_pipeable_fn
        {
            template
            detail::pipeable_binder operator()(Fun fun) const
            {
                return {std::move(fun)};
            }
        };

        /// \ingroup group-utility
        /// \sa `make_pipeable_fn`
        RANGES_INLINE_VARIABLE(make_pipeable_fn, make_pipeable)

        template
            typename U = meta::if_<
                std::is_lvalue_reference,
                std::reference_wrapper>>,
                T &&>>
        U bind_forward(meta::_t> &t) noexcept
        {
            return static_cast(t);
        }

        template
        T && bind_forward(meta::_t> &&t) noexcept
        {
            // This is to catch way sketchy stuff like: forward(42)
            static_assert(!std::is_lvalue_reference::value, "You didn't just do that!");
            return static_cast(t);
        }

        struct pipeable_base
        {};

        template
        struct is_pipeable
          : std::is_base_of
        {};

        template
        struct is_pipeable
          : is_pipeable
        {};

        struct pipeable_access
        {
            template
            struct impl : Pipeable
            {
                using Pipeable::pipe;
            };

            template
            struct impl : impl
            {};
        };

        template
        struct pipeable : pipeable_base
        {
        private:
            friend pipeable_access;
            // Default Pipe behavior just passes the argument to the pipe's function call
            // operator
            template
            static auto pipe(Arg && arg, Pipe pipe)
            RANGES_DECLTYPE_AUTO_RETURN
            (
                pipe(static_cast(arg))
            )
        };

        // Evaluate the pipe with an argument
        template
            CONCEPT_REQUIRES_(!is_pipeable() && is_pipeable())>
        auto operator|(Arg && arg, Pipe pipe)
        RANGES_DECLTYPE_AUTO_RETURN
        (
            pipeable_access::impl::pipe(static_cast(arg), pipe)
        )

        // Compose two pipes
        template
            CONCEPT_REQUIRES_(is_pipeable() && is_pipeable())>
        auto operator|(Pipe0 pipe0, Pipe1 pipe1)
        RANGES_DECLTYPE_AUTO_RETURN
        (
            make_pipeable(detail::composed_pipe{pipe0, pipe1})
        )

        template
        struct bind_element
          : meta::if_<
                std::is_same, T>,
                meta::id,
                bind_element>>
        {};

        template
        struct bind_element>
        {
            using type = T &;
        };

        template
        struct bind_element>
        {
            using type = typename reference_wrapper::reference;
        };

        template
        using bind_element_t = meta::_t>;

        struct ref_fn : pipeable
        {
            template())>
            reference_wrapper operator()(T &t) const
            {
                return {t};
            }
            /// \overload
            template
            reference_wrapper operator()(reference_wrapper t) const
            {
                return t;
            }
            /// \overload
            template
            reference_wrapper operator()(std::reference_wrapper t) const
            {
                return {t.get()};
            }
        };

        /// \ingroup group-utility
        /// \sa `ref_fn`
        RANGES_INLINE_VARIABLE(ref_fn, ref)

        template
        using ref_t = decltype(ref(std::declval()));

        struct unwrap_reference_fn : pipeable
        {
            template())>
            T &&operator()(T &&t) const noexcept
            {
                return static_cast(t);
            }
            /// \overload
            template
            typename reference_wrapper::reference
            operator()(reference_wrapper t) const noexcept
            {
                return t.get();
            }
            /// \overload
            template
            T &operator()(std::reference_wrapper t) const noexcept
            {
                return t.get();
            }
        };

        /// \ingroup group-utility
        /// \sa `unwrap_reference_fn`
        RANGES_INLINE_VARIABLE(unwrap_reference_fn, unwrap_reference)

        template
        using unwrap_reference_t = decltype(unwrap_reference(std::declval()));

        /// \cond
        namespace detail
        {
            template
            struct protect
            {
            private:
                Bind bind_;
            public:
                protect() = default;
                protect(Bind b)
                  : bind_(std::move(b))
                {}
                template
                auto operator()(Ts &&...ts)
                RANGES_DECLTYPE_AUTO_RETURN
                (
                    bind_(static_cast(ts)...)
                )
                /// \overload
                template
                auto operator()(Ts &&...ts) const
                RANGES_DECLTYPE_AUTO_RETURN
                (
                    bind_(static_cast(ts)...)
                )
            };
        }
        /// \endcond

        struct protect_fn
        {
            template>())>
            detail::protect> operator()(F && f) const
            {
                return {static_cast(f)};
            }
            /// \overload
            template>())>
            F operator()(F && f) const
            {
                return static_cast(f);
            }
        };

        /// Protect a callable so that it can be safely used in a bind expression without
        /// accidentally becoming a "nested" bind.
        /// \ingroup group-utility
        /// \sa `protect_fn`
        RANGES_INLINE_VARIABLE(protect_fn, protect)

        // Accepts initializer_lists as either the first or second parameter, or both,
        // and forwards on to an implementation.
        template
        struct with_braced_init_args
          : ImplFn
        {
        private:
            constexpr ImplFn const & base() const
            {
                return *this;
            }
        public:
            using ImplFn::operator();

            template
            constexpr
            auto operator()(std::initializer_list &&rng0, Args &&...args) const ->
                decltype(std::declval()(std::move(rng0), std::declval()...))
            {
                return base()(std::move(rng0), static_cast(args)...);
            }
            /// \overload
            template
            constexpr
            auto operator()(Rng0 && rng0, std::initializer_list &&rng1, Args &&...args) const ->
                decltype(std::declval()(std::declval(), std::move(rng1), std::declval()...))
            {
                return base()(static_cast(rng0), std::move(rng1), static_cast(args)...);
            }
            /// \overload
            template
            constexpr
            auto operator()(std::initializer_list rng0, std::initializer_list &&rng1, Args &&...args) const ->
                decltype(std::declval()(std::move(rng0), std::move(rng1), std::declval()...))
            {
                return base()(std::move(rng0), std::move(rng1), static_cast(args)...);
            }
        };
        /// @}
    }
}

RANGES_RE_ENABLE_WARNINGS

#endif