Add a bit of type safety to message handling about actor-framework

[Neverlord]

The usual way of coding in message oriented programming is always pattern -> behavior. And what you do is to hide the pattern.

If you are worry about, that your message format might be change in the future, just use a structure instead of "structured tuples" where you're using atoms for context informations.

See the announce_example_1 from libcppa (stripped):

#include <utility>
#include <iostream>

#include "cppa/cppa.hpp"

using std::cout;
using std::endl;

using namespace cppa;

struct foo 
{
    int a;
    int b;
};

bool operator==(const foo& lhs, const foo& rhs)
{
    return    lhs.a == rhs.a
           && lhs.b == rhs.b;
}

int main(int, char**)
{
    announce<foo>(&foo::a, &foo::b);
    send(self(), foo{1,2});
    receive_loop
    (   
        on<foo>() >> [](const foo& val)
        {   
            cout << "foo("
                 << val.a << "," 
                 << val.b << ")" 
                 << endl;
        }   
    );  
    return 0;
}

If foo changes in the future, it does not affect "old" code and if it does (e.g. if you access a member that's deleted from the class), your compiler will tell you. This is what you meant by "type safety", I guess.

The downside of this is, that you can't match against member values of foo, because the C++ type system does not allow for something similar to case classes like Scala. If you try to emulate case classes in C++ you end up coding hundreds of lines of precompiler statements, making your source code just ... bad (this is why I discarded acedia, btw.).

The structure you're using has to fulfill two requirements: it has to provide operator== and you have to tell libcppa how to serialize it (this is what announce does).