client.hpp

Go to the documentation of this file.

#pragma once
 
#include <atomic>
#include <future>
#include <memory>
#include <mutex>
#include <optional>
#include <string>
#include <thread>
#include <unordered_map>
 
#include <nlohmann/json_fwd.hpp>
 
#include "jsonrpc/client/request.hpp"
#include "jsonrpc/transport/transport.hpp"
 
namespace jsonrpc::client {
 
class Client {
 public:
  explicit Client(std::unique_ptr<transport::Transport> transport);
 
  ~Client() = default;
 
  // Delete copy constructor and copy assignment operator
  Client(const Client &) = delete;
  auto operator=(const Client &) -> Client & = delete;
 
  // Delete move constructor and move assignment operator
  Client(Client &&) noexcept = delete;
  auto operator=(Client &&) noexcept -> Client & = delete;
 
  void Start();
 
  void Stop();
 
  auto IsRunning() const -> bool;
 
  auto SendMethodCall(
      const std::string &method,
      std::optional<nlohmann::json> params = std::nullopt) -> nlohmann::json;
 
  auto SendMethodCallAsync(
      const std::string &method,
      std::optional<nlohmann::json> params = std::nullopt)
      -> std::future<nlohmann::json>;
 
  void SendNotification(
      const std::string &method,
      std::optional<nlohmann::json> params = std::nullopt);
 
  auto HasPendingRequests() const -> bool;
 
 private:
  void Listener();
 
  auto SendRequest(const Request &request) -> nlohmann::json;
 
  auto SendRequestAsync(const Request &request) -> std::future<nlohmann::json>;
 
  auto GetNextRequestId() -> int;
 
  void HandleResponse(const std::string &response);
 
  static auto ValidateResponse(const nlohmann::json &response) -> bool;
 
  std::unique_ptr<transport::Transport> transport_;
 
  std::atomic<int> req_id_counter_{0};
 
  std::atomic<int> expected_count_{0};
 
  std::unordered_map<int, std::promise<nlohmann::json>> requests_map_;
 
  mutable std::mutex requests_mutex_;
 
  std::thread listener_;
 
  std::atomic<bool> is_running_{false};
};
 
}  // namespace jsonrpc::client