[Boost-users] Next layer: Boost.Asio mixins?

Subject: [Boost-users] Next layer: Boost.Asio mixins?
From: Boris Schaeling (boris_at_[hidden])
Date: 2009-05-11 14:19:03

Did anyone create and use Boost.Asio mixins and can share his experience?  
I especially wonder if there is a benefit or if it's just an exercise in  
templates.

The reason I started to think about Boost.Asio mixins is that I see the  
very same code in various classes which all use Boost.Asio objects. I  
would assume that this is not only true in my projects but also in others.

Here's an example. Let's say we create a client class to connect to  
another host. We could come up with something like this:

class client
{
public:
   void resolve(std::string host, std::string service);
   void connect(boost::asio::ip::tcp::resolver::iterator endpoint_iterator);
   void send(std::string msg);
   void receive();

private:
   boost::asio::ip::tcp::resolver r;
   boost::asio::ip::tcp::socket s;
};

If we create another class to encapsulate a POSIX file descriptor we don't  
need resolve() and connect() but send() and receive():

class posix_fd
{
public:
   void send(std::string msg);
   void receive();

private:
   boost::asio::posix::stream_descriptor fd;
};

While the two classes are based on different I/O objects the  
implementation of send() and receive() could be the same. That lead me to  
create mixins with which I can define client and posix_fd like this:

class client :
   public resolver<boost::asio::ip::tcp::resolver, handler>,
   public connector<boost::asio::ip::tcp::socket, handler>,
   public sender<boost::asio::ip::tcp::socket, handler>,
   public receiver<boost::asio::ip::tcp::socket, handler>
{
   // Inherited from parent classes:
   // void resolve(std::string host, std::string service);
   // void connect(boost::asio::ip::tcp::resolver::iterator  
endpoint_iterator);
   // void send(std::string msg);
   // void receive();
};

class posix_fd :
   public sender<boost::asio::posix::stream_descriptor, handler>,
   public receiver<boost::asio::posix::stream_descriptor, handler>
{
   // Inherited from parent classes:
   // void send(std::string msg);
   // void receive();
};

Sending and receiving data asynchronously has been implemented now once  
and for all in the sender and receiver template classes. As the  
implementation doesn't differ for Boost.Asio I/O objects they can be  
reused. And if we had concepts already in C++ the mixins could be based on  
them.

It all seems to fit nicely together. While there are some problems, too, I  
haven't made my mind yet if these Boost.Asio mixins are an improvement or  
make code more complicated. I'm not asking about mixins in general but  
wonder if anyone had a good or bad experience using them with Boost.Asio?  
Or are all Boost.Asio users simply calling the very same async_write() and  
async_read() functions again and again, creating yet another buffer,  
checking again the error code in the handlers etc.?

Boris