grpc 1.50.0-x86_64-linux → 1.51.0-x86_64-linux

data/src/core/lib/promise/detail/promise_factory.h

@@ -74,6 +74,20 @@ struct ResultOfT<F(Args...),
   using T = decltype(std::declval<RemoveCVRef<F>>()(std::declval<Args>()...));
 };
 
+template <typename F, typename... Args>
+struct ResultOfT<F(Args...)&,
+                 absl::void_t<decltype(std::declval<RemoveCVRef<F>>()(
+                     std::declval<Args>()...))>> {
+  using T = decltype(std::declval<RemoveCVRef<F>>()(std::declval<Args>()...));
+};
+
+template <typename F, typename... Args>
+struct ResultOfT<const F(Args...)&,
+                 absl::void_t<decltype(std::declval<RemoveCVRef<F>>()(
+                     std::declval<Args>()...))>> {
+  using T = decltype(std::declval<RemoveCVRef<F>>()(std::declval<Args>()...));
+};
+
 template <typename T>
 using ResultOf = typename ResultOfT<T>::T;
 
@@ -127,6 +141,14 @@ PromiseFactoryImpl(F&& f, A&& arg) {
   return f(std::forward<A>(arg));
 }
 
+// Given a callable(A) -> Promise<T>, name it a PromiseFactory and use it.
+template <typename A, typename F>
+absl::enable_if_t<IsVoidCallable<ResultOf<F(A)>>::value,
+                  PromiseLike<decltype(std::declval<F>()(std::declval<A>()))>>
+PromiseFactoryImpl(F& f, A&& arg) {
+  return f(std::forward<A>(arg));
+}
+
 // Given a callable() -> Promise<T>, promote it to a
 // PromiseFactory(A) -> Promise<T> by dropping the first argument.
 template <typename A, typename F>
@@ -145,7 +167,7 @@ PromiseFactoryImpl(F&& f) {
 };
 
 template <typename A, typename F>
-class PromiseFactory {
+class OncePromiseFactory {
  private:
   GPR_NO_UNIQUE_ADDRESS F f_;
 
@@ -154,31 +176,57 @@ class PromiseFactory {
   using Promise =
       decltype(PromiseFactoryImpl(std::move(f_), std::declval<A>()));
 
-  explicit PromiseFactory(F f) : f_(std::move(f)) {}
+  explicit OncePromiseFactory(F f) : f_(std::move(f)) {}
 
-  Promise Once(Arg&& a) {
+  Promise Make(Arg&& a) {
     return PromiseFactoryImpl(std::move(f_), std::forward<Arg>(a));
   }
+};
 
-  Promise Repeated(Arg&& a) const {
+template <typename F>
+class OncePromiseFactory<void, F> {
+ private:
+  GPR_NO_UNIQUE_ADDRESS F f_;
+
+ public:
+  using Arg = void;
+  using Promise = decltype(PromiseFactoryImpl(std::move(f_)));
+
+  explicit OncePromiseFactory(F f) : f_(std::move(f)) {}
+
+  Promise Make() { return PromiseFactoryImpl(std::move(f_)); }
+};
+
+template <typename A, typename F>
+class RepeatedPromiseFactory {
+ private:
+  GPR_NO_UNIQUE_ADDRESS F f_;
+
+ public:
+  using Arg = A;
+  using Promise = decltype(PromiseFactoryImpl(f_, std::declval<A>()));
+
+  explicit RepeatedPromiseFactory(F f) : f_(std::move(f)) {}
+
+  Promise Make(Arg&& a) const {
     return PromiseFactoryImpl(f_, std::forward<Arg>(a));
   }
+  Promise Make(Arg&& a) { return PromiseFactoryImpl(f_, std::forward<Arg>(a)); }
 };
 
 template <typename F>
-class PromiseFactory<void, F> {
+class RepeatedPromiseFactory<void, F> {
  private:
   GPR_NO_UNIQUE_ADDRESS F f_;
 
  public:
   using Arg = void;
-  using Promise = decltype(PromiseFactoryImpl(std::move(f_)));
-
-  explicit PromiseFactory(F f) : f_(std::move(f)) {}
+  using Promise = decltype(PromiseFactoryImpl(f_));
 
-  Promise Once() { return PromiseFactoryImpl(std::move(f_)); }
+  explicit RepeatedPromiseFactory(F f) : f_(std::move(f)) {}
 
-  Promise Repeated() const { return PromiseFactoryImpl(f_); }
+  Promise Make() const { return PromiseFactoryImpl(f_); }
+  Promise Make() { return PromiseFactoryImpl(f_); }
 };
 
 }  // namespace promise_detail

data/src/core/lib/promise/detail/status.h

@@ -45,6 +45,34 @@ inline absl::Status IntoStatus(absl::Status* status) {
 // can participate in TrySeq as result types that affect control flow.
 inline bool IsStatusOk(const absl::Status& status) { return status.ok(); }
 
+template <typename To, typename From>
+struct StatusCastImpl;
+
+template <typename To>
+struct StatusCastImpl<To, To> {
+  static To Cast(To&& t) { return std::move(t); }
+};
+
+template <typename To>
+struct StatusCastImpl<To, const To&> {
+  static To Cast(const To& t) { return t; }
+};
+
+template <typename T>
+struct StatusCastImpl<absl::StatusOr<T>, absl::Status> {
+  static absl::StatusOr<T> Cast(absl::Status&& t) { return std::move(t); }
+};
+
+template <typename T>
+struct StatusCastImpl<absl::StatusOr<T>, const absl::Status&> {
+  static absl::StatusOr<T> Cast(const absl::Status& t) { return t; }
+};
+
+template <typename To, typename From>
+To StatusCast(From&& from) {
+  return StatusCastImpl<To, From>::Cast(std::forward<From>(from));
+}
+
 }  // namespace grpc_core
 
 #endif  // GRPC_CORE_LIB_PROMISE_DETAIL_STATUS_H