dispatcher.hpp

Go to the documentation of this file.

#pragma once
 
#include <optional>
#include <string>
#include <unordered_map>
#include <vector>
 
#include <BS_thread_pool.hpp>
#include <nlohmann/json.hpp>
 
#include "jsonrpc/server/request.hpp"
#include "jsonrpc/server/response.hpp"
#include "jsonrpc/server/types.hpp"
 
namespace jsonrpc::server {
 
class Dispatcher {
 public:
  explicit Dispatcher(
      bool enable_multithreading = true,
      size_t num_threads = std::thread::hardware_concurrency());
 
  Dispatcher(const Dispatcher &) = delete;
  Dispatcher(Dispatcher &&) = delete;
  auto operator=(const Dispatcher &) -> Dispatcher & = delete;
  auto operator=(Dispatcher &&) -> Dispatcher & = delete;
 
  virtual ~Dispatcher() = default;
 
  auto DispatchRequest(const std::string &request)
      -> std::optional<std::string>;
 
  void RegisterMethodCall(
      const std::string &method, const MethodCallHandler &handler);
 
  void RegisterNotification(
      const std::string &method, const NotificationHandler &handler);
 
 private:
  static auto ParseAndValidateJson(const std::string &request_str)
      -> std::optional<nlohmann::json>;
 
  auto DispatchSingleRequest(const nlohmann::json &request_json)
      -> std::optional<std::string>;
 
  auto DispatchSingleRequestInner(const nlohmann::json &request_json)
      -> std::optional<nlohmann::json>;
 
  auto DispatchBatchRequest(const nlohmann::json &request_json)
      -> std::optional<std::string>;
 
  auto DispatchBatchRequestInner(const nlohmann::json &request_json)
      -> std::vector<nlohmann::json>;
 
  static auto ValidateRequest(const nlohmann::json &request_json)
      -> std::optional<Response>;
 
  static auto FindHandler(
      const std::unordered_map<std::string, Handler> &handlers,
      const std::string &method) -> std::optional<Handler>;
 
  static auto HandleRequest(const Request &request, const Handler &handler)
      -> std::optional<nlohmann::json>;
 
  static auto HandleMethodCall(
      const Request &request, const MethodCallHandler &handler) -> Response;
 
  static void HandleNotification(
      const Request &request, const NotificationHandler &handler);
 
  std::unordered_map<std::string, Handler> handlers_;
 
  bool enable_multithreading_;
 
  BS::thread_pool thread_pool_;
};
 
}  // namespace jsonrpc::server