grpc 1.65.1 → 1.66.0.pre3

data/src/core/lib/promise/status_flag.h

@@ -15,9 +15,12 @@
 #ifndef GRPC_SRC_CORE_LIB_PROMISE_STATUS_FLAG_H
 #define GRPC_SRC_CORE_LIB_PROMISE_STATUS_FLAG_H
 
+#include <ostream>
+
 #include "absl/log/check.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
+#include "absl/strings/str_cat.h"
 #include "absl/types/optional.h"
 
 #include <grpc/support/log.h>
@@ -40,43 +43,58 @@ struct Success {
   }
 };
 
-inline bool IsStatusOk(Failure) { return false; }
-inline bool IsStatusOk(Success) { return true; }
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline bool IsStatusOk(Failure) {
+  return false;
+}
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline bool IsStatusOk(Success) {
+  return true;
+}
 
 template <>
 struct StatusCastImpl<absl::Status, Success> {
-  static absl::Status Cast(Success) { return absl::OkStatus(); }
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static absl::Status Cast(Success) {
+    return absl::OkStatus();
+  }
 };
 
 template <>
 struct StatusCastImpl<absl::Status, const Success&> {
-  static absl::Status Cast(Success) { return absl::OkStatus(); }
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static absl::Status Cast(Success) {
+    return absl::OkStatus();
+  }
 };
 
 template <>
 struct StatusCastImpl<absl::Status, Failure> {
-  static absl::Status Cast(Failure) { return absl::CancelledError(); }
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static absl::Status Cast(Failure) {
+    return absl::CancelledError();
+  }
 };
 
 template <typename T>
 struct StatusCastImpl<absl::StatusOr<T>, Failure> {
-  static absl::StatusOr<T> Cast(Failure) { return absl::CancelledError(); }
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static absl::StatusOr<T> Cast(Failure) {
+    return absl::CancelledError();
+  }
 };
 
 // A boolean representing whether an operation succeeded (true) or failed
 // (false).
 class StatusFlag {
  public:
-  StatusFlag() : value_(true) {}
-  explicit StatusFlag(bool value) : value_(value) {}
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION StatusFlag() : value_(true) {}
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION explicit StatusFlag(bool value)
+      : value_(value) {}
   // NOLINTNEXTLINE(google-explicit-constructor)
-  StatusFlag(Failure) : value_(false) {}
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION StatusFlag(Failure) : value_(false) {}
   // NOLINTNEXTLINE(google-explicit-constructor)
-  StatusFlag(Success) : value_(true) {}
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION StatusFlag(Success) : value_(true) {}
 
-  bool ok() const { return value_; }
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION bool ok() const { return value_; }
 
-  bool operator==(StatusFlag other) const { return value_ == other.value_; }
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION bool operator==(StatusFlag other) const {
+    return value_ == other.value_;
+  }
   std::string ToString() const { return value_ ? "ok" : "failed"; }
 
   template <typename Sink>
@@ -92,42 +110,78 @@ class StatusFlag {
   bool value_;
 };
 
-inline bool operator==(StatusFlag flag, Failure) { return !flag.ok(); }
-inline bool operator==(Failure, StatusFlag flag) { return !flag.ok(); }
-inline bool operator==(StatusFlag flag, Success) { return flag.ok(); }
-inline bool operator==(Success, StatusFlag flag) { return flag.ok(); }
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline bool operator==(StatusFlag flag,
+                                                            Failure) {
+  return !flag.ok();
+}
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline bool operator==(Failure,
+                                                            StatusFlag flag) {
+  return !flag.ok();
+}
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline bool operator==(StatusFlag flag,
+                                                            Success) {
+  return flag.ok();
+}
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline bool operator==(Success,
+                                                            StatusFlag flag) {
+  return flag.ok();
+}
 
-inline bool operator!=(StatusFlag flag, Failure) { return flag.ok(); }
-inline bool operator!=(Failure, StatusFlag flag) { return flag.ok(); }
-inline bool operator!=(StatusFlag flag, Success) { return !flag.ok(); }
-inline bool operator!=(Success, StatusFlag flag) { return !flag.ok(); }
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline bool operator!=(StatusFlag flag,
+                                                            Failure) {
+  return flag.ok();
+}
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline bool operator!=(Failure,
+                                                            StatusFlag flag) {
+  return flag.ok();
+}
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline bool operator!=(StatusFlag flag,
+                                                            Success) {
+  return !flag.ok();
+}
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline bool operator!=(Success,
+                                                            StatusFlag flag) {
+  return !flag.ok();
+}
 
-inline bool IsStatusOk(const StatusFlag& flag) { return flag.ok(); }
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline bool IsStatusOk(
+    const StatusFlag& flag) {
+  return flag.ok();
+}
 
 template <>
 struct StatusCastImpl<absl::Status, StatusFlag> {
-  static absl::Status Cast(StatusFlag flag) {
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static absl::Status Cast(
+      StatusFlag flag) {
     return flag.ok() ? absl::OkStatus() : absl::CancelledError();
   }
 };
 
 template <>
 struct StatusCastImpl<absl::Status, StatusFlag&> {
-  static absl::Status Cast(StatusFlag flag) {
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static absl::Status Cast(
+      StatusFlag flag) {
     return flag.ok() ? absl::OkStatus() : absl::CancelledError();
   }
 };
 
 template <>
 struct StatusCastImpl<absl::Status, const StatusFlag&> {
-  static absl::Status Cast(StatusFlag flag) {
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static absl::Status Cast(
+      StatusFlag flag) {
     return flag.ok() ? absl::OkStatus() : absl::CancelledError();
   }
 };
 
+template <>
+struct StatusCastImpl<StatusFlag, Success> {
+  static StatusFlag Cast(Success) { return StatusFlag(true); }
+};
+
 template <typename T>
 struct FailureStatusCastImpl<absl::StatusOr<T>, StatusFlag> {
-  static absl::StatusOr<T> Cast(StatusFlag flag) {
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static absl::StatusOr<T> Cast(
+      StatusFlag flag) {
     DCHECK(!flag.ok());
     return absl::CancelledError();
   }
@@ -135,7 +189,8 @@ struct FailureStatusCastImpl<absl::StatusOr<T>, StatusFlag> {
 
 template <typename T>
 struct FailureStatusCastImpl<absl::StatusOr<T>, StatusFlag&> {
-  static absl::StatusOr<T> Cast(StatusFlag flag) {
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static absl::StatusOr<T> Cast(
+      StatusFlag flag) {
     DCHECK(!flag.ok());
     return absl::CancelledError();
   }
@@ -143,7 +198,8 @@ struct FailureStatusCastImpl<absl::StatusOr<T>, StatusFlag&> {
 
 template <typename T>
 struct FailureStatusCastImpl<absl::StatusOr<T>, const StatusFlag&> {
-  static absl::StatusOr<T> Cast(StatusFlag flag) {
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static absl::StatusOr<T> Cast(
+      StatusFlag flag) {
     DCHECK(!flag.ok());
     return absl::CancelledError();
   }
@@ -160,49 +216,90 @@ class ValueOrFailure {
   // NOLINTNEXTLINE(google-explicit-constructor)
   ValueOrFailure(StatusFlag status) { CHECK(!status.ok()); }
 
-  static ValueOrFailure FromOptional(absl::optional<T> value) {
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static ValueOrFailure FromOptional(
+      absl::optional<T> value) {
     return ValueOrFailure{std::move(value)};
   }
 
-  bool ok() const { return value_.has_value(); }
-  StatusFlag status() const { return StatusFlag(ok()); }
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION bool ok() const {
+    return value_.has_value();
+  }
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION StatusFlag status() const {
+    return StatusFlag(ok());
+  }
 
-  const T& value() const { return value_.value(); }
-  T& value() { return value_.value(); }
-  const T& operator*() const { return *value_; }
-  T& operator*() { return *value_; }
-  const T* operator->() const { return &*value_; }
-  T* operator->() { return &*value_; }
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION const T& value() const {
+    return value_.value();
+  }
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION T& value() { return value_.value(); }
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION const T& operator*() const {
+    return *value_;
+  }
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION T& operator*() { return *value_; }
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION const T* operator->() const {
+    return &*value_;
+  }
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION T* operator->() { return &*value_; }
 
-  bool operator==(const ValueOrFailure& other) const {
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION bool operator==(
+      const ValueOrFailure& other) const {
     return value_ == other.value_;
   }
 
-  bool operator!=(const ValueOrFailure& other) const {
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION bool operator!=(
+      const ValueOrFailure& other) const {
     return value_ != other.value_;
   }
 
-  bool operator==(const T& other) const { return value_ == other; }
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION bool operator==(const T& other) const {
+    return value_ == other;
+  }
 
-  bool operator!=(const T& other) const { return value_ != other; }
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION bool operator!=(const T& other) const {
+    return value_ != other;
+  }
+
+  template <typename Sink>
+  friend void AbslStringify(Sink& sink, const ValueOrFailure& value) {
+    if (value.ok()) {
+      sink.Append("Success(");
+      sink.Append(absl::StrCat(*value));
+      sink.Append(")");
+    } else {
+      sink.Append("Failure");
+    }
+  }
 
  private:
   absl::optional<T> value_;
 };
 
 template <typename T>
-inline bool IsStatusOk(const ValueOrFailure<T>& value) {
+inline std::ostream& operator<<(std::ostream& os,
+                                const ValueOrFailure<T>& value) {
+  if (value.ok()) {
+    return os << "Success(" << *value << ")";
+  } else {
+    return os << "Failure";
+  }
+}
+
+template <typename T>
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline bool IsStatusOk(
+    const ValueOrFailure<T>& value) {
   return value.ok();
 }
 
 template <typename T>
-inline T TakeValue(ValueOrFailure<T>&& value) {
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline T TakeValue(
+    ValueOrFailure<T>&& value) {
   return std::move(value.value());
 }
 
 template <typename T>
 struct StatusCastImpl<absl::StatusOr<T>, ValueOrFailure<T>> {
-  static absl::StatusOr<T> Cast(ValueOrFailure<T> value) {
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static absl::StatusOr<T> Cast(
+      ValueOrFailure<T> value) {
     return value.ok() ? absl::StatusOr<T>(std::move(value.value()))
                       : absl::CancelledError();
   }
@@ -210,14 +307,15 @@ struct StatusCastImpl<absl::StatusOr<T>, ValueOrFailure<T>> {
 
 template <typename T>
 struct StatusCastImpl<ValueOrFailure<T>, Failure> {
-  static ValueOrFailure<T> Cast(Failure) {
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static ValueOrFailure<T> Cast(Failure) {
     return ValueOrFailure<T>(Failure{});
   }
 };
 
 template <typename T>
 struct StatusCastImpl<ValueOrFailure<T>, StatusFlag&> {
-  static ValueOrFailure<T> Cast(StatusFlag f) {
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static ValueOrFailure<T> Cast(
+      StatusFlag f) {
     CHECK(!f.ok());
     return ValueOrFailure<T>(Failure{});
   }
@@ -225,7 +323,8 @@ struct StatusCastImpl<ValueOrFailure<T>, StatusFlag&> {
 
 template <typename T>
 struct StatusCastImpl<ValueOrFailure<T>, StatusFlag> {
-  static ValueOrFailure<T> Cast(StatusFlag f) {
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static ValueOrFailure<T> Cast(
+      StatusFlag f) {
     CHECK(!f.ok());
     return ValueOrFailure<T>(Failure{});
   }
@@ -233,4 +332,4 @@ struct StatusCastImpl<ValueOrFailure<T>, StatusFlag> {
 
 }  // namespace grpc_core
 
-#endif  // GRPC_SRC_CORE_LIB_PROMISE_STATUS_FLAG_H
+#endif  // GRPC_SRC_CORE_LIB_PROMISE_STATUS_FLAG_H

data/src/core/lib/promise/try_join.h

@@ -51,44 +51,56 @@ struct TryJoinTraits {
   template <typename T>
   using ResultType = Result<absl::remove_reference_t<T>>;
   template <typename T>
-  static bool IsOk(const absl::StatusOr<T>& x) {
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static bool IsOk(
+      const absl::StatusOr<T>& x) {
+    return x.ok();
+  }
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static bool IsOk(const absl::Status& x) {
+    return x.ok();
+  }
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static bool IsOk(StatusFlag x) {
     return x.ok();
   }
-  static bool IsOk(const absl::Status& x) { return x.ok(); }
-  static bool IsOk(StatusFlag x) { return x.ok(); }
   template <typename T>
-  static bool IsOk(const ValueOrFailure<T>& x) {
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static bool IsOk(
+      const ValueOrFailure<T>& x) {
     return x.ok();
   }
   template <typename T>
-  static T Unwrapped(absl::StatusOr<T> x) {
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static T Unwrapped(absl::StatusOr<T> x) {
     return std::move(*x);
   }
   template <typename T>
-  static T Unwrapped(ValueOrFailure<T> x) {
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static T Unwrapped(ValueOrFailure<T> x) {
     return std::move(*x);
   }
-  static Empty Unwrapped(absl::Status) { return Empty{}; }
-  static Empty Unwrapped(StatusFlag) { return Empty{}; }
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static Empty Unwrapped(absl::Status) {
+    return Empty{};
+  }
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static Empty Unwrapped(StatusFlag) {
+    return Empty{};
+  }
   template <typename R, typename T>
-  static R EarlyReturn(absl::StatusOr<T> x) {
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static R EarlyReturn(
+      absl::StatusOr<T> x) {
     return x.status();
   }
   template <typename R>
-  static R EarlyReturn(absl::Status x) {
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static R EarlyReturn(absl::Status x) {
     return FailureStatusCast<R>(std::move(x));
   }
   template <typename R>
-  static R EarlyReturn(StatusFlag x) {
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static R EarlyReturn(StatusFlag x) {
     return FailureStatusCast<R>(x);
   }
   template <typename R, typename T>
-  static R EarlyReturn(const ValueOrFailure<T>& x) {
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static R EarlyReturn(
+      const ValueOrFailure<T>& x) {
     CHECK(!x.ok());
     return FailureStatusCast<R>(Failure{});
   }
   template <typename... A>
-  static auto FinalReturn(A&&... a) {
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static auto FinalReturn(A&&... a) {
     return Result<std::tuple<A...>>(std::make_tuple(std::forward<A>(a)...));
   }
 };
@@ -97,8 +109,11 @@ struct TryJoinTraits {
 template <template <typename> class R, typename... Promises>
 class TryJoin {
  public:
-  explicit TryJoin(Promises... promises) : state_(std::move(promises)...) {}
-  auto operator()() { return state_.PollOnce(); }
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION explicit TryJoin(Promises... promises)
+      : state_(std::move(promises)...) {}
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION auto operator()() {
+    return state_.PollOnce();
+  }
 
  private:
   JoinState<TryJoinTraits<R>, Promises...> state_;
@@ -107,7 +122,7 @@ class TryJoin {
 template <template <typename> class R>
 struct WrapInStatusOrTuple {
   template <typename T>
-  R<std::tuple<T>> operator()(R<T> x) {
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION R<std::tuple<T>> operator()(R<T> x) {
     if (!x.ok()) return x.status();
     return std::make_tuple(std::move(*x));
   }
@@ -119,12 +134,13 @@ struct WrapInStatusOrTuple {
 // If any fail, cancel the rest and return the failure.
 // If all succeed, return Ok(tuple-of-results).
 template <template <typename> class R, typename... Promises>
-promise_detail::TryJoin<R, Promises...> TryJoin(Promises... promises) {
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION promise_detail::TryJoin<R, Promises...>
+TryJoin(Promises... promises) {
   return promise_detail::TryJoin<R, Promises...>(std::move(promises)...);
 }
 
 template <template <typename> class R, typename F>
-auto TryJoin(F promise) {
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION auto TryJoin(F promise) {
   return Map(promise, promise_detail::WrapInStatusOrTuple<R>{});
 }