File Coverage

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

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

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

namespace ranges
{
    inline namespace v3
    {
        /// \cond
        namespace compressed_tuple_detail
        {
            // tagging individual elements with the complete type list disambiguates
            // base classes when composing compressed_tuples recursively.
            template
            using storage = box, Ts...>>;

            template struct compressed_tuple_;
            template
            struct RANGES_EMPTY_BASES compressed_tuple_, meta::index_sequence>
              : storage...
            {
                static_assert(Same,
                    meta::make_index_sequence>(), "What madness is this?!?");

                compressed_tuple_() = default;

                template
                    meta::if_...>, int> = 0>
                constexpr compressed_tuple_(Args &&... args)
                    noexcept(meta::strict_and, Args>...>::value)
                  : storage{static_cast(args)}...
                {}

                template
                    meta::if_...>, int> = 0>
                constexpr operator std::tuple () const
                    noexcept(meta::strict_and...>::value)
                {
                    return std::tuple{get(*this)...};
                }
            };

            template
            using compressed_tuple =
                compressed_tuple_, meta::make_index_sequence>;

            template, I>>
            RANGES_CXX14_CONSTEXPR T &
            get(compressed_tuple_, meta::index_sequence> &tuple) noexcept
            {
                return static_cast &>(tuple).get();
            }
            template, I>>
            constexpr T const &
            get(compressed_tuple_, meta::index_sequence> const &tuple) noexcept
            {
                return static_cast const &>(tuple).get();
            }
            template, I>>
            RANGES_CXX14_CONSTEXPR T &&
            get(compressed_tuple_, meta::index_sequence> &&tuple) noexcept
            {
                return static_cast &&>(tuple).get();
            }
            template, I>>
            RANGES_CXX14_CONSTEXPR T const &&
            get(compressed_tuple_, meta::index_sequence> const &&tuple) noexcept
            {
                return static_cast const &&>(tuple).get();
            }
        }
        /// \endcond

        using compressed_tuple_detail::compressed_tuple;
        using compressed_tuple_detail::get;

        struct make_compressed_tuple_fn
        {
            template
            constexpr auto operator()(Args &&... args) const
            RANGES_DECLTYPE_AUTO_RETURN_NOEXCEPT(
                compressed_tuple...>{static_cast(args)...}
            )
        };

        /// \ingroup group-utility
        /// \sa `make_compressed_tuple_fn`
        RANGES_INLINE_VARIABLE(make_compressed_tuple_fn, make_compressed_tuple)

        template
        using tagged_compressed_tuple =
            tagged...>, detail::tag_spec...>;

        RANGES_DEFINE_TAG_SPECIFIER(first)
        RANGES_DEFINE_TAG_SPECIFIER(second)

        template
        struct compressed_pair
            : tagged_compressed_tuple
        {
            using base_t = tagged_compressed_tuple;
            using first_type = First;
            using second_type = Second;

            using base_t::first;
            using base_t::second;

            compressed_pair() = default;
            using base_t::base_t;

            template
                meta::if_,
                                           std::is_constructible>, int> = 0>
            constexpr operator std::pair () const
                noexcept(std::is_nothrow_constructible::value &&
                    std::is_nothrow_constructible::value)
            {
                return std::pair{first(), second()};
            }
        };

        struct make_compressed_pair_fn
        {
            template
            constexpr auto operator()(First && f, Second && s) const
            RANGES_DECLTYPE_AUTO_RETURN_NOEXCEPT(
                compressed_pair, bind_element_t>{
                    static_cast(f), static_cast(s)
                }
            )
        };

        /// \ingroup group-utility
        /// \sa `make_compressed_pair_fn`
        RANGES_INLINE_VARIABLE(make_compressed_pair_fn, make_compressed_pair)
    }
}

RANGES_DIAGNOSTIC_PUSH
RANGES_DIAGNOSTIC_IGNORE_MISMATCHED_TAGS
namespace std
{
    template
    struct tuple_size< ::ranges::v3::compressed_tuple_detail::compressed_tuple_<::meta::list, ::meta::index_sequence>>
      : integral_constant
    {};

    template
    struct tuple_element, ::meta::index_sequence>>
    {
        using type = ::meta::at_c<::meta::list, I>;
    };

    template
    struct tuple_size< ::ranges::v3::compressed_pair>
      : integral_constant
    {};

    template
    struct tuple_element<0, ::ranges::v3::compressed_pair>
    {
        using type = First;
    };

    template
    struct tuple_element<1, ::ranges::v3::compressed_pair>
    {
        using type = Second;
    };
}
RANGES_DIAGNOSTIC_POP

#endif