Header file range/v3/view/split.hpp

#include <meta/meta.hpp>

#include <range/v3/range_fwd.hpp>

#include <range/v3/begin_end.hpp>

#include <range/v3/iterator_range.hpp>

#include <range/v3/range_traits.hpp>

#include <range/v3/range_concepts.hpp>

#include <range/v3/view_facade.hpp>

#include <range/v3/utility/iterator.hpp>

#include <range/v3/utility/functional.hpp>

#include <range/v3/utility/semiregular.hpp>

#include <range/v3/utility/static_const.hpp>

#include <range/v3/algorithm/adjacent_find.hpp>

#include <range/v3/view/view.hpp>

#include <range/v3/view/all.hpp>

#include <range/v3/view/iota.hpp>

#include <range/v3/view/indirect.hpp>

#include <range/v3/view/take_while.hpp>

#include <range/v3/algorithm/find_if_not.hpp>

namespace ranges
{
    inline namespace v3
    {
        template <typename Rng, typename Fun>
        struct split_view;
        
        namespace view
        {
            struct split_fn
            {
                template <typename Rng, typename Fun>
                using FunctionConcept = meta::and_<ForwardRange<Rng>, Function<Fun, range_iterator_t<Rng>, range_sentinel_t<Rng>>, ConvertibleTo<concepts::Function::result_t<Fun, range_iterator_t<Rng>, range_sentinel_t<Rng>>, std::pair<bool, range_iterator_t<Rng>>>>;
                
                template <typename Rng, typename Fun>
                using PredicateConcept = meta::and_<ForwardRange<Rng>, Predicate<Fun, range_reference_t<Rng>>>;
                
                template <typename Rng>
                using ElementConcept = meta::and_<ForwardRange<Rng>, Regular<range_value_t<Rng>>>;
                
                template <typename Rng, typename Sub>
                using SubRangeConcept = meta::and_<ForwardRange<Rng>, ForwardRange<Sub>, EqualityComparable<range_value_t<Rng>, range_value_t<Sub>>>;
                
                template <typename Rng, typename Fun, int _concept_requires_226 = 42, typename std::enable_if<(_concept_requires_226==43)||(FunctionConcept<Rng, Fun>()), int>::type=0>
                split_view<all_t<Rng>, Fun> operator()(Rng&& rng, Fun fun) const;
                
                template <typename Rng, typename Fun, int _concept_requires_232 = 42, typename std::enable_if<(_concept_requires_232==43)||(PredicateConcept<Rng, Fun>()), int>::type=0>
                split_view<all_t<Rng>, predicate_pred<Rng, Fun>> operator()(Rng&& rng, Fun fun) const;
                
                template <typename Rng, int _concept_requires_238 = 42, typename std::enable_if<(_concept_requires_238==43)||(ElementConcept<Rng>()), int>::type=0>
                split_view<all_t<Rng>, element_pred<Rng>> operator()(Rng&& rng, range_value_t<Rng> val) const;
                
                template <typename Rng, typename Sub, int _concept_requires_244 = 42, typename std::enable_if<(_concept_requires_244==43)||(SubRangeConcept<Rng, Sub>()), int>::type=0>
                split_view<all_t<Rng>, subrange_pred<Rng, Sub>> operator()(Rng&& rng, Sub&& sub) const;
                
                template <typename Rng, typename T, int _concept_requires_252 = 42, typename std::enable_if<(_concept_requires_252==43)||(!ConvertibleTo<T, range_value_t<Rng>>()), int>::type=0>
                void operator()(Rng&&, T&&) const volatile;
            };
            
            inline namespace 
            {
                constexpr auto& split = static_const<view<split_fn>>::value;
            }
        }
    }
}

Class template ranges::v3::split_view<Rng, Fun>

template <typename Rng, typename Fun>
struct split_view
: view_facade<split_view<Rng, Fun>, is_finite<Rng>::value ? finite : range_cardinality<Rng>::value>
{
    split_view() = default;
    
    split_view(Rng rng, Fun fun);
};

@{