}
}
-template <class _Tp>
-struct __inplace_merge_switch
-{
- static const unsigned value = is_trivially_copy_assignable<_Tp>::value;
-};
-
template <class _BidirectionalIterator, class _Compare>
inline _LIBCPP_INLINE_VISIBILITY
void
difference_type __len1 = _VSTD::distance(__first, __middle);
difference_type __len2 = _VSTD::distance(__middle, __last);
difference_type __buf_size = _VSTD::min(__len1, __len2);
- pair<value_type*, ptrdiff_t> __buf(0, 0);
- unique_ptr<value_type, __return_temporary_buffer> __h;
- if (__inplace_merge_switch<value_type>::value && __buf_size > 8)
- {
- __buf = _VSTD::get_temporary_buffer<value_type>(__buf_size);
- __h.reset(__buf.first);
- }
+ pair<value_type*, ptrdiff_t> __buf = _VSTD::get_temporary_buffer<value_type>(__buf_size);
+ unique_ptr<value_type, __return_temporary_buffer> __h(__buf.first);
+
#ifdef _LIBCPP_DEBUG
typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref;
__debug_less<_Compare> __c(__comp);
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#include "test_iterators.h"
+#include "counting_predicates.hpp"
template <class Iter>
void
std::random_shuffle(ia, ia+N);
std::sort(ia, ia+M, std::greater<int>());
std::sort(ia+M, ia+N, std::greater<int>());
- std::inplace_merge(Iter(ia), Iter(ia+M), Iter(ia+N), std::greater<int>());
+ binary_counting_predicate<std::greater<int>, int, int> pred((std::greater<int>()));
+ std::inplace_merge(Iter(ia), Iter(ia+M), Iter(ia+N), std::ref(pred));
if(N > 0)
{
assert(ia[0] == N-1);
assert(ia[N-1] == 0);
assert(std::is_sorted(ia, ia+N, std::greater<int>()));
+ assert(pred.count() <= (N-1));
}
delete [] ia;
}
test_one<Iter>(3, 2);
test_one<Iter>(3, 3);
test<Iter>(4);
+ test<Iter>(20);
test<Iter>(100);
test<Iter>(1000);
}
#include <cassert>
#include "test_iterators.h"
+#include "counting_predicates.hpp"
template <class InIter1, class InIter2, class OutIter>
void
ib[i] = 2*i+1;
std::reverse(ia, ia+N);
std::reverse(ib, ib+N);
+ binary_counting_predicate<std::greater<int>, int, int> pred((std::greater<int>()));
OutIter r = std::merge(InIter1(ia), InIter1(ia+N),
- InIter2(ib), InIter2(ib+N), OutIter(ic), std::greater<int>());
+ InIter2(ib), InIter2(ib+N), OutIter(ic), pred);
assert(base(r) == ic+2*N);
assert(ic[0] == 2*N-1);
assert(ic[2*N-1] == 0);
assert(std::is_sorted(ic, ic+2*N, std::greater<int>()));
+ assert(pred.count() <= (N + N - 1));
delete [] ic;
delete [] ib;
delete [] ia;
std::copy(ic+N, ic+2*N, ib);
std::sort(ia, ia+N, std::greater<int>());
std::sort(ib, ib+N, std::greater<int>());
+ binary_counting_predicate<std::greater<int>, int, int> pred((std::greater<int>()));
OutIter r = std::merge(InIter1(ia), InIter1(ia+N),
- InIter2(ib), InIter2(ib+N), OutIter(ic), std::greater<int>());
+ InIter2(ib), InIter2(ib+N), OutIter(ic), pred);
assert(base(r) == ic+2*N);
assert(ic[0] == 2*N-1);
assert(ic[2*N-1] == 0);
assert(std::is_sorted(ic, ic+2*N, std::greater<int>()));
+ assert(pred.count() <= (N + N - 1));
delete [] ic;
delete [] ib;
delete [] ia;