Unconditionally use absl::apply() and absl::make_from_tuple() ins…

…tead of

conditionally using either their `std` counterparts or other workarounds.

PiperOrigin-RevId: 606192944

riegeli/base/BUILD

@@ -208,6 +208,7 @@ cc_library(
         "@com_google_absl//absl/meta:type_traits",
         "@com_google_absl//absl/strings",
         "@com_google_absl//absl/types:span",
+        "@com_google_absl//absl/utility",
     ],
 )
 
@@ -365,6 +366,7 @@ cc_library(
         "@com_google_absl//absl/strings:cord",
         "@com_google_absl//absl/types:optional",
         "@com_google_absl//absl/types:span",
+        "@com_google_absl//absl/utility",
     ],
 )
 

riegeli/base/any_dependency.h

@@ -789,23 +789,9 @@ inline Handle SentinelHandleInternal(Handle&& handle) {
   return std::move(handle);
 }
 
-#if !__cpp_lib_make_from_tuple
-template <typename Handle, typename... HandleArgs, size_t... indices>
-inline Handle SentinelHandleInternal(
-    ABSL_ATTRIBUTE_UNUSED std::tuple<HandleArgs...>&& handle_args,
-    std::index_sequence<indices...>) {
-  return Handle(std::forward<HandleArgs>(std::get<indices>(handle_args))...);
-}
-#endif
-
 template <typename Handle, typename... HandleArgs>
 inline Handle SentinelHandleInternal(std::tuple<HandleArgs...> handle_args) {
-#if __cpp_lib_make_from_tuple
-  return std::make_from_tuple<Handle>(std::move(handle_args));
-#else
-  return SentinelHandleInternal<Handle>(
-      std::move(handle_args), std::index_sequence_for<HandleArgs...>());
-#endif
+  return absl::make_from_tuple<Handle>(std::move(handle_args));
 }
 
 template <typename Handle>

riegeli/base/chain.h

@@ -36,6 +36,7 @@
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
 #include "absl/types/span.h"
+#include "absl/utility/utility.h"
 #include "riegeli/base/arithmetic.h"
 #include "riegeli/base/assert.h"
 #include "riegeli/base/buffering.h"
@@ -1054,7 +1055,7 @@ class Chain::RawBlock {
   template <typename T>
   static constexpr size_t kExternalObjectOffset();
 
-#if !__cpp_guaranteed_copy_elision || !__cpp_lib_make_from_tuple
+#if !__cpp_guaranteed_copy_elision
   template <typename T, typename... Args, size_t... indices>
   void ConstructExternal(std::tuple<Args...>&& args,
                          std::index_sequence<indices...>);
@@ -1284,10 +1285,10 @@ void Chain::ExternalMethodsFor<T>::RegisterSubobjects(
 
 template <typename T, typename... Args>
 inline Chain::RawBlock::RawBlock(ExternalType<T>, std::tuple<Args...> args) {
-#if __cpp_guaranteed_copy_elision && __cpp_lib_make_from_tuple
+#if __cpp_guaranteed_copy_elision
   external_.methods = &ExternalMethodsFor<T>::methods;
   new (&unchecked_external_object<T>())
-      T(std::make_from_tuple<T>(std::move(args)));
+      T(absl::make_from_tuple<T>(std::move(args)));
 #else
   ConstructExternal<T>(std::move(args), std::index_sequence_for<Args...>());
 #endif
@@ -1302,10 +1303,10 @@ template <typename T, typename... Args>
 inline Chain::RawBlock::RawBlock(ExternalType<T>, std::tuple<Args...> args,
                                  absl::string_view data)
     : data_(data.data()), size_(data.size()) {
-#if __cpp_guaranteed_copy_elision && __cpp_lib_make_from_tuple
+#if __cpp_guaranteed_copy_elision
   external_.methods = &ExternalMethodsFor<T>::methods;
   new (&unchecked_external_object<T>())
-      T(std::make_from_tuple<T>(std::move(args)));
+      T(absl::make_from_tuple<T>(std::move(args)));
 #else
   ConstructExternal<T>(std::move(args), std::index_sequence_for<Args...>());
 #endif
@@ -1347,7 +1348,7 @@ void Chain::RawBlock::Unref() {
   }
 }
 
-#if !__cpp_guaranteed_copy_elision || !__cpp_lib_make_from_tuple
+#if !__cpp_guaranteed_copy_elision
 template <typename T, typename... Args, size_t... indices>
 inline void Chain::RawBlock::ConstructExternal(
     ABSL_ATTRIBUTE_UNUSED std::tuple<Args...>&& args,

riegeli/base/dependency.h

@@ -27,6 +27,7 @@
 #include "absl/meta/type_traits.h"
 #include "absl/strings/string_view.h"
 #include "absl/types/span.h"
+#include "absl/utility/utility.h"
 #include "riegeli/base/assert.h"
 #include "riegeli/base/compare.h"
 #include "riegeli/base/reset.h"
@@ -235,8 +236,8 @@ class DependencyBase {
   template <typename... ManagerArgs>
   explicit DependencyBase(std::tuple<ManagerArgs...> manager_args)
       :
-#if __cpp_guaranteed_copy_elision && __cpp_lib_make_from_tuple
-        manager_(std::make_from_tuple<Manager>(std::move(manager_args)))
+#if __cpp_guaranteed_copy_elision
+        manager_(absl::make_from_tuple<Manager>(std::move(manager_args)))
 #else
         DependencyBase(std::move(manager_args),
                        std::index_sequence_for<ManagerArgs...>())
@@ -266,16 +267,11 @@ class DependencyBase {
   template <typename... ManagerArgs>
   ABSL_ATTRIBUTE_REINITIALIZES void Reset(
       std::tuple<ManagerArgs...> manager_args) {
-#if __cpp_lib_apply
-    std::apply(
+    absl::apply(
         [&](ManagerArgs&&... args) {
           riegeli::Reset(manager_, std::forward<ManagerArgs>(args)...);
         },
         std::move(manager_args));
-#else
-    ResetInternal(std::move(manager_args),
-                  std::index_sequence_for<ManagerArgs...>());
-#endif
   }
 
   Manager& manager() { return manager_; }
@@ -293,7 +289,7 @@ class DependencyBase {
   Manager& mutable_manager() const { return manager_; }
 
  private:
-#if !__cpp_guaranteed_copy_elision || !__cpp_lib_make_from_tuple
+#if !__cpp_guaranteed_copy_elision
   template <typename... ManagerArgs, size_t... indices>
   explicit DependencyBase(
       ABSL_ATTRIBUTE_UNUSED std::tuple<ManagerArgs...>&& manager_args,
@@ -302,16 +298,6 @@ class DependencyBase {
             std::forward<ManagerArgs>(std::get<indices>(manager_args))...) {}
 #endif
 
-#if !__cpp_lib_apply
-  template <typename... ManagerArgs, size_t... indices>
-  void ResetInternal(
-      ABSL_ATTRIBUTE_UNUSED std::tuple<ManagerArgs...>&& manager_args,
-      std::index_sequence<indices...>) {
-    riegeli::Reset(manager_, std::forward<ManagerArgs>(
-                                 std::get<indices>(manager_args))...);
-  }
-#endif
-
   mutable Manager manager_;
 };