#ifndef SPROUT_RANGE_ADAPTOR_REPLACED_IF_HPP #define SPROUT_RANGE_ADAPTOR_REPLACED_IF_HPP #include #include #include #include #include #include #include #include #include #include #include namespace sprout { namespace adaptors { namespace detail { template class replace_value_if { public: typedef Predicate predicate_type; typedef T const& result_type; typedef T const& first_argument_type; private: Predicate pred_; T new_; public: SPROUT_CONSTEXPR replace_value_if(Predicate pred, T const& new_value) : pred_(pred) , new_(new_value) {} SPROUT_CONSTEXPR T const& operator()(T const& value) const { return pred_(value) ? new_ : value; } }; } // namespace detail // // replaced_if_range // template class replaced_if_range : public sprout::range::range_container< sprout::transform_iterator< sprout::adaptors::detail::replace_value_if::value_type>, typename sprout::container_traits::iterator > > , public sprout::detail::container_nosy_static_size , public sprout::detail::container_nosy_fixed_size { public: typedef Range range_type; typedef sprout::range::range_container< sprout::transform_iterator< sprout::adaptors::detail::replace_value_if::value_type>, typename sprout::container_traits::iterator > > base_type; typedef typename base_type::iterator iterator; typedef typename base_type::value_type value_type; public: replaced_if_range() = default; replaced_if_range(replaced_if_range const&) = default; explicit SPROUT_CONSTEXPR replaced_if_range(range_type& range, Predicate pred, value_type const& new_value) : base_type( iterator(sprout::begin(range), typename iterator::functor_type(pred, new_value)), iterator(sprout::end(range), typename iterator::functor_type(pred, new_value)) ) {} }; // // replace_if_holder // template class replace_if_holder { public: typedef Predicate predicate_type; typedef T value_type; private: predicate_type pred_; value_type new_; public: SPROUT_CONSTEXPR replace_if_holder(predicate_type pred, value_type const& new_value) : pred_(pred) , new_(new_value) {} SPROUT_CONSTEXPR predicate_type predicate() const { return pred_; } SPROUT_CONSTEXPR value_type new_value() const { return new_; } }; // // replaced_if_forwarder // class replaced_if_forwarder { public: template SPROUT_CONSTEXPR sprout::adaptors::replace_if_holder operator()(Predicate pred, T const& new_value) { return sprout::adaptors::replace_if_holder(pred, new_value); } }; // // replaced_if // namespace { SPROUT_STATIC_CONSTEXPR sprout::adaptors::replaced_if_forwarder replaced_if{}; } // anonymous-namespace // // operator| // template inline SPROUT_CONSTEXPR sprout::adaptors::replaced_if_range< Predicate, typename std::remove_reference::type>::type > operator|(Range&& lhs, sprout::adaptors::replace_if_holder const& rhs) { return sprout::adaptors::replaced_if_range< Predicate, typename std::remove_reference::type>::type >( sprout::lvalue_forward(lhs), rhs.predicate(), rhs.new_value() ); } } // namespace adaptors // // container_construct_traits // template struct container_construct_traits > { public: typedef typename sprout::container_construct_traits::copied_type copied_type; public: template static SPROUT_CONSTEXPR copied_type deep_copy(Cont&& cont) { return sprout::range::fixed::copy(sprout::forward(cont), sprout::pit()); } template static SPROUT_CONSTEXPR copied_type make(Args&&... args) { return sprout::make(sprout::forward(args)...); } template static SPROUT_CONSTEXPR copied_type remake( Cont&& cont, typename sprout::container_traits >::difference_type size, Args&&... args ) { return sprout::remake(sprout::forward(cont), size, sprout::forward(args)...); } }; } // namespace sprout #endif // #ifndef SPROUT_RANGE_ADAPTOR_REPLACED_IF_HPP