pending_request.hpp

Go to the documentation of this file.

#pragma once
 
#include <condition_variable>
#include <mutex>
 
#include <asio.hpp>
#include <nlohmann/json.hpp>
 
namespace jsonrpc::endpoint {
 
class PendingRequest {
 public:
  explicit PendingRequest(asio::strand<asio::any_io_executor> strand)
      : strand_(std::move(strand)) {
  }
 
  // Prevent copying and moving
  PendingRequest(const PendingRequest&) = delete;
  auto operator=(const PendingRequest&) -> PendingRequest& = delete;
  PendingRequest(PendingRequest&&) = delete;
  auto operator=(PendingRequest&&) -> PendingRequest& = delete;
 
  ~PendingRequest() = default;
 
  void SetResult(nlohmann::json result) {
    // Execute within the strand to ensure thread safety
    asio::post(strand_, [this, result = std::move(result)]() mutable {
      if (!is_ready_) {
        result_ = std::move(result);
        is_ready_ = true;
 
        // Notify any waiting consumers
        std::lock_guard<std::mutex> lock(mutex_);
        ready_cv_.notify_all();
      }
    });
  }
 
  void Cancel(int code, const std::string& message) {
    // Create a JSON-RPC error object
    nlohmann::json error = {{"error", {{"code", code}, {"message", message}}}};
 
    has_error_ = true;
 
    // Set the result with the error
    SetResult(std::move(error));
  }
 
  auto GetResult() -> asio::awaitable<nlohmann::json> {
    // If the result is already ready, return it immediately
    if (is_ready_) {
      co_return result_;
    }
 
    // Otherwise, wait for the result using a timer and polling
    // This is a simplified approach that works with ASIO
    auto executor = co_await asio::this_coro::executor;
    asio::steady_timer timer(executor, std::chrono::milliseconds(10));
 
    while (!is_ready_) {
      co_await timer.async_wait(asio::use_awaitable);
      timer.expires_after(std::chrono::milliseconds(10));
    }
 
    // Return the result
    co_return result_;
  }
 
  [[nodiscard]] bool IsReady() const {
    return is_ready_;
  }
 
  [[nodiscard]] bool HasError() const {
    return has_error_;
  }
 
 private:
  asio::strand<asio::any_io_executor> strand_;
 
  nlohmann::json result_;
 
  bool is_ready_{};
 
  bool has_error_{};
 
  std::mutex mutex_;
 
  std::condition_variable ready_cv_;
};
 
}  // namespace jsonrpc::endpoint