summaryrefslogtreecommitdiffstatshomepage
path: root/3rdparty/asio/src/examples/cpp03/serialization/connection.hpp
diff options
context:
space:
mode:
author Miodrag Milanovic <mmicko@gmail.com>2016-10-07 14:13:19 +0200
committer Miodrag Milanovic <mmicko@gmail.com>2016-10-07 14:13:19 +0200
commitff01b716711b97c2fcaa709ea97f7650f106aa10 (patch)
tree50dd4d687f38f50c4e136af030c02c267c769f3a /3rdparty/asio/src/examples/cpp03/serialization/connection.hpp
parent2a138159c30457aecd9e9679be5159704db0f954 (diff)
Added ASIO networking library (nw)
Diffstat (limited to '3rdparty/asio/src/examples/cpp03/serialization/connection.hpp')
-rw-r--r--3rdparty/asio/src/examples/cpp03/serialization/connection.hpp188
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