grpc 1.84.1 → 1.85.0.pre1

data/third_party/abseil-cpp/absl/types/optional_ref.h

@@ -0,0 +1,295 @@
+// Copyright 2026 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.
+//
+// -----------------------------------------------------------------------------
+// File: optional_ref.h
+// -----------------------------------------------------------------------------
+//
+// `optional_ref<T>` provides a `std::optional`-like interface around `T*`.
+// It is similar to C++26's `std::optional<T&>`, but with slight enhancements,
+// such as the fact that it permits construction from rvalues. That is, it
+// relaxes the std::reference_constructs_from_temporary constraint. Its intent
+// is to make it easier for functions to accept nullable object addresses,
+// regardless of whether or not they point to temporaries.
+//
+// It can be constructed in the following ways:
+//   * optional_ref<T> ref;
+//   * optional_ref<T> ref = std::nullopt;
+//   * T foo; optional_ref<T> ref = foo;
+//   * std::optional<T> foo; optional_ref<T> ref = foo;
+//   * T* foo = ...; optional_ref<T> ref = foo;
+//   * optional_ref<T> foo; optional_ref<const T> ref = foo;
+//
+// Since it is trivially copyable and destructible, it should be passed by
+// value.
+//
+// Other properties:
+//   * Assignment is not allowed. Example:
+//       optional_ref<int> ref;
+//       // Compile error.
+//       ref = 2;
+//
+//   * operator bool() is intentionally not defined, as it would be error prone
+//     for optional_ref<bool>.
+//
+// Example usage, assuming some type `T` that is expensive to copy:
+//   void ProcessT(optional_ref<const T> input) {
+//     if (!input.has_value()) {
+//       // Handle empty case.
+//       return;
+//     }
+//     const T& val = *input;
+//     // Do something with val.
+//   }
+//
+//   ProcessT(std::nullopt);
+//   ProcessT(BuildT());
+
+#ifndef ABSL_TYPES_OPTIONAL_REF_H_
+#define ABSL_TYPES_OPTIONAL_REF_H_
+
+#include <cstddef>
+#include <memory>
+#include <optional>
+#include <type_traits>
+#include <utility>
+
+#include "absl/base/attributes.h"
+#include "absl/base/config.h"
+#include "absl/base/internal/hardening.h"
+#include "absl/base/macros.h"
+#include "absl/base/optimization.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+template <typename T>
+class optional_ref {
+  template <typename U>
+  using EnableIfConvertibleFrom =
+      std::enable_if_t<std::is_convertible_v<U*, T*>>;
+
+ public:
+  using value_type = T;
+
+  constexpr optional_ref() : ptr_(nullptr) {}
+  constexpr optional_ref(  // NOLINT(google-explicit-constructor)
+      std::nullopt_t)
+      : ptr_(nullptr) {}
+
+  // Constructor given a concrete value.
+  constexpr optional_ref(  // NOLINT(google-explicit-constructor)
+      T& input ABSL_ATTRIBUTE_LIFETIME_BOUND)
+      : ptr_(std::addressof(input)) {}
+
+  // Constructors given an existing std::optional value.
+  // Templated on the input optional's type to avoid creating a temporary.
+  template <typename U, typename = EnableIfConvertibleFrom<const U>>
+  constexpr optional_ref(  // NOLINT(google-explicit-constructor)
+      const std::optional<U>& input ABSL_ATTRIBUTE_LIFETIME_BOUND)
+      : ptr_(input.has_value() ? std::addressof(*input) : nullptr) {}
+  template <typename U, typename = EnableIfConvertibleFrom<U>>
+  constexpr optional_ref(  // NOLINT(google-explicit-constructor)
+      std::optional<U>& input ABSL_ATTRIBUTE_LIFETIME_BOUND)
+      : ptr_(input.has_value() ? std::addressof(*input) : nullptr) {}
+
+  // Constructor given a T*, where nullptr indicates empty/absent.
+  constexpr optional_ref(  // NOLINT(google-explicit-constructor)
+      T* input ABSL_ATTRIBUTE_LIFETIME_BOUND)
+      : ptr_(input) {}
+
+  // Don't allow naked nullptr as input, as this creates confusion in the case
+  // of optional_ref<T*>. Use std::nullopt instead to create an empty
+  // optional_ref.
+  constexpr optional_ref(  // NOLINT(google-explicit-constructor)
+      std::nullptr_t) = delete;
+
+  // Copying is allowed.
+  optional_ref(const optional_ref<T>&) = default;
+  // Assignment is not allowed.
+  optional_ref<T>& operator=(const optional_ref<T>&) = delete;
+
+  // Conversion from optional_ref<U> is allowed iff U* is convertible to T*.
+  // (Note this also allows non-const to const conversions.)
+  template <typename U, typename = EnableIfConvertibleFrom<U>>
+  constexpr optional_ref(  // NOLINT(google-explicit-constructor)
+      optional_ref<U> input)
+      : ptr_(input.as_pointer()) {}
+
+  // Determines whether the `optional_ref` contains a value. Returns `false` if
+  // and only if `*this` is empty.
+  constexpr bool has_value() const { return ptr_ != nullptr; }
+
+  // Returns a reference to an `optional_ref`s underlying value. The constness
+  // and lvalue/rvalue-ness of the `optional_ref` is preserved to the view of
+  // the `T` sub-object. Throws the same error as `std::optional`'s `value()`
+  // when the `optional_ref` is empty.
+  constexpr T& value() const {
+    return ABSL_PREDICT_TRUE(ptr_ != nullptr)
+               ? *ptr_
+               // Replicate the same error logic as in `std::optional`'s
+               // `value()`. It either throws an exception or aborts the
+               // program. We intentionally ignore the return value of
+               // the constructed optional's value as we only need to run
+               // the code for error checking.
+               : ((void)std::optional<T>().value(), *ptr_);
+  }
+
+  // Returns the value iff *this has a value, otherwise returns `default_value`.
+  template <typename U>
+  constexpr T value_or(U&& default_value) const {
+    // Instantiate std::optional<T>::value_or(U) to trigger its static_asserts.
+    if (false) {
+      // We use `std::add_const_t` here since just using `const` makes MSVC
+      // complain about the syntax.
+      (void)std::add_const_t<std::optional<T>>{}.value_or(
+          std::forward<U>(default_value));
+    }
+    return ptr_ != nullptr ? *ptr_
+                           : static_cast<T>(std::forward<U>(default_value));
+  }
+
+  // Accesses the underlying `T` value of an `optional_ref`. If the
+  // `optional_ref` is empty, behavior is undefined.
+  constexpr T& operator*() const {
+    absl::base_internal::HardeningAssertNonNull(ptr_);
+    return *ptr_;
+  }
+  constexpr T* operator->() const {
+    absl::base_internal::HardeningAssertNonNull(ptr_);
+    return ptr_;
+  }
+
+  // Convenience function to represent the `optional_ref` as a `T*` pointer.
+  constexpr T* as_pointer() const { return ptr_; }
+  // Convenience function to represent the `optional_ref` as an `optional`,
+  // which incurs a copy when the `optional_ref` is non-empty. The template type
+  // allows for implicit type conversion; example:
+  //   optional_ref<std::string> a = ...;
+  //   std::optional<std::string_view> b = a.as_optional<std::string_view>();
+  template <typename U = std::decay_t<T>>
+  constexpr std::optional<U> as_optional() const {
+    if (ptr_ == nullptr) return std::nullopt;
+    return *ptr_;
+  }
+
+ private:
+  T* const ptr_;
+
+  // T constraint checks.  You can't have an optional of nullopt_t or
+  // in_place_t.
+  static_assert(!std::is_same_v<std::nullopt_t, std::remove_cv_t<T>>,
+                "optional_ref<nullopt_t> is not allowed.");
+  static_assert(!std::is_same_v<std::in_place_t, std::remove_cv_t<T>>,
+                "optional_ref<in_place_t> is not allowed.");
+};
+
+// Template type deduction guides:
+
+template <typename T>
+optional_ref(const T&) -> optional_ref<const T>;
+template <typename T>
+optional_ref(T&) -> optional_ref<T>;
+
+template <typename T>
+optional_ref(const std::optional<T>&) -> optional_ref<const T>;
+template <typename T>
+optional_ref(std::optional<T>&) -> optional_ref<T>;
+
+template <typename T>
+optional_ref(T*) -> optional_ref<T>;
+
+namespace optional_ref_internal {
+
+// This is a C++-11 compatible version of std::equality_comparable_with that
+// only requires `t == u` is a valid boolean expression.
+//
+// We still need this for a couple reasons:
+// -  As of 2026-02-13, Abseil supports C++17.
+//  - Even for targets that are built with the default toolchain, using
+//    std::equality_comparable_with gives us an error due to mutual recursion
+//    between its definition and our definition of operator==.
+//
+template <typename T, typename U>
+using enable_if_equality_comparable_t = std::enable_if_t<std::is_convertible_v<
+    decltype(std::declval<T>() == std::declval<U>()), bool>>;
+
+}  // namespace optional_ref_internal
+
+// Compare an optional referenced value to std::nullopt.
+
+template <typename T>
+constexpr bool operator==(optional_ref<T> a, std::nullopt_t) {
+  return !a.has_value();
+}
+template <typename T>
+constexpr bool operator==(std::nullopt_t, optional_ref<T> b) {
+  return !b.has_value();
+}
+template <typename T>
+constexpr bool operator!=(optional_ref<T> a, std::nullopt_t) {
+  return a.has_value();
+}
+template <typename T>
+constexpr bool operator!=(std::nullopt_t, optional_ref<T> b) {
+  return b.has_value();
+}
+
+// Compare two optional referenced values. Note, this does not test that the
+// contained `ptr_`s are equal. If the caller wants "shallow" reference equality
+// semantics, they should use `as_pointer()` explicitly.
+
+template <typename T, typename U>
+constexpr bool operator==(optional_ref<T> a, optional_ref<U> b) {
+  return a.has_value() ? *a == b : !b.has_value();
+}
+
+// Compare an optional referenced value to a non-optional value.
+
+template <
+    typename T, typename U,
+    typename = optional_ref_internal::enable_if_equality_comparable_t<T, U>>
+constexpr bool operator==(const T& a, optional_ref<U> b) {
+  return b.has_value() && a == *b;
+}
+template <
+    typename T, typename U,
+    typename = optional_ref_internal::enable_if_equality_comparable_t<T, U>>
+constexpr bool operator==(optional_ref<T> a, const U& b) {
+  return b == a;
+}
+
+// Inequality operators, as above.
+
+template <typename T, typename U>
+constexpr bool operator!=(optional_ref<T> a, optional_ref<U> b) {
+  return !(a == b);
+}
+template <
+    typename T, typename U,
+    typename = optional_ref_internal::enable_if_equality_comparable_t<T, U>>
+constexpr bool operator!=(optional_ref<T> a, const U& b) {
+  return !(a == b);
+}
+template <
+    typename T, typename U,
+    typename = optional_ref_internal::enable_if_equality_comparable_t<T, U>>
+constexpr bool operator!=(const T& a, optional_ref<U> b) {
+  return !(a == b);
+}
+
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_TYPES_OPTIONAL_REF_H_

data/third_party/{boringssl-with-bazel/crypto/x509/x_val.cc → abseil-cpp/absl/types/source_location.cc}

@@ -1,4 +1,4 @@
-// Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved.
+// Copyright 2026 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.
@@ -12,17 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include <stdio.h>
+#include "absl/types/source_location.h"
 
-#include <openssl/asn1t.h>
-#include <openssl/x509.h>
-
-#include "internal.h"
-
-
-ASN1_SEQUENCE(X509_VAL) = {
-    ASN1_SIMPLE(X509_VAL, notBefore, ASN1_TIME),
-    ASN1_SIMPLE(X509_VAL, notAfter, ASN1_TIME),
-} ASN1_SEQUENCE_END(X509_VAL)
-
-IMPLEMENT_ASN1_FUNCTIONS_const(X509_VAL)
+#include "absl/base/attributes.h"
+#include "absl/base/config.h"

data/third_party/abseil-cpp/absl/types/source_location.h

@@ -0,0 +1,172 @@
+// 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.
+//
+// -----------------------------------------------------------------------------
+// File: source_location.h
+// -----------------------------------------------------------------------------
+//
+// absl::SourceLocation provides source-code location info for C++17 and later.
+//
+// Critically, it is a **view type** (like std::string_view). Unlike
+// std::source_location, it is not permanently valid and must not outlive its
+// source. Using an invalid location is an error and may result in warnings
+// or crashes.
+//
+// Additionally, it does not guarantee the retention of all caller information
+// (e.g. column or function name) and may e.g. return unspecified values for
+// performance reasons.
+//
+// To define a function that has access to the source location of the
+// callsite, define it with a parameter of type `absl::SourceLocation`. The
+// caller can then invoke the function, passing
+// `absl::SourceLocation::current()` as the argument.
+//
+// If at all possible, make the `absl::SourceLocation` parameter be the
+// function's last parameter. That way, when `std::source_location` is
+// available, you will be able to switch to it, and give the parameter a default
+// argument of `std::source_location::current()`. Users will then be able to
+// omit that argument, and the default will automatically capture the location
+// of the callsite.
+
+#ifndef ABSL_TYPES_SOURCE_LOCATION_H_
+#define ABSL_TYPES_SOURCE_LOCATION_H_
+
+#include <cstdint>
+#include <type_traits>
+
+#include "absl/base/config.h"
+#include "absl/base/nullability.h"
+
+// This needs to come after absl/base/config.h, which is responsible for
+// defining ABSL_HAVE_STD_SOURCE_LOCATION
+#ifdef ABSL_HAVE_STD_SOURCE_LOCATION
+#include <source_location>  // NOLINT(build/c++20)
+#endif
+
+// For OSS release, whether to alias to std::source_location is configurable via
+// config.h/options.h, similar to std::string_view/variant/etc.
+#if defined(ABSL_USES_STD_SOURCE_LOCATION) && \
+    defined(ABSL_HAVE_STD_SOURCE_LOCATION)
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+using SourceLocation = std::source_location;
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#else  // ABSL_HAVE_STD_SOURCE_LOCATION
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+// C++17-compatible class representing a specific location in the source code of
+// a program. Similar to std::source_location, but with a few key differences
+// explained above.
+class SourceLocation {
+  struct PrivateTag {
+   private:
+    explicit PrivateTag() = default;
+    friend class SourceLocation;
+  };
+
+ public:
+  // Avoid this constructor; it populates the object with dummy values.
+  SourceLocation() = default;
+
+#ifdef ABSL_HAVE_STD_SOURCE_LOCATION
+  constexpr SourceLocation(  // NOLINT(google-explicit-constructor)
+      std::source_location loc)
+      : SourceLocation(loc.line(), loc.file_name()) {}
+#endif
+
+#ifdef ABSL_INTERNAL_HAVE_BUILTIN_LINE_FILE
+  // SourceLocation::current
+  //
+  // Creates a `SourceLocation` based on the current source location. Currently,
+  // it only captures file and line information for efficiency purposes, but
+  // that is subject to change. APIs that accept a `SourceLocation` as a default
+  // parameter can use this to capture their caller's locations.
+  //
+  // Example:
+  //
+  //   void TracedAdd(int i, SourceLocation loc = SourceLocation::current()) {
+  //     std::cout << loc.file_name() << ":" << loc.line() << " added " << i;
+  //     ...
+  //   }
+  //
+  //   void UserCode() {
+  //     TracedAdd(1);
+  //     TracedAdd(2);
+  //   }
+  static constexpr SourceLocation current(
+      PrivateTag = PrivateTag{}, std::uint_least32_t line = __builtin_LINE(),
+      const char* absl_nonnull file_name = __builtin_FILE()) {
+    return SourceLocation(line, file_name);
+  }
+#else
+  // Creates a dummy `SourceLocation` of "<source_location>" at line number 1,
+  // if no `SourceLocation::current()` implementation is available.
+  static constexpr SourceLocation current() {
+    return SourceLocation(1, "<source_location>");
+  }
+#endif
+  // The line number of the captured source location, or an unspecified value
+  // if this information is not available.
+  constexpr std::uint_least32_t line() const noexcept { return line_; }
+
+  // The column number of the captured source location, or an unspecified value
+  // if this information is not available.
+  constexpr std::uint_least32_t column() const noexcept { return 0; }
+
+  // The file name of the captured source location, or an unspecified string
+  // if this information is not available. Guaranteed to never be NULL.
+  constexpr const char* absl_nonnull file_name() const noexcept {
+    return file_name_;
+  }
+
+  // The function name of the captured source location, or an unspecified string
+  // if this information is not available. Guaranteed to never be NULL.
+  //
+  // NOTE: Currently, we deliberately avoid providing the function name, as it
+  // can bloat binary sizes and is non-critical. This may change in the future.
+  constexpr const char* absl_nonnull function_name() const noexcept {
+    return "";
+  }
+
+ private:
+  // `file_name` must outlive all copies of the `absl::SourceLocation` object,
+  // so in practice it should be a string literal.
+  constexpr SourceLocation(std::uint_least32_t line,
+                           const char* absl_nonnull file_name)
+      : line_(line), file_name_(file_name) {}
+
+  // We would use [[maybe_unused]] here, but it doesn't work on all supported
+  // toolchains at the moment.
+  friend constexpr int UseUnused() {
+    static_assert(SourceLocation(0, nullptr).unused_column_ == 0,
+                  "Use the otherwise-unused member.");
+    return 0;
+  }
+
+  // "unused" members are present to minimize future changes in the size of this
+  // type.
+  std::uint_least32_t line_ = 0;
+  std::uint_least32_t unused_column_ = 0;
+  const char* absl_nonnull file_name_ = "";
+};
+
+ABSL_NAMESPACE_END
+}  // namespace absl
+#endif  // ABSL_HAVE_STD_SOURCE_LOCATION
+
+#endif  // ABSL_TYPES_SOURCE_LOCATION_H_