1 //===----------------------------------------------------------------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #ifndef _LIBCPP___ALGORITHM_INPLACE_MERGE_H 10 #define _LIBCPP___ALGORITHM_INPLACE_MERGE_H 11 12 #include <__algorithm/comp.h> 13 #include <__algorithm/comp_ref_type.h> 14 #include <__algorithm/iterator_operations.h> 15 #include <__algorithm/lower_bound.h> 16 #include <__algorithm/min.h> 17 #include <__algorithm/move.h> 18 #include <__algorithm/rotate.h> 19 #include <__algorithm/upper_bound.h> 20 #include <__config> 21 #include <__functional/identity.h> 22 #include <__iterator/advance.h> 23 #include <__iterator/distance.h> 24 #include <__iterator/iterator_traits.h> 25 #include <__iterator/reverse_iterator.h> 26 #include <__memory/destruct_n.h> 27 #include <__memory/unique_ptr.h> 28 #include <__memory/unique_temporary_buffer.h> 29 #include <__utility/move.h> 30 #include <__utility/pair.h> 31 #include <new> 32 33 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) 34 # pragma GCC system_header 35 #endif 36 37 _LIBCPP_PUSH_MACROS 38 #include <__undef_macros> 39 40 _LIBCPP_BEGIN_NAMESPACE_STD 41 42 template <class _Predicate> 43 class __invert // invert the sense of a comparison 44 { 45 private: 46 _Predicate __p_; 47 48 public: 49 _LIBCPP_HIDE_FROM_ABI __invert() {} 50 51 _LIBCPP_HIDE_FROM_ABI explicit __invert(_Predicate __p) : __p_(__p) {} 52 53 template <class _T1> 54 _LIBCPP_HIDE_FROM_ABI bool operator()(const _T1& __x) { 55 return !__p_(__x); 56 } 57 58 template <class _T1, class _T2> 59 _LIBCPP_HIDE_FROM_ABI bool operator()(const _T1& __x, const _T2& __y) { 60 return __p_(__y, __x); 61 } 62 }; 63 64 template <class _AlgPolicy, 65 class _Compare, 66 class _InputIterator1, 67 class _Sent1, 68 class _InputIterator2, 69 class _Sent2, 70 class _OutputIterator> 71 _LIBCPP_HIDE_FROM_ABI void __half_inplace_merge( 72 _InputIterator1 __first1, 73 _Sent1 __last1, 74 _InputIterator2 __first2, 75 _Sent2 __last2, 76 _OutputIterator __result, 77 _Compare&& __comp) { 78 for (; __first1 != __last1; ++__result) { 79 if (__first2 == __last2) { 80 std::__move<_AlgPolicy>(__first1, __last1, __result); 81 return; 82 } 83 84 if (__comp(*__first2, *__first1)) { 85 *__result = _IterOps<_AlgPolicy>::__iter_move(__first2); 86 ++__first2; 87 } else { 88 *__result = _IterOps<_AlgPolicy>::__iter_move(__first1); 89 ++__first1; 90 } 91 } 92 // __first2 through __last2 are already in the right spot. 93 } 94 95 template <class _AlgPolicy, class _Compare, class _BidirectionalIterator> 96 _LIBCPP_HIDE_FROM_ABI void __buffered_inplace_merge( 97 _BidirectionalIterator __first, 98 _BidirectionalIterator __middle, 99 _BidirectionalIterator __last, 100 _Compare&& __comp, 101 typename iterator_traits<_BidirectionalIterator>::difference_type __len1, 102 typename iterator_traits<_BidirectionalIterator>::difference_type __len2, 103 typename iterator_traits<_BidirectionalIterator>::value_type* __buff) { 104 typedef typename iterator_traits<_BidirectionalIterator>::value_type value_type; 105 __destruct_n __d(0); 106 unique_ptr<value_type, __destruct_n&> __h2(__buff, __d); 107 if (__len1 <= __len2) { 108 value_type* __p = __buff; 109 for (_BidirectionalIterator __i = __first; __i != __middle; 110 __d.template __incr<value_type>(), (void)++__i, (void)++__p) 111 ::new ((void*)__p) value_type(_IterOps<_AlgPolicy>::__iter_move(__i)); 112 std::__half_inplace_merge<_AlgPolicy>(__buff, __p, __middle, __last, __first, __comp); 113 } else { 114 value_type* __p = __buff; 115 for (_BidirectionalIterator __i = __middle; __i != __last; 116 __d.template __incr<value_type>(), (void)++__i, (void)++__p) 117 ::new ((void*)__p) value_type(_IterOps<_AlgPolicy>::__iter_move(__i)); 118 typedef reverse_iterator<_BidirectionalIterator> _RBi; 119 typedef reverse_iterator<value_type*> _Rv; 120 typedef __invert<_Compare> _Inverted; 121 std::__half_inplace_merge<_AlgPolicy>( 122 _Rv(__p), _Rv(__buff), _RBi(__middle), _RBi(__first), _RBi(__last), _Inverted(__comp)); 123 } 124 } 125 126 template <class _AlgPolicy, class _Compare, class _BidirectionalIterator> 127 void __inplace_merge( 128 _BidirectionalIterator __first, 129 _BidirectionalIterator __middle, 130 _BidirectionalIterator __last, 131 _Compare&& __comp, 132 typename iterator_traits<_BidirectionalIterator>::difference_type __len1, 133 typename iterator_traits<_BidirectionalIterator>::difference_type __len2, 134 typename iterator_traits<_BidirectionalIterator>::value_type* __buff, 135 ptrdiff_t __buff_size) { 136 using _Ops = _IterOps<_AlgPolicy>; 137 138 typedef typename iterator_traits<_BidirectionalIterator>::difference_type difference_type; 139 while (true) { 140 // if __middle == __last, we're done 141 if (__len2 == 0) 142 return; 143 if (__len1 <= __buff_size || __len2 <= __buff_size) 144 return std::__buffered_inplace_merge<_AlgPolicy>(__first, __middle, __last, __comp, __len1, __len2, __buff); 145 // shrink [__first, __middle) as much as possible (with no moves), returning if it shrinks to 0 146 for (; true; ++__first, (void)--__len1) { 147 if (__len1 == 0) 148 return; 149 if (__comp(*__middle, *__first)) 150 break; 151 } 152 // __first < __middle < __last 153 // *__first > *__middle 154 // partition [__first, __m1) [__m1, __middle) [__middle, __m2) [__m2, __last) such that 155 // all elements in: 156 // [__first, __m1) <= [__middle, __m2) 157 // [__middle, __m2) < [__m1, __middle) 158 // [__m1, __middle) <= [__m2, __last) 159 // and __m1 or __m2 is in the middle of its range 160 _BidirectionalIterator __m1; // "median" of [__first, __middle) 161 _BidirectionalIterator __m2; // "median" of [__middle, __last) 162 difference_type __len11; // distance(__first, __m1) 163 difference_type __len21; // distance(__middle, __m2) 164 // binary search smaller range 165 if (__len1 < __len2) { // __len >= 1, __len2 >= 2 166 __len21 = __len2 / 2; 167 __m2 = __middle; 168 _Ops::advance(__m2, __len21); 169 __m1 = std::__upper_bound<_AlgPolicy>(__first, __middle, *__m2, __comp, std::__identity()); 170 __len11 = _Ops::distance(__first, __m1); 171 } else { 172 if (__len1 == 1) { // __len1 >= __len2 && __len2 > 0, therefore __len2 == 1 173 // It is known *__first > *__middle 174 _Ops::iter_swap(__first, __middle); 175 return; 176 } 177 // __len1 >= 2, __len2 >= 1 178 __len11 = __len1 / 2; 179 __m1 = __first; 180 _Ops::advance(__m1, __len11); 181 __m2 = std::lower_bound(__middle, __last, *__m1, __comp); 182 __len21 = _Ops::distance(__middle, __m2); 183 } 184 difference_type __len12 = __len1 - __len11; // distance(__m1, __middle) 185 difference_type __len22 = __len2 - __len21; // distance(__m2, __last) 186 // [__first, __m1) [__m1, __middle) [__middle, __m2) [__m2, __last) 187 // swap middle two partitions 188 __middle = std::__rotate<_AlgPolicy>(__m1, __middle, __m2).first; 189 // __len12 and __len21 now have swapped meanings 190 // merge smaller range with recursive call and larger with tail recursion elimination 191 if (__len11 + __len21 < __len12 + __len22) { 192 std::__inplace_merge<_AlgPolicy>(__first, __m1, __middle, __comp, __len11, __len21, __buff, __buff_size); 193 __first = __middle; 194 __middle = __m2; 195 __len1 = __len12; 196 __len2 = __len22; 197 } else { 198 std::__inplace_merge<_AlgPolicy>(__middle, __m2, __last, __comp, __len12, __len22, __buff, __buff_size); 199 __last = __middle; 200 __middle = __m1; 201 __len1 = __len11; 202 __len2 = __len21; 203 } 204 } 205 } 206 207 template <class _AlgPolicy, class _BidirectionalIterator, class _Compare> 208 _LIBCPP_HIDE_FROM_ABI void __inplace_merge( 209 _BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last, _Compare&& __comp) { 210 typedef typename iterator_traits<_BidirectionalIterator>::value_type value_type; 211 typedef typename iterator_traits<_BidirectionalIterator>::difference_type difference_type; 212 difference_type __len1 = _IterOps<_AlgPolicy>::distance(__first, __middle); 213 difference_type __len2 = _IterOps<_AlgPolicy>::distance(__middle, __last); 214 difference_type __buf_size = std::min(__len1, __len2); 215 __unique_temporary_buffer<value_type> __unique_buf = std::__allocate_unique_temporary_buffer<value_type>(__buf_size); 216 return std::__inplace_merge<_AlgPolicy>( 217 std::move(__first), 218 std::move(__middle), 219 std::move(__last), 220 __comp, 221 __len1, 222 __len2, 223 __unique_buf.get(), 224 __unique_buf.get_deleter().__count_); 225 } 226 227 template <class _BidirectionalIterator, class _Compare> 228 inline _LIBCPP_HIDE_FROM_ABI void inplace_merge( 229 _BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last, _Compare __comp) { 230 std::__inplace_merge<_ClassicAlgPolicy>( 231 std::move(__first), std::move(__middle), std::move(__last), static_cast<__comp_ref_type<_Compare> >(__comp)); 232 } 233 234 template <class _BidirectionalIterator> 235 inline _LIBCPP_HIDE_FROM_ABI void 236 inplace_merge(_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last) { 237 std::inplace_merge(std::move(__first), std::move(__middle), std::move(__last), __less<>()); 238 } 239 240 _LIBCPP_END_NAMESPACE_STD 241 242 _LIBCPP_POP_MACROS 243 244 #endif // _LIBCPP___ALGORITHM_INPLACE_MERGE_H 245