json-rpc-cxx

To handle incoming JSON-RPC requests, you must register methods with the server using the Add method. The JsonRpcServer class provides two overloads for Add depending on whether the method is a standard request/response method or a notification (which does not require a response).

Constraints:

• Method names cannot start with the prefix rpc..
• If Add returns false, the registration failed (likely due to the name prefix constraint).

Overloads:

• bool Add(const std::string &name, MethodHandle callback, const NamedParamMapping &mapping = NAMED_PARAM_MAPPING): Registers a method that expects a response.
• bool Add(const std::string &name, NotificationHandle callback, const NamedParamMapping &mapping = NAMED_PARAM_MAPPING): Registers a notification handler that does not return a result to the client.

// Example of adding a method to a server instance
JsonRpc2Server server;

server.Add("subtract", [](int a, int b) {
    return a - b;
});

The JsonRpc2Server class implements the JSON-RPC 2.0 specification. Use HandleRequest to process incoming request strings.

Behavior:

• Input: A std::string containing a single JSON object or a JSON array of requests.
• Output: A std::string containing the JSON-RPC response(s). If the input was an array, the output is an array of responses. If the input was an object, the output is a single response object.
• Batch Processing: If the input is a JSON array, the server iterates through each request and returns an array of results (excluding null results from notifications).
• Error Handling: The method catches parse errors, invalid request formats, and internal server errors, returning standard JSON-RPC error objects.

Error Codes returned by HandleRequest:

• invalid_request: The request is not properly formatted (e.g., missing jsonrpc version, invalid method type, or invalid params type).
• parse_error: The input string is not valid JSON.
• internal_error: An unhandled exception occurred during method execution.

JsonRpc2Server server;
// ... register methods ...

std::string request = R!("{""jsonrpc"": ""2.0"", ""method"": ""subtract"", ""params"": [10, 4], ""id"": 1}")!";
std::string response = server.HandleRequest(request);
// response will be: {""jsonrpc"": ""2.0"", ""id"": 1, ""result"": 6}

The JsonRpcClient class is the primary interface for sending JSON-RPC 1.0 or 2.0 requests to a server. It requires an implementation of IClientConnector to handle the actual transport of the JSON strings.

To use it, instantiate JsonRpcClient with a connector and a version (v1 or v2). You can then call methods using positional parameters, named parameters, or notifications.

// Assuming an implementation of IClientConnector named 'my_connector' exists
jsonrpccxx::JsonRpcClient client(my_connector, jsonrpccxx::version::v2);

// Call a method with positional parameters and get a typed result
int result = client.CallMethod<int>(1, "subtract", {42, 23});

// Call a method with named parameters
jsonrpccxx::named_parameter params = {{"a", 1}, {"b", 2}};
int sum = client.CallMethodNamed<int>(2, "add", params);

// Send a notification (no response expected)
client.CallNotification("update_status", {{"status", "ok"}});