dispatch automation - c++

Question

I myself am not exactly sure what I am asking for here, so please bear with me for a second.
Basically, I have an application that has to, amongst other things, be able to process commands that are received from some external source, let's say a socket.
Every command uses two data structures specific to this command - one structure holds a set of arguments relevant to the processing of this command, the other one receives some resulting data.
Naturally, data transfer handler class knows nothing about which command uses which structures, so the first thing that is invoked after command is received looks like this:
CSocketHandler::ReceiveCommand(int CommandCode, const TBuffer& Args, TBuffer& Result);
And the last one looks like this:
CClassBar::ProcessCommandFoo(const TFooArgs& Args, TFooResult& Result);
Now, all that's missing is the part that converts TBuffer to TFooArgs, invokes a correct method, then converts TFooResult back to TBuffer (A conversion is trivial).
The amount of different handler classes and commands promises to be quite large, so what I am looking at here is a method three miles long that does the same thing to different data types then calls different functions over and over again.
So my question - is it possible to automate this tedious and error prone task? Preferably to the point where just defining a new message handling method would be enough, but I am willing to compromise.

Answer 1

Generic code is good.
Create two convert methods, one from TBuffer to XArgs and the other from XResult to TBuffer
Create an automatic command wrapper
Implement a map to automatically dispatch to those wrappers
You can do it either through pointer to functions or inheritance, I suppose inheritance will be easier...
class BaseCommand {
public:
virtual ~BaseCommand() {}
virtual TBuffer invoke(TBuffer const& tb) = 0;
};
template <typename Args, typename Result>
class CommandT: public BaseCommand {
public:
virtual TBuffer invoke(TBuffer const& tb) {
Args const a = from_buffer(tb, &a); // free function
Result const r = this->invoke(a);
return to_buffer(r); // free function
}
private:
virtual Result invoke(Args const&) = 0;
};
Note: as a cheat, we pass &a to from_buffer to get automatic argument deduction, it is expected that the pointer is unused.
So, let us suppose that we have our arguments and results (both int it's easier):
int from_buffer(TBuffer const& tb, int const*) {
return tb.asInt();
}
TBuffer to_buffer(int i) {
return TBuffer(i);
}
And then we can implement a command that deals with int:
class IntCommand: public CommandT<int, int> {
virtual int invoke(int const& i) override { return i; }
};
Okay, let us move on to the dispatch. The idea is to register each command to its ID.
template <typename T>
std::unique_ptr<BaseCommand> make_command() { return std::unique_ptr<T>(new T()); }
static std::map<int, std::unique_ptr<BaseCommand>> Commands;
int main() {
Commands.insert(std::make_pair(1, make_command<IntCommand>()));
// lots of them...
// starts processing
}
And in SocketHandler we have:
void SocketHandler::ReceiveCommand(int code, TBuffer const& a, TBuffer& r) {
typedef std::map<int, std::unique_ptr<BaseCommand>>::const_iterator const_it;
const_it it = Commands.find(code);
if (it == Commands.end()) {
std::cerr << "Unknown command: " << code << "\n";
throw std::runtime_error("Unknown command");
}
r = it->second->invoke(a);
}