Header file range/v3/view/replace_if.hpp

#include <meta/meta.hpp>

#include <range/v3/range_fwd.hpp>

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

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

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

#include <range/v3/utility/functional.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
        {
            template <typename Pred, typename Val>
            struct replacer_if_fn;
        }
        
        namespace view
        {
            struct replace_if_fn
            {
                template <typename Rng, typename Pred, typename Val>
                using Concept = meta::and_<InputRange<Rng>, IndirectCallablePredicate<Pred, range_iterator_t<Rng>>, Common<detail::decay_t<unwrap_reference_t<Val const&>>, range_value_t<Rng>>, CommonReference<unwrap_reference_t<Val const&>, range_reference_t<Rng>>, CommonReference<unwrap_reference_t<Val const&>, range_rvalue_reference_t<Rng>>>;
                
                template <typename Rng, typename Pred, typename Val, int _concept_requires_132 = 42, typename std::enable_if<(_concept_requires_132==43)||(Concept<Rng, Pred, Val>()), int>::type=0>
                replace_if_view<all_t<Rng>, Pred, Val> operator()(Rng&& rng, Pred pred, Val new_value) const;
                
                template <typename Rng, typename Pred, typename Val, int _concept_requires_141 = 42, typename std::enable_if<(_concept_requires_141==43)||(!Concept<Rng, Pred, Val>()), int>::type=0>
                void operator()(Rng&&, Pred, Val) const;
            };
            
            inline namespace 
            {
                constexpr auto& replace_if = static_const<view<replace_if_fn>>::value;
            }
        }
    }
}

Class template ranges::v3::detail::replacer_if_fn<Pred, Val>

template <typename Pred, typename Val>
struct replacer_if_fn
: compressed_pair<semiregular_t<function_type<Pred> >, Val>
{
    replacer_if_fn() = default;
    
    replacer_if_fn(Pred pred, Val new_value);
    
    template <typename I>
    common_type_t<decay_t<unwrap_reference_t<Val const&>>, iterator_value_t<I>>& operator()(copy_tag, I const&) const;
    
    template <typename I, int _concept_requires_63 = 42, typename std::enable_if<(_concept_requires_63==43)||(!Callable<Pred const, iterator_reference_t<I>>()), int>::type=0>
    common_reference_t<unwrap_reference_t<Val const&>, iterator_reference_t<I>> operator()(I const& i);
    
    template <typename I, int _concept_requires_73 = 42, typename std::enable_if<(_concept_requires_73==43)||(Callable<Pred const, iterator_reference_t<I>>()), int>::type=0>
    common_reference_t<unwrap_reference_t<Val const&>, iterator_reference_t<I>> operator()(I const& i) const;
    
    template <typename I, int _concept_requires_84 = 42, typename std::enable_if<(_concept_requires_84==43)||(!Callable<Pred const, iterator_rvalue_reference_t<I>>()), int>::type=0>
    common_reference_t<unwrap_reference_t<Val const&>, iterator_rvalue_reference_t<I>> operator()(move_tag, I const& i);
    
    template <typename I, int _concept_requires_94 = 42, typename std::enable_if<(_concept_requires_94==43)||(Callable<Pred const, iterator_rvalue_reference_t<I>>()), int>::type=0>
    common_reference_t<unwrap_reference_t<Val const&>, iterator_rvalue_reference_t<I>> operator()(move_tag, I const& i) const;
};

@{