Header file range/v3/view/take_while.hpp

#include <meta/meta.hpp>

#include <range/v3/range_fwd.hpp>

#include <range/v3/range_concepts.hpp>

#include <range/v3/view_adaptor.hpp>

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

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

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

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

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

namespace ranges
{
    inline namespace v3
    {
        template <typename Rng, typename Pred>
        struct iter_take_while_view;
        
        template <typename Rng, typename Pred>
        struct take_while_view
        : iter_take_while_view<Rng, indirected<Pred> >
        {
            take_while_view() = default;
            
            take_while_view(Rng rng, Pred pred);
        };
        
        namespace view
        {
            struct iter_take_while_fn
            {
                template <typename Rng, typename Pred>
                using Concept = meta::and_<InputRange<Rng>, CallablePredicate<Pred, range_iterator_t<Rng>>>;
                
                template <typename Rng, typename Pred, int _concept_requires_111 = 42, typename std::enable_if<(_concept_requires_111==43)||(Concept<Rng, Pred>()), int>::type=0>
                iter_take_while_view<all_t<Rng>, Pred> operator()(Rng&& rng, Pred pred) const;
                
                template <typename Rng, typename Pred, int _concept_requires_118 = 42, typename std::enable_if<(_concept_requires_118==43)||(!Concept<Rng, Pred>()), int>::type=0>
                void operator()(Rng&&, Pred) const;
            };
            
            struct take_while_fn
            {
                template <typename Rng, typename Pred>
                using Concept = meta::and_<InputRange<Rng>, IndirectCallablePredicate<Pred, range_iterator_t<Rng>>>;
                
                template <typename Rng, typename Pred, int _concept_requires_150 = 42, typename std::enable_if<(_concept_requires_150==43)||(Concept<Rng, Pred>()), int>::type=0>
                take_while_view<all_t<Rng>, Pred> operator()(Rng&& rng, Pred pred) const;
                
                template <typename Rng, typename Pred, int _concept_requires_157 = 42, typename std::enable_if<(_concept_requires_157==43)||(!Concept<Rng, Pred>()), int>::type=0>
                void operator()(Rng&&, Pred) const;
            };
            
            inline namespace 
            {
                constexpr auto& iter_take_while = static_const<view<iter_take_while_fn>>::value;
            }
            
            inline namespace 
            {
                constexpr auto& take_while = static_const<view<take_while_fn>>::value;
            }
        }
    }
}

Class template ranges::v3::iter_take_while_view<Rng, Pred>

template <typename Rng, typename Pred>
struct iter_take_while_view
: view_adaptor<iter_take_while_view<Rng, Pred>, Rng, is_finite<Rng>::value ? finite : unknown>
{
    iter_take_while_view() = default;
    
    iter_take_while_view(Rng rng, Pred pred);
};

@{