Question

I have a Message class that is able to pack its payload to binary and unpack it back. Like:

PayloadA p;
msg->Unpack(&p);

where PayloadA is a class.

The problem is that I have a bunch of payloads, so I need giant if or switch statement:

if (msg->PayloadType() == kPayloadTypeA)
{
    PayloadA p;
    msg->Unpack(&p); // void Unpack(IPayload *);

    // do something with payload ...
}
else if ...

I want to write a helper function that unpacks payloads. But what would be the type of this function? Something like:

PayloadType UnpackPayload(IMessage *msg) { ... }

where PayloadType is a typedef of a proper payload class. I know it is impossible but I looking for solutions like this. Any ideas?

Thanks.

Answer 1

I would split one level higher to avoid the problem entirely:

#include <map>
#include <functional>

...
std::map<int, std::function<void()> _actions;
...

// In some init section
_actions[kPayloadA] = [](IMessage* msg) {
    PayloadA p;
    msg->Unpack(&p);

    // do something with payload ...
};
// repeat for all payloads

...

// decoding function
DecodeMsg(IMessage* msg) {
    _actions[id](msg);
}

To further reduce the code size, try to make Unpack a function template (possible easily only if it’s not virtual, if it is you can try to add one level of indirection so that it isn’t ;):

class Message {
   template <class Payload>
   Payload Unpack() { ... }
};

auto p = msg->Unpack<PayloadA>();

// do something with payload ...

EDIT

Now let’s see how we can avoid writing the long list of _actions[kPayloadN]. This is highly non trivial.

First you need a helper to run code during the static initialization (i.e. before main):

template <class T>
class Registrable
{
    struct Registrar
    {
        Registrar()
        {
            T::Init();
        }
    };

    static Registrar R;

    template <Registrar& r>
    struct Force{ };
    static Force<R> F; // Required to force all compilers to instantiate R
                       // it won't be done without this
};

template <class T>
typename Registrable<T>::Registrar Registrable<T>::R;

Now we need to define our actual registration logic:

typedef map<int, function<void()> PayloadActionsT;
inline PayloadActionsT& GetActions() // you may move this to a CPP
{
    static PayloadActionsT all;
    return all;
}

Then we factor in the parsing code:

template <class Payload>
struct BasePayload : Registrable<BasePayload>
{
    static void Init()
    {
        GetActions()[Payload::Id] = [](IMessage* msg) {
             auto p = msg->Unpack<Payload>();
             p.Action();
        }
    }
};

Then we define all the payloads one by one

struct PayloadA : BasePayload<PayloadA>
{
    static const int Id = /* something unique */;
    void Action()
    { /* what to do with this payload */ }
}

Finally we parse the incoming messages:

void DecodeMessage(IMessage* msg)
{
    static const auto& actions = GetActions();
    actions[msg->GetPayloadType]();
}