race.h

Go to the documentation of this file.

// Copyright 2021 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_CORE_LIB_PROMISE_RACE_H
#define GRPC_CORE_LIB_PROMISE_RACE_H
 
#include <grpc/support/port_platform.h>
 
#include <type_traits>
 
#include "absl/types/variant.h"
 
#include "src/core/lib/promise/poll.h"
 
namespace grpc_core {
 
namespace promise_detail {
 
// Implementation type for Race combinator.
template <typename... Promises>
class Race;
 
template <typename Promise, typename... Promises>
class Race<Promise, Promises...> {
 public:
  using Result = decltype(std::declval<Promise>()());
 
  explicit Race(Promise promise, Promises... promises)
      : promise_(std::move(promise)), next_(std::move(promises)...) {}
 
  Result operator()() {
    // Check our own promise.
    auto r = promise_();
    if (absl::holds_alternative<Pending>(r)) {
      // Check the rest of them.
      return next_();
    }
    // Return the first ready result.
    return std::move(absl::get<kPollReadyIdx>(std::move(r)));
  }
 
 private:
  // The Promise checked by this instance.
  Promise promise_;
  // We recursively expand to check the rest of the instances.
  Race<Promises...> next_;
};
 
template <typename Promise>
class Race<Promise> {
 public:
  using Result = decltype(std::declval<Promise>()());
  explicit Race(Promise promise) : promise_(std::move(promise)) {}
  Result operator()() { return promise_(); }
 
 private:
  Promise promise_;
};
 
}  // namespace promise_detail
 
template <typename... Promises>
promise_detail::Race<Promises...> Race(Promises... promises) {
  return promise_detail::Race<Promises...>(std::move(promises)...);
}
 
}  // namespace grpc_core
 
#endif  // GRPC_CORE_LIB_PROMISE_RACE_H