[libcxx-commits] [libcxx] P1223R5: `find_last` (PR #99312)

[A. Jiang via libcxx-commits]

================
@@ -0,0 +1,103 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___ALGORITHM_RANGES_FIND_LAST_H
+#define _LIBCPP___ALGORITHM_RANGES_FIND_LAST_H
+
+#include <__config>
+#include <__functional/identity.h>
+#include <__functional/invoke.h>
+#include <__functional/ranges_operations.h>
+#include <__iterator/concepts.h>
+#include <__iterator/indirectly_comparable.h>
+#include <__iterator/next.h>
+#include <__iterator/prev.h>
+#include <__iterator/projected.h>
+#include <__ranges/access.h>
+#include <__ranges/concepts.h>
+#include <__ranges/subrange.h>
+#include <__utility/move.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+#if _LIBCPP_STD_VER >= 23
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+namespace ranges {
+namespace __find_last {
+struct __fn {
+  template <class _Iter, class _Sent, class _Type, class _Proj>
+  _LIBCPP_HIDE_FROM_ABI constexpr static subrange<_Iter>
+  __find_last_impl(_Iter __first, _Sent __last, const _Type& __value, _Proj& __proj) {
+    if (__first == __last) {
+      return subrange<_Iter>(__first, __first);
+    }
+
+    if constexpr (bidirectional_iterator<_Iter>) {
+      auto __last_it = ranges::next(__first, __last);
+      for (auto __it = ranges::prev(__last_it); __it != __first; --__it) {
+        if (std::invoke(__proj, *__it) == __value) {
+          return subrange<_Iter>(std::move(__it), std::move(__last_it));
+        }
+      }
+      if (std::invoke(__proj, *__first) == __value) {
+        return subrange<_Iter>(std::move(__first), std::move(__last_it));
+      }
+      return subrange<_Iter>(__last_it, __last_it);
+    } else {
+      bool __found = false;
+      _Iter __found_it;
+      for (; __first != __last; ++__first) {
+        if (std::invoke(__proj, *__first) == __value) {
+          __found    = true;
+          __found_it = __first;
+        }
+      }
+
+      if (__found) {
+        return subrange<_Iter>(std::move(__found_it), std::move(__first));
+      } else {
+        return subrange<_Iter>(__first, __first);
+      }
+    }
+  }
+
+  template <forward_iterator _Iter, sentinel_for<_Iter> _Sent, class _Type, class _Proj = identity>
+    requires indirect_binary_predicate<ranges::equal_to, projected<_Iter, _Proj>, const _Type*>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr subrange<_Iter>
+  operator()(_Iter __first, _Sent __last, const _Type& __value, _Proj __proj = {}) const {
----------------
frederick-vs-ja wrote:

It seems that we can and should use `static operator()` for C++23 (and later)-only stateless functors. (Ditto below.)

https://github.com/llvm/llvm-project/pull/99312