From aaeca77a79a9a897c97f00f83f2471e7a8bd6685 Mon Sep 17 00:00:00 2001 From: Jonathan Wakely Date: Fri, 13 Jun 2025 17:27:51 +0100 Subject: [PATCH] libstdc++: Eliminate __gnu_cxx::__ops function objects MIME-Version: 1.0 Content-Type: text/plain; charset=utf8 Content-Transfer-Encoding: 8bit This removes the indirect functors from that are used by our STL algorithms. Currently we wrap all predicates and values into callables which accept iterator arguments, and automatically dereference the iterators. With this change we no longer do that dereferencing and so all predicates are passed values not iterators, and the algorithms that invoke those predicates must dereference the iterators. This avoids wrapping user-provided predicates into another predicate that does the dereferencing. User-provided predicates are now passed unchanged to our internal algos like __search_n. For the overloads that take a value instead of a predicate, we still need to create a predicate that does comparison to the value, but we can now use std::less and std::equal_to as the base predicate and bind the value to those base predicates. Because the "transparent operators" std::less and std::equal_to were not added until C++14, this change defines those explicit specializations unconditionally for C++98 and C++11 too (but the default template arguments that make std::less<> and std::equal_to<> refer to those specializations are still only present for C++14 and later, because we don't need to rely on those default template arguments for our internal uses). When binding a predicate and a value into a new call wrapper, we now decide whether to store the predicate by value when it's an empty type or a scalar (such as a function pointer). This avoids a double-indirection through function pointers, and avoids storing and invoking stateless empty functors through a reference. For C++11 and later we also use [[no_unique_address]] to avoid wasted storage for empty predicates (which includes all standard relational ops, such as std::less). The call wrappers in bits/predefined_ops.h all have non-const operator() because we can't be sure that the predicates they wrap are const-invocable. The requirements in [algorithms.requirements] for Predicate and BinaryPredicate template arguments require pred(*i) to be valid, but do not require that std::to_const(pred)(*i) has to be valid, and similarly for binary_pred. libstdc++-v3/ChangeLog: * include/bits/predefined_ops.h (equal_to, less): Define aliases for std::equal_to and std::less. (bind1st, bind2nd, not1, __equal_to): New object generator functions for adapting predicates. (__iter_less_iter, __iter_less_val, __iter_comp_val) (__val_less_iter, __val_comp_iter, __iter_equal_to_iter) (__iter_equal_to_val, __iter_comp_iter, __negate): Remove all object generator functions and the class templates they return. * include/bits/stl_algo.h (__move_median_to_first, __find_if_not) (__find_if_not_n, __search_n_aux, find_end, find_if_not) (__remove_copy_if, remove_copy, remove_copy_if, remove) (remove_if, __adjacent_find, __unique, unique, __unique_copy) (__unique_copy_1, __stable_partition_adaptive, stable_partition) (__heap_select, __partial_sort_copy, partial_sort_copy) (__unguarded_linear_insert, __insertion_sort) (__unguarded_insertion_sort, __unguarded_partition) (lower_bound, __upper_bound, upper_bound, __equal_range) (equal_range, binary_search, __move_merge_adaptive) (__move_merge_adaptive_backward, __merge_adaptive_resize) (__merge_without_buffer, inplace_merge, __move_merge) (__includes, includes, __next_permutation, next_permutation) (__prev_permutation, prev_permutation, __replace_copy_if) (replace_copy, replace_copy_if, __is_sorted_until) (is_sorted_until, __minmax_element, minmax_element, minmax) (is_permutation, __is_permutation, find, find_if, adjacent_find) (count, count_if, search, search_n, unique_copy, partial_sort) (nth_element, sort, __merge, merge, stable_sort, __set_union) (set_union, __set_intersection, set_intersection) (__set_difference, set_difference, __set_symmetric_difference) (set_symmetric_difference, __min_element, min_element) (__max_element, max_element, min, max): Use direct predicates instead of __iter_equal_to_iter, __iter_comp_iter, and __iter_less_iter, __negate etc. Dereference iterators when invoking predicates. * include/bits/stl_algobase.h (__lexicographical_compare_impl) (__lexicographical_compare::__lc, __lower_bound, lower_bound) (lexicographical_compare, __mismatch, mismatch, __find_if) (__count_if, __remove_if, __search, __is_permutation) (is_permutation, search): Likewise. * include/bits/stl_function.h (equal_to, less): Define transparent comparison functions for C++98 and C++11. * include/bits/stl_heap.h (__is_heap_until, __is_heap) (__push_heap, push_heap, __adjust_heap, pop_heap, make_heap) (sort_heap, is_heap_until, is_heap): Likewise. * include/std/deque (erase_if): Remove call to __pred_iter. (erase): Replace __iter_equals_val with __equal_to. * include/std/inplace_vector (erase_if, erase): Likewise. * include/std/string (erase_if, erase): Likewise. * include/std/vector (erase_if, erase): Likewise. Reviewed-by: Tomasz Kamiński Reviewed-by: François Dumont --- libstdc++-v3/include/bits/predefined_ops.h | 444 ++++++--------------- libstdc++-v3/include/bits/stl_algo.h | 399 ++++++++---------- libstdc++-v3/include/bits/stl_algobase.h | 54 +-- libstdc++-v3/include/bits/stl_function.h | 52 +++ libstdc++-v3/include/bits/stl_heap.h | 53 +-- libstdc++-v3/include/std/deque | 4 +- libstdc++-v3/include/std/inplace_vector | 4 +- libstdc++-v3/include/std/string | 4 +- libstdc++-v3/include/std/vector | 4 +- 9 files changed, 404 insertions(+), 614 deletions(-) diff --git a/libstdc++-v3/include/bits/predefined_ops.h b/libstdc++-v3/include/bits/predefined_ops.h index 5759ebd0e5bc..d75b5c2ffc85 100644 --- a/libstdc++-v3/include/bits/predefined_ops.h +++ b/libstdc++-v3/include/bits/predefined_ops.h @@ -30,376 +30,178 @@ #ifndef _GLIBCXX_PREDEFINED_OPS_H #define _GLIBCXX_PREDEFINED_OPS_H 1 -#include +#include // less, equal_to +#if __cplusplus >= 201103L +# include // is_empty, is_scalar, __conditional_t, __or_ +#else +# include // __conditional_type +#endif namespace __gnu_cxx { namespace __ops { - struct _Iter_less_iter - { - template - _GLIBCXX14_CONSTEXPR - bool - operator()(_Iterator1 __it1, _Iterator2 __it2) const - { return *__it1 < *__it2; } - }; - - _GLIBCXX14_CONSTEXPR - inline _Iter_less_iter - __iter_less_iter() - { return _Iter_less_iter(); } - - struct _Iter_less_val - { -#if __cplusplus >= 201103L - constexpr _Iter_less_val() = default; -#else - _Iter_less_val() { } -#endif + // These two explicit specializations are always defined by libstdc++, + // even when __cpp_lib_transparent_operators is not defined. + typedef std::equal_to equal_to; + typedef std::less less; - _GLIBCXX20_CONSTEXPR - explicit - _Iter_less_val(_Iter_less_iter) { } - - template - _GLIBCXX20_CONSTEXPR - bool - operator()(_Iterator __it, _Value& __val) const - { return *__it < __val; } - }; - - _GLIBCXX20_CONSTEXPR - inline _Iter_less_val - __iter_less_val() - { return _Iter_less_val(); } - - _GLIBCXX20_CONSTEXPR - inline _Iter_less_val - __iter_comp_val(_Iter_less_iter) - { return _Iter_less_val(); } - - struct _Val_less_iter - { #if __cplusplus >= 201103L - constexpr _Val_less_iter() = default; -#else - _Val_less_iter() { } -#endif - _GLIBCXX20_CONSTEXPR - explicit - _Val_less_iter(_Iter_less_iter) { } - - template - _GLIBCXX20_CONSTEXPR - bool - operator()(_Value& __val, _Iterator __it) const - { return __val < *__it; } - }; - - _GLIBCXX20_CONSTEXPR - inline _Val_less_iter - __val_less_iter() - { return _Val_less_iter(); } - - _GLIBCXX20_CONSTEXPR - inline _Val_less_iter - __val_comp_iter(_Iter_less_iter) - { return _Val_less_iter(); } - - struct _Iter_equal_to_iter - { - template - _GLIBCXX20_CONSTEXPR - bool - operator()(_Iterator1 __it1, _Iterator2 __it2) const - { return *__it1 == *__it2; } - }; - - _GLIBCXX20_CONSTEXPR - inline _Iter_equal_to_iter - __iter_equal_to_iter() - { return _Iter_equal_to_iter(); } - - struct _Iter_equal_to_val - { - template - _GLIBCXX20_CONSTEXPR - bool - operator()(_Iterator __it, _Value& __val) const - { return *__it == __val; } - }; - - _GLIBCXX20_CONSTEXPR - inline _Iter_equal_to_val - __iter_equal_to_val() - { return _Iter_equal_to_val(); } - - _GLIBCXX20_CONSTEXPR - inline _Iter_equal_to_val - __iter_comp_val(_Iter_equal_to_iter) - { return _Iter_equal_to_val(); } - - template - struct _Iter_comp_iter - { - _Compare _M_comp; - - explicit _GLIBCXX14_CONSTEXPR - _Iter_comp_iter(_Compare __comp) - : _M_comp(_GLIBCXX_MOVE(__comp)) - { } - - template - _GLIBCXX14_CONSTEXPR - bool - operator()(_Iterator1 __it1, _Iterator2 __it2) - { return bool(_M_comp(*__it1, *__it2)); } - }; + template + using __by_ref_or_value_fn + = std::__conditional_t, + std::is_scalar<_Fn>>::value, + _Fn, _Fn&>; - template - _GLIBCXX14_CONSTEXPR - inline _Iter_comp_iter<_Compare> - __iter_comp_iter(_Compare __comp) - { return _Iter_comp_iter<_Compare>(_GLIBCXX_MOVE(__comp)); } + // More generic replacements for the deprecated utilities + // std::bind1st, std::bind2nd, and std::not1. + // These aren't fully "transparent" like std::less because they + // do not use perfect forwarding, everything is treated as an lvalue. - template - struct _Iter_comp_val + template + struct _Comp_with_val { - _Compare _M_comp; - - _GLIBCXX20_CONSTEXPR - explicit - _Iter_comp_val(_Compare __comp) - : _M_comp(_GLIBCXX_MOVE(__comp)) - { } - - _GLIBCXX20_CONSTEXPR - explicit - _Iter_comp_val(const _Iter_comp_iter<_Compare>& __comp) - : _M_comp(__comp._M_comp) - { } - -#if __cplusplus >= 201103L - _GLIBCXX20_CONSTEXPR - explicit - _Iter_comp_val(_Iter_comp_iter<_Compare>&& __comp) - : _M_comp(std::move(__comp._M_comp)) - { } -#endif - - template - _GLIBCXX20_CONSTEXPR - bool - operator()(_Iterator __it, _Value& __val) - { return bool(_M_comp(*__it, __val)); } + using _Fn = __by_ref_or_value_fn<_Func>; + + explicit constexpr + _Comp_with_val(_Fn __f, const _Value& __v) + : _M_f(__f), _M_val(__v) { } + + [[__no_unique_address__]] _Fn _M_f; + const _Value& _M_val; + + template + _GLIBCXX14_CONSTEXPR bool + operator()(_Tp&& __arg) + { +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wc++17-extensions" + if constexpr (_Val_2nd) + return _M_f(__arg, _M_val); + else + return _M_f(_M_val, __arg); +#pragma GCC diagnostic pop + } }; - template - _GLIBCXX20_CONSTEXPR - inline _Iter_comp_val<_Compare> - __iter_comp_val(_Compare __comp) - { return _Iter_comp_val<_Compare>(_GLIBCXX_MOVE(__comp)); } - - template - _GLIBCXX20_CONSTEXPR - inline _Iter_comp_val<_Compare> - __iter_comp_val(_Iter_comp_iter<_Compare> __comp) - { return _Iter_comp_val<_Compare>(_GLIBCXX_MOVE(__comp)); } + template + using _Comp_with_val_1st = _Comp_with_val<_Func, _Value, false>; + template + using _Comp_with_val_2nd = _Comp_with_val<_Func, _Value, true>; - template - struct _Val_comp_iter + template + struct _Unary_negate { - _Compare _M_comp; + using _Fn = __by_ref_or_value_fn<_Func>; - _GLIBCXX20_CONSTEXPR - explicit - _Val_comp_iter(_Compare __comp) - : _M_comp(_GLIBCXX_MOVE(__comp)) - { } - - _GLIBCXX20_CONSTEXPR - explicit - _Val_comp_iter(const _Iter_comp_iter<_Compare>& __comp) - : _M_comp(__comp._M_comp) - { } + explicit constexpr + _Unary_negate(_Fn __f) : _M_f(__f) { } -#if __cplusplus >= 201103L - _GLIBCXX20_CONSTEXPR - explicit - _Val_comp_iter(_Iter_comp_iter<_Compare>&& __comp) - : _M_comp(std::move(__comp._M_comp)) - { } -#endif + [[__no_unique_address__]] _Fn _M_f; - template - _GLIBCXX20_CONSTEXPR - bool - operator()(_Value& __val, _Iterator __it) - { return bool(_M_comp(__val, *__it)); } + template + _GLIBCXX14_CONSTEXPR bool + operator()(_Tp&& __arg) { return !_M_f(__arg); } }; - template - _GLIBCXX20_CONSTEXPR - inline _Val_comp_iter<_Compare> - __val_comp_iter(_Compare __comp) - { return _Val_comp_iter<_Compare>(_GLIBCXX_MOVE(__comp)); } + template + constexpr _Unary_negate<_Func> + not1(_Func& __f) + { return _Unary_negate<_Func>(__f); } - template - _GLIBCXX20_CONSTEXPR - inline _Val_comp_iter<_Compare> - __val_comp_iter(_Iter_comp_iter<_Compare> __comp) - { return _Val_comp_iter<_Compare>(_GLIBCXX_MOVE(__comp)); } +#else // <= C++11 - template - struct _Iter_equals_val - { - _Value& _M_value; + template + struct __by_ref_or_value_fn + : __conditional_type<__is_empty(_Fn), _Fn, _Fn&> + { }; - _GLIBCXX20_CONSTEXPR - explicit - _Iter_equals_val(_Value& __value) - : _M_value(__value) - { } - - template - _GLIBCXX20_CONSTEXPR - bool - operator()(_Iterator __it) - { return *__it == _M_value; } - }; + template + struct __by_ref_or_value_fn<_Fn*> + { typedef _Fn* __type; }; - template - _GLIBCXX20_CONSTEXPR - inline _Iter_equals_val<_Value> - __iter_equals_val(_Value& __val) - { return _Iter_equals_val<_Value>(__val); } + // We don't use std::binder1st, std::binder2nd, or std::unary_negate here + // because they require adaptable function objects, i.e. types with nested + // result_type and argument_type/first_argument_type/second_argument_type. - template - struct _Iter_equals_iter + template + struct _Comp_with_val_1st { - _Iterator1 _M_it1; + typedef typename __by_ref_or_value_fn<_Func>::__type _Fn; - _GLIBCXX20_CONSTEXPR explicit - _Iter_equals_iter(_Iterator1 __it1) - : _M_it1(__it1) - { } + _Comp_with_val_1st(_Fn __f, const _Value& __v) + : _M_f(__f), _M_val(__v) { } - template - _GLIBCXX20_CONSTEXPR - bool - operator()(_Iterator2 __it2) - { return *__it2 == *_M_it1; } - }; + _Fn _M_f; + const _Value& _M_val; - template - _GLIBCXX20_CONSTEXPR - inline _Iter_equals_iter<_Iterator> - __iter_comp_iter(_Iter_equal_to_iter, _Iterator __it) - { return _Iter_equals_iter<_Iterator>(__it); } + template + bool operator()(_Tp& __arg) { return _M_f(_M_val, __arg); } + template + bool operator()(const _Tp& __arg) { return _M_f(_M_val, __arg); } + }; - template - struct _Iter_pred + template + struct _Comp_with_val_2nd { - _Predicate _M_pred; + typedef typename __by_ref_or_value_fn<_Func>::__type _Fn; - _GLIBCXX20_CONSTEXPR explicit - _Iter_pred(_Predicate __pred) - : _M_pred(_GLIBCXX_MOVE(__pred)) - { } - - template - _GLIBCXX20_CONSTEXPR - bool - operator()(_Iterator __it) - { return bool(_M_pred(*__it)); } - }; + _Comp_with_val_2nd(_Fn __f, const _Value& __v) + : _M_f(__f), _M_val(__v) { } - template - _GLIBCXX20_CONSTEXPR - inline _Iter_pred<_Predicate> - __pred_iter(_Predicate __pred) - { return _Iter_pred<_Predicate>(_GLIBCXX_MOVE(__pred)); } + _Fn _M_f; + const _Value& _M_val; - template - struct _Iter_comp_to_val - { - _Compare _M_comp; - _Value& _M_value; - - _GLIBCXX20_CONSTEXPR - _Iter_comp_to_val(_Compare __comp, _Value& __value) - : _M_comp(_GLIBCXX_MOVE(__comp)), _M_value(__value) - { } - - template - _GLIBCXX20_CONSTEXPR - bool - operator()(_Iterator __it) - { return bool(_M_comp(*__it, _M_value)); } + template + bool operator()(_Tp& __arg) { return _M_f(__arg, _M_val); } + template + bool operator()(const _Tp& __arg) { return _M_f(__arg, _M_val); } }; - template - _Iter_comp_to_val<_Compare, _Value> - _GLIBCXX20_CONSTEXPR - __iter_comp_val(_Compare __comp, _Value &__val) + template + struct _Unary_negate_1 // N.B. different name for C++98 to satisfy ODR { - return _Iter_comp_to_val<_Compare, _Value>(_GLIBCXX_MOVE(__comp), __val); - } + typedef typename __by_ref_or_value_fn<_Func>::__type _Fn; - template - struct _Iter_comp_to_iter - { - _Compare _M_comp; - _Iterator1 _M_it1; + explicit _Unary_negate_1(_Fn __f) : _M_f(__f) { } - _GLIBCXX20_CONSTEXPR - _Iter_comp_to_iter(_Compare __comp, _Iterator1 __it1) - : _M_comp(_GLIBCXX_MOVE(__comp)), _M_it1(__it1) - { } + _Fn _M_f; - template - _GLIBCXX20_CONSTEXPR + template + bool + operator()(_Tp& __arg) { return !_M_f(__arg); } + template bool - operator()(_Iterator2 __it2) - { return bool(_M_comp(*__it2, *_M_it1)); } + operator()(const _Tp& __arg) { return !_M_f(__arg); } }; - template - _GLIBCXX20_CONSTEXPR - inline _Iter_comp_to_iter<_Compare, _Iterator> - __iter_comp_iter(_Iter_comp_iter<_Compare> __comp, _Iterator __it) - { - return _Iter_comp_to_iter<_Compare, _Iterator>( - _GLIBCXX_MOVE(__comp._M_comp), __it); - } + template + inline _Unary_negate_1<_Func> + not1(_Func& __f) + { return _Unary_negate_1<_Func>(__f); } +#endif - template - struct _Iter_negate - { - _Predicate _M_pred; + // N.B. these functions take lvalue references because we want to avoid + // returning a call wrapper that has a dangling reference to a prvalue. - _GLIBCXX20_CONSTEXPR - explicit - _Iter_negate(_Predicate __pred) - : _M_pred(_GLIBCXX_MOVE(__pred)) - { } + template + _GLIBCXX_CONSTEXPR inline _Comp_with_val_1st<_Func, _Value> + bind1st(_Func& __f, const _Value& __val) + { return _Comp_with_val_1st<_Func, _Value>(__f, __val); } - template - _GLIBCXX20_CONSTEXPR - bool - operator()(_Iterator __it) - { return !bool(_M_pred(*__it)); } - }; + template + _GLIBCXX_CONSTEXPR inline _Comp_with_val_2nd<_Func, _Value> + bind2nd(_Func& __f, const _Value& __val) + { return _Comp_with_val_2nd<_Func, _Value>(__f, __val); } - template - _GLIBCXX20_CONSTEXPR - inline _Iter_negate<_Predicate> - __negate(_Iter_pred<_Predicate> __pred) - { return _Iter_negate<_Predicate>(_GLIBCXX_MOVE(__pred._M_pred)); } + // Equivalent to bind2nd(equal_to{}, val) + template + _GLIBCXX_CONSTEXPR inline _Comp_with_val_2nd + __equal_to(const _Value& __val) + { return _Comp_with_val_2nd(equal_to(), __val); } } // namespace __ops } // namespace __gnu_cxx diff --git a/libstdc++-v3/include/bits/stl_algo.h b/libstdc++-v3/include/bits/stl_algo.h index b296e12cf0f8..7ff5dd84a97a 100644 --- a/libstdc++-v3/include/bits/stl_algo.h +++ b/libstdc++-v3/include/bits/stl_algo.h @@ -85,21 +85,21 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template _GLIBCXX20_CONSTEXPR void - __move_median_to_first(_Iterator __result,_Iterator __a, _Iterator __b, + __move_median_to_first(_Iterator __result, _Iterator __a, _Iterator __b, _Iterator __c, _Compare __comp) { - if (__comp(__a, __b)) + if (__comp(*__a, *__b)) { - if (__comp(__b, __c)) + if (__comp(*__b, *__c)) std::iter_swap(__result, __b); - else if (__comp(__a, __c)) + else if (__comp(*__a, *__c)) std::iter_swap(__result, __c); else std::iter_swap(__result, __a); } - else if (__comp(__a, __c)) + else if (__comp(*__a, *__c)) std::iter_swap(__result, __a); - else if (__comp(__b, __c)) + else if (__comp(*__b, *__c)) std::iter_swap(__result, __c); else std::iter_swap(__result, __b); @@ -113,7 +113,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION _Predicate __pred) { return std::__find_if(__first, __last, - __gnu_cxx::__ops::__negate(__pred)); + __gnu_cxx::__ops::not1(__pred)); } /// Like find_if_not(), but uses and updates a count of the @@ -125,7 +125,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION __find_if_not_n(_InputIterator __first, _Distance& __len, _Predicate __pred) { for (; __len; --__len, (void) ++__first) - if (!__pred(__first)) + if (!__pred(*__first)) break; return __first; } @@ -162,7 +162,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION __n = __count; _ForwardIterator __i = __first; ++__i; - while (__i != __last && __n != 1 && __unary_pred(__i)) + while (__i != __last && __n != 1 && __unary_pred(*__i)) { ++__i; --__n; @@ -201,7 +201,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION // __first here is always pointing to one past the last element of // next possible match. _RandomAccessIter __backTrack = __first; - while (__unary_pred(--__backTrack)) + while (__unary_pred(*--__backTrack)) { if (--__remainder == 0) return __first - _DistanceType(__count); // Success @@ -339,7 +339,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION return std::__find_end(__first1, __last1, __first2, __last2, std::__iterator_category(__first1), std::__iterator_category(__first2), - __gnu_cxx::__ops::__iter_equal_to_iter()); + __gnu_cxx::__ops::equal_to()); } /** @@ -390,7 +390,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION return std::__find_end(__first1, __last1, __first2, __last2, std::__iterator_category(__first1), std::__iterator_category(__first2), - __gnu_cxx::__ops::__iter_comp_iter(__comp)); + __comp); } #if __cplusplus >= 201103L @@ -470,8 +470,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate, typename iterator_traits<_InputIterator>::value_type>) __glibcxx_requires_valid_range(__first, __last); - return std::__find_if_not(__first, __last, - __gnu_cxx::__ops::__pred_iter(__pred)); + return std::__find_if_not(__first, __last, __pred); } /** @@ -551,7 +550,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION _OutputIterator __result, _Predicate __pred) { for (; __first != __last; ++__first) - if (!__pred(__first)) + if (!__pred(*__first)) { *__result = *__first; ++__result; @@ -588,7 +587,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION __glibcxx_requires_valid_range(__first, __last); return std::__remove_copy_if(__first, __last, __result, - __gnu_cxx::__ops::__iter_equals_val(__value)); + __gnu_cxx::__ops::__equal_to(__value)); } /** @@ -621,8 +620,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION typename iterator_traits<_InputIterator>::value_type>) __glibcxx_requires_valid_range(__first, __last); - return std::__remove_copy_if(__first, __last, __result, - __gnu_cxx::__ops::__pred_iter(__pred)); + return std::__remove_copy_if(__first, __last, __result, __pred); } #if __cplusplus >= 201103L @@ -780,7 +778,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION __glibcxx_requires_valid_range(__first, __last); return std::__remove_if(__first, __last, - __gnu_cxx::__ops::__iter_equals_val(__value)); + __gnu_cxx::__ops::__equal_to(__value)); } /** @@ -813,8 +811,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION typename iterator_traits<_ForwardIterator>::value_type>) __glibcxx_requires_valid_range(__first, __last); - return std::__remove_if(__first, __last, - __gnu_cxx::__ops::__pred_iter(__pred)); + return std::__remove_if(__first, __last, __pred); } template @@ -828,7 +825,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION _ForwardIterator __next = __first; while (++__next != __last) { - if (__binary_pred(__first, __next)) + if (__binary_pred(*__first, *__next)) return __first; __first = __next; } @@ -850,7 +847,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION _ForwardIterator __dest = __first; ++__first; while (++__first != __last) - if (!__binary_pred(__dest, __first)) + if (!__binary_pred(*__dest, *__first)) *++__dest = _GLIBCXX_MOVE(*__first); return ++__dest; } @@ -881,8 +878,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION typename iterator_traits<_ForwardIterator>::value_type>) __glibcxx_requires_valid_range(__first, __last); - return std::__unique(__first, __last, - __gnu_cxx::__ops::__iter_equal_to_iter()); + return std::__unique(__first, __last, __gnu_cxx::__ops::equal_to()); } /** @@ -914,8 +910,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION typename iterator_traits<_ForwardIterator>::value_type>) __glibcxx_requires_valid_range(__first, __last); - return std::__unique(__first, __last, - __gnu_cxx::__ops::__iter_comp_iter(__binary_pred)); + return std::__unique(__first, __last, __binary_pred); } // _GLIBCXX_RESOLVE_LIB_DEFECTS @@ -934,7 +929,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION _ForwardIterator __prev = __first; *__result = *__first; while (++__first != __last) - if (!__binary_pred(__prev, __first)) + if (!__binary_pred(*__prev, *__first)) { *++__result = *__first; __prev = __first; @@ -956,7 +951,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION _Val __value = *__first; *__result = __value; while (++__first != __last) - if (!__binary_pred(std::__addressof(__value), __first)) + if (!__binary_pred(__value, *__first)) { __value = *__first; *++__result = __value; @@ -975,7 +970,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION { *__result = *__first; while (++__first != __last) - if (!__binary_pred(__result, __first)) + if (!__binary_pred(*__result, *__first)) *++__result = *__first; return ++__result; } @@ -1445,10 +1440,10 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2) // partition /// This is a helper function... - /// Requires __first != __last and !__pred(__first) + /// Requires __first != __last and !__pred(*__first) /// and __len == distance(__first, __last). /// - /// !__pred(__first) allows us to guarantee that we don't + /// !__pred(*__first) allows us to guarantee that we don't /// move-assign an element onto itself. template @@ -1468,14 +1463,14 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2) _ForwardIterator __result1 = __first; _Pointer __result2 = __buffer; - // The precondition guarantees that !__pred(__first), so + // The precondition guarantees that !__pred(*__first), so // move that element to the buffer before starting the loop. // This ensures that we only call __pred once per element. *__result2 = _GLIBCXX_MOVE(*__first); ++__result2; ++__first; for (; __first != __last; ++__first) - if (__pred(__first)) + if (__pred(*__first)) { *__result1 = _GLIBCXX_MOVE(*__first); ++__result1; @@ -1581,8 +1576,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2) typename iterator_traits<_ForwardIterator>::value_type>) __glibcxx_requires_valid_range(__first, __last); - return std::__stable_partition(__first, __last, - __gnu_cxx::__ops::__pred_iter(__pred)); + return std::__stable_partition(__first, __last, __pred); } #endif // HOSTED @@ -1598,7 +1592,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2) { std::__make_heap(__first, __middle, __comp); for (_RandomAccessIterator __i = __middle; __i < __last; ++__i) - if (__comp(__i, __first)) + if (__comp(*__i, *__first)) std::__pop_heap(__first, __middle, __i, __comp); } @@ -1631,7 +1625,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2) std::__make_heap(__result_first, __result_real_last, __comp); while (__first != __last) { - if (__comp(__first, __result_first)) + if (__comp(*__first, *__result_first)) std::__adjust_heap(__result_first, _DistanceType(0), _DistanceType(__result_real_last - __result_first), @@ -1689,7 +1683,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2) return std::__partial_sort_copy(__first, __last, __result_first, __result_last, - __gnu_cxx::__ops::__iter_less_iter()); + __gnu_cxx::__ops::less()); } /** @@ -1744,7 +1738,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2) return std::__partial_sort_copy(__first, __last, __result_first, __result_last, - __gnu_cxx::__ops::__iter_comp_iter(__comp)); + __comp); } /// @cond undocumented @@ -1760,7 +1754,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2) __val = _GLIBCXX_MOVE(*__last); _RandomAccessIterator __next = __last; --__next; - while (__comp(__val, __next)) + while (__comp(__val, *__next)) { *__last = _GLIBCXX_MOVE(*__next); __last = __next; @@ -1784,15 +1778,14 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2) for (_RandomAccessIterator __i = __first + _Dist(1); __i != __last; ++__i) { - if (__comp(__i, __first)) + if (__comp(*__i, *__first)) { typename _IterTraits::value_type __val = _GLIBCXX_MOVE(*__i); _GLIBCXX_MOVE_BACKWARD3(__first, __i, __i + _Dist(1)); *__first = _GLIBCXX_MOVE(__val); } else - std::__unguarded_linear_insert(__i, - __gnu_cxx::__ops::__val_comp_iter(__comp)); + std::__unguarded_linear_insert(__i, __comp); } } @@ -1804,8 +1797,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2) _RandomAccessIterator __last, _Compare __comp) { for (_RandomAccessIterator __i = __first; __i != __last; ++__i) - std::__unguarded_linear_insert(__i, - __gnu_cxx::__ops::__val_comp_iter(__comp)); + std::__unguarded_linear_insert(__i, __comp); } /** @@ -1844,10 +1836,10 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2) { while (true) { - while (__comp(__first, __pivot)) + while (__comp(*__first, *__pivot)) ++__first; --__last; - while (__comp(__pivot, __last)) + while (__comp(*__pivot, *__last)) --__last; if (!(__first < __last)) return __first; @@ -1989,8 +1981,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2) __glibcxx_requires_partitioned_lower_pred(__first, __last, __val, __comp); - return std::__lower_bound(__first, __last, __val, - __gnu_cxx::__ops::__iter_comp_val(__comp)); + return std::__lower_bound(__first, __last, __val, __comp); } template @@ -2009,7 +2000,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2) _DistanceType __half = __len >> 1; _ForwardIterator __middle = __first; std::advance(__middle, __half); - if (__comp(__val, __middle)) + if (__comp(__val, *__middle)) __len = __half; else { @@ -2045,7 +2036,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2) __glibcxx_requires_partitioned_upper(__first, __last, __val); return std::__upper_bound(__first, __last, __val, - __gnu_cxx::__ops::__val_less_iter()); + __gnu_cxx::__ops::less()); } /** @@ -2076,17 +2067,14 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2) __glibcxx_requires_partitioned_upper_pred(__first, __last, __val, __comp); - return std::__upper_bound(__first, __last, __val, - __gnu_cxx::__ops::__val_comp_iter(__comp)); + return std::__upper_bound(__first, __last, __val, __comp); } - template + template _GLIBCXX20_CONSTEXPR pair<_ForwardIterator, _ForwardIterator> __equal_range(_ForwardIterator __first, _ForwardIterator __last, - const _Tp& __val, - _CompareItTp __comp_it_val, _CompareTpIt __comp_val_it) + const _Tp& __val, _Compare __comp) { typedef typename iterator_traits<_ForwardIterator>::difference_type _DistanceType; @@ -2098,21 +2086,21 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2) _DistanceType __half = __len >> 1; _ForwardIterator __middle = __first; std::advance(__middle, __half); - if (__comp_it_val(__middle, __val)) + if (__comp(*__middle, __val)) { __first = __middle; ++__first; __len = __len - __half - 1; } - else if (__comp_val_it(__val, __middle)) + else if (__comp(__val, *__middle)) __len = __half; else { _ForwardIterator __left - = std::__lower_bound(__first, __middle, __val, __comp_it_val); + = std::__lower_bound(__first, __middle, __val, __comp); std::advance(__first, __len); _ForwardIterator __right - = std::__upper_bound(++__middle, __first, __val, __comp_val_it); + = std::__upper_bound(++__middle, __first, __val, __comp); return pair<_ForwardIterator, _ForwardIterator>(__left, __right); } } @@ -2152,8 +2140,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2) __glibcxx_requires_partitioned_upper(__first, __last, __val); return std::__equal_range(__first, __last, __val, - __gnu_cxx::__ops::__iter_less_val(), - __gnu_cxx::__ops::__val_less_iter()); + __gnu_cxx::__ops::less()); } /** @@ -2190,9 +2177,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2) __glibcxx_requires_partitioned_upper_pred(__first, __last, __val, __comp); - return std::__equal_range(__first, __last, __val, - __gnu_cxx::__ops::__iter_comp_val(__comp), - __gnu_cxx::__ops::__val_comp_iter(__comp)); + return std::__equal_range(__first, __last, __val, __comp); } /** @@ -2221,8 +2206,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2) __glibcxx_requires_partitioned_upper(__first, __last, __val); _ForwardIterator __i - = std::__lower_bound(__first, __last, __val, - __gnu_cxx::__ops::__iter_less_val()); + = std::__lower_bound(__first, __last, __val, __gnu_cxx::__ops::less()); return __i != __last && !(__val < *__i); } @@ -2257,8 +2241,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2) __val, __comp); _ForwardIterator __i - = std::__lower_bound(__first, __last, __val, - __gnu_cxx::__ops::__iter_comp_val(__comp)); + = std::__lower_bound(__first, __last, __val, __comp); return __i != __last && !bool(__comp(__val, *__i)); } @@ -2274,7 +2257,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2) { while (__first1 != __last1 && __first2 != __last2) { - if (__comp(__first2, __first1)) + if (__comp(*__first2, *__first1)) { *__result = _GLIBCXX_MOVE(*__first2); ++__first2; @@ -2313,7 +2296,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2) --__last2; while (true) { - if (__comp(__last2, __last1)) + if (__comp(*__last2, *__last1)) { *--__result = _GLIBCXX_MOVE(*__last1); if (__first1 == __last1) @@ -2419,8 +2402,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2) __len11 = __len1 / 2; std::advance(__first_cut, __len11); __second_cut - = std::__lower_bound(__middle, __last, *__first_cut, - __gnu_cxx::__ops::__iter_comp_val(__comp)); + = std::__lower_bound(__middle, __last, *__first_cut, __comp); __len22 = std::distance(__middle, __second_cut); } else @@ -2428,8 +2410,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2) __len22 = __len2 / 2; std::advance(__second_cut, __len22); __first_cut - = std::__upper_bound(__first, __middle, *__second_cut, - __gnu_cxx::__ops::__val_comp_iter(__comp)); + = std::__upper_bound(__first, __middle, *__second_cut, __comp); __len11 = std::distance(__first, __first_cut); } @@ -2463,7 +2444,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2) if (__len1 + __len2 == 2) { - if (__comp(__middle, __first)) + if (__comp(*__middle, *__first)) std::iter_swap(__first, __middle); return; } @@ -2477,8 +2458,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2) __len11 = __len1 / 2; std::advance(__first_cut, __len11); __second_cut - = std::__lower_bound(__middle, __last, *__first_cut, - __gnu_cxx::__ops::__iter_comp_val(__comp)); + = std::__lower_bound(__middle, __last, *__first_cut, __comp); __len22 = std::distance(__middle, __second_cut); } else @@ -2486,8 +2466,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2) __len22 = __len2 / 2; std::advance(__second_cut, __len22); __first_cut - = std::__upper_bound(__first, __middle, *__second_cut, - __gnu_cxx::__ops::__val_comp_iter(__comp)); + = std::__upper_bound(__first, __middle, *__second_cut, __comp); __len11 = std::distance(__first, __first_cut); } @@ -2581,7 +2560,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2) __glibcxx_requires_irreflexive(__first, __last); std::__inplace_merge(__first, __middle, __last, - __gnu_cxx::__ops::__iter_less_iter()); + __gnu_cxx::__ops::less()); } /** @@ -2624,8 +2603,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2) __glibcxx_requires_sorted_pred(__middle, __last, __comp); __glibcxx_requires_irreflexive_pred(__first, __last, __comp); - std::__inplace_merge(__first, __middle, __last, - __gnu_cxx::__ops::__iter_comp_iter(__comp)); + std::__inplace_merge(__first, __middle, __last, __comp); } @@ -2639,7 +2617,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2) { while (__first1 != __last1 && __first2 != __last2) { - if (__comp(__first2, __first1)) + if (__comp(*__first2, *__first1)) { *__result = _GLIBCXX_MOVE(*__first2); ++__first2; @@ -2804,9 +2782,9 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2) { while (__first1 != __last1 && __first2 != __last2) { - if (__comp(__first2, __first1)) + if (__comp(*__first2, *__first1)) return false; - if (!__comp(__first1, __first2)) + if (!__comp(*__first1, *__first2)) ++__first2; ++__first1; } @@ -2853,7 +2831,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2) __glibcxx_requires_irreflexive2(__first2, __last2); return std::__includes(__first1, __last1, __first2, __last2, - __gnu_cxx::__ops::__iter_less_iter()); + __gnu_cxx::__ops::less()); } /** @@ -2899,8 +2877,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2) __glibcxx_requires_irreflexive_pred2(__first1, __last1, __comp); __glibcxx_requires_irreflexive_pred2(__first2, __last2, __comp); - return std::__includes(__first1, __last1, __first2, __last2, - __gnu_cxx::__ops::__iter_comp_iter(__comp)); + return std::__includes(__first1, __last1, __first2, __last2, __comp); } // nth_element @@ -2932,10 +2909,10 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2) { _BidirectionalIterator __ii = __i; --__i; - if (__comp(__i, __ii)) + if (__comp(*__i, *__ii)) { _BidirectionalIterator __j = __last; - while (!__comp(__i, --__j)) + while (!__comp(*__i, *--__j)) {} std::iter_swap(__i, __j); std::__reverse(__ii, __last, @@ -2977,8 +2954,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2) __glibcxx_requires_valid_range(__first, __last); __glibcxx_requires_irreflexive(__first, __last); - return std::__next_permutation - (__first, __last, __gnu_cxx::__ops::__iter_less_iter()); + return std::__next_permutation(__first, __last, __gnu_cxx::__ops::less()); } /** @@ -3011,8 +2987,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2) __glibcxx_requires_valid_range(__first, __last); __glibcxx_requires_irreflexive_pred(__first, __last, __comp); - return std::__next_permutation - (__first, __last, __gnu_cxx::__ops::__iter_comp_iter(__comp)); + return std::__next_permutation(__first, __last, __comp); } template @@ -3034,10 +3009,10 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2) { _BidirectionalIterator __ii = __i; --__i; - if (__comp(__ii, __i)) + if (__comp(*__ii, *__i)) { _BidirectionalIterator __j = __last; - while (!__comp(--__j, __i)) + while (!__comp(*--__j, *__i)) {} std::iter_swap(__i, __j); std::__reverse(__ii, __last, @@ -3080,8 +3055,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2) __glibcxx_requires_valid_range(__first, __last); __glibcxx_requires_irreflexive(__first, __last); - return std::__prev_permutation(__first, __last, - __gnu_cxx::__ops::__iter_less_iter()); + return std::__prev_permutation(__first, __last, __gnu_cxx::__ops::less()); } /** @@ -3114,8 +3088,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2) __glibcxx_requires_valid_range(__first, __last); __glibcxx_requires_irreflexive_pred(__first, __last, __comp); - return std::__prev_permutation(__first, __last, - __gnu_cxx::__ops::__iter_comp_iter(__comp)); + return std::__prev_permutation(__first, __last, __comp); } // replace @@ -3130,7 +3103,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2) _Predicate __pred, const _Tp& __new_value) { for (; __first != __last; ++__first, (void)++__result) - if (__pred(__first)) + if (__pred(*__first)) *__result = __new_value; else *__result = *__first; @@ -3167,8 +3140,8 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2) __glibcxx_requires_valid_range(__first, __last); return std::__replace_copy_if(__first, __last, __result, - __gnu_cxx::__ops::__iter_equals_val(__old_value), - __new_value); + __gnu_cxx::__ops::__equal_to(__old_value), + __new_value); } /** @@ -3202,9 +3175,8 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2) typename iterator_traits<_InputIterator>::value_type>) __glibcxx_requires_valid_range(__first, __last); - return std::__replace_copy_if(__first, __last, __result, - __gnu_cxx::__ops::__pred_iter(__pred), - __new_value); + return std::__replace_copy_if(__first, __last, __result, __pred, + __new_value); } #if __cplusplus >= 201103L @@ -3248,7 +3220,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2) _ForwardIterator __next = __first; for (++__next; __next != __last; __first = __next, (void)++__next) - if (__comp(__next, __first)) + if (__comp(*__next, *__first)) return __next; return __next; } @@ -3274,7 +3246,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2) __glibcxx_requires_irreflexive(__first, __last); return std::__is_sorted_until(__first, __last, - __gnu_cxx::__ops::__iter_less_iter()); + __gnu_cxx::__ops::less()); } /** @@ -3300,8 +3272,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2) __glibcxx_requires_valid_range(__first, __last); __glibcxx_requires_irreflexive_pred(__first, __last, __comp); - return std::__is_sorted_until(__first, __last, - __gnu_cxx::__ops::__iter_comp_iter(__comp)); + return std::__is_sorted_until(__first, __last, __comp); } /** @@ -3354,7 +3325,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2) return std::make_pair(__first, __first); _ForwardIterator __min{}, __max{}; - if (__comp(__next, __first)) + if (__comp(*__next, *__first)) { __min = __next; __max = __first; @@ -3373,25 +3344,25 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2) __next = __first; if (++__next == __last) { - if (__comp(__first, __min)) + if (__comp(*__first, *__min)) __min = __first; - else if (!__comp(__first, __max)) + else if (!__comp(*__first, *__max)) __max = __first; break; } - if (__comp(__next, __first)) + if (__comp(*__next, *__first)) { - if (__comp(__next, __min)) + if (__comp(*__next, *__min)) __min = __next; - if (!__comp(__first, __max)) + if (!__comp(*__first, *__max)) __max = __first; } else { - if (__comp(__first, __min)) + if (__comp(*__first, *__min)) __min = __first; - if (!__comp(__next, __max)) + if (!__comp(*__next, *__max)) __max = __next; } @@ -3425,8 +3396,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2) __glibcxx_requires_valid_range(__first, __last); __glibcxx_requires_irreflexive(__first, __last); - return std::__minmax_element(__first, __last, - __gnu_cxx::__ops::__iter_less_iter()); + return std::__minmax_element(__first, __last, __gnu_cxx::__ops::less()); } /** @@ -3455,8 +3425,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2) __glibcxx_requires_valid_range(__first, __last); __glibcxx_requires_irreflexive_pred(__first, __last, __comp); - return std::__minmax_element(__first, __last, - __gnu_cxx::__ops::__iter_comp_iter(__comp)); + return std::__minmax_element(__first, __last, __comp); } template @@ -3467,7 +3436,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2) __glibcxx_requires_irreflexive(__l.begin(), __l.end()); pair __p = std::__minmax_element(__l.begin(), __l.end(), - __gnu_cxx::__ops::__iter_less_iter()); + __gnu_cxx::__ops::less()); return std::make_pair(*__p.first, *__p.second); } @@ -3478,8 +3447,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2) { __glibcxx_requires_irreflexive_pred(__l.begin(), __l.end(), __comp); pair __p = - std::__minmax_element(__l.begin(), __l.end(), - __gnu_cxx::__ops::__iter_comp_iter(__comp)); + std::__minmax_element(__l.begin(), __l.end(), __comp); return std::make_pair(*__p.first, *__p.second); } @@ -3512,8 +3480,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2) typename iterator_traits<_ForwardIterator2>::value_type>) __glibcxx_requires_valid_range(__first1, __last1); - return std::__is_permutation(__first1, __last1, __first2, - __gnu_cxx::__ops::__iter_comp_iter(__pred)); + return std::__is_permutation(__first1, __last1, __first2, __pred); } #if __glibcxx_robust_nonmodifying_seq_ops // C++ >= 14 @@ -3544,7 +3511,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2) // have the same elements in the same order. for (; __first1 != __last1 && __first2 != __last2; ++__first1, (void)++__first2) - if (!__pred(__first1, __first2)) + if (!__pred(*__first1, *__first2)) break; if constexpr (__ra_iters) @@ -3565,14 +3532,16 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2) for (_ForwardIterator1 __scan = __first1; __scan != __last1; ++__scan) { if (__scan != std::__find_if(__first1, __scan, - __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan))) + __gnu_cxx::__ops::bind1st(__pred, + *__scan))) continue; // We've seen this one before. auto __matches = std::__count_if(__first2, __last2, - __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan)); + __gnu_cxx::__ops::bind1st(__pred, + *__scan)); if (0 == __matches || std::__count_if(__scan, __last1, - __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan)) + __gnu_cxx::__ops::bind1st(__pred, *__scan)) != __matches) return false; } @@ -3602,9 +3571,8 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2) __glibcxx_requires_valid_range(__first1, __last1); __glibcxx_requires_valid_range(__first2, __last2); - return - std::__is_permutation(__first1, __last1, __first2, __last2, - __gnu_cxx::__ops::__iter_equal_to_iter()); + return std::__is_permutation(__first1, __last1, __first2, __last2, + __gnu_cxx::__ops::equal_to()); } /** @@ -3633,7 +3601,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2) __glibcxx_requires_valid_range(__first2, __last2); return std::__is_permutation(__first1, __last1, __first2, __last2, - __gnu_cxx::__ops::__iter_comp_iter(__pred)); + __pred); } #endif // __glibcxx_robust_nonmodifying_seq_ops @@ -3912,7 +3880,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO #endif return std::__find_if(__first, __last, - __gnu_cxx::__ops::__iter_equals_val(__val)); + __gnu_cxx::__ops::__equal_to(__val)); } /** @@ -3937,8 +3905,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO typename iterator_traits<_InputIterator>::value_type>) __glibcxx_requires_valid_range(__first, __last); - return std::__find_if(__first, __last, - __gnu_cxx::__ops::__pred_iter(__pred)); + return std::__find_if(__first, __last, __pred); } /** @@ -4043,7 +4010,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO __glibcxx_requires_valid_range(__first, __last); return std::__adjacent_find(__first, __last, - __gnu_cxx::__ops::__iter_equal_to_iter()); + __gnu_cxx::__ops::equal_to()); } /** @@ -4070,8 +4037,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO typename iterator_traits<_ForwardIterator>::value_type>) __glibcxx_requires_valid_range(__first, __last); - return std::__adjacent_find(__first, __last, - __gnu_cxx::__ops::__iter_comp_iter(__binary_pred)); + return std::__adjacent_find(__first, __last, __binary_pred); } /** @@ -4095,7 +4061,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO __glibcxx_requires_valid_range(__first, __last); return std::__count_if(__first, __last, - __gnu_cxx::__ops::__iter_equals_val(__value)); + __gnu_cxx::__ops::__equal_to(__value)); } /** @@ -4118,8 +4084,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO typename iterator_traits<_InputIterator>::value_type>) __glibcxx_requires_valid_range(__first, __last); - return std::__count_if(__first, __last, - __gnu_cxx::__ops::__pred_iter(__pred)); + return std::__count_if(__first, __last, __pred); } /** @@ -4164,7 +4129,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO __glibcxx_requires_valid_range(__first2, __last2); return std::__search(__first1, __last1, __first2, __last2, - __gnu_cxx::__ops::__iter_equal_to_iter()); + __gnu_cxx::__ops::equal_to()); } /** @@ -4195,7 +4160,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO __glibcxx_requires_valid_range(__first, __last); return std::__search_n(__first, __last, __count, - __gnu_cxx::__ops::__iter_equals_val(__val)); + __gnu_cxx::__ops::__equal_to(__val)); } @@ -4231,7 +4196,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO __glibcxx_requires_valid_range(__first, __last); return std::__search_n(__first, __last, __count, - __gnu_cxx::__ops::__iter_comp_val(__binary_pred, __val)); + __gnu_cxx::__ops::bind2nd(__binary_pred, __val)); } #if __cplusplus >= 201703L @@ -4488,7 +4453,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO if (__first == __last) return __result; return std::__unique_copy(__first, __last, __result, - __gnu_cxx::__ops::__iter_equal_to_iter(), + __gnu_cxx::__ops::equal_to(), std::__iterator_category(__first)); } @@ -4529,8 +4494,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO if (__first == __last) return __result; - return std::__unique_copy(__first, __last, __result, - __gnu_cxx::__ops::__iter_comp_iter(__binary_pred), + return std::__unique_copy(__first, __last, __result, __binary_pred, std::__iterator_category(__first)); } @@ -4717,7 +4681,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO __glibcxx_requires_irreflexive(__first, __last); std::__partial_sort(__first, __middle, __last, - __gnu_cxx::__ops::__iter_less_iter()); + __gnu_cxx::__ops::less()); } /** @@ -4757,8 +4721,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO __glibcxx_requires_valid_range(__middle, __last); __glibcxx_requires_irreflexive_pred(__first, __last, __comp); - std::__partial_sort(__first, __middle, __last, - __gnu_cxx::__ops::__iter_comp_iter(__comp)); + std::__partial_sort(__first, __middle, __last, __comp); } /** @@ -4796,7 +4759,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO std::__introselect(__first, __nth, __last, std::__lg(__last - __first) * 2, - __gnu_cxx::__ops::__iter_less_iter()); + __gnu_cxx::__ops::less()); } /** @@ -4837,7 +4800,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO std::__introselect(__first, __nth, __last, std::__lg(__last - __first) * 2, - __gnu_cxx::__ops::__iter_comp_iter(__comp)); + __comp); } /** @@ -4867,7 +4830,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO __glibcxx_requires_valid_range(__first, __last); __glibcxx_requires_irreflexive(__first, __last); - std::__sort(__first, __last, __gnu_cxx::__ops::__iter_less_iter()); + std::__sort(__first, __last, __gnu_cxx::__ops::less()); } /** @@ -4900,7 +4863,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO __glibcxx_requires_valid_range(__first, __last); __glibcxx_requires_irreflexive_pred(__first, __last, __comp); - std::__sort(__first, __last, __gnu_cxx::__ops::__iter_comp_iter(__comp)); + std::__sort(__first, __last, __comp); } template @@ -5098,7 +5059,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO __glibcxx_requires_irreflexive(__first, __last); _GLIBCXX_STD_A::__stable_sort(__first, __last, - __gnu_cxx::__ops::__iter_less_iter()); + __gnu_cxx::__ops::less()); } /** @@ -5134,13 +5095,11 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO __glibcxx_requires_valid_range(__first, __last); __glibcxx_requires_irreflexive_pred(__first, __last, __comp); - _GLIBCXX_STD_A::__stable_sort(__first, __last, - __gnu_cxx::__ops::__iter_comp_iter(__comp)); + _GLIBCXX_STD_A::__stable_sort(__first, __last, __comp); } template + typename _OutputIterator, typename _Compare> _GLIBCXX20_CONSTEXPR _OutputIterator __set_union(_InputIterator1 __first1, _InputIterator1 __last1, @@ -5149,12 +5108,12 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO { while (__first1 != __last1 && __first2 != __last2) { - if (__comp(__first1, __first2)) + if (__comp(*__first1, *__first2)) { *__result = *__first1; ++__first1; } - else if (__comp(__first2, __first1)) + else if (__comp(*__first2, *__first1)) { *__result = *__first2; ++__first2; @@ -5216,9 +5175,8 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO __glibcxx_requires_irreflexive2(__first1, __last1); __glibcxx_requires_irreflexive2(__first2, __last2); - return _GLIBCXX_STD_A::__set_union(__first1, __last1, - __first2, __last2, __result, - __gnu_cxx::__ops::__iter_less_iter()); + return _GLIBCXX_STD_A::__set_union(__first1, __last1, __first2, __last2, + __result, __gnu_cxx::__ops::less()); } /** @@ -5267,14 +5225,12 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO __glibcxx_requires_irreflexive_pred2(__first1, __last1, __comp); __glibcxx_requires_irreflexive_pred2(__first2, __last2, __comp); - return _GLIBCXX_STD_A::__set_union(__first1, __last1, - __first2, __last2, __result, - __gnu_cxx::__ops::__iter_comp_iter(__comp)); + return _GLIBCXX_STD_A::__set_union(__first1, __last1, __first2, __last2, + __result, __comp); } template + typename _OutputIterator, typename _Compare> _GLIBCXX20_CONSTEXPR _OutputIterator __set_intersection(_InputIterator1 __first1, _InputIterator1 __last1, @@ -5282,9 +5238,9 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO _OutputIterator __result, _Compare __comp) { while (__first1 != __last1 && __first2 != __last2) - if (__comp(__first1, __first2)) + if (__comp(*__first1, *__first2)) ++__first1; - else if (__comp(__first2, __first1)) + else if (__comp(*__first2, *__first1)) ++__first2; else { @@ -5338,9 +5294,9 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO __glibcxx_requires_irreflexive2(__first1, __last1); __glibcxx_requires_irreflexive2(__first2, __last2); - return _GLIBCXX_STD_A::__set_intersection(__first1, __last1, - __first2, __last2, __result, - __gnu_cxx::__ops::__iter_less_iter()); + return _GLIBCXX_STD_A:: + __set_intersection(__first1, __last1, __first2, __last2, + __result, __gnu_cxx::__ops::less()); } /** @@ -5388,14 +5344,13 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO __glibcxx_requires_irreflexive_pred2(__first1, __last1, __comp); __glibcxx_requires_irreflexive_pred2(__first2, __last2, __comp); - return _GLIBCXX_STD_A::__set_intersection(__first1, __last1, - __first2, __last2, __result, - __gnu_cxx::__ops::__iter_comp_iter(__comp)); + return _GLIBCXX_STD_A:: + __set_intersection(__first1, __last1, __first2, __last2, + __result, __comp); } template + typename _OutputIterator, typename _Compare> _GLIBCXX20_CONSTEXPR _OutputIterator __set_difference(_InputIterator1 __first1, _InputIterator1 __last1, @@ -5403,13 +5358,13 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO _OutputIterator __result, _Compare __comp) { while (__first1 != __last1 && __first2 != __last2) - if (__comp(__first1, __first2)) + if (__comp(*__first1, *__first2)) { *__result = *__first1; ++__first1; ++__result; } - else if (__comp(__first2, __first1)) + else if (__comp(*__first2, *__first1)) ++__first2; else { @@ -5463,9 +5418,9 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO __glibcxx_requires_irreflexive2(__first1, __last1); __glibcxx_requires_irreflexive2(__first2, __last2); - return _GLIBCXX_STD_A::__set_difference(__first1, __last1, - __first2, __last2, __result, - __gnu_cxx::__ops::__iter_less_iter()); + return _GLIBCXX_STD_A:: + __set_difference(__first1, __last1, __first2, __last2, __result, + __gnu_cxx::__ops::less()); } /** @@ -5515,9 +5470,9 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO __glibcxx_requires_irreflexive_pred2(__first1, __last1, __comp); __glibcxx_requires_irreflexive_pred2(__first2, __last2, __comp); - return _GLIBCXX_STD_A::__set_difference(__first1, __last1, - __first2, __last2, __result, - __gnu_cxx::__ops::__iter_comp_iter(__comp)); + return _GLIBCXX_STD_A:: + __set_difference(__first1, __last1, __first2, __last2, __result, + __comp); } template @@ -5666,7 +5621,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO return __first; _ForwardIterator __result = __first; while (++__first != __last) - if (__comp(__first, __result)) + if (__comp(*__first, *__result)) __result = __first; return __result; } @@ -5680,8 +5635,8 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO */ template _GLIBCXX_NODISCARD _GLIBCXX14_CONSTEXPR - _ForwardIterator - inline min_element(_ForwardIterator __first, _ForwardIterator __last) + inline _ForwardIterator + min_element(_ForwardIterator __first, _ForwardIterator __last) { // concept requirements __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>) @@ -5691,7 +5646,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO __glibcxx_requires_irreflexive(__first, __last); return _GLIBCXX_STD_A::__min_element(__first, __last, - __gnu_cxx::__ops::__iter_less_iter()); + __gnu_cxx::__ops::less()); } /** @@ -5717,8 +5672,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO __glibcxx_requires_valid_range(__first, __last); __glibcxx_requires_irreflexive_pred(__first, __last, __comp); - return _GLIBCXX_STD_A::__min_element(__first, __last, - __gnu_cxx::__ops::__iter_comp_iter(__comp)); + return _GLIBCXX_STD_A::__min_element(__first, __last, __comp); } template @@ -5730,7 +5684,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO if (__first == __last) return __first; _ForwardIterator __result = __first; while (++__first != __last) - if (__comp(__result, __first)) + if (__comp(*__result, *__first)) __result = __first; return __result; } @@ -5755,7 +5709,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO __glibcxx_requires_irreflexive(__first, __last); return _GLIBCXX_STD_A::__max_element(__first, __last, - __gnu_cxx::__ops::__iter_less_iter()); + __gnu_cxx::__ops::less()); } /** @@ -5781,8 +5735,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO __glibcxx_requires_valid_range(__first, __last); __glibcxx_requires_irreflexive_pred(__first, __last, __comp); - return _GLIBCXX_STD_A::__max_element(__first, __last, - __gnu_cxx::__ops::__iter_comp_iter(__comp)); + return _GLIBCXX_STD_A::__max_element(__first, __last, __comp); } #if __cplusplus >= 201103L @@ -5794,7 +5747,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO { __glibcxx_requires_irreflexive(__l.begin(), __l.end()); return *_GLIBCXX_STD_A::__min_element(__l.begin(), __l.end(), - __gnu_cxx::__ops::__iter_less_iter()); + __gnu_cxx::__ops::less()); } template @@ -5803,8 +5756,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO min(initializer_list<_Tp> __l, _Compare __comp) { __glibcxx_requires_irreflexive_pred(__l.begin(), __l.end(), __comp); - return *_GLIBCXX_STD_A::__min_element(__l.begin(), __l.end(), - __gnu_cxx::__ops::__iter_comp_iter(__comp)); + return *_GLIBCXX_STD_A::__min_element(__l.begin(), __l.end(), __comp); } template @@ -5814,7 +5766,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO { __glibcxx_requires_irreflexive(__l.begin(), __l.end()); return *_GLIBCXX_STD_A::__max_element(__l.begin(), __l.end(), - __gnu_cxx::__ops::__iter_less_iter()); + __gnu_cxx::__ops::less()); } template @@ -5823,8 +5775,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO max(initializer_list<_Tp> __l, _Compare __comp) { __glibcxx_requires_irreflexive_pred(__l.begin(), __l.end(), __comp); - return *_GLIBCXX_STD_A::__max_element(__l.begin(), __l.end(), - __gnu_cxx::__ops::__iter_comp_iter(__comp)); + return *_GLIBCXX_STD_A::__max_element(__l.begin(), __l.end(), __comp); } #endif // C++11 diff --git a/libstdc++-v3/include/bits/stl_algobase.h b/libstdc++-v3/include/bits/stl_algobase.h index 022668076138..03f64fb3e6c3 100644 --- a/libstdc++-v3/include/bits/stl_algobase.h +++ b/libstdc++-v3/include/bits/stl_algobase.h @@ -1340,9 +1340,9 @@ _GLIBCXX_END_NAMESPACE_CONTAINER for (; __first1 != __last1 && __rai_type::__cnd2(__first2, __last2); ++__first1, (void)++__first2) { - if (__comp(__first1, __first2)) + if (__comp(*__first1, *__first2)) return true; - if (__comp(__first2, __first1)) + if (__comp(*__first2, *__first1)) return false; } return __first1 == __last1 && __first2 != __last2; @@ -1356,10 +1356,10 @@ _GLIBCXX_END_NAMESPACE_CONTAINER static bool __lc(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2) { - using __gnu_cxx::__ops::__iter_less_iter; + using __gnu_cxx::__ops::less; return std::__lexicographical_compare_impl(__first1, __last1, __first2, __last2, - __iter_less_iter()); + less()); } template @@ -1515,7 +1515,7 @@ _GLIBCXX_END_NAMESPACE_CONTAINER _DistanceType __half = __len >> 1; _ForwardIterator __middle = __first; std::advance(__middle, __half); - if (__comp(__middle, __val)) + if (__comp(*__middle, __val)) { __first = __middle; ++__first; @@ -1551,7 +1551,7 @@ _GLIBCXX_END_NAMESPACE_CONTAINER __glibcxx_requires_partitioned_lower(__first, __last, __val); return std::__lower_bound(__first, __last, __val, - __gnu_cxx::__ops::__iter_less_val()); + __gnu_cxx::__ops::less()); } /// This is a helper function for the sort routines and for random.tcc. @@ -1825,8 +1825,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO __glibcxx_requires_valid_range(__first2, __last2); return std::__lexicographical_compare_impl - (__first1, __last1, __first2, __last2, - __gnu_cxx::__ops::__iter_comp_iter(__comp)); + (__first1, __last1, __first2, __last2, __comp); } #if __cpp_lib_three_way_comparison @@ -1934,7 +1933,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO __mismatch(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _BinaryPredicate __binary_pred) { - while (__first1 != __last1 && __binary_pred(__first1, __first2)) + while (__first1 != __last1 && __binary_pred(*__first1, *__first2)) { ++__first1; ++__first2; @@ -1970,7 +1969,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO __glibcxx_requires_valid_range(__first1, __last1); return _GLIBCXX_STD_A::__mismatch(__first1, __last1, __first2, - __gnu_cxx::__ops::__iter_equal_to_iter()); + __gnu_cxx::__ops::equal_to()); } /** @@ -2002,7 +2001,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO __glibcxx_requires_valid_range(__first1, __last1); return _GLIBCXX_STD_A::__mismatch(__first1, __last1, __first2, - __gnu_cxx::__ops::__iter_comp_iter(__binary_pred)); + __binary_pred); } #if __glibcxx_robust_nonmodifying_seq_ops // C++ >= 14 @@ -2015,7 +2014,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO _BinaryPredicate __binary_pred) { while (__first1 != __last1 && __first2 != __last2 - && __binary_pred(__first1, __first2)) + && __binary_pred(*__first1, *__first2)) { ++__first1; ++__first2; @@ -2053,7 +2052,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO __glibcxx_requires_valid_range(__first2, __last2); return _GLIBCXX_STD_A::__mismatch(__first1, __last1, __first2, __last2, - __gnu_cxx::__ops::__iter_equal_to_iter()); + __gnu_cxx::__ops::equal_to()); } /** @@ -2088,7 +2087,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO __glibcxx_requires_valid_range(__first2, __last2); return _GLIBCXX_STD_A::__mismatch(__first1, __last1, __first2, __last2, - __gnu_cxx::__ops::__iter_comp_iter(__binary_pred)); + __binary_pred); } #endif // __glibcxx_robust_nonmodifying_seq_ops @@ -2101,7 +2100,7 @@ _GLIBCXX_END_NAMESPACE_ALGO __find_if(_Iterator __first, _Iterator __last, _Predicate __pred) { #pragma GCC unroll 4 - while (__first != __last && !__pred(__first)) + while (__first != __last && !__pred(*__first)) ++__first; return __first; } @@ -2113,7 +2112,7 @@ _GLIBCXX_END_NAMESPACE_ALGO { typename iterator_traits<_InputIterator>::difference_type __n = 0; for (; __first != __last; ++__first) - if (__pred(__first)) + if (__pred(*__first)) ++__n; return __n; } @@ -2130,7 +2129,7 @@ _GLIBCXX_END_NAMESPACE_ALGO _ForwardIterator __result = __first; ++__first; for (; __first != __last; ++__first) - if (!__pred(__first)) + if (!__pred(*__first)) { *__result = _GLIBCXX_MOVE(*__first); ++__result; @@ -2154,7 +2153,8 @@ _GLIBCXX_END_NAMESPACE_ALGO _ForwardIterator2 __p1(__first2); if (++__p1 == __last2) return std::__find_if(__first1, __last1, - __gnu_cxx::__ops::__iter_comp_iter(__predicate, __first2)); + __gnu_cxx::__ops::bind2nd(__predicate, + *__first2)); // General case. _ForwardIterator1 __current = __first1; @@ -2163,7 +2163,7 @@ _GLIBCXX_END_NAMESPACE_ALGO { __first1 = std::__find_if(__first1, __last1, - __gnu_cxx::__ops::__iter_comp_iter(__predicate, __first2)); + __gnu_cxx::__ops::bind2nd(__predicate, *__first2)); if (__first1 == __last1) return __last1; @@ -2173,7 +2173,7 @@ _GLIBCXX_END_NAMESPACE_ALGO if (++__current == __last1) return __last1; - while (__predicate(__current, __p)) + while (__predicate(*__current, *__p)) { if (++__p == __last2) return __first1; @@ -2196,7 +2196,7 @@ _GLIBCXX_END_NAMESPACE_ALGO // Efficiently compare identical prefixes: O(N) if sequences // have the same elements in the same order. for (; __first1 != __last1; ++__first1, (void)++__first2) - if (!__pred(__first1, __first2)) + if (!__pred(*__first1, *__first2)) break; if (__first1 == __last1) @@ -2209,15 +2209,16 @@ _GLIBCXX_END_NAMESPACE_ALGO for (_ForwardIterator1 __scan = __first1; __scan != __last1; ++__scan) { if (__scan != std::__find_if(__first1, __scan, - __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan))) + __gnu_cxx::__ops::bind1st(__pred, + *__scan))) continue; // We've seen this one before. auto __matches = std::__count_if(__first2, __last2, - __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan)); + __gnu_cxx::__ops::bind1st(__pred, *__scan)); if (0 == __matches || std::__count_if(__scan, __last1, - __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan)) + __gnu_cxx::__ops::bind1st(__pred, *__scan)) != __matches) return false; } @@ -2251,7 +2252,7 @@ _GLIBCXX_END_NAMESPACE_ALGO __glibcxx_requires_valid_range(__first1, __last1); return std::__is_permutation(__first1, __last1, __first2, - __gnu_cxx::__ops::__iter_equal_to_iter()); + __gnu_cxx::__ops::equal_to()); } #endif // C++11 @@ -2295,8 +2296,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO __glibcxx_requires_valid_range(__first1, __last1); __glibcxx_requires_valid_range(__first2, __last2); - return std::__search(__first1, __last1, __first2, __last2, - __gnu_cxx::__ops::__iter_comp_iter(__predicate)); + return std::__search(__first1, __last1, __first2, __last2, __predicate); } _GLIBCXX_END_NAMESPACE_ALGO diff --git a/libstdc++-v3/include/bits/stl_function.h b/libstdc++-v3/include/bits/stl_function.h index 136fd01c9847..ff3f8f4c6e79 100644 --- a/libstdc++-v3/include/bits/stl_function.h +++ b/libstdc++-v3/include/bits/stl_function.h @@ -762,6 +762,58 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION is_convertible<_Tp, const volatile void*>, is_convertible<_Up, const volatile void*>>; }; +#else // < C++14 + + // We need less and equal_to for + + template<> + struct equal_to + { +#ifdef __cpp_rvalue_references + template + bool + operator()(_Tp&& __t, _Up&& __u) const + { return __t == __u; } +#else // C++98 + template + bool + operator()(_Tp& __t, _Up& __u) const { return __t == __u; } + template + bool + operator()(const _Tp& __t, _Up& __u) const { return __t == __u; } + template + bool + operator()(_Tp& __t, const _Up& __u) const { return __t == __u; } + template + bool + operator()(const _Tp& __t, const _Up& __u) const { return __t == __u; } +#endif + }; + + template<> + struct less + { +#ifdef __cpp_rvalue_references + template + bool + operator()(_Tp&& __t, _Up&& __u) const + { return __t < __u; } +#else // C++98 + template + bool + operator()(_Tp& __t, _Up& __u) const { return __t < __u; } + template + bool + operator()(const _Tp& __t, _Up& __u) const { return __t < __u; } + template + bool + operator()(_Tp& __t, const _Up& __u) const { return __t < __u; } + template + bool + operator()(const _Tp& __t, const _Up& __u) const { return __t < __u; } +#endif + }; + #endif // __glibcxx_transparent_operators /** @} */ diff --git a/libstdc++-v3/include/bits/stl_heap.h b/libstdc++-v3/include/bits/stl_heap.h index f2b1e87e42a8..b10495bc8052 100644 --- a/libstdc++-v3/include/bits/stl_heap.h +++ b/libstdc++-v3/include/bits/stl_heap.h @@ -85,7 +85,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION _Distance __parent = 0; for (_Distance __child = 1; __child < __n; ++__child) { - if (__comp(__first + __parent, __first + __child)) + if (__comp(__first[__parent], __first[__child])) return __child; if ((__child & 1) == 0) ++__parent; @@ -101,7 +101,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION __is_heap(_RandomAccessIterator __first, _Distance __n) { typename iterator_traits<_RandomAccessIterator>::difference_type __d(__n); - __gnu_cxx::__ops::_Iter_less_iter __comp; + __gnu_cxx::__ops::less __comp; return std::__is_heap_until(__first, __d, __comp) == __n; } @@ -112,9 +112,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION __is_heap(_RandomAccessIterator __first, _Compare __comp, _Distance __n) { typename iterator_traits<_RandomAccessIterator>::difference_type __d(__n); - typedef __decltype(__comp) _Cmp; - __gnu_cxx::__ops::_Iter_comp_iter<_Cmp> __cmp(_GLIBCXX_MOVE(__comp)); - return std::__is_heap_until(__first, __d, __cmp) == __n; + return std::__is_heap_until(__first, __d, __comp) == __n; } template @@ -145,7 +143,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION _Compare& __comp) { _Distance __parent = (__holeIndex - 1) / 2; - while (__holeIndex > __topIndex && __comp(__first + __parent, __value)) + while (__holeIndex > __topIndex && __comp(__first[__parent], __value)) { *(__first + __holeIndex) = _GLIBCXX_MOVE(*(__first + __parent)); __holeIndex = __parent; @@ -182,7 +180,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION __glibcxx_requires_irreflexive(__first, __last); __glibcxx_requires_heap(__first, __last - _DistanceType(1)); - __gnu_cxx::__ops::_Iter_less_val __comp; + __gnu_cxx::__ops::less __comp; _ValueType __value = _GLIBCXX_MOVE(*(__last - _DistanceType(1))); std::__push_heap(__first, _DistanceType((__last - __first) - 1), _DistanceType(0), _GLIBCXX_MOVE(__value), __comp); @@ -218,11 +216,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION __glibcxx_requires_irreflexive_pred(__first, __last, __comp); __glibcxx_requires_heap_pred(__first, __last - _DistanceType(1), __comp); - __decltype(__gnu_cxx::__ops::__iter_comp_val(_GLIBCXX_MOVE(__comp))) - __cmp(_GLIBCXX_MOVE(__comp)); _ValueType __value = _GLIBCXX_MOVE(*(__last - _DistanceType(1))); std::__push_heap(__first, _DistanceType((__last - __first) - 1), - _DistanceType(0), _GLIBCXX_MOVE(__value), __cmp); + _DistanceType(0), _GLIBCXX_MOVE(__value), __comp); } template @@ -303,7 +297,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION if (__last - __first > 1) { --__last; - __gnu_cxx::__ops::_Iter_less_iter __comp; + __gnu_cxx::__ops::less __comp; std::__pop_heap(__first, __last, __last, __comp); } } @@ -335,10 +329,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION if (__last - __first > 1) { - typedef __decltype(__comp) _Cmp; - __gnu_cxx::__ops::_Iter_comp_iter<_Cmp> __cmp(_GLIBCXX_MOVE(__comp)); --__last; - std::__pop_heap(__first, __last, __last, __cmp); + std::__pop_heap(__first, __last, __last, __comp); } } @@ -390,7 +382,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION __glibcxx_requires_valid_range(__first, __last); __glibcxx_requires_irreflexive(__first, __last); - __gnu_cxx::__ops::_Iter_less_iter __comp; + __gnu_cxx::__ops::less __comp; std::__make_heap(__first, __last, __comp); } @@ -416,9 +408,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION __glibcxx_requires_valid_range(__first, __last); __glibcxx_requires_irreflexive_pred(__first, __last, __comp); - typedef __decltype(__comp) _Cmp; - __gnu_cxx::__ops::_Iter_comp_iter<_Cmp> __cmp(_GLIBCXX_MOVE(__comp)); - std::__make_heap(__first, __last, __cmp); + std::__make_heap(__first, __last, __comp); } template @@ -456,7 +446,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION __glibcxx_requires_irreflexive(__first, __last); __glibcxx_requires_heap(__first, __last); - __gnu_cxx::__ops::_Iter_less_iter __comp; + __gnu_cxx::__ops::less __comp; std::__sort_heap(__first, __last, __comp); } @@ -483,9 +473,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION __glibcxx_requires_irreflexive_pred(__first, __last, __comp); __glibcxx_requires_heap_pred(__first, __last, __comp); - typedef __decltype(__comp) _Cmp; - __gnu_cxx::__ops::_Iter_comp_iter<_Cmp> __cmp(_GLIBCXX_MOVE(__comp)); - std::__sort_heap(__first, __last, __cmp); + std::__sort_heap(__first, __last, __comp); } #if __cplusplus >= 201103L @@ -512,7 +500,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION __glibcxx_requires_valid_range(__first, __last); __glibcxx_requires_irreflexive(__first, __last); - __gnu_cxx::__ops::_Iter_less_iter __comp; + __gnu_cxx::__ops::less __comp; return __first + std::__is_heap_until(__first, std::distance(__first, __last), __comp); } @@ -540,10 +528,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION __glibcxx_requires_valid_range(__first, __last); __glibcxx_requires_irreflexive_pred(__first, __last, __comp); - typedef __decltype(__comp) _Cmp; - __gnu_cxx::__ops::_Iter_comp_iter<_Cmp> __cmp(_GLIBCXX_MOVE(__comp)); return __first - + std::__is_heap_until(__first, std::distance(__first, __last), __cmp); + + std::__is_heap_until(__first, std::distance(__first, __last), + __comp); } /** @@ -580,9 +567,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION __glibcxx_requires_irreflexive_pred(__first, __last, __comp); const auto __dist = std::distance(__first, __last); - typedef __decltype(__comp) _Cmp; - __gnu_cxx::__ops::_Iter_comp_iter<_Cmp> __cmp(_GLIBCXX_MOVE(__comp)); - return std::__is_heap_until(__first, __dist, __cmp) == __dist; + return std::__is_heap_until(__first, __dist, __comp) == __dist; } #endif diff --git a/libstdc++-v3/include/std/deque b/libstdc++-v3/include/std/deque index 2badab80a6dc..3b1a7dea2b10 100644 --- a/libstdc++-v3/include/std/deque +++ b/libstdc++-v3/include/std/deque @@ -109,7 +109,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION const auto __osz = __cont.size(); const auto __end = __ucont.end(); auto __removed = std::__remove_if(__ucont.begin(), __end, - __ops::__pred_iter(std::ref(__pred))); + std::ref(__pred)); if (__removed != __end) { __cont.erase(__niter_wrap(__cont.begin(), __removed), @@ -130,7 +130,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION const auto __osz = __cont.size(); const auto __end = __ucont.end(); auto __removed = std::__remove_if(__ucont.begin(), __end, - __ops::__iter_equals_val(__value)); + __ops::__equal_to(__value)); if (__removed != __end) { __cont.erase(__niter_wrap(__cont.begin(), __removed), diff --git a/libstdc++-v3/include/std/inplace_vector b/libstdc++-v3/include/std/inplace_vector index b5a81bed3c98..b32aa4f3708c 100644 --- a/libstdc++-v3/include/std/inplace_vector +++ b/libstdc++-v3/include/std/inplace_vector @@ -1343,7 +1343,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION const auto __osz = __cont.size(); const auto __end = __cont.end(); auto __removed = std::__remove_if(__cont.begin(), __end, - __ops::__pred_iter(std::ref(__pred))); + std::ref(__pred)); if (__removed != __end) { __cont.erase(__niter_wrap(__cont.begin(), __removed), @@ -1362,7 +1362,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION const auto __osz = __cont.size(); const auto __end = __cont.end(); auto __removed = std::__remove_if(__cont.begin(), __end, - __ops::__iter_equals_val(__value)); + __ops::__equal_to(__value)); if (__removed != __end) { __cont.erase(__niter_wrap(__cont.begin(), __removed), diff --git a/libstdc++-v3/include/std/string b/libstdc++-v3/include/std/string index 71864715ff75..74e0c7f2be58 100644 --- a/libstdc++-v3/include/std/string +++ b/libstdc++-v3/include/std/string @@ -104,7 +104,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION const auto __osz = __cont.size(); const auto __end = __cont.end(); auto __removed = std::__remove_if(__cont.begin(), __end, - __ops::__pred_iter(std::ref(__pred))); + std::ref(__pred)); __cont.erase(__removed, __end); return __osz - __cont.size(); } @@ -119,7 +119,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION const auto __osz = __cont.size(); const auto __end = __cont.end(); auto __removed = std::__remove_if(__cont.begin(), __end, - __ops::__iter_equals_val(__value)); + __ops::__equal_to(__value)); __cont.erase(__removed, __end); return __osz - __cont.size(); } diff --git a/libstdc++-v3/include/std/vector b/libstdc++-v3/include/std/vector index a98ffb179ec0..47105210bc0c 100644 --- a/libstdc++-v3/include/std/vector +++ b/libstdc++-v3/include/std/vector @@ -122,7 +122,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION const auto __osz = __cont.size(); const auto __end = __ucont.end(); auto __removed = std::__remove_if(__ucont.begin(), __end, - __ops::__pred_iter(std::ref(__pred))); + std::ref(__pred)); if (__removed != __end) { __cont.erase(__niter_wrap(__cont.begin(), __removed), @@ -144,7 +144,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION const auto __osz = __cont.size(); const auto __end = __ucont.end(); auto __removed = std::__remove_if(__ucont.begin(), __end, - __ops::__iter_equals_val(__value)); + __ops::__equal_to(__value)); if (__removed != __end) { __cont.erase(__niter_wrap(__cont.begin(), __removed), -- 2.47.3