Steven Watanabe wrote:
You might also look into replacing Packet with boost::variant.
I would second this. If you use:
typedef boost::variant Packet;
You might also consider using pointers in your Packet type, or even
shared_ptr<WalkPacket>, etc, but that is a detail which depends on how
the rest of your application is built. I use pointer-like types because
I am very aware of making copies of my potentially-large and numerous
packets.
In this situation, all of your messaging infrastructure that deals with
packets passes around instances of the variant type.
As you have described, your clients have a mechanism where they can
register using wrapper functions around the signals library to receive
notification on the arrival of specific packet types - one signal for
each packet type.
When it comes time to distribute your packet, you can make use of the
boost::variant visitor feature, which allows you to select operations
based on the actual type of the data in your variant instance. In your
case it might look something like this:
// Your packet type
typedef boost::variant Packet;
// Your signals...
boost::signal distributeWalkerPacket;
boost::signal distributeChatPacket;
// Helper class for apply_visitor
class doDistributePacket : public static_visitor<>
{
public:
void operator() ( WalkPacket p ) const
{
distributeWalkPacket( p );
}
void operator() ( ChatPacket p ) const
{
distributeChatPacket( p );
}
// and so on ...
};
// Free function to drive this above.
void DistributePacket( Packet p )
{
apply_visitor( doDistributePacket(), p );
}
I like boost::variant because it tends to bring all the type-dependent
code together and makes it easy to encapsulate type based decisions.
Kevin
