grpc 1.72.0 → 1.74.0.pre2

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

@@ -1,119 +0,0 @@
-//
-//
-// Copyright 2015 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_EXECUTOR_H
-#define GRPC_SRC_CORE_LIB_IOMGR_EXECUTOR_H
-
-#include <grpc/support/port_platform.h>
-
-#include "src/core/lib/iomgr/closure.h"
-#include "src/core/util/spinlock.h"
-#include "src/core/util/thd.h"
-
-namespace grpc_core {
-
-struct ThreadState {
-  gpr_mu mu;
-  size_t id;         // For debugging purposes
-  const char* name;  // Thread state name
-  gpr_cv cv;
-  grpc_closure_list elems;
-  size_t depth;  // Number of closures in the closure list
-  bool shutdown;
-  bool queued_long_job;
-  Thread thd;
-};
-
-enum class ExecutorType {
-  DEFAULT = 0,
-  RESOLVER,
-
-  NUM_EXECUTORS  // Add new values above this
-};
-
-enum class ExecutorJobType {
-  SHORT = 0,
-  LONG,
-  NUM_JOB_TYPES  // Add new values above this
-};
-
-class Executor {
- public:
-  explicit Executor(const char* executor_name);
-
-  void Init();
-
-  /// Is the executor multi-threaded?
-  bool IsThreaded() const;
-
-  // Enable/disable threading - must be called after Init and Shutdown(). Never
-  // call SetThreading(false) in the middle of an application
-  void SetThreading(bool threading);
-
-  /// Shutdown the executor, running all pending work as part of the call
-  void Shutdown();
-
-  /// Enqueue the closure onto the executor. is_short is true if the closure is
-  /// a short job (i.e expected to not block and complete quickly)
-  void Enqueue(grpc_closure* closure, grpc_error_handle error, bool is_short);
-
-  // TODO(sreek): Currently we have two executors (available globally): The
-  // default executor and the resolver executor.
-  //
-  // Some of the functions below operate on the DEFAULT executor only while some
-  // operate of ALL the executors. This is a bit confusing and should be cleaned
-  // up in future (where we make all the following functions take ExecutorType
-  // and/or JobType)
-
-  // Initialize ALL the executors
-  static void InitAll();
-
-  static void Run(grpc_closure* closure, grpc_error_handle error,
-                  ExecutorType executor_type = ExecutorType::DEFAULT,
-                  ExecutorJobType job_type = ExecutorJobType::SHORT);
-
-  // Shutdown ALL the executors
-  static void ShutdownAll();
-
-  // Set the threading mode for ALL the executors
-  static void SetThreadingAll(bool enable);
-
-  // Set the threading mode for ALL the executors
-  static void SetThreadingDefault(bool enable);
-
-  // Return if a given executor is running in threaded mode (i.e if
-  // SetThreading(true) was called previously on that executor)
-  static bool IsThreaded(ExecutorType executor_type);
-
-  // Return if the DEFAULT executor is threaded
-  static bool IsThreadedDefault();
-
- private:
-  static size_t RunClosures(const char* executor_name, grpc_closure_list list);
-  static void ThreadMain(void* arg);
-
-  const char* name_;
-  ThreadState* thd_state_;
-  size_t max_threads_;
-  gpr_atm num_threads_;
-  gpr_spinlock adding_thread_lock_;
-};
-
-}  // namespace grpc_core
-
-#endif  // GRPC_SRC_CORE_LIB_IOMGR_EXECUTOR_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/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_

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

@@ -1,108 +0,0 @@
-// Copyright 2023 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_NULLABILITY_IMPL_H_
-#define ABSL_BASE_INTERNAL_NULLABILITY_IMPL_H_
-
-#include <memory>
-#include <type_traits>
-
-#include "absl/base/attributes.h"
-#include "absl/base/config.h"
-#include "absl/meta/type_traits.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace nullability_internal {
-
-// `IsNullabilityCompatible` checks whether its first argument is a class
-// explicitly tagged as supporting nullability annotations. The tag is the type
-// declaration `absl_nullability_compatible`.
-template <typename, typename = void>
-struct IsNullabilityCompatible : std::false_type {};
-
-template <typename T>
-struct IsNullabilityCompatible<
-    T, absl::void_t<typename T::absl_nullability_compatible>> : std::true_type {
-};
-
-template <typename T>
-constexpr bool IsSupportedType = IsNullabilityCompatible<T>::value;
-
-template <typename T>
-constexpr bool IsSupportedType<T*> = true;
-
-template <typename T, typename U>
-constexpr bool IsSupportedType<T U::*> = true;
-
-template <typename T, typename... Deleter>
-constexpr bool IsSupportedType<std::unique_ptr<T, Deleter...>> = true;
-
-template <typename T>
-constexpr bool IsSupportedType<std::shared_ptr<T>> = true;
-
-template <typename T>
-struct EnableNullable {
-  static_assert(nullability_internal::IsSupportedType<std::remove_cv_t<T>>,
-                "Template argument must be a raw or supported smart pointer "
-                "type. See absl/base/nullability.h.");
-  using type = T;
-};
-
-template <typename T>
-struct EnableNonnull {
-  static_assert(nullability_internal::IsSupportedType<std::remove_cv_t<T>>,
-                "Template argument must be a raw or supported smart pointer "
-                "type. See absl/base/nullability.h.");
-  using type = T;
-};
-
-template <typename T>
-struct EnableNullabilityUnknown {
-  static_assert(nullability_internal::IsSupportedType<std::remove_cv_t<T>>,
-                "Template argument must be a raw or supported smart pointer "
-                "type. See absl/base/nullability.h.");
-  using type = T;
-};
-
-// Note: we do not apply Clang nullability attributes (e.g. _Nullable).  These
-// only support raw pointers, and conditionally enabling them only for raw
-// pointers inhibits template arg deduction.  Ideally, they would support all
-// pointer-like types.
-template <typename T, typename = typename EnableNullable<T>::type>
-using NullableImpl
-#if ABSL_HAVE_CPP_ATTRIBUTE(clang::annotate)
-    [[clang::annotate("Nullable")]]
-#endif
-    = T;
-
-template <typename T, typename = typename EnableNonnull<T>::type>
-using NonnullImpl
-#if ABSL_HAVE_CPP_ATTRIBUTE(clang::annotate)
-    [[clang::annotate("Nonnull")]]
-#endif
-    = T;
-
-template <typename T, typename = typename EnableNullabilityUnknown<T>::type>
-using NullabilityUnknownImpl
-#if ABSL_HAVE_CPP_ATTRIBUTE(clang::annotate)
-    [[clang::annotate("Nullability_Unspecified")]]
-#endif
-    = T;
-
-}  // namespace nullability_internal
-ABSL_NAMESPACE_END
-}  // namespace absl
-
-#endif  // ABSL_BASE_INTERNAL_NULLABILITY_IMPL_H_

data/third_party/abseil-cpp/absl/log/log_entry.cc

@@ -1,41 +0,0 @@
-//
-// Copyright 2022 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.
-
-#include "absl/log/log_entry.h"
-
-#include "absl/base/config.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-#ifdef ABSL_INTERNAL_NEED_REDUNDANT_CONSTEXPR_DECL
-constexpr int LogEntry::kNoVerbosityLevel;
-constexpr int LogEntry::kNoVerboseLevel;
-#endif
-
-// https://github.com/abseil/abseil-cpp/issues/1465
-// CMake builds on Apple platforms error when libraries are empty.
-// Our CMake configuration can avoid this error on header-only libraries,
-// but since this library is conditionally empty, including a single
-// variable is an easy workaround.
-#ifdef __APPLE__
-namespace log_internal {
-extern const char kAvoidEmptyLogEntryLibraryWarning;
-const char kAvoidEmptyLogEntryLibraryWarning = 0;
-}  // namespace log_internal
-#endif  // __APPLE__
-
-ABSL_NAMESPACE_END
-}  // namespace absl