1 // -*- C++ -*- 2 //===----------------------------------------------------------------------===// 3 // 4 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 5 // See https://llvm.org/LICENSE.txt for license information. 6 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 7 // 8 //===----------------------------------------------------------------------===// 9 10 #ifndef _LIBCPP___ALGORITHM_FIND_END_OF_H 11 #define _LIBCPP___ALGORITHM_FIND_END_OF_H 12 13 #include <__algorithm/comp.h> 14 #include <__algorithm/iterator_operations.h> 15 #include <__algorithm/search.h> 16 #include <__config> 17 #include <__functional/identity.h> 18 #include <__functional/invoke.h> 19 #include <__iterator/advance.h> 20 #include <__iterator/iterator_traits.h> 21 #include <__iterator/next.h> 22 #include <__iterator/reverse_iterator.h> 23 #include <__utility/pair.h> 24 25 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) 26 # pragma GCC system_header 27 #endif 28 29 _LIBCPP_BEGIN_NAMESPACE_STD 30 31 template < 32 class _AlgPolicy, 33 class _Iter1, 34 class _Sent1, 35 class _Iter2, 36 class _Sent2, 37 class _Pred, 38 class _Proj1, 39 class _Proj2> 40 _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_CONSTEXPR_SINCE_CXX14 pair<_Iter1, _Iter1> __find_end_impl( 41 _Iter1 __first1, 42 _Sent1 __last1, 43 _Iter2 __first2, 44 _Sent2 __last2, 45 _Pred& __pred, 46 _Proj1& __proj1, 47 _Proj2& __proj2, 48 forward_iterator_tag, 49 forward_iterator_tag) { 50 // modeled after search algorithm 51 _Iter1 __match_first = _IterOps<_AlgPolicy>::next(__first1, __last1); // __last1 is the "default" answer 52 _Iter1 __match_last = __match_first; 53 if (__first2 == __last2) 54 return pair<_Iter1, _Iter1>(__match_last, __match_last); 55 while (true) { 56 while (true) { 57 if (__first1 == __last1) // if source exhausted return last correct answer (or __last1 if never found) 58 return pair<_Iter1, _Iter1>(__match_first, __match_last); 59 if (std::__invoke(__pred, std::__invoke(__proj1, *__first1), std::__invoke(__proj2, *__first2))) 60 break; 61 ++__first1; 62 } 63 // *__first1 matches *__first2, now match elements after here 64 _Iter1 __m1 = __first1; 65 _Iter2 __m2 = __first2; 66 while (true) { 67 if (++__m2 == __last2) { // Pattern exhaused, record answer and search for another one 68 __match_first = __first1; 69 __match_last = ++__m1; 70 ++__first1; 71 break; 72 } 73 if (++__m1 == __last1) // Source exhausted, return last answer 74 return pair<_Iter1, _Iter1>(__match_first, __match_last); 75 // mismatch, restart with a new __first 76 if (!std::__invoke(__pred, std::__invoke(__proj1, *__m1), std::__invoke(__proj2, *__m2))) 77 { 78 ++__first1; 79 break; 80 } // else there is a match, check next elements 81 } 82 } 83 } 84 85 template < 86 class _IterOps, 87 class _Pred, 88 class _Iter1, 89 class _Sent1, 90 class _Iter2, 91 class _Sent2, 92 class _Proj1, 93 class _Proj2> 94 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _Iter1 __find_end( 95 _Iter1 __first1, 96 _Sent1 __sent1, 97 _Iter2 __first2, 98 _Sent2 __sent2, 99 _Pred& __pred, 100 _Proj1& __proj1, 101 _Proj2& __proj2, 102 bidirectional_iterator_tag, 103 bidirectional_iterator_tag) { 104 auto __last1 = _IterOps::next(__first1, __sent1); 105 auto __last2 = _IterOps::next(__first2, __sent2); 106 // modeled after search algorithm (in reverse) 107 if (__first2 == __last2) 108 return __last1; // Everything matches an empty sequence 109 _Iter1 __l1 = __last1; 110 _Iter2 __l2 = __last2; 111 --__l2; 112 while (true) { 113 // Find last element in sequence 1 that matchs *(__last2-1), with a mininum of loop checks 114 while (true) { 115 if (__first1 == __l1) // return __last1 if no element matches *__first2 116 return __last1; 117 if (std::__invoke(__pred, std::__invoke(__proj1, *--__l1), std::__invoke(__proj2, *__l2))) 118 break; 119 } 120 // *__l1 matches *__l2, now match elements before here 121 _Iter1 __m1 = __l1; 122 _Iter2 __m2 = __l2; 123 while (true) { 124 if (__m2 == __first2) // If pattern exhausted, __m1 is the answer (works for 1 element pattern) 125 return __m1; 126 if (__m1 == __first1) // Otherwise if source exhaused, pattern not found 127 return __last1; 128 129 // if there is a mismatch, restart with a new __l1 130 if (!std::__invoke(__pred, std::__invoke(__proj1, *--__m1), std::__invoke(__proj2, *--__m2))) 131 { 132 break; 133 } // else there is a match, check next elements 134 } 135 } 136 } 137 138 template < 139 class _AlgPolicy, 140 class _Pred, 141 class _Iter1, 142 class _Sent1, 143 class _Iter2, 144 class _Sent2, 145 class _Proj1, 146 class _Proj2> 147 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _Iter1 __find_end( 148 _Iter1 __first1, 149 _Sent1 __sent1, 150 _Iter2 __first2, 151 _Sent2 __sent2, 152 _Pred& __pred, 153 _Proj1& __proj1, 154 _Proj2& __proj2, 155 random_access_iterator_tag, 156 random_access_iterator_tag) { 157 typedef typename iterator_traits<_Iter1>::difference_type _D1; 158 auto __last1 = _IterOps<_AlgPolicy>::next(__first1, __sent1); 159 auto __last2 = _IterOps<_AlgPolicy>::next(__first2, __sent2); 160 // Take advantage of knowing source and pattern lengths. Stop short when source is smaller than pattern 161 auto __len2 = __last2 - __first2; 162 if (__len2 == 0) 163 return __last1; 164 auto __len1 = __last1 - __first1; 165 if (__len1 < __len2) 166 return __last1; 167 const _Iter1 __s = __first1 + _D1(__len2 - 1); // End of pattern match can't go before here 168 _Iter1 __l1 = __last1; 169 _Iter2 __l2 = __last2; 170 --__l2; 171 while (true) { 172 while (true) { 173 if (__s == __l1) 174 return __last1; 175 if (std::__invoke(__pred, std::__invoke(__proj1, *--__l1), std::__invoke(__proj2, *__l2))) 176 break; 177 } 178 _Iter1 __m1 = __l1; 179 _Iter2 __m2 = __l2; 180 while (true) { 181 if (__m2 == __first2) 182 return __m1; 183 // no need to check range on __m1 because __s guarantees we have enough source 184 if (!std::__invoke(__pred, std::__invoke(__proj1, *--__m1), std::__invoke(*--__m2))) { 185 break; 186 } 187 } 188 } 189 } 190 191 template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate> 192 _LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 193 _ForwardIterator1 __find_end_classic(_ForwardIterator1 __first1, _ForwardIterator1 __last1, 194 _ForwardIterator2 __first2, _ForwardIterator2 __last2, 195 _BinaryPredicate& __pred) { 196 auto __proj = __identity(); 197 return std::__find_end_impl<_ClassicAlgPolicy>( 198 __first1, 199 __last1, 200 __first2, 201 __last2, 202 __pred, 203 __proj, 204 __proj, 205 typename iterator_traits<_ForwardIterator1>::iterator_category(), 206 typename iterator_traits<_ForwardIterator2>::iterator_category()) 207 .first; 208 } 209 210 template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate> 211 _LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 212 _ForwardIterator1 find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1, 213 _ForwardIterator2 __first2, _ForwardIterator2 __last2, 214 _BinaryPredicate __pred) { 215 return std::__find_end_classic(__first1, __last1, __first2, __last2, __pred); 216 } 217 218 template <class _ForwardIterator1, class _ForwardIterator2> 219 _LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 220 _ForwardIterator1 find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1, 221 _ForwardIterator2 __first2, _ForwardIterator2 __last2) { 222 return std::find_end(__first1, __last1, __first2, __last2, __equal_to()); 223 } 224 225 _LIBCPP_END_NAMESPACE_STD 226 227 #endif // _LIBCPP___ALGORITHM_FIND_END_OF_H 228