1018 lines
19 KiB
C++
1018 lines
19 KiB
C++
/***
|
|
This file is part of jsonrpc++
|
|
Copyright (C) 2017 Johannes Pohl
|
|
|
|
This software may be modified and distributed under the terms
|
|
of the MIT license. See the LICENSE file for details.
|
|
***/
|
|
|
|
#include "jsonrp.hpp"
|
|
|
|
|
|
using namespace std;
|
|
|
|
namespace jsonrpcpp
|
|
{
|
|
|
|
|
|
/////////////////////////// Entity implementation /////////////////////////////
|
|
|
|
Entity::Entity(entity_t type) : entity(type)
|
|
{
|
|
}
|
|
|
|
|
|
Entity::~Entity()
|
|
{
|
|
}
|
|
|
|
|
|
bool Entity::is_exception()
|
|
{
|
|
return (entity == entity_t::exception);
|
|
}
|
|
|
|
|
|
bool Entity::is_id()
|
|
{
|
|
return (entity == entity_t::id);
|
|
}
|
|
|
|
|
|
bool Entity::is_error()
|
|
{
|
|
return (entity == entity_t::error);
|
|
}
|
|
|
|
|
|
bool Entity::is_response()
|
|
{
|
|
return (entity == entity_t::response);
|
|
}
|
|
|
|
|
|
bool Entity::is_request()
|
|
{
|
|
return (entity == entity_t::request);
|
|
}
|
|
|
|
|
|
bool Entity::is_notification()
|
|
{
|
|
return (entity == entity_t::notification);
|
|
}
|
|
|
|
|
|
bool Entity::is_batch()
|
|
{
|
|
return (entity == entity_t::batch);
|
|
}
|
|
|
|
|
|
void Entity::parse(const char* json_str)
|
|
{
|
|
// http://www.jsonrpc.org/specification
|
|
// code message meaning
|
|
// -32700 Parse error Invalid JSON was received by the server. An error occurred on the server while parsing the JSON text.
|
|
// -32600 Invalid Request The JSON sent is not a valid Request object.
|
|
// -32601 Method not found The method does not exist / is not available.
|
|
// -32602 Invalid params Invalid method parameter(s).
|
|
// -32603 Internal error Internal JSON-RPC error.
|
|
// -32000 to -32099 Server error Reserved for implementation-defined server-errors.
|
|
try
|
|
{
|
|
parse_json(Json::parse(json_str));
|
|
}
|
|
catch (const RpcException& e)
|
|
{
|
|
throw;
|
|
}
|
|
catch (const exception& e)
|
|
{
|
|
throw ParseErrorException(e.what());
|
|
}
|
|
}
|
|
|
|
|
|
void Entity::parse(const std::string& json_str)
|
|
{
|
|
parse(json_str.c_str());
|
|
}
|
|
|
|
|
|
std::string Entity::type_str() const
|
|
{
|
|
switch (entity)
|
|
{
|
|
case entity_t::unknown:
|
|
return "unknown";
|
|
case entity_t::id:
|
|
return "id";
|
|
case entity_t::exception:
|
|
return "exception";
|
|
case entity_t::error:
|
|
return "error";
|
|
case entity_t::response:
|
|
return "response";
|
|
case entity_t::request:
|
|
return "request";
|
|
case entity_t::notification:
|
|
return "notification";
|
|
case entity_t::batch:
|
|
return "batch";
|
|
default:
|
|
return "unknown";
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/////////////////////////// NullableEntity implementation /////////////////////
|
|
|
|
NullableEntity::NullableEntity(entity_t type) : Entity(type), isNull(false)
|
|
{
|
|
}
|
|
|
|
|
|
NullableEntity::NullableEntity(entity_t type, std::nullptr_t) : Entity(type), isNull(true)
|
|
{
|
|
}
|
|
|
|
|
|
NullableEntity::~NullableEntity()
|
|
{
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
/////////////////////////// Id implementation /////////////////////////////////
|
|
|
|
Id::Id() : Entity(entity_t::id), type(value_t::null), int_id(0), string_id("")
|
|
{
|
|
}
|
|
|
|
|
|
Id::Id(int id) : Entity(entity_t::id), type(value_t::integer), int_id(id), string_id("")
|
|
{
|
|
}
|
|
|
|
|
|
Id::Id(const char* id) : Entity(entity_t::id), type(value_t::string), int_id(0), string_id(id)
|
|
{
|
|
}
|
|
|
|
|
|
Id::Id(const std::string& id) : Id(id.c_str())
|
|
{
|
|
}
|
|
|
|
|
|
Id::Id(const Json& json_id) : Entity(entity_t::id), type(value_t::null)
|
|
{
|
|
parse_json(json_id);
|
|
}
|
|
|
|
|
|
void Id::parse_json(const Json& json)
|
|
{
|
|
if (json.is_null())
|
|
{
|
|
type = value_t::null;
|
|
}
|
|
else if (json.is_number_integer())
|
|
{
|
|
int_id = json.get<int>();
|
|
type = value_t::integer;
|
|
}
|
|
else if (json.is_string())
|
|
{
|
|
string_id = json.get<std::string>();
|
|
type = value_t::string;
|
|
}
|
|
else
|
|
throw std::invalid_argument("id must be integer, string or null");
|
|
}
|
|
|
|
|
|
Json Id::to_json() const
|
|
{
|
|
if (type == value_t::null)
|
|
return nullptr;
|
|
else if (type == value_t::string)
|
|
return string_id;
|
|
else if (type == value_t::integer)
|
|
return int_id;
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
//////////////////////// Error implementation /////////////////////////////////
|
|
|
|
Parameter::Parameter(std::nullptr_t) : NullableEntity(entity_t::id, nullptr), type(value_t::null)
|
|
{
|
|
}
|
|
|
|
|
|
Parameter::Parameter(const Json& json) : NullableEntity(entity_t::id), type(value_t::null)
|
|
{
|
|
if (json != nullptr)
|
|
parse_json(json);
|
|
}
|
|
|
|
|
|
Parameter::Parameter(const std::string& key1, const Json& value1,
|
|
const std::string& key2, const Json& value2,
|
|
const std::string& key3, const Json& value3,
|
|
const std::string& key4, const Json& value4) : NullableEntity(entity_t::id), type(value_t::map)
|
|
{
|
|
param_map[key1] = value1;
|
|
if (!key2.empty())
|
|
param_map[key2] = value2;
|
|
if (!key3.empty())
|
|
param_map[key3] = value3;
|
|
if (!key4.empty())
|
|
param_map[key4] = value4;
|
|
}
|
|
|
|
|
|
void Parameter::parse_json(const Json& json)
|
|
{
|
|
if (json.is_array())
|
|
{
|
|
param_array = json.get<std::vector<Json>>();
|
|
param_map.clear();
|
|
type = value_t::array;
|
|
}
|
|
else
|
|
{
|
|
param_map = json.get<std::map<std::string, Json>>();
|
|
param_array.clear();
|
|
type = value_t::map;
|
|
}
|
|
}
|
|
|
|
|
|
Json Parameter::to_json() const
|
|
{
|
|
if (type == value_t::array)
|
|
return param_array;
|
|
else if (type == value_t::map)
|
|
return param_map;
|
|
else
|
|
return nullptr;
|
|
}
|
|
|
|
|
|
bool Parameter::is_array() const
|
|
{
|
|
return type == value_t::array;
|
|
}
|
|
|
|
|
|
bool Parameter::is_map() const
|
|
{
|
|
return type == value_t::map;
|
|
}
|
|
|
|
|
|
bool Parameter::is_null() const
|
|
{
|
|
return isNull;
|
|
}
|
|
|
|
|
|
bool Parameter::has(const std::string& key) const
|
|
{
|
|
if (type != value_t::map)
|
|
return false;
|
|
return (param_map.find(key) != param_map.end());
|
|
}
|
|
|
|
|
|
Json Parameter::get(const std::string& key) const
|
|
{
|
|
return param_map.at(key);
|
|
}
|
|
|
|
|
|
bool Parameter::has(size_t idx) const
|
|
{
|
|
if (type != value_t::array)
|
|
return false;
|
|
return (param_array.size() > idx);
|
|
}
|
|
|
|
|
|
Json Parameter::get(size_t idx) const
|
|
{
|
|
return param_array.at(idx);
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
//////////////////////// Error implementation /////////////////////////////////
|
|
|
|
Error::Error(const Json& json) : Error("Internal error", -32603, nullptr)
|
|
{
|
|
if (json != nullptr)
|
|
parse_json(json);
|
|
}
|
|
|
|
|
|
Error::Error(std::nullptr_t) : NullableEntity(entity_t::error, nullptr), code(0), message(""), data(nullptr)
|
|
{
|
|
}
|
|
|
|
|
|
Error::Error(const std::string& message, int code, const Json& data) : NullableEntity(entity_t::error), code(code), message(message), data(data)
|
|
{
|
|
}
|
|
|
|
|
|
void Error::parse_json(const Json& json)
|
|
{
|
|
try
|
|
{
|
|
if (json.count("code") == 0)
|
|
throw RpcException("code is missing");
|
|
code = json["code"];
|
|
if (json.count("message") == 0)
|
|
throw RpcException("message is missing");
|
|
message = json["message"];
|
|
if (json.count("data"))
|
|
data = json["data"];
|
|
else
|
|
data = nullptr;
|
|
}
|
|
catch (const RpcException& e)
|
|
{
|
|
throw;
|
|
}
|
|
catch (const exception& e)
|
|
{
|
|
throw RpcException(e.what());
|
|
}
|
|
}
|
|
|
|
|
|
Json Error::to_json() const
|
|
{
|
|
Json j = {
|
|
{"code", code},
|
|
{"message", message},
|
|
};
|
|
|
|
if (!data.is_null())
|
|
j["data"] = data;
|
|
return j;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
////////////////////// Request implementation /////////////////////////////////
|
|
|
|
Request::Request(const Json& json) : Entity(entity_t::request), method(""), id()
|
|
{
|
|
if (json != nullptr)
|
|
parse_json(json);
|
|
}
|
|
|
|
|
|
Request::Request(const Id& id, const std::string& method, const Parameter& params) : Entity(entity_t::request), method(method), params(params), id(id)
|
|
{
|
|
}
|
|
|
|
|
|
void Request::parse_json(const Json& json)
|
|
{
|
|
try
|
|
{
|
|
if (json.count("id") == 0)
|
|
throw InvalidRequestException("id is missing");
|
|
|
|
try
|
|
{
|
|
id = Id(json["id"]);
|
|
}
|
|
catch(const std::exception& e)
|
|
{
|
|
throw InvalidRequestException(e.what());
|
|
}
|
|
|
|
if (json.count("jsonrpc") == 0)
|
|
throw InvalidRequestException("jsonrpc is missing", id);
|
|
string jsonrpc = json["jsonrpc"].get<string>();
|
|
if (jsonrpc != "2.0")
|
|
throw InvalidRequestException("invalid jsonrpc value: " + jsonrpc, id);
|
|
|
|
if (json.count("method") == 0)
|
|
throw InvalidRequestException("method is missing", id);
|
|
if (!json["method"].is_string())
|
|
throw InvalidRequestException("method must be a string value", id);
|
|
method = json["method"];
|
|
if (method.empty())
|
|
throw InvalidRequestException("method must not be empty", id);
|
|
|
|
if (json.count("params"))
|
|
params.parse_json(json["params"]);
|
|
else
|
|
params = nullptr;
|
|
}
|
|
catch (const RequestException& e)
|
|
{
|
|
throw;
|
|
}
|
|
catch (const exception& e)
|
|
{
|
|
throw InternalErrorException(e.what(), id);
|
|
}
|
|
}
|
|
|
|
|
|
Json Request::to_json() const
|
|
{
|
|
Json json = {
|
|
{"jsonrpc", "2.0"},
|
|
{"method", method},
|
|
{"id", id.to_json()}
|
|
};
|
|
|
|
if (params)
|
|
json["params"] = params.to_json();
|
|
|
|
return json;
|
|
}
|
|
|
|
|
|
|
|
RpcException::RpcException(const char* text)
|
|
{
|
|
text_ = new char[std::strlen(text) + 1];
|
|
std::strcpy(text_, text);
|
|
}
|
|
|
|
RpcException::RpcException(const std::string& text) : RpcException(text.c_str())
|
|
{
|
|
}
|
|
|
|
RpcException::RpcException(const RpcException& e) : RpcException(e.what())
|
|
{
|
|
}
|
|
|
|
RpcException::~RpcException() throw()
|
|
{
|
|
delete[] text_;
|
|
}
|
|
|
|
const char* RpcException::what() const noexcept
|
|
{
|
|
return text_;
|
|
}
|
|
|
|
|
|
|
|
|
|
ParseErrorException::ParseErrorException(const Error& error) : RpcException(error.message), Entity(entity_t::exception), error(error)
|
|
{
|
|
}
|
|
|
|
ParseErrorException::ParseErrorException(const ParseErrorException& e) : RpcException(e.what()), Entity(entity_t::exception), error(e.error)
|
|
{
|
|
}
|
|
|
|
ParseErrorException::ParseErrorException(const std::string& data) : ParseErrorException(Error("Parse error", -32700, data))
|
|
{
|
|
}
|
|
|
|
Json ParseErrorException::to_json() const
|
|
{
|
|
Json response = {
|
|
{"jsonrpc", "2.0"},
|
|
{"error", error.to_json()},
|
|
{"id", nullptr}
|
|
};
|
|
|
|
return response;
|
|
}
|
|
|
|
void ParseErrorException::parse_json(const Json& json)
|
|
{
|
|
}
|
|
|
|
|
|
|
|
|
|
RequestException::RequestException(const Error& error, const Id& requestId) : RpcException(error.message), Entity(entity_t::exception), error(error), id(requestId)
|
|
{
|
|
}
|
|
|
|
RequestException::RequestException(const RequestException& e) : RpcException(e.what()), Entity(entity_t::exception), error(e.error), id(e.id)
|
|
{
|
|
}
|
|
|
|
Json RequestException::to_json() const
|
|
{
|
|
Json response = {
|
|
{"jsonrpc", "2.0"},
|
|
{"error", error.to_json()},
|
|
{"id", id.to_json()}
|
|
};
|
|
|
|
return response;
|
|
}
|
|
|
|
void RequestException::parse_json(const Json& json)
|
|
{
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
InvalidRequestException::InvalidRequestException(const Id& requestId) : RequestException(Error("Invalid request", -32600), requestId)
|
|
{
|
|
}
|
|
|
|
InvalidRequestException::InvalidRequestException(const Request& request) : InvalidRequestException(request.id)
|
|
{
|
|
}
|
|
|
|
InvalidRequestException::InvalidRequestException(const char* data, const Id& requestId) : RequestException(Error("Invalid request", -32600, data), requestId)
|
|
{
|
|
}
|
|
|
|
InvalidRequestException::InvalidRequestException(const std::string& data, const Id& requestId) : InvalidRequestException(data.c_str(), requestId)
|
|
{
|
|
}
|
|
|
|
|
|
|
|
MethodNotFoundException::MethodNotFoundException(const Id& requestId) : RequestException(Error("Method not found", -32601), requestId)
|
|
{
|
|
}
|
|
|
|
MethodNotFoundException::MethodNotFoundException(const Request& request) : MethodNotFoundException(request.id)
|
|
{
|
|
}
|
|
|
|
MethodNotFoundException::MethodNotFoundException(const char* data, const Id& requestId) : RequestException(Error("Method not found", -32601, data), requestId)
|
|
{
|
|
}
|
|
|
|
MethodNotFoundException::MethodNotFoundException(const std::string& data, const Id& requestId) : MethodNotFoundException(data.c_str(), requestId)
|
|
{
|
|
}
|
|
|
|
|
|
|
|
InvalidParamsException::InvalidParamsException(const Id& requestId) : RequestException(Error("Invalid params", -32602), requestId)
|
|
{
|
|
}
|
|
|
|
InvalidParamsException::InvalidParamsException(const Request& request) : InvalidParamsException(request.id)
|
|
{
|
|
}
|
|
|
|
InvalidParamsException::InvalidParamsException(const char* data, const Id& requestId) : RequestException(Error("Invalid params", -32602, data), requestId)
|
|
{
|
|
}
|
|
|
|
InvalidParamsException::InvalidParamsException(const std::string& data, const Id& requestId) : InvalidParamsException(data.c_str(), requestId)
|
|
{
|
|
}
|
|
|
|
|
|
|
|
InternalErrorException::InternalErrorException(const Id& requestId) : RequestException(Error("Internal error", -32603), requestId)
|
|
{
|
|
}
|
|
|
|
InternalErrorException::InternalErrorException(const Request& request) : InternalErrorException(request.id)
|
|
{
|
|
}
|
|
|
|
InternalErrorException::InternalErrorException(const char* data, const Id& requestId) : RequestException(Error("Internal error", -32603, data), requestId)
|
|
{
|
|
}
|
|
|
|
InternalErrorException::InternalErrorException(const std::string& data, const Id& requestId) : InternalErrorException(data.c_str(), requestId)
|
|
{
|
|
}
|
|
|
|
|
|
|
|
///////////////////// Response implementation /////////////////////////////////
|
|
|
|
Response::Response(const Json& json) : Entity(entity_t::response)
|
|
{
|
|
if (json != nullptr)
|
|
parse_json(json);
|
|
}
|
|
|
|
|
|
Response::Response(const Id& id, const Json& result) : Entity(entity_t::response), id(id), result(result), error(nullptr)
|
|
{
|
|
}
|
|
|
|
|
|
Response::Response(const Id& id, const Error& error) : Entity(entity_t::response), id(id), result(), error(error)
|
|
{
|
|
}
|
|
|
|
|
|
Response::Response(const Request& request, const Json& result) : Response(request.id, result)
|
|
{
|
|
}
|
|
|
|
|
|
Response::Response(const Request& request, const Error& error) : Response(request.id, error)
|
|
{
|
|
}
|
|
|
|
|
|
Response::Response(const RequestException& exception) : Response(exception.id, exception.error)
|
|
{
|
|
}
|
|
|
|
|
|
void Response::parse_json(const Json& json)
|
|
{
|
|
try
|
|
{
|
|
error = nullptr;
|
|
result = nullptr;
|
|
if (json.count("jsonrpc") == 0)
|
|
throw RpcException("jsonrpc is missing");
|
|
string jsonrpc = json["jsonrpc"].get<string>();
|
|
if (jsonrpc != "2.0")
|
|
throw RpcException("invalid jsonrpc value: " + jsonrpc);
|
|
if (json.count("id") == 0)
|
|
throw RpcException("id is missing");
|
|
id = Id(json["id"]);
|
|
if (json.count("result"))
|
|
result = json["result"];
|
|
else if (json.count("error"))
|
|
error.parse_json(json["error"]);
|
|
else
|
|
throw RpcException("response must contain result or error");
|
|
}
|
|
catch (const RpcException& e)
|
|
{
|
|
throw;
|
|
}
|
|
catch (const exception& e)
|
|
{
|
|
throw RpcException(e.what());
|
|
}
|
|
}
|
|
|
|
|
|
Json Response::to_json() const
|
|
{
|
|
Json j = {
|
|
{"jsonrpc", "2.0"},
|
|
{"id", id.to_json()},
|
|
};
|
|
|
|
if (error)
|
|
j["error"] = error.to_json();
|
|
else
|
|
j["result"] = result;
|
|
|
|
return j;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
///////////////// Notification implementation /////////////////////////////////
|
|
|
|
Notification::Notification(const Json& json) : Entity(entity_t::notification)
|
|
{
|
|
if (json != nullptr)
|
|
parse_json(json);
|
|
}
|
|
|
|
|
|
Notification::Notification(const char* method, const Parameter& params) : Entity(entity_t::notification), method(method), params(params)
|
|
{
|
|
}
|
|
|
|
|
|
Notification::Notification(const std::string& method, const Parameter& params) : Notification(method.c_str(), params)
|
|
{
|
|
}
|
|
|
|
|
|
void Notification::parse_json(const Json& json)
|
|
{
|
|
try
|
|
{
|
|
if (json.count("jsonrpc") == 0)
|
|
throw RpcException("jsonrpc is missing");
|
|
string jsonrpc = json["jsonrpc"].get<string>();
|
|
if (jsonrpc != "2.0")
|
|
throw RpcException("invalid jsonrpc value: " + jsonrpc);
|
|
|
|
if (json.count("method") == 0)
|
|
throw RpcException("method is missing");
|
|
if (!json["method"].is_string())
|
|
throw RpcException("method must be a string value");
|
|
method = json["method"];
|
|
if (method.empty())
|
|
throw RpcException("method must not be empty");
|
|
|
|
if (json.count("params"))
|
|
params.parse_json(json["params"]);
|
|
else
|
|
params = nullptr;
|
|
}
|
|
catch (const RpcException& e)
|
|
{
|
|
throw;
|
|
}
|
|
catch (const exception& e)
|
|
{
|
|
throw RpcException(e.what());
|
|
}
|
|
}
|
|
|
|
|
|
Json Notification::to_json() const
|
|
{
|
|
Json json = {
|
|
{"jsonrpc", "2.0"},
|
|
{"method", method},
|
|
};
|
|
|
|
if (params)
|
|
json["params"] = params.to_json();
|
|
|
|
return json;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
//////////////////////// Batch implementation /////////////////////////////////
|
|
|
|
Batch::Batch(const Json& json) : Entity(entity_t::batch)
|
|
{
|
|
if (json != nullptr)
|
|
parse_json(json);
|
|
}
|
|
|
|
|
|
void Batch::parse_json(const Json& json)
|
|
{
|
|
// cout << "Batch::parse: " << json.dump() << "\n";
|
|
entities.clear();
|
|
for (auto it = json.begin(); it != json.end(); ++it)
|
|
{
|
|
// cout << "x: " << it->dump() << "\n";
|
|
entity_ptr entity(nullptr);
|
|
try
|
|
{
|
|
entity = Parser::do_parse_json(*it);
|
|
if (!entity)
|
|
entity = make_shared<Error>("Invalid Request", -32600);
|
|
}
|
|
catch(const RequestException& e)
|
|
{
|
|
entity = make_shared<RequestException>(e);
|
|
}
|
|
catch(const std::exception& e)
|
|
{
|
|
entity = make_shared<Error>(e.what(), -32600);
|
|
}
|
|
entities.push_back(entity);
|
|
}
|
|
if (entities.empty())
|
|
throw InvalidRequestException();
|
|
}
|
|
|
|
|
|
Json Batch::to_json() const
|
|
{
|
|
Json result;
|
|
for (const auto& j: entities)
|
|
result.push_back(j->to_json());
|
|
return result;
|
|
}
|
|
|
|
|
|
/*void Batch::add(const entity_ptr entity)
|
|
{
|
|
entities.push_back(entity);
|
|
}
|
|
*/
|
|
|
|
|
|
|
|
|
|
//////////////////////// Parser implementation ////////////////////////////////
|
|
|
|
Parser::Parser()
|
|
{
|
|
|
|
}
|
|
|
|
|
|
Parser::~Parser()
|
|
{
|
|
|
|
}
|
|
|
|
|
|
void Parser::register_notification_callback(const std::string& notification, notification_callback callback)
|
|
{
|
|
if (callback)
|
|
notification_callbacks_[notification] = callback;
|
|
}
|
|
|
|
|
|
void Parser::register_request_callback(const std::string& request, request_callback callback)
|
|
{
|
|
if (callback)
|
|
request_callbacks_[request] = callback;
|
|
}
|
|
|
|
|
|
entity_ptr Parser::parse(const std::string& json_str)
|
|
{
|
|
//std::cout << "parse: " << json_str << "\n";
|
|
entity_ptr entity = do_parse(json_str);
|
|
if (entity && entity->is_notification())
|
|
{
|
|
notification_ptr notification = dynamic_pointer_cast<jsonrpcpp::Notification>(entity);
|
|
if (notification_callbacks_.find(notification->method) != notification_callbacks_.end())
|
|
{
|
|
notification_callback callback = notification_callbacks_[notification->method];
|
|
if (callback)
|
|
callback(notification->params);
|
|
}
|
|
}
|
|
else if (entity && entity->is_request())
|
|
{
|
|
request_ptr request = dynamic_pointer_cast<jsonrpcpp::Request>(entity);
|
|
if (request_callbacks_.find(request->method) != request_callbacks_.end())
|
|
{
|
|
request_callback callback = request_callbacks_[request->method];
|
|
if (callback)
|
|
{
|
|
jsonrpcpp::response_ptr response = callback(request->id, request->params);
|
|
if (response)
|
|
return response;
|
|
}
|
|
}
|
|
}
|
|
return entity;
|
|
}
|
|
|
|
|
|
entity_ptr Parser::parse_json(const Json& json)
|
|
{
|
|
return do_parse_json(json);
|
|
}
|
|
|
|
|
|
entity_ptr Parser::do_parse(const std::string& json_str)
|
|
{
|
|
try
|
|
{
|
|
return do_parse_json(Json::parse(json_str));
|
|
}
|
|
catch (const RpcException& e)
|
|
{
|
|
throw;
|
|
}
|
|
catch (const exception& e)
|
|
{
|
|
throw ParseErrorException(e.what());
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
|
|
entity_ptr Parser::do_parse_json(const Json& json)
|
|
{
|
|
try
|
|
{
|
|
if (is_request(json))
|
|
return make_shared<Request>(json);
|
|
else if (is_notification(json))
|
|
return make_shared<Notification>(json);
|
|
else if (is_response(json))
|
|
return make_shared<Response>(json);
|
|
else if (is_batch(json))
|
|
return make_shared<Batch>(json);
|
|
}
|
|
catch (const RpcException& e)
|
|
{
|
|
throw;
|
|
}
|
|
catch (const exception& e)
|
|
{
|
|
throw RpcException(e.what());
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
|
|
bool Parser::is_request(const std::string& json_str)
|
|
{
|
|
try
|
|
{
|
|
return is_request(Json::parse(json_str));
|
|
}
|
|
catch (const exception& e)
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
bool Parser::is_request(const Json& json)
|
|
{
|
|
return (json.count("method") && json.count("id"));
|
|
}
|
|
|
|
|
|
bool Parser::is_notification(const std::string& json_str)
|
|
{
|
|
try
|
|
{
|
|
return is_notification(Json::parse(json_str));
|
|
}
|
|
catch (const exception& e)
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
bool Parser:: is_notification(const Json& json)
|
|
{
|
|
return (json.count("method") && (json.count("id") == 0));
|
|
}
|
|
|
|
|
|
bool Parser::is_response(const std::string& json_str)
|
|
{
|
|
try
|
|
{
|
|
return is_response(Json::parse(json_str));
|
|
}
|
|
catch (const exception& e)
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
bool Parser::is_response(const Json& json)
|
|
{
|
|
return (json.count("result") && json.count("id"));
|
|
}
|
|
|
|
|
|
bool Parser::is_batch(const std::string& json_str)
|
|
{
|
|
try
|
|
{
|
|
return is_batch(Json::parse(json_str));
|
|
}
|
|
catch (const exception& e)
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
bool Parser::is_batch(const Json& json)
|
|
{
|
|
return (json.is_array());
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|