Header file range/v3/algorithm/inplace_merge.hpp

#include <range/v3/range_fwd.hpp>

#include <range/v3/begin_end.hpp>

#include <range/v3/distance.hpp>

#include <range/v3/range_concepts.hpp>

#include <range/v3/range_traits.hpp>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

namespace ranges
{
    inline namespace v3
    {
        namespace detail
        {
            struct merge_adaptive_fn
            {
                template <typename I, typename C = ordered_less, typename P = ident, int _concept_requires_88 = 42, typename std::enable_if<(_concept_requires_88==43)||(BidirectionalIterator<I>()&&Sortable<I, C, P>()), int>::type=0>
                void operator()(I begin, I middle, I end, iterator_difference_t<I> len1, iterator_difference_t<I> len2, iterator_value_t<I>* buf, std::ptrdiff_t buf_size, C pred_ = C{}, P proj_ = P{}) const;
            };
            
            inline namespace 
            {
                constexpr auto& merge_adaptive = static_const<merge_adaptive_fn>::value;
            }
            
            struct inplace_merge_no_buffer_fn
            {
                template <typename I, typename C = ordered_less, typename P = ident, int _concept_requires_183 = 42, typename std::enable_if<(_concept_requires_183==43)||(BidirectionalIterator<I>()&&Sortable<I, C, P>()), int>::type=0>
                void operator()(I begin, I middle, I end, iterator_difference_t<I> len1, iterator_difference_t<I> len2, C pred = C{}, P proj = P{}) const;
            };
            
            inline namespace 
            {
                constexpr auto& inplace_merge_no_buffer = static_const<inplace_merge_no_buffer_fn>::value;
            }
        }
        
        struct inplace_merge_fn;
        
        inline namespace 
        {
            constexpr auto& inplace_merge = static_const<with_braced_init_args<inplace_merge_fn>>::value;
        }
    }
}

Class ranges::v3::inplace_merge_fn

struct inplace_merge_fn
{
    template <typename I, typename S, typename C = ordered_less, typename P = ident, int _concept_requires_203 = 42, typename std::enable_if<(_concept_requires_203==43)||(BidirectionalIterator<I>()&&Sortable<I, C, P>()), int>::type=0>
    I operator()(I begin, I middle, S end, C pred = C{}, P proj = P{}) const;
    
    template <typename Rng, typename C = ordered_less, typename P = ident, typename I = range_iterator_t<Rng>, int _concept_requires_225 = 42, typename std::enable_if<(_concept_requires_225==43)||(BidirectionalRange<Rng>()&&Sortable<I, C, P>()), int>::type=0>
    range_safe_iterator_t<Rng> operator()(Rng&& rng, I middle, C pred = C{}, P proj = P{}) const;
};

@{


Variable ranges::v3::inplace_merge

constexpr auto& inplace_merge = static_const<with_braced_init_args<inplace_merge_fn>>::value;

inplace_merge_fn