template <class AsyncReadStream >
class Protocol::AsyncHelper:
  public boost::enable_shared_from_this< Protocol::
                                         AsyncHelper< AsyncReadStream > > {

 public:
  AsyncHelper(Protocol &protocol,
              AsyncReadStream &stream,
              AsyncReadHandler handler) :
      buf(),
      protocol_(protocol),
      stream_(stream),
      handler_(handler) {}

  void AsyncReadMessage() {
    buf.reset(new uint8_t[sizeof(uint32_t) * 2]);
    boost::asio::async_read(stream_, boost::asio::buffer(&buf[0],
                                                        sizeof(uint32_t) * 2),
                            boost::bind(&AsyncHelper::AsyncReadHeader,
                                        shared_from_this(),
                                        boost::asio::placeholders::error));
  }
 private:
  void AsyncReadHeader(const boost::system::error_code &ec) {
    if (ec) {
      handler_(MessageP(), ProtocolExceptionP(
          new ProtocolException("IO error in Protocol::"
                                "AsyncHelper::AsyncReadHeader.")));
      return;
    }
    uint32_t id = reinterpret_cast<uint32_t*>(&buf[0])[0];
    uint32_t size = reinterpret_cast<uint32_t*>(&buf[0])[1];
    buf.reset(new uint8_t[size]);
    boost::asio::async_read(stream_, boost::asio::buffer(&buf[0], size),
                            boost::bind(&AsyncHelper::AsyncReadBody,
                                        shared_from_this(),
                                        boost::asio::placeholders::error,
                                        id,
                                        size);
  }

  void AsyncReadBody(const boost::system::error_code &ec,
                     uint32_t id, uint32_t size) {
    if (ec) {
      handler_(MessageP(), ProtocolExceptionP(
          new ProtocolException("IO error in Protocol::"
                                "AsyncHelper::AsyncReadBody.")));
      return;
    }

    ProtocolExceptionP exception;
    MessageP message;
    try {
      message = protocol_.helpers_[id]->ReadMessage(&buf[0], size);
    } catch (ProtocolException &e) {
      exception.reset(new ProtocolException(e));
    }
    handler_(message, exception);
  }
 private:
  boost::scoped_array<uint8_t> buf;
  Protocol &protocol_;
  AsyncReadStream &stream_;
  AsyncReadHandler handler_;
};

template <class AsyncReadStream>
void Protocol::AsyncReadMessage(AsyncReadStream &stream,
                                AsyncReadHandler handler) {
  typedef AsyncHelper< AsyncReadStream > Helper;
  boost::shared_ptr< Helper > helper(new Helper(*this, stream, handler));
  helper->AsyncReadMessage();
}