File Coverage

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

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

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

RANGES_DIAGNOSTIC_PUSH
RANGES_DIAGNOSTIC_IGNORE_CXX17_COMPAT

namespace ranges
{
    inline namespace v3
    {
        /// \addtogroup group-utility
        /// @{
        template
        struct is_reference_wrapper
          : meta::if_<
                std::is_same, T>,
                std::false_type,
                is_reference_wrapper>>
        {};

        template
        struct is_reference_wrapper>
          : std::true_type
        {};

        template
        struct is_reference_wrapper>
          : std::true_type
        {};

        template
        using is_reference_wrapper_t = meta::_t>;

        struct invoke_fn
        {
        private:
            template
            static constexpr auto invoke_member_fn(
                std::true_type, detail::any, MemberFunctionPtr fn, First && first, Rest &&... rest)
            RANGES_DECLTYPE_AUTO_RETURN_NOEXCEPT
            (
                (static_cast(first).*fn)(static_cast(rest)...)
            )
            template
            static constexpr auto invoke_member_fn(
                std::false_type, std::true_type, MemberFunctionPtr fn, First && first, Rest &&... rest)
            RANGES_DECLTYPE_AUTO_RETURN_NOEXCEPT
            (
                (static_cast(first).get().*fn)(static_cast(rest)...)
            )
            template
            static constexpr auto invoke_member_fn(
                std::false_type, std::false_type, MemberFunctionPtr fn, First && first, Rest &&... rest)
            RANGES_DECLTYPE_AUTO_RETURN_NOEXCEPT
            (
                ((*static_cast(first)).*fn)(static_cast(rest)...)
            )

            template
            static constexpr auto invoke_member_data(
                std::true_type, detail::any, MemberDataPtr ptr, First && first)
            RANGES_DECLTYPE_AUTO_RETURN_NOEXCEPT
            (
                static_cast(first).*ptr
            )
            template
            static constexpr auto invoke_member_data(
                std::false_type, std::true_type, MemberDataPtr ptr, First && first)
            RANGES_DECLTYPE_AUTO_RETURN_NOEXCEPT
            (
                static_cast(first).get().*ptr
            )
            template
            static constexpr auto invoke_member_data(
                std::false_type, std::false_type, MemberDataPtr ptr, First && first)
            RANGES_DECLTYPE_AUTO_RETURN_NOEXCEPT
            (
                (*static_cast(first)).*ptr
            )
        public:
            template
                meta::if_c::value, int> = 0>
            constexpr auto operator()(F Obj::*ptr, First && first, Rest &&... rest) const
            RANGES_DECLTYPE_AUTO_RETURN_NOEXCEPT
            (
                invoke_member_fn(std::is_base_of>{},
                    is_reference_wrapper_t>{},
                    ptr, static_cast(first), static_cast(rest)...)
            )
            template
                meta::if_c::value, int> = 0>
            constexpr auto operator()(Data Obj::*ptr, First && first) const
            RANGES_DECLTYPE_AUTO_RETURN_NOEXCEPT
            (
                invoke_member_data(std::is_base_of>{},
                    is_reference_wrapper_t>{},
                    ptr, static_cast(first))
            )
            template
                meta::if_c>::value, int> = 0>
            constexpr auto operator()(F && fn, Args &&... args) const
            RANGES_DECLTYPE_AUTO_RETURN_NOEXCEPT
            (
                static_cast(fn)(static_cast(args)...)
            )
        };
        RANGES_INLINE_VARIABLE(invoke_fn, invoke)

        /// \cond
        namespace detail
        {
            template
            struct reference_wrapper_
            {
                T *t_ = nullptr;
                constexpr reference_wrapper_() = default;
                constexpr reference_wrapper_(T &t) noexcept
                  : t_(std::addressof(t))
                {}
                constexpr reference_wrapper_(T &&) = delete;
                constexpr T &get() const noexcept
                {
                    return *t_;
                }
            };
            template
            struct reference_wrapper_ : reference_wrapper_
            {
                using reference_wrapper_::reference_wrapper_;
            };
            template
            struct reference_wrapper_
            {
                T *t_ = nullptr;
                constexpr reference_wrapper_() = default;
                constexpr reference_wrapper_(T &&t) noexcept
                  : t_(std::addressof(t))
                {}
                constexpr T &&get() const noexcept
                {
                    return static_cast(*t_);
                }
            };
        }
        /// \endcond

        // Can be used to store rvalue references in addition to lvalue references.
        // Also, see: https://wg21.link/lwg2993
        template
        struct reference_wrapper : private detail::reference_wrapper_
        {
        private:
            using base_ = detail::reference_wrapper_;
        public:
            using type = meta::_t>;
            using reference = meta::if_, T, T &>;

            constexpr reference_wrapper() = default;
            template
                CONCEPT_REQUIRES_(Constructible() &&
                    !Same, reference_wrapper>())>
            constexpr reference_wrapper(U &&u)
                noexcept(std::is_nothrow_constructible::value)
              : detail::reference_wrapper_{static_cast(u)}
            {}
            constexpr reference get() const noexcept
            {
                return this->base_::get();
            }
            constexpr operator reference() const noexcept
            {
                return get();
            }
            CONCEPT_REQUIRES(!std::is_rvalue_reference::value)
            operator std::reference_wrapper () const noexcept
            {
                return {get()};
            }
            template
            constexpr auto operator()(Args &&...args) const
            RANGES_DECLTYPE_NOEXCEPT(
                invoke(std::declval(), std::declval()...))
            {
                return invoke(get(), static_cast(args)...);
            }
        };

#ifdef RANGES_WORKAROUND_MSVC_701385
        /// \cond
        namespace detail
        {
            template
            struct _invoke_result_
            {};

            template
            struct _invoke_result_<
                meta::void_(), std::declval()...))>,
                Fun, Args...>
            {
                using type = decltype(invoke(std::declval(), std::declval()...));
            };
        }
        /// \endcond

        template
        using invoke_result = detail::_invoke_result_;

        template
        using invoke_result_t = meta::_t>;
#else // RANGES_WORKAROUND_MSVC_701385
        template
        using invoke_result_t =
            decltype(invoke(std::declval(), std::declval()...));

        template
        struct invoke_result
          : meta::defer
        {};
#endif // RANGES_WORKAROUND_MSVC_701385

        template
        struct result_of
        {};

        template
        struct result_of
          : meta::defer
        {};
    } // namespace v3
} // namespace ranges

RANGES_DIAGNOSTIC_POP

#endif // RANGES_V3_UTILITY_INVOKE_HPP