text: //
  // connection.hpp
  // ~~~~~~~~~~~~~~
  //
  // Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
  //
  // Distributed under the Boost Software License, Version 1.0. (See accompanying
  // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
  //
  
  #ifndef SERIALIZATION_CONNECTION_HPP
  #define SERIALIZATION_CONNECTION_HPP
  
  #include <asio.hpp>
  #include <boost/archive/text_iarchive.hpp>
  #include <boost/archive/text_oarchive.hpp>
  #include <boost/bind.hpp>
  #include <boost/shared_ptr.hpp>
  #include <boost/tuple/tuple.hpp>
  #include <iomanip>
  #include <string>
  #include <sstream>
  #include <vector>
  
  namespace s11n_example {
  
  /// The connection class provides serialization primitives on top of a socket.
  /**
   * Each message sent using this class consists of:
   * @li An 8-byte header containing the length of the serialized data in
   * hexadecimal.
   * @li The serialized data.
   */
  class connection
  {
  public:
    /// Constructor.
    connection(asio::io_context& io_context)
      : socket_(io_context)
    {
    }
  
    /// Get the underlying socket. Used for making a connection or for accepting
    /// an incoming connection.
    asio::ip::tcp::socket& socket()
    {
      return socket_;
    }
  
    /// Asynchronously write a data structure to the socket.
    template <typename T, typename Handler>
    void async_write(const T& t, Handler handler)
    {
      // Serialize the data first so we know how large it is.
      std::ostringstream archive_stream;
      boost::archive::text_oarchive archive(archive_stream);
      archive << t;
      outbound_data_ = archive_stream.str();
  
      // Format the header.
      std::ostringstream header_stream;
      header_stream << std::setw(header_length)
        << std::hex << outbound_data_.size();
      if (!header_stream || header_stream.str().size() != header_length)
      {
        // Something went wrong, inform the caller.
        asio::error_code error(asio::error::invalid_argument);
        socket_.get_io_context().post(boost::bind(handler, error));
        return;
      }
      outbound_header_ = header_stream.str();
  
      // Write the serialized data to the socket. We use "gather-write" to send
      // both the header and the data in a single write operation.
      std::vector<asio::const_buffer> buffers;
      buffers.push_back(asio::buffer(outbound_header_));
      buffers.push_back(asio::buffer(outbound_data_));
      asio::async_write(socket_, buffers, handler);
    }
  
    /// Asynchronously read a data structure from the socket.
    template <typename T, typename Handler>
    void async_read(T& t, Handler handler)
    {
      // Issue a read operation to read exactly the number of bytes in a header.
      void (connection::*f)(
          const asio::error_code&,
          T&, boost::tuple<Handler>)
        = &connection::handle_read_header<T, Handler>;
      asio::async_read(socket_, asio::buffer(inbound_header_),
          boost::bind(f,
            this, asio::placeholders::error, boost::ref(t),
            boost::make_tuple(handler)));
    }
  
    /// Handle a completed read of a message header. The handler is passed using
    /// a tuple since boost::bind seems to have trouble binding a function object
    /// created using boost::bind as a parameter.
    template <typename T, typename Handler>
    void handle_read_header(const asio::error_code& e,
        T& t, boost::tuple<Handler> handler)
    {
      if (e)
      {
        boost::get<0>(handler)(e);
      }
      else
      {
        // Determine the length of the serialized data.
        std::istringstream is(std::string(inbound_header_, header_length));
        std::size_t inbound_data_size = 0;
        if (!(is >> std::hex >> inbound_data_size))
        {
          // Header doesn't seem to be valid. Inform the caller.
          asio::error_code error(asio::error::invalid_argument);
          boost::get<0>(handler)(error);
          return;
        }
  
        // Start an asynchronous call to receive the data.
        inbound_data_.resize(inbound_data_size);
        void (connection::*f)(
            const asio::error_code&,
            T&, boost::tuple<Handler>)
          = &connection::handle_read_data<T, Handler>;
        asio::async_read(socket_, asio::buffer(inbound_data_),
          boost::bind(f, this,
            asio::placeholders::error, boost::ref(t), handler));
      }
    }
  
    /// Handle a completed read of message data.
    template <typename T, typename Handler>
    void handle_read_data(const asio::error_code& e,
        T& t, boost::tuple<Handler> handler)
    {
      if (e)
      {
        boost::get<0>(handler)(e);
      }
      else
      {
        // Extract the data structure from the data just received.
        try
        {
          std::string archive_data(&inbound_data_[0], inbound_data_.size());
          std::istringstream archive_stream(archive_data);
          boost::archive::text_iarchive archive(archive_stream);
          archive >> t;
        }
        catch (std::exception& e)
        {
          // Unable to decode data.
          asio::error_code error(asio::error::invalid_argument);
          boost::get<0>(handler)(error);
          return;
        }
  
        // Inform caller that data has been received ok.
        boost::get<0>(handler)(e);
      }
    }
  
  private:
    /// The underlying socket.
    asio::ip::tcp::socket socket_;
  
    /// The size of a fixed length header.
    enum { header_length = 8 };
  
    /// Holds an outbound header.
    std::string outbound_header_;
  
    /// Holds the outbound data.
    std::string outbound_data_;
  
    /// Holds an inbound header.
    char inbound_header_[header_length];
  
    /// Holds the inbound data.
    std::vector<char> inbound_data_;
  };
  
  typedef boost::shared_ptr<connection> connection_ptr;
  
  } // namespace s11n_example
  
  #endif // SERIALIZATION_CONNECTION_HPP
  