Steven Watanabe wrote:
You might also look into replacing Packet with boost::variant.
I would second this. If you use: typedef boost::variant<WalkPacket,CharPacket,etc> 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<WalkPacket,ChatPacket,etc> Packet; // Your signals... boost::signal<void (WalkerPacket)> distributeWalkerPacket; boost::signal<void (ChatPacket)> 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