Transport agnostic interfaces

[tinu73]

First of all this is really a great and useful framework.

I would like to raise the question or rather a discussion weather the interfaces are transport agnostic yes or no. If i am right in my conclusion they are not. Why?

• The http client client.hpp and iclientconnector.hpp are implemented in a synchronous request/response pattern, therefore offering a Send method with return type std::string
• A tcp client is preferably implemented in asynchronous send/receive pattern, therefore client.hpp and iclientconnector.hpp cannot be used 'agnostically' out of the box
• For using json-rpc-cxx with a tcp client/server, the iclientconnector.hpp and client.hpp have to be extended by offering, e.g. a Post method without a return value and a MessageHandler, e.g.

iclientconnector.hpp

using MessageHandler = std::function<void(const std::string)>;
virtual void Post(const std::string &request) = 0;
MessageHandler OnMessage;

client.hpp

using MessageHandler = std::function<void(const JsonRpcResponse)>;
JsonRpcClient(IClientConnector &connector, version v) : connector(connector), v(v)
{
    connector.OnMessage = [this](const std::string &message)
    {
        json response = json::parse(message);
        JsonRpcResponse rpc_response{};
        ...
        OnMessage(rpc_response);
    }
}
...
MessageHandler OnMessage;

client.cpp

std::future<JsonRpcResponse> future;
std::promise<JsonRpcResponse> promise;
JsonRpcResponse response;
client.OnMessage = [&] (const JsonRpcResponse &response) mutable
{
    promise.set_value(response);
};
future = promise.get_future();
client.CallMethod(1, "GetProduct", {"0xff"});
response = future.get();
std::cout << response.result.dump() << std::endl;

[cinemast]

Hi!

I am not sure I fully understood your issue with the synchronous interface. If you actually need async semantics, you can always wrap it into future/promises, right? Just introducing them on the connector level does not really make sense in my opinions, since the calling semantics through the RPC client will be synchronous again.

Could you explain in a bit more detail, maybe even using the TCP connector example what exactly would be easier/better with async interfaces?