File Coverage

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

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

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

#include
#include
#include
#include
#include

namespace ranges
{
    inline namespace v3
    {
        /// \addtogroup group-utility
        /// @{

        /// \cond
        namespace detail
        {
            template
            struct semiregular_move_assign
              : optional
            {
                using optional::optional;

                semiregular_move_assign() = default;
                semiregular_move_assign(semiregular_move_assign const &) = default;
                semiregular_move_assign(semiregular_move_assign &&) = default;
                semiregular_move_assign &operator=(semiregular_move_assign const &) = default;
                RANGES_CXX14_CONSTEXPR
                semiregular_move_assign &operator=(semiregular_move_assign &&that)
                    noexcept(std::is_nothrow_move_constructible::value)
                {
                    this->reset();
                    if (that)
                        this->emplace(detail::move(*that));
                    return *this;
                }
            };

            template
            using semiregular_move_layer =
                meta::if_, optional, semiregular_move_assign>;

            template
            struct semiregular_copy_assign
              : semiregular_move_layer
            {
                using semiregular_move_layer::semiregular_move_layer;

                semiregular_copy_assign() = default;
                semiregular_copy_assign(semiregular_copy_assign const &) = default;
                semiregular_copy_assign(semiregular_copy_assign &&) = default;
                RANGES_CXX14_CONSTEXPR
                semiregular_copy_assign &operator=(semiregular_copy_assign const &that)
                    noexcept(std::is_nothrow_copy_constructible::value)
                {
                    this->reset();
                    if (that)
                        this->emplace(*that);
                    return *this;
                }
                semiregular_copy_assign &operator=(semiregular_copy_assign &&) = default;
            };

            template
            using semiregular_copy_layer =
                meta::if_, optional, semiregular_copy_assign>;
        } // namespace detail
        /// \endcond

        template
        struct semiregular
          : detail::semiregular_copy_layer
        {
            using detail::semiregular_copy_layer::semiregular_copy_layer;

            constexpr semiregular()
                noexcept(std::is_nothrow_default_constructible::value ||
                    !std::is_default_constructible::value)
              : semiregular(tag{}, std::is_default_constructible{})
            {}
            RANGES_CXX14_CONSTEXPR T &get() & noexcept
            {
                return **this;
            }
            constexpr T const &get() const & noexcept
            {
                return **this;
            }
            RANGES_CXX14_CONSTEXPR T &&get() && noexcept
            {
                return *detail::move(*this);
            }
            constexpr T const &&get() const && noexcept
            {
                return *detail::move(*this);
            }
            RANGES_CXX14_CONSTEXPR operator T &() & noexcept
            {
                return **this;
            }
            constexpr operator T const &() const & noexcept
            {
                return **this;
            }
            RANGES_CXX14_CONSTEXPR operator T &&() && noexcept
            {
                return *detail::move(*this);
            }
            constexpr operator T const &&() const && noexcept
            {
                return *detail::move(*this);
            }
            template
            RANGES_CXX14_CONSTEXPR auto operator()(Args &&...args) &
            RANGES_DECLTYPE_NOEXCEPT(std::declval()(static_cast(args)...))
            {
                return (**this)(static_cast(args)...);
            }
            template
            constexpr auto operator()(Args &&...args) const &
            RANGES_DECLTYPE_NOEXCEPT(std::declval()(static_cast(args)...))
            {
                return (**this)(static_cast(args)...);
            }
            template
            RANGES_CXX14_CONSTEXPR auto operator()(Args &&...args) &&
            RANGES_DECLTYPE_NOEXCEPT(std::declval()(static_cast(args)...))
            {
                return (*detail::move(*this))(static_cast(args)...);
            }
            template
            constexpr auto operator()(Args &&...args) const &&
            RANGES_DECLTYPE_NOEXCEPT(std::declval()(static_cast(args)...))
            {
                return (*detail::move(*this))(static_cast(args)...);
            }
        private:
            struct tag {};
            constexpr semiregular(tag, std::false_type) noexcept
            {}
            constexpr semiregular(tag, std::true_type)
                noexcept(std::is_nothrow_default_constructible::value)
              : detail::semiregular_copy_layer{in_place}
            {}
        };

        template
        struct semiregular
          : private ranges::reference_wrapper
        {
            semiregular() = default;
            template
                CONCEPT_REQUIRES_(Constructible, Arg &>())>
            semiregular(in_place_t, Arg &arg)
              : ranges::reference_wrapper(arg)
            {}
            using ranges::reference_wrapper::reference_wrapper;
            using ranges::reference_wrapper::get;
            using ranges::reference_wrapper::operator T &;
            using ranges::reference_wrapper::operator();
        };

        template
        struct semiregular
          : private ranges::reference_wrapper
        {
            semiregular() = default;
            template
                CONCEPT_REQUIRES_(Constructible, Arg>())>
            semiregular(in_place_t, Arg &&arg)
              : ranges::reference_wrapper(static_cast(arg))
            {}
            using ranges::reference_wrapper::reference_wrapper;
            using ranges::reference_wrapper::get;
            using ranges::reference_wrapper::operator T &&;
            using ranges::reference_wrapper::operator();
        };

        template
        using semiregular_t =
            meta::if_, T, semiregular>;

        template
        using movesemiregular_t =
            meta::if_c<
                Movable() && DefaultConstructible(),
                T,
                semiregular>;

        template
        using semiregular_ref_or_val_t =
            meta::if_<
                SemiRegular,
                meta::if_c>,
                reference_wrapper const, semiregular>>>;

        template
        auto get(meta::id_t> &t)
        RANGES_DECLTYPE_AUTO_RETURN_NOEXCEPT
        (
            t.get()
        )

        template
        auto get(meta::id_t> const &t)
        RANGES_DECLTYPE_AUTO_RETURN_NOEXCEPT
        (
            t.get()
        )

        template
        auto get(meta::id_t> &&t)
        RANGES_DECLTYPE_AUTO_RETURN_NOEXCEPT
        (
            detail::move(t).get()
        )
        /// @}
    }
}

#endif