EIC code displayed by LXR master/​include/​range/​v3/​range_fwd.hpp	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2024-11-15 09:54:58

 /// \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 <type_traits>
 #include <utility>
 
 #include <meta/meta.hpp>
 
 #include <concepts/concepts.hpp>
 #include <concepts/compare.hpp>
 
 #include <range/v3/detail/config.hpp>
 #include <range/v3/utility/static_const.hpp>
 #include <range/v3/version.hpp>
 
 /// \defgroup group-iterator Iterator
 /// Iterator functionality
 
 /// \defgroup group-iterator-concepts Iterator Concepts
 /// \ingroup group-iterator
 /// Iterator concepts
 
 /// \defgroup group-range Range
 /// Core range functionality
 
 /// \defgroup group-range-concepts Range Concepts
 /// \ingroup group-range
 /// Range concepts
 
 /// \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-utility Utility
 /// Utility classes
 
 /// \defgroup group-functional Functional
 /// Function and function object utilities
 
 /// \defgroup group-numerics Numerics
 /// Numeric utilities
 
 #include <range/v3/detail/prologue.hpp>
 
 RANGES_DIAGNOSTIC_PUSH
 RANGES_DIAGNOSTIC_IGNORE_CXX17_COMPAT
 
 namespace ranges
 {
     /// \cond
     namespace views
     {
     }
 
     namespace actions
     {
     }
 
 // GCC either fails to accept an attribute on a namespace, or else
 // it ignores the deprecation attribute. Frustrating.
 #if(RANGES_CXX_VER < RANGES_CXX_STD_17 || defined(__GNUC__) && !defined(__clang__))
     inline namespace v3
     {
         using namespace ranges;
     }
 
     namespace view = views;
     namespace action = actions;
 #else
     inline namespace RANGES_DEPRECATED(
         "The name ranges::v3 namespace is deprecated. "
         "Please discontinue using it.") v3
     {
         using namespace ranges;
     }
 
     namespace RANGES_DEPRECATED(
         "The ranges::view namespace has been renamed to ranges::views. "
         "(Sorry!)") view
     {
         using namespace views;
     }
 
     namespace RANGES_DEPRECATED(
         "The ranges::action namespace has been renamed to ranges::actions. "
         "(Sorry!)") action
     {
         using namespace actions;
     }
 #endif
 
     namespace _end_
     {
         struct fn;
     }
     using end_fn = _end_::fn;
 
     namespace _size_
     {
         struct fn;
     }
 
     template<typename>
     struct result_of;
 
     template<typename Sig>
     using result_of_t RANGES_DEPRECATED(
         "ranges::result_of_t is deprecated. "
         "Please use ranges::invoke_result_t") = meta::_t<result_of<Sig>>;
     /// \endcond
 
     template<typename...>
     struct variant;
 
     struct dangling;
 
     struct make_pipeable_fn;
 
     struct pipeable_base;
 
     template<typename First, typename Second>
     struct composed;
 
     template<typename... Fns>
     struct overloaded;
 
     namespace actions
     {
         template<typename ActionFn>
         struct action_closure;
     }
 
     namespace views
     {
         template<typename ViewFn>
         struct view_closure;
     }
 
     struct advance_fn;
 
     struct advance_to_fn;
 
     struct advance_bounded_fn;
 
     struct next_fn;
 
     struct prev_fn;
 
     struct distance_fn;
 
     struct iter_size_fn;
 
     template<typename T>
     struct indirectly_readable_traits;
 
     template<typename T>
     using readable_traits RANGES_DEPRECATED("Please use ranges::indirectly_readable_traits")
      = indirectly_readable_traits<T>;
 
     template<typename T>
     struct incrementable_traits;
 
     struct view_base
     {};
 
     /// \cond
     namespace detail
     {
         template<typename T>
         struct difference_type_;
 
         template<typename T>
         struct value_type_;
     } // namespace detail
 
     template<typename T>
     using difference_type RANGES_DEPRECATED(
         "ranges::difference_type<T>::type is deprecated. Use "
         "ranges::incrementable_traits<T>::difference_type instead.") =
         detail::difference_type_<T>;
 
     template<typename T>
     using value_type RANGES_DEPRECATED(
         "ranges::value_type<T>::type is deprecated. Use "
         "ranges::indirectly_readable_traits<T>::value_type instead.") = detail::value_type_<T>;
 
     template<typename T>
     struct size_type;
     /// \endcond
 
     /// \cond
     namespace detail
     {
         struct ignore_t
         {
             ignore_t() = default;
             template<typename T>
             constexpr ignore_t(T &&) noexcept
             {}
             template<typename T>
             constexpr ignore_t const & operator=(T &&) const noexcept
             {
                 return *this;
             }
         };
 
         struct value_init
         {
             template<typename T>
             operator T() const
             {
                 return T{};
             }
         };
 
         struct make_compressed_pair_fn;
 
         template<typename T>
         constexpr meta::_t<std::remove_reference<T>> && move(T && t) noexcept
         {
             return static_cast<meta::_t<std::remove_reference<T>> &&>(t);
         }
 
         struct as_const_fn
         {
             template<typename T>
             constexpr T const & operator()(T & t) const noexcept
             {
                 return t;
             }
             template<typename T>
             constexpr T const && operator()(T && t) const noexcept
             {
                 return (T &&) t;
             }
         };
 
         RANGES_INLINE_VARIABLE(as_const_fn, as_const)
 
         template<typename T>
         using as_const_t = decltype(as_const(std::declval<T>()));
 
         template<typename T>
         using decay_t = meta::_t<std::decay<T>>;
 
         template<typename T, typename R = meta::_t<std::remove_reference<T>>>
         using as_ref_t =
             meta::_t<std::add_lvalue_reference<meta::_t<std::remove_const<R>>>>;
 
         template<typename T, typename R = meta::_t<std::remove_reference<T>>>
         using as_cref_t = meta::_t<std::add_lvalue_reference<R const>>;
 
         struct get_first;
         struct get_second;
 
         template<typename Val1, typename Val2>
         struct replacer_fn;
 
         template<typename Pred, typename Val>
         struct replacer_if_fn;
 
         template<typename I>
         struct move_into_cursor;
 
         template<typename Int>
         struct from_end_;
 
         template<typename... Ts>
         constexpr int ignore_unused(Ts &&...)
         {
             return 42;
         }
 
         template<int I>
         struct priority_tag : priority_tag<I - 1>
         {};
 
         template<>
         struct priority_tag<0>
         {};
 
 #if defined(__clang__) && !defined(_LIBCPP_VERSION)
         template<typename T, typename... Args>
         RANGES_INLINE_VAR constexpr bool is_trivially_constructible_v =
             __is_trivially_constructible(T, Args...);
         template<typename T>
         RANGES_INLINE_VAR constexpr bool is_trivially_default_constructible_v =
             is_trivially_constructible_v<T>;
         template<typename T>
         RANGES_INLINE_VAR constexpr bool is_trivially_copy_constructible_v =
             is_trivially_constructible_v<T, T const &>;
         template<typename T>
         RANGES_INLINE_VAR constexpr bool is_trivially_move_constructible_v =
             is_trivially_constructible_v<T, T>;
         template<typename T>
         RANGES_INLINE_VAR constexpr bool is_trivially_copyable_v =
             __is_trivially_copyable(T);
         template<typename T, typename U>
         RANGES_INLINE_VAR constexpr bool is_trivially_assignable_v =
             __is_trivially_assignable(T, U);
         template<typename T>
         RANGES_INLINE_VAR constexpr bool is_trivially_copy_assignable_v =
             is_trivially_assignable_v<T &, T const &>;
         template<typename T>
         RANGES_INLINE_VAR constexpr bool is_trivially_move_assignable_v =
             is_trivially_assignable_v<T &, T>;
 
         template<typename T, typename... Args>
         struct is_trivially_constructible
           : meta::bool_<is_trivially_constructible_v<T, Args...>>
         {};
         template<typename T>
         struct is_trivially_default_constructible
           : meta::bool_<is_trivially_default_constructible_v<T>>
         {};
         template<typename T>
         struct is_trivially_copy_constructible
           : meta::bool_<is_trivially_copy_constructible_v<T>>
         {};
         template<typename T>
         struct is_trivially_move_constructible
           : meta::bool_<is_trivially_move_constructible_v<T>>
         {};
         template<typename T>
         struct is_trivially_copyable
           : meta::bool_<is_trivially_copyable_v<T>>
         {};
         template<typename T, typename U>
         struct is_trivially_assignable
           : meta::bool_<is_trivially_assignable_v<T, U>>
         {};
         template<typename T>
         struct is_trivially_copy_assignable
           : meta::bool_<is_trivially_copy_assignable_v<T>>
         {};
         template<typename T>
         struct is_trivially_move_assignable
           : meta::bool_<is_trivially_move_assignable_v<T>>
         {};
 #else
         using std::is_trivially_constructible;
         using std::is_trivially_default_constructible;
         using std::is_trivially_copy_assignable;
         using std::is_trivially_copy_constructible;
         using std::is_trivially_copyable;
         using std::is_trivially_assignable;
         using std::is_trivially_move_assignable;
         using std::is_trivially_move_constructible;
 #if META_CXX_TRAIT_VARIABLE_TEMPLATES
         using std::is_trivially_constructible_v;
         using std::is_trivially_default_constructible_v;
         using std::is_trivially_copy_assignable_v;
         using std::is_trivially_copy_constructible_v;
         using std::is_trivially_copyable_v;
         using std::is_trivially_assignable_v;
         using std::is_trivially_move_assignable_v;
         using std::is_trivially_move_constructible_v;
 #else
         template<typename T, typename... Args>
         RANGES_INLINE_VAR constexpr bool is_trivially_constructible_v =
             is_trivially_constructible<T, Args...>::value;
         template<typename T>
         RANGES_INLINE_VAR constexpr bool is_trivially_default_constructible_v =
             is_trivially_default_constructible<T>::value;
         template<typename T>
         RANGES_INLINE_VAR constexpr bool is_trivially_copy_constructible_v =
             is_trivially_copy_constructible<T>::value;
         template<typename T>
         RANGES_INLINE_VAR constexpr bool is_trivially_move_constructible_v =
             is_trivially_move_constructible<T>::value;
         template<typename T>
         RANGES_INLINE_VAR constexpr bool is_trivially_copyable_v =
             is_trivially_copyable<T>::value;
         template<typename T, typename U>
         RANGES_INLINE_VAR constexpr bool is_trivially_assignable_v =
             is_trivially_assignable<T, U>::value;
         template<typename T>
         RANGES_INLINE_VAR constexpr bool is_trivially_copy_assignable_v =
             is_trivially_copy_assignable<T>::value;
         template<typename T>
         RANGES_INLINE_VAR constexpr bool is_trivially_move_assignable_v =
             is_trivially_move_assignable<T>::value;
 #endif
 #endif
 
         template<typename T>
         RANGES_INLINE_VAR constexpr bool is_trivial_v =
             is_trivially_copyable_v<T> &&
             is_trivially_default_constructible_v<T>;
 
         template<typename T>
         struct is_trivial
           : meta::bool_<is_trivial_v<T>>
         {};
 
 #if RANGES_CXX_LIB_IS_FINAL > 0
 #if defined(__clang__) && !defined(_LIBCPP_VERSION)
         template<typename T>
         RANGES_INLINE_VAR constexpr bool is_final_v = __is_final(T);
 
         template<typename T>
         struct is_final
           : meta::bool_<is_final_v<T>>
         {};
 #else
         using std::is_final;
 #if META_CXX_TRAIT_VARIABLE_TEMPLATES
         using std::is_final_v;
 #else
         template<typename T>
         RANGES_INLINE_VAR constexpr bool is_final_v = is_final<T>::value;
 #endif
 #endif
 #else
         template<typename T>
         RANGES_INLINE_VAR constexpr bool is_final_v = false;
 
         template<typename T>
         using is_final = std::false_type;
 #endif
 
         // Work around libc++'s buggy std::is_function
         // Function types here:
         template<typename T>
         char (&is_function_impl_(priority_tag<0>))[1];
 
         // Array types here:
         template<typename T, typename = decltype((*(T *)0)[0])>
         char (&is_function_impl_(priority_tag<1>))[2];
 
         // Anything that can be returned from a function here (including
         // void and reference types):
         template<typename T, typename = T (*)()>
         char (&is_function_impl_(priority_tag<2>))[3];
 
         // Classes and unions (including abstract types) here:
         template<typename T, typename = int T::*>
         char (&is_function_impl_(priority_tag<3>))[4];
 
         template<typename T>
         RANGES_INLINE_VAR constexpr bool is_function_v =
             sizeof(detail::is_function_impl_<T>(priority_tag<3>{})) == 1;
 
         template<typename T>
         struct remove_rvalue_reference
         {
             using type = T;
         };
 
         template<typename T>
         struct remove_rvalue_reference<T &&>
         {
             using type = T;
         };
 
         template<typename T>
         using remove_rvalue_reference_t = meta::_t<remove_rvalue_reference<T>>;
 
         // Workaround bug in the Standard Library:
         // From cannot be an incomplete class type despite that
         // is_convertible<X, Y> should be equivalent to is_convertible<X&&, Y>
         // in such a case.
         template<typename From, typename To>
         using is_convertible =
             std::is_convertible<meta::_t<std::add_rvalue_reference<From>>, To>;
     } // namespace detail
     /// \endcond
 
     struct begin_tag
     {};
     struct end_tag
     {};
     struct copy_tag
     {};
     struct move_tag
     {};
 
     template<typename T>
     using uncvref_t = meta::_t<std::remove_cv<meta::_t<std::remove_reference<T>>>>;
 
     struct not_equal_to;
     struct equal_to;
     struct less;
 #if __cplusplus > 201703L && __has_include(<compare>) && \
     defined(__cpp_concepts) && defined(__cpp_impl_three_way_comparison)
     struct compare_three_way;
 #endif // __cplusplus
     struct identity;
     template<typename Pred>
     struct logical_negate;
 
     enum cardinality : std::ptrdiff_t
     {
         infinite = -3,
         unknown = -2,
         finite = -1
     };
 
     template<typename Rng, typename Void = void>
     struct range_cardinality;
 
     template<typename Rng>
     using is_finite = meta::bool_<range_cardinality<Rng>::value >= finite>;
 
     template<typename Rng>
     using is_infinite = meta::bool_<range_cardinality<Rng>::value == infinite>;
 
     template<typename S, typename I>
     RANGES_INLINE_VAR constexpr bool disable_sized_sentinel = false;
 
     template<typename R>
     RANGES_INLINE_VAR constexpr bool enable_borrowed_range = false;
 
     namespace detail
     {
         template<typename R>
         RANGES_DEPRECATED("Please use ranges::enable_borrowed_range instead.")
         RANGES_INLINE_VAR constexpr bool enable_safe_range = enable_borrowed_range<R>;
     } // namespace detail
 
     using detail::enable_safe_range;
 
     template<typename Cur>
     struct basic_mixin;
 
     template<typename Cur>
     struct RANGES_EMPTY_BASES basic_iterator;
 
     template<cardinality>
     struct basic_view : view_base
     {};
 
     template<typename Derived, cardinality C = finite>
     struct view_facade;
 
     template<typename Derived, typename BaseRng,
              cardinality C = range_cardinality<BaseRng>::value>
     struct view_adaptor;
 
     template<typename I, typename S>
     struct common_iterator;
 
     /// \cond
     namespace detail
     {
         template<typename I>
         struct cpp17_iterator_cursor;
 
         template<typename I>
         using cpp17_iterator = basic_iterator<cpp17_iterator_cursor<I>>;
     } // namespace detail
     /// \endcond
 
     template<typename First, typename Second>
     struct compressed_pair;
 
     template<typename T>
     struct bind_element;
 
     template<typename T>
     using bind_element_t = meta::_t<bind_element<T>>;
 
     template<typename Derived, cardinality = finite>
     struct view_interface;
 
     template<typename T>
     struct istream_view;
 
     template<typename I, typename S = I>
     struct RANGES_EMPTY_BASES iterator_range;
 
     template<typename I, typename S = I>
     struct sized_iterator_range;
 
     template<typename T>
     struct reference_wrapper;
 
     // Views
     //
     template<typename Rng, typename Pred>
     struct RANGES_EMPTY_BASES adjacent_filter_view;
 
     namespace views
     {
         struct adjacent_filter_fn;
     }
 
     template<typename Rng, typename Pred>
     struct RANGES_EMPTY_BASES adjacent_remove_if_view;
 
     namespace views
     {
         struct adjacent_remove_if_fn;
     }
 
     namespace views
     {
         struct all_fn;
     }
 
 
     template<typename Rng, typename Fun>
     struct chunk_by_view;
 
     namespace views
     {
         struct chunk_by_fn;
     }
 
     template<typename Rng>
     struct const_view;
 
     namespace views
     {
         struct const_fn;
     }
 
     template<typename I>
     struct counted_view;
 
     namespace views
     {
         struct counted_fn;
     }
 
     struct default_sentinel_t;
 
     template<typename I>
     struct move_iterator;
 
     template<typename I>
     using move_into_iterator = basic_iterator<detail::move_into_cursor<I>>;
 
     template<typename Rng, bool = (bool)is_infinite<Rng>()>
     struct RANGES_EMPTY_BASES cycled_view;
 
     namespace views
     {
         struct cycle_fn;
     }
 
     /// \cond
     namespace detail
     {
         template<typename I>
         struct reverse_cursor;
     }
     /// \endcond
 
     template<typename I>
     using reverse_iterator = basic_iterator<detail::reverse_cursor<I>>;
 
     template<typename T>
     struct empty_view;
 
     namespace views
     {
         struct empty_fn;
     }
 
     template<typename Rng, typename Fun>
     struct group_by_view;
 
     namespace views
     {
         struct group_by_fn;
     }
 
     template<typename Rng>
     struct indirect_view;
 
     namespace views
     {
         struct indirect_fn;
     }
 
     struct unreachable_sentinel_t;
 
     template<typename From, typename To = unreachable_sentinel_t>
     struct iota_view;
 
     template<typename From, typename To = From>
     struct closed_iota_view;
 
     namespace views
     {
         struct iota_fn;
         struct closed_iota_fn;
     } // namespace views
 
     template<typename Rng>
     struct join_view;
 
     template<typename Rng, typename ValRng>
     struct join_with_view;
 
     namespace views
     {
         struct join_fn;
     }
 
     template<typename... Rngs>
     struct concat_view;
 
     namespace views
     {
         struct concat_fn;
     }
 
     template<typename Rng, typename Fun>
     struct partial_sum_view;
 
     namespace views
     {
         struct partial_sum_fn;
     }
 
     template<typename Rng>
     struct move_view;
 
     namespace views
     {
         struct move_fn;
     }
 
     template<typename Rng>
     struct ref_view;
 
     namespace views
     {
         struct ref_fn;
     }
 
     template<typename Val>
     struct repeat_view;
 
     namespace views
     {
         struct repeat_fn;
     }
 
     template<typename Rng>
     struct RANGES_EMPTY_BASES reverse_view;
 
     namespace views
     {
         struct reverse_fn;
     }
 
     template<typename Rng>
     struct slice_view;
 
     namespace views
     {
         struct slice_fn;
     }
 
     // template<typename Rng, typename Fun>
     // struct split_view;
 
     // namespace views
     // {
     //     struct split_fn;
     // }
 
     template<typename Rng>
     struct single_view;
 
     namespace views
     {
         struct single_fn;
     }
 
     template<typename Rng>
     struct stride_view;
 
     namespace views
     {
         struct stride_fn;
     }
 
     template<typename Rng>
     struct take_view;
 
     namespace views
     {
         struct take_fn;
     }
 
     /// \cond
     namespace detail
     {
         template<typename Rng>
         struct is_random_access_common_;
 
         template<typename Rng,
                  bool IsRandomAccessCommon = is_random_access_common_<Rng>::value>
         struct take_exactly_view_;
     } // namespace detail
     /// \endcond
 
     template<typename Rng>
     using take_exactly_view = detail::take_exactly_view_<Rng>;
 
     namespace views
     {
         struct take_exactly_fn;
     }
 
     template<typename Rng, typename Pred>
     struct iter_take_while_view;
 
     template<typename Rng, typename Pred>
     struct take_while_view;
 
     namespace views
     {
         struct iter_take_while_fn;
         struct take_while_fn;
     } // namespace views
 
     template<typename Rng, typename Regex, typename SubMatchRange>
     struct tokenize_view;
 
     namespace views
     {
         struct tokenize_fn;
     }
 
     template<typename Rng, typename Fun>
     struct iter_transform_view;
 
     template<typename Rng, typename Fun>
     struct transform_view;
 
     namespace views
     {
         struct transform_fn;
     }
 
     template<typename Rng, typename Val1, typename Val2>
     using replace_view = iter_transform_view<Rng, detail::replacer_fn<Val1, Val2>>;
 
     template<typename Rng, typename Pred, typename Val>
     using replace_if_view = iter_transform_view<Rng, detail::replacer_if_fn<Pred, Val>>;
 
     namespace views
     {
         struct replace_fn;
 
         struct replace_if_fn;
     } // namespace views
 
     template<typename Rng, typename Pred>
     struct trim_view;
 
     namespace views
     {
         struct trim_fn;
     }
 
     template<typename I>
     struct unbounded_view;
 
     namespace views
     {
         struct unbounded_fn;
     }
 
     template<typename Rng>
     using unique_view = adjacent_filter_view<Rng, logical_negate<equal_to>>;
 
     namespace views
     {
         struct unique_fn;
     }
 
     template<typename Rng>
     using keys_range_view = transform_view<Rng, detail::get_first>;
 
     template<typename Rng>
     using values_view = transform_view<Rng, detail::get_second>;
 
     namespace views
     {
         struct keys_fn;
 
         struct values_fn;
     } // namespace views
 
     template<typename Fun, typename... Rngs>
     struct iter_zip_with_view;
 
     template<typename Fun, typename... Rngs>
     struct zip_with_view;
 
     template<typename... Rngs>
     struct zip_view;
 
     namespace views
     {
         struct iter_zip_with_fn;
 
         struct zip_with_fn;
 
         struct zip_fn;
     } // namespace views
 } // namespace ranges
 
 /// \cond
 namespace ranges
 {
     namespace concepts = ::concepts;
     using namespace ::concepts::defs;
     using ::concepts::and_v;
 } // namespace ranges
 /// \endcond
 
 RANGES_DIAGNOSTIC_POP
 
 #include <range/v3/detail/epilogue.hpp>
 
 #endif

This page was automatically generated by the 2.3.7 LXR engine. The LXR team