diff options
Diffstat (limited to '3rdparty/asio/src/examples/cpp03/serialization/connection.hpp')
-rw-r--r-- | 3rdparty/asio/src/examples/cpp03/serialization/connection.hpp | 188 |
1 files changed, 188 insertions, 0 deletions
diff --git a/3rdparty/asio/src/examples/cpp03/serialization/connection.hpp b/3rdparty/asio/src/examples/cpp03/serialization/connection.hpp new file mode 100644 index 00000000000..a1fa2a19e8e --- /dev/null +++ b/3rdparty/asio/src/examples/cpp03/serialization/connection.hpp @@ -0,0 +1,188 @@ +// +// connection.hpp +// ~~~~~~~~~~~~~~ +// +// Copyright (c) 2003-2016 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 |