Header file range/v3/view/transform.hpp

#include <meta/meta.hpp>

#include <range/v3/range_fwd.hpp>

#include <range/v3/size.hpp>

#include <range/v3/begin_end.hpp>

#include <range/v3/range_traits.hpp>

#include <range/v3/view_adaptor.hpp>

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

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

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

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

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

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

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

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

namespace ranges
{
    inline namespace v3
    {
        namespace detail
        {
            constexpr cardinality transform2_cardinality(cardinality c1, cardinality c2);
        }
        
        template <typename Rng, typename Fun>
        struct iter_transform_view;
        
        template <typename Rng, typename Fun>
        struct transform_view
        : iter_transform_view<Rng, indirected<Fun> >
        {
            transform_view() = default;
            
            transform_view(Rng rng, Fun fun);
        };
        
        template <typename Rng1, typename Rng2, typename Fun>
        struct iter_transform2_view
        : view_facade<iter_transform2_view<Rng1, Rng2, Fun>, detail::transform2_cardinality(range_cardinality<Rng1>::value, range_cardinality<Rng2>::value)>
        {
            iter_transform2_view() = default;
            
            iter_transform2_view(Rng1 rng1, Rng2 rng2, Fun fun);
            
            template <int _concept_requires_287 = 42, typename std::enable_if<(_concept_requires_287==43)||(my_cardinality>=0), int>::type=0>
            constexpr size_type_ size() const;
            
            template <int _concept_requires_292 = 42, typename std::enable_if<(_concept_requires_292==43)||(my_cardinality<0&&SizedRange<Rng1 const>()&&SizedRange<Rng2 const>()), int>::type=0>
            constexpr size_type_ size() const;
            
            template <int _concept_requires_298 = 42, typename std::enable_if<(_concept_requires_298==43)||(my_cardinality<0&&SizedRange<Rng1>()&&SizedRange<Rng2>()), int>::type=0>
            constexpr size_type_ size();
        };
        
        template <typename Rng1, typename Rng2, typename Fun>
        struct transform2_view
        : iter_transform2_view<Rng1, Rng2, indirected<Fun> >
        {
            transform2_view() = default;
            
            transform2_view(Rng1 rng1, Rng2 rng2, Fun fun);
        };
        
        namespace view
        {
            struct iter_transform_fn
            {
                template <typename Rng, typename Fun>
                using Concept = meta::and_<InputRange<Rng>, Callable<Fun, range_iterator_t<Rng>>, Callable<Fun, copy_tag, range_iterator_t<Rng>>, Callable<Fun, move_tag, range_iterator_t<Rng>>>;
                
                template <typename Rng1, typename Rng2, typename Fun>
                using Concept2 = meta::and_<InputRange<Rng1>, InputRange<Rng2>, Callable<Fun, range_iterator_t<Rng1>, range_iterator_t<Rng2>>, Callable<Fun, copy_tag, range_iterator_t<Rng1>, range_iterator_t<Rng2>>, Callable<Fun, move_tag, range_iterator_t<Rng1>, range_iterator_t<Rng2>>>;
                
                template <typename Rng, typename Fun, int _concept_requires_347 = 42, typename std::enable_if<(_concept_requires_347==43)||(Concept<Rng, Fun>()), int>::type=0>
                iter_transform_view<all_t<Rng>, Fun> operator()(Rng&& rng, Fun fun) const;
                
                template <typename Rng1, typename Rng2, typename Fun, int _concept_requires_354 = 42, typename std::enable_if<(_concept_requires_354==43)||(Concept2<Rng1, Rng2, Fun>()), int>::type=0>
                iter_transform2_view<all_t<Rng1>, all_t<Rng2>, Fun> operator()(Rng1&& rng1, Rng2&& rng2, Fun fun) const;
                
                template <typename Rng, typename Fun, int _concept_requires_363 = 42, typename std::enable_if<(_concept_requires_363==43)||(!Concept<Rng, Fun>()), int>::type=0>
                void operator()(Rng&&, Fun) const;
                
                template <typename Rng1, typename Rng2, typename Fun, int _concept_requires_384 = 42, typename std::enable_if<(_concept_requires_384==43)||(!Concept2<Rng1, Rng2, Fun>()), int>::type=0>
                void operator()(Rng1&&, Rng2&&, Fun) const;
            };
            
            inline namespace 
            {
                constexpr auto& iter_transform = static_const<view<iter_transform_fn>>::value;
            }
            
            struct transform_fn
            {
                template <typename Rng, typename Fun>
                using Concept = meta::and_<InputRange<Rng>, Callable<Fun, range_reference_t<Rng>&&>>;
                
                template <typename Rng1, typename Rng2, typename Fun>
                using Concept2 = meta::and_<InputRange<Rng1>, InputRange<Rng2>, Callable<Fun, range_reference_t<Rng1>&&, range_reference_t<Rng2>&&>>;
                
                template <typename Rng, typename Fun, int _concept_requires_437 = 42, typename std::enable_if<(_concept_requires_437==43)||(Concept<Rng, Fun>()), int>::type=0>
                transform_view<all_t<Rng>, Fun> operator()(Rng&& rng, Fun fun) const;
                
                template <typename Rng1, typename Rng2, typename Fun, int _concept_requires_444 = 42, typename std::enable_if<(_concept_requires_444==43)||(Concept2<Rng1, Rng2, Fun>()), int>::type=0>
                transform2_view<all_t<Rng1>, all_t<Rng2>, Fun> operator()(Rng1&& rng1, Rng2&& rng2, Fun fun) const;
                
                template <typename Rng, typename Fun, int _concept_requires_454 = 42, typename std::enable_if<(_concept_requires_454==43)||(!Concept<Rng, Fun>()), int>::type=0>
                void operator()(Rng&&, Fun) const;
                
                template <typename Rng1, typename Rng2, typename Fun, int _concept_requires_467 = 42, typename std::enable_if<(_concept_requires_467==43)||(!Concept2<Rng1, Rng2, Fun>()), int>::type=0>
                void operator()(Rng1&&, Rng2&&, Fun) const;
            };
            
            inline namespace 
            {
                constexpr auto& transform = static_const<view<transform_fn>>::value;
            }
        }
    }
}

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

template <typename Rng, typename Fun>
struct iter_transform_view
: view_adaptor<iter_transform_view<Rng, Fun>, Rng>
{
    iter_transform_view() = default;
    
    iter_transform_view(Rng rng, Fun fun);
    
    template <int _concept_requires_116 = 42, typename std::enable_if<(_concept_requires_116==43)||(SizedRange<Rng const>()), int>::type=0>
    constexpr range_size_t<Rng> size() const;
    
    template <int _concept_requires_121 = 42, typename std::enable_if<(_concept_requires_121==43)||(SizedRange<Rng>()), int>::type=0>
    constexpr range_size_t<Rng> size();
};

@{