File Coverage

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

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

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

/// \defgroup group-utility Utility
/// Utility classes

/// \defgroup group-core Core
/// Core range functionality

/// \defgroup group-algorithms Algorithms
/// Iterator- and range-based algorithms, like the standard algorithms

/// \defgroup group-views Views
/// Lazy, non-owning, non-mutating, composable range views

/// \defgroup group-actions Actions
/// Eager, mutating, composable algorithms

/// \defgroup group-concepts Concepts
/// Concept-checking classes and utilities

RANGES_DIAGNOSTIC_PUSH
RANGES_DIAGNOSTIC_IGNORE_CXX17_COMPAT

namespace ranges
{
    inline namespace v3
    {
        inline namespace CPOs {}

        /// \cond
        namespace _end_
        {
            struct fn;
        }
        using end_fn = _end_::fn;

        namespace _size_
        {
            struct fn;
        }
        /// \endcond

        template
        struct variant;

        template
        struct dangling;

        template
        struct common_type;

        template
        using common_type_t = meta::_t>;

        template
        struct basic_common_reference;

        template
        struct common_reference;

        template
        using common_reference_t = meta::_t>;

        template
        struct result_of;

        template
        using result_of_t = meta::_t>;

        struct make_pipeable_fn;

        template
        struct pipeable;

        template
        struct composed;

        template
        struct overloaded;

        namespace action
        {
            template
            struct action;
        }

        namespace view
        {
            template
            struct view;
        }

        namespace adl_advance_detail
        {
            struct advance_fn;
        }
        using adl_advance_detail::advance_fn;

        struct advance_to_fn;

        struct advance_bounded_fn;

        struct next_fn;

        struct prev_fn;

        struct distance_fn;

        struct iter_size_fn;

        template
        struct difference_type;

        template
        struct value_type;

        template
        struct iterator_category;

        template
        struct size_type;

        struct view_base
        {};

        /// \cond
        namespace detail
        {
            template
            struct any_
            {
                any_() = default;
                any_(T &&)
                {}
            };

            template<>
            struct any_
            {
                any_() = default;
                template
                any_(T &&)
                {}
            };

            using any = any_<>;

            struct value_init
            {
                template
                operator T () const
                {
                    return T{};
                }
            };

            struct make_compressed_pair_fn;

            template
            constexpr T && forward(meta::_t> & t) noexcept
            {
                return static_cast(t);
            }

            template
            constexpr T && 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);
            }

            template
            constexpr meta::_t> &&
            move(T && t) noexcept
            {
                return static_cast> &&>(t);
            }

            template
            constexpr T const &as_const(T & t) noexcept
            {
                return t;
            }
            template
            void as_const(T const &&) = delete;

            template
            using decay_t = meta::_t>;

            template>>
            using as_ref_t =
                meta::_t>>>;

            template>>
            using as_cref_t =
                meta::_t>>>;

            struct get_first;
            struct get_second;

            template
            struct replacer_fn;

            template
            struct replacer_if_fn;

            template
            struct move_into_cursor;

            template
            struct from_end_;

            template
            constexpr int ignore_unused(Ts &&...)
            {
                return 42;
            }

            template
            struct priority_tag
              : priority_tag
            {};

            template<>
            struct priority_tag<0>
            {};

        #if defined(__clang__) && !defined(_LIBCPP_VERSION)
            template
            using is_trivially_constructible =
                meta::bool_<__is_trivially_constructible(T, Args...)>;
            template
            using is_trivially_default_constructible =
                is_trivially_constructible;
            template
            using is_trivially_copy_constructible =
                is_trivially_constructible;
            template
            using is_trivially_move_constructible =
                is_trivially_constructible;
            template
            using is_trivially_assignable =
                meta::bool_<__is_trivially_assignable(T, U)>;
            template
            using is_trivially_copy_assignable =
                is_trivially_assignable;
            template
            using is_trivially_move_assignable =
                is_trivially_assignable;
            template
            using is_trivially_copyable =
                meta::bool_<__is_trivially_copyable(T)>;
        #elif defined(__GNUC__) && !defined(__clang__) && __GNUC__ < 5
            template
            using is_trivially_default_constructible = std::is_trivial;
            template
            using is_trivially_copy_constructible = std::is_trivial;
            template
            using is_trivially_move_constructible = std::is_trivial;
            template
            using is_trivially_copy_assignable = std::is_trivial;
            template
            using is_trivially_move_assignable = std::is_trivial;
            template
            using is_trivially_copyable = std::is_trivial;
        #else
            template
            using is_trivially_default_constructible =
                std::is_trivially_constructible;
            using std::is_trivially_copy_constructible;
            using std::is_trivially_move_constructible;
            using std::is_trivially_copy_assignable;
            using std::is_trivially_move_assignable;
            using std::is_trivially_copyable;
        #endif

        #if RANGES_CXX_LIB_IS_FINAL > 0
        # if defined(__clang__) && !defined(_LIBCPP_VERSION)
            template
            using is_final = meta::bool_<__is_final(T)>;
        # else
            using std::is_final;
        # endif
        #else
            template
            using is_final = std::false_type;
        #endif

            // Work around libc++'s buggy std::is_function
            // Function types here:
            template
            char (&is_function_impl_(priority_tag<0>))[1];

            // Array types here:
            template
            char (&is_function_impl_(priority_tag<1>))[2];

            // Anything that can be returned from a function here (including
            // void and reference types):
            template
            char (&is_function_impl_(priority_tag<2>))[3];

            // Classes and unions (including abstract types) here:
            template
            char (&is_function_impl_(priority_tag<3>))[4];

            template
            struct is_function
              : meta::bool_(priority_tag<3>{})) == 1>
            {};

            template
            struct remove_rvalue_reference
            {
                using type = T;
            };

            template
            struct remove_rvalue_reference
            {
                using type = T;
            };

            template
            using remove_rvalue_reference_t = meta::_t>;

            // Workaround bug in the Standard Library:
            // From cannot be an incomplete class type despite that
            // is_convertible should be equivalent to is_convertible
            // in such a case.
            template
            using is_convertible =
                std::is_convertible>, To>;
        }
        /// \endcond

        namespace concepts
        {
            template
            struct models;
        }

        struct begin_tag {};
        struct end_tag {};
        struct copy_tag {};
        struct move_tag {};

        template
        using uncvref_t =
            meta::_t>>>;

        struct not_equal_to;
        struct equal_to;
        struct less;
        struct ordered_less;
        struct ident;
        template
        struct logical_negate_;
        template
        using logical_negate = logical_negate_>;

        enum cardinality : std::ptrdiff_t
        {
            infinite = -3,
            unknown = -2,
            finite = -1
        };

        template
        struct range_cardinality;

        template
        using is_finite = meta::bool_::value >= finite>;

        template
        using is_infinite = meta::bool_::value == infinite>;

        template
        struct enable_view;

        template
        struct disable_sized_range;

        template
        struct disable_sized_sentinel;

        template
        struct basic_mixin;

        template
        struct RANGES_EMPTY_BASES basic_iterator;

        template
        struct basic_view : view_base
        {};

        template
        struct view_facade;

        template
                 typename BaseRng,
                 cardinality C = range_cardinality::value>
        struct view_adaptor;

        template
        struct common_iterator;

        template
        using common_iterator_t =
            meta::if_, I, common_iterator>;

        template
        struct compressed_pair;

        template
        struct bind_element;

        template
        using bind_element_t = meta::_t>;

        template
        struct view_interface;

        template
        struct istream_range;

    #if !RANGES_CXX_VARIABLE_TEMPLATES
        template
        istream_range istream(std::istream & sin);
    #endif

        template
        struct RANGES_EMPTY_BASES iterator_range;

        template
        struct sized_iterator_range;

        template
        struct reference_wrapper;

        template
        struct is_reference_wrapper;

        // Views
        //
        template
        struct RANGES_EMPTY_BASES adjacent_filter_view;

        namespace view
        {
            struct adjacent_filter_fn;
        }

        template
        struct RANGES_EMPTY_BASES adjacent_remove_if_view;

        namespace view
        {
            struct adjacent_remove_if_fn;
        }

        namespace view
        {
            struct all_fn;
        }

        template
        struct const_view;

        namespace view
        {
            struct const_fn;
        }

        template
        struct counted_view;

        namespace view
        {
            struct counted_fn;
        }

        struct default_sentinel { };

        template
        struct move_iterator;

        template
        using move_into_iterator =
            basic_iterator>;

        template()>
        struct RANGES_EMPTY_BASES cycled_view;

        namespace view
        {
            struct cycle_fn;
        }

        /// \cond
        namespace detail
        {
            template struct reverse_cursor;
        }
        /// \endcond

        template
        using reverse_iterator = basic_iterator>;

        template
        struct empty_view;

        namespace view
        {
            struct empty_fn;
        }

        template
        struct group_by_view;

        namespace view
        {
            struct group_by_fn;
        }

        template
        struct indirect_view;

        namespace view
        {
            struct indirect_fn;
        }

        template
        struct iota_view;

        template
        struct closed_iota_view;

        namespace view
        {
            struct iota_fn;
            struct closed_iota_fn;
        }

        template
        struct join_view;

        namespace view
        {
            struct join_fn;
        }

        template
        struct concat_view;

        namespace view
        {
            struct concat_fn;
        }

        template
        struct partial_sum_view;

        namespace view
        {
            struct partial_sum_fn;
        }

        template
        struct move_view;

        namespace view
        {
            struct move_fn;
        }

        template
        struct repeat_view;

        namespace view
        {
            struct repeat_fn;
        }

        template
        struct RANGES_EMPTY_BASES reverse_view;

        namespace view
        {
            struct reverse_fn;
        }

        template
        struct slice_view;

        namespace view
        {
            struct slice_fn;
        }

        template
        struct split_view;

        namespace view
        {
            struct split_fn;
        }

        template
        struct single_view;

        namespace view
        {
            struct single_fn;
        }

        template
        struct stride_view;

        namespace view
        {
            struct stride_fn;
        }

        template
        struct take_view;

        namespace view
        {
            struct take_fn;
        }

        /// \cond
        namespace detail
        {
            template
            struct is_random_access_bounded_;

            template
                bool IsRandomAccessBounded = is_random_access_bounded_::value>
            struct take_exactly_view_;
        }
        /// \endcond

        template
        using take_exactly_view = detail::take_exactly_view_;

        namespace view
        {
            struct take_exactly_fn;
        }

        template
        struct iter_take_while_view;

        template
        struct take_while_view;

        namespace view
        {
            struct iter_take_while_fn;
            struct take_while_fn;
        }

        template
        struct tokenize_view;

        namespace view
        {
            struct tokenize_fn;
        }

        template
        struct iter_transform_view;

        template
        struct transform_view;

        namespace view
        {
            struct transform_fn;
        }

        template
        using replace_view = iter_transform_view>;

        template
        using replace_if_view = iter_transform_view>;

        namespace view
        {
            struct replace_fn;

            struct replace_if_fn;
        }

        template
        struct unbounded_view;

        namespace view
        {
            struct unbounded_fn;
        }

        template
        using unique_view = adjacent_filter_view>;

        namespace view
        {
            struct unique_fn;
        }

        template
        using keys_range_view = transform_view;

        template
        using values_view = transform_view;

        namespace view
        {
            struct keys_fn;

            struct values_fn;
        }

        template
        struct iter_zip_with_view;

        template
        struct zip_with_view;

        template
        struct zip_view;

        namespace view
        {
            struct iter_zip_with_fn;

            struct zip_with_fn;

            struct zip_fn;
        }
    }
}

RANGES_DIAGNOSTIC_POP

#endif