Header file range/v3/range_fwd.hpp

#include <meta/meta.hpp>

#include <range/v3/detail/config.hpp>

namespace ranges
{
    inline namespace v3
    {
        inline namespace function_objects{}
        
        namespace aux
        {
            inline namespace function_objects{}
        }
        
        namespace view
        {
            inline namespace function_objects{}
        }
        
        namespace action
        {
            inline namespace function_objects{}
        }
        
        namespace detail
        {
            inline namespace function_objects{}
        }
        
        namespace adl_begin_end_detail{}
        
        using adl_begin_end_detail::begin_fn;
        
        using adl_begin_end_detail::end_fn;
        
        using adl_begin_end_detail::cbegin_fn;
        
        using adl_begin_end_detail::cend_fn;
        
        using adl_begin_end_detail::rbegin_fn;
        
        using adl_begin_end_detail::rend_fn;
        
        using adl_begin_end_detail::crbegin_fn;
        
        using adl_begin_end_detail::crend_fn;
        
        namespace adl_size_detail{}
        
        using adl_size_detail::size_fn;
        
        template <typename ... Ts>
        using common_type_t = meta::_t<common_type<Ts...>>;
        
        template <typename ... Ts>
        using common_reference_t = meta::_t<common_reference<Ts...>>;
        
        template <typename Sig>
        using result_of_t = meta::_t<std::result_of<Sig>>;
        
        namespace action{}
        
        namespace view{}
        
        namespace adl_advance_detail{}
        
        using adl_advance_detail::advance_fn;
        
        struct view_base{};
        
        namespace detail
        {
            template <typename T = void>
            struct any_
            {
                any_() = default;
                
                any_(T&&);
            };
            
            template <>
            struct any_<void>
            {
                any_() = default;
                
                template <typename T>
                any_(T&&);
            };
            
            using any = any_<>;
            
            struct value_init
            {
                template <typename T>
                operator T() const;
            };
            
            template <typename T>
            constexpr T&& forward(meta::_t<std::remove_reference<T>>& t) noexcept;
            
            template <typename T>
            constexpr T&& forward(meta::_t<std::remove_reference<T>>&& t) noexcept;
            
            template <typename T>
            constexpr meta::_t<std::remove_reference<T>>&& move(T&& t) noexcept;
            
            template <typename T>
            constexpr T const& as_const(T& t) noexcept;
            
            template <typename T>
            void as_const(T const&&) = delete;
            
            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<meta::_t<std::add_const<R>>>>;
            
            template <typename ... Ts>
            void valid_exprs(Ts&&...);
            
            template <typename ... Ts>
            void ignore_unused(Ts&&...);
            
            using std::is_trivially_copy_assignable;
            
            using std::is_trivially_move_assignable;
            
            using std::is_final;
            
            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>>;
        }
        
        namespace concepts{}
        
        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>>>>;
        
        enum cardinality
        {
            infinite = -3,
            unknown = -2,
            finite = -1,
            _max_ = 2147483647,
        };
        
        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 <cardinality>
        struct basic_view
        : ranges::v3::view_base
        {};
        
        template <typename I, typename S>
        using common_iterator = meta::if_<std::is_same<I, S>, I, basic_iterator<detail::common_cursor<I, S>>>;
        
        template <typename T>
        using bind_element_t = meta::_t<bind_element<T>>;
        
        template <typename T>
        istream_range<T> istream(std::istream& sin);
        
        template <typename T>
        using rvalue_reference_wrapper = reference_wrapper<T, true>;
        
        namespace view{}
        
        namespace view{}
        
        namespace view{}
        
        namespace view{}
        
        namespace view{}
        
        namespace view{}
        
        using default_sentinel = basic_sentinel<default_end_cursor>;
        
        template <typename I, typename D = meta::_t<difference_type<I>>>
        using counted_iterator = basic_iterator<detail::counted_cursor<I, D>, default_end_cursor>;
        
        template <typename I>
        using move_iterator = basic_iterator<detail::move_cursor<I>, default_end_cursor>;
        
        template <typename I>
        using move_into_iterator = basic_iterator<detail::move_into_cursor<I>, default_end_cursor>;
        
        namespace view{}
        
        namespace detail{}
        
        template <typename I>
        using reverse_iterator = basic_iterator<detail::reverse_cursor<I>, detail::reverse_cursor<I>>;
        
        namespace view{}
        
        namespace view{}
        
        namespace view{}
        
        namespace view{}
        
        namespace view{}
        
        namespace view{}
        
        namespace view{}
        
        namespace view{}
        
        namespace view{}
        
        namespace view{}
        
        namespace view{}
        
        namespace view{}
        
        namespace view{}
        
        namespace view{}
        
        namespace view{}
        
        namespace view{}
        
        namespace detail{}
        
        template <typename Rng>
        using take_exactly_view = detail::take_exactly_view_<Rng>;
        
        namespace view{}
        
        namespace view{}
        
        namespace view{}
        
        namespace view{}
        
        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 view{}
        
        namespace view{}
        
        template <typename Rng>
        using unique_view = adjacent_filter_view<Rng, not_equal_to>;
        
        namespace view{}
        
        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 view{}
        
        namespace view{}
    }
}