grpc 1.73.0 → 1.75.0

data/src/core/lib/event_engine/forkable.cc

@@ -1,105 +0,0 @@
-// Copyright 2022 gRPC authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "src/core/lib/event_engine/forkable.h"
-
-#include <grpc/support/port_platform.h>
-
-#include "absl/log/check.h"
-
-#ifdef GRPC_POSIX_FORK_ALLOW_PTHREAD_ATFORK
-#include <pthread.h>
-#endif
-
-#include <algorithm>
-#include <utility>
-#include <vector>
-
-#include "src/core/config/config_vars.h"
-#include "src/core/lib/debug/trace.h"
-
-namespace grpc_event_engine::experimental {
-
-namespace {
-bool IsForkEnabled() {
-  static bool enabled = grpc_core::ConfigVars::Get().EnableForkSupport();
-  return enabled;
-}
-}  // namespace
-
-void ObjectGroupForkHandler::RegisterForkable(
-    std::shared_ptr<Forkable> forkable, GRPC_UNUSED void (*prepare)(void),
-    GRPC_UNUSED void (*parent)(void), GRPC_UNUSED void (*child)(void)) {
-  if (IsForkEnabled()) {
-    CHECK(!is_forking_);
-    forkables_.emplace_back(forkable);
-#ifdef GRPC_POSIX_FORK_ALLOW_PTHREAD_ATFORK
-    if (!std::exchange(registered_, true)) {
-      pthread_atfork(prepare, parent, child);
-    }
-#endif  // GRPC_POSIX_FORK_ALLOW_PTHREAD_ATFORK
-  }
-}
-
-void ObjectGroupForkHandler::Prefork() {
-  if (IsForkEnabled()) {
-    CHECK(!std::exchange(is_forking_, true));
-    GRPC_TRACE_LOG(fork, INFO) << "PrepareFork";
-    for (auto it = forkables_.begin(); it != forkables_.end();) {
-      auto shared = it->lock();
-      if (shared) {
-        shared->PrepareFork();
-        ++it;
-      } else {
-        it = forkables_.erase(it);
-      }
-    }
-  }
-}
-
-void ObjectGroupForkHandler::PostforkParent() {
-  if (IsForkEnabled()) {
-    CHECK(is_forking_);
-    GRPC_TRACE_LOG(fork, INFO) << "PostforkParent";
-    for (auto it = forkables_.begin(); it != forkables_.end();) {
-      auto shared = it->lock();
-      if (shared) {
-        shared->PostforkParent();
-        ++it;
-      } else {
-        it = forkables_.erase(it);
-      }
-    }
-    is_forking_ = false;
-  }
-}
-
-void ObjectGroupForkHandler::PostforkChild() {
-  if (IsForkEnabled()) {
-    CHECK(is_forking_);
-    GRPC_TRACE_LOG(fork, INFO) << "PostforkChild";
-    for (auto it = forkables_.begin(); it != forkables_.end();) {
-      auto shared = it->lock();
-      if (shared) {
-        shared->PostforkChild();
-        ++it;
-      } else {
-        it = forkables_.erase(it);
-      }
-    }
-    is_forking_ = false;
-  }
-}
-
-}  // namespace grpc_event_engine::experimental

data/src/core/lib/event_engine/forkable.h

@@ -1,67 +0,0 @@
-// Copyright 2022 gRPC authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-#ifndef GRPC_SRC_CORE_LIB_EVENT_ENGINE_FORKABLE_H
-#define GRPC_SRC_CORE_LIB_EVENT_ENGINE_FORKABLE_H
-
-#include <grpc/support/port_platform.h>
-
-#include <memory>
-#include <vector>
-
-#include "src/core/lib/debug/trace.h"
-
-namespace grpc_event_engine::experimental {
-
-// An interface to be implemented by EventEngines that wish to have managed fork
-// support. The child class must guarantee that those methods are thread-safe.
-class Forkable {
- public:
-  virtual ~Forkable() = default;
-  virtual void PrepareFork() = 0;
-  virtual void PostforkParent() = 0;
-  virtual void PostforkChild() = 0;
-};
-
-// ObjectGroupForkHandler is meant to be used as a static object in each
-// translation unit where Forkables are created and registered with the
-// ObjectGroupForkHandler. It essentially provides storage for Forkables'
-// instances (as a vector of weak pointers) and helper methods that are meant to
-// be invoked inside the fork handlers (see pthread_atfork(3)). The idea is to
-// have different Forkables (e.g. PosixEventPoller) to store their instances
-// (e.g. a PosixEventPoller object) in a single place separated from other
-// Forkables (a sharded approach). Forkables need to register their pthread fork
-// handlers and manage the relative ordering themselves. This object is
-// thread-unsafe.
-class ObjectGroupForkHandler {
- public:
-  // Registers a Forkable with this ObjectGroupForkHandler, the Forkable must be
-  // created as a shared pointer.
-  void RegisterForkable(std::shared_ptr<Forkable> forkable,
-                        GRPC_UNUSED void (*prepare)(void),
-                        GRPC_UNUSED void (*parent)(void),
-                        GRPC_UNUSED void (*child)(void));
-
-  void Prefork();
-  void PostforkParent();
-  void PostforkChild();
-
- private:
-  GRPC_UNUSED bool registered_ = false;
-  bool is_forking_ = false;
-  std::vector<std::weak_ptr<Forkable> > forkables_;
-};
-
-}  // namespace grpc_event_engine::experimental
-
-#endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_FORKABLE_H

data/src/core/lib/iomgr/python_util.h

@@ -1,46 +0,0 @@
-//
-//
-// Copyright 2018 gRPC authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-//
-
-#ifndef GRPC_SRC_CORE_LIB_IOMGR_PYTHON_UTIL_H
-#define GRPC_SRC_CORE_LIB_IOMGR_PYTHON_UTIL_H
-
-#include <grpc/slice.h>
-#include <grpc/status.h>
-#include <grpc/support/port_platform.h>
-
-#include "src/core/lib/iomgr/error.h"
-
-// These are only used by the gRPC Python extensions.
-// They are easier to define here (rather than in Cython)
-// because Cython doesn't handle #defines well.
-
-inline grpc_error_handle grpc_socket_error(char* error) {
-  return grpc_error_set_int(GRPC_ERROR_CREATE(error),
-                            grpc_core::StatusIntProperty::kRpcStatus,
-                            GRPC_STATUS_UNAVAILABLE);
-}
-
-inline char* grpc_slice_buffer_start(grpc_slice_buffer* buffer, int i) {
-  return reinterpret_cast<char*>(GRPC_SLICE_START_PTR(buffer->slices[i]));
-}
-
-inline int grpc_slice_buffer_length(grpc_slice_buffer* buffer, int i) {
-  return GRPC_SLICE_LENGTH(buffer->slices[i]);
-}
-
-#endif  // GRPC_SRC_CORE_LIB_IOMGR_PYTHON_UTIL_H

data/src/core/util/ring_buffer.h

@@ -1,122 +0,0 @@
-// Copyright 2024 gRPC authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef GRPC_SRC_CORE_UTIL_RING_BUFFER_H
-#define GRPC_SRC_CORE_UTIL_RING_BUFFER_H
-
-#include <grpc/support/port_platform.h>
-
-#include <array>
-#include <cstddef>
-#include <iterator>
-#include <optional>
-
-namespace grpc_core {
-
-template <typename T, int kCapacity>
-class RingBuffer {
- public:
-  class RingBufferIterator {
-   public:
-    using iterator_category = std::forward_iterator_tag;
-    using value_type = const T;
-    using pointer = void;
-    using reference = void;
-    using difference_type = std::ptrdiff_t;
-
-    RingBufferIterator& operator++() {
-      if (--size_ <= 0) {
-        head_ = 0;
-        size_ = 0;
-        buffer_ = nullptr;
-      } else {
-        head_ = (head_ + 1) % kCapacity;
-      }
-      return *this;
-    }
-
-    RingBufferIterator operator++(int) {
-      RingBufferIterator tmp(*this);
-      operator++();
-      return tmp;
-    }
-
-    bool operator==(const RingBufferIterator& rhs) const {
-      return (buffer_ == rhs.buffer_ && head_ == rhs.head_ &&
-              size_ == rhs.size_);
-    }
-
-    bool operator!=(const RingBufferIterator& rhs) const {
-      return !operator==(rhs);
-    }
-
-    T operator*() { return buffer_->data_[head_]; }
-
-    RingBufferIterator() : buffer_(nullptr), head_(0), size_(0) {};
-    RingBufferIterator(const RingBufferIterator& other) = default;
-    explicit RingBufferIterator(const RingBuffer<T, kCapacity>* buffer)
-        : buffer_(buffer), head_(buffer->head_), size_(buffer->size_) {
-      if (!size_) {
-        buffer_ = nullptr;
-      }
-    }
-
-   private:
-    friend class RingBuffer<T, kCapacity>;
-    const RingBuffer<T, kCapacity>* buffer_;
-    int head_ = 0;
-    int size_ = 0;
-  };
-
-  RingBuffer() = default;
-
-  void Append(T data) {
-    if (size_ < kCapacity) {
-      data_[size_] = std::move(data);
-      size_++;
-    } else {
-      data_[head_] = std::move(data);
-      head_ = (head_ + 1) % kCapacity;
-    }
-  }
-
-  // Returns the data of the first element in the buffer and removes it from
-  // the buffer. If the buffer is empty, returns std::nullopt.
-  std::optional<T> PopIfNotEmpty() {
-    if (!size_) return std::nullopt;
-    T data = std::move(data_[head_]);
-    --size_;
-    head_ = (head_ + 1) % kCapacity;
-    return data;
-  }
-
-  void Clear() {
-    head_ = 0;
-    size_ = 0;
-  }
-
-  RingBufferIterator begin() const { return RingBufferIterator(this); }
-
-  RingBufferIterator end() const { return RingBufferIterator(); }
-
- private:
-  friend class RingBufferIterator;
-  std::array<T, kCapacity> data_;
-  int head_ = 0;
-  int size_ = 0;
-};
-
-}  // namespace grpc_core
-
-#endif  // GRPC_SRC_CORE_UTIL_RING_BUFFER_H

data/third_party/abseil-cpp/absl/base/internal/inline_variable.h

@@ -1,108 +0,0 @@
-// Copyright 2017 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef ABSL_BASE_INTERNAL_INLINE_VARIABLE_H_
-#define ABSL_BASE_INTERNAL_INLINE_VARIABLE_H_
-
-#include <type_traits>
-
-#include "absl/base/internal/identity.h"
-
-// File:
-//   This file define a macro that allows the creation of or emulation of C++17
-//   inline variables based on whether or not the feature is supported.
-
-////////////////////////////////////////////////////////////////////////////////
-// Macro: ABSL_INTERNAL_INLINE_CONSTEXPR(type, name, init)
-//
-// Description:
-//   Expands to the equivalent of an inline constexpr instance of the specified
-//   `type` and `name`, initialized to the value `init`. If the compiler being
-//   used is detected as supporting actual inline variables as a language
-//   feature, then the macro expands to an actual inline variable definition.
-//
-// Requires:
-//   `type` is a type that is usable in an extern variable declaration.
-//
-// Requires: `name` is a valid identifier
-//
-// Requires:
-//   `init` is an expression that can be used in the following definition:
-//     constexpr type name = init;
-//
-// Usage:
-//
-//   // Equivalent to: `inline constexpr size_t variant_npos = -1;`
-//   ABSL_INTERNAL_INLINE_CONSTEXPR(size_t, variant_npos, -1);
-//
-// Differences in implementation:
-//   For a direct, language-level inline variable, decltype(name) will be the
-//   type that was specified along with const qualification, whereas for
-//   emulated inline variables, decltype(name) may be different (in practice
-//   it will likely be a reference type).
-////////////////////////////////////////////////////////////////////////////////
-
-#ifdef __cpp_inline_variables
-
-// Clang's -Wmissing-variable-declarations option erroneously warned that
-// inline constexpr objects need to be pre-declared. This has now been fixed,
-// but we will need to support this workaround for people building with older
-// versions of clang.
-//
-// Bug: https://bugs.llvm.org/show_bug.cgi?id=35862
-//
-// Note:
-//   type_identity_t is used here so that the const and name are in the
-//   appropriate place for pointer types, reference types, function pointer
-//   types, etc..
-#if defined(__clang__)
-#define ABSL_INTERNAL_EXTERN_DECL(type, name) \
-  extern const ::absl::internal::type_identity_t<type> name;
-#else  // Otherwise, just define the macro to do nothing.
-#define ABSL_INTERNAL_EXTERN_DECL(type, name)
-#endif  // defined(__clang__)
-
-// See above comment at top of file for details.
-#define ABSL_INTERNAL_INLINE_CONSTEXPR(type, name, init) \
-  ABSL_INTERNAL_EXTERN_DECL(type, name)                  \
-  inline constexpr ::absl::internal::type_identity_t<type> name = init
-
-#else
-
-// See above comment at top of file for details.
-//
-// Note:
-//   type_identity_t is used here so that the const and name are in the
-//   appropriate place for pointer types, reference types, function pointer
-//   types, etc..
-#define ABSL_INTERNAL_INLINE_CONSTEXPR(var_type, name, init)                 \
-  template <class /*AbslInternalDummy*/ = void>                              \
-  struct AbslInternalInlineVariableHolder##name {                            \
-    static constexpr ::absl::internal::type_identity_t<var_type> kInstance = \
-        init;                                                                \
-  };                                                                         \
-                                                                             \
-  template <class AbslInternalDummy>                                         \
-  constexpr ::absl::internal::type_identity_t<var_type>                      \
-      AbslInternalInlineVariableHolder##name<AbslInternalDummy>::kInstance;  \
-                                                                             \
-  static constexpr const ::absl::internal::type_identity_t<var_type>&        \
-      name = /* NOLINT */                                                    \
-      AbslInternalInlineVariableHolder##name<>::kInstance;                   \
-  static_assert(sizeof(void (*)(decltype(name))) != 0,                       \
-                "Silence unused variable warnings.")
-
-#endif  // __cpp_inline_variables
-
-#endif  // ABSL_BASE_INTERNAL_INLINE_VARIABLE_H_

data/third_party/abseil-cpp/absl/base/internal/invoke.h

@@ -1,241 +0,0 @@
-// Copyright 2017 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-// absl::base_internal::invoke(f, args...) is an implementation of
-// INVOKE(f, args...) from section [func.require] of the C++ standard.
-// When compiled as C++17 and later versions, it is implemented as an alias of
-// std::invoke.
-//
-// [func.require]
-// Define INVOKE (f, t1, t2, ..., tN) as follows:
-// 1. (t1.*f)(t2, ..., tN) when f is a pointer to a member function of a class T
-//    and t1 is an object of type T or a reference to an object of type T or a
-//    reference to an object of a type derived from T;
-// 2. ((*t1).*f)(t2, ..., tN) when f is a pointer to a member function of a
-//    class T and t1 is not one of the types described in the previous item;
-// 3. t1.*f when N == 1 and f is a pointer to member data of a class T and t1 is
-//    an object of type T or a reference to an object of type T or a reference
-//    to an object of a type derived from T;
-// 4. (*t1).*f when N == 1 and f is a pointer to member data of a class T and t1
-//    is not one of the types described in the previous item;
-// 5. f(t1, t2, ..., tN) in all other cases.
-//
-// The implementation is SFINAE-friendly: substitution failure within invoke()
-// isn't an error.
-
-#ifndef ABSL_BASE_INTERNAL_INVOKE_H_
-#define ABSL_BASE_INTERNAL_INVOKE_H_
-
-#include "absl/base/config.h"
-
-#if ABSL_INTERNAL_CPLUSPLUS_LANG >= 201703L
-
-#include <functional>
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace base_internal {
-
-using std::invoke;
-using std::invoke_result_t;
-using std::is_invocable_r;
-
-}  // namespace base_internal
-ABSL_NAMESPACE_END
-}  // namespace absl
-
-#else  // ABSL_INTERNAL_CPLUSPLUS_LANG >= 201703L
-
-#include <algorithm>
-#include <type_traits>
-#include <utility>
-
-#include "absl/meta/type_traits.h"
-
-// The following code is internal implementation detail.  See the comment at the
-// top of this file for the API documentation.
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace base_internal {
-
-// The five classes below each implement one of the clauses from the definition
-// of INVOKE. The inner class template Accept<F, Args...> checks whether the
-// clause is applicable; static function template Invoke(f, args...) does the
-// invocation.
-//
-// By separating the clause selection logic from invocation we make sure that
-// Invoke() does exactly what the standard says.
-
-template <typename Derived>
-struct StrippedAccept {
-  template <typename... Args>
-  struct Accept : Derived::template AcceptImpl<typename std::remove_cv<
-                      typename std::remove_reference<Args>::type>::type...> {};
-};
-
-// (t1.*f)(t2, ..., tN) when f is a pointer to a member function of a class T
-// and t1 is an object of type T or a reference to an object of type T or a
-// reference to an object of a type derived from T.
-struct MemFunAndRef : StrippedAccept<MemFunAndRef> {
-  template <typename... Args>
-  struct AcceptImpl : std::false_type {};
-
-  template <typename MemFunType, typename C, typename Obj, typename... Args>
-  struct AcceptImpl<MemFunType C::*, Obj, Args...>
-      : std::integral_constant<bool, std::is_base_of<C, Obj>::value &&
-                                         absl::is_function<MemFunType>::value> {
-  };
-
-  template <typename MemFun, typename Obj, typename... Args>
-  static decltype((std::declval<Obj>().*
-                   std::declval<MemFun>())(std::declval<Args>()...))
-  Invoke(MemFun&& mem_fun, Obj&& obj, Args&&... args) {
-// Ignore bogus GCC warnings on this line.
-// See https://gcc.gnu.org/bugzilla/show_bug.cgi?id=101436 for similar example.
-#if ABSL_INTERNAL_HAVE_MIN_GNUC_VERSION(11, 0)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Warray-bounds"
-#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
-#endif
-    return (std::forward<Obj>(obj).*
-            std::forward<MemFun>(mem_fun))(std::forward<Args>(args)...);
-#if ABSL_INTERNAL_HAVE_MIN_GNUC_VERSION(11, 0)
-#pragma GCC diagnostic pop
-#endif
-  }
-};
-
-// ((*t1).*f)(t2, ..., tN) when f is a pointer to a member function of a
-// class T and t1 is not one of the types described in the previous item.
-struct MemFunAndPtr : StrippedAccept<MemFunAndPtr> {
-  template <typename... Args>
-  struct AcceptImpl : std::false_type {};
-
-  template <typename MemFunType, typename C, typename Ptr, typename... Args>
-  struct AcceptImpl<MemFunType C::*, Ptr, Args...>
-      : std::integral_constant<bool, !std::is_base_of<C, Ptr>::value &&
-                                         absl::is_function<MemFunType>::value> {
-  };
-
-  template <typename MemFun, typename Ptr, typename... Args>
-  static decltype(((*std::declval<Ptr>()).*
-                   std::declval<MemFun>())(std::declval<Args>()...))
-  Invoke(MemFun&& mem_fun, Ptr&& ptr, Args&&... args) {
-    return ((*std::forward<Ptr>(ptr)).*
-            std::forward<MemFun>(mem_fun))(std::forward<Args>(args)...);
-  }
-};
-
-// t1.*f when N == 1 and f is a pointer to member data of a class T and t1 is
-// an object of type T or a reference to an object of type T or a reference
-// to an object of a type derived from T.
-struct DataMemAndRef : StrippedAccept<DataMemAndRef> {
-  template <typename... Args>
-  struct AcceptImpl : std::false_type {};
-
-  template <typename R, typename C, typename Obj>
-  struct AcceptImpl<R C::*, Obj>
-      : std::integral_constant<bool, std::is_base_of<C, Obj>::value &&
-                                         !absl::is_function<R>::value> {};
-
-  template <typename DataMem, typename Ref>
-  static decltype(std::declval<Ref>().*std::declval<DataMem>()) Invoke(
-      DataMem&& data_mem, Ref&& ref) {
-    return std::forward<Ref>(ref).*std::forward<DataMem>(data_mem);
-  }
-};
-
-// (*t1).*f when N == 1 and f is a pointer to member data of a class T and t1
-// is not one of the types described in the previous item.
-struct DataMemAndPtr : StrippedAccept<DataMemAndPtr> {
-  template <typename... Args>
-  struct AcceptImpl : std::false_type {};
-
-  template <typename R, typename C, typename Ptr>
-  struct AcceptImpl<R C::*, Ptr>
-      : std::integral_constant<bool, !std::is_base_of<C, Ptr>::value &&
-                                         !absl::is_function<R>::value> {};
-
-  template <typename DataMem, typename Ptr>
-  static decltype((*std::declval<Ptr>()).*std::declval<DataMem>()) Invoke(
-      DataMem&& data_mem, Ptr&& ptr) {
-    return (*std::forward<Ptr>(ptr)).*std::forward<DataMem>(data_mem);
-  }
-};
-
-// f(t1, t2, ..., tN) in all other cases.
-struct Callable {
-  // Callable doesn't have Accept because it's the last clause that gets picked
-  // when none of the previous clauses are applicable.
-  template <typename F, typename... Args>
-  static decltype(std::declval<F>()(std::declval<Args>()...)) Invoke(
-      F&& f, Args&&... args) {
-    return std::forward<F>(f)(std::forward<Args>(args)...);
-  }
-};
-
-// Resolves to the first matching clause.
-template <typename... Args>
-struct Invoker {
-  typedef typename std::conditional<
-      MemFunAndRef::Accept<Args...>::value, MemFunAndRef,
-      typename std::conditional<
-          MemFunAndPtr::Accept<Args...>::value, MemFunAndPtr,
-          typename std::conditional<
-              DataMemAndRef::Accept<Args...>::value, DataMemAndRef,
-              typename std::conditional<DataMemAndPtr::Accept<Args...>::value,
-                                        DataMemAndPtr, Callable>::type>::type>::
-          type>::type type;
-};
-
-// The result type of Invoke<F, Args...>.
-template <typename F, typename... Args>
-using invoke_result_t = decltype(Invoker<F, Args...>::type::Invoke(
-    std::declval<F>(), std::declval<Args>()...));
-
-// Invoke(f, args...) is an implementation of INVOKE(f, args...) from section
-// [func.require] of the C++ standard.
-template <typename F, typename... Args>
-invoke_result_t<F, Args...> invoke(F&& f, Args&&... args) {
-  return Invoker<F, Args...>::type::Invoke(std::forward<F>(f),
-                                           std::forward<Args>(args)...);
-}
-
-template <typename AlwaysVoid, typename, typename, typename...>
-struct IsInvocableRImpl : std::false_type {};
-
-template <typename R, typename F, typename... Args>
-struct IsInvocableRImpl<
-    absl::void_t<absl::base_internal::invoke_result_t<F, Args...> >, R, F,
-    Args...>
-    : std::integral_constant<
-          bool,
-          std::is_convertible<absl::base_internal::invoke_result_t<F, Args...>,
-                              R>::value ||
-              std::is_void<R>::value> {};
-
-// Type trait whose member `value` is true if invoking `F` with `Args` is valid,
-// and either the return type is convertible to `R`, or `R` is void.
-// C++11-compatible version of `std::is_invocable_r`.
-template <typename R, typename F, typename... Args>
-using is_invocable_r = IsInvocableRImpl<void, R, F, Args...>;
-
-}  // namespace base_internal
-ABSL_NAMESPACE_END
-}  // namespace absl
-
-#endif  // ABSL_INTERNAL_CPLUSPLUS_LANG >= 201703L
-
-#endif  // ABSL_BASE_INTERNAL_INVOKE_H_