diff --git a/.gitignore b/.gitignore
index e6d440e03..ae6362ad2 100644
--- a/.gitignore
+++ b/.gitignore
@@ -13,3 +13,4 @@ _build
 build/
 libs/network/doc/doxygen/
 .DS_Store
+*.swo
diff --git a/boost/network/protocol/http/server.hpp b/boost/network/protocol/http/server.hpp
index 386901c13..b70381fa6 100644
--- a/boost/network/protocol/http/server.hpp
+++ b/boost/network/protocol/http/server.hpp
@@ -12,37 +12,35 @@
 
 #include <boost/network/protocol/http/response.hpp>
 #include <boost/network/protocol/http/request.hpp>
-#include <boost/network/protocol/http/server/sync_server.hpp>
 #include <boost/network/protocol/http/server/async_server.hpp>
 
 namespace boost {
 namespace network {
 namespace http {
 
-template <class Tag, class Handler, class Enable = void>
-struct server_base {
-  typedef unsupported_tag<Tag> type;
-};
-
-template <class Tag, class Handler>
-struct server_base<Tag, Handler, typename enable_if<is_async<Tag> >::type> {
-  typedef async_server_base<Tag, Handler> type;
-};
-
-template <class Tag, class Handler>
-struct server_base<Tag, Handler, typename enable_if<is_sync<Tag> >::type> {
-  typedef sync_server_base<Tag, Handler> type;
-};
-
-template <class Tag, class Handler>
-struct basic_server : server_base<Tag, Handler>::type {};
-
+/**
+ * The main HTTP Server template implementing an asynchronous HTTP service.
+ *
+ * Usage Example:
+ * \code{.cpp}
+ *     handler_type handler;
+ *     http_server::options options(handler);
+ *     options.thread_pool(
+ *         std::make_shared<boost::network::utils::thread_pool>());
+ *     http_server server(options.address("localhost").port("8000"));
+ * \endcode
+ *
+ */
 template <class Handler>
-struct server : server_base<tags::http_server, Handler>::type {
-  typedef typename server_base<tags::http_server, Handler>::type server_base;
+struct server : async_server_base<tags::http_server, Handler> {
+  /// A convenience typedef for the base of this type, implementing most of
+  /// the internal details.
+  typedef async_server_base<tags::http_server, Handler> server_base;
+
+  /// The options supported by the server.
   typedef server_options<tags::http_server, Handler> options;
 
-  explicit server(options const &options) : server_base(options) {}
+  using server_base::server_base;
 };
 
 }  // namespace http
diff --git a/boost/network/protocol/http/server/async_connection.hpp b/boost/network/protocol/http/server/async_connection.hpp
index 0c259f9cc..e5c361ab6 100644
--- a/boost/network/protocol/http/server/async_connection.hpp
+++ b/boost/network/protocol/http/server/async_connection.hpp
@@ -20,6 +20,7 @@
 #include <asio/ip/tcp.hpp>
 #include <asio/strand.hpp>
 #include <asio/streambuf.hpp>
+#include <asio/write.hpp>
 #include <boost/network/protocol/http/algorithms/linearize.hpp>
 #include <boost/network/protocol/http/server/request_parser.hpp>
 #include <boost/network/protocol/stream_handler.hpp>
@@ -35,16 +36,17 @@
 #include <boost/utility/typed_in_place_factory.hpp>
 
 #ifndef BOOST_NETWORK_HTTP_SERVER_CONNECTION_HEADER_BUFFER_MAX_SIZE
-/** Here we define a page's worth of header connection buffer data.
- *  This can be tuned to reduce the memory cost of connections, but this
- *  default size is set to be friendly to typical service applications.
- *  This is the maximum size though and Boost.Asio's internal representation
- *  of a streambuf would make appropriate decisions on how big a buffer
- *  is to begin with.
+/**
+ * Here we define a page's worth of header connection buffer data.
+ * This can be tuned to reduce the memory cost of connections, but this
+ * default size is set to be friendly to typical service applications.
+ * This is the maximum size though and Boost.Asio's internal representation
+ * of a streambuf would make appropriate decisions on how big a buffer
+ * is to begin with.
  *
- *  This kinda assumes that a page is by default 4096. Since we're using
- *  the default allocator with the static buffers, it's not guaranteed that
- *  the static buffers will be page-aligned when they are allocated.
+ * This kinda assumes that a page is by default 4096. Since we're using
+ * the default allocator with the static buffers, it's not guaranteed that
+ * the static buffers will be page-aligned when they are allocated.
  */
 #define BOOST_NETWORK_HTTP_SERVER_CONNECTION_HEADER_BUFFER_MAX_SIZE 4096
 #endif /* BOOST_NETWORK_HTTP_SERVER_CONNECTION_HEADER_BUFFER_MAX_SIZE */
@@ -61,17 +63,15 @@ namespace boost {
 namespace network {
 namespace http {
 
-#ifndef BOOST_NETWORK_NO_LIB
 extern void parse_version(std::string const& partial_parsed,
                           std::tuple<std::uint8_t, std::uint8_t>& version_pair);
 extern void parse_headers(std::string const& input,
                           std::vector<request_header_narrow>& container);
-#endif
 
 template <class Tag, class Handler>
 struct async_connection
     : std::enable_shared_from_this<async_connection<Tag, Handler> > {
-
+  /// The set of known status codes for HTTP server responses.
   enum status_t {
     ok = 200,
     created = 201,
@@ -100,6 +100,8 @@ struct async_connection
 
   typedef typename string<Tag>::type string_type;
   typedef basic_request<Tag> request;
+
+  /// The connection pointer type.
   typedef std::shared_ptr<async_connection> connection_ptr;
 
  private:
@@ -180,10 +182,10 @@ struct async_connection
   }
 
  public:
-  async_connection(asio::io_service& io_service, Handler& handler,
-                   utils::thread_pool& thread_pool,
-                   std::shared_ptr<ssl_context> ctx =
-                       std::shared_ptr<ssl_context>())
+  async_connection(
+      asio::io_service& io_service, Handler& handler,
+      utils::thread_pool& thread_pool,
+      std::shared_ptr<ssl_context> ctx = std::shared_ptr<ssl_context>())
       : strand(io_service),
         handler(handler),
         thread_pool_(thread_pool),
@@ -207,17 +209,16 @@ struct async_connection
     socket_.shutdown(asio::ip::tcp::socket::shutdown_receive, ignored);
   }
 
-  /** Function: template <class Range> set_headers(Range headers)
-   *  Precondition: headers have not been sent yet
-   *  Postcondition: headers have been linearized to a buffer,
-   *                 and assumed to have been sent already when the
-   *function exits
-   *  Throws: std::logic_error in case the headers have already been sent.
+  /**
+   * A call to set_headers takes a Range where each element models the Header
+   * concept. This Range will be linearized onto a buffer, which is then sent
+   * as soon as the first call to `write` or `flush` commences.
    *
-   *  A call to set_headers takes a Range where each element models the
-   *  Header concept. This Range will be linearized onto a buffer, which
-   *is
-   *  then sent as soon as the first call to `write` or `flush` commences.
+   * @param[in] headers A range of Header objects to write out.
+   * @pre Headers have not been sent yet.
+   * @post Headers have been linearized to a buffer, and assumed to have been
+   *   sent already when the function exits.
+   * @throw std::logic_error when the precondition is violated.
    */
   template <class Range>
   void set_headers(Range headers) {
@@ -249,6 +250,14 @@ struct async_connection
     write_headers_only([self] {});
   }
 
+  /**
+   * Sets the status of the response.
+   *
+   * @param[in] new_status The new status for this response.
+   * @pre Headers have not been sent.
+   * @post Status is set on the response.
+   * @throw std::logic_error when the precondition is violated.
+   */
   void set_status(status_t new_status) {
     lock_guard lock(headers_mutex);
     if (headers_already_sent)
@@ -260,33 +269,78 @@ struct async_connection
     status = new_status;
   }
 
+  /**
+   * Writes a given range of bytes out in order.
+   *
+   * Even though this function looks synchronous, all it does is schedules
+   * asynchronous writes to the connection as soon as the range is serialised
+   * into appropriately sized buffers.
+   *
+   * To use in your handler, it would look like:
+   *
+   * Example:
+   * \code{.cpp}
+   *     connection->write("Hello, world!\n");
+   *     std::string sample = "I have a string!";
+   *     connection->write(sample);
+   * \endcode
+   *
+   * Note that if you want to send custom status and headers, you MUST call
+   * set_status and/or set_headers before any calls to write.
+   *
+   * @param[in] range A Boost.Range ``Single Pass Range`` of char's for writing.
+   * @throw std::system_error The encountered underlying error in previous
+   *     operations.
+   * @post Status and headers have been sent, contents in the range have been
+   *     serialized.
+   */
   template <class Range>
   void write(Range const& range) {
     lock_guard lock(headers_mutex);
     if (error_encountered)
       boost::throw_exception(std::system_error(*error_encountered));
     auto self = this->shared_from_this();
-    auto f = [this, self](std::error_code ec) {
-      this->default_error(ec);
-    };
+    auto f = [this, self](std::error_code ec) { this->default_error(ec); };
     write_impl(boost::make_iterator_range(range), f);
   }
 
+  /**
+   * Writes a given range out and schedules a completion callback to be invoked
+   * when the writes are done. This works similarly to write above.
+   *
+   * This overload is useful for writing streaming applications that send out
+   * chunks of data at a time, or for writing data that may not all fit in
+   * memory at once.
+   *
+   * @param[in] range A Boost.Range ``Single Pass Range`` of char's for writing.
+   * @param[in] callback A function of type `void(std::error_code)`.
+   * @throw std::system_error The encountered underlying error in previous
+   *     operations.
+   * @post Status and headers have been sent, contents in the range have been
+   *     serialized and scheduled for writing through the socket.
+   */
   template <class Range, class Callback>
   typename disable_if<
       is_base_of<asio::const_buffer, typename Range::value_type>, void>::type
-  write(Range const& range, Callback const& callback) {
+      write(Range const& range, Callback const& callback) {
     lock_guard lock(headers_mutex);
     if (error_encountered)
       boost::throw_exception(std::system_error(*error_encountered));
     write_impl(boost::make_iterator_range(range), callback);
   }
 
+  /**
+   * Writes a given set of `asio::const_buffer`s out using a more efficient
+   * implementation.
+   *
+   * @param[in] seq A sequence of `asio::const_buffer` objects.
+   * @param[in] callback A function of type `void(std::error_code)`.
+   */
   template <class ConstBufferSeq, class Callback>
   typename enable_if<
       is_base_of<asio::const_buffer, typename ConstBufferSeq::value_type>,
       void>::type
-  write(ConstBufferSeq const& seq, Callback const& callback) {
+      write(ConstBufferSeq const& seq, Callback const& callback) {
     write_vec_impl(seq, callback, shared_array_list(), shared_buffers());
   }
 
@@ -295,11 +349,30 @@ struct async_connection
       buffer_type;
 
  public:
+  /// The input range taken by ``read`` callbacks. Typically a range of
+  /// ``char``s.
   typedef iterator_range<buffer_type::const_iterator> input_range;
-  typedef std::function<
-      void(input_range, std::error_code, std::size_t, connection_ptr)>
-      read_callback_function;
 
+  /// Type required for ``read`` callbacks. Takes an input range, an error
+  /// code, the number of bytes read, and a connection pointer.
+  typedef std::function<void(input_range, std::error_code, std::size_t,
+                             connection_ptr)> read_callback_function;
+
+  /**
+   * Schedules an asynchronous read from the connection. This is generally
+   * useful for handling POST/PUT or other requests that may have data coming
+   * in through the HTTP request's body in a streaming manner.
+   *
+   * To use this function, the caller needs to provide a callback that handles
+   * a chunk of data at a time. The signature of the function (lambda or actual
+   * function pointer) should be of the following form:
+   *
+   *     void(input_range, error_code, size_t, connection_ptr)
+   *
+   * @param[in] callback Invoked when the read has data ready for processing.
+   * @throw std::system_error The underlying error encountered in previous
+   *     operations.
+   */
   void read(read_callback_function callback) {
     if (error_encountered)
       boost::throw_exception(std::system_error(*error_encountered));
@@ -316,17 +389,24 @@ struct async_connection
     }
 
     auto self = this->shared_from_this();
-    socket().async_read_some(
-        asio::buffer(read_buffer_),
-        strand.wrap([this, self, callback](std::error_code ec,
-                                           size_t bytes_transferred) {
-          callback(ec, bytes_transferred);
-        }));
+    socket().async_read_some(asio::buffer(read_buffer_),
+                             strand.wrap([this, self, callback](
+                                 std::error_code ec, size_t bytes_transferred) {
+                               callback(ec, bytes_transferred);
+                             }));
   }
 
+  /// Returns a reference to the underlying socket.
   boost::network::stream_handler& socket() { return socket_; }
+
+  /// Returns a reference to the thread_pool running this handler.
   utils::thread_pool& thread_pool() { return thread_pool_; }
+
+  /// Returns whether or not there were errors encountered in previous
+  /// operations.
   bool has_error() { return (!!error_encountered); }
+
+  /// Returns the most recent error encountered.
   optional<std::system_error> error() { return error_encountered; }
 
  private:
@@ -378,12 +458,7 @@ struct async_connection
   template <class, class>
   friend struct async_server_base;
 
-  enum state_t {
-    method,
-    uri,
-    version,
-    headers
-  };
+  enum state_t { method, uri, version, headers };
 
   void start() {
     typename ostringstream<Tag>::type ip_stream;
@@ -397,11 +472,10 @@ struct async_connection
     auto self = this->shared_from_this();
 #ifdef BOOST_NETWORK_ENABLE_HTTPS
     if (socket_.is_ssl_enabled() && !handshake_done) {
-      socket_.async_handshake(
-          asio::ssl::stream_base::server,
-          [this, self, state](std::error_code ec) {
-            handle_handshake(ec, state);
-          });
+      socket_.async_handshake(asio::ssl::stream_base::server,
+                              [this, self, state](std::error_code ec) {
+                                handle_handshake(ec, state);
+                              });
     } else {
 #endif
       socket_.async_read_some(
@@ -530,11 +604,11 @@ struct async_connection
         "text/plain\r\nContent-Length: 12\r\n\r\nBad Request.";
 
     auto self = this->shared_from_this();
-    asio::async_write(socket(), asio::buffer(bad_request, strlen(bad_request)),
-                      strand.wrap([this, self](std::error_code ec,
-                                               size_t bytes_transferred) {
-                        client_error_sent(ec, bytes_transferred);
-                      }));
+    asio::async_write(
+        socket(), asio::buffer(bad_request, strlen(bad_request)),
+        strand.wrap([this, self](std::error_code ec, size_t bytes_transferred) {
+          client_error_sent(ec, bytes_transferred);
+        }));
   }
 
   void client_error_sent(std::error_code const& ec, std::size_t) {
@@ -551,11 +625,11 @@ struct async_connection
     if (headers_in_progress) return;
     headers_in_progress = true;
     auto self = this->shared_from_this();
-    asio::async_write(
-        socket(), headers_buffer,
-        strand.wrap([this, self, callback] (std::error_code ec, size_t bytes_transferred) {
-	  handle_write_headers(callback, ec, bytes_transferred);
-	  }));
+    asio::async_write(socket(), headers_buffer,
+                      strand.wrap([this, self, callback](
+                          std::error_code ec, size_t bytes_transferred) {
+                        handle_write_headers(callback, ec, bytes_transferred);
+                      }));
   }
 
   void handle_write_headers(std::function<void()> callback,
@@ -575,17 +649,15 @@ struct async_connection
     }
   }
 
-  void handle_write(
-      std::function<void(std::error_code const&)> callback,
-      shared_array_list, shared_buffers, std::error_code const& ec,
-      std::size_t) {
+  void handle_write(std::function<void(std::error_code const&)> callback,
+                    shared_array_list, shared_buffers,
+                    std::error_code const& ec, std::size_t) {
     // we want to forget the temporaries and buffers
     thread_pool().post([callback, ec] { callback(ec); });
   }
 
   template <class Range>
-  void write_impl(Range range,
-                  std::function<void(std::error_code)> callback) {
+  void write_impl(Range range, std::function<void(std::error_code)> callback) {
     // linearize the whole range into a vector
     // of fixed-sized buffers, then schedule an asynchronous
     // write of these buffers -- make sure they are live
@@ -645,11 +717,11 @@ struct async_connection
       pending_actions.push_back(continuation);
       return;
     }
-    asio::async_write(socket_, seq, [this, self, callback, temporaries,
-                                     buffers](std::error_code ec,
-                                              size_t bytes_transferred) {
-      handle_write(callback, temporaries, buffers, ec, bytes_transferred);
-    });
+    asio::async_write(
+        socket_, seq, [this, self, callback, temporaries, buffers](
+                          std::error_code ec, size_t bytes_transferred) {
+          handle_write(callback, temporaries, buffers, ec, bytes_transferred);
+        });
   }
 
   void handle_handshake(const std::error_code& ec, state_t state) {
diff --git a/boost/network/protocol/http/server/async_server.hpp b/boost/network/protocol/http/server/async_server.hpp
index f3d665d51..954e0a5c3 100644
--- a/boost/network/protocol/http/server/async_server.hpp
+++ b/boost/network/protocol/http/server/async_server.hpp
@@ -21,15 +21,21 @@ namespace http {
 
 template <class Tag, class Handler>
 struct async_server_base : server_storage_base, socket_options_base {
+  /// The request type for this server.
   typedef basic_request<Tag> request;
-  typedef basic_response<Tag> response;
   typedef typename string<Tag>::type string_type;
-  typedef typename boost::network::http::response_header<Tag>::type
-      response_header;
+
+  /// The header type for this server.
+  typedef
+      typename boost::network::http::response_header<Tag>::type response_header;
+
+  /// The connection type for this server.
   typedef async_connection<Tag, Handler> connection;
+
+  /// Defines the type for the connection pointer.
   typedef std::shared_ptr<connection> connection_ptr;
-  typedef std::unique_lock<std::mutex> scoped_mutex_lock;
 
+  /// Constructs and initializes the asynchronous server core.
   explicit async_server_base(server_options<Tag, Handler> const &options)
       : server_storage_base(options),
         socket_options_base(options),
@@ -47,11 +53,31 @@ struct async_server_base : server_storage_base, socket_options_base {
         listening(false),
         ctx_(options.context()) {}
 
+  /**
+   * Listens to the correct port and runs the server's event loop. This can be
+   * run on multiple threads, as in the example below:
+   *
+   * Example:
+   *    handler_type handler;
+   *    http_server::options options(handler);
+   *    options.thread_pool(
+   *        std::make_shared<boost::network::utils::thread_pool>());
+   *    http_server server(options.address("localhost").port("8000"));
+   *
+   *    // Run in three threads including the current thread.
+   *    std::thread t1([&server] { server.run() });
+   *    std::thread t2([&server] { server.run() });
+   *    server.run();
+   *    t1.join();
+   *    t2.join();
+   */
   void run() {
     listen();
     service_.run();
   };
 
+  /// Stops the HTTP server acceptor and waits for all pending request handlers
+  /// to finish.
   void stop() {
     // stop accepting new requests and let all the existing
     // handlers finish.
@@ -63,10 +89,12 @@ struct async_server_base : server_storage_base, socket_options_base {
       std::error_code ignored;
       acceptor.close(ignored);
       listening = false;
-      service_.post([this] () { this->handle_stop(); });
+      service_.post([this]() { this->handle_stop(); });
     }
   }
 
+  /// Explicitly listens on the configured host and port. May be called
+  /// multiple times but only takes effect once.
   void listen() {
     scoped_mutex_lock listening_lock(listening_mutex_);
     BOOST_NETWORK_MESSAGE("Listening on " << address_ << ':' << port_);
@@ -81,6 +109,8 @@ struct async_server_base : server_storage_base, socket_options_base {
   }
 
  private:
+  typedef std::unique_lock<std::mutex> scoped_mutex_lock;
+
   Handler &handler;
   string_type address_, port_;
   std::shared_ptr<utils::thread_pool> thread_pool;
@@ -126,7 +156,7 @@ struct async_server_base : server_storage_base, socket_options_base {
 #else
         new_connection->socket(),
 #endif
-        [this] (std::error_code const &ec) { this->handle_accept(ec); });
+        [this](std::error_code const &ec) { this->handle_accept(ec); });
   }
 
   void start_listening() {
@@ -168,7 +198,7 @@ struct async_server_base : server_storage_base, socket_options_base {
 #else
         new_connection->socket(),
 #endif
-        [this] (std::error_code const &ec) { this->handle_accept(ec); });
+        [this](std::error_code const &ec) { this->handle_accept(ec); });
     listening = true;
     scoped_mutex_lock stopping_lock(stopping_mutex_);
     stopping = false;  // if we were in the process of stopping, we revoke
diff --git a/boost/network/protocol/http/server/options.hpp b/boost/network/protocol/http/server/options.hpp
index a9db0e23c..d3d9f03a1 100644
--- a/boost/network/protocol/http/server/options.hpp
+++ b/boost/network/protocol/http/server/options.hpp
@@ -20,10 +20,15 @@ namespace boost {
 namespace network {
 namespace http {
 
+/**
+ * The options supported by an HTTP Server's constructor.
+ */
 template <class Tag, class Handler>
 struct server_options {
   typedef typename string<Tag>::type string_type;
 
+  /// A single-argument constructor that takes a Handler, and sets all options
+  /// to defaults.
   explicit server_options(Handler &handler)
       : io_service_(),
         handler_(handler),
@@ -41,139 +46,186 @@ struct server_options {
         thread_pool_(),
         context_() {}
 
-  server_options(const server_options &other)
-      : io_service_(other.io_service()),
-        handler_(other.handler_),
-        address_(other.address_),
-        port_(other.port_),
-        reuse_address_(other.reuse_address_),
-        report_aborted_(other.report_aborted_),
-        non_blocking_io_(other.non_blocking_io_),
-        linger_(other.linger_),
-        linger_timeout_(0),
-        receive_buffer_size_(other.receive_buffer_size_),
-        send_buffer_size_(other.send_buffer_size_),
-        receive_low_watermark_(other.receive_low_watermark_),
-        send_low_watermark_(other.send_low_watermark_),
-        thread_pool_(other.thread_pool_),
-        context_(other.context_) {}
-
-  server_options &operator=(server_options other) {
-    other.swap(*this);
-    return *this;
-  }
+  /// Disabled default constructor for the options class.
+  server_options() = delete;
 
-  void swap(server_options &other) {
-    using std::swap;
-    swap(io_service_, other.io_service_);
-    swap(address_, other.address_);
-    swap(port_, other.port_);
-    swap(reuse_address_, other.reuse_address_);
-    swap(report_aborted_, other.report_aborted_);
-    swap(non_blocking_io_, other.non_blocking_io_);
-    swap(linger_, other.linger_);
-    swap(linger_timeout_, other.linger_timeout_);
-    swap(receive_buffer_size_, other.receive_buffer_size_);
-    swap(send_buffer_size_, other.send_buffer_size_);
-    swap(receive_low_watermark_, other.receive_low_watermark_);
-    swap(send_low_watermark_, other.send_low_watermark_);
-    swap(thread_pool_, other.thread_pool_);
-    swap(context_, other.context_);
-  }
+  /// Copy constructor for the options class.
+  server_options(const server_options &) = default;
+
+  /// Copy assignment for the options class.
+  server_options &operator=(const server_options &) = default;
+
+  /// Move constructor for the options class.
+  server_options(server_options &&) = default;
+
+  /// Move assignment for the options class.
+  server_options &operator=(server_options &&) = default;
 
+  /// Destructor for the options class.
+  ~server_options() = default;
+
+  /// Sets the SSL context for the server. Default is nullptr.
   server_options &context(std::shared_ptr<ssl_context> v) {
     context_ = v;
     return *this;
   }
+
+  /// Provides an Asio io_service for the server. Default is nullptr.
   server_options &io_service(std::shared_ptr<asio::io_service> v) {
     io_service_ = v;
     return *this;
   }
-  server_options &address(string_type const &v) {
-    address_ = v;
+
+  /// Sets the address to listen to for the server. Default is localhost.
+  server_options &address(string_type v) {
+    address_ = std::move(v);
     return *this;
   }
+
+  /// Set the port to listen to for the server. Default is 80.
   server_options &port(string_type const &v) {
     port_ = v;
     return *this;
   }
+
+  /// Set whether to reuse the address (SO_REUSE_ADDR). Default is false.
   server_options &reuse_address(bool v) {
     reuse_address_ = v;
     return *this;
   }
+
+  /// Set whether to report aborted connections. Default is false.
   server_options &report_aborted(bool v) {
     report_aborted_ = v;
     return *this;
   }
+
+  /// Set whether to use non-blocking IO. Default is true.
   server_options &non_blocking_io(bool v) {
     non_blocking_io_ = v;
     return *this;
   }
+
+  /// Set whether sockets linger (SO_LINGER). Default is true.
   server_options &linger(bool v) {
     linger_ = v;
     return *this;
   }
+
+  /// Set the linger timeout. Default is 0.
   server_options &linger_timeout(size_t v) {
     linger_timeout_ = v;
     return *this;
   }
+
+  /// Set the socket receive buffer size. Unset by default.
   server_options &receive_buffer_size(
       asio::socket_base::receive_buffer_size v) {
     receive_buffer_size_ = v;
     return *this;
   }
-  server_options &send_buffer_size(
-      asio::socket_base::send_buffer_size v) {
+
+  /// Set the send buffer size. Unset by default.
+  server_options &send_buffer_size(asio::socket_base::send_buffer_size v) {
     send_buffer_size_ = v;
     return *this;
   }
+
+  /// Set the socket receive low watermark. Unset by default.
   server_options &receive_low_watermark(
       asio::socket_base::receive_low_watermark v) {
     receive_low_watermark_ = v;
     return *this;
   }
-  server_options &send_low_watermark(
-      asio::socket_base::send_low_watermark v) {
+
+  /// Set the socket send low watermark. Unset by default.
+  server_options &send_low_watermark(asio::socket_base::send_low_watermark v) {
     send_low_watermark_ = v;
     return *this;
   }
+
+  /// Set the thread-pool to use. Default is nullptr.
   server_options &thread_pool(std::shared_ptr<utils::thread_pool> v) {
     thread_pool_ = v;
     return *this;
   }
 
-  std::shared_ptr<asio::io_service> io_service() const {
-    return io_service_;
-  }
+  /// Returns the provided Asio io_service.
+  std::shared_ptr<asio::io_service> io_service() const { return io_service_; }
+
+  /// Returns the address to listen on.
   string_type address() const { return address_; }
+
+  /// Returns the port to listen on.
   string_type port() const { return port_; }
+
+  /// Returns a reference to the provided handler.
   Handler &handler() const { return handler_; }
+
+  /// Returns whether to reuse the address.
   bool reuse_address() const { return reuse_address_; }
+
+  /// Returns whether to report aborted connections.
   bool report_aborted() const { return report_aborted_; }
+
+  /// Returns whether to perform non-blocking IO.
   bool non_blocking_io() const { return non_blocking_io_; }
+
+  /// Returns whether to linger.
   bool linger() const { return linger_; }
+
+  /// Returns the linger timeout.
   size_t linger_timeout() const { return linger_timeout_; }
-  boost::optional<asio::socket_base::receive_buffer_size>
-  receive_buffer_size() const {
+
+  /// Returns the optional receive buffer size.
+  boost::optional<asio::socket_base::receive_buffer_size> receive_buffer_size()
+      const {
     return receive_buffer_size_;
   }
+
+  /// Returns the optional send buffer size.
   boost::optional<asio::socket_base::send_buffer_size> send_buffer_size()
       const {
     return send_buffer_size_;
   }
+
+  /// Returns the optional receive low watermark.
   boost::optional<asio::socket_base::receive_low_watermark>
-  receive_low_watermark() const {
+      receive_low_watermark() const {
     return receive_low_watermark_;
   }
-  boost::optional<asio::socket_base::send_low_watermark>
-  send_low_watermark() const {
+
+  /// Returns the optional send low watermark.
+  boost::optional<asio::socket_base::send_low_watermark> send_low_watermark()
+      const {
     return send_low_watermark_;
   }
+
+  /// Returns a pointer to the provided thread pool.
   std::shared_ptr<utils::thread_pool> thread_pool() const {
     return thread_pool_;
   }
-  std::shared_ptr<ssl_context> context() const {
-    return context_;
+
+  /// Returns a pointer to the provided context.
+  std::shared_ptr<ssl_context> context() const { return context_; }
+
+  /// Swap implementation for the server options.
+  void swap(server_options &other) {
+    using std::swap;
+    swap(io_service_, other.io_service_);
+    swap(address_, other.address_);
+    swap(port_, other.port_);
+    swap(reuse_address_, other.reuse_address_);
+    swap(report_aborted_, other.report_aborted_);
+    swap(non_blocking_io_, other.non_blocking_io_);
+    swap(linger_, other.linger_);
+    swap(linger_timeout_, other.linger_timeout_);
+    swap(receive_buffer_size_, other.receive_buffer_size_);
+    swap(send_buffer_size_, other.send_buffer_size_);
+    swap(receive_low_watermark_, other.receive_low_watermark_);
+    swap(send_low_watermark_, other.send_low_watermark_);
+    swap(thread_pool_, other.thread_pool_);
+    swap(context_, other.context_);
   }
 
  private:
@@ -186,13 +238,11 @@ struct server_options {
   bool non_blocking_io_;
   bool linger_;
   size_t linger_timeout_;
-  boost::optional<asio::socket_base::receive_buffer_size>
-      receive_buffer_size_;
+  boost::optional<asio::socket_base::receive_buffer_size> receive_buffer_size_;
   boost::optional<asio::socket_base::send_buffer_size> send_buffer_size_;
   boost::optional<asio::socket_base::receive_low_watermark>
       receive_low_watermark_;
-  boost::optional<asio::socket_base::send_low_watermark>
-      send_low_watermark_;
+  boost::optional<asio::socket_base::send_low_watermark> send_low_watermark_;
   std::shared_ptr<utils::thread_pool> thread_pool_;
   std::shared_ptr<ssl_context> context_;
 };
diff --git a/boost/network/protocol/http/server/sync_connection.hpp b/boost/network/protocol/http/server/sync_connection.hpp
deleted file mode 100644
index 969ce6bba..000000000
--- a/boost/network/protocol/http/server/sync_connection.hpp
+++ /dev/null
@@ -1,233 +0,0 @@
-// Copyright 2009 (c) Dean Michael Berris <mikhailberis@gmail.com>
-// Copyright 2009 (c) Tarroo, Inc.
-// Adapted from Christopher Kholhoff's Boost.Asio Example, released under
-// the Boost Software License, Version 1.0. (See acccompanying file
-// LICENSE_1_0.txt
-// or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef BOOST_NETWORK_HTTP_SERVER_SYNC_CONNECTION_HPP_
-#define BOOST_NETWORK_HTTP_SERVER_SYNC_CONNECTION_HPP_
-
-#ifndef BOOST_NETWORK_HTTP_SERVER_CONNECTION_BUFFER_SIZE
-#define BOOST_NETWORK_HTTP_SERVER_CONNECTION_BUFFER_SIZE 1024uL
-#endif
-
-#include <memory>
-#include <array>
-#include <asio/io_service.hpp>
-#include <asio/ip/tcp.hpp>
-#include <asio/buffer.hpp>
-#include <asio/write.hpp>
-#include <asio/read.hpp>
-#include <asio/strand.hpp>
-#include <asio/placeholders.hpp>
-#include <boost/algorithm/string/case_conv.hpp>
-#include <boost/network/protocol/http/request_parser.hpp>
-#include <boost/network/protocol/http/request.hpp>
-#include <boost/network/protocol/http/response.hpp>
-
-namespace boost {
-namespace network {
-namespace http {
-
-template <class Tag, class Handler>
-struct sync_connection
-    : std::enable_shared_from_this<sync_connection<Tag, Handler> > {
-
-  sync_connection(asio::io_service &service, Handler &handler)
-      : service_(service),
-        handler_(handler),
-        socket_(service_),
-        wrapper_(service_) {}
-
-  asio::ip::tcp::socket &socket() { return socket_; }
-
-  void start() {
-    // This is HTTP so we really want to just
-    // read and parse a request that's incoming
-    // and then pass that request object to the
-    // handler_ instance.
-    //
-    using asio::ip::tcp;
-    std::error_code option_error;
-    socket_.set_option(tcp::no_delay(true), option_error);
-    if (option_error)
-      handler_.log(std::system_error(option_error).what());
-    auto self = this->shared_from_this();
-    socket_.async_read_some(
-        asio::buffer(buffer_),
-        wrapper_.wrap([=] (std::error_code const &ec,
-                           std::size_t bytes_transferred) {
-                        self->handle_read_headers(ec, bytes_transferred);
-                      }));
-  }
-
- private:
-  struct is_content_length {
-    template <class Header>
-    bool operator()(Header const &header) {
-      return boost::to_lower_copy(header.name) == "content-length";
-    }
-  };
-
-  void handle_read_headers(std::error_code const &ec,
-                           size_t bytes_transferred) {
-    if (!ec) {
-      request_.source = socket_.remote_endpoint().address().to_string();
-      request_.source_port = socket_.remote_endpoint().port();
-      boost::tribool done;
-      buffer_type::iterator new_start;
-      tie(done, new_start) = parser_.parse_headers(
-          request_, buffer_.data(), buffer_.data() + bytes_transferred);
-      if (done) {
-        if (request_.method[0] == 'P') {
-          // look for the content-length header
-          auto
-              it = std::find_if(request_.headers.begin(),
-                                request_.headers.end(), is_content_length());
-          if (it == request_.headers.end()) {
-            response_ = basic_response<Tag>::stock_reply(
-                basic_response<Tag>::bad_request);
-            auto self = this->shared_from_this();
-            asio::async_write(
-                socket_, response_.to_buffers(),
-                wrapper_.wrap([=] (std::error_code const &ec) {
-                    self->handle_write(ec);
-                  }));
-            return;
-          }
-
-          size_t content_length = 0;
-
-          try {
-            content_length = std::stoul(it->value);
-          }
-          catch (...) {
-            response_ = basic_response<Tag>::stock_reply(
-                basic_response<Tag>::bad_request);
-            auto self = this->shared_from_this();
-            asio::async_write(
-                socket_, response_.to_buffers(),
-                wrapper_.wrap([=] (std::error_code const &ec) {
-                    self->handle_write(ec);
-                  }));
-            return;
-          }
-
-          if (content_length != 0) {
-            if (new_start != (buffer_.begin() + bytes_transferred)) {
-              request_.body.append(new_start,
-                                   buffer_.begin() + bytes_transferred);
-              content_length -=
-                  std::distance(new_start, buffer_.begin() + bytes_transferred);
-            }
-            if (content_length > 0) {
-              auto self = this->shared_from_this();
-              socket_.async_read_some(
-                  asio::buffer(buffer_),
-                  wrapper_.wrap([=] (std::error_code const &ec,
-                                     std::size_t bytes_transferred) {
-                                  self->handle_read_body_contents(ec, content_length,
-                                                                  bytes_transferred);
-                                }));
-              return;
-            }
-          }
-
-          handler_(request_, response_);
-          auto self = this->shared_from_this();
-          asio::async_write(
-              socket_, response_.to_buffers(),
-              wrapper_.wrap([=] (std::error_code const &ec) {
-                  self->handle_write(ec);
-                }));
-        } else {
-          handler_(request_, response_);
-          auto self = this->shared_from_this();
-          asio::async_write(
-              socket_, response_.to_buffers(),
-              wrapper_.wrap([=] (std::error_code const &ec) {
-                  self->handle_write(ec);
-                }));
-        }
-      } else if (!done) {
-        response_ =
-            basic_response<Tag>::stock_reply(basic_response<Tag>::bad_request);
-          auto self = this->shared_from_this();
-        asio::async_write(
-            socket_, response_.to_buffers(),
-            wrapper_.wrap([=] (std::error_code const &ec) {
-                self->handle_write(ec);
-              }));
-      } else {
-        auto self = this->shared_from_this();
-        socket_.async_read_some(
-            asio::buffer(buffer_),
-            wrapper_.wrap([=] (std::error_code const &ec,
-                               std::size_t bytes_transferred) {
-                            self->handle_read_headers(ec, bytes_transferred);
-                          }));
-      }
-    }
-    // TODO Log the error?
-  }
-
-  void handle_read_body_contents(std::error_code const &ec,
-                                 size_t bytes_to_read,
-                                 size_t bytes_transferred) {
-    if (!ec) {
-      size_t difference = bytes_to_read - bytes_transferred;
-      buffer_type::iterator start = buffer_.begin(), past_end = start;
-      std::advance(past_end, (std::min)(bytes_to_read, bytes_transferred));
-      request_.body.append(buffer_.begin(), past_end);
-      if (difference == 0) {
-        handler_(request_, response_);
-        auto self = this->shared_from_this();
-        asio::async_write(
-            socket_, response_.to_buffers(),
-            wrapper_.wrap([=] (std::error_code const &ec) {
-                self->handle_write(ec);
-              }));
-      } else {
-        auto self = this->shared_from_this();
-        socket_.async_read_some(
-            asio::buffer(buffer_),
-            wrapper_.wrap([=] (std::error_code const &ec,
-                               std::size_t bytes_transferred) {
-                            self->handle_read_body_contents(ec, difference, bytes_transferred);
-                          }));
-      }
-    }
-    // TODO Log the error?
-  }
-
-  void handle_write(std::error_code const &ec) {
-    if (!ec) {
-      using asio::ip::tcp;
-      std::error_code ignored_ec;
-      socket_.shutdown(tcp::socket::shutdown_receive, ignored_ec);
-    }
-  }
-
-  asio::io_service &service_;
-  Handler &handler_;
-  asio::ip::tcp::socket socket_;
-  asio::io_service::strand wrapper_;
-
-  typedef std::array<char, BOOST_NETWORK_HTTP_SERVER_CONNECTION_BUFFER_SIZE>
-      buffer_type;
-  buffer_type buffer_;
-  typedef basic_request_parser<Tag> request_parser;
-  request_parser parser_;
-  basic_request<Tag> request_;
-  basic_response<Tag> response_;
-};
-
-}  // namespace http
-
-}  // namespace network
-
-}  // namespace boost
-
-#endif  // BOOST_NETWORK_HTTP_SERVER_SYNC_CONNECTION_HPP_
diff --git a/boost/network/protocol/http/server/sync_server.hpp b/boost/network/protocol/http/server/sync_server.hpp
deleted file mode 100644
index 2b4b976da..000000000
--- a/boost/network/protocol/http/server/sync_server.hpp
+++ /dev/null
@@ -1,133 +0,0 @@
-
-// Copyright 2010 Dean Michael Berris.
-// Copyright 2010 Glyn Matthews.
-// 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 BOOST_NETWORK_PROTOCOL_HTTP_SERVER_SYNC_SERVER_HPP_20101025
-#define BOOST_NETWORK_PROTOCOL_HTTP_SERVER_SYNC_SERVER_HPP_20101025
-
-#include <memory>
-#include <mutex>
-#include <asio/ip/tcp.hpp>
-#include <boost/network/detail/debug.hpp>
-#include <boost/network/protocol/http/response.hpp>
-#include <boost/network/protocol/http/request.hpp>
-#include <boost/network/protocol/http/server/sync_connection.hpp>
-#include <boost/network/protocol/http/server/storage_base.hpp>
-#include <boost/network/protocol/http/server/socket_options_base.hpp>
-#include <boost/network/protocol/http/server/options.hpp>
-#include <boost/network/traits/string.hpp>
-
-namespace boost {
-namespace network {
-namespace http {
-
-template <class Tag, class Handler>
-struct sync_server_base : server_storage_base, socket_options_base {
-  typedef typename string<Tag>::type string_type;
-  typedef basic_request<Tag> request;
-  typedef basic_response<Tag> response;
-  typedef typename boost::network::http::response_header<Tag>::type
-      response_header;
-
-  sync_server_base(server_options<Tag, Handler> const& options)
-      : server_storage_base(options),
-        socket_options_base(options),
-        handler_(options.handler()),
-        address_(options.address()),
-        port_(options.port()),
-        acceptor_(server_storage_base::service_),
-        new_connection(),
-        listening_mutex_(),
-        listening_(false) {}
-
-  void run() {
-    listen();
-    service_.run();
-  }
-
-  void stop() {
-    // stop accepting new connections and let all the existing handlers
-    // finish.
-    std::error_code ignored;
-    acceptor_.close(ignored);
-    service_.stop();
-  }
-
-  void listen() {
-    std::unique_lock<std::mutex> listening_lock(listening_mutex_);
-    if (!listening_) start_listening();
-  }
-
- private:
-  Handler& handler_;
-  string_type address_, port_;
-  asio::ip::tcp::acceptor acceptor_;
-  std::shared_ptr<sync_connection<Tag, Handler> > new_connection;
-  std::mutex listening_mutex_;
-  bool listening_;
-
-  void handle_accept(std::error_code const& ec) {
-    if (ec) {
-    }
-    socket_options_base::socket_options(new_connection->socket());
-    new_connection->start();
-    new_connection.reset(new sync_connection<Tag, Handler>(service_, handler_));
-    auto self = this->shared_from_this();
-    acceptor_.async_accept(
-        new_connection->socket(),
-        [=] (std::error_code const &ec) { self->handle_accept(); });
-  }
-
-  void start_listening() {
-    using asio::ip::tcp;
-    std::error_code error;
-    tcp::resolver resolver(service_);
-    tcp::resolver::query query(address_, port_);
-    tcp::resolver::iterator endpoint_iterator = resolver.resolve(query, error);
-    if (error) {
-      BOOST_NETWORK_MESSAGE("Error resolving address: " << address_ << ':'
-                                                        << port_);
-      boost::throw_exception(std::runtime_error("Error resolving address."));
-    }
-    tcp::endpoint endpoint = *endpoint_iterator;
-    acceptor_.open(endpoint.protocol(), error);
-    if (error) {
-      BOOST_NETWORK_MESSAGE("Error opening socket: " << address_ << ':' << port_
-                                                     << " -- reason: '" << error
-                                                     << '\'');
-      boost::throw_exception(std::runtime_error("Error opening socket."));
-    }
-    socket_options_base::acceptor_options(acceptor_);
-    acceptor_.bind(endpoint, error);
-    if (error) {
-      BOOST_NETWORK_MESSAGE("Error binding to socket: "
-                            << address_ << ':' << port_ << " -- reason: '"
-                            << error << '\'');
-      boost::throw_exception(std::runtime_error("Error binding to socket."));
-    }
-    acceptor_.listen(tcp::socket::max_connections, error);
-    if (error) {
-      BOOST_NETWORK_MESSAGE("Error listening on socket: "
-                            << address_ << ':' << port_ << " -- reason: '"
-                            << error << '\'');
-      boost::throw_exception(std::runtime_error("Error listening on socket."));
-    }
-    new_connection.reset(new sync_connection<Tag, Handler>(service_, handler_));
-    auto self = this->shared_from_this();
-    acceptor_.async_accept(
-        new_connection->socket(),
-        [=] (std::error_code const &ec) { self->handle_accept(ec); });
-    listening_ = true;
-  }
-};
-
-} /* http */
-
-} /* network */
-
-} /* boost */
-
-#endif /* BOOST_NETWORK_PROTOCOL_HTTP_SERVER_SYNC_SERVER_HPP_20101025 */
diff --git a/libs/network/doc/contents.rst b/libs/network/doc/contents.rst
index b014eab03..0c41b80a7 100644
--- a/libs/network/doc/contents.rst
+++ b/libs/network/doc/contents.rst
@@ -10,8 +10,5 @@ Contents
    whats_new.rst
    getting_started.rst
    examples.rst
-   in_depth.rst
-   techniques.rst
-   history.rst
    reference.rst
    references.rst
diff --git a/libs/network/doc/history.rst b/libs/network/doc/history.rst
deleted file mode 100644
index 24f503f0a..000000000
--- a/libs/network/doc/history.rst
+++ /dev/null
@@ -1,54 +0,0 @@
-Project history
-===============
-
-The :mod:`cpp-netlib` was founded by Dean Michael Berris in 2007.
-Initially it consisted of a message template and an HTTP client.  It
-found a home on Sourceforge_ but was migrated at the end of 2009 to
-Github_ where development is actively continued by a committed
-community.
-
-Motivation
-~~~~~~~~~~
-
-We're a group of C++ developers and we kept becoming annoyed that we
-had to repeatedly write the same code when building applications that
-needed to be network-aware.
-
-We found that there was a lack of accessible networking libraries,
-either standard or open source, that fulfilled our needs.  Such
-libraries exist for every other major language.  So, building on top
-of `Boost.Asio`_, we decided to get together and build our own.
-
-Objectives
-~~~~~~~~~~
-
-The objectives of the :mod:`cpp-netlib` are to:
-
-* develop a high quality, portable, easy to use C++ networking library
-* enable developers to easily extend the library
-* lower the barrier to entry for cross-platform network-aware C++
-  applications
-
-The goal the of :mod:`cpp-netlib` has never been to build a
-fully-featured web server - there are plenty of excellent options
-already available.  The niche that this library targets is for
-light-weight networking functionality for C++ applications that have
-demanding performance requirements or memory constraints, but that
-also need to be portable.  This type of application is becoming
-increasingly common as software becomes more distributed, and
-applications need to communicate with services.
-
-While many languages provide direct library support for high level
-network programming, this feature is missing in C++.  Therefore, this
-library has been developed with the intention of eventually being
-submitted to Boost_, a collection of general, high quality
-libraries for C++ developers.
-
-Eventually, the :mod:`cpp-netlib` will be extended to support many of
-the application layer protocols such as SMTP, FTP, SOAP, XMPP etc.
-
-
-.. _Sourceforge: http://sourceforge.net/projects/cpp-netlib/
-.. _Github: http://github.com/cpp-netlib/cpp-netlib
-.. _Boost: http://www.boost.org/
-.. _`Boost.Asio`: http://www.boost.org/libs/asio/
diff --git a/libs/network/doc/html/_images/ftp_uri.png b/libs/network/doc/html/_images/ftp_uri.png
deleted file mode 100644
index f77d3c87b..000000000
Binary files a/libs/network/doc/html/_images/ftp_uri.png and /dev/null differ
diff --git a/libs/network/doc/html/_images/http_uri.png b/libs/network/doc/html/_images/http_uri.png
deleted file mode 100644
index a7bf7561b..000000000
Binary files a/libs/network/doc/html/_images/http_uri.png and /dev/null differ
diff --git a/libs/network/doc/html/_images/mailto_uri.png b/libs/network/doc/html/_images/mailto_uri.png
deleted file mode 100644
index 118d6f4ba..000000000
Binary files a/libs/network/doc/html/_images/mailto_uri.png and /dev/null differ
diff --git a/libs/network/doc/html/_sources/contents.txt b/libs/network/doc/html/_sources/contents.txt
index b014eab03..0c41b80a7 100644
--- a/libs/network/doc/html/_sources/contents.txt
+++ b/libs/network/doc/html/_sources/contents.txt
@@ -10,8 +10,5 @@ Contents
    whats_new.rst
    getting_started.rst
    examples.rst
-   in_depth.rst
-   techniques.rst
-   history.rst
    reference.rst
    references.rst
diff --git a/libs/network/doc/html/_sources/history.txt b/libs/network/doc/html/_sources/history.txt
deleted file mode 100644
index 24f503f0a..000000000
--- a/libs/network/doc/html/_sources/history.txt
+++ /dev/null
@@ -1,54 +0,0 @@
-Project history
-===============
-
-The :mod:`cpp-netlib` was founded by Dean Michael Berris in 2007.
-Initially it consisted of a message template and an HTTP client.  It
-found a home on Sourceforge_ but was migrated at the end of 2009 to
-Github_ where development is actively continued by a committed
-community.
-
-Motivation
-~~~~~~~~~~
-
-We're a group of C++ developers and we kept becoming annoyed that we
-had to repeatedly write the same code when building applications that
-needed to be network-aware.
-
-We found that there was a lack of accessible networking libraries,
-either standard or open source, that fulfilled our needs.  Such
-libraries exist for every other major language.  So, building on top
-of `Boost.Asio`_, we decided to get together and build our own.
-
-Objectives
-~~~~~~~~~~
-
-The objectives of the :mod:`cpp-netlib` are to:
-
-* develop a high quality, portable, easy to use C++ networking library
-* enable developers to easily extend the library
-* lower the barrier to entry for cross-platform network-aware C++
-  applications
-
-The goal the of :mod:`cpp-netlib` has never been to build a
-fully-featured web server - there are plenty of excellent options
-already available.  The niche that this library targets is for
-light-weight networking functionality for C++ applications that have
-demanding performance requirements or memory constraints, but that
-also need to be portable.  This type of application is becoming
-increasingly common as software becomes more distributed, and
-applications need to communicate with services.
-
-While many languages provide direct library support for high level
-network programming, this feature is missing in C++.  Therefore, this
-library has been developed with the intention of eventually being
-submitted to Boost_, a collection of general, high quality
-libraries for C++ developers.
-
-Eventually, the :mod:`cpp-netlib` will be extended to support many of
-the application layer protocols such as SMTP, FTP, SOAP, XMPP etc.
-
-
-.. _Sourceforge: http://sourceforge.net/projects/cpp-netlib/
-.. _Github: http://github.com/cpp-netlib/cpp-netlib
-.. _Boost: http://www.boost.org/
-.. _`Boost.Asio`: http://www.boost.org/libs/asio/
diff --git a/libs/network/doc/html/_sources/in_depth.txt b/libs/network/doc/html/_sources/in_depth.txt
deleted file mode 100644
index 39af9a4f4..000000000
--- a/libs/network/doc/html/_sources/in_depth.txt
+++ /dev/null
@@ -1,15 +0,0 @@
-.. _in_depth:
-
-An in-depth look at the :mod:`cpp-netlib`
-=========================================
-
-The :mod:`cpp-netlib` is composed of three different sets of
-functionality: a **message** template, a **URI** template and
-different **protocol** implementations.
-
-.. toctree::
-   :maxdepth: 2
-
-   in_depth/message
-   in_depth/uri
-   in_depth/http
diff --git a/libs/network/doc/html/_sources/in_depth/http.txt b/libs/network/doc/html/_sources/in_depth/http.txt
deleted file mode 100644
index 711bf6b3e..000000000
--- a/libs/network/doc/html/_sources/in_depth/http.txt
+++ /dev/null
@@ -1,180 +0,0 @@
-HTTP implementation
-===================
-
-HTTP client
-```````````
-
-At the heart of the HTTP client implementation is a single class aptly named
-``basic_client``, which is also a template. The template ``basic_client`` takes
-three template parameters:
-
-.. code-block:: c++
-
-    namespace boost { namespace http {
-
-        template <class Tag, unsigned version_major, unsigned version_minor>
-        struct basic_client;
-
-    } // namespace http
-
-    } // namespace boost
-
-The ``Tag`` template parameter follows the same tag-dispatch mechanism to
-determine the behavior of the ``basic_client``. The interface of
-``basic_client`` may change depending on certain properties defined for the tag
-you provide. Below is a table of predefined supported tags you can use in your
-overload of the ``basic_client``:
-
-------------
-
-.. include:: http_client_tags.rst
-
-.. _Boost.Thread: http://www.boost.org/libs/thread
-
-
-The default typedef for the HTTP client that is provided uses the
-``http_async_8bit_udp_resolve`` tag, and implements HTTP 1.1. The exact
-typedef is in the ``boost::network::http`` namespace as the following:
-
-.. code-block:: c++
-
-    namespace boost { namespace network { namespace http {
-
-        typedef basic_client<tags::http_async_8bit_udp_resolve, 1, 1>
-            client;
-
-    }}}
-
-
-This type has nested typedefs for the correct types for the ``basic_request``
-and ``basic_response`` templates. To use the correct types for ``basic_request``
-or ``basic_response`` you can use these nested typedefs like so:
-
-
-.. code-block:: c++
-
-    boost::network::http::client::request request;
-    boost::network::http::client::response response;
-
-    // or...
-    using namespace boost::network;
-    http::client::request request;
-    http::client::response response;
-
-
-Typical use cases for the HTTP client would look something like the following:
-
-
-.. code-block:: c++
-
-    using namespace boost::network;
-    http::request request("http://www.boost.org/");
-    request << header("Connection", "close");
-
-
-The ``basic_client`` implements all HTTP methods as member functions
-(HEAD, GET, POST, PUT, DELETE).  Therefore, the code to make an HTTP
-request looks trivially simple:
-
-
-.. code-block:: c++
-
-    using namespace boost::network;
-    http::client client;
-    http::client::request request("http://www.boost.org/");
-    http::client::response response = client.get(request);
-
-
-Accessing data from ``http::response`` is done using wrappers.
-To get the response headers, we use the ``headers`` wrapper which
-returns, in the default case, a multimap of strings to strings:
-
-
-.. code-block:: c++
-
-    using namespace boost::network;
-    typedef headers_range<http_client::response>::type response_headers;
-    boost::range_iterator<response_headers>::type iterator;
-
-    response_headers headers_ = headers(response);
-    for (iterator it = headers_.begin(); it != headers_.end(); ++it) {
-        std::cout << it->first << ": " << it->second << std::endl;
-    }
-    std::cout << std::endl;
-
-
-HTTP server
-```````````
-
-As with the HTTP client, the HTTP server that is provided with
-cpp-netlib is extensible through the tag mechanism and is embeddable.
-The template class declaration of ``basic_server`` is given below:
-
-
-.. code-block:: c++
-
-    namespace boost { namespace network { namespace http {
-
-        template <class Tag, class RequestHandler> basic_server;
-
-    }}}
-
-
-The second template argument is used to specify the request handler
-type. The request handler type is a functor type which should overload
-the function call operator (``RequestHandler::operator()`` should be
-overloaded) that takes two parameters: the first one being a reference
-to a ``const basic_request<Tag>`` and the second being a reference to
-a ``basic_response<Tag>`` instance.
-
-All the logic for parsing the HTTP request and building the ``const
-basic_request<Tag>`` object resides internally in the ``basic_server``
-template.  Processing the request is delegated to the
-``RequestHandler`` type, and the assumption of which would be that the
-response is formed inside the ``RequestHandler`` function call
-operator overload.
-
-The ``basic_server`` template however is only an underlying
-implementation while the user-visible implementation is the
-``http::server`` template. This simply specializes the
-``basic_server`` template to use the ``default_`` tag and forwards the
-``RequestHandler`` parameter:
-
-.. code-block:: c++
-
-    namespace boost { namespace network { namespace http {
-
-        template <class RequestHandler>
-        class server :
-            public basic_server<default_, RequestHandler> {};
-
-    }}}
-
-To use the forwarding server type you just supply the request handler
-implementation as the parameter. For example, an "echo" server example
-might look something like this:
-
-
-.. code-block:: c++
-
-    using namespace boost::network;
-    struct echo;
-    typedef http::server<echo> echo_server;
-
-    struct echo {
-        void operator () (const echo_server::request &request,
-                          echo_server::response &response) const {
-            std::string ip = source(request);
-            response = echo_server::response::stock_reply(
-                echo_server::response::ok,
-		body(request));
-            std::cerr << "[" << ip << "]: " << request.uri <<
-                " status = " << echo_server::response::ok << '\n';
-        }
-    };
-
-
-Here, all we're doing is returning the original request body with an
-HTTP OK response (200). We are also printing the IP address from where the
-request came from. Notice that we are using a wrapper to access the source of
-the request.
diff --git a/libs/network/doc/html/_sources/in_depth/http_client_tags.txt b/libs/network/doc/html/_sources/in_depth/http_client_tags.txt
deleted file mode 100644
index 5d79ed1ea..000000000
--- a/libs/network/doc/html/_sources/in_depth/http_client_tags.txt
+++ /dev/null
@@ -1,42 +0,0 @@
-+---------------------------------+---------------------------------------------+
-| Tag                             | Description                                 |
-+=================================+=============================================+
-| http_default_8bit_tcp_resolve   | This is the default HTTP implementation tag |
-|                                 | that resolves addresses with a TCP resolver |
-|                                 | and provides a synchronous/blocking HTTP    |
-|                                 | client interface.                           |
-+---------------------------------+---------------------------------------------+
-| http_default_8bit_udp_resolve   | This is similar to the above tag except that|
-|                                 | it specifies the HTTP client to use a UDP   |
-|                                 | resolver. It also provides a synchronous/   |
-|                                 | blocking HTTP client interface.             |
-+---------------------------------+---------------------------------------------+
-| http_keepalive_8bit_tcp_resolve | This tag specifies that the HTTP client by  |
-|                                 | default will keep connections to the server |
-|                                 | alive. It only makes sense if the           |
-|                                 | ``version_major`` and ``version_minor`` are |
-|                                 | both ``1``, to indicate HTTP 1.1. This tag  |
-|                                 | causes the HTTP client to resolve using a   |
-|                                 | TCP resolver and provides a synchronous/    |
-|                                 | blocking HTTP client interface.             |
-+---------------------------------+---------------------------------------------+
-| http_keepalive_8bit_udp_resolve | This is similar to the above tag except that|
-|                                 | it specifies the HTTP client to use a UDP   |
-|                                 | resolver. It also provides a synchronous/   |
-|                                 | blocking HTTP client interface.             |
-+---------------------------------+---------------------------------------------+
-| http_async_8bit_tcp_resolve     | This tag provides an active HTTP client     |
-|                                 | object implementation that uses a TCP       |
-|                                 | resolver. Response objects returned will    |
-|                                 | encapsulate a number of Boost.Thread_       |
-|                                 | shared futures to hold values. Users don't  |
-|                                 | have to see this as they are implementation |
-|                                 | details.                                    |
-+---------------------------------+---------------------------------------------+
-| http_async_8bit_udp_resolve     | This is similar to the above tag except that|
-|                                 | specifies the HTTP client to use a UDP      |
-|                                 | resolver.                                   |
-+---------------------------------+---------------------------------------------+
-
-.. _Boost.Thread: http://www.boost.org/libs/thread
-
diff --git a/libs/network/doc/html/_sources/in_depth/message.txt b/libs/network/doc/html/_sources/in_depth/message.txt
deleted file mode 100644
index 51512314b..000000000
--- a/libs/network/doc/html/_sources/in_depth/message.txt
+++ /dev/null
@@ -1,233 +0,0 @@
-The message template
-====================
-
-One of the core components in the library is the concept and the
-implementation of a common message type. In most (not all) network
-protocols, the concept of a message is central to the definition of
-the protocol. In HTTP, SMTP, XMPP, and even other protocols like SNMP
-and ICMP, there is a common notion of a "packet" or a message. In
-cpp-netlib we chose to implement the concept of a message that has the
-following common parts:
-
-  * **Source** - every message has a source identifier which varies
-    from protocol to protocol.
-
-  * **Destination** - every message has a destination identifier which
-    varies from protocol to protocol.
-
-  * **Headers** - each message is assumed to contain headers, which
-    may be empty in cases where the protocol does not support it, but
-    is nonetheless supported by cpp-netlib messages.
-
-  * **Body** - the content area of a message which varies from
-    protocol to protocol (also sometimes referred to as payload).
-
-This division is purely logical -- in the underlying implementation,
-the message type can choose to have different means of storing the
-data, depending on the type used to tag the message. This section
-covers the `Message Concept`_ as well as the `basic_message`_
-implementation.
-
-Message Concept
-```````````````
-
-.. warning:: The Message framework is deprecated in the 0.11 release, and will
-             be removed in future versions of the library.
-
-The Message Concept specifies what the valid operations on a message
-are as well as what messages look like semantically. The following
-table summarize the operations and syntactic as well as semantic
-properties of messages.
-
-**Legend**
-
-:M: The message type.
-:H: A headers container type.
-:m,n: An instance of **M**.
-:S: A string type.
-:s,k,v: An instance of **S**.
-:O: The source type.
-:D: The destination type.
-:B: The body type.
-:T: The Tag type.
-
-+----------------------------+----------------------+-----------------------------------------+
-| Construct                  | Result               | Description                             |
-+============================+======================+=========================================+
-| ``typename M::tag``        | T                    | The nested tag type.                    |
-+----------------------------+----------------------+-----------------------------------------+
-| ``M()``                    | Instance of M        | Default constructible.                  |
-+----------------------------+----------------------+-----------------------------------------+
-| ``M(m)``                   | Instance of M        | Copy constructible.                     |
-+----------------------------+----------------------+-----------------------------------------+
-| ``m = n;``                 | Reference to m       | Assignable.                             |
-+----------------------------+----------------------+-----------------------------------------+
-| ``swap(m, n);``            | ``void``             | Swappable.                              |
-+----------------------------+----------------------+-----------------------------------------+
-| ``source(m);``             | Convertible to O     | Retrieve the source of ``m``.           |
-+----------------------------+----------------------+-----------------------------------------+
-| ``destination(m);``        | Convertible to D     | Retrieve the destination of ``m``.      |
-+----------------------------+----------------------+-----------------------------------------+
-| ``headers(m);``            | Convertible to H     | Retrieve the headers of ``m``.          |
-+----------------------------+----------------------+-----------------------------------------+
-| ``body(m);``               | Convertible to B     | Retrieve the body of ``m``.             |
-+----------------------------+----------------------+-----------------------------------------+
-| ``m << source(s);``        | ``M &``              | Set the source of ``m``.                |
-+----------------------------+----------------------+-----------------------------------------+
-| ``m << destination(s);``   | ``M &``              | Set the destination of ``m``.           |
-+----------------------------+----------------------+-----------------------------------------+
-| ``m << header(k, v);``     | ``M &``              | Add a header to ``m``.                  |
-+----------------------------+----------------------+-----------------------------------------+
-| ``m << remove_header(k);`` | ``M &``              | Remove a header from ``m``.             |
-+----------------------------+----------------------+-----------------------------------------+
-| ``m << body(s);``          | ``M &``              | Set the body of ``m``.                  |
-+----------------------------+----------------------+-----------------------------------------+
-| ``source(m,s);``           | ``void``             | Set the source of ``m``.                |
-+----------------------------+----------------------+-----------------------------------------+
-| ``destination(m,s);``      | ``void``             | Set the destination of ``m``.           |
-+----------------------------+----------------------+-----------------------------------------+
-| ``add_header(m, k, v);``   | ``void``             | Add a header to ``m``.                  |
-+----------------------------+----------------------+-----------------------------------------+
-| ``remove_header(m, k);``   | ``void``             | Remove a header from ``m``.             |
-+----------------------------+----------------------+-----------------------------------------+
-| ``clear_headers(m);``      | ``void``             | Clear the headers of ``m``.             |
-+----------------------------+----------------------+-----------------------------------------+
-| ``body(m,s);``             | ``M &``              | Set the body of ``m``.                  |
-+----------------------------+----------------------+-----------------------------------------+
-
-Types that model the Message Concept are meant to encapsulate data
-that has a source, a destination, one or more named headers, and a
-body/payload. Because the accessors and the directives are not
-required to be part of the message type that models the Message
-Concept, a message can be implemented as a POD type and have all
-manipulations performed in the directive implementations, as well as
-value transformations done in the accessors.
-
-Directives, Modifiers, and Wrappers
-```````````````````````````````````
-
-In the Message Concept definition there are three basic constructs that follow a
-certain pattern. These patterns are Directives_, Modifiers_, and Wrappers_.
-
-Directives
-~~~~~~~~~~
-
-A directive is a function object that is applied to a Message. Directives
-encapsulate a set of operations that apply to messages. The general requirement
-for a Directive is that it should apply these operations on a message.
-
-A directive may dispatch on the type of the message passed to it at the point of
-the function call. Typically, directives are generated using a factory function
-that returns the correct directive type.
-
-For a given directive ``foo_directive`` a generator function called ``foo`` is
-typically implemented:
-
-.. code-block:: c++
-
-    struct foo_directive {
-        template <class Message>
-        Message & operator()(Message & m) const {
-            // do something to m
-            return m;
-        }
-    };
-
-    foo_directive const foo() {
-        return foo_directive();
-    }
-
-    // to apply a directive, we use the << operator
-    message m;
-    m << foo();
-
-Modifiers
-~~~~~~~~~
-
-A modifier is generally defined as a free function that takes a reference to a
-non-const lvalue message as the first parameter, and any number of parameters.
-In the concept definition of the Message Concept, a modifier follows the form:
-
-.. code-block:: c++
-
-    modifier(message, ...)
-
-Modifiers are meant to imply modifications on a message, which also allows for
-easier dispatch based on Argument Dependent Lookup (ADL_) on the type of the
-message. Note that Directives_ can be implemented in terms of Modifiers and
-vice versa, although that is not required nor specified.
-
-.. _ADL: http://en.wikipedia.org/wiki/Argument-dependent_name_lookup
-
-Wrappers
-~~~~~~~~
-
-A Wrapper is basically an implementation detail that ensures that a given
-message, when wrapped, can be converted to the associated part of the message. A
-wrapper has a type that encapsulates the conversion logic from a message to a
-given type.
-
-An example of a Wrapper would be ``source_wrapper`` which would be returned by a
-call to the wrapper generator function ``source``. An example implementation of
-the ``source_wrapper`` would look like:
-
-.. code-block:: c++
-
-    template <class Tag, template <class> class Message>
-    struct source_wrapper {
-        Message<Tag> const & m;
-        explicit source_wrapper(Message<Tag> const & m)
-        : m(m) {}
-        typedef typename source<Tag>::type source_type;
-        operator source_type const & () {
-            return m.source;
-        }
-        operator source_type const () {
-            return m.source;
-        }
-        operator source_type () {
-            return m.source;
-        }
-    };
-
-    template <class Tag, template <class> class Message>
-    source_wrapper<Tag, Message> const
-    source(Message<Tag> const & message) {
-        return source_wrapper<Tag, Message>(message);
-    }
-
-This pattern is similar to an adapter, but the specific notion of wrapping a
-data type (in this case, an object of a type that models the Message Concept)
-using an intermediary wrapper is what is pertained to by the Wrapper pattern.
-In this case, the Wrapper is ``source_wrapper`` while ``source`` is merely a
-wrapper generator function.
-
-``basic_message``
-`````````````````
-
-The default implementation of a simple type that models the Message
-Concept is available in cpp-netlib. This default implementation is
-named ``basic_message`` which supports a ``Tag`` template
-parameter. The definition of ``basic_message`` looks like this:
-
-.. code-block:: c++
-
-    template <class Tag>
-    class basic_message;
-
-The ``basic_message`` template requires that the following
-tag-dispatched metafunctions are defined for the type ``Tag``:
-
-.. code-block:: c++
-
-    template <class Tag>
-    struct string;
-
-    template <class Tag>
-    struct headers_container;
-
-All the operations defined by the message concept are implemented by
-this basic message type. Other message implementations can either use
-this common message type or specialize it according to whether they
-want to use different containers or whether it's going to be just a
-POD type.
diff --git a/libs/network/doc/html/_sources/in_depth/uri.txt b/libs/network/doc/html/_sources/in_depth/uri.txt
deleted file mode 100644
index 84eca62e2..000000000
--- a/libs/network/doc/html/_sources/in_depth/uri.txt
+++ /dev/null
@@ -1,151 +0,0 @@
-The URI class
-=============
-
-In addition to protocol implementations, the :mod:`cpp-netlib`
-provides a powerful URI class.  The class implements a parser based
-on `RFC 3986`_ and `RFC 2732`_.
-
-Generic URI syntax overview
-```````````````````````````
-
-A generic URI will take the form::
-
-  [scheme:]scheme-specific-part[#fragment]
-
-A URI is known as `absolute` if it specifies the scheme.  Otherwise,
-it is known as a relative URI.  Currently, ``uri`` supports only
-absolute URIs.
-
-URIs can be further classified according to whether they're
-hierarchical or opaque (non-hierarchical).
-
-Some examples of non-hierarchical URIs include::
-
-   mailto:john.doe@example.com
-   news:comp.infosystems.www.servers.unix
-   tel:+1-816-555-1212
-
-The data following the first ``":"`` is said to be opaque to the URI
-parser and requires no further parsing.  By way of example, the
-following shows how a non-hierarchical URI is processed by the parser
-by defining everything after the ``":"`` to be a part of the path:
-
-.. image:: ../_static/mailto_uri.png
-
-A hierarchical URI is identified by a double slash (``"//"``) after
-the scheme and a scheme-specific component, which `RFC 3986`_ defines
-to be::
-
-  [scheme:][//authority][path][?query][#fragment]
-
-The authority component can be further broken down to::
-
-  [user_info@]host[:port]
-
-Examples of hierarchical URIs include::
-
-   http://www.boost.org/
-   file:///bin/bash
-
-The following example, describing a complex URI using FTP, shows how
-a URI is broken down by the parser:
-
-.. image:: ../_static/ftp_uri.png
-
-Note that the ``authority`` is further subdivided into different
-elements.  Another example, using HTTP is given below:
-
-.. image:: ../_static/http_uri.png
-
-The difference here between the path in a hierarchical URI and that in
-the example above for the non-hierarchical URI.
-
-The ``uri`` class
-`````````````````
-
-As of version 0.9.3, ``uri`` supplies a URI parser and builder.
-To use the parser, it's as simple as supplying a string to the
-constructor:
-
-.. code-block:: c++
-
-   using namespace boost::network;
-   uri::uri instance("http://cpp-netlib.github.com/");
-   assert(instance.is_valid());
-   std::cout << "scheme: " << instance.scheme() << std::endl
-             << "host: " << instance.host() << std::endl;
-
-The command-line output of this program will be::
-
-   scheme: http
-   host: cpp-netlib.github.com
-
-The ``uri`` builder
-```````````````````
-
-``uri`` support a stream style syntax to create a URI from it's
-elements.  For example the program:
-
-.. code-block:: c++
-
-   #include <iostream>
-   #include <boost/network/uri.hpp>
-   #include <boost/network/uri/uri_io.hpp>
-   using namespace boost::network;
-
-   int main() {
-       uri::uri url;
-       url << uri::scheme("http")
-           << uri::host("www.github.com")
-           << uri::path("/cpp-netlib");
-       std::cout << url << std::endl;
-       return 0;
-   }
-
-will output::
-
-   http://www.github.com/cpp-netlib
-
-``URI Concept``
-```````````````
-
-**Legend**
-
-:U: The URI type.
-:u,u_: An instance of **M**.
-:S: A string type.
-:s,v: An instance of **S**.
-:T: The Tag type.
-
-+----------------------------+----------------------+-----------------------------------------+
-| Construct                  | Result               | Description                             |
-+============================+======================+=========================================+
-| ``U(u)``                   | Instance of U        | Copy constructible.                     |
-+----------------------------+----------------------+-----------------------------------------+
-| ``U(s)``                   | Instance of U        | Constructible from string.              |
-+----------------------------+----------------------+-----------------------------------------+
-| ``u = u_;``                | Reference to u       | Assignable.                             |
-+----------------------------+----------------------+-----------------------------------------+
-| ``u = s;``                 | Reference to u       | Assignable from string.                 |
-+----------------------------+----------------------+-----------------------------------------+
-| ``swap(u, u_);``           | ``void``             | Swappable.                              |
-+----------------------------+----------------------+-----------------------------------------+
-| ``scheme(u);``             | Convertible to S     | Retrieve the URI scheme of ``u``.       |
-+----------------------------+----------------------+-----------------------------------------+
-| ``user_info(u);``          | Convertible to S     | Retrieve the user info of ``u``.        |
-+----------------------------+----------------------+-----------------------------------------+
-| ``host(u);``               | Convertible to S     | Retrieve the host of ``u``.             |
-+----------------------------+----------------------+-----------------------------------------+
-| ``port(u);``               | Convertible to H     | Retrieve the port of ``u``.             |
-+----------------------------+----------------------+-----------------------------------------+
-| ``path(u);``               | Convertible to S     | Retrieve the path of ``u``.             |
-+----------------------------+----------------------+-----------------------------------------+
-| ``query(u);``              | Convertible to S     | Retrieve the query string of ``u``.     |
-+----------------------------+----------------------+-----------------------------------------+
-| ``fragment(u);``           | Convertible to S     | Retrieve the fragment of ``u``.         |
-+----------------------------+----------------------+-----------------------------------------+
-
-.. _`RFC 3986`: http://tools.ietf.org/html/rfc3986
-.. _`RFC 2368`: http://tools.ietf.org/html/rfc2368
-.. _`RFC 3513`: http://tools.ietf.org/html/rfc3513
-.. _`RFC 2732`: http://tools.ietf.org/html/rfc2732
diff --git a/libs/network/doc/html/_sources/index.txt b/libs/network/doc/html/_sources/index.txt
index fc9e65405..3329b8a30 100644
--- a/libs/network/doc/html/_sources/index.txt
+++ b/libs/network/doc/html/_sources/index.txt
@@ -108,7 +108,6 @@ Want to learn more?
     * :ref:`Take a look at the getting started guide <getting_started>`
     * :ref:`Learn from some simple examples <examples>`
     * :ref:`Find out what's new <whats_new>`
-    * :ref:`Study the library in more depth <in_depth>`
     * :ref:`Discover more through the full reference <reference>`
     * :ref:`Full table of contents <contents>`
 
diff --git a/libs/network/doc/html/_sources/reference/http_server.txt b/libs/network/doc/html/_sources/reference/http_server.txt
index 26ceb9b65..c0022bdda 100644
--- a/libs/network/doc/html/_sources/reference/http_server.txt
+++ b/libs/network/doc/html/_sources/reference/http_server.txt
@@ -5,9 +5,9 @@ HTTP Server API
 General
 -------
 
-:mod:`cpp-netlib` includes and implements two distinct HTTP server
-implementations that you can use and embed in your own applications. Both HTTP
-Server implementations:
+:mod:`cpp-netlib` includes and implements and asynchronous HTTP server
+implementation that you can use and embed in your own applications. The HTTP
+Server implementation:
 
   * **Cannot be copied.** This means you may have to store instances of the HTTP
     Server in dynamic memory if you intend to use them as function parameters or
@@ -15,60 +15,19 @@ Server implementations:
   * **Assume that requests made are independent of each other.** None of the
     HTTP Server implementations support request pipelining (yet) so a single
     connection only deals with a single request.
-  * **Are header-only and are compiled-into your application.** Future releases
-    in case you want to upgrade the implementation you are using in your
-    application will be distributed as header-only implementations, which means
-    you have to re-compile your application to use a newer version of the
-    implementations.
-
-The HTTP Servers have different semantics, and in some cases require different
-APIs from the supplied template parameters.
-
-Implementations
----------------
-
-There are two different user-facing template classes that differentiate the
-`Synchronous Servers`_ from the `Asynchronous Servers`_. Both templates take a
-single template parameter named ``Handler`` which describes the type of the
-Handler function object.
-
-There are two different Handler concepts, one concept for `Synchronous Servers`_
-and another for `Asynchronous Servers`.
-
-The SynchronousHandler concept for `Synchronous Servers`_ is described by the
-following table:
-
----------------
-
-**Legend:**
-
-H
-    The Handler type.
-h
-    An instance of H.
-Req
-    A type that models the Request Concept.
-Res
-    A type that models the Response Concept.
-req
-    An instance of Req.
-res
-    An instance of Res.
-
-+----------------+-------------+----------------------------------------------+
-| Construct      | Return Type | Description                                  |
-+================+=============+==============================================+
-| ``h(req,res)`` | ``void``    | Handle the request; res is passed in as a    |
-|                |             | non-const lvalue, which represents the       |
-|                |             | response to be returned to the client        |
-|                |             | performing the request.                      |
-+----------------+-------------+----------------------------------------------+
-
-More information about the internals of the `Synchronous Servers`_ can be found
-in the following section.
-
-The AsynchronousHandler concept for `Asynchronous Servers`_ is described by the
-following table:
+  * **The Handler instance is invoked asynchronously**. This means the I/O
+    thread used to handle network-related events are free to handle only the
+    I/O related events. This enables the server to scale better as to the
+    number of concurrent connections it can handle.
+  * **The Handler is able to schedule asynchronous actions on the thread pool
+    associated with the server.** This allows handlers to perform multiple
+    asynchronous computations that later on perform writes to the connection.
+  * **The Handler is able to control the (asynchronous) writes to and reads
+    from the HTTP connection.** Because the connection is available to the
+    Handler, that means it can write out chunks of data at a time or stream
+    data through the connection continuously.
+
+The Handler concept for the HTTP Server is described by the following table:
 
 ---------------
 
@@ -95,270 +54,30 @@ conn
 |                  |             | writing to and reading from the connection.|
 +------------------+-------------+--------------------------------------------+
 
-More information about the internals of the `Asynchronous Servers`_ can be found
-in the following section.
-
-Synchronous Servers
--------------------
-
-The synchronous server implementation is represented by the template ``server``
-in namespace ``boost::network::http``. The ``server`` template takes in a single
-template parameter named ``Handler`` which models the SynchronousHandler
-concept (described above).
-
-An instance of Handler is taken in by reference to the constructor of the HTTP
-server. This means the Handler is not copied around and only a single instance
-of the handler is used for all connections and requests performed against the
-HTTP server.
-
-.. warning:: It is important to note that the HTTP server does not implement any
-   locking upon invoking the Handler. In case you have any state in the Handler
-   that will be associated with the synchronous server, you would have to
-   implement your own synchronization internal to the Handler implementation.
-   This matters especially if you run the synchronous server in multiple
-   threads.
-
-The general pattern of usage for the HTTP Server template is shown below:
-
-.. code-block:: c++
-
-    struct handler;
-    typedef boost::network::http::server<handler> http_server;
-
-    struct handler {
-        void operator()(
-            http_server::request const & req,
-            http_server::response & res
-        ) {
-            // do something, and then edit the res object here.
-        }
-    };
-
-More information about the actual HTTP Server API follows in the next section.
-It is important to understand that the HTTP Server is actually embedded in your
-application, which means you can expose almost all your application logic
-through the Handler type, which you can also initialize appropriately.
-
-API Documentation
-~~~~~~~~~~~~~~~~~
-
-The following sections assume that the following file has been included:
-
-.. code-block:: c++
-
-    #include <boost/network/include/http/server.hpp>
-
-And that the following typedef's have been put in place:
-
-.. code-block:: c++
-
-    struct handler_type;
-    typedef boost::network::http::server<handler_type> http_server;
-
-    struct handler_type {
-        void operator()(http_server::request const & request,
-                        http_server::response & response) {
-            // do something here
-        }
-    };
-
-Constructor
-```````````
-
-``explicit http_server(options)``
-    Construct an HTTP Server instance, passing in a ``server_options<Tag,
-    Handler>`` object. The following table shows the supported options in
-    ``server_options<Tag, Handler>``.
-
-+-----------------------+------------------------------------------+--------------------------------------------------------------------------------------------------+
-| Parameter Name        | Type                                     | Description                                                                                      |
-+=======================+==========================================+==================================================================================================+
-| address               | string_type                              | The hostname or IP address from which the server should be bound to. This parameter is required. |
-+-----------------------+------------------------------------------+--------------------------------------------------------------------------------------------------+
-| port                  | string_type                              | The port to which the server should bind and listen to. This parameter is required.              |
-+-----------------------+------------------------------------------+--------------------------------------------------------------------------------------------------+
-| thread_pool           | ``shared_ptr<thread_pool>``              | A shared pointer to an instance of ``boost::network::utils::thread_pool`` -- this is the         |
-|                       |                                          | thread pool from where the handler is invoked. This parameter is only applicable and required    |
-|                       |                                          | for ``async_server`` instances.                                                                  |
-+-----------------------+------------------------------------------+--------------------------------------------------------------------------------------------------+
-| io_service            | ``shared_ptr<io_service>``               | An optional lvalue to an instance of ``boost::asio::io_service`` which allows the server to use  |
-|                       |                                          | an already-constructed ``boost::asio::io_service`` instance instead of instantiating one that it |
-|                       |                                          | manages.                                                                                         |
-+-----------------------+------------------------------------------+--------------------------------------------------------------------------------------------------+
-| reuse_address         | ``bool``                                 | A boolean that specifies whether to re-use the address and port on which the server will be      |
-|                       |                                          | bound to. This enables or disables the socket option for listener sockets. The default is        |
-|                       |                                          | ``false``.                                                                                       |
-+-----------------------+------------------------------------------+--------------------------------------------------------------------------------------------------+
-| report_aborted        | ``bool``                                 | A boolean that specifies whether the listening socket should report aborted connection attempts  |
-|                       |                                          | to the accept handler (an internal detail of cpp-netlib). This is put in place to allow for      |
-|                       |                                          | future-proofing the code in case an optional error handler function is supported in later        |
-|                       |                                          | releases of cpp-netlib. The default is ``false``.                                                |
-+-----------------------+------------------------------------------+--------------------------------------------------------------------------------------------------+
-| receive_buffer_size   | ``int``                                  | The size of the socket's receive buffer. The default is defined by Boost.Asio and is             |
-|                       |                                          | platform-dependent.                                                                              |
-+-----------------------+------------------------------------------+--------------------------------------------------------------------------------------------------+
-| send_buffer_size      | ``int``                                  | The size of the socket's send buffer. The default is defined by Boost.Asio and is                |
-|                       |                                          | platform-dependent.                                                                              |
-+-----------------------+------------------------------------------+--------------------------------------------------------------------------------------------------+
-| receive_low_watermark | ``int``                                  | The size of the socket's low watermark for its receive buffer. The default is defined by         |
-|                       |                                          | Boost.Asio and is platform-dependent.                                                            |
-+-----------------------+------------------------------------------+--------------------------------------------------------------------------------------------------+
-| send_buffer_size      | ``int``                                  | The size of the socket's send low watermark for its send buffer. The default is defined by       |
-|                       |                                          | Boost.Asio and is platform-dependent.                                                            |
-+-----------------------+------------------------------------------+--------------------------------------------------------------------------------------------------+
-| non_blocking_io       | ``bool``                                 | An optional bool to define whether the socket should use non-blocking I/O in case the platform   |
-|                       |                                          | supports it. The default is ``true``.                                                            |
-+-----------------------+------------------------------------------+--------------------------------------------------------------------------------------------------+
-| linger                | ``bool``                                 | An optional bool to determine whether the socket should linger in case there's still data to be  |
-|                       |                                          | sent out at the time of its closing. The default is ``true``.                                    |
-+-----------------------+------------------------------------------+--------------------------------------------------------------------------------------------------+
-| linger_timeout        | ``int``                                  | An optional int to define the timeout to wait for socket closes before it is set to linger.      |
-|                       |                                          | The default is ``0``.                                                                            |
-+-----------------------+------------------------------------------+--------------------------------------------------------------------------------------------------+
-| context               | ``shared_ptr<context>``                  | An optional shared pointer to an instance of ``boost::asio::ssl::context`` -- this contains the  |
-|                       |                                          | settings needed to support SSL. This parameter is only applicable for ``async_server`` instances.|
-+-----------------------+------------------------------------------+--------------------------------------------------------------------------------------------------+
-
-To use the above supported named parameters, you'll have code that looks like the following:
-
-.. code-block:: c++
-
-    using namespace boost::network::http; // parameters are in this namespace
-    handler handler_instance;
-    sync_server<handler>::options options(handler_instance);
-    options.address("0.0.0.0")
-           .port("80")
-           .io_service(boost::make_shared<boost::asio::io_service>())
-           .reuse_address(true);
-    sync_server<handler> instance(options);
-    instance.run();
-
-Public Members
-``````````````
-
-The following definitions assume that a properly constructed ``http_server``
-instance has been constructed in the following manner:
-
-.. code-block:: c++
-
-    handler_type handler;
-    http_server::options options(handler);
-    http_server server(options.address("127.0.0.1").port("8000"));
-
-``server.run()``
-    Run the HTTP Server event loop. This function can be run on multiple threads
-    following the example:
-
-.. code-block:: c++
-
-    boost::thread t1(boost::bind(&http_server::run, &server));
-    boost::thread t2(boost::bind(&http_server::run, &server));
-    server.run();
-    t1.join();
-    t2.join();
-
-``server.stop()``
-    Stop the HTTP Server acceptor and wait for all pending requests to finish.
-
-Response Object
-```````````````
-
-The response object has its own public member functions which can be very
-helpful in certain simple situations.
-
-``response = http_server::response::stock_reply(status, body)``
-    Code like the above should go inside the handler's ``operator()`` overload.
-    The body parameter is an ``std::string``. The status parameter is any of
-    the following values from the ``http_server::response`` enum
-    ``status_type``:
-
-.. code-block:: c++
-
-    enum status_type {
-        ok = 200,
-        created = 201,
-        accepted = 202,
-        no_content = 204,
-        multiple_choices = 300,
-        moved_permanently = 301,
-        moved_temporarily = 302,
-        not_modified = 304,
-        bad_request = 400,
-        unauthorized = 401,
-        forbidden = 403,
-        not_found = 404,
-        not_supported = 405,
-        not_acceptable = 406,
-        internal_server_error = 500,
-        not_implemented = 501,
-        bad_gateway = 502,
-        service_unavailable = 503
-    };
+---------------
 
-The response object also has the following publicly accessible member values
-which can be directly manipulated by the handler.
-
-+------------------+----------------------+------------------------------------+
-| Member Name      | Type                 | Description                        |
-+==================+======================+====================================+
-| status           | ``status_type``      | The HTTP status of the response.   |
-+------------------+----------------------+------------------------------------+
-| headers          | ``vector<header>``   | Vector of headers. [#]_            |
-+------------------+----------------------+------------------------------------+
-| content          | ``string_type`` [#]_ | The contents of the response.      |
-+------------------+----------------------+------------------------------------+
-
-.. [#] A header is a struct of type
-   ``response_header<http::tags::http_server>``. An instance always has the
-   members ``name`` and ``value`` both of which are of type ``string_type``.
-.. [#] ``string_type`` is
-   ``boost::network::string<http::tags::http_server>::type``.
-
-Asynchronous Servers
---------------------
-
-The asynchronous server implementation is significantly different to the
-synchronous server implementation in three ways:
-
-  #. **The Handler instance is invoked asynchronously**. This means the I/O
-     thread used to handle network-related events are free to handle only the
-     I/O related events. This enables the server to scale better as to the
-     number of concurrent connections it can handle.
-  #. **The Handler is able to schedule asynchronous actions on the thread pool
-     associated with the server.** This allows handlers to perform multiple
-     asynchronous computations that later on perform writes to the connection.
-  #. **The Handler is able to control the (asynchronous) writes to and reads from
-     the HTTP connection.** Because the connection is available to the Handler,
-     that means it can write out chunks of data at a time or stream data through
-     the connection continuously.
-
-The asynchronous server is meant to allow for better scalability in terms of the
-number of concurrent connections and for performing asynchronous actions within
-the handlers. If your application does not need to write out information
-asynchronously or perform potentially long computations, then the synchronous
-server gives a generally better performance profile than the asynchronous
-server.
-
-The asynchronous server implementation is available from a single user-facing
-template named ``async_server``. This template takes in a single template
+The HTTP Server is meant to allow for better scalability in terms of the number
+of concurrent connections and for performing asynchronous actions within the
+handlers.  The HTTP Server implementation is available from a single
+user-facing template named ``server``. This template takes in a single template
 parameter which is the type of the Handler to be called once a request has been
 parsed from a connection.
 
-An instance of Handler is taken as a reference to the constructor similar to the
-synchronous server implementation.
+An instance of Handler is taken as a reference to the constructor of the server
+instance.
 
-.. warning:: The asynchronous server implementation, like the synchronous server
-   implementation, does not perform any synchronization on the calls to the
-   Handler invocation. This means if your handler contains or maintains internal
-   state, you are responsible for implementing your own synchronization on
-   accesses to the internal state of the Handler.
+.. warning:: The HTTP Server implementation does not perform any
+   synchronization on the calls to the Handler invocation. This means if your
+   handler contains or maintains internal state, you are responsible for
+   implementing your own synchronization on accesses to the internal state of
+   the Handler.
 
-The general pattern for using the ``async_server`` template is shown below:
+The general pattern for using the ``server`` template is shown below:
 
 .. code-block:: c++
 
     struct handler;
-    typedef boost::network::http::async_server<handler> http_server;
+    typedef boost::network::http::server<handler> http_server;
 
     struct handler {
         void operator()(
@@ -371,7 +90,7 @@ The general pattern for using the ``async_server`` template is shown below:
     };
 
 API Documentation
-~~~~~~~~~~~~~~~~~
+-----------------
 
 The following sections assume that the following file has been included:
 
@@ -395,135 +114,36 @@ And that the following typedef's have been put in place:
     };
 
 Constructor
-```````````
+~~~~~~~~~~~
 
 ``explicit http_server(options)``
     Construct an HTTP server instance passing in a ``server_options<Tag,
     Handler>`` instance.
 
-Public Members
-``````````````
-
-The following definitions assume that a properly constructed ``http_server``
-instance has been constructed in the following manner:
+Server Options
+~~~~~~~~~~~~~~
 
-.. code-block:: c++
-
-    handler_type handler;
-    http_server::options options(handler);
-    options.thread_pool(boost::make_shared<boost::network::utils::thread_pool>(2));
-    http_server server(options.address("127.0.0.1").port("8000"));
-
-``server.run()``
-    Run the HTTP Server event loop. This function can be run on multiple threads
-    following the example:
-
-.. code-block:: c++
+.. doxygenstruct:: boost::network::http::server_options
+   :project: cppnetlib
+   :members:
 
-    boost::thread t1(boost::bind(&http_server::run, &server));
-    boost::thread t2(boost::bind(&http_server::run, &server));
-    server.run();
-    t1.join();
-    t2.join();
+Public Members
+~~~~~~~~~~~~~~
 
-``server.stop()``
-    Stop the HTTP Server acceptor and wait for all pending requests to finish.
+.. doxygenstruct:: boost::network::http::server
+   :project: cppnetlib
+   :members:
+   :undoc-members:
 
 Connection Object
-`````````````````
-
-The connection object has its own public member functions which will be the
-primary means for reading from and writing to the connection.
-
-``template <class Range> write(Range range)``
-    The connection object exposes a function ``write`` that can be given a
-    parameter that adheres to the Boost.Range_ ``Single Pass Range`` Concept.
-    The write function, although it looks synchronous, starts of a series of
-    asynchronous writes to the connection as soon as the range is serialized to
-    appropriately sized buffers.
-
-    To use this in your handler, it would look something like this:
-
-.. code-block:: c++
-
-    connection->write("Hello, world!");
-    std::string sample = "I have a string!";
-    connection->write(sample);
-
-``template <class Range, class Callback> void write(Range range, Callback callback)``
-    The connection object also exposes a function ``write`` that can be given a
-    parameter that adheres to the Boost.Range_ ``Single Pass Range`` Concept, as
-    well as a Callback function that returns ``void`` and takes a
-    ``boost::system::error_code`` as a parameter. This overload of ``write`` is
-    useful for writing streaming applications that send out chunks of data at a
-    time, or for writing data that may not all fit in memory right away.
-
-``template <class ReadCallback> void read(ReadCallback callback)``
-    The connection object has a function ``read`` which can be used to read more
-    information from the connection. This ``read`` function takes in a callback
-    that can be assigned to a Boost.Function_ with the signature
-    ``void(input_range,error_code,size_t,connection_ptr)``. The following list
-    shows what the types actually mean:
-
-      * **input_range** -- ``boost::iterator_range<char const *>`` : The range
-        that denotes the data read from the connection.
-      * **error_code** -- ``boost::system::error_code`` : The error code if
-        there were any errors encountered from the read.
-      * **size_t** -- ``std::size_t`` : The number of bytes transferred.
-      * **connection_ptr** -- ``http_server::connection_ptr`` : A handle to the
-        current connection, so that it is kept alive at the time of the read
-        callback invocation.
-
-    This interface is useful when doing reads of uploaded data that can be
-    potentially large and may not fit in memory. The read handler is then
-    responsible for dealing with the chunks of data available from the
-    connection.
-
-``void set_status(status_t new_status)``
-    The ``set_status`` function takes a parameter of type ``status_t`` which is
-    an enum type nested in ``http_status::connection`` which is given in the
-    following code listing.
-
-.. code-block:: c++
-
-    enum status_t {
-        ok = 200
-        , created = 201
-        , accepted = 202
-        , no_content = 204
-        , multiple_choices = 300
-        , moved_permanently = 301
-        , moved_temporarily = 302
-        , not_modified = 304
-        , bad_request = 400
-        , unauthorized = 401
-        , forbidden = 403
-        , not_found = 404
-        , not_supported = 405
-        , not_acceptable = 406
-        , internal_server_error = 500
-        , not_implemented = 501
-        , bad_gateway = 502
-        , service_unavailable = 503
-    };
-
-.. note:: You may set and re-set the status several times as long as you have
-   not set the headers or sent data through the connection. If you do this after
-   data has already been set, the function will throw an instance of
-   ``std::logic_error``.
-
-``template <class Range> void set_headers(Range range)``
-    The ``set_headers`` function takes a Single Pass Range of
-    ``boost::network::http::response_header<http::tags::http_async_server>``
-    instances and linearizes them to a buffer with at most
-    ``BOOST_NETWORK_HTTP_SERVER_CONNECTION_HEADER_BUFFER_MAX_SIZE`` and
-    immediately schedules an asynchronous write once that is done.
+~~~~~~~~~~~~~~~~~
 
-    The function throws an instance of ``std::logic_error`` if you try to set
-    the headers for a connection more than once.
+.. doxygenstruct:: boost::network::http::async_connection
+   :project: cppnetlib
+   :members:
 
-Adding SSL support to Asynchronous Server
------------------------------------------
+Adding SSL support to the HTTP Server
+-------------------------------------
 
 In order to setup SSL support for an Asynchronous Server, it is best to start from
 a regular Asynchronous Server (see above). Once this server is setup, SSL can be
@@ -533,24 +153,25 @@ used are defined in the link.
 .. code-block:: c++
 
     // Initialize SSL context
-    boost::shared_ptr<boost::asio::ssl::context> ctx = boost::make_shared<boost::asio::ssl::context>(boost::asio::ssl::context::sslv23);
+    std::shared_ptr<asio::ssl::context> ctx =
+        std::make_shared<asio::ssl::context>(asio::ssl::context::sslv23);
     ctx->set_options(
-                boost::asio::ssl::context::default_workarounds
-                | boost::asio::ssl::context::no_sslv2
-                | boost::asio::ssl::context::single_dh_use);
+                asio::ssl::context::default_workarounds
+                | asio::ssl::context::no_sslv3
+                | asio::ssl::context::single_dh_use);
     
     // Set keys
     ctx->set_password_callback(password_callback);
     ctx->use_certificate_chain_file("server.pem");
-    ctx->use_private_key_file("server.pem", boost::asio::ssl::context::pem);
+    ctx->use_private_key_file("server.pem", asio::ssl::context::pem);
     ctx->use_tmp_dh_file("dh512.pem");
     
     handler_type handler;
     http_server::options options(handler);
-    options.thread_pool(boost::make_shared<boost::network::utils::thread_pool>(2));
+    options.thread_pool(std::make_shared<boost::network::utils::thread_pool>(2));
     http_server server(options.address("127.0.0.1").port("8442").context(ctx));
 
-    std::string password_callback(std::size_t max_length, boost::asio::ssl::context_base::password_purpose purpose) {
+    std::string password_callback(std::size_t max_length, asio::ssl::context_base::password_purpose purpose) {
         return std::string("test");
     }
     
diff --git a/libs/network/doc/html/_sources/techniques.txt b/libs/network/doc/html/_sources/techniques.txt
deleted file mode 100644
index b52bf7e36..000000000
--- a/libs/network/doc/html/_sources/techniques.txt
+++ /dev/null
@@ -1,12 +0,0 @@
-Techniques
-==========
-
-The :mod:`cpp-netlib` uses several advanced techniques to achieve it's
-aims.  This chapter describes some of those techniques.
-
-.. toctree::
-   :maxdepth: 1
-
-   techniques/tag_metafunctions
-   techniques/directives
-   techniques/polymorphism
diff --git a/libs/network/doc/html/_sources/techniques/directives.txt b/libs/network/doc/html/_sources/techniques/directives.txt
deleted file mode 100644
index e40882d95..000000000
--- a/libs/network/doc/html/_sources/techniques/directives.txt
+++ /dev/null
@@ -1,92 +0,0 @@
-Directives
-==========
-
-The :mod:`cpp-netlib` uses a technique for allowing message-passing
-semantics in a chainable fashion in the form of directives. The basic
-concept for directives is, in a general sense, an encapsulated
-transformation that can be applied to objects that abide by the
-directive protocol.
-
-Using the object-oriented notion of message passing, where an object
-accepts a message (usually a function call) we define a simple DSEL in
-order for the protocol to be supported by certain object types. In the
-:mod:`cpp-netlib` the protocol implemented is similar to that of the
-standard iostream formatting system:
-
-.. code-block:: c++
-
-    object << directive1(...)
-           << directive2(...)
-           ...
-           << directiveN(...);
-
-In :mod:`cpp-netlib` the directives are simple function objects that
-take a target object as reference and returns a reference to the same
-object as a result. In code the directive pattern looks like the
-following:
-
-.. code-block:: c++
-
-    struct directive_type {
-        template <class Input>
-        Input & operator()(Input & input) const {
-            // do something to input
-            return input;
-        }
-    };
-
-To simplify directive creation, usually factory or generator functions
-are defined to return concrete objects of the directive's type.
-
-.. code-block:: c++
-
-    inline
-    directive_type directive(...) {
-        return directive_type();
-    }
-
-The trivial implementation of the directive protocol then boils down
-to the specialization of the shift-left operator on the target type.
-
-.. code-block:: c++
-
-    template <class Directive>
-    inline target_type & operator<< 
-    (target_type & x, Directive const & f) {
-        return f(x);
-    }
-
-.. todo::
-
-    An example using a directive.
-
-The rationale for implementing directives include the following:
-
-  * **Encapsulation** - by moving logic into the directive types the
-    target object's interface can remain rudimentary and even hidden
-    to the user's immediate attention. Adding this layer of
-    indirection also allows for changing the underlying
-    implementations while maintaining the same syntactic and semantic
-    properties.
-  * **Flexibility** - by allowing the creation of directives that are
-    independent from the target object's type, generic operations can
-    be applied based on the concept being modeled by the target
-    type. The flexibility also afforded comes in the directive's
-    generator function, which can also generate different concrete
-    directive specializations based on parameters to the function.
-  * **Extensibility** - because the directives are independent of the
-    target object's type, new directives can be added and supported
-    without having to change the target object at all.
-  * **Reuse** - truly generic directives can then be used for a broad
-    set of target object types that model the same concepts supported
-    by the directive.  Because the directives are self-contained
-    objects, the state and other object references it keeps are only
-    accessible to it and can be re-used in different contexts as well.
-
-Extending a system that uses directives is trivial in header-only
-systems because new directives are simply additive. The protocol is
-simple and can be applied to a broad class of situations.
-
-In a header-only library, the static nature of the wiring and chaining
-of the operations lends itself to compiler abuse. A deep enough
-nesting of the directives can lead to prolonged compilation times.
diff --git a/libs/network/doc/html/_sources/techniques/polymorphism.txt b/libs/network/doc/html/_sources/techniques/polymorphism.txt
deleted file mode 100644
index d5e42f8c9..000000000
--- a/libs/network/doc/html/_sources/techniques/polymorphism.txt
+++ /dev/null
@@ -1,92 +0,0 @@
-Static and dynamic polymorphism
-===============================
-
-
-With a header only library, you can only do so much with static
-polymorphism alone. There are some situations where you have to handle
-dynamic polymorphism because of unavoidable runtime-based decision
-making. Although you can deal with the base types that remain static,
-behavior can vary greatly which derived type should be handling the
-situation based on runtime values.
-
-This situation comes up in the :mod:`cpp-netlib` when we decide what
-kind of connection handler to use for a given HTTP URI -- whether it's
-plain HTTP or HTTPS.  Although the HTTP semantics are the same for
-HTTP and HTTPS the implementation of the connection handler greatly
-varies on whether to use a plain TCP connection or an SSL-wrapped TCP
-connection.
-
-The general pattern or technique is to combine tag-based dispatch with
-a strategy factory, all while not requiring any externally built
-libraries. Doing it in a header-only library requires a little
-creativity and additional layers of indirection that you otherwise
-will not need for a library with externally built static/dynamic
-libraries.
-
-First we define the base type which we want to support dynamic
-behavior with.  There's nothing special with the base type, except
-that it supports the tag dispatch earlier defined and has a virtual
-destructor. In code it looks like this:
-
-.. code-block:: c++
-
-    template <class Tag>
-    struct base {
-        virtual void foo() = 0; // make this an abstract base
-        virtual ~base() {
-            // do the base destructor thing here.
-        }
-    };
-
-We then define a set of derived types that specialize the
-implementation of the ``foo`` member function. To facilitate the
-dispatch of the correct type based on an input, we create a strategy
-factory function:
-
-.. code-block:: c++
-
-    template <class Tag>
-    unique_ptr<base<Tag> > strategy(int input, Tag) {
-        unique_ptr<base<Tag> > ptr;
-        switch(input) {
-            case 0: ptr.reset(new derived0()); break;
-            case 1: ptr.reset(new derived1()); break;
-            // ...
-            default: ptr.reset(0); break;
-        }
-        return ptr;
-    }
-
-    unique_ptr<base<default_> > ptr =
-        strategy(input, default_()); // input is a runtime value
-
-The strategy factory can be a standalone function, or a static member
-of a factory class that is specialized by tag dispatch. This can be
-done like the following:
-
-.. code-block:: c++
-
-    template <class Tag>
-    struct strategy;
-
-    template <>
-    struct strategy<default_> {
-        static unique_ptr<base<default_> > create(int input) {
-            unique_ptr<base<default_> > ptr;
-            switch(input) {
-                case 0: ptr.reset(new derived0()); break;
-                case 1: ptr.reset(new derived1()); break;
-                //...
-                default: ptr.reset(0); break;
-            }
-            return ptr;
-        }
-    };
-
-This approach allows the header-only libraries to define new dynamic
-types in subsequent versions of the library while keeping the
-static-dynamic bridge fluid. The only down-side to this is the
-possibility of derived type explosion in case there are a lot of
-different strategies or specializations available -- this though is
-not unique to static-dynamic bridging, but is also a problem with pure
-object oriented programming with dynamic polymorphism.
diff --git a/libs/network/doc/html/_sources/techniques/tag_metafunctions.txt b/libs/network/doc/html/_sources/techniques/tag_metafunctions.txt
deleted file mode 100644
index 68edd1449..000000000
--- a/libs/network/doc/html/_sources/techniques/tag_metafunctions.txt
+++ /dev/null
@@ -1,172 +0,0 @@
-Tag metafunctions
-=================
-
-Sometimes you want to vary a function or a type's behavior based on a
-static parameter. In the :mod:`cpp-netlib` there are a number of
-things you might want to change based on some such parameter -- like
-what the underlying string type should be and how large a buffer
-should be, among other things. The primary way to define this in a
-header-only manner is to use tag-based metafunctions.
-
-The skeleton of the approach is based on a similar technique for
-defining type traits. In the :mod:`cpp-netlib` however the type traits
-are defined on opaque tag types which serve to associate results to a
-family of metafunctions.
-
-Template Specialization
------------------------
-
-To illustrate this point, let's define a tag ``default_`` which we use
-to denote the default implementation of a certain type ``foo``. For
-instance we decide that the default string type we will use for
-``default_`` tagged ``foo`` specializations will be an
-``std::string``.
-
-In the :mod:`cpp-netlib` this is done by defining a ``string``
-metafunction type that is specialized on the tag ``default_`` whose
-nested ``type`` result is the type ``std::string``. In code this would
-translate to:
-
-.. code-block:: c++
-
-    template <class Tag>
-    struct string {
-        typedef void type;
-    };
-
-    struct default_;
-
-    template <>
-    struct string<default_> {
-        typedef std::string type;
-    };
-
-Template Metaprogramming
-------------------------
-
-Starting with version 0.7, the tag dispatch mechanism changed slightly to use
-Boost.MPL_. The idea is still the same, although we can get a little smarter
-than just using template specializations. Instead of just defining an opaque
-type ``default_``, we use the Boost.MPL equivalent of a vector to define which
-root types of properties this ``default_`` tag supports. The idea is to make the
-opaque type ``default_`` inherit property tags which the library supports
-internally as definite extension points.
-
-.. _Boost.MPL: http://www.boost.org/libs/mpl/index.html
-
-Our definition of the ``default_`` tag will then look something like the
-following:
-
-.. code-block:: c++
-
-    typedef mpl::vector<default_string> default_tags;
-
-    template <class Tag>
-    struct components;
-
-    typedef mpl::inherit_linearly<
-        default_tags,
-        mpl::inherit<mpl::placeholders::_1, mpl::placeholders::_2>
-        >::type default_;
-
-    template <class Tag>
-    struct components<default_> {
-        typedef default_tags type;
-    };
-
-In the above listing, ``default_string`` is what we call a "root" tag which is
-meant to be combined with other "root" tags to form composite tags. In this case
-our composite tag is the tag ``default_``. There are a number of these "root"
-tags that :mod:`cpp-netlib` provides. These are in the namespace
-``boost::network::tags`` and are defined in ``boost/network/tags.hpp``.
-
-Using this technique we change slightly our definition of the ``string``
-metafunction class into this:
-
-.. code-block:: c++
-
-    template <class Tag>
-    struct unsupported_tag;
-
-    template <class Tag>
-    struct string :
-        mpl::if_<
-            is_base_of<
-                tags::default_string,
-                Tag
-            >,
-            std::string,
-            unsupported_tag<Tag>
-        >
-    {};
-
-Notice that we don't have the typedef for ``type`` in the body of ``string``
-anymore, but we do inherit from ``mpl::if_``. Since ``mpl::if_`` is a template
-metafunction itself, it contains a definition of the resulting ``type`` which
-``string`` inherits.
-
-You can see the real definition of the ``string`` metafunction in
-``boost/network/traits/string.hpp``.
-
-Using Tags
-----------
-
-Once we have the defined tag, we can then use this in the definition of our
-types. In the definition of the type ``foo`` we use this type function
-``string`` and pass the tag type parameter to determine what to use as
-the string type in the context of the type ``foo``. In code this would
-translate into:
-
-.. code-block:: c++
-
-    template <class Tag>
-    struct foo {
-        typedef typename string<Tag>::type string_type;
-
-        // .. use string_type where you need a string.
-    };
-
-Using this approach we can support different types of strings for
-different tags on the type ``foo``. In case we want to use a different
-type of string for the tag ``default_`` we only change the
-composition of the ``string_tags`` MPL vector. For example, in :mod:`cpp-netlib`
-there is a root tag ``default_wstring`` which causes the ``string`` metafunction 
-to define ``std::wstring`` as the resulting type.
-
-The approach also allows for the control of the structure and features
-of types like ``foo`` based on the specialization of the tag. Whole
-type function families can be defined on tags where they are supported
-and ignored in cases where they are not.
-
-To illustrate let's define a new tag ``swappable``. Given the above
-definition of ``foo``, we want to make the ``swappable``-tagged
-``foo`` define a ``swap`` function that extends the original
-``default_``-tagged ``foo``. In code this would look like:
-
-.. code-block:: c++
-
-    struct swappable;
-
-    template <>
-    struct foo<swappable> : foo<default_> {
-        void swap(foo<swappable> & other) {
-            // ...
-        }
-    };
-
-We also for example want to enable an ADL-reachable ``swap`` function:
-
-.. code-block:: c++
-
-    struct swappable;
-
-    inline
-    void swap(foo<swappable> & left, foo<swappable> & right) {
-        left.swap(right);
-    }
-
-Overall what the tag-based definition approach allows is for static
-definition of extension points that ensures type-safety and
-invariants. This keeps the whole extension mechanism static and yet
-flexible.
-
diff --git a/libs/network/doc/html/contents.html b/libs/network/doc/html/contents.html
index af9c12b4d..ce952c360 100644
--- a/libs/network/doc/html/contents.html
+++ b/libs/network/doc/html/contents.html
@@ -144,48 +144,6 @@ <h3>Navigation</h3>
 </li>
 </ul>
 </li>
-<li class="toctree-l1"><a class="reference internal" href="in_depth.html">An in-depth look at the <code class="docutils literal"><span class="pre">cpp-netlib</span></code></a><ul>
-<li class="toctree-l2"><a class="reference internal" href="in_depth/message.html">The message template</a><ul>
-<li class="toctree-l3"><a class="reference internal" href="in_depth/message.html#message-concept">Message Concept</a></li>
-<li class="toctree-l3"><a class="reference internal" href="in_depth/message.html#directives-modifiers-and-wrappers">Directives, Modifiers, and Wrappers</a><ul>
-<li class="toctree-l4"><a class="reference internal" href="in_depth/message.html#directives">Directives</a></li>
-<li class="toctree-l4"><a class="reference internal" href="in_depth/message.html#modifiers">Modifiers</a></li>
-<li class="toctree-l4"><a class="reference internal" href="in_depth/message.html#wrappers">Wrappers</a></li>
-</ul>
-</li>
-<li class="toctree-l3"><a class="reference internal" href="in_depth/message.html#basic-message"><code class="docutils literal"><span class="pre">basic_message</span></code></a></li>
-</ul>
-</li>
-<li class="toctree-l2"><a class="reference internal" href="in_depth/uri.html">The URI class</a><ul>
-<li class="toctree-l3"><a class="reference internal" href="in_depth/uri.html#generic-uri-syntax-overview">Generic URI syntax overview</a></li>
-<li class="toctree-l3"><a class="reference internal" href="in_depth/uri.html#id1">The <code class="docutils literal"><span class="pre">uri</span></code> class</a></li>
-<li class="toctree-l3"><a class="reference internal" href="in_depth/uri.html#the-uri-builder">The <code class="docutils literal"><span class="pre">uri</span></code> builder</a></li>
-<li class="toctree-l3"><a class="reference internal" href="in_depth/uri.html#uri-concept"><code class="docutils literal"><span class="pre">URI</span> <span class="pre">Concept</span></code></a></li>
-</ul>
-</li>
-<li class="toctree-l2"><a class="reference internal" href="in_depth/http.html">HTTP implementation</a><ul>
-<li class="toctree-l3"><a class="reference internal" href="in_depth/http.html#http-client">HTTP client</a></li>
-<li class="toctree-l3"><a class="reference internal" href="in_depth/http.html#http-server">HTTP server</a></li>
-</ul>
-</li>
-</ul>
-</li>
-<li class="toctree-l1"><a class="reference internal" href="techniques.html">Techniques</a><ul>
-<li class="toctree-l2"><a class="reference internal" href="techniques/tag_metafunctions.html">Tag metafunctions</a><ul>
-<li class="toctree-l3"><a class="reference internal" href="techniques/tag_metafunctions.html#template-specialization">Template Specialization</a></li>
-<li class="toctree-l3"><a class="reference internal" href="techniques/tag_metafunctions.html#template-metaprogramming">Template Metaprogramming</a></li>
-<li class="toctree-l3"><a class="reference internal" href="techniques/tag_metafunctions.html#using-tags">Using Tags</a></li>
-</ul>
-</li>
-<li class="toctree-l2"><a class="reference internal" href="techniques/directives.html">Directives</a></li>
-<li class="toctree-l2"><a class="reference internal" href="techniques/polymorphism.html">Static and dynamic polymorphism</a></li>
-</ul>
-</li>
-<li class="toctree-l1"><a class="reference internal" href="history.html">Project history</a><ul>
-<li class="toctree-l2"><a class="reference internal" href="history.html#motivation">Motivation</a></li>
-<li class="toctree-l2"><a class="reference internal" href="history.html#objectives">Objectives</a></li>
-</ul>
-</li>
 <li class="toctree-l1"><a class="reference internal" href="reference.html">Reference Manual</a><ul>
 <li class="toctree-l2"><a class="reference internal" href="reference/http_client.html">HTTP Client API</a><ul>
 <li class="toctree-l3"><a class="reference internal" href="reference/http_client.html#general">General</a></li>
@@ -220,16 +178,14 @@ <h3>Navigation</h3>
 </li>
 <li class="toctree-l2"><a class="reference internal" href="reference/http_server.html">HTTP Server API</a><ul>
 <li class="toctree-l3"><a class="reference internal" href="reference/http_server.html#general">General</a></li>
-<li class="toctree-l3"><a class="reference internal" href="reference/http_server.html#implementations">Implementations</a></li>
-<li class="toctree-l3"><a class="reference internal" href="reference/http_server.html#synchronous-servers">Synchronous Servers</a><ul>
-<li class="toctree-l4"><a class="reference internal" href="reference/http_server.html#api-documentation">API Documentation</a></li>
-</ul>
-</li>
-<li class="toctree-l3"><a class="reference internal" href="reference/http_server.html#asynchronous-servers">Asynchronous Servers</a><ul>
-<li class="toctree-l4"><a class="reference internal" href="reference/http_server.html#id5">API Documentation</a></li>
+<li class="toctree-l3"><a class="reference internal" href="reference/http_server.html#api-documentation">API Documentation</a><ul>
+<li class="toctree-l4"><a class="reference internal" href="reference/http_server.html#constructor">Constructor</a></li>
+<li class="toctree-l4"><a class="reference internal" href="reference/http_server.html#server-options">Server Options</a></li>
+<li class="toctree-l4"><a class="reference internal" href="reference/http_server.html#public-members">Public Members</a></li>
+<li class="toctree-l4"><a class="reference internal" href="reference/http_server.html#connection-object">Connection Object</a></li>
 </ul>
 </li>
-<li class="toctree-l3"><a class="reference internal" href="reference/http_server.html#adding-ssl-support-to-asynchronous-server">Adding SSL support to Asynchronous Server</a></li>
+<li class="toctree-l3"><a class="reference internal" href="reference/http_server.html#adding-ssl-support-to-the-http-server">Adding SSL support to the HTTP Server</a></li>
 </ul>
 </li>
 </ul>
@@ -280,7 +236,7 @@ <h3>Navigation</h3>
     </div>
     <div class="footer" role="contentinfo">
         &copy; Copyright 2008-2014, Glyn Matthews, Dean Michael Berris; 2013 Google, Inc..
-      Last updated on Mar 07, 2016.
+      Last updated on Mar 29, 2016.
       Created using <a href="http://sphinx-doc.org/">Sphinx</a> 1.3.6.
     </div>
   </body>
diff --git a/libs/network/doc/html/examples.html b/libs/network/doc/html/examples.html
index 88fc1c073..767f3579d 100644
--- a/libs/network/doc/html/examples.html
+++ b/libs/network/doc/html/examples.html
@@ -129,7 +129,7 @@ <h3>Navigation</h3>
     </div>
     <div class="footer" role="contentinfo">
         &copy; Copyright 2008-2014, Glyn Matthews, Dean Michael Berris; 2013 Google, Inc..
-      Last updated on Mar 07, 2016.
+      Last updated on Mar 29, 2016.
       Created using <a href="http://sphinx-doc.org/">Sphinx</a> 1.3.6.
     </div>
   </body>
diff --git a/libs/network/doc/html/examples/http/atom_reader.html b/libs/network/doc/html/examples/http/atom_reader.html
index 8a09a4e34..f833de2c2 100644
--- a/libs/network/doc/html/examples/http/atom_reader.html
+++ b/libs/network/doc/html/examples/http/atom_reader.html
@@ -175,7 +175,7 @@ <h3>Navigation</h3>
     </div>
     <div class="footer" role="contentinfo">
         &copy; Copyright 2008-2014, Glyn Matthews, Dean Michael Berris; 2013 Google, Inc..
-      Last updated on Mar 07, 2016.
+      Last updated on Mar 29, 2016.
       Created using <a href="http://sphinx-doc.org/">Sphinx</a> 1.3.6.
     </div>
   </body>
diff --git a/libs/network/doc/html/examples/http/hello_world_client.html b/libs/network/doc/html/examples/http/hello_world_client.html
index ba547bf9b..e9ff6a48e 100644
--- a/libs/network/doc/html/examples/http/hello_world_client.html
+++ b/libs/network/doc/html/examples/http/hello_world_client.html
@@ -192,7 +192,7 @@ <h3>Navigation</h3>
     </div>
     <div class="footer" role="contentinfo">
         &copy; Copyright 2008-2014, Glyn Matthews, Dean Michael Berris; 2013 Google, Inc..
-      Last updated on Mar 07, 2016.
+      Last updated on Mar 29, 2016.
       Created using <a href="http://sphinx-doc.org/">Sphinx</a> 1.3.6.
     </div>
   </body>
diff --git a/libs/network/doc/html/examples/http/hello_world_server.html b/libs/network/doc/html/examples/http/hello_world_server.html
index aee567a99..cdea75e8f 100644
--- a/libs/network/doc/html/examples/http/hello_world_server.html
+++ b/libs/network/doc/html/examples/http/hello_world_server.html
@@ -242,7 +242,7 @@ <h3>Navigation</h3>
     </div>
     <div class="footer" role="contentinfo">
         &copy; Copyright 2008-2014, Glyn Matthews, Dean Michael Berris; 2013 Google, Inc..
-      Last updated on Mar 07, 2016.
+      Last updated on Mar 29, 2016.
       Created using <a href="http://sphinx-doc.org/">Sphinx</a> 1.3.6.
     </div>
   </body>
diff --git a/libs/network/doc/html/examples/http/http_client.html b/libs/network/doc/html/examples/http/http_client.html
index a3b4ef0c0..b5ef618f8 100644
--- a/libs/network/doc/html/examples/http/http_client.html
+++ b/libs/network/doc/html/examples/http/http_client.html
@@ -206,7 +206,7 @@ <h3>Navigation</h3>
     </div>
     <div class="footer" role="contentinfo">
         &copy; Copyright 2008-2014, Glyn Matthews, Dean Michael Berris; 2013 Google, Inc..
-      Last updated on Mar 07, 2016.
+      Last updated on Mar 29, 2016.
       Created using <a href="http://sphinx-doc.org/">Sphinx</a> 1.3.6.
     </div>
   </body>
diff --git a/libs/network/doc/html/examples/http/simple_wget.html b/libs/network/doc/html/examples/http/simple_wget.html
index 005e83026..709d941cd 100644
--- a/libs/network/doc/html/examples/http/simple_wget.html
+++ b/libs/network/doc/html/examples/http/simple_wget.html
@@ -203,7 +203,7 @@ <h3>Navigation</h3>
     </div>
     <div class="footer" role="contentinfo">
         &copy; Copyright 2008-2014, Glyn Matthews, Dean Michael Berris; 2013 Google, Inc..
-      Last updated on Mar 07, 2016.
+      Last updated on Mar 29, 2016.
       Created using <a href="http://sphinx-doc.org/">Sphinx</a> 1.3.6.
     </div>
   </body>
diff --git a/libs/network/doc/html/examples/http/twitter_search.html b/libs/network/doc/html/examples/http/twitter_search.html
index 7e526d8eb..62018b073 100644
--- a/libs/network/doc/html/examples/http/twitter_search.html
+++ b/libs/network/doc/html/examples/http/twitter_search.html
@@ -25,7 +25,7 @@
     <script type="text/javascript" src="../../_static/doctools.js"></script>
     <link rel="top" title="cpp-netlib v0.11.2" href="../../contents.html" />
     <link rel="up" title="Examples" href="../../examples.html" />
-    <link rel="next" title="An in-depth look at the cpp-netlib" href="../../in_depth.html" />
+    <link rel="next" title="Reference Manual" href="../../reference.html" />
     <link rel="prev" title="Atom feed reader" href="atom_reader.html" />
 <link rel="stylesheet" href="http://fonts.googleapis.com/css?family=Neuton&amp;subset=latin" type="text/css" media="screen" charset="utf-8" />
 <link rel="stylesheet" href="http://fonts.googleapis.com/css?family=Nobile:regular,italic,bold,bolditalic&amp;subset=latin" type="text/css" media="screen" charset="utf-8" />
@@ -40,7 +40,7 @@
       <h3>Navigation</h3>
       <ul>
         <li class="right" style="margin-right: 10px">
-          <a href="../../in_depth.html" title="An in-depth look at the cpp-netlib"
+          <a href="../../reference.html" title="Reference Manual"
              accesskey="N">next</a></li>
         <li class="right" >
           <a href="atom_reader.html" title="Atom feed reader"
@@ -175,8 +175,8 @@ <h4>Previous topic</h4>
   <p class="topless"><a href="atom_reader.html"
                         title="previous chapter">Atom feed reader</a></p>
   <h4>Next topic</h4>
-  <p class="topless"><a href="../../in_depth.html"
-                        title="next chapter">An in-depth look at the <code class="docutils literal"><span class="pre">cpp-netlib</span></code></a></p>
+  <p class="topless"><a href="../../reference.html"
+                        title="next chapter">Reference Manual</a></p>
 <div id="searchbox" style="display: none" role="search">
   <h3>Quick search</h3>
     <form class="search" action="../../search.html" method="get">
@@ -198,7 +198,7 @@ <h3>Quick search</h3>
       <h3>Navigation</h3>
       <ul>
         <li class="right" style="margin-right: 10px">
-          <a href="../../in_depth.html" title="An in-depth look at the cpp-netlib"
+          <a href="../../reference.html" title="Reference Manual"
              >next</a></li>
         <li class="right" >
           <a href="atom_reader.html" title="Atom feed reader"
@@ -209,7 +209,7 @@ <h3>Navigation</h3>
     </div>
     <div class="footer" role="contentinfo">
         &copy; Copyright 2008-2014, Glyn Matthews, Dean Michael Berris; 2013 Google, Inc..
-      Last updated on Mar 07, 2016.
+      Last updated on Mar 29, 2016.
       Created using <a href="http://sphinx-doc.org/">Sphinx</a> 1.3.6.
     </div>
   </body>
diff --git a/libs/network/doc/html/getting_started.html b/libs/network/doc/html/getting_started.html
index 6bd8f7c00..3c8a000cc 100644
--- a/libs/network/doc/html/getting_started.html
+++ b/libs/network/doc/html/getting_started.html
@@ -350,7 +350,7 @@ <h3>Navigation</h3>
     </div>
     <div class="footer" role="contentinfo">
         &copy; Copyright 2008-2014, Glyn Matthews, Dean Michael Berris; 2013 Google, Inc..
-      Last updated on Mar 07, 2016.
+      Last updated on Mar 29, 2016.
       Created using <a href="http://sphinx-doc.org/">Sphinx</a> 1.3.6.
     </div>
   </body>
diff --git a/libs/network/doc/html/history.html b/libs/network/doc/html/history.html
deleted file mode 100644
index 271921c2a..000000000
--- a/libs/network/doc/html/history.html
+++ /dev/null
@@ -1,156 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-
-
-<html xmlns="http://www.w3.org/1999/xhtml">
-  <head>
-    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-    
-    <title>Project history &mdash; cpp-netlib v0.11.2</title>
-    
-    <link rel="stylesheet" href="_static/pyramid.css" type="text/css" />
-    <link rel="stylesheet" href="_static/pygments.css" type="text/css" />
-    
-    <script type="text/javascript">
-      var DOCUMENTATION_OPTIONS = {
-        URL_ROOT:    './',
-        VERSION:     '0.11.2',
-        COLLAPSE_INDEX: false,
-        FILE_SUFFIX: '.html',
-        HAS_SOURCE:  true
-      };
-    </script>
-    <script type="text/javascript" src="_static/jquery.js"></script>
-    <script type="text/javascript" src="_static/underscore.js"></script>
-    <script type="text/javascript" src="_static/doctools.js"></script>
-    <link rel="top" title="cpp-netlib v0.11.2" href="contents.html" />
-    <link rel="next" title="Reference Manual" href="reference.html" />
-    <link rel="prev" title="Static and dynamic polymorphism" href="techniques/polymorphism.html" />
-<link rel="stylesheet" href="http://fonts.googleapis.com/css?family=Neuton&amp;subset=latin" type="text/css" media="screen" charset="utf-8" />
-<link rel="stylesheet" href="http://fonts.googleapis.com/css?family=Nobile:regular,italic,bold,bolditalic&amp;subset=latin" type="text/css" media="screen" charset="utf-8" />
-<!--[if lte IE 6]>
-<link rel="stylesheet" href="_static/ie6.css" type="text/css" media="screen" charset="utf-8" />
-<![endif]-->
-
-  </head>
-  <body role="document">
-
-    <div class="related" role="navigation" aria-label="related navigation">
-      <h3>Navigation</h3>
-      <ul>
-        <li class="right" style="margin-right: 10px">
-          <a href="reference.html" title="Reference Manual"
-             accesskey="N">next</a></li>
-        <li class="right" >
-          <a href="techniques/polymorphism.html" title="Static and dynamic polymorphism"
-             accesskey="P">previous</a> |</li>
-        <li class="nav-item nav-item-0"><a href="contents.html">cpp-netlib v0.11.2</a> &raquo;</li> 
-      </ul>
-    </div>  
-
-    <div class="document">
-      <div class="documentwrapper">
-        <div class="bodywrapper">
-          <div class="body" role="main">
-            
-  <div class="section" id="project-history">
-<h1>Project history<a class="headerlink" href="#project-history" title="Permalink to this headline">¶</a></h1>
-<p>The <code class="xref py py-mod docutils literal"><span class="pre">cpp-netlib</span></code> was founded by Dean Michael Berris in 2007.
-Initially it consisted of a message template and an HTTP client.  It
-found a home on <a class="reference external" href="http://sourceforge.net/projects/cpp-netlib/">Sourceforge</a> but was migrated at the end of 2009 to
-<a class="reference external" href="http://github.com/cpp-netlib/cpp-netlib">Github</a> where development is actively continued by a committed
-community.</p>
-<div class="section" id="motivation">
-<h2>Motivation<a class="headerlink" href="#motivation" title="Permalink to this headline">¶</a></h2>
-<p>We&#8217;re a group of C++ developers and we kept becoming annoyed that we
-had to repeatedly write the same code when building applications that
-needed to be network-aware.</p>
-<p>We found that there was a lack of accessible networking libraries,
-either standard or open source, that fulfilled our needs.  Such
-libraries exist for every other major language.  So, building on top
-of <a class="reference external" href="http://www.boost.org/libs/asio/">Boost.Asio</a>, we decided to get together and build our own.</p>
-</div>
-<div class="section" id="objectives">
-<h2>Objectives<a class="headerlink" href="#objectives" title="Permalink to this headline">¶</a></h2>
-<p>The objectives of the <code class="xref py py-mod docutils literal"><span class="pre">cpp-netlib</span></code> are to:</p>
-<ul class="simple">
-<li>develop a high quality, portable, easy to use C++ networking library</li>
-<li>enable developers to easily extend the library</li>
-<li>lower the barrier to entry for cross-platform network-aware C++
-applications</li>
-</ul>
-<p>The goal the of <code class="xref py py-mod docutils literal"><span class="pre">cpp-netlib</span></code> has never been to build a
-fully-featured web server - there are plenty of excellent options
-already available.  The niche that this library targets is for
-light-weight networking functionality for C++ applications that have
-demanding performance requirements or memory constraints, but that
-also need to be portable.  This type of application is becoming
-increasingly common as software becomes more distributed, and
-applications need to communicate with services.</p>
-<p>While many languages provide direct library support for high level
-network programming, this feature is missing in C++.  Therefore, this
-library has been developed with the intention of eventually being
-submitted to <a class="reference external" href="http://www.boost.org/">Boost</a>, a collection of general, high quality
-libraries for C++ developers.</p>
-<p>Eventually, the <code class="xref py py-mod docutils literal"><span class="pre">cpp-netlib</span></code> will be extended to support many of
-the application layer protocols such as SMTP, FTP, SOAP, XMPP etc.</p>
-</div>
-</div>
-
-
-          </div>
-        </div>
-      </div>
-      <div class="sphinxsidebar" role="navigation" aria-label="main navigation">
-        <div class="sphinxsidebarwrapper">
-  <h3><a href="contents.html">Table Of Contents</a></h3>
-  <ul>
-<li><a class="reference internal" href="#">Project history</a><ul>
-<li><a class="reference internal" href="#motivation">Motivation</a></li>
-<li><a class="reference internal" href="#objectives">Objectives</a></li>
-</ul>
-</li>
-</ul>
-
-  <h4>Previous topic</h4>
-  <p class="topless"><a href="techniques/polymorphism.html"
-                        title="previous chapter">Static and dynamic polymorphism</a></p>
-  <h4>Next topic</h4>
-  <p class="topless"><a href="reference.html"
-                        title="next chapter">Reference Manual</a></p>
-<div id="searchbox" style="display: none" role="search">
-  <h3>Quick search</h3>
-    <form class="search" action="search.html" method="get">
-      <input type="text" name="q" />
-      <input type="submit" value="Go" />
-      <input type="hidden" name="check_keywords" value="yes" />
-      <input type="hidden" name="area" value="default" />
-    </form>
-    <p class="searchtip" style="font-size: 90%">
-    Enter search terms or a module, class or function name.
-    </p>
-</div>
-<script type="text/javascript">$('#searchbox').show(0);</script>
-        </div>
-      </div>
-      <div class="clearer"></div>
-    </div>
-    <div class="related" role="navigation" aria-label="related navigation">
-      <h3>Navigation</h3>
-      <ul>
-        <li class="right" style="margin-right: 10px">
-          <a href="reference.html" title="Reference Manual"
-             >next</a></li>
-        <li class="right" >
-          <a href="techniques/polymorphism.html" title="Static and dynamic polymorphism"
-             >previous</a> |</li>
-        <li class="nav-item nav-item-0"><a href="contents.html">cpp-netlib v0.11.2</a> &raquo;</li> 
-      </ul>
-    </div>
-    <div class="footer" role="contentinfo">
-        &copy; Copyright 2008-2014, Glyn Matthews, Dean Michael Berris; 2013 Google, Inc..
-      Last updated on Mar 07, 2016.
-      Created using <a href="http://sphinx-doc.org/">Sphinx</a> 1.3.6.
-    </div>
-  </body>
-</html>
\ No newline at end of file
diff --git a/libs/network/doc/html/in_depth.html b/libs/network/doc/html/in_depth.html
deleted file mode 100644
index 0a4148354..000000000
--- a/libs/network/doc/html/in_depth.html
+++ /dev/null
@@ -1,132 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-
-
-<html xmlns="http://www.w3.org/1999/xhtml">
-  <head>
-    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-    
-    <title>An in-depth look at the cpp-netlib &mdash; cpp-netlib v0.11.2</title>
-    
-    <link rel="stylesheet" href="_static/pyramid.css" type="text/css" />
-    <link rel="stylesheet" href="_static/pygments.css" type="text/css" />
-    
-    <script type="text/javascript">
-      var DOCUMENTATION_OPTIONS = {
-        URL_ROOT:    './',
-        VERSION:     '0.11.2',
-        COLLAPSE_INDEX: false,
-        FILE_SUFFIX: '.html',
-        HAS_SOURCE:  true
-      };
-    </script>
-    <script type="text/javascript" src="_static/jquery.js"></script>
-    <script type="text/javascript" src="_static/underscore.js"></script>
-    <script type="text/javascript" src="_static/doctools.js"></script>
-    <link rel="top" title="cpp-netlib v0.11.2" href="contents.html" />
-    <link rel="next" title="The message template" href="in_depth/message.html" />
-    <link rel="prev" title="Twitter search" href="examples/http/twitter_search.html" />
-<link rel="stylesheet" href="http://fonts.googleapis.com/css?family=Neuton&amp;subset=latin" type="text/css" media="screen" charset="utf-8" />
-<link rel="stylesheet" href="http://fonts.googleapis.com/css?family=Nobile:regular,italic,bold,bolditalic&amp;subset=latin" type="text/css" media="screen" charset="utf-8" />
-<!--[if lte IE 6]>
-<link rel="stylesheet" href="_static/ie6.css" type="text/css" media="screen" charset="utf-8" />
-<![endif]-->
-
-  </head>
-  <body role="document">
-
-    <div class="related" role="navigation" aria-label="related navigation">
-      <h3>Navigation</h3>
-      <ul>
-        <li class="right" style="margin-right: 10px">
-          <a href="in_depth/message.html" title="The message template"
-             accesskey="N">next</a></li>
-        <li class="right" >
-          <a href="examples/http/twitter_search.html" title="Twitter search"
-             accesskey="P">previous</a> |</li>
-        <li class="nav-item nav-item-0"><a href="contents.html">cpp-netlib v0.11.2</a> &raquo;</li> 
-      </ul>
-    </div>  
-
-    <div class="document">
-      <div class="documentwrapper">
-        <div class="bodywrapper">
-          <div class="body" role="main">
-            
-  <div class="section" id="an-in-depth-look-at-the-cpp-netlib">
-<span id="in-depth"></span><h1>An in-depth look at the <code class="xref py py-mod docutils literal"><span class="pre">cpp-netlib</span></code><a class="headerlink" href="#an-in-depth-look-at-the-cpp-netlib" title="Permalink to this headline">¶</a></h1>
-<p>The <code class="xref py py-mod docutils literal"><span class="pre">cpp-netlib</span></code> is composed of three different sets of
-functionality: a <strong>message</strong> template, a <strong>URI</strong> template and
-different <strong>protocol</strong> implementations.</p>
-<div class="toctree-wrapper compound">
-<ul>
-<li class="toctree-l1"><a class="reference internal" href="in_depth/message.html">The message template</a><ul>
-<li class="toctree-l2"><a class="reference internal" href="in_depth/message.html#message-concept">Message Concept</a></li>
-<li class="toctree-l2"><a class="reference internal" href="in_depth/message.html#directives-modifiers-and-wrappers">Directives, Modifiers, and Wrappers</a></li>
-<li class="toctree-l2"><a class="reference internal" href="in_depth/message.html#basic-message"><code class="docutils literal"><span class="pre">basic_message</span></code></a></li>
-</ul>
-</li>
-<li class="toctree-l1"><a class="reference internal" href="in_depth/uri.html">The URI class</a><ul>
-<li class="toctree-l2"><a class="reference internal" href="in_depth/uri.html#generic-uri-syntax-overview">Generic URI syntax overview</a></li>
-<li class="toctree-l2"><a class="reference internal" href="in_depth/uri.html#id1">The <code class="docutils literal"><span class="pre">uri</span></code> class</a></li>
-<li class="toctree-l2"><a class="reference internal" href="in_depth/uri.html#the-uri-builder">The <code class="docutils literal"><span class="pre">uri</span></code> builder</a></li>
-<li class="toctree-l2"><a class="reference internal" href="in_depth/uri.html#uri-concept"><code class="docutils literal"><span class="pre">URI</span> <span class="pre">Concept</span></code></a></li>
-</ul>
-</li>
-<li class="toctree-l1"><a class="reference internal" href="in_depth/http.html">HTTP implementation</a><ul>
-<li class="toctree-l2"><a class="reference internal" href="in_depth/http.html#http-client">HTTP client</a></li>
-<li class="toctree-l2"><a class="reference internal" href="in_depth/http.html#http-server">HTTP server</a></li>
-</ul>
-</li>
-</ul>
-</div>
-</div>
-
-
-          </div>
-        </div>
-      </div>
-      <div class="sphinxsidebar" role="navigation" aria-label="main navigation">
-        <div class="sphinxsidebarwrapper">
-  <h4>Previous topic</h4>
-  <p class="topless"><a href="examples/http/twitter_search.html"
-                        title="previous chapter">Twitter search</a></p>
-  <h4>Next topic</h4>
-  <p class="topless"><a href="in_depth/message.html"
-                        title="next chapter">The message template</a></p>
-<div id="searchbox" style="display: none" role="search">
-  <h3>Quick search</h3>
-    <form class="search" action="search.html" method="get">
-      <input type="text" name="q" />
-      <input type="submit" value="Go" />
-      <input type="hidden" name="check_keywords" value="yes" />
-      <input type="hidden" name="area" value="default" />
-    </form>
-    <p class="searchtip" style="font-size: 90%">
-    Enter search terms or a module, class or function name.
-    </p>
-</div>
-<script type="text/javascript">$('#searchbox').show(0);</script>
-        </div>
-      </div>
-      <div class="clearer"></div>
-    </div>
-    <div class="related" role="navigation" aria-label="related navigation">
-      <h3>Navigation</h3>
-      <ul>
-        <li class="right" style="margin-right: 10px">
-          <a href="in_depth/message.html" title="The message template"
-             >next</a></li>
-        <li class="right" >
-          <a href="examples/http/twitter_search.html" title="Twitter search"
-             >previous</a> |</li>
-        <li class="nav-item nav-item-0"><a href="contents.html">cpp-netlib v0.11.2</a> &raquo;</li> 
-      </ul>
-    </div>
-    <div class="footer" role="contentinfo">
-        &copy; Copyright 2008-2014, Glyn Matthews, Dean Michael Berris; 2013 Google, Inc..
-      Last updated on Mar 07, 2016.
-      Created using <a href="http://sphinx-doc.org/">Sphinx</a> 1.3.6.
-    </div>
-  </body>
-</html>
\ No newline at end of file
diff --git a/libs/network/doc/html/in_depth/http.html b/libs/network/doc/html/in_depth/http.html
deleted file mode 100644
index c0fca35a9..000000000
--- a/libs/network/doc/html/in_depth/http.html
+++ /dev/null
@@ -1,311 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-
-
-<html xmlns="http://www.w3.org/1999/xhtml">
-  <head>
-    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-    
-    <title>HTTP implementation &mdash; cpp-netlib v0.11.2</title>
-    
-    <link rel="stylesheet" href="../_static/pyramid.css" type="text/css" />
-    <link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
-    
-    <script type="text/javascript">
-      var DOCUMENTATION_OPTIONS = {
-        URL_ROOT:    '../',
-        VERSION:     '0.11.2',
-        COLLAPSE_INDEX: false,
-        FILE_SUFFIX: '.html',
-        HAS_SOURCE:  true
-      };
-    </script>
-    <script type="text/javascript" src="../_static/jquery.js"></script>
-    <script type="text/javascript" src="../_static/underscore.js"></script>
-    <script type="text/javascript" src="../_static/doctools.js"></script>
-    <link rel="top" title="cpp-netlib v0.11.2" href="../contents.html" />
-    <link rel="up" title="An in-depth look at the cpp-netlib" href="../in_depth.html" />
-    <link rel="next" title="Techniques" href="../techniques.html" />
-    <link rel="prev" title="The URI class" href="uri.html" />
-<link rel="stylesheet" href="http://fonts.googleapis.com/css?family=Neuton&amp;subset=latin" type="text/css" media="screen" charset="utf-8" />
-<link rel="stylesheet" href="http://fonts.googleapis.com/css?family=Nobile:regular,italic,bold,bolditalic&amp;subset=latin" type="text/css" media="screen" charset="utf-8" />
-<!--[if lte IE 6]>
-<link rel="stylesheet" href="../_static/ie6.css" type="text/css" media="screen" charset="utf-8" />
-<![endif]-->
-
-  </head>
-  <body role="document">
-
-    <div class="related" role="navigation" aria-label="related navigation">
-      <h3>Navigation</h3>
-      <ul>
-        <li class="right" style="margin-right: 10px">
-          <a href="../techniques.html" title="Techniques"
-             accesskey="N">next</a></li>
-        <li class="right" >
-          <a href="uri.html" title="The URI class"
-             accesskey="P">previous</a> |</li>
-        <li class="nav-item nav-item-0"><a href="../contents.html">cpp-netlib v0.11.2</a> &raquo;</li>
-          <li class="nav-item nav-item-1"><a href="../in_depth.html" accesskey="U">An in-depth look at the <code class="docutils literal"><span class="pre">cpp-netlib</span></code></a> &raquo;</li> 
-      </ul>
-    </div>  
-
-    <div class="document">
-      <div class="documentwrapper">
-        <div class="bodywrapper">
-          <div class="body" role="main">
-            
-  <div class="section" id="http-implementation">
-<h1>HTTP implementation<a class="headerlink" href="#http-implementation" title="Permalink to this headline">¶</a></h1>
-<div class="section" id="http-client">
-<h2>HTTP client<a class="headerlink" href="#http-client" title="Permalink to this headline">¶</a></h2>
-<p>At the heart of the HTTP client implementation is a single class aptly named
-<code class="docutils literal"><span class="pre">basic_client</span></code>, which is also a template. The template <code class="docutils literal"><span class="pre">basic_client</span></code> takes
-three template parameters:</p>
-<div class="highlight-c++"><div class="highlight"><pre><span></span><span class="k">namespace</span> <span class="n">boost</span> <span class="p">{</span> <span class="k">namespace</span> <span class="n">http</span> <span class="p">{</span>
-
-    <span class="k">template</span> <span class="o">&lt;</span><span class="k">class</span> <span class="nc">Tag</span><span class="p">,</span> <span class="kt">unsigned</span> <span class="n">version_major</span><span class="p">,</span> <span class="kt">unsigned</span> <span class="n">version_minor</span><span class="o">&gt;</span>
-    <span class="k">struct</span> <span class="n">basic_client</span><span class="p">;</span>
-
-<span class="p">}</span> <span class="c1">// namespace http</span>
-
-<span class="p">}</span> <span class="c1">// namespace boost</span>
-</pre></div>
-</div>
-<p>The <code class="docutils literal"><span class="pre">Tag</span></code> template parameter follows the same tag-dispatch mechanism to
-determine the behavior of the <code class="docutils literal"><span class="pre">basic_client</span></code>. The interface of
-<code class="docutils literal"><span class="pre">basic_client</span></code> may change depending on certain properties defined for the tag
-you provide. Below is a table of predefined supported tags you can use in your
-overload of the <code class="docutils literal"><span class="pre">basic_client</span></code>:</p>
-<hr class="docutils" />
-<table border="1" class="docutils">
-<colgroup>
-<col width="42%" />
-<col width="58%" />
-</colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head">Tag</th>
-<th class="head">Description</th>
-</tr>
-</thead>
-<tbody valign="top">
-<tr class="row-even"><td>http_default_8bit_tcp_resolve</td>
-<td>This is the default HTTP implementation tag
-that resolves addresses with a TCP resolver
-and provides a synchronous/blocking HTTP
-client interface.</td>
-</tr>
-<tr class="row-odd"><td>http_default_8bit_udp_resolve</td>
-<td>This is similar to the above tag except that
-it specifies the HTTP client to use a UDP
-resolver. It also provides a synchronous/
-blocking HTTP client interface.</td>
-</tr>
-<tr class="row-even"><td>http_keepalive_8bit_tcp_resolve</td>
-<td>This tag specifies that the HTTP client by
-default will keep connections to the server
-alive. It only makes sense if the
-<code class="docutils literal"><span class="pre">version_major</span></code> and <code class="docutils literal"><span class="pre">version_minor</span></code> are
-both <code class="docutils literal"><span class="pre">1</span></code>, to indicate HTTP 1.1. This tag
-causes the HTTP client to resolve using a
-TCP resolver and provides a synchronous/
-blocking HTTP client interface.</td>
-</tr>
-<tr class="row-odd"><td>http_keepalive_8bit_udp_resolve</td>
-<td>This is similar to the above tag except that
-it specifies the HTTP client to use a UDP
-resolver. It also provides a synchronous/
-blocking HTTP client interface.</td>
-</tr>
-<tr class="row-even"><td>http_async_8bit_tcp_resolve</td>
-<td>This tag provides an active HTTP client
-object implementation that uses a TCP
-resolver. Response objects returned will
-encapsulate a number of <a class="reference external" href="http://www.boost.org/libs/thread">Boost.Thread</a>
-shared futures to hold values. Users don&#8217;t
-have to see this as they are implementation
-details.</td>
-</tr>
-<tr class="row-odd"><td>http_async_8bit_udp_resolve</td>
-<td>This is similar to the above tag except that
-specifies the HTTP client to use a UDP
-resolver.</td>
-</tr>
-</tbody>
-</table>
-<p>The default typedef for the HTTP client that is provided uses the
-<code class="docutils literal"><span class="pre">http_async_8bit_udp_resolve</span></code> tag, and implements HTTP 1.1. The exact
-typedef is in the <code class="docutils literal"><span class="pre">boost::network::http</span></code> namespace as the following:</p>
-<div class="highlight-c++"><div class="highlight"><pre><span></span><span class="k">namespace</span> <span class="n">boost</span> <span class="p">{</span> <span class="k">namespace</span> <span class="n">network</span> <span class="p">{</span> <span class="k">namespace</span> <span class="n">http</span> <span class="p">{</span>
-
-    <span class="k">typedef</span> <span class="n">basic_client</span><span class="o">&lt;</span><span class="n">tags</span><span class="o">::</span><span class="n">http_async_8bit_udp_resolve</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span> <span class="mi">1</span><span class="o">&gt;</span>
-        <span class="n">client</span><span class="p">;</span>
-
-<span class="p">}}}</span>
-</pre></div>
-</div>
-<p>This type has nested typedefs for the correct types for the <code class="docutils literal"><span class="pre">basic_request</span></code>
-and <code class="docutils literal"><span class="pre">basic_response</span></code> templates. To use the correct types for <code class="docutils literal"><span class="pre">basic_request</span></code>
-or <code class="docutils literal"><span class="pre">basic_response</span></code> you can use these nested typedefs like so:</p>
-<div class="highlight-c++"><div class="highlight"><pre><span></span><span class="n">boost</span><span class="o">::</span><span class="n">network</span><span class="o">::</span><span class="n">http</span><span class="o">::</span><span class="n">client</span><span class="o">::</span><span class="n">request</span> <span class="n">request</span><span class="p">;</span>
-<span class="n">boost</span><span class="o">::</span><span class="n">network</span><span class="o">::</span><span class="n">http</span><span class="o">::</span><span class="n">client</span><span class="o">::</span><span class="n">response</span> <span class="n">response</span><span class="p">;</span>
-
-<span class="c1">// or...</span>
-<span class="k">using</span> <span class="k">namespace</span> <span class="n">boost</span><span class="o">::</span><span class="n">network</span><span class="p">;</span>
-<span class="n">http</span><span class="o">::</span><span class="n">client</span><span class="o">::</span><span class="n">request</span> <span class="n">request</span><span class="p">;</span>
-<span class="n">http</span><span class="o">::</span><span class="n">client</span><span class="o">::</span><span class="n">response</span> <span class="n">response</span><span class="p">;</span>
-</pre></div>
-</div>
-<p>Typical use cases for the HTTP client would look something like the following:</p>
-<div class="highlight-c++"><div class="highlight"><pre><span></span><span class="k">using</span> <span class="k">namespace</span> <span class="n">boost</span><span class="o">::</span><span class="n">network</span><span class="p">;</span>
-<span class="n">http</span><span class="o">::</span><span class="n">request</span> <span class="n">request</span><span class="p">(</span><span class="s">&quot;http://www.boost.org/&quot;</span><span class="p">);</span>
-<span class="n">request</span> <span class="o">&lt;&lt;</span> <span class="n">header</span><span class="p">(</span><span class="s">&quot;Connection&quot;</span><span class="p">,</span> <span class="s">&quot;close&quot;</span><span class="p">);</span>
-</pre></div>
-</div>
-<p>The <code class="docutils literal"><span class="pre">basic_client</span></code> implements all HTTP methods as member functions
-(HEAD, GET, POST, PUT, DELETE).  Therefore, the code to make an HTTP
-request looks trivially simple:</p>
-<div class="highlight-c++"><div class="highlight"><pre><span></span><span class="k">using</span> <span class="k">namespace</span> <span class="n">boost</span><span class="o">::</span><span class="n">network</span><span class="p">;</span>
-<span class="n">http</span><span class="o">::</span><span class="n">client</span> <span class="n">client</span><span class="p">;</span>
-<span class="n">http</span><span class="o">::</span><span class="n">client</span><span class="o">::</span><span class="n">request</span> <span class="n">request</span><span class="p">(</span><span class="s">&quot;http://www.boost.org/&quot;</span><span class="p">);</span>
-<span class="n">http</span><span class="o">::</span><span class="n">client</span><span class="o">::</span><span class="n">response</span> <span class="n">response</span> <span class="o">=</span> <span class="n">client</span><span class="p">.</span><span class="n">get</span><span class="p">(</span><span class="n">request</span><span class="p">);</span>
-</pre></div>
-</div>
-<p>Accessing data from <code class="docutils literal"><span class="pre">http::response</span></code> is done using wrappers.
-To get the response headers, we use the <code class="docutils literal"><span class="pre">headers</span></code> wrapper which
-returns, in the default case, a multimap of strings to strings:</p>
-<div class="highlight-c++"><div class="highlight"><pre><span></span><span class="k">using</span> <span class="k">namespace</span> <span class="n">boost</span><span class="o">::</span><span class="n">network</span><span class="p">;</span>
-<span class="k">typedef</span> <span class="n">headers_range</span><span class="o">&lt;</span><span class="n">http_client</span><span class="o">::</span><span class="n">response</span><span class="o">&gt;::</span><span class="n">type</span> <span class="n">response_headers</span><span class="p">;</span>
-<span class="n">boost</span><span class="o">::</span><span class="n">range_iterator</span><span class="o">&lt;</span><span class="n">response_headers</span><span class="o">&gt;::</span><span class="n">type</span> <span class="n">iterator</span><span class="p">;</span>
-
-<span class="n">response_headers</span> <span class="n">headers_</span> <span class="o">=</span> <span class="n">headers</span><span class="p">(</span><span class="n">response</span><span class="p">);</span>
-<span class="k">for</span> <span class="p">(</span><span class="n">iterator</span> <span class="n">it</span> <span class="o">=</span> <span class="n">headers_</span><span class="p">.</span><span class="n">begin</span><span class="p">();</span> <span class="n">it</span> <span class="o">!=</span> <span class="n">headers_</span><span class="p">.</span><span class="n">end</span><span class="p">();</span> <span class="o">++</span><span class="n">it</span><span class="p">)</span> <span class="p">{</span>
-    <span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="n">it</span><span class="o">-&gt;</span><span class="n">first</span> <span class="o">&lt;&lt;</span> <span class="s">&quot;: &quot;</span> <span class="o">&lt;&lt;</span> <span class="n">it</span><span class="o">-&gt;</span><span class="n">second</span> <span class="o">&lt;&lt;</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
-<span class="p">}</span>
-<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
-</pre></div>
-</div>
-</div>
-<div class="section" id="http-server">
-<h2>HTTP server<a class="headerlink" href="#http-server" title="Permalink to this headline">¶</a></h2>
-<p>As with the HTTP client, the HTTP server that is provided with
-cpp-netlib is extensible through the tag mechanism and is embeddable.
-The template class declaration of <code class="docutils literal"><span class="pre">basic_server</span></code> is given below:</p>
-<div class="highlight-c++"><div class="highlight"><pre><span></span><span class="k">namespace</span> <span class="n">boost</span> <span class="p">{</span> <span class="k">namespace</span> <span class="n">network</span> <span class="p">{</span> <span class="k">namespace</span> <span class="n">http</span> <span class="p">{</span>
-
-    <span class="k">template</span> <span class="o">&lt;</span><span class="k">class</span> <span class="nc">Tag</span><span class="p">,</span> <span class="k">class</span> <span class="nc">RequestHandler</span><span class="o">&gt;</span> <span class="n">basic_server</span><span class="p">;</span>
-
-<span class="p">}}}</span>
-</pre></div>
-</div>
-<p>The second template argument is used to specify the request handler
-type. The request handler type is a functor type which should overload
-the function call operator (<code class="docutils literal"><span class="pre">RequestHandler::operator()</span></code> should be
-overloaded) that takes two parameters: the first one being a reference
-to a <code class="docutils literal"><span class="pre">const</span> <span class="pre">basic_request&lt;Tag&gt;</span></code> and the second being a reference to
-a <code class="docutils literal"><span class="pre">basic_response&lt;Tag&gt;</span></code> instance.</p>
-<p>All the logic for parsing the HTTP request and building the <code class="docutils literal"><span class="pre">const</span>
-<span class="pre">basic_request&lt;Tag&gt;</span></code> object resides internally in the <code class="docutils literal"><span class="pre">basic_server</span></code>
-template.  Processing the request is delegated to the
-<code class="docutils literal"><span class="pre">RequestHandler</span></code> type, and the assumption of which would be that the
-response is formed inside the <code class="docutils literal"><span class="pre">RequestHandler</span></code> function call
-operator overload.</p>
-<p>The <code class="docutils literal"><span class="pre">basic_server</span></code> template however is only an underlying
-implementation while the user-visible implementation is the
-<code class="docutils literal"><span class="pre">http::server</span></code> template. This simply specializes the
-<code class="docutils literal"><span class="pre">basic_server</span></code> template to use the <code class="docutils literal"><span class="pre">default_</span></code> tag and forwards the
-<code class="docutils literal"><span class="pre">RequestHandler</span></code> parameter:</p>
-<div class="highlight-c++"><div class="highlight"><pre><span></span><span class="k">namespace</span> <span class="n">boost</span> <span class="p">{</span> <span class="k">namespace</span> <span class="n">network</span> <span class="p">{</span> <span class="k">namespace</span> <span class="n">http</span> <span class="p">{</span>
-
-    <span class="k">template</span> <span class="o">&lt;</span><span class="k">class</span> <span class="nc">RequestHandler</span><span class="o">&gt;</span>
-    <span class="k">class</span> <span class="nc">server</span> <span class="o">:</span>
-        <span class="k">public</span> <span class="n">basic_server</span><span class="o">&lt;</span><span class="n">default_</span><span class="p">,</span> <span class="n">RequestHandler</span><span class="o">&gt;</span> <span class="p">{};</span>
-
-<span class="p">}}}</span>
-</pre></div>
-</div>
-<p>To use the forwarding server type you just supply the request handler
-implementation as the parameter. For example, an &#8220;echo&#8221; server example
-might look something like this:</p>
-<div class="highlight-c++"><div class="highlight"><pre><span></span><span class="k">using</span> <span class="k">namespace</span> <span class="n">boost</span><span class="o">::</span><span class="n">network</span><span class="p">;</span>
-<span class="k">struct</span> <span class="n">echo</span><span class="p">;</span>
-<span class="k">typedef</span> <span class="n">http</span><span class="o">::</span><span class="n">server</span><span class="o">&lt;</span><span class="n">echo</span><span class="o">&gt;</span> <span class="n">echo_server</span><span class="p">;</span>
-
-<span class="k">struct</span> <span class="n">echo</span> <span class="p">{</span>
-    <span class="kt">void</span> <span class="k">operator</span> <span class="p">()</span> <span class="p">(</span><span class="k">const</span> <span class="n">echo_server</span><span class="o">::</span><span class="n">request</span> <span class="o">&amp;</span><span class="n">request</span><span class="p">,</span>
-                      <span class="n">echo_server</span><span class="o">::</span><span class="n">response</span> <span class="o">&amp;</span><span class="n">response</span><span class="p">)</span> <span class="k">const</span> <span class="p">{</span>
-        <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">ip</span> <span class="o">=</span> <span class="n">source</span><span class="p">(</span><span class="n">request</span><span class="p">);</span>
-        <span class="n">response</span> <span class="o">=</span> <span class="n">echo_server</span><span class="o">::</span><span class="n">response</span><span class="o">::</span><span class="n">stock_reply</span><span class="p">(</span>
-            <span class="n">echo_server</span><span class="o">::</span><span class="n">response</span><span class="o">::</span><span class="n">ok</span><span class="p">,</span>
-            <span class="n">body</span><span class="p">(</span><span class="n">request</span><span class="p">));</span>
-        <span class="n">std</span><span class="o">::</span><span class="n">cerr</span> <span class="o">&lt;&lt;</span> <span class="s">&quot;[&quot;</span> <span class="o">&lt;&lt;</span> <span class="n">ip</span> <span class="o">&lt;&lt;</span> <span class="s">&quot;]: &quot;</span> <span class="o">&lt;&lt;</span> <span class="n">request</span><span class="p">.</span><span class="n">uri</span> <span class="o">&lt;&lt;</span>
-            <span class="s">&quot; status = &quot;</span> <span class="o">&lt;&lt;</span> <span class="n">echo_server</span><span class="o">::</span><span class="n">response</span><span class="o">::</span><span class="n">ok</span> <span class="o">&lt;&lt;</span> <span class="sc">&#39;\n&#39;</span><span class="p">;</span>
-    <span class="p">}</span>
-<span class="p">};</span>
-</pre></div>
-</div>
-<p>Here, all we&#8217;re doing is returning the original request body with an
-HTTP OK response (200). We are also printing the IP address from where the
-request came from. Notice that we are using a wrapper to access the source of
-the request.</p>
-</div>
-</div>
-
-
-          </div>
-        </div>
-      </div>
-      <div class="sphinxsidebar" role="navigation" aria-label="main navigation">
-        <div class="sphinxsidebarwrapper">
-  <h3><a href="../contents.html">Table Of Contents</a></h3>
-  <ul>
-<li><a class="reference internal" href="#">HTTP implementation</a><ul>
-<li><a class="reference internal" href="#http-client">HTTP client</a></li>
-<li><a class="reference internal" href="#http-server">HTTP server</a></li>
-</ul>
-</li>
-</ul>
-
-  <h4>Previous topic</h4>
-  <p class="topless"><a href="uri.html"
-                        title="previous chapter">The URI class</a></p>
-  <h4>Next topic</h4>
-  <p class="topless"><a href="../techniques.html"
-                        title="next chapter">Techniques</a></p>
-<div id="searchbox" style="display: none" role="search">
-  <h3>Quick search</h3>
-    <form class="search" action="../search.html" method="get">
-      <input type="text" name="q" />
-      <input type="submit" value="Go" />
-      <input type="hidden" name="check_keywords" value="yes" />
-      <input type="hidden" name="area" value="default" />
-    </form>
-    <p class="searchtip" style="font-size: 90%">
-    Enter search terms or a module, class or function name.
-    </p>
-</div>
-<script type="text/javascript">$('#searchbox').show(0);</script>
-        </div>
-      </div>
-      <div class="clearer"></div>
-    </div>
-    <div class="related" role="navigation" aria-label="related navigation">
-      <h3>Navigation</h3>
-      <ul>
-        <li class="right" style="margin-right: 10px">
-          <a href="../techniques.html" title="Techniques"
-             >next</a></li>
-        <li class="right" >
-          <a href="uri.html" title="The URI class"
-             >previous</a> |</li>
-        <li class="nav-item nav-item-0"><a href="../contents.html">cpp-netlib v0.11.2</a> &raquo;</li>
-          <li class="nav-item nav-item-1"><a href="../in_depth.html" >An in-depth look at the <code class="docutils literal"><span class="pre">cpp-netlib</span></code></a> &raquo;</li> 
-      </ul>
-    </div>
-    <div class="footer" role="contentinfo">
-        &copy; Copyright 2008-2014, Glyn Matthews, Dean Michael Berris; 2013 Google, Inc..
-      Last updated on Mar 07, 2016.
-      Created using <a href="http://sphinx-doc.org/">Sphinx</a> 1.3.6.
-    </div>
-  </body>
-</html>
\ No newline at end of file
diff --git a/libs/network/doc/html/in_depth/http_client_tags.html b/libs/network/doc/html/in_depth/http_client_tags.html
deleted file mode 100644
index e7f75be59..000000000
--- a/libs/network/doc/html/in_depth/http_client_tags.html
+++ /dev/null
@@ -1,139 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-
-
-<html xmlns="http://www.w3.org/1999/xhtml">
-  <head>
-    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-    
-    <title>&lt;no title&gt; &mdash; cpp-netlib v0.11.2</title>
-    
-    <link rel="stylesheet" href="../_static/pyramid.css" type="text/css" />
-    <link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
-    
-    <script type="text/javascript">
-      var DOCUMENTATION_OPTIONS = {
-        URL_ROOT:    '../',
-        VERSION:     '0.11.2',
-        COLLAPSE_INDEX: false,
-        FILE_SUFFIX: '.html',
-        HAS_SOURCE:  true
-      };
-    </script>
-    <script type="text/javascript" src="../_static/jquery.js"></script>
-    <script type="text/javascript" src="../_static/underscore.js"></script>
-    <script type="text/javascript" src="../_static/doctools.js"></script>
-    <link rel="top" title="cpp-netlib v0.11.2" href="../contents.html" />
-<link rel="stylesheet" href="http://fonts.googleapis.com/css?family=Neuton&amp;subset=latin" type="text/css" media="screen" charset="utf-8" />
-<link rel="stylesheet" href="http://fonts.googleapis.com/css?family=Nobile:regular,italic,bold,bolditalic&amp;subset=latin" type="text/css" media="screen" charset="utf-8" />
-<!--[if lte IE 6]>
-<link rel="stylesheet" href="../_static/ie6.css" type="text/css" media="screen" charset="utf-8" />
-<![endif]-->
-
-  </head>
-  <body role="document">
-
-    <div class="related" role="navigation" aria-label="related navigation">
-      <h3>Navigation</h3>
-      <ul>
-        <li class="nav-item nav-item-0"><a href="../contents.html">cpp-netlib v0.11.2</a> &raquo;</li> 
-      </ul>
-    </div>  
-
-    <div class="document">
-      <div class="documentwrapper">
-        <div class="bodywrapper">
-          <div class="body" role="main">
-            
-  <table border="1" class="docutils">
-<colgroup>
-<col width="42%" />
-<col width="58%" />
-</colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head">Tag</th>
-<th class="head">Description</th>
-</tr>
-</thead>
-<tbody valign="top">
-<tr class="row-even"><td>http_default_8bit_tcp_resolve</td>
-<td>This is the default HTTP implementation tag
-that resolves addresses with a TCP resolver
-and provides a synchronous/blocking HTTP
-client interface.</td>
-</tr>
-<tr class="row-odd"><td>http_default_8bit_udp_resolve</td>
-<td>This is similar to the above tag except that
-it specifies the HTTP client to use a UDP
-resolver. It also provides a synchronous/
-blocking HTTP client interface.</td>
-</tr>
-<tr class="row-even"><td>http_keepalive_8bit_tcp_resolve</td>
-<td>This tag specifies that the HTTP client by
-default will keep connections to the server
-alive. It only makes sense if the
-<code class="docutils literal"><span class="pre">version_major</span></code> and <code class="docutils literal"><span class="pre">version_minor</span></code> are
-both <code class="docutils literal"><span class="pre">1</span></code>, to indicate HTTP 1.1. This tag
-causes the HTTP client to resolve using a
-TCP resolver and provides a synchronous/
-blocking HTTP client interface.</td>
-</tr>
-<tr class="row-odd"><td>http_keepalive_8bit_udp_resolve</td>
-<td>This is similar to the above tag except that
-it specifies the HTTP client to use a UDP
-resolver. It also provides a synchronous/
-blocking HTTP client interface.</td>
-</tr>
-<tr class="row-even"><td>http_async_8bit_tcp_resolve</td>
-<td>This tag provides an active HTTP client
-object implementation that uses a TCP
-resolver. Response objects returned will
-encapsulate a number of <a class="reference external" href="http://www.boost.org/libs/thread">Boost.Thread</a>
-shared futures to hold values. Users don&#8217;t
-have to see this as they are implementation
-details.</td>
-</tr>
-<tr class="row-odd"><td>http_async_8bit_udp_resolve</td>
-<td>This is similar to the above tag except that
-specifies the HTTP client to use a UDP
-resolver.</td>
-</tr>
-</tbody>
-</table>
-
-
-          </div>
-        </div>
-      </div>
-      <div class="sphinxsidebar" role="navigation" aria-label="main navigation">
-        <div class="sphinxsidebarwrapper">
-<div id="searchbox" style="display: none" role="search">
-  <h3>Quick search</h3>
-    <form class="search" action="../search.html" method="get">
-      <input type="text" name="q" />
-      <input type="submit" value="Go" />
-      <input type="hidden" name="check_keywords" value="yes" />
-      <input type="hidden" name="area" value="default" />
-    </form>
-    <p class="searchtip" style="font-size: 90%">
-    Enter search terms or a module, class or function name.
-    </p>
-</div>
-<script type="text/javascript">$('#searchbox').show(0);</script>
-        </div>
-      </div>
-      <div class="clearer"></div>
-    </div>
-    <div class="related" role="navigation" aria-label="related navigation">
-      <h3>Navigation</h3>
-      <ul>
-        <li class="nav-item nav-item-0"><a href="../contents.html">cpp-netlib v0.11.2</a> &raquo;</li> 
-      </ul>
-    </div>
-    <div class="footer" role="contentinfo">
-        &copy; Copyright 2008-2014, Glyn Matthews, Dean Michael Berris; 2013 Google, Inc..
-      Last updated on Mar 07, 2016.
-      Created using <a href="http://sphinx-doc.org/">Sphinx</a> 1.3.6.
-    </div>
-  </body>
-</html>
\ No newline at end of file
diff --git a/libs/network/doc/html/in_depth/message.html b/libs/network/doc/html/in_depth/message.html
deleted file mode 100644
index 8951f6e90..000000000
--- a/libs/network/doc/html/in_depth/message.html
+++ /dev/null
@@ -1,399 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-
-
-<html xmlns="http://www.w3.org/1999/xhtml">
-  <head>
-    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-    
-    <title>The message template &mdash; cpp-netlib v0.11.2</title>
-    
-    <link rel="stylesheet" href="../_static/pyramid.css" type="text/css" />
-    <link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
-    
-    <script type="text/javascript">
-      var DOCUMENTATION_OPTIONS = {
-        URL_ROOT:    '../',
-        VERSION:     '0.11.2',
-        COLLAPSE_INDEX: false,
-        FILE_SUFFIX: '.html',
-        HAS_SOURCE:  true
-      };
-    </script>
-    <script type="text/javascript" src="../_static/jquery.js"></script>
-    <script type="text/javascript" src="../_static/underscore.js"></script>
-    <script type="text/javascript" src="../_static/doctools.js"></script>
-    <link rel="top" title="cpp-netlib v0.11.2" href="../contents.html" />
-    <link rel="up" title="An in-depth look at the cpp-netlib" href="../in_depth.html" />
-    <link rel="next" title="The URI class" href="uri.html" />
-    <link rel="prev" title="An in-depth look at the cpp-netlib" href="../in_depth.html" />
-<link rel="stylesheet" href="http://fonts.googleapis.com/css?family=Neuton&amp;subset=latin" type="text/css" media="screen" charset="utf-8" />
-<link rel="stylesheet" href="http://fonts.googleapis.com/css?family=Nobile:regular,italic,bold,bolditalic&amp;subset=latin" type="text/css" media="screen" charset="utf-8" />
-<!--[if lte IE 6]>
-<link rel="stylesheet" href="../_static/ie6.css" type="text/css" media="screen" charset="utf-8" />
-<![endif]-->
-
-  </head>
-  <body role="document">
-
-    <div class="related" role="navigation" aria-label="related navigation">
-      <h3>Navigation</h3>
-      <ul>
-        <li class="right" style="margin-right: 10px">
-          <a href="uri.html" title="The URI class"
-             accesskey="N">next</a></li>
-        <li class="right" >
-          <a href="../in_depth.html" title="An in-depth look at the cpp-netlib"
-             accesskey="P">previous</a> |</li>
-        <li class="nav-item nav-item-0"><a href="../contents.html">cpp-netlib v0.11.2</a> &raquo;</li>
-          <li class="nav-item nav-item-1"><a href="../in_depth.html" accesskey="U">An in-depth look at the <code class="docutils literal"><span class="pre">cpp-netlib</span></code></a> &raquo;</li> 
-      </ul>
-    </div>  
-
-    <div class="document">
-      <div class="documentwrapper">
-        <div class="bodywrapper">
-          <div class="body" role="main">
-            
-  <div class="section" id="the-message-template">
-<h1>The message template<a class="headerlink" href="#the-message-template" title="Permalink to this headline">¶</a></h1>
-<p>One of the core components in the library is the concept and the
-implementation of a common message type. In most (not all) network
-protocols, the concept of a message is central to the definition of
-the protocol. In HTTP, SMTP, XMPP, and even other protocols like SNMP
-and ICMP, there is a common notion of a &#8220;packet&#8221; or a message. In
-cpp-netlib we chose to implement the concept of a message that has the
-following common parts:</p>
-<blockquote>
-<div><ul class="simple">
-<li><strong>Source</strong> - every message has a source identifier which varies
-from protocol to protocol.</li>
-<li><strong>Destination</strong> - every message has a destination identifier which
-varies from protocol to protocol.</li>
-<li><strong>Headers</strong> - each message is assumed to contain headers, which
-may be empty in cases where the protocol does not support it, but
-is nonetheless supported by cpp-netlib messages.</li>
-<li><strong>Body</strong> - the content area of a message which varies from
-protocol to protocol (also sometimes referred to as payload).</li>
-</ul>
-</div></blockquote>
-<p>This division is purely logical &#8211; in the underlying implementation,
-the message type can choose to have different means of storing the
-data, depending on the type used to tag the message. This section
-covers the <a class="reference internal" href="#message-concept">Message Concept</a> as well as the <a class="reference internal" href="#basic-message">basic_message</a>
-implementation.</p>
-<div class="section" id="message-concept">
-<h2>Message Concept<a class="headerlink" href="#message-concept" title="Permalink to this headline">¶</a></h2>
-<div class="admonition warning">
-<p class="first admonition-title">Warning</p>
-<p class="last">The Message framework is deprecated in the 0.11 release, and will
-be removed in future versions of the library.</p>
-</div>
-<p>The Message Concept specifies what the valid operations on a message
-are as well as what messages look like semantically. The following
-table summarize the operations and syntactic as well as semantic
-properties of messages.</p>
-<p><strong>Legend</strong></p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field-odd field"><th class="field-name">M:</th><td class="field-body">The message type.</td>
-</tr>
-<tr class="field-even field"><th class="field-name">H:</th><td class="field-body">A headers container type.</td>
-</tr>
-<tr class="field-odd field"><th class="field-name">m,n:</th><td class="field-body">An instance of <strong>M</strong>.</td>
-</tr>
-<tr class="field-even field"><th class="field-name">S:</th><td class="field-body">A string type.</td>
-</tr>
-<tr class="field-odd field"><th class="field-name">s,k,v:</th><td class="field-body">An instance of <strong>S</strong>.</td>
-</tr>
-<tr class="field-even field"><th class="field-name">O:</th><td class="field-body">The source type.</td>
-</tr>
-<tr class="field-odd field"><th class="field-name">D:</th><td class="field-body">The destination type.</td>
-</tr>
-<tr class="field-even field"><th class="field-name">B:</th><td class="field-body">The body type.</td>
-</tr>
-<tr class="field-odd field"><th class="field-name">T:</th><td class="field-body">The Tag type.</td>
-</tr>
-</tbody>
-</table>
-<table border="1" class="docutils">
-<colgroup>
-<col width="31%" />
-<col width="24%" />
-<col width="45%" />
-</colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head">Construct</th>
-<th class="head">Result</th>
-<th class="head">Description</th>
-</tr>
-</thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal"><span class="pre">typename</span> <span class="pre">M::tag</span></code></td>
-<td>T</td>
-<td>The nested tag type.</td>
-</tr>
-<tr class="row-odd"><td><code class="docutils literal"><span class="pre">M()</span></code></td>
-<td>Instance of M</td>
-<td>Default constructible.</td>
-</tr>
-<tr class="row-even"><td><code class="docutils literal"><span class="pre">M(m)</span></code></td>
-<td>Instance of M</td>
-<td>Copy constructible.</td>
-</tr>
-<tr class="row-odd"><td><code class="docutils literal"><span class="pre">m</span> <span class="pre">=</span> <span class="pre">n;</span></code></td>
-<td>Reference to m</td>
-<td>Assignable.</td>
-</tr>
-<tr class="row-even"><td><code class="docutils literal"><span class="pre">swap(m,</span> <span class="pre">n);</span></code></td>
-<td><code class="docutils literal"><span class="pre">void</span></code></td>
-<td>Swappable.</td>
-</tr>
-<tr class="row-odd"><td><code class="docutils literal"><span class="pre">source(m);</span></code></td>
-<td>Convertible to O</td>
-<td>Retrieve the source of <code class="docutils literal"><span class="pre">m</span></code>.</td>
-</tr>
-<tr class="row-even"><td><code class="docutils literal"><span class="pre">destination(m);</span></code></td>
-<td>Convertible to D</td>
-<td>Retrieve the destination of <code class="docutils literal"><span class="pre">m</span></code>.</td>
-</tr>
-<tr class="row-odd"><td><code class="docutils literal"><span class="pre">headers(m);</span></code></td>
-<td>Convertible to H</td>
-<td>Retrieve the headers of <code class="docutils literal"><span class="pre">m</span></code>.</td>
-</tr>
-<tr class="row-even"><td><code class="docutils literal"><span class="pre">body(m);</span></code></td>
-<td>Convertible to B</td>
-<td>Retrieve the body of <code class="docutils literal"><span class="pre">m</span></code>.</td>
-</tr>
-<tr class="row-odd"><td><code class="docutils literal"><span class="pre">m</span> <span class="pre">&lt;&lt;</span> <span class="pre">source(s);</span></code></td>
-<td><code class="docutils literal"><span class="pre">M</span> <span class="pre">&amp;</span></code></td>
-<td>Set the source of <code class="docutils literal"><span class="pre">m</span></code>.</td>
-</tr>
-<tr class="row-even"><td><code class="docutils literal"><span class="pre">m</span> <span class="pre">&lt;&lt;</span> <span class="pre">destination(s);</span></code></td>
-<td><code class="docutils literal"><span class="pre">M</span> <span class="pre">&amp;</span></code></td>
-<td>Set the destination of <code class="docutils literal"><span class="pre">m</span></code>.</td>
-</tr>
-<tr class="row-odd"><td><code class="docutils literal"><span class="pre">m</span> <span class="pre">&lt;&lt;</span> <span class="pre">header(k,</span> <span class="pre">v);</span></code></td>
-<td><code class="docutils literal"><span class="pre">M</span> <span class="pre">&amp;</span></code></td>
-<td>Add a header to <code class="docutils literal"><span class="pre">m</span></code>.</td>
-</tr>
-<tr class="row-even"><td><code class="docutils literal"><span class="pre">m</span> <span class="pre">&lt;&lt;</span> <span class="pre">remove_header(k);</span></code></td>
-<td><code class="docutils literal"><span class="pre">M</span> <span class="pre">&amp;</span></code></td>
-<td>Remove a header from <code class="docutils literal"><span class="pre">m</span></code>.</td>
-</tr>
-<tr class="row-odd"><td><code class="docutils literal"><span class="pre">m</span> <span class="pre">&lt;&lt;</span> <span class="pre">body(s);</span></code></td>
-<td><code class="docutils literal"><span class="pre">M</span> <span class="pre">&amp;</span></code></td>
-<td>Set the body of <code class="docutils literal"><span class="pre">m</span></code>.</td>
-</tr>
-<tr class="row-even"><td><code class="docutils literal"><span class="pre">source(m,s);</span></code></td>
-<td><code class="docutils literal"><span class="pre">void</span></code></td>
-<td>Set the source of <code class="docutils literal"><span class="pre">m</span></code>.</td>
-</tr>
-<tr class="row-odd"><td><code class="docutils literal"><span class="pre">destination(m,s);</span></code></td>
-<td><code class="docutils literal"><span class="pre">void</span></code></td>
-<td>Set the destination of <code class="docutils literal"><span class="pre">m</span></code>.</td>
-</tr>
-<tr class="row-even"><td><code class="docutils literal"><span class="pre">add_header(m,</span> <span class="pre">k,</span> <span class="pre">v);</span></code></td>
-<td><code class="docutils literal"><span class="pre">void</span></code></td>
-<td>Add a header to <code class="docutils literal"><span class="pre">m</span></code>.</td>
-</tr>
-<tr class="row-odd"><td><code class="docutils literal"><span class="pre">remove_header(m,</span> <span class="pre">k);</span></code></td>
-<td><code class="docutils literal"><span class="pre">void</span></code></td>
-<td>Remove a header from <code class="docutils literal"><span class="pre">m</span></code>.</td>
-</tr>
-<tr class="row-even"><td><code class="docutils literal"><span class="pre">clear_headers(m);</span></code></td>
-<td><code class="docutils literal"><span class="pre">void</span></code></td>
-<td>Clear the headers of <code class="docutils literal"><span class="pre">m</span></code>.</td>
-</tr>
-<tr class="row-odd"><td><code class="docutils literal"><span class="pre">body(m,s);</span></code></td>
-<td><code class="docutils literal"><span class="pre">M</span> <span class="pre">&amp;</span></code></td>
-<td>Set the body of <code class="docutils literal"><span class="pre">m</span></code>.</td>
-</tr>
-</tbody>
-</table>
-<p>Types that model the Message Concept are meant to encapsulate data
-that has a source, a destination, one or more named headers, and a
-body/payload. Because the accessors and the directives are not
-required to be part of the message type that models the Message
-Concept, a message can be implemented as a POD type and have all
-manipulations performed in the directive implementations, as well as
-value transformations done in the accessors.</p>
-</div>
-<div class="section" id="directives-modifiers-and-wrappers">
-<h2>Directives, Modifiers, and Wrappers<a class="headerlink" href="#directives-modifiers-and-wrappers" title="Permalink to this headline">¶</a></h2>
-<p>In the Message Concept definition there are three basic constructs that follow a
-certain pattern. These patterns are <a class="reference internal" href="#directives">Directives</a>, <a class="reference internal" href="#modifiers">Modifiers</a>, and <a class="reference internal" href="#wrappers">Wrappers</a>.</p>
-<div class="section" id="directives">
-<h3>Directives<a class="headerlink" href="#directives" title="Permalink to this headline">¶</a></h3>
-<p>A directive is a function object that is applied to a Message. Directives
-encapsulate a set of operations that apply to messages. The general requirement
-for a Directive is that it should apply these operations on a message.</p>
-<p>A directive may dispatch on the type of the message passed to it at the point of
-the function call. Typically, directives are generated using a factory function
-that returns the correct directive type.</p>
-<p>For a given directive <code class="docutils literal"><span class="pre">foo_directive</span></code> a generator function called <code class="docutils literal"><span class="pre">foo</span></code> is
-typically implemented:</p>
-<div class="highlight-c++"><div class="highlight"><pre><span></span><span class="k">struct</span> <span class="n">foo_directive</span> <span class="p">{</span>
-    <span class="k">template</span> <span class="o">&lt;</span><span class="k">class</span> <span class="nc">Message</span><span class="o">&gt;</span>
-    <span class="n">Message</span> <span class="o">&amp;</span> <span class="k">operator</span><span class="p">()(</span><span class="n">Message</span> <span class="o">&amp;</span> <span class="n">m</span><span class="p">)</span> <span class="k">const</span> <span class="p">{</span>
-        <span class="c1">// do something to m</span>
-        <span class="k">return</span> <span class="n">m</span><span class="p">;</span>
-    <span class="p">}</span>
-<span class="p">};</span>
-
-<span class="n">foo_directive</span> <span class="k">const</span> <span class="nf">foo</span><span class="p">()</span> <span class="p">{</span>
-    <span class="k">return</span> <span class="n">foo_directive</span><span class="p">();</span>
-<span class="p">}</span>
-
-<span class="c1">// to apply a directive, we use the &lt;&lt; operator</span>
-<span class="n">message</span> <span class="n">m</span><span class="p">;</span>
-<span class="n">m</span> <span class="o">&lt;&lt;</span> <span class="n">foo</span><span class="p">();</span>
-</pre></div>
-</div>
-</div>
-<div class="section" id="modifiers">
-<h3>Modifiers<a class="headerlink" href="#modifiers" title="Permalink to this headline">¶</a></h3>
-<p>A modifier is generally defined as a free function that takes a reference to a
-non-const lvalue message as the first parameter, and any number of parameters.
-In the concept definition of the Message Concept, a modifier follows the form:</p>
-<div class="highlight-c++"><div class="highlight"><pre><span></span><span class="n">modifier</span><span class="p">(</span><span class="n">message</span><span class="p">,</span> <span class="p">...)</span>
-</pre></div>
-</div>
-<p>Modifiers are meant to imply modifications on a message, which also allows for
-easier dispatch based on Argument Dependent Lookup (<a class="reference external" href="http://en.wikipedia.org/wiki/Argument-dependent_name_lookup">ADL</a>) on the type of the
-message. Note that <a class="reference internal" href="#directives">Directives</a> can be implemented in terms of Modifiers and
-vice versa, although that is not required nor specified.</p>
-</div>
-<div class="section" id="wrappers">
-<h3>Wrappers<a class="headerlink" href="#wrappers" title="Permalink to this headline">¶</a></h3>
-<p>A Wrapper is basically an implementation detail that ensures that a given
-message, when wrapped, can be converted to the associated part of the message. A
-wrapper has a type that encapsulates the conversion logic from a message to a
-given type.</p>
-<p>An example of a Wrapper would be <code class="docutils literal"><span class="pre">source_wrapper</span></code> which would be returned by a
-call to the wrapper generator function <code class="docutils literal"><span class="pre">source</span></code>. An example implementation of
-the <code class="docutils literal"><span class="pre">source_wrapper</span></code> would look like:</p>
-<div class="highlight-c++"><div class="highlight"><pre><span></span><span class="k">template</span> <span class="o">&lt;</span><span class="k">class</span> <span class="nc">Tag</span><span class="p">,</span> <span class="k">template</span> <span class="o">&lt;</span><span class="n">class</span><span class="o">&gt;</span> <span class="k">class</span> <span class="nc">Message</span><span class="o">&gt;</span>
-<span class="k">struct</span> <span class="n">source_wrapper</span> <span class="p">{</span>
-    <span class="n">Message</span><span class="o">&lt;</span><span class="n">Tag</span><span class="o">&gt;</span> <span class="k">const</span> <span class="o">&amp;</span> <span class="n">m</span><span class="p">;</span>
-    <span class="k">explicit</span> <span class="nf">source_wrapper</span><span class="p">(</span><span class="n">Message</span><span class="o">&lt;</span><span class="n">Tag</span><span class="o">&gt;</span> <span class="k">const</span> <span class="o">&amp;</span> <span class="n">m</span><span class="p">)</span>
-    <span class="o">:</span> <span class="n">m</span><span class="p">(</span><span class="n">m</span><span class="p">)</span> <span class="p">{}</span>
-    <span class="k">typedef</span> <span class="k">typename</span> <span class="n">source</span><span class="o">&lt;</span><span class="n">Tag</span><span class="o">&gt;::</span><span class="n">type</span> <span class="n">source_type</span><span class="p">;</span>
-    <span class="k">operator</span> <span class="n">source_type</span> <span class="k">const</span> <span class="o">&amp;</span> <span class="p">()</span> <span class="p">{</span>
-        <span class="k">return</span> <span class="n">m</span><span class="p">.</span><span class="n">source</span><span class="p">;</span>
-    <span class="p">}</span>
-    <span class="k">operator</span> <span class="n">source_type</span> <span class="k">const</span> <span class="p">()</span> <span class="p">{</span>
-        <span class="k">return</span> <span class="n">m</span><span class="p">.</span><span class="n">source</span><span class="p">;</span>
-    <span class="p">}</span>
-    <span class="k">operator</span> <span class="n">source_type</span> <span class="p">()</span> <span class="p">{</span>
-        <span class="k">return</span> <span class="n">m</span><span class="p">.</span><span class="n">source</span><span class="p">;</span>
-    <span class="p">}</span>
-<span class="p">};</span>
-
-<span class="k">template</span> <span class="o">&lt;</span><span class="k">class</span> <span class="nc">Tag</span><span class="p">,</span> <span class="k">template</span> <span class="o">&lt;</span><span class="n">class</span><span class="o">&gt;</span> <span class="k">class</span> <span class="nc">Message</span><span class="o">&gt;</span>
-<span class="n">source_wrapper</span><span class="o">&lt;</span><span class="n">Tag</span><span class="p">,</span> <span class="n">Message</span><span class="o">&gt;</span> <span class="k">const</span>
-<span class="n">source</span><span class="p">(</span><span class="n">Message</span><span class="o">&lt;</span><span class="n">Tag</span><span class="o">&gt;</span> <span class="k">const</span> <span class="o">&amp;</span> <span class="n">message</span><span class="p">)</span> <span class="p">{</span>
-    <span class="k">return</span> <span class="n">source_wrapper</span><span class="o">&lt;</span><span class="n">Tag</span><span class="p">,</span> <span class="n">Message</span><span class="o">&gt;</span><span class="p">(</span><span class="n">message</span><span class="p">);</span>
-<span class="p">}</span>
-</pre></div>
-</div>
-<p>This pattern is similar to an adapter, but the specific notion of wrapping a
-data type (in this case, an object of a type that models the Message Concept)
-using an intermediary wrapper is what is pertained to by the Wrapper pattern.
-In this case, the Wrapper is <code class="docutils literal"><span class="pre">source_wrapper</span></code> while <code class="docutils literal"><span class="pre">source</span></code> is merely a
-wrapper generator function.</p>
-</div>
-</div>
-<div class="section" id="basic-message">
-<h2><code class="docutils literal"><span class="pre">basic_message</span></code><a class="headerlink" href="#basic-message" title="Permalink to this headline">¶</a></h2>
-<p>The default implementation of a simple type that models the Message
-Concept is available in cpp-netlib. This default implementation is
-named <code class="docutils literal"><span class="pre">basic_message</span></code> which supports a <code class="docutils literal"><span class="pre">Tag</span></code> template
-parameter. The definition of <code class="docutils literal"><span class="pre">basic_message</span></code> looks like this:</p>
-<div class="highlight-c++"><div class="highlight"><pre><span></span><span class="k">template</span> <span class="o">&lt;</span><span class="k">class</span> <span class="nc">Tag</span><span class="o">&gt;</span>
-<span class="k">class</span> <span class="nc">basic_message</span><span class="p">;</span>
-</pre></div>
-</div>
-<p>The <code class="docutils literal"><span class="pre">basic_message</span></code> template requires that the following
-tag-dispatched metafunctions are defined for the type <code class="docutils literal"><span class="pre">Tag</span></code>:</p>
-<div class="highlight-c++"><div class="highlight"><pre><span></span><span class="k">template</span> <span class="o">&lt;</span><span class="k">class</span> <span class="nc">Tag</span><span class="o">&gt;</span>
-<span class="k">struct</span> <span class="n">string</span><span class="p">;</span>
-
-<span class="k">template</span> <span class="o">&lt;</span><span class="k">class</span> <span class="nc">Tag</span><span class="o">&gt;</span>
-<span class="k">struct</span> <span class="n">headers_container</span><span class="p">;</span>
-</pre></div>
-</div>
-<p>All the operations defined by the message concept are implemented by
-this basic message type. Other message implementations can either use
-this common message type or specialize it according to whether they
-want to use different containers or whether it&#8217;s going to be just a
-POD type.</p>
-</div>
-</div>
-
-
-          </div>
-        </div>
-      </div>
-      <div class="sphinxsidebar" role="navigation" aria-label="main navigation">
-        <div class="sphinxsidebarwrapper">
-  <h3><a href="../contents.html">Table Of Contents</a></h3>
-  <ul>
-<li><a class="reference internal" href="#">The message template</a><ul>
-<li><a class="reference internal" href="#message-concept">Message Concept</a></li>
-<li><a class="reference internal" href="#directives-modifiers-and-wrappers">Directives, Modifiers, and Wrappers</a><ul>
-<li><a class="reference internal" href="#directives">Directives</a></li>
-<li><a class="reference internal" href="#modifiers">Modifiers</a></li>
-<li><a class="reference internal" href="#wrappers">Wrappers</a></li>
-</ul>
-</li>
-<li><a class="reference internal" href="#basic-message"><code class="docutils literal"><span class="pre">basic_message</span></code></a></li>
-</ul>
-</li>
-</ul>
-
-  <h4>Previous topic</h4>
-  <p class="topless"><a href="../in_depth.html"
-                        title="previous chapter">An in-depth look at the <code class="docutils literal"><span class="pre">cpp-netlib</span></code></a></p>
-  <h4>Next topic</h4>
-  <p class="topless"><a href="uri.html"
-                        title="next chapter">The URI class</a></p>
-<div id="searchbox" style="display: none" role="search">
-  <h3>Quick search</h3>
-    <form class="search" action="../search.html" method="get">
-      <input type="text" name="q" />
-      <input type="submit" value="Go" />
-      <input type="hidden" name="check_keywords" value="yes" />
-      <input type="hidden" name="area" value="default" />
-    </form>
-    <p class="searchtip" style="font-size: 90%">
-    Enter search terms or a module, class or function name.
-    </p>
-</div>
-<script type="text/javascript">$('#searchbox').show(0);</script>
-        </div>
-      </div>
-      <div class="clearer"></div>
-    </div>
-    <div class="related" role="navigation" aria-label="related navigation">
-      <h3>Navigation</h3>
-      <ul>
-        <li class="right" style="margin-right: 10px">
-          <a href="uri.html" title="The URI class"
-             >next</a></li>
-        <li class="right" >
-          <a href="../in_depth.html" title="An in-depth look at the cpp-netlib"
-             >previous</a> |</li>
-        <li class="nav-item nav-item-0"><a href="../contents.html">cpp-netlib v0.11.2</a> &raquo;</li>
-          <li class="nav-item nav-item-1"><a href="../in_depth.html" >An in-depth look at the <code class="docutils literal"><span class="pre">cpp-netlib</span></code></a> &raquo;</li> 
-      </ul>
-    </div>
-    <div class="footer" role="contentinfo">
-        &copy; Copyright 2008-2014, Glyn Matthews, Dean Michael Berris; 2013 Google, Inc..
-      Last updated on Mar 07, 2016.
-      Created using <a href="http://sphinx-doc.org/">Sphinx</a> 1.3.6.
-    </div>
-  </body>
-</html>
\ No newline at end of file
diff --git a/libs/network/doc/html/in_depth/uri.html b/libs/network/doc/html/in_depth/uri.html
deleted file mode 100644
index fc59ce7d0..000000000
--- a/libs/network/doc/html/in_depth/uri.html
+++ /dev/null
@@ -1,295 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-
-
-<html xmlns="http://www.w3.org/1999/xhtml">
-  <head>
-    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-    
-    <title>The URI class &mdash; cpp-netlib v0.11.2</title>
-    
-    <link rel="stylesheet" href="../_static/pyramid.css" type="text/css" />
-    <link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
-    
-    <script type="text/javascript">
-      var DOCUMENTATION_OPTIONS = {
-        URL_ROOT:    '../',
-        VERSION:     '0.11.2',
-        COLLAPSE_INDEX: false,
-        FILE_SUFFIX: '.html',
-        HAS_SOURCE:  true
-      };
-    </script>
-    <script type="text/javascript" src="../_static/jquery.js"></script>
-    <script type="text/javascript" src="../_static/underscore.js"></script>
-    <script type="text/javascript" src="../_static/doctools.js"></script>
-    <link rel="top" title="cpp-netlib v0.11.2" href="../contents.html" />
-    <link rel="up" title="An in-depth look at the cpp-netlib" href="../in_depth.html" />
-    <link rel="next" title="HTTP implementation" href="http.html" />
-    <link rel="prev" title="The message template" href="message.html" />
-<link rel="stylesheet" href="http://fonts.googleapis.com/css?family=Neuton&amp;subset=latin" type="text/css" media="screen" charset="utf-8" />
-<link rel="stylesheet" href="http://fonts.googleapis.com/css?family=Nobile:regular,italic,bold,bolditalic&amp;subset=latin" type="text/css" media="screen" charset="utf-8" />
-<!--[if lte IE 6]>
-<link rel="stylesheet" href="../_static/ie6.css" type="text/css" media="screen" charset="utf-8" />
-<![endif]-->
-
-  </head>
-  <body role="document">
-
-    <div class="related" role="navigation" aria-label="related navigation">
-      <h3>Navigation</h3>
-      <ul>
-        <li class="right" style="margin-right: 10px">
-          <a href="http.html" title="HTTP implementation"
-             accesskey="N">next</a></li>
-        <li class="right" >
-          <a href="message.html" title="The message template"
-             accesskey="P">previous</a> |</li>
-        <li class="nav-item nav-item-0"><a href="../contents.html">cpp-netlib v0.11.2</a> &raquo;</li>
-          <li class="nav-item nav-item-1"><a href="../in_depth.html" accesskey="U">An in-depth look at the <code class="docutils literal"><span class="pre">cpp-netlib</span></code></a> &raquo;</li> 
-      </ul>
-    </div>  
-
-    <div class="document">
-      <div class="documentwrapper">
-        <div class="bodywrapper">
-          <div class="body" role="main">
-            
-  <div class="section" id="the-uri-class">
-<h1>The URI class<a class="headerlink" href="#the-uri-class" title="Permalink to this headline">¶</a></h1>
-<p>In addition to protocol implementations, the <code class="xref py py-mod docutils literal"><span class="pre">cpp-netlib</span></code>
-provides a powerful URI class.  The class implements a parser based
-on <a class="reference external" href="http://tools.ietf.org/html/rfc3986">RFC 3986</a> and <a class="reference external" href="http://tools.ietf.org/html/rfc2732">RFC 2732</a>.</p>
-<div class="section" id="generic-uri-syntax-overview">
-<h2>Generic URI syntax overview<a class="headerlink" href="#generic-uri-syntax-overview" title="Permalink to this headline">¶</a></h2>
-<p>A generic URI will take the form:</p>
-<div class="highlight-python"><div class="highlight"><pre><span></span>[scheme:]scheme-specific-part[#fragment]
-</pre></div>
-</div>
-<p>A URI is known as <cite>absolute</cite> if it specifies the scheme.  Otherwise,
-it is known as a relative URI.  Currently, <code class="docutils literal"><span class="pre">uri</span></code> supports only
-absolute URIs.</p>
-<p>URIs can be further classified according to whether they&#8217;re
-hierarchical or opaque (non-hierarchical).</p>
-<p>Some examples of non-hierarchical URIs include:</p>
-<div class="highlight-python"><div class="highlight"><pre><span></span>mailto:john.doe@example.com
-news:comp.infosystems.www.servers.unix
-tel:+1-816-555-1212
-</pre></div>
-</div>
-<p>The data following the first <code class="docutils literal"><span class="pre">&quot;:&quot;</span></code> is said to be opaque to the URI
-parser and requires no further parsing.  By way of example, the
-following shows how a non-hierarchical URI is processed by the parser
-by defining everything after the <code class="docutils literal"><span class="pre">&quot;:&quot;</span></code> to be a part of the path:</p>
-<img alt="../_images/mailto_uri.png" src="../_images/mailto_uri.png" />
-<p>A hierarchical URI is identified by a double slash (<code class="docutils literal"><span class="pre">&quot;//&quot;</span></code>) after
-the scheme and a scheme-specific component, which <a class="reference external" href="http://tools.ietf.org/html/rfc3986">RFC 3986</a> defines
-to be:</p>
-<div class="highlight-python"><div class="highlight"><pre><span></span>[scheme:][//authority][path][?query][#fragment]
-</pre></div>
-</div>
-<p>The authority component can be further broken down to:</p>
-<div class="highlight-python"><div class="highlight"><pre><span></span>[user_info@]host[:port]
-</pre></div>
-</div>
-<p>Examples of hierarchical URIs include:</p>
-<div class="highlight-python"><div class="highlight"><pre><span></span>http://www.boost.org/
-file:///bin/bash
-</pre></div>
-</div>
-<p>The following example, describing a complex URI using FTP, shows how
-a URI is broken down by the parser:</p>
-<img alt="../_images/ftp_uri.png" src="../_images/ftp_uri.png" />
-<p>Note that the <code class="docutils literal"><span class="pre">authority</span></code> is further subdivided into different
-elements.  Another example, using HTTP is given below:</p>
-<img alt="../_images/http_uri.png" src="../_images/http_uri.png" />
-<p>The difference here between the path in a hierarchical URI and that in
-the example above for the non-hierarchical URI.</p>
-</div>
-<div class="section" id="id1">
-<h2>The <code class="docutils literal"><span class="pre">uri</span></code> class<a class="headerlink" href="#id1" title="Permalink to this headline">¶</a></h2>
-<p>As of version 0.9.3, <code class="docutils literal"><span class="pre">uri</span></code> supplies a URI parser and builder.
-To use the parser, it&#8217;s as simple as supplying a string to the
-constructor:</p>
-<div class="highlight-c++"><div class="highlight"><pre><span></span><span class="k">using</span> <span class="k">namespace</span> <span class="n">boost</span><span class="o">::</span><span class="n">network</span><span class="p">;</span>
-<span class="n">uri</span><span class="o">::</span><span class="n">uri</span> <span class="n">instance</span><span class="p">(</span><span class="s">&quot;http://cpp-netlib.github.com/&quot;</span><span class="p">);</span>
-<span class="n">assert</span><span class="p">(</span><span class="n">instance</span><span class="p">.</span><span class="n">is_valid</span><span class="p">());</span>
-<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="s">&quot;scheme: &quot;</span> <span class="o">&lt;&lt;</span> <span class="n">instance</span><span class="p">.</span><span class="n">scheme</span><span class="p">()</span> <span class="o">&lt;&lt;</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span>
-          <span class="o">&lt;&lt;</span> <span class="s">&quot;host: &quot;</span> <span class="o">&lt;&lt;</span> <span class="n">instance</span><span class="p">.</span><span class="n">host</span><span class="p">()</span> <span class="o">&lt;&lt;</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
-</pre></div>
-</div>
-<p>The command-line output of this program will be:</p>
-<div class="highlight-python"><div class="highlight"><pre><span></span>scheme: http
-host: cpp-netlib.github.com
-</pre></div>
-</div>
-</div>
-<div class="section" id="the-uri-builder">
-<h2>The <code class="docutils literal"><span class="pre">uri</span></code> builder<a class="headerlink" href="#the-uri-builder" title="Permalink to this headline">¶</a></h2>
-<p><code class="docutils literal"><span class="pre">uri</span></code> support a stream style syntax to create a URI from it&#8217;s
-elements.  For example the program:</p>
-<div class="highlight-c++"><div class="highlight"><pre><span></span><span class="cp">#include</span> <span class="cpf">&lt;iostream&gt;</span><span class="cp"></span>
-<span class="cp">#include</span> <span class="cpf">&lt;boost/network/uri.hpp&gt;</span><span class="cp"></span>
-<span class="cp">#include</span> <span class="cpf">&lt;boost/network/uri/uri_io.hpp&gt;</span><span class="cp"></span>
-<span class="k">using</span> <span class="k">namespace</span> <span class="n">boost</span><span class="o">::</span><span class="n">network</span><span class="p">;</span>
-
-<span class="kt">int</span> <span class="nf">main</span><span class="p">()</span> <span class="p">{</span>
-    <span class="n">uri</span><span class="o">::</span><span class="n">uri</span> <span class="n">url</span><span class="p">;</span>
-    <span class="n">url</span> <span class="o">&lt;&lt;</span> <span class="n">uri</span><span class="o">::</span><span class="n">scheme</span><span class="p">(</span><span class="s">&quot;http&quot;</span><span class="p">)</span>
-        <span class="o">&lt;&lt;</span> <span class="n">uri</span><span class="o">::</span><span class="n">host</span><span class="p">(</span><span class="s">&quot;www.github.com&quot;</span><span class="p">)</span>
-        <span class="o">&lt;&lt;</span> <span class="n">uri</span><span class="o">::</span><span class="n">path</span><span class="p">(</span><span class="s">&quot;/cpp-netlib&quot;</span><span class="p">);</span>
-    <span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="n">url</span> <span class="o">&lt;&lt;</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
-    <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
-<span class="p">}</span>
-</pre></div>
-</div>
-<p>will output:</p>
-<div class="highlight-python"><div class="highlight"><pre><span></span>http://www.github.com/cpp-netlib
-</pre></div>
-</div>
-</div>
-<div class="section" id="uri-concept">
-<h2><code class="docutils literal"><span class="pre">URI</span> <span class="pre">Concept</span></code><a class="headerlink" href="#uri-concept" title="Permalink to this headline">¶</a></h2>
-<p><strong>Legend</strong></p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field-odd field"><th class="field-name">U:</th><td class="field-body">The URI type.</td>
-</tr>
-<tr class="field-even field"><th class="field-name">u,u_:</th><td class="field-body">An instance of <strong>M</strong>.</td>
-</tr>
-<tr class="field-odd field"><th class="field-name">S:</th><td class="field-body">A string type.</td>
-</tr>
-<tr class="field-even field"><th class="field-name">s,v:</th><td class="field-body">An instance of <strong>S</strong>.</td>
-</tr>
-<tr class="field-odd field"><th class="field-name">T:</th><td class="field-body">The Tag type.</td>
-</tr>
-</tbody>
-</table>
-<table border="1" class="docutils">
-<colgroup>
-<col width="31%" />
-<col width="24%" />
-<col width="45%" />
-</colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head">Construct</th>
-<th class="head">Result</th>
-<th class="head">Description</th>
-</tr>
-</thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal"><span class="pre">U(u)</span></code></td>
-<td>Instance of U</td>
-<td>Copy constructible.</td>
-</tr>
-<tr class="row-odd"><td><code class="docutils literal"><span class="pre">U(s)</span></code></td>
-<td>Instance of U</td>
-<td>Constructible from string.</td>
-</tr>
-<tr class="row-even"><td><code class="docutils literal"><span class="pre">u</span> <span class="pre">=</span> <span class="pre">u_;</span></code></td>
-<td>Reference to u</td>
-<td>Assignable.</td>
-</tr>
-<tr class="row-odd"><td><code class="docutils literal"><span class="pre">u</span> <span class="pre">=</span> <span class="pre">s;</span></code></td>
-<td>Reference to u</td>
-<td>Assignable from string.</td>
-</tr>
-<tr class="row-even"><td><code class="docutils literal"><span class="pre">swap(u,</span> <span class="pre">u_);</span></code></td>
-<td><code class="docutils literal"><span class="pre">void</span></code></td>
-<td>Swappable.</td>
-</tr>
-<tr class="row-odd"><td><code class="docutils literal"><span class="pre">scheme(u);</span></code></td>
-<td>Convertible to S</td>
-<td>Retrieve the URI scheme of <code class="docutils literal"><span class="pre">u</span></code>.</td>
-</tr>
-<tr class="row-even"><td><code class="docutils literal"><span class="pre">user_info(u);</span></code></td>
-<td>Convertible to S</td>
-<td>Retrieve the user info of <code class="docutils literal"><span class="pre">u</span></code>.</td>
-</tr>
-<tr class="row-odd"><td><code class="docutils literal"><span class="pre">host(u);</span></code></td>
-<td>Convertible to S</td>
-<td>Retrieve the host of <code class="docutils literal"><span class="pre">u</span></code>.</td>
-</tr>
-<tr class="row-even"><td><code class="docutils literal"><span class="pre">port(u);</span></code></td>
-<td>Convertible to H</td>
-<td>Retrieve the port of <code class="docutils literal"><span class="pre">u</span></code>.</td>
-</tr>
-<tr class="row-odd"><td><code class="docutils literal"><span class="pre">path(u);</span></code></td>
-<td>Convertible to S</td>
-<td>Retrieve the path of <code class="docutils literal"><span class="pre">u</span></code>.</td>
-</tr>
-<tr class="row-even"><td><code class="docutils literal"><span class="pre">query(u);</span></code></td>
-<td>Convertible to S</td>
-<td>Retrieve the query string of <code class="docutils literal"><span class="pre">u</span></code>.</td>
-</tr>
-<tr class="row-odd"><td><code class="docutils literal"><span class="pre">fragment(u);</span></code></td>
-<td>Convertible to S</td>
-<td>Retrieve the fragment of <code class="docutils literal"><span class="pre">u</span></code>.</td>
-</tr>
-</tbody>
-</table>
-</div>
-</div>
-
-
-          </div>
-        </div>
-      </div>
-      <div class="sphinxsidebar" role="navigation" aria-label="main navigation">
-        <div class="sphinxsidebarwrapper">
-  <h3><a href="../contents.html">Table Of Contents</a></h3>
-  <ul>
-<li><a class="reference internal" href="#">The URI class</a><ul>
-<li><a class="reference internal" href="#generic-uri-syntax-overview">Generic URI syntax overview</a></li>
-<li><a class="reference internal" href="#id1">The <code class="docutils literal"><span class="pre">uri</span></code> class</a></li>
-<li><a class="reference internal" href="#the-uri-builder">The <code class="docutils literal"><span class="pre">uri</span></code> builder</a></li>
-<li><a class="reference internal" href="#uri-concept"><code class="docutils literal"><span class="pre">URI</span> <span class="pre">Concept</span></code></a></li>
-</ul>
-</li>
-</ul>
-
-  <h4>Previous topic</h4>
-  <p class="topless"><a href="message.html"
-                        title="previous chapter">The message template</a></p>
-  <h4>Next topic</h4>
-  <p class="topless"><a href="http.html"
-                        title="next chapter">HTTP implementation</a></p>
-<div id="searchbox" style="display: none" role="search">
-  <h3>Quick search</h3>
-    <form class="search" action="../search.html" method="get">
-      <input type="text" name="q" />
-      <input type="submit" value="Go" />
-      <input type="hidden" name="check_keywords" value="yes" />
-      <input type="hidden" name="area" value="default" />
-    </form>
-    <p class="searchtip" style="font-size: 90%">
-    Enter search terms or a module, class or function name.
-    </p>
-</div>
-<script type="text/javascript">$('#searchbox').show(0);</script>
-        </div>
-      </div>
-      <div class="clearer"></div>
-    </div>
-    <div class="related" role="navigation" aria-label="related navigation">
-      <h3>Navigation</h3>
-      <ul>
-        <li class="right" style="margin-right: 10px">
-          <a href="http.html" title="HTTP implementation"
-             >next</a></li>
-        <li class="right" >
-          <a href="message.html" title="The message template"
-             >previous</a> |</li>
-        <li class="nav-item nav-item-0"><a href="../contents.html">cpp-netlib v0.11.2</a> &raquo;</li>
-          <li class="nav-item nav-item-1"><a href="../in_depth.html" >An in-depth look at the <code class="docutils literal"><span class="pre">cpp-netlib</span></code></a> &raquo;</li> 
-      </ul>
-    </div>
-    <div class="footer" role="contentinfo">
-        &copy; Copyright 2008-2014, Glyn Matthews, Dean Michael Berris; 2013 Google, Inc..
-      Last updated on Mar 07, 2016.
-      Created using <a href="http://sphinx-doc.org/">Sphinx</a> 1.3.6.
-    </div>
-  </body>
-</html>
\ No newline at end of file
diff --git a/libs/network/doc/html/index.html b/libs/network/doc/html/index.html
index 17217be76..6627ee1cc 100644
--- a/libs/network/doc/html/index.html
+++ b/libs/network/doc/html/index.html
@@ -137,7 +137,6 @@ <h1>Want to learn more?<a class="headerlink" href="#want-to-learn-more" title="P
 <li><a class="reference internal" href="getting_started.html#getting-started"><span>Take a look at the getting started guide</span></a></li>
 <li><a class="reference internal" href="examples.html#examples"><span>Learn from some simple examples</span></a></li>
 <li><a class="reference internal" href="whats_new.html#whats-new"><span>Find out what&#8217;s new</span></a></li>
-<li><a class="reference internal" href="in_depth.html#in-depth"><span>Study the library in more depth</span></a></li>
 <li><a class="reference internal" href="reference.html#reference"><span>Discover more through the full reference</span></a></li>
 <li><a class="reference internal" href="contents.html#contents"><span>Full table of contents</span></a></li>
 </ul>
@@ -203,7 +202,7 @@ <h3>Navigation</h3>
     </div>
     <div class="footer" role="contentinfo">
         &copy; Copyright 2008-2014, Glyn Matthews, Dean Michael Berris; 2013 Google, Inc..
-      Last updated on Mar 07, 2016.
+      Last updated on Mar 29, 2016.
       Created using <a href="http://sphinx-doc.org/">Sphinx</a> 1.3.6.
     </div>
   </body>
diff --git a/libs/network/doc/html/objects.inv b/libs/network/doc/html/objects.inv
index 40077345c..16d62166a 100644
Binary files a/libs/network/doc/html/objects.inv and b/libs/network/doc/html/objects.inv differ
diff --git a/libs/network/doc/html/reference.html b/libs/network/doc/html/reference.html
index e98115678..1206f38f7 100644
--- a/libs/network/doc/html/reference.html
+++ b/libs/network/doc/html/reference.html
@@ -25,7 +25,7 @@
     <script type="text/javascript" src="_static/doctools.js"></script>
     <link rel="top" title="cpp-netlib v0.11.2" href="contents.html" />
     <link rel="next" title="HTTP Client API" href="reference/http_client.html" />
-    <link rel="prev" title="Project history" href="history.html" />
+    <link rel="prev" title="Twitter search" href="examples/http/twitter_search.html" />
 <link rel="stylesheet" href="http://fonts.googleapis.com/css?family=Neuton&amp;subset=latin" type="text/css" media="screen" charset="utf-8" />
 <link rel="stylesheet" href="http://fonts.googleapis.com/css?family=Nobile:regular,italic,bold,bolditalic&amp;subset=latin" type="text/css" media="screen" charset="utf-8" />
 <!--[if lte IE 6]>
@@ -42,7 +42,7 @@ <h3>Navigation</h3>
           <a href="reference/http_client.html" title="HTTP Client API"
              accesskey="N">next</a></li>
         <li class="right" >
-          <a href="history.html" title="Project history"
+          <a href="examples/http/twitter_search.html" title="Twitter search"
              accesskey="P">previous</a> |</li>
         <li class="nav-item nav-item-0"><a href="contents.html">cpp-netlib v0.11.2</a> &raquo;</li> 
       </ul>
@@ -82,10 +82,8 @@ <h3>Navigation</h3>
 </li>
 <li class="toctree-l1"><a class="reference internal" href="reference/http_server.html">HTTP Server API</a><ul>
 <li class="toctree-l2"><a class="reference internal" href="reference/http_server.html#general">General</a></li>
-<li class="toctree-l2"><a class="reference internal" href="reference/http_server.html#implementations">Implementations</a></li>
-<li class="toctree-l2"><a class="reference internal" href="reference/http_server.html#synchronous-servers">Synchronous Servers</a></li>
-<li class="toctree-l2"><a class="reference internal" href="reference/http_server.html#asynchronous-servers">Asynchronous Servers</a></li>
-<li class="toctree-l2"><a class="reference internal" href="reference/http_server.html#adding-ssl-support-to-asynchronous-server">Adding SSL support to Asynchronous Server</a></li>
+<li class="toctree-l2"><a class="reference internal" href="reference/http_server.html#api-documentation">API Documentation</a></li>
+<li class="toctree-l2"><a class="reference internal" href="reference/http_server.html#adding-ssl-support-to-the-http-server">Adding SSL support to the HTTP Server</a></li>
 </ul>
 </li>
 </ul>
@@ -99,8 +97,8 @@ <h3>Navigation</h3>
       <div class="sphinxsidebar" role="navigation" aria-label="main navigation">
         <div class="sphinxsidebarwrapper">
   <h4>Previous topic</h4>
-  <p class="topless"><a href="history.html"
-                        title="previous chapter">Project history</a></p>
+  <p class="topless"><a href="examples/http/twitter_search.html"
+                        title="previous chapter">Twitter search</a></p>
   <h4>Next topic</h4>
   <p class="topless"><a href="reference/http_client.html"
                         title="next chapter">HTTP Client API</a></p>
@@ -128,14 +126,14 @@ <h3>Navigation</h3>
           <a href="reference/http_client.html" title="HTTP Client API"
              >next</a></li>
         <li class="right" >
-          <a href="history.html" title="Project history"
+          <a href="examples/http/twitter_search.html" title="Twitter search"
              >previous</a> |</li>
         <li class="nav-item nav-item-0"><a href="contents.html">cpp-netlib v0.11.2</a> &raquo;</li> 
       </ul>
     </div>
     <div class="footer" role="contentinfo">
         &copy; Copyright 2008-2014, Glyn Matthews, Dean Michael Berris; 2013 Google, Inc..
-      Last updated on Mar 07, 2016.
+      Last updated on Mar 29, 2016.
       Created using <a href="http://sphinx-doc.org/">Sphinx</a> 1.3.6.
     </div>
   </body>
diff --git a/libs/network/doc/html/reference/http_client.html b/libs/network/doc/html/reference/http_client.html
index 4df7b0799..f60a4ddd5 100644
--- a/libs/network/doc/html/reference/http_client.html
+++ b/libs/network/doc/html/reference/http_client.html
@@ -112,61 +112,6 @@ <h2>Client Implementation<a class="headerlink" href="#client-implementation" tit
 number.</li>
 </ul>
 </div></blockquote>
-<table border="1" class="docutils">
-<colgroup>
-<col width="42%" />
-<col width="58%" />
-</colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head">Tag</th>
-<th class="head">Description</th>
-</tr>
-</thead>
-<tbody valign="top">
-<tr class="row-even"><td>http_default_8bit_tcp_resolve</td>
-<td>This is the default HTTP implementation tag
-that resolves addresses with a TCP resolver
-and provides a synchronous/blocking HTTP
-client interface.</td>
-</tr>
-<tr class="row-odd"><td>http_default_8bit_udp_resolve</td>
-<td>This is similar to the above tag except that
-it specifies the HTTP client to use a UDP
-resolver. It also provides a synchronous/
-blocking HTTP client interface.</td>
-</tr>
-<tr class="row-even"><td>http_keepalive_8bit_tcp_resolve</td>
-<td>This tag specifies that the HTTP client by
-default will keep connections to the server
-alive. It only makes sense if the
-<code class="docutils literal"><span class="pre">version_major</span></code> and <code class="docutils literal"><span class="pre">version_minor</span></code> are
-both <code class="docutils literal"><span class="pre">1</span></code>, to indicate HTTP 1.1. This tag
-causes the HTTP client to resolve using a
-TCP resolver and provides a synchronous/
-blocking HTTP client interface.</td>
-</tr>
-<tr class="row-odd"><td>http_keepalive_8bit_udp_resolve</td>
-<td>This is similar to the above tag except that
-it specifies the HTTP client to use a UDP
-resolver. It also provides a synchronous/
-blocking HTTP client interface.</td>
-</tr>
-<tr class="row-even"><td>http_async_8bit_tcp_resolve</td>
-<td>This tag provides an active HTTP client
-object implementation that uses a TCP
-resolver. Response objects returned will
-encapsulate a number of <a class="reference external" href="http://www.boost.org/libs/thread">Boost.Thread</a>
-shared futures to hold values. Users don&#8217;t
-have to see this as they are implementation
-details.</td>
-</tr>
-<tr class="row-odd"><td>http_async_8bit_udp_resolve</td>
-<td>This is similar to the above tag except that
-specifies the HTTP client to use a UDP
-resolver.</td>
-</tr>
-</tbody>
-</table>
 <p>In the above table the tags follow a pattern for describing the behavior
 introduced by the tags. This pattern is shown below:</p>
 <blockquote>
@@ -817,7 +762,7 @@ <h3>Navigation</h3>
     </div>
     <div class="footer" role="contentinfo">
         &copy; Copyright 2008-2014, Glyn Matthews, Dean Michael Berris; 2013 Google, Inc..
-      Last updated on Mar 07, 2016.
+      Last updated on Mar 29, 2016.
       Created using <a href="http://sphinx-doc.org/">Sphinx</a> 1.3.6.
     </div>
   </body>
diff --git a/libs/network/doc/html/reference/http_request.html b/libs/network/doc/html/reference/http_request.html
index 9b93d12de..2f916959f 100644
--- a/libs/network/doc/html/reference/http_request.html
+++ b/libs/network/doc/html/reference/http_request.html
@@ -436,7 +436,7 @@ <h3>Navigation</h3>
     </div>
     <div class="footer" role="contentinfo">
         &copy; Copyright 2008-2014, Glyn Matthews, Dean Michael Berris; 2013 Google, Inc..
-      Last updated on Mar 07, 2016.
+      Last updated on Mar 29, 2016.
       Created using <a href="http://sphinx-doc.org/">Sphinx</a> 1.3.6.
     </div>
   </body>
diff --git a/libs/network/doc/html/reference/http_response.html b/libs/network/doc/html/reference/http_response.html
index e732d48b9..8d8338e5c 100644
--- a/libs/network/doc/html/reference/http_response.html
+++ b/libs/network/doc/html/reference/http_response.html
@@ -469,7 +469,7 @@ <h3>Navigation</h3>
     </div>
     <div class="footer" role="contentinfo">
         &copy; Copyright 2008-2014, Glyn Matthews, Dean Michael Berris; 2013 Google, Inc..
-      Last updated on Mar 07, 2016.
+      Last updated on Mar 29, 2016.
       Created using <a href="http://sphinx-doc.org/">Sphinx</a> 1.3.6.
     </div>
   </body>
diff --git a/libs/network/doc/html/reference/http_server.html b/libs/network/doc/html/reference/http_server.html
index cb8dd0b85..d8329e200 100644
--- a/libs/network/doc/html/reference/http_server.html
+++ b/libs/network/doc/html/reference/http_server.html
@@ -59,9 +59,9 @@ <h3>Navigation</h3>
 <h1>HTTP Server API<a class="headerlink" href="#http-server-api" title="Permalink to this headline">¶</a></h1>
 <div class="section" id="general">
 <h2>General<a class="headerlink" href="#general" title="Permalink to this headline">¶</a></h2>
-<p><code class="xref py py-mod docutils literal"><span class="pre">cpp-netlib</span></code> includes and implements two distinct HTTP server
-implementations that you can use and embed in your own applications. Both HTTP
-Server implementations:</p>
+<p><code class="xref py py-mod docutils literal"><span class="pre">cpp-netlib</span></code> includes and implements and asynchronous HTTP server
+implementation that you can use and embed in your own applications. The HTTP
+Server implementation:</p>
 <blockquote>
 <div><ul class="simple">
 <li><strong>Cannot be copied.</strong> This means you may have to store instances of the HTTP
@@ -70,68 +70,20 @@ <h2>General<a class="headerlink" href="#general" title="Permalink to this headli
 <li><strong>Assume that requests made are independent of each other.</strong> None of the
 HTTP Server implementations support request pipelining (yet) so a single
 connection only deals with a single request.</li>
-<li><strong>Are header-only and are compiled-into your application.</strong> Future releases
-in case you want to upgrade the implementation you are using in your
-application will be distributed as header-only implementations, which means
-you have to re-compile your application to use a newer version of the
-implementations.</li>
+<li><strong>The Handler instance is invoked asynchronously</strong>. This means the I/O
+thread used to handle network-related events are free to handle only the
+I/O related events. This enables the server to scale better as to the
+number of concurrent connections it can handle.</li>
+<li><strong>The Handler is able to schedule asynchronous actions on the thread pool
+associated with the server.</strong> This allows handlers to perform multiple
+asynchronous computations that later on perform writes to the connection.</li>
+<li><strong>The Handler is able to control the (asynchronous) writes to and reads
+from the HTTP connection.</strong> Because the connection is available to the
+Handler, that means it can write out chunks of data at a time or stream
+data through the connection continuously.</li>
 </ul>
 </div></blockquote>
-<p>The HTTP Servers have different semantics, and in some cases require different
-APIs from the supplied template parameters.</p>
-</div>
-<div class="section" id="implementations">
-<h2>Implementations<a class="headerlink" href="#implementations" title="Permalink to this headline">¶</a></h2>
-<p>There are two different user-facing template classes that differentiate the
-<a class="reference internal" href="#synchronous-servers">Synchronous Servers</a> from the <a class="reference internal" href="#asynchronous-servers">Asynchronous Servers</a>. Both templates take a
-single template parameter named <code class="docutils literal"><span class="pre">Handler</span></code> which describes the type of the
-Handler function object.</p>
-<p>There are two different Handler concepts, one concept for <a class="reference internal" href="#synchronous-servers">Synchronous Servers</a>
-and another for <cite>Asynchronous Servers</cite>.</p>
-<p>The SynchronousHandler concept for <a class="reference internal" href="#synchronous-servers">Synchronous Servers</a> is described by the
-following table:</p>
-<hr class="docutils" />
-<p><strong>Legend:</strong></p>
-<dl class="docutils">
-<dt>H</dt>
-<dd>The Handler type.</dd>
-<dt>h</dt>
-<dd>An instance of H.</dd>
-<dt>Req</dt>
-<dd>A type that models the Request Concept.</dd>
-<dt>Res</dt>
-<dd>A type that models the Response Concept.</dd>
-<dt>req</dt>
-<dd>An instance of Req.</dd>
-<dt>res</dt>
-<dd>An instance of Res.</dd>
-</dl>
-<table border="1" class="docutils">
-<colgroup>
-<col width="21%" />
-<col width="17%" />
-<col width="61%" />
-</colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head">Construct</th>
-<th class="head">Return Type</th>
-<th class="head">Description</th>
-</tr>
-</thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal"><span class="pre">h(req,res)</span></code></td>
-<td><code class="docutils literal"><span class="pre">void</span></code></td>
-<td>Handle the request; res is passed in as a
-non-const lvalue, which represents the
-response to be returned to the client
-performing the request.</td>
-</tr>
-</tbody>
-</table>
-<p>More information about the internals of the <a class="reference internal" href="#synchronous-servers">Synchronous Servers</a> can be found
-in the following section.</p>
-<p>The AsynchronousHandler concept for <a class="reference internal" href="#asynchronous-servers">Asynchronous Servers</a> is described by the
-following table:</p>
+<p>The Handler concept for the HTTP Server is described by the following table:</p>
 <hr class="docutils" />
 <p><strong>Legend:</strong></p>
 <dl class="docutils">
@@ -169,50 +121,44 @@ <h2>Implementations<a class="headerlink" href="#implementations" title="Permalin
 </tr>
 </tbody>
 </table>
-<p>More information about the internals of the <a class="reference internal" href="#asynchronous-servers">Asynchronous Servers</a> can be found
-in the following section.</p>
-</div>
-<div class="section" id="synchronous-servers">
-<h2>Synchronous Servers<a class="headerlink" href="#synchronous-servers" title="Permalink to this headline">¶</a></h2>
-<p>The synchronous server implementation is represented by the template <code class="docutils literal"><span class="pre">server</span></code>
-in namespace <code class="docutils literal"><span class="pre">boost::network::http</span></code>. The <code class="docutils literal"><span class="pre">server</span></code> template takes in a single
-template parameter named <code class="docutils literal"><span class="pre">Handler</span></code> which models the SynchronousHandler
-concept (described above).</p>
-<p>An instance of Handler is taken in by reference to the constructor of the HTTP
-server. This means the Handler is not copied around and only a single instance
-of the handler is used for all connections and requests performed against the
-HTTP server.</p>
+<hr class="docutils" />
+<p>The HTTP Server is meant to allow for better scalability in terms of the number
+of concurrent connections and for performing asynchronous actions within the
+handlers.  The HTTP Server implementation is available from a single
+user-facing template named <code class="docutils literal"><span class="pre">server</span></code>. This template takes in a single template
+parameter which is the type of the Handler to be called once a request has been
+parsed from a connection.</p>
+<p>An instance of Handler is taken as a reference to the constructor of the server
+instance.</p>
 <div class="admonition warning">
 <p class="first admonition-title">Warning</p>
-<p class="last">It is important to note that the HTTP server does not implement any
-locking upon invoking the Handler. In case you have any state in the Handler
-that will be associated with the synchronous server, you would have to
-implement your own synchronization internal to the Handler implementation.
-This matters especially if you run the synchronous server in multiple
-threads.</p>
+<p class="last">The HTTP Server implementation does not perform any
+synchronization on the calls to the Handler invocation. This means if your
+handler contains or maintains internal state, you are responsible for
+implementing your own synchronization on accesses to the internal state of
+the Handler.</p>
 </div>
-<p>The general pattern of usage for the HTTP Server template is shown below:</p>
+<p>The general pattern for using the <code class="docutils literal"><span class="pre">server</span></code> template is shown below:</p>
 <div class="highlight-c++"><div class="highlight"><pre><span></span><span class="k">struct</span> <span class="n">handler</span><span class="p">;</span>
 <span class="k">typedef</span> <span class="n">boost</span><span class="o">::</span><span class="n">network</span><span class="o">::</span><span class="n">http</span><span class="o">::</span><span class="n">server</span><span class="o">&lt;</span><span class="n">handler</span><span class="o">&gt;</span> <span class="n">http_server</span><span class="p">;</span>
 
 <span class="k">struct</span> <span class="n">handler</span> <span class="p">{</span>
     <span class="kt">void</span> <span class="k">operator</span><span class="p">()(</span>
         <span class="n">http_server</span><span class="o">::</span><span class="n">request</span> <span class="k">const</span> <span class="o">&amp;</span> <span class="n">req</span><span class="p">,</span>
-        <span class="n">http_server</span><span class="o">::</span><span class="n">response</span> <span class="o">&amp;</span> <span class="n">res</span>
+        <span class="n">http_server</span><span class="o">::</span><span class="n">connection_ptr</span> <span class="n">connection</span>
     <span class="p">)</span> <span class="p">{</span>
-        <span class="c1">// do something, and then edit the res object here.</span>
+        <span class="c1">// handle the request here, and use the connection to</span>
+        <span class="c1">// either read more data or write data out to the client</span>
     <span class="p">}</span>
 <span class="p">};</span>
 </pre></div>
 </div>
-<p>More information about the actual HTTP Server API follows in the next section.
-It is important to understand that the HTTP Server is actually embedded in your
-application, which means you can expose almost all your application logic
-through the Handler type, which you can also initialize appropriately.</p>
+</div>
 <div class="section" id="api-documentation">
-<h3>API Documentation<a class="headerlink" href="#api-documentation" title="Permalink to this headline">¶</a></h3>
+<h2>API Documentation<a class="headerlink" href="#api-documentation" title="Permalink to this headline">¶</a></h2>
 <p>The following sections assume that the following file has been included:</p>
 <div class="highlight-c++"><div class="highlight"><pre><span></span><span class="cp">#include</span> <span class="cpf">&lt;boost/network/include/http/server.hpp&gt;</span><span class="cp"></span>
+<span class="cp">#include</span> <span class="cpf">&lt;boost/network/utils/thread_pool.hpp&gt;</span><span class="cp"></span>
 </pre></div>
 </div>
 <p>And that the following typedef&#8217;s have been put in place:</p>
@@ -221,458 +167,709 @@ <h3>API Documentation<a class="headerlink" href="#api-documentation" title="Perm
 
 <span class="k">struct</span> <span class="n">handler_type</span> <span class="p">{</span>
     <span class="kt">void</span> <span class="k">operator</span><span class="p">()(</span><span class="n">http_server</span><span class="o">::</span><span class="n">request</span> <span class="k">const</span> <span class="o">&amp;</span> <span class="n">request</span><span class="p">,</span>
-                    <span class="n">http_server</span><span class="o">::</span><span class="n">response</span> <span class="o">&amp;</span> <span class="n">response</span><span class="p">)</span> <span class="p">{</span>
+                    <span class="n">http_server</span><span class="o">::</span><span class="n">connection_ptr</span> <span class="n">connection</span><span class="p">)</span> <span class="p">{</span>
         <span class="c1">// do something here</span>
     <span class="p">}</span>
 <span class="p">};</span>
 </pre></div>
 </div>
 <div class="section" id="constructor">
-<h4>Constructor<a class="headerlink" href="#constructor" title="Permalink to this headline">¶</a></h4>
+<h3>Constructor<a class="headerlink" href="#constructor" title="Permalink to this headline">¶</a></h3>
 <dl class="docutils">
 <dt><code class="docutils literal"><span class="pre">explicit</span> <span class="pre">http_server(options)</span></code></dt>
-<dd>Construct an HTTP Server instance, passing in a <code class="docutils literal"><span class="pre">server_options&lt;Tag,</span>
-<span class="pre">Handler&gt;</span></code> object. The following table shows the supported options in
-<code class="docutils literal"><span class="pre">server_options&lt;Tag,</span> <span class="pre">Handler&gt;</span></code>.</dd>
+<dd>Construct an HTTP server instance passing in a <code class="docutils literal"><span class="pre">server_options&lt;Tag,</span>
+<span class="pre">Handler&gt;</span></code> instance.</dd>
 </dl>
-<table border="1" class="docutils">
-<colgroup>
-<col width="14%" />
-<col width="26%" />
-<col width="60%" />
-</colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head">Parameter Name</th>
-<th class="head">Type</th>
-<th class="head">Description</th>
-</tr>
-</thead>
-<tbody valign="top">
-<tr class="row-even"><td>address</td>
-<td>string_type</td>
-<td>The hostname or IP address from which the server should be bound to. This parameter is required.</td>
-</tr>
-<tr class="row-odd"><td>port</td>
-<td>string_type</td>
-<td>The port to which the server should bind and listen to. This parameter is required.</td>
-</tr>
-<tr class="row-even"><td>thread_pool</td>
-<td><code class="docutils literal"><span class="pre">shared_ptr&lt;thread_pool&gt;</span></code></td>
-<td>A shared pointer to an instance of <code class="docutils literal"><span class="pre">boost::network::utils::thread_pool</span></code> &#8211; this is the
-thread pool from where the handler is invoked. This parameter is only applicable and required
-for <code class="docutils literal"><span class="pre">async_server</span></code> instances.</td>
-</tr>
-<tr class="row-odd"><td>io_service</td>
-<td><code class="docutils literal"><span class="pre">shared_ptr&lt;io_service&gt;</span></code></td>
-<td>An optional lvalue to an instance of <code class="docutils literal"><span class="pre">boost::asio::io_service</span></code> which allows the server to use
-an already-constructed <code class="docutils literal"><span class="pre">boost::asio::io_service</span></code> instance instead of instantiating one that it
-manages.</td>
-</tr>
-<tr class="row-even"><td>reuse_address</td>
-<td><code class="docutils literal"><span class="pre">bool</span></code></td>
-<td>A boolean that specifies whether to re-use the address and port on which the server will be
-bound to. This enables or disables the socket option for listener sockets. The default is
-<code class="docutils literal"><span class="pre">false</span></code>.</td>
-</tr>
-<tr class="row-odd"><td>report_aborted</td>
-<td><code class="docutils literal"><span class="pre">bool</span></code></td>
-<td>A boolean that specifies whether the listening socket should report aborted connection attempts
-to the accept handler (an internal detail of cpp-netlib). This is put in place to allow for
-future-proofing the code in case an optional error handler function is supported in later
-releases of cpp-netlib. The default is <code class="docutils literal"><span class="pre">false</span></code>.</td>
-</tr>
-<tr class="row-even"><td>receive_buffer_size</td>
-<td><code class="docutils literal"><span class="pre">int</span></code></td>
-<td>The size of the socket&#8217;s receive buffer. The default is defined by Boost.Asio and is
-platform-dependent.</td>
-</tr>
-<tr class="row-odd"><td>send_buffer_size</td>
-<td><code class="docutils literal"><span class="pre">int</span></code></td>
-<td>The size of the socket&#8217;s send buffer. The default is defined by Boost.Asio and is
-platform-dependent.</td>
-</tr>
-<tr class="row-even"><td>receive_low_watermark</td>
-<td><code class="docutils literal"><span class="pre">int</span></code></td>
-<td>The size of the socket&#8217;s low watermark for its receive buffer. The default is defined by
-Boost.Asio and is platform-dependent.</td>
-</tr>
-<tr class="row-odd"><td>send_buffer_size</td>
-<td><code class="docutils literal"><span class="pre">int</span></code></td>
-<td>The size of the socket&#8217;s send low watermark for its send buffer. The default is defined by
-Boost.Asio and is platform-dependent.</td>
-</tr>
-<tr class="row-even"><td>non_blocking_io</td>
-<td><code class="docutils literal"><span class="pre">bool</span></code></td>
-<td>An optional bool to define whether the socket should use non-blocking I/O in case the platform
-supports it. The default is <code class="docutils literal"><span class="pre">true</span></code>.</td>
-</tr>
-<tr class="row-odd"><td>linger</td>
-<td><code class="docutils literal"><span class="pre">bool</span></code></td>
-<td>An optional bool to determine whether the socket should linger in case there&#8217;s still data to be
-sent out at the time of its closing. The default is <code class="docutils literal"><span class="pre">true</span></code>.</td>
-</tr>
-<tr class="row-even"><td>linger_timeout</td>
-<td><code class="docutils literal"><span class="pre">int</span></code></td>
-<td>An optional int to define the timeout to wait for socket closes before it is set to linger.
-The default is <code class="docutils literal"><span class="pre">0</span></code>.</td>
-</tr>
-<tr class="row-odd"><td>context</td>
-<td><code class="docutils literal"><span class="pre">shared_ptr&lt;context&gt;</span></code></td>
-<td>An optional shared pointer to an instance of <code class="docutils literal"><span class="pre">boost::asio::ssl::context</span></code> &#8211; this contains the
-settings needed to support SSL. This parameter is only applicable for <code class="docutils literal"><span class="pre">async_server</span></code> instances.</td>
-</tr>
-</tbody>
-</table>
-<p>To use the above supported named parameters, you&#8217;ll have code that looks like the following:</p>
-<div class="highlight-c++"><div class="highlight"><pre><span></span><span class="k">using</span> <span class="k">namespace</span> <span class="n">boost</span><span class="o">::</span><span class="n">network</span><span class="o">::</span><span class="n">http</span><span class="p">;</span> <span class="c1">// parameters are in this namespace</span>
-<span class="n">handler</span> <span class="n">handler_instance</span><span class="p">;</span>
-<span class="n">sync_server</span><span class="o">&lt;</span><span class="n">handler</span><span class="o">&gt;::</span><span class="n">options</span> <span class="n">options</span><span class="p">(</span><span class="n">handler_instance</span><span class="p">);</span>
-<span class="n">options</span><span class="p">.</span><span class="n">address</span><span class="p">(</span><span class="s">&quot;0.0.0.0&quot;</span><span class="p">)</span>
-       <span class="p">.</span><span class="n">port</span><span class="p">(</span><span class="s">&quot;80&quot;</span><span class="p">)</span>
-       <span class="p">.</span><span class="n">io_service</span><span class="p">(</span><span class="n">boost</span><span class="o">::</span><span class="n">make_shared</span><span class="o">&lt;</span><span class="n">boost</span><span class="o">::</span><span class="n">asio</span><span class="o">::</span><span class="n">io_service</span><span class="o">&gt;</span><span class="p">())</span>
-       <span class="p">.</span><span class="n">reuse_address</span><span class="p">(</span><span class="nb">true</span><span class="p">);</span>
-<span class="n">sync_server</span><span class="o">&lt;</span><span class="n">handler</span><span class="o">&gt;</span> <span class="n">instance</span><span class="p">(</span><span class="n">options</span><span class="p">);</span>
-<span class="n">instance</span><span class="p">.</span><span class="n">run</span><span class="p">();</span>
-</pre></div>
-</div>
 </div>
-<div class="section" id="public-members">
-<h4>Public Members<a class="headerlink" href="#public-members" title="Permalink to this headline">¶</a></h4>
-<p>The following definitions assume that a properly constructed <code class="docutils literal"><span class="pre">http_server</span></code>
-instance has been constructed in the following manner:</p>
-<div class="highlight-c++"><div class="highlight"><pre><span></span><span class="n">handler_type</span> <span class="n">handler</span><span class="p">;</span>
-<span class="n">http_server</span><span class="o">::</span><span class="n">options</span> <span class="n">options</span><span class="p">(</span><span class="n">handler</span><span class="p">);</span>
-<span class="n">http_server</span> <span class="nf">server</span><span class="p">(</span><span class="n">options</span><span class="p">.</span><span class="n">address</span><span class="p">(</span><span class="s">&quot;127.0.0.1&quot;</span><span class="p">).</span><span class="n">port</span><span class="p">(</span><span class="s">&quot;8000&quot;</span><span class="p">));</span>
-</pre></div>
-</div>
-<dl class="docutils">
-<dt><code class="docutils literal"><span class="pre">server.run()</span></code></dt>
-<dd>Run the HTTP Server event loop. This function can be run on multiple threads
-following the example:</dd>
-</dl>
-<div class="highlight-c++"><div class="highlight"><pre><span></span><span class="n">boost</span><span class="o">::</span><span class="kr">thread</span> <span class="n">t1</span><span class="p">(</span><span class="n">boost</span><span class="o">::</span><span class="n">bind</span><span class="p">(</span><span class="o">&amp;</span><span class="n">http_server</span><span class="o">::</span><span class="n">run</span><span class="p">,</span> <span class="o">&amp;</span><span class="n">server</span><span class="p">));</span>
-<span class="n">boost</span><span class="o">::</span><span class="kr">thread</span> <span class="n">t2</span><span class="p">(</span><span class="n">boost</span><span class="o">::</span><span class="n">bind</span><span class="p">(</span><span class="o">&amp;</span><span class="n">http_server</span><span class="o">::</span><span class="n">run</span><span class="p">,</span> <span class="o">&amp;</span><span class="n">server</span><span class="p">));</span>
-<span class="n">server</span><span class="p">.</span><span class="n">run</span><span class="p">();</span>
-<span class="n">t1</span><span class="p">.</span><span class="n">join</span><span class="p">();</span>
-<span class="n">t2</span><span class="p">.</span><span class="n">join</span><span class="p">();</span>
-</pre></div>
+<div class="section" id="server-options">
+<h3>Server Options<a class="headerlink" href="#server-options" title="Permalink to this headline">¶</a></h3>
+<dl class="class">
+<dt>
+<span class="target" id="cppnetlibstructboost_1_1network_1_1http_1_1server__options"></span><em class="property">template </em>&lt;class <em>Tag</em>, class <em>Handler</em>&gt;</dt>
+<dt id="_CPPv2N5boost7network4http14server_optionsE">
+<span id="boost::network::http::server_options"></span><em class="property">struct </em><code class="descclassname">boost::network::http::</code><code class="descname">server_options</code><a class="headerlink" href="#_CPPv2N5boost7network4http14server_optionsE" title="Permalink to this definition">¶</a></dt>
+<dd><p>The options supported by an HTTP Server&#8217;s constructor. </p>
+<div class="breathe-sectiondef container">
+<p class="breathe-sectiondef-title rubric">Public Functions</p>
+<dl class="function">
+<dt id="_CPPv2N5boost7network4http14server_options14server_optionsER7Handler">
+<span id="boost::network::http::server_options::server_options__HandlerR"></span><span class="target" id="cppnetlibstructboost_1_1network_1_1http_1_1server__options_1abf9af18765187285cc6bde1337d5f8b3"></span><code class="descname">server_options</code><span class="sig-paren">(</span>Handler &amp;<em>handler</em><span class="sig-paren">)</span><a class="headerlink" href="#_CPPv2N5boost7network4http14server_options14server_optionsER7Handler" title="Permalink to this definition">¶</a></dt>
+<dd><p>A single-argument constructor that takes a Handler, and sets all options to defaults. </p>
+</dd></dl>
+
+<dl class="function">
+<dt id="_CPPv2N5boost7network4http14server_options14server_optionsEv">
+<span id="boost::network::http::server_options::server_options"></span><span class="target" id="cppnetlibstructboost_1_1network_1_1http_1_1server__options_1a12d3f97e677f5976756f4b433fb32eb2"></span><code class="descname">server_options</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#_CPPv2N5boost7network4http14server_options14server_optionsEv" title="Permalink to this definition">¶</a></dt>
+<dd><p>Disabled default constructor for the options class. </p>
+</dd></dl>
+
+<dl class="function">
+<dt id="_CPPv2N5boost7network4http14server_options14server_optionsERK14server_options">
+<span id="boost::network::http::server_options::server_options__server_optionsCR"></span><span class="target" id="cppnetlibstructboost_1_1network_1_1http_1_1server__options_1ab069a731d77d61983ca5ad4ece7013d7"></span><code class="descname">server_options</code><span class="sig-paren">(</span><em class="property">const</em> <a class="reference internal" href="#_CPPv2N5boost7network4http14server_options14server_optionsER7Handler" title="boost::network::http::server_options::server_options">server_options</a>&amp;<span class="sig-paren">)</span><a class="headerlink" href="#_CPPv2N5boost7network4http14server_options14server_optionsERK14server_options" title="Permalink to this definition">¶</a></dt>
+<dd><p>Copy constructor for the options class. </p>
+</dd></dl>
+
+<dl class="function">
+<dt id="_CPPv2N5boost7network4http14server_optionsaSERK14server_options">
+<span id="boost::network::http::server_options::assign-operator__server_optionsCR"></span><span class="target" id="cppnetlibstructboost_1_1network_1_1http_1_1server__options_1aa71091762f0383f71aa7904d65165542"></span><a class="reference internal" href="#_CPPv2N5boost7network4http14server_options14server_optionsER7Handler" title="boost::network::http::server_options::server_options">server_options</a> &amp;<code class="descname">operator=</code><span class="sig-paren">(</span><em class="property">const</em> <a class="reference internal" href="#_CPPv2N5boost7network4http14server_options14server_optionsER7Handler" title="boost::network::http::server_options::server_options">server_options</a>&amp;<span class="sig-paren">)</span><a class="headerlink" href="#_CPPv2N5boost7network4http14server_optionsaSERK14server_options" title="Permalink to this definition">¶</a></dt>
+<dd><p>Copy assignment for the options class. </p>
+</dd></dl>
+
+<dl class="function">
+<dt id="_CPPv2N5boost7network4http14server_options14server_optionsERR14server_options">
+<span id="boost::network::http::server_options::server_options__server_optionsRR"></span><span class="target" id="cppnetlibstructboost_1_1network_1_1http_1_1server__options_1aaa73f2c3bfd7541f4a89c9eb3be0f13b"></span><code class="descname">server_options</code><span class="sig-paren">(</span><a class="reference internal" href="#_CPPv2N5boost7network4http14server_options14server_optionsER7Handler" title="boost::network::http::server_options::server_options">server_options</a>&amp;&amp;<span class="sig-paren">)</span><a class="headerlink" href="#_CPPv2N5boost7network4http14server_options14server_optionsERR14server_options" title="Permalink to this definition">¶</a></dt>
+<dd><p>Move constructor for the options class. </p>
+</dd></dl>
+
+<dl class="function">
+<dt id="_CPPv2N5boost7network4http14server_optionsaSERR14server_options">
+<span id="boost::network::http::server_options::assign-operator__server_optionsRR"></span><span class="target" id="cppnetlibstructboost_1_1network_1_1http_1_1server__options_1a0fcba71831c2a2bcdf6337534abe9afd"></span><a class="reference internal" href="#_CPPv2N5boost7network4http14server_options14server_optionsER7Handler" title="boost::network::http::server_options::server_options">server_options</a> &amp;<code class="descname">operator=</code><span class="sig-paren">(</span><a class="reference internal" href="#_CPPv2N5boost7network4http14server_options14server_optionsER7Handler" title="boost::network::http::server_options::server_options">server_options</a>&amp;&amp;<span class="sig-paren">)</span><a class="headerlink" href="#_CPPv2N5boost7network4http14server_optionsaSERR14server_options" title="Permalink to this definition">¶</a></dt>
+<dd><p>Move assignment for the options class. </p>
+</dd></dl>
+
+<dl class="function">
+<dt id="_CPPv2N5boost7network4http14server_optionsD0Ev">
+<span id="boost::network::http::server_options::~server_options"></span><span class="target" id="cppnetlibstructboost_1_1network_1_1http_1_1server__options_1a20ee60d6d7468be2e49b184984a39f15"></span><code class="descname">~server_options</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#_CPPv2N5boost7network4http14server_optionsD0Ev" title="Permalink to this definition">¶</a></dt>
+<dd><p>Destructor for the options class. </p>
+</dd></dl>
+
+<dl class="function">
+<dt id="_CPPv2N5boost7network4http14server_options7contextENSt10shared_ptrI11ssl_contextEE">
+<span id="boost::network::http::server_options::context__std::shared_ptr:ssl_context:"></span><span class="target" id="cppnetlibstructboost_1_1network_1_1http_1_1server__options_1afc6ec13db274b337a7067bb657c10a8f"></span><a class="reference internal" href="#_CPPv2N5boost7network4http14server_options14server_optionsER7Handler" title="boost::network::http::server_options::server_options">server_options</a> &amp;<code class="descname">context</code><span class="sig-paren">(</span>std::shared_ptr&lt;ssl_context&gt; <em>v</em><span class="sig-paren">)</span><a class="headerlink" href="#_CPPv2N5boost7network4http14server_options7contextENSt10shared_ptrI11ssl_contextEE" title="Permalink to this definition">¶</a></dt>
+<dd><p>Sets the SSL context for the server. Default is nullptr. </p>
+</dd></dl>
+
+<dl class="function">
+<dt id="_CPPv2N5boost7network4http14server_options10io_serviceENSt10shared_ptrIN4asio10io_serviceEEE">
+<span id="boost::network::http::server_options::io_service__std::shared_ptr:asio::io_service:"></span><span class="target" id="cppnetlibstructboost_1_1network_1_1http_1_1server__options_1ac1b9b3d37160070ce0e4a716a0591998"></span><a class="reference internal" href="#_CPPv2N5boost7network4http14server_options14server_optionsER7Handler" title="boost::network::http::server_options::server_options">server_options</a> &amp;<code class="descname">io_service</code><span class="sig-paren">(</span>std::shared_ptr&lt;asio::io_service&gt; <em>v</em><span class="sig-paren">)</span><a class="headerlink" href="#_CPPv2N5boost7network4http14server_options10io_serviceENSt10shared_ptrIN4asio10io_serviceEEE" title="Permalink to this definition">¶</a></dt>
+<dd><p>Provides an Asio io_service for the server. Default is nullptr. </p>
+</dd></dl>
+
+<dl class="function">
+<dt id="_CPPv2N5boost7network4http14server_options7addressE11string_type">
+<span id="boost::network::http::server_options::address__string_type"></span><span class="target" id="cppnetlibstructboost_1_1network_1_1http_1_1server__options_1a19ad2b3bebc165f268e6ad9273096e53"></span><a class="reference internal" href="#_CPPv2N5boost7network4http14server_options14server_optionsER7Handler" title="boost::network::http::server_options::server_options">server_options</a> &amp;<code class="descname">address</code><span class="sig-paren">(</span>string_type <em>v</em><span class="sig-paren">)</span><a class="headerlink" href="#_CPPv2N5boost7network4http14server_options7addressE11string_type" title="Permalink to this definition">¶</a></dt>
+<dd><p>Sets the address to listen to for the server. Default is localhost. </p>
+</dd></dl>
+
+<dl class="function">
+<dt id="_CPPv2N5boost7network4http14server_options4portER11string_type">
+<span id="boost::network::http::server_options::port__string_typeCR"></span><span class="target" id="cppnetlibstructboost_1_1network_1_1http_1_1server__options_1a013f7f63ae3497a4d644cb28cfd8be96"></span><a class="reference internal" href="#_CPPv2N5boost7network4http14server_options14server_optionsER7Handler" title="boost::network::http::server_options::server_options">server_options</a> &amp;<code class="descname">port</code><span class="sig-paren">(</span>string_type <em class="property">const</em> &amp;<em>v</em><span class="sig-paren">)</span><a class="headerlink" href="#_CPPv2N5boost7network4http14server_options4portER11string_type" title="Permalink to this definition">¶</a></dt>
+<dd><p>Set the port to listen to for the server. Default is 80. </p>
+</dd></dl>
+
+<dl class="function">
+<dt id="_CPPv2N5boost7network4http14server_options13reuse_addressEb">
+<span id="boost::network::http::server_options::reuse_address__b"></span><span class="target" id="cppnetlibstructboost_1_1network_1_1http_1_1server__options_1a5420b1d37c24e15d688555e370d41e10"></span><a class="reference internal" href="#_CPPv2N5boost7network4http14server_options14server_optionsER7Handler" title="boost::network::http::server_options::server_options">server_options</a> &amp;<code class="descname">reuse_address</code><span class="sig-paren">(</span>bool <em>v</em><span class="sig-paren">)</span><a class="headerlink" href="#_CPPv2N5boost7network4http14server_options13reuse_addressEb" title="Permalink to this definition">¶</a></dt>
+<dd><p>Set whether to reuse the address (SO_REUSE_ADDR). Default is false. </p>
+</dd></dl>
+
+<dl class="function">
+<dt id="_CPPv2N5boost7network4http14server_options14report_abortedEb">
+<span id="boost::network::http::server_options::report_aborted__b"></span><span class="target" id="cppnetlibstructboost_1_1network_1_1http_1_1server__options_1aa556226ef13f57eba098e28031201070"></span><a class="reference internal" href="#_CPPv2N5boost7network4http14server_options14server_optionsER7Handler" title="boost::network::http::server_options::server_options">server_options</a> &amp;<code class="descname">report_aborted</code><span class="sig-paren">(</span>bool <em>v</em><span class="sig-paren">)</span><a class="headerlink" href="#_CPPv2N5boost7network4http14server_options14report_abortedEb" title="Permalink to this definition">¶</a></dt>
+<dd><p>Set whether to report aborted connections. Default is false. </p>
+</dd></dl>
+
+<dl class="function">
+<dt id="_CPPv2N5boost7network4http14server_options15non_blocking_ioEb">
+<span id="boost::network::http::server_options::non_blocking_io__b"></span><span class="target" id="cppnetlibstructboost_1_1network_1_1http_1_1server__options_1acb8fe8f75308f5aff44243f8a50d8764"></span><a class="reference internal" href="#_CPPv2N5boost7network4http14server_options14server_optionsER7Handler" title="boost::network::http::server_options::server_options">server_options</a> &amp;<code class="descname">non_blocking_io</code><span class="sig-paren">(</span>bool <em>v</em><span class="sig-paren">)</span><a class="headerlink" href="#_CPPv2N5boost7network4http14server_options15non_blocking_ioEb" title="Permalink to this definition">¶</a></dt>
+<dd><p>Set whether to use non-blocking IO. Default is true. </p>
+</dd></dl>
+
+<dl class="function">
+<dt id="_CPPv2N5boost7network4http14server_options6lingerEb">
+<span id="boost::network::http::server_options::linger__b"></span><span class="target" id="cppnetlibstructboost_1_1network_1_1http_1_1server__options_1a40e9a857b04b10237164cf71b6c15b73"></span><a class="reference internal" href="#_CPPv2N5boost7network4http14server_options14server_optionsER7Handler" title="boost::network::http::server_options::server_options">server_options</a> &amp;<code class="descname">linger</code><span class="sig-paren">(</span>bool <em>v</em><span class="sig-paren">)</span><a class="headerlink" href="#_CPPv2N5boost7network4http14server_options6lingerEb" title="Permalink to this definition">¶</a></dt>
+<dd><p>Set whether sockets linger (SO_LINGER). Default is true. </p>
+</dd></dl>
+
+<dl class="function">
+<dt id="_CPPv2N5boost7network4http14server_options14linger_timeoutE6size_t">
+<span id="boost::network::http::server_options::linger_timeout__s"></span><span class="target" id="cppnetlibstructboost_1_1network_1_1http_1_1server__options_1a108484ab86498c54173887b32861cf7f"></span><a class="reference internal" href="#_CPPv2N5boost7network4http14server_options14server_optionsER7Handler" title="boost::network::http::server_options::server_options">server_options</a> &amp;<code class="descname">linger_timeout</code><span class="sig-paren">(</span>size_t <em>v</em><span class="sig-paren">)</span><a class="headerlink" href="#_CPPv2N5boost7network4http14server_options14linger_timeoutE6size_t" title="Permalink to this definition">¶</a></dt>
+<dd><p>Set the linger timeout. Default is 0. </p>
+</dd></dl>
+
+<dl class="function">
+<dt id="_CPPv2N5boost7network4http14server_options19receive_buffer_sizeEN4asio11socket_base19receive_buffer_sizeE">
+<span id="boost::network::http::server_options::receive_buffer_size__asio::socket_base::receive_buffer_size"></span><span class="target" id="cppnetlibstructboost_1_1network_1_1http_1_1server__options_1a71efee670efa9e4cba556ce8df027ca1"></span><a class="reference internal" href="#_CPPv2N5boost7network4http14server_options14server_optionsER7Handler" title="boost::network::http::server_options::server_options">server_options</a> &amp;<code class="descname">receive_buffer_size</code><span class="sig-paren">(</span>asio::socket_base::receive_buffer_size <em>v</em><span class="sig-paren">)</span><a class="headerlink" href="#_CPPv2N5boost7network4http14server_options19receive_buffer_sizeEN4asio11socket_base19receive_buffer_sizeE" title="Permalink to this definition">¶</a></dt>
+<dd><p>Set the socket receive buffer size. Unset by default. </p>
+</dd></dl>
+
+<dl class="function">
+<dt id="_CPPv2N5boost7network4http14server_options16send_buffer_sizeEN4asio11socket_base16send_buffer_sizeE">
+<span id="boost::network::http::server_options::send_buffer_size__asio::socket_base::send_buffer_size"></span><span class="target" id="cppnetlibstructboost_1_1network_1_1http_1_1server__options_1a2a8d88b07101fe17574fc1da9dc9c7ac"></span><a class="reference internal" href="#_CPPv2N5boost7network4http14server_options14server_optionsER7Handler" title="boost::network::http::server_options::server_options">server_options</a> &amp;<code class="descname">send_buffer_size</code><span class="sig-paren">(</span>asio::socket_base::send_buffer_size <em>v</em><span class="sig-paren">)</span><a class="headerlink" href="#_CPPv2N5boost7network4http14server_options16send_buffer_sizeEN4asio11socket_base16send_buffer_sizeE" title="Permalink to this definition">¶</a></dt>
+<dd><p>Set the send buffer size. Unset by default. </p>
+</dd></dl>
+
+<dl class="function">
+<dt id="_CPPv2N5boost7network4http14server_options21receive_low_watermarkEN4asio11socket_base21receive_low_watermarkE">
+<span id="boost::network::http::server_options::receive_low_watermark__asio::socket_base::receive_low_watermark"></span><span class="target" id="cppnetlibstructboost_1_1network_1_1http_1_1server__options_1a49557100cb665c40c112cde0af9e19ee"></span><a class="reference internal" href="#_CPPv2N5boost7network4http14server_options14server_optionsER7Handler" title="boost::network::http::server_options::server_options">server_options</a> &amp;<code class="descname">receive_low_watermark</code><span class="sig-paren">(</span>asio::socket_base::receive_low_watermark <em>v</em><span class="sig-paren">)</span><a class="headerlink" href="#_CPPv2N5boost7network4http14server_options21receive_low_watermarkEN4asio11socket_base21receive_low_watermarkE" title="Permalink to this definition">¶</a></dt>
+<dd><p>Set the socket receive low watermark. Unset by default. </p>
+</dd></dl>
+
+<dl class="function">
+<dt id="_CPPv2N5boost7network4http14server_options18send_low_watermarkEN4asio11socket_base18send_low_watermarkE">
+<span id="boost::network::http::server_options::send_low_watermark__asio::socket_base::send_low_watermark"></span><span class="target" id="cppnetlibstructboost_1_1network_1_1http_1_1server__options_1ad4d000db7c9f42d9c61fc8c788d8b832"></span><a class="reference internal" href="#_CPPv2N5boost7network4http14server_options14server_optionsER7Handler" title="boost::network::http::server_options::server_options">server_options</a> &amp;<code class="descname">send_low_watermark</code><span class="sig-paren">(</span>asio::socket_base::send_low_watermark <em>v</em><span class="sig-paren">)</span><a class="headerlink" href="#_CPPv2N5boost7network4http14server_options18send_low_watermarkEN4asio11socket_base18send_low_watermarkE" title="Permalink to this definition">¶</a></dt>
+<dd><p>Set the socket send low watermark. Unset by default. </p>
+</dd></dl>
+
+<dl class="function">
+<dt id="_CPPv2N5boost7network4http14server_options11thread_poolENSt10shared_ptrIN5utils11thread_poolEEE">
+<span id="boost::network::http::server_options::thread_pool__std::shared_ptr:utils::thread_pool:"></span><span class="target" id="cppnetlibstructboost_1_1network_1_1http_1_1server__options_1a228ccc0a29ad4ae785119f75682e6ed0"></span><a class="reference internal" href="#_CPPv2N5boost7network4http14server_options14server_optionsER7Handler" title="boost::network::http::server_options::server_options">server_options</a> &amp;<code class="descname">thread_pool</code><span class="sig-paren">(</span>std::shared_ptr&lt;utils::thread_pool&gt; <em>v</em><span class="sig-paren">)</span><a class="headerlink" href="#_CPPv2N5boost7network4http14server_options11thread_poolENSt10shared_ptrIN5utils11thread_poolEEE" title="Permalink to this definition">¶</a></dt>
+<dd><p>Set the thread-pool to use. Default is nullptr. </p>
+</dd></dl>
+
+<dl class="function">
+<dt id="_CPPv2N5boost7network4http14server_options10io_serviceEv">
+<span id="boost::network::http::server_options::io_service"></span><span class="target" id="cppnetlibstructboost_1_1network_1_1http_1_1server__options_1ad75c89b4b43c83ca4b49ab9b1a680ee0"></span>std::shared_ptr&lt;asio::io_service&gt; <code class="descname">io_service</code><span class="sig-paren">(</span><span class="sig-paren">)</span> const<a class="headerlink" href="#_CPPv2N5boost7network4http14server_options10io_serviceEv" title="Permalink to this definition">¶</a></dt>
+<dd><p>Returns the provided Asio io_service. </p>
+</dd></dl>
+
+<dl class="function">
+<dt id="_CPPv2N5boost7network4http14server_options7addressEv">
+<span id="boost::network::http::server_options::address"></span><span class="target" id="cppnetlibstructboost_1_1network_1_1http_1_1server__options_1a4580c0b0a27c31b371fcb0318dabb831"></span>string_type <code class="descname">address</code><span class="sig-paren">(</span><span class="sig-paren">)</span> const<a class="headerlink" href="#_CPPv2N5boost7network4http14server_options7addressEv" title="Permalink to this definition">¶</a></dt>
+<dd><p>Returns the address to listen on. </p>
+</dd></dl>
+
+<dl class="function">
+<dt id="_CPPv2N5boost7network4http14server_options4portEv">
+<span id="boost::network::http::server_options::port"></span><span class="target" id="cppnetlibstructboost_1_1network_1_1http_1_1server__options_1a983e7457901b56b74749e537e9628790"></span>string_type <code class="descname">port</code><span class="sig-paren">(</span><span class="sig-paren">)</span> const<a class="headerlink" href="#_CPPv2N5boost7network4http14server_options4portEv" title="Permalink to this definition">¶</a></dt>
+<dd><p>Returns the port to listen on. </p>
+</dd></dl>
+
+<dl class="function">
+<dt id="_CPPv2N5boost7network4http14server_options7handlerEv">
+<span id="boost::network::http::server_options::handler"></span><span class="target" id="cppnetlibstructboost_1_1network_1_1http_1_1server__options_1aadeeb4a853489e80f0f0df97350f56c5"></span>Handler &amp;<code class="descname">handler</code><span class="sig-paren">(</span><span class="sig-paren">)</span> const<a class="headerlink" href="#_CPPv2N5boost7network4http14server_options7handlerEv" title="Permalink to this definition">¶</a></dt>
+<dd><p>Returns a reference to the provided handler. </p>
+</dd></dl>
+
+<dl class="function">
+<dt id="_CPPv2N5boost7network4http14server_options13reuse_addressEv">
+<span id="boost::network::http::server_options::reuse_address"></span><span class="target" id="cppnetlibstructboost_1_1network_1_1http_1_1server__options_1ade26cd4c50c3533db9897222da26cf72"></span>bool <code class="descname">reuse_address</code><span class="sig-paren">(</span><span class="sig-paren">)</span> const<a class="headerlink" href="#_CPPv2N5boost7network4http14server_options13reuse_addressEv" title="Permalink to this definition">¶</a></dt>
+<dd><p>Returns whether to reuse the address. </p>
+</dd></dl>
+
+<dl class="function">
+<dt id="_CPPv2N5boost7network4http14server_options14report_abortedEv">
+<span id="boost::network::http::server_options::report_aborted"></span><span class="target" id="cppnetlibstructboost_1_1network_1_1http_1_1server__options_1a9cd725f59857166d35ea9b09f96cefa5"></span>bool <code class="descname">report_aborted</code><span class="sig-paren">(</span><span class="sig-paren">)</span> const<a class="headerlink" href="#_CPPv2N5boost7network4http14server_options14report_abortedEv" title="Permalink to this definition">¶</a></dt>
+<dd><p>Returns whether to report aborted connections. </p>
+</dd></dl>
+
+<dl class="function">
+<dt id="_CPPv2N5boost7network4http14server_options15non_blocking_ioEv">
+<span id="boost::network::http::server_options::non_blocking_io"></span><span class="target" id="cppnetlibstructboost_1_1network_1_1http_1_1server__options_1a89716aacbb765c6fc99120d98743ad3c"></span>bool <code class="descname">non_blocking_io</code><span class="sig-paren">(</span><span class="sig-paren">)</span> const<a class="headerlink" href="#_CPPv2N5boost7network4http14server_options15non_blocking_ioEv" title="Permalink to this definition">¶</a></dt>
+<dd><p>Returns whether to perform non-blocking IO. </p>
+</dd></dl>
+
+<dl class="function">
+<dt id="_CPPv2N5boost7network4http14server_options6lingerEv">
+<span id="boost::network::http::server_options::linger"></span><span class="target" id="cppnetlibstructboost_1_1network_1_1http_1_1server__options_1ac8f981bf13f92b7d2ef24ee04c6ab797"></span>bool <code class="descname">linger</code><span class="sig-paren">(</span><span class="sig-paren">)</span> const<a class="headerlink" href="#_CPPv2N5boost7network4http14server_options6lingerEv" title="Permalink to this definition">¶</a></dt>
+<dd><p>Returns whether to linger. </p>
+</dd></dl>
+
+<dl class="function">
+<dt id="_CPPv2N5boost7network4http14server_options14linger_timeoutEv">
+<span id="boost::network::http::server_options::linger_timeout"></span><span class="target" id="cppnetlibstructboost_1_1network_1_1http_1_1server__options_1a05a6c4fe5caf2636373006ad4f80a837"></span>size_t <code class="descname">linger_timeout</code><span class="sig-paren">(</span><span class="sig-paren">)</span> const<a class="headerlink" href="#_CPPv2N5boost7network4http14server_options14linger_timeoutEv" title="Permalink to this definition">¶</a></dt>
+<dd><p>Returns the linger timeout. </p>
+</dd></dl>
+
+<dl class="function">
+<dt id="_CPPv2N5boost7network4http14server_options19receive_buffer_sizeEv">
+<span id="boost::network::http::server_options::receive_buffer_size"></span><span class="target" id="cppnetlibstructboost_1_1network_1_1http_1_1server__options_1a90fb005458e5bb74d5b5cb330b462a44"></span>boost::optional&lt;asio::socket_base::receive_buffer_size&gt; <code class="descname">receive_buffer_size</code><span class="sig-paren">(</span><span class="sig-paren">)</span> const<a class="headerlink" href="#_CPPv2N5boost7network4http14server_options19receive_buffer_sizeEv" title="Permalink to this definition">¶</a></dt>
+<dd><p>Returns the optional receive buffer size. </p>
+</dd></dl>
+
+<dl class="function">
+<dt id="_CPPv2N5boost7network4http14server_options16send_buffer_sizeEv">
+<span id="boost::network::http::server_options::send_buffer_size"></span><span class="target" id="cppnetlibstructboost_1_1network_1_1http_1_1server__options_1a13d296d0b69f81d6ec8bf2b745eec9ff"></span>boost::optional&lt;asio::socket_base::send_buffer_size&gt; <code class="descname">send_buffer_size</code><span class="sig-paren">(</span><span class="sig-paren">)</span> const<a class="headerlink" href="#_CPPv2N5boost7network4http14server_options16send_buffer_sizeEv" title="Permalink to this definition">¶</a></dt>
+<dd><p>Returns the optional send buffer size. </p>
+</dd></dl>
+
+<dl class="function">
+<dt id="_CPPv2N5boost7network4http14server_options21receive_low_watermarkEv">
+<span id="boost::network::http::server_options::receive_low_watermark"></span><span class="target" id="cppnetlibstructboost_1_1network_1_1http_1_1server__options_1a2278ed6da4e3d861347dfeaccb50e4ba"></span>boost::optional&lt;asio::socket_base::receive_low_watermark&gt; <code class="descname">receive_low_watermark</code><span class="sig-paren">(</span><span class="sig-paren">)</span> const<a class="headerlink" href="#_CPPv2N5boost7network4http14server_options21receive_low_watermarkEv" title="Permalink to this definition">¶</a></dt>
+<dd><p>Returns the optional receive low watermark. </p>
+</dd></dl>
+
+<dl class="function">
+<dt id="_CPPv2N5boost7network4http14server_options18send_low_watermarkEv">
+<span id="boost::network::http::server_options::send_low_watermark"></span><span class="target" id="cppnetlibstructboost_1_1network_1_1http_1_1server__options_1a38065fc14fc53235c4f2392ea2004080"></span>boost::optional&lt;asio::socket_base::send_low_watermark&gt; <code class="descname">send_low_watermark</code><span class="sig-paren">(</span><span class="sig-paren">)</span> const<a class="headerlink" href="#_CPPv2N5boost7network4http14server_options18send_low_watermarkEv" title="Permalink to this definition">¶</a></dt>
+<dd><p>Returns the optional send low watermark. </p>
+</dd></dl>
+
+<dl class="function">
+<dt id="_CPPv2N5boost7network4http14server_options11thread_poolEv">
+<span id="boost::network::http::server_options::thread_pool"></span><span class="target" id="cppnetlibstructboost_1_1network_1_1http_1_1server__options_1ab2bb3645ef3be04b01606b0484599129"></span>std::shared_ptr&lt;utils::thread_pool&gt; <code class="descname">thread_pool</code><span class="sig-paren">(</span><span class="sig-paren">)</span> const<a class="headerlink" href="#_CPPv2N5boost7network4http14server_options11thread_poolEv" title="Permalink to this definition">¶</a></dt>
+<dd><p>Returns a pointer to the provided thread pool. </p>
+</dd></dl>
+
+<dl class="function">
+<dt id="_CPPv2N5boost7network4http14server_options7contextEv">
+<span id="boost::network::http::server_options::context"></span><span class="target" id="cppnetlibstructboost_1_1network_1_1http_1_1server__options_1a7acb5bb27b3fa928500b37192389460c"></span>std::shared_ptr&lt;ssl_context&gt; <code class="descname">context</code><span class="sig-paren">(</span><span class="sig-paren">)</span> const<a class="headerlink" href="#_CPPv2N5boost7network4http14server_options7contextEv" title="Permalink to this definition">¶</a></dt>
+<dd><p>Returns a pointer to the provided context. </p>
+</dd></dl>
+
+<dl class="function">
+<dt id="_CPPv2N5boost7network4http14server_options4swapER14server_options">
+<span id="boost::network::http::server_options::swap__server_optionsR"></span><span class="target" id="cppnetlibstructboost_1_1network_1_1http_1_1server__options_1a194e0cc3d88ffd2bebc843aa4003db3b"></span>void <code class="descname">swap</code><span class="sig-paren">(</span><a class="reference internal" href="#_CPPv2N5boost7network4http14server_options14server_optionsER7Handler" title="boost::network::http::server_options::server_options">server_options</a> &amp;<em>other</em><span class="sig-paren">)</span><a class="headerlink" href="#_CPPv2N5boost7network4http14server_options4swapER14server_options" title="Permalink to this definition">¶</a></dt>
+<dd><p>Swap implementation for the server options. </p>
+</dd></dl>
+
 </div>
-<dl class="docutils">
-<dt><code class="docutils literal"><span class="pre">server.stop()</span></code></dt>
-<dd>Stop the HTTP Server acceptor and wait for all pending requests to finish.</dd>
-</dl>
+</dd></dl>
+
 </div>
-<div class="section" id="response-object">
-<h4>Response Object<a class="headerlink" href="#response-object" title="Permalink to this headline">¶</a></h4>
-<p>The response object has its own public member functions which can be very
-helpful in certain simple situations.</p>
-<dl class="docutils">
-<dt><code class="docutils literal"><span class="pre">response</span> <span class="pre">=</span> <span class="pre">http_server::response::stock_reply(status,</span> <span class="pre">body)</span></code></dt>
-<dd>Code like the above should go inside the handler&#8217;s <code class="docutils literal"><span class="pre">operator()</span></code> overload.
-The body parameter is an <code class="docutils literal"><span class="pre">std::string</span></code>. The status parameter is any of
-the following values from the <code class="docutils literal"><span class="pre">http_server::response</span></code> enum
-<code class="docutils literal"><span class="pre">status_type</span></code>:</dd>
-</dl>
-<div class="highlight-c++"><div class="highlight"><pre><span></span><span class="k">enum</span> <span class="n">status_type</span> <span class="p">{</span>
-    <span class="n">ok</span> <span class="o">=</span> <span class="mi">200</span><span class="p">,</span>
-    <span class="n">created</span> <span class="o">=</span> <span class="mi">201</span><span class="p">,</span>
-    <span class="n">accepted</span> <span class="o">=</span> <span class="mi">202</span><span class="p">,</span>
-    <span class="n">no_content</span> <span class="o">=</span> <span class="mi">204</span><span class="p">,</span>
-    <span class="n">multiple_choices</span> <span class="o">=</span> <span class="mi">300</span><span class="p">,</span>
-    <span class="n">moved_permanently</span> <span class="o">=</span> <span class="mi">301</span><span class="p">,</span>
-    <span class="n">moved_temporarily</span> <span class="o">=</span> <span class="mi">302</span><span class="p">,</span>
-    <span class="n">not_modified</span> <span class="o">=</span> <span class="mi">304</span><span class="p">,</span>
-    <span class="n">bad_request</span> <span class="o">=</span> <span class="mi">400</span><span class="p">,</span>
-    <span class="n">unauthorized</span> <span class="o">=</span> <span class="mi">401</span><span class="p">,</span>
-    <span class="n">forbidden</span> <span class="o">=</span> <span class="mi">403</span><span class="p">,</span>
-    <span class="n">not_found</span> <span class="o">=</span> <span class="mi">404</span><span class="p">,</span>
-    <span class="n">not_supported</span> <span class="o">=</span> <span class="mi">405</span><span class="p">,</span>
-    <span class="n">not_acceptable</span> <span class="o">=</span> <span class="mi">406</span><span class="p">,</span>
-    <span class="n">internal_server_error</span> <span class="o">=</span> <span class="mi">500</span><span class="p">,</span>
-    <span class="n">not_implemented</span> <span class="o">=</span> <span class="mi">501</span><span class="p">,</span>
-    <span class="n">bad_gateway</span> <span class="o">=</span> <span class="mi">502</span><span class="p">,</span>
-    <span class="n">service_unavailable</span> <span class="o">=</span> <span class="mi">503</span>
-<span class="p">};</span>
+<div class="section" id="public-members">
+<h3>Public Members<a class="headerlink" href="#public-members" title="Permalink to this headline">¶</a></h3>
+<dl class="class">
+<dt>
+<span class="target" id="cppnetlibstructboost_1_1network_1_1http_1_1server"></span><em class="property">template </em>&lt;<em class="property">class</em> Handler&gt;</dt>
+<dt id="_CPPv2N5boost7network4http6serverE">
+<span id="boost::network::http::server"></span><em class="property">struct </em><code class="descclassname">boost::network::http::</code><code class="descname">server</code><a class="headerlink" href="#_CPPv2N5boost7network4http6serverE" title="Permalink to this definition">¶</a></dt>
+<dd><p>The main HTTP Server template implementing an asynchronous HTTP service.</p>
+<p>Usage Example:  <div class="highlight-python"><div class="highlight"><pre><span></span>handler_type handler;
+http_server::options options(handler);
+options.thread_pool(
+    std::make_shared&lt;boost::network::utils::thread_pool&gt;());
+http_server server(options.address(&quot;localhost&quot;).port(&quot;8000&quot;));
 </pre></div>
 </div>
-<p>The response object also has the following publicly accessible member values
-which can be directly manipulated by the handler.</p>
-<table border="1" class="docutils">
-<colgroup>
-<col width="24%" />
-<col width="29%" />
-<col width="47%" />
-</colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head">Member Name</th>
-<th class="head">Type</th>
-<th class="head">Description</th>
-</tr>
-</thead>
-<tbody valign="top">
-<tr class="row-even"><td>status</td>
-<td><code class="docutils literal"><span class="pre">status_type</span></code></td>
-<td>The HTTP status of the response.</td>
-</tr>
-<tr class="row-odd"><td>headers</td>
-<td><code class="docutils literal"><span class="pre">vector&lt;header&gt;</span></code></td>
-<td>Vector of headers. <a class="footnote-reference" href="#id3" id="id1">[1]</a></td>
-</tr>
-<tr class="row-even"><td>content</td>
-<td><code class="docutils literal"><span class="pre">string_type</span></code> <a class="footnote-reference" href="#id4" id="id2">[2]</a></td>
-<td>The contents of the response.</td>
-</tr>
-</tbody>
-</table>
-<table class="docutils footnote" frame="void" id="id3" rules="none">
-<colgroup><col class="label" /><col /></colgroup>
-<tbody valign="top">
-<tr><td class="label"><a class="fn-backref" href="#id1">[1]</a></td><td>A header is a struct of type
-<code class="docutils literal"><span class="pre">response_header&lt;http::tags::http_server&gt;</span></code>. An instance always has the
-members <code class="docutils literal"><span class="pre">name</span></code> and <code class="docutils literal"><span class="pre">value</span></code> both of which are of type <code class="docutils literal"><span class="pre">string_type</span></code>.</td></tr>
-</tbody>
-</table>
-<table class="docutils footnote" frame="void" id="id4" rules="none">
-<colgroup><col class="label" /><col /></colgroup>
-<tbody valign="top">
-<tr><td class="label"><a class="fn-backref" href="#id2">[2]</a></td><td><code class="docutils literal"><span class="pre">string_type</span></code> is
-<code class="docutils literal"><span class="pre">boost::network::string&lt;http::tags::http_server&gt;::type</span></code>.</td></tr>
-</tbody>
-</table>
-</div>
-</div>
-</div>
-<div class="section" id="asynchronous-servers">
-<h2>Asynchronous Servers<a class="headerlink" href="#asynchronous-servers" title="Permalink to this headline">¶</a></h2>
-<p>The asynchronous server implementation is significantly different to the
-synchronous server implementation in three ways:</p>
-<blockquote>
-<div><ol class="arabic simple">
-<li><strong>The Handler instance is invoked asynchronously</strong>. This means the I/O
-thread used to handle network-related events are free to handle only the
-I/O related events. This enables the server to scale better as to the
-number of concurrent connections it can handle.</li>
-<li><strong>The Handler is able to schedule asynchronous actions on the thread pool
-associated with the server.</strong> This allows handlers to perform multiple
-asynchronous computations that later on perform writes to the connection.</li>
-<li><strong>The Handler is able to control the (asynchronous) writes to and reads from
-the HTTP connection.</strong> Because the connection is available to the Handler,
-that means it can write out chunks of data at a time or stream data through
-the connection continuously.</li>
-</ol>
-</div></blockquote>
-<p>The asynchronous server is meant to allow for better scalability in terms of the
-number of concurrent connections and for performing asynchronous actions within
-the handlers. If your application does not need to write out information
-asynchronously or perform potentially long computations, then the synchronous
-server gives a generally better performance profile than the asynchronous
-server.</p>
-<p>The asynchronous server implementation is available from a single user-facing
-template named <code class="docutils literal"><span class="pre">async_server</span></code>. This template takes in a single template
-parameter which is the type of the Handler to be called once a request has been
-parsed from a connection.</p>
-<p>An instance of Handler is taken as a reference to the constructor similar to the
-synchronous server implementation.</p>
-<div class="admonition warning">
-<p class="first admonition-title">Warning</p>
-<p class="last">The asynchronous server implementation, like the synchronous server
-implementation, does not perform any synchronization on the calls to the
-Handler invocation. This means if your handler contains or maintains internal
-state, you are responsible for implementing your own synchronization on
-accesses to the internal state of the Handler.</p>
+</p>
+<p>Inherits from boost::network::http::async_server_base&lt; tags::http_server, Handler &gt;</p>
+<div class="breathe-sectiondef container">
+<p class="breathe-sectiondef-title rubric">Public Types</p>
+<dl class="type">
+<dt id="_CPPv2N5boost7network4http6server11server_baseE">
+<span id="boost::network::http::server::server_base"></span><span class="target" id="cppnetlibstructboost_1_1network_1_1http_1_1server_1a4e5f2b1783c4e797d7aacffdc9126770"></span><em class="property">typedef </em>async_server_base&lt;tags::http_server, Handler&gt; <code class="descname">server_base</code><a class="headerlink" href="#_CPPv2N5boost7network4http6server11server_baseE" title="Permalink to this definition">¶</a></dt>
+<dd><p>A convenience typedef for the base of this type, implementing most of the internal details. </p>
+</dd></dl>
+
+<dl class="type">
+<dt id="_CPPv2N5boost7network4http6server7optionsE">
+<span id="boost::network::http::server::options"></span><span class="target" id="cppnetlibstructboost_1_1network_1_1http_1_1server_1aa7880be8e651d6af16efaff526f37ac7"></span><em class="property">typedef </em><a class="reference internal" href="#_CPPv2N5boost7network4http14server_optionsE" title="boost::network::http::server_options">server_options</a>&lt;tags::http_server, Handler&gt; <code class="descname">options</code><a class="headerlink" href="#_CPPv2N5boost7network4http6server7optionsE" title="Permalink to this definition">¶</a></dt>
+<dd><p>The options supported by the server. </p>
+</dd></dl>
+
+<dl class="type">
+<dt id="_CPPv2N5boost7network4http17async_server_base7requestE">
+<span id="boost::network::http::async_server_base::request"></span><span class="target" id="cppnetlibstructboost_1_1network_1_1http_1_1async__server__base_1aa1bd7e517b6fcbb07e39c5260b90131d"></span><em class="property">typedef </em>basic_request&lt;tags::http_server&gt; <code class="descname">request</code><a class="headerlink" href="#_CPPv2N5boost7network4http17async_server_base7requestE" title="Permalink to this definition">¶</a></dt>
+<dd><p>The request type for this server. </p>
+</dd></dl>
+
+<dl class="type">
+<dt id="_CPPv2N5boost7network4http17async_server_base11string_typeE">
+<span id="boost::network::http::async_server_base::string_type"></span><span class="target" id="cppnetlibstructboost_1_1network_1_1http_1_1async__server__base_1a0a882e6c5e76a26efc950c894ef2c145"></span><em class="property">typedef </em>string&lt;tags::http_server&gt;::type <code class="descname">string_type</code><a class="headerlink" href="#_CPPv2N5boost7network4http17async_server_base11string_typeE" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="type">
+<dt id="_CPPv2N5boost7network4http17async_server_base15response_headerE">
+<span id="boost::network::http::async_server_base::response_header"></span><span class="target" id="cppnetlibstructboost_1_1network_1_1http_1_1async__server__base_1a6e17d4d32a618f4849e85ff1caa8e7c4"></span><em class="property">typedef </em>boost::network::http::response_header&lt;tags::http_server&gt;::type <code class="descname">response_header</code><a class="headerlink" href="#_CPPv2N5boost7network4http17async_server_base15response_headerE" title="Permalink to this definition">¶</a></dt>
+<dd><p>The header type for this server. </p>
+</dd></dl>
+
+<dl class="type">
+<dt id="_CPPv2N5boost7network4http17async_server_base10connectionE">
+<span id="boost::network::http::async_server_base::connection"></span><span class="target" id="cppnetlibstructboost_1_1network_1_1http_1_1async__server__base_1adb74643848806fae5e8940a300cf1143"></span><em class="property">typedef </em><a class="reference internal" href="#_CPPv2N5boost7network4http16async_connectionE" title="boost::network::http::async_connection">async_connection</a>&lt;tags::http_server, Handler&gt; <code class="descname">connection</code><a class="headerlink" href="#_CPPv2N5boost7network4http17async_server_base10connectionE" title="Permalink to this definition">¶</a></dt>
+<dd><p>The connection type for this server. </p>
+</dd></dl>
+
+<dl class="type">
+<dt id="_CPPv2N5boost7network4http17async_server_base14connection_ptrE">
+<span id="boost::network::http::async_server_base::connection_ptr"></span><span class="target" id="cppnetlibstructboost_1_1network_1_1http_1_1async__server__base_1aa5d60a85c8e7c6e0efd07a8b6aba8ed1"></span><em class="property">typedef </em>std::shared_ptr&lt;<a class="reference internal" href="#_CPPv2N5boost7network4http17async_server_base10connectionE" title="boost::network::http::async_server_base::connection">connection</a>&gt; <code class="descname">connection_ptr</code><a class="headerlink" href="#_CPPv2N5boost7network4http17async_server_base14connection_ptrE" title="Permalink to this definition">¶</a></dt>
+<dd><p>Defines the type for the connection pointer. </p>
+</dd></dl>
+
 </div>
-<p>The general pattern for using the <code class="docutils literal"><span class="pre">async_server</span></code> template is shown below:</p>
-<div class="highlight-c++"><div class="highlight"><pre><span></span><span class="k">struct</span> <span class="n">handler</span><span class="p">;</span>
-<span class="k">typedef</span> <span class="n">boost</span><span class="o">::</span><span class="n">network</span><span class="o">::</span><span class="n">http</span><span class="o">::</span><span class="n">async_server</span><span class="o">&lt;</span><span class="n">handler</span><span class="o">&gt;</span> <span class="n">http_server</span><span class="p">;</span>
+<div class="breathe-sectiondef container">
+<p class="breathe-sectiondef-title rubric">Public Functions</p>
+<dl class="function">
+<dt id="_CPPv2N5boost7network4http17async_server_base3runEv">
+<span id="boost::network::http::async_server_base::run"></span><span class="target" id="cppnetlibstructboost_1_1network_1_1http_1_1async__server__base_1a563d465032ede2e194f6647be88c5ffb"></span>void <code class="descname">run</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#_CPPv2N5boost7network4http17async_server_base3runEv" title="Permalink to this definition">¶</a></dt>
+<dd><p>Listens to the correct port and runs the server&#8217;s event loop. This can be run on multiple threads, as in the example below:</p>
+<p>Example: handler_type handler; http_server::options options(handler); options.thread_pool( std::make_shared&lt;boost::network::utils::thread_pool&gt;()); http_server server(options.address(&#8220;localhost&#8221;).port(&#8220;8000&#8221;));</p>
+<p>// Run in three threads including the current thread. std::thread t1([&amp;server] { server.run() }); std::thread t2([&amp;server] { server.run() }); server.run(); t1.join(); t2.join(); </p>
+</dd></dl>
+
+<dl class="function">
+<dt id="_CPPv2N5boost7network4http17async_server_base4stopEv">
+<span id="boost::network::http::async_server_base::stop"></span><span class="target" id="cppnetlibstructboost_1_1network_1_1http_1_1async__server__base_1a4b88de42b3096338a92e2e0c55c6dea0"></span>void <code class="descname">stop</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#_CPPv2N5boost7network4http17async_server_base4stopEv" title="Permalink to this definition">¶</a></dt>
+<dd><p>Stops the HTTP server acceptor and waits for all pending request handlers to finish. </p>
+</dd></dl>
+
+<dl class="function">
+<dt id="_CPPv2N5boost7network4http17async_server_base6listenEv">
+<span id="boost::network::http::async_server_base::listen"></span><span class="target" id="cppnetlibstructboost_1_1network_1_1http_1_1async__server__base_1a4a4ff11175f853eaecf9fd901e85f901"></span>void <code class="descname">listen</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#_CPPv2N5boost7network4http17async_server_base6listenEv" title="Permalink to this definition">¶</a></dt>
+<dd><p>Explicitly listens on the configured host and port. May be called multiple times but only takes effect once. </p>
+</dd></dl>
 
-<span class="k">struct</span> <span class="n">handler</span> <span class="p">{</span>
-    <span class="kt">void</span> <span class="k">operator</span><span class="p">()(</span>
-        <span class="n">http_server</span><span class="o">::</span><span class="n">request</span> <span class="k">const</span> <span class="o">&amp;</span> <span class="n">req</span><span class="p">,</span>
-        <span class="n">http_server</span><span class="o">::</span><span class="n">connection_ptr</span> <span class="n">connection</span>
-    <span class="p">)</span> <span class="p">{</span>
-        <span class="c1">// handle the request here, and use the connection to</span>
-        <span class="c1">// either read more data or write data out to the client</span>
-    <span class="p">}</span>
-<span class="p">};</span>
-</pre></div>
 </div>
-<div class="section" id="id5">
-<h3>API Documentation<a class="headerlink" href="#id5" title="Permalink to this headline">¶</a></h3>
-<p>The following sections assume that the following file has been included:</p>
-<div class="highlight-c++"><div class="highlight"><pre><span></span><span class="cp">#include</span> <span class="cpf">&lt;boost/network/include/http/server.hpp&gt;</span><span class="cp"></span>
-<span class="cp">#include</span> <span class="cpf">&lt;boost/network/utils/thread_pool.hpp&gt;</span><span class="cp"></span>
-</pre></div>
+</dd></dl>
+
 </div>
-<p>And that the following typedef&#8217;s have been put in place:</p>
-<div class="highlight-c++"><div class="highlight"><pre><span></span><span class="k">struct</span> <span class="n">handler_type</span><span class="p">;</span>
-<span class="k">typedef</span> <span class="n">boost</span><span class="o">::</span><span class="n">network</span><span class="o">::</span><span class="n">http</span><span class="o">::</span><span class="n">server</span><span class="o">&lt;</span><span class="n">handler_type</span><span class="o">&gt;</span> <span class="n">http_server</span><span class="p">;</span>
+<div class="section" id="connection-object">
+<h3>Connection Object<a class="headerlink" href="#connection-object" title="Permalink to this headline">¶</a></h3>
+<dl class="class">
+<dt>
+<span class="target" id="cppnetlibstructboost_1_1network_1_1http_1_1async__connection"></span><em class="property">template </em>&lt;<em class="property">class</em> Tag, <em class="property">class</em> Handler&gt;</dt>
+<dt id="_CPPv2N5boost7network4http16async_connectionE">
+<span id="boost::network::http::async_connection"></span><em class="property">struct </em><code class="descclassname">boost::network::http::</code><code class="descname">async_connection</code><a class="headerlink" href="#_CPPv2N5boost7network4http16async_connectionE" title="Permalink to this definition">¶</a></dt>
+<dd><p>Inherits from std::enable_shared_from_this&lt; async_connection&lt; Tag, Handler &gt; &gt;</p>
+<div class="breathe-sectiondef container">
+<p class="breathe-sectiondef-title rubric">Public Types</p>
+<dl class="type">
+<dt id="_CPPv2N5boost7network4http16async_connection8status_tE">
+<span id="boost::network::http::async_connection::status_t"></span><span class="target" id="cppnetlibstructboost_1_1network_1_1http_1_1async__connection_1a6e0311ff1c74e9b3d0278738a721e3ed"></span><em class="property">enum </em><code class="descname">status_t</code><a class="headerlink" href="#_CPPv2N5boost7network4http16async_connection8status_tE" title="Permalink to this definition">¶</a></dt>
+<dd><p>The set of known status codes for HTTP server responses. </p>
+<p><em>Values:</em></p>
+<dl class="member">
+<dt id="_CPPv2N5boost7network4http16async_connection2okE">
+<span id="boost::network::http::async_connection::ok"></span><span class="target" id="cppnetlibstructboost_1_1network_1_1http_1_1async__connection_1a6e0311ff1c74e9b3d0278738a721e3eda1083caceea420870157c5aee09d412fa"></span><code class="descname">ok</code> = 200<a class="headerlink" href="#_CPPv2N5boost7network4http16async_connection2okE" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="member">
+<dt id="_CPPv2N5boost7network4http16async_connection7createdE">
+<span id="boost::network::http::async_connection::created"></span><span class="target" id="cppnetlibstructboost_1_1network_1_1http_1_1async__connection_1a6e0311ff1c74e9b3d0278738a721e3eda854de7b51c1ac8a15b4f66a01c82363f"></span><code class="descname">created</code> = 201<a class="headerlink" href="#_CPPv2N5boost7network4http16async_connection7createdE" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="member">
+<dt id="_CPPv2N5boost7network4http16async_connection8acceptedE">
+<span id="boost::network::http::async_connection::accepted"></span><span class="target" id="cppnetlibstructboost_1_1network_1_1http_1_1async__connection_1a6e0311ff1c74e9b3d0278738a721e3edaaed5c0ab063ea8e8f79e4c8cd3cfac70"></span><code class="descname">accepted</code> = 202<a class="headerlink" href="#_CPPv2N5boost7network4http16async_connection8acceptedE" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="member">
+<dt id="_CPPv2N5boost7network4http16async_connection10no_contentE">
+<span id="boost::network::http::async_connection::no_content"></span><span class="target" id="cppnetlibstructboost_1_1network_1_1http_1_1async__connection_1a6e0311ff1c74e9b3d0278738a721e3eda98dda05b7f976355d2fceb0de289bb29"></span><code class="descname">no_content</code> = 204<a class="headerlink" href="#_CPPv2N5boost7network4http16async_connection10no_contentE" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="member">
+<dt id="_CPPv2N5boost7network4http16async_connection15partial_contentE">
+<span id="boost::network::http::async_connection::partial_content"></span><span class="target" id="cppnetlibstructboost_1_1network_1_1http_1_1async__connection_1a6e0311ff1c74e9b3d0278738a721e3edaa8ed180697c0aadbec91ad8fd34823a4"></span><code class="descname">partial_content</code> = 206<a class="headerlink" href="#_CPPv2N5boost7network4http16async_connection15partial_contentE" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="member">
+<dt id="_CPPv2N5boost7network4http16async_connection16multiple_choicesE">
+<span id="boost::network::http::async_connection::multiple_choices"></span><span class="target" id="cppnetlibstructboost_1_1network_1_1http_1_1async__connection_1a6e0311ff1c74e9b3d0278738a721e3eda557eeb830f2f03deb38dd0e446d6c247"></span><code class="descname">multiple_choices</code> = 300<a class="headerlink" href="#_CPPv2N5boost7network4http16async_connection16multiple_choicesE" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="member">
+<dt id="_CPPv2N5boost7network4http16async_connection17moved_permanentlyE">
+<span id="boost::network::http::async_connection::moved_permanently"></span><span class="target" id="cppnetlibstructboost_1_1network_1_1http_1_1async__connection_1a6e0311ff1c74e9b3d0278738a721e3edacfa18818dbf6414fa92b8c9ad7d5a278"></span><code class="descname">moved_permanently</code> = 301<a class="headerlink" href="#_CPPv2N5boost7network4http16async_connection17moved_permanentlyE" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="member">
+<dt id="_CPPv2N5boost7network4http16async_connection17moved_temporarilyE">
+<span id="boost::network::http::async_connection::moved_temporarily"></span><span class="target" id="cppnetlibstructboost_1_1network_1_1http_1_1async__connection_1a6e0311ff1c74e9b3d0278738a721e3eda2f4addabfe0b4b44a5d687a3363398b5"></span><code class="descname">moved_temporarily</code> = 302<a class="headerlink" href="#_CPPv2N5boost7network4http16async_connection17moved_temporarilyE" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="member">
+<dt id="_CPPv2N5boost7network4http16async_connection12not_modifiedE">
+<span id="boost::network::http::async_connection::not_modified"></span><span class="target" id="cppnetlibstructboost_1_1network_1_1http_1_1async__connection_1a6e0311ff1c74e9b3d0278738a721e3edabf55ac10b68ef5229bc51c52b805a460"></span><code class="descname">not_modified</code> = 304<a class="headerlink" href="#_CPPv2N5boost7network4http16async_connection12not_modifiedE" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="member">
+<dt id="_CPPv2N5boost7network4http16async_connection11bad_requestE">
+<span id="boost::network::http::async_connection::bad_request"></span><span class="target" id="cppnetlibstructboost_1_1network_1_1http_1_1async__connection_1a6e0311ff1c74e9b3d0278738a721e3eda3e550baf02168f757e8f5fe45960313b"></span><code class="descname">bad_request</code> = 400<a class="headerlink" href="#_CPPv2N5boost7network4http16async_connection11bad_requestE" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="member">
+<dt id="_CPPv2N5boost7network4http16async_connection12unauthorizedE">
+<span id="boost::network::http::async_connection::unauthorized"></span><span class="target" id="cppnetlibstructboost_1_1network_1_1http_1_1async__connection_1a6e0311ff1c74e9b3d0278738a721e3edae44b8427a3c71d5689550b69f4fb9721"></span><code class="descname">unauthorized</code> = 401<a class="headerlink" href="#_CPPv2N5boost7network4http16async_connection12unauthorizedE" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="member">
+<dt id="_CPPv2N5boost7network4http16async_connection9forbiddenE">
+<span id="boost::network::http::async_connection::forbidden"></span><span class="target" id="cppnetlibstructboost_1_1network_1_1http_1_1async__connection_1a6e0311ff1c74e9b3d0278738a721e3eda991d134964473e55b793004bab665950"></span><code class="descname">forbidden</code> = 403<a class="headerlink" href="#_CPPv2N5boost7network4http16async_connection9forbiddenE" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="member">
+<dt id="_CPPv2N5boost7network4http16async_connection9not_foundE">
+<span id="boost::network::http::async_connection::not_found"></span><span class="target" id="cppnetlibstructboost_1_1network_1_1http_1_1async__connection_1a6e0311ff1c74e9b3d0278738a721e3edae265ff1108dccaca109c7639ac668651"></span><code class="descname">not_found</code> = 404<a class="headerlink" href="#_CPPv2N5boost7network4http16async_connection9not_foundE" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="member">
+<dt id="_CPPv2N5boost7network4http16async_connection13not_supportedE">
+<span id="boost::network::http::async_connection::not_supported"></span><span class="target" id="cppnetlibstructboost_1_1network_1_1http_1_1async__connection_1a6e0311ff1c74e9b3d0278738a721e3eda83ca89d8e6813c3bf6eedf14b5b92505"></span><code class="descname">not_supported</code> = 405<a class="headerlink" href="#_CPPv2N5boost7network4http16async_connection13not_supportedE" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="member">
+<dt id="_CPPv2N5boost7network4http16async_connection14not_acceptableE">
+<span id="boost::network::http::async_connection::not_acceptable"></span><span class="target" id="cppnetlibstructboost_1_1network_1_1http_1_1async__connection_1a6e0311ff1c74e9b3d0278738a721e3eda00d37c53db64e07c5ae2de0d360aa929"></span><code class="descname">not_acceptable</code> = 406<a class="headerlink" href="#_CPPv2N5boost7network4http16async_connection14not_acceptableE" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="member">
+<dt id="_CPPv2N5boost7network4http16async_connection15request_timeoutE">
+<span id="boost::network::http::async_connection::request_timeout"></span><span class="target" id="cppnetlibstructboost_1_1network_1_1http_1_1async__connection_1a6e0311ff1c74e9b3d0278738a721e3edacf91665a06c9b6158808d9c8fb9191d5"></span><code class="descname">request_timeout</code> = 408<a class="headerlink" href="#_CPPv2N5boost7network4http16async_connection15request_timeoutE" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="member">
+<dt id="_CPPv2N5boost7network4http16async_connection19precondition_failedE">
+<span id="boost::network::http::async_connection::precondition_failed"></span><span class="target" id="cppnetlibstructboost_1_1network_1_1http_1_1async__connection_1a6e0311ff1c74e9b3d0278738a721e3eda4256dbcb6dbba5e307c59ce608643cea"></span><code class="descname">precondition_failed</code> = 412<a class="headerlink" href="#_CPPv2N5boost7network4http16async_connection19precondition_failedE" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="member">
+<dt id="_CPPv2N5boost7network4http16async_connection19unsatisfiable_rangeE">
+<span id="boost::network::http::async_connection::unsatisfiable_range"></span><span class="target" id="cppnetlibstructboost_1_1network_1_1http_1_1async__connection_1a6e0311ff1c74e9b3d0278738a721e3eda34603321665cccdbe65a09625a3aac8a"></span><code class="descname">unsatisfiable_range</code> = 416<a class="headerlink" href="#_CPPv2N5boost7network4http16async_connection19unsatisfiable_rangeE" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="member">
+<dt id="_CPPv2N5boost7network4http16async_connection21internal_server_errorE">
+<span id="boost::network::http::async_connection::internal_server_error"></span><span class="target" id="cppnetlibstructboost_1_1network_1_1http_1_1async__connection_1a6e0311ff1c74e9b3d0278738a721e3eda9c474588f7b987c762fcac64a9506a76"></span><code class="descname">internal_server_error</code> = 500<a class="headerlink" href="#_CPPv2N5boost7network4http16async_connection21internal_server_errorE" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="member">
+<dt id="_CPPv2N5boost7network4http16async_connection15not_implementedE">
+<span id="boost::network::http::async_connection::not_implemented"></span><span class="target" id="cppnetlibstructboost_1_1network_1_1http_1_1async__connection_1a6e0311ff1c74e9b3d0278738a721e3edaffdf2a669971c41b6cd2400f16360e8d"></span><code class="descname">not_implemented</code> = 501<a class="headerlink" href="#_CPPv2N5boost7network4http16async_connection15not_implementedE" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="member">
+<dt id="_CPPv2N5boost7network4http16async_connection11bad_gatewayE">
+<span id="boost::network::http::async_connection::bad_gateway"></span><span class="target" id="cppnetlibstructboost_1_1network_1_1http_1_1async__connection_1a6e0311ff1c74e9b3d0278738a721e3eda0c538d7c0b5a79c3e0fe28c33409c316"></span><code class="descname">bad_gateway</code> = 502<a class="headerlink" href="#_CPPv2N5boost7network4http16async_connection11bad_gatewayE" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="member">
+<dt id="_CPPv2N5boost7network4http16async_connection19service_unavailableE">
+<span id="boost::network::http::async_connection::service_unavailable"></span><span class="target" id="cppnetlibstructboost_1_1network_1_1http_1_1async__connection_1a6e0311ff1c74e9b3d0278738a721e3eda98feb6aef7d9d1096c9af9d36e15e8c7"></span><code class="descname">service_unavailable</code> = 503<a class="headerlink" href="#_CPPv2N5boost7network4http16async_connection19service_unavailableE" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="member">
+<dt id="_CPPv2N5boost7network4http16async_connection17space_unavailableE">
+<span id="boost::network::http::async_connection::space_unavailable"></span><span class="target" id="cppnetlibstructboost_1_1network_1_1http_1_1async__connection_1a6e0311ff1c74e9b3d0278738a721e3eda13fe0d3cb21095cbe6d27ae1792f182d"></span><code class="descname">space_unavailable</code> = 507<a class="headerlink" href="#_CPPv2N5boost7network4http16async_connection17space_unavailableE" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+</dd></dl>
+
+<dl class="type">
+<dt id="_CPPv2N5boost7network4http16async_connection14connection_ptrE">
+<span id="boost::network::http::async_connection::connection_ptr"></span><span class="target" id="cppnetlibstructboost_1_1network_1_1http_1_1async__connection_1ac70117f7bd7af5d07abddf29863ad84c"></span><em class="property">typedef </em>std::shared_ptr&lt;<a class="reference internal" href="#_CPPv2N5boost7network4http16async_connectionE" title="boost::network::http::async_connection">async_connection</a>&gt; <code class="descname">connection_ptr</code><a class="headerlink" href="#_CPPv2N5boost7network4http16async_connection14connection_ptrE" title="Permalink to this definition">¶</a></dt>
+<dd><p>The connection pointer type. </p>
+</dd></dl>
+
+<dl class="type">
+<dt id="_CPPv2N5boost7network4http16async_connection11input_rangeE">
+<span id="boost::network::http::async_connection::input_range"></span><span class="target" id="cppnetlibstructboost_1_1network_1_1http_1_1async__connection_1a576ba8888c4152529c235a8dab8b5da4"></span><em class="property">typedef </em>iterator_range&lt;buffer_type::const_iterator&gt; <code class="descname">input_range</code><a class="headerlink" href="#_CPPv2N5boost7network4http16async_connection11input_rangeE" title="Permalink to this definition">¶</a></dt>
+<dd><p>The input range taken by <code class="docutils literal"><span class="pre">read</span></code> callbacks. Typically a range of <code class="docutils literal"><span class="pre">char</span></code>s. </p>
+</dd></dl>
+
+<dl class="type">
+<dt id="_CPPv2N5boost7network4http16async_connection22read_callback_functionE">
+<span id="boost::network::http::async_connection::read_callback_function"></span><span class="target" id="cppnetlibstructboost_1_1network_1_1http_1_1async__connection_1ac2c0d82bd4219924fc5d4f8c673dd89a"></span><em class="property">typedef </em>std::function&lt;void<span class="sig-paren">(</span><a class="reference internal" href="#_CPPv2N5boost7network4http16async_connection11input_rangeE" title="boost::network::http::async_connection::input_range">input_range</a>, std::error_code, std::size_t, <a class="reference internal" href="#_CPPv2N5boost7network4http16async_connection14connection_ptrE" title="boost::network::http::async_connection::connection_ptr">connection_ptr</a><span class="sig-paren">)</span>&gt; <code class="descname">read_callback_function</code><a class="headerlink" href="#_CPPv2N5boost7network4http16async_connection22read_callback_functionE" title="Permalink to this definition">¶</a></dt>
+<dd><p>Type required for <code class="docutils literal"><span class="pre">read</span></code> callbacks. Takes an input range, an error code, the number of bytes read, and a connection pointer. </p>
+</dd></dl>
 
-<span class="k">struct</span> <span class="n">handler_type</span> <span class="p">{</span>
-    <span class="kt">void</span> <span class="k">operator</span><span class="p">()(</span><span class="n">http_server</span><span class="o">::</span><span class="n">request</span> <span class="k">const</span> <span class="o">&amp;</span> <span class="n">request</span><span class="p">,</span>
-                    <span class="n">http_server</span><span class="o">::</span><span class="n">connection_ptr</span> <span class="n">connection</span><span class="p">)</span> <span class="p">{</span>
-        <span class="c1">// do something here</span>
-    <span class="p">}</span>
-<span class="p">};</span>
-</pre></div>
 </div>
-<div class="section" id="id6">
-<h4>Constructor<a class="headerlink" href="#id6" title="Permalink to this headline">¶</a></h4>
-<dl class="docutils">
-<dt><code class="docutils literal"><span class="pre">explicit</span> <span class="pre">http_server(options)</span></code></dt>
-<dd>Construct an HTTP server instance passing in a <code class="docutils literal"><span class="pre">server_options&lt;Tag,</span>
-<span class="pre">Handler&gt;</span></code> instance.</dd>
+<div class="breathe-sectiondef container">
+<p class="breathe-sectiondef-title rubric">Public Functions</p>
+<dl class="function">
+<dt>
+<em class="property">template </em>&lt;<em class="property">class</em> Range&gt;</dt>
+<dt id="_CPPv2N5boost7network4http16async_connection11set_headersE5Range">
+<span id="boost::network::http::async_connection::set_headers__Range"></span><span class="target" id="cppnetlibstructboost_1_1network_1_1http_1_1async__connection_1a487c70a079c736b8469032ad5e1dabd2"></span>void <code class="descname">set_headers</code><span class="sig-paren">(</span>Range <em>headers</em><span class="sig-paren">)</span><a class="headerlink" href="#_CPPv2N5boost7network4http16async_connection11set_headersE5Range" title="Permalink to this definition">¶</a></dt>
+<dd><p>A call to set_headers takes a Range where each element models the Header concept. This Range will be linearized onto a buffer, which is then sent as soon as the first call to <code class="docutils literal"><span class="pre">write</span></code> or <code class="docutils literal"><span class="pre">flush</span></code> commences.</p>
+<p><dl class="docutils">
+<dt><strong>Pre</strong></dt>
+<dd>Headers have not been sent yet. </dd>
+<dt><strong>Post</strong></dt>
+<dd>Headers have been linearized to a buffer, and assumed to have been sent already when the function exits. </dd>
+<dt><strong>Parameters</strong></dt>
+<dd><ul class="breatheparameterlist first last">
+<li><code class="first docutils literal"><span class="pre">headers</span></code> - <p>A range of Header objects to write out. </p>
+</li>
+</ul>
+</dd>
+<dt><strong>Exceptions</strong></dt>
+<dd><ul class="breatheparameterlist first last">
+<li><code class="first docutils literal"><span class="pre">std::logic_error</span></code> - <p>when the precondition is violated. </p>
+</li>
+</ul>
+</dd>
 </dl>
-</div>
-<div class="section" id="id7">
-<h4>Public Members<a class="headerlink" href="#id7" title="Permalink to this headline">¶</a></h4>
-<p>The following definitions assume that a properly constructed <code class="docutils literal"><span class="pre">http_server</span></code>
-instance has been constructed in the following manner:</p>
-<div class="highlight-c++"><div class="highlight"><pre><span></span><span class="n">handler_type</span> <span class="n">handler</span><span class="p">;</span>
-<span class="n">http_server</span><span class="o">::</span><span class="n">options</span> <span class="n">options</span><span class="p">(</span><span class="n">handler</span><span class="p">);</span>
-<span class="n">options</span><span class="p">.</span><span class="n">thread_pool</span><span class="p">(</span><span class="n">boost</span><span class="o">::</span><span class="n">make_shared</span><span class="o">&lt;</span><span class="n">boost</span><span class="o">::</span><span class="n">network</span><span class="o">::</span><span class="n">utils</span><span class="o">::</span><span class="n">thread_pool</span><span class="o">&gt;</span><span class="p">(</span><span class="mi">2</span><span class="p">));</span>
-<span class="n">http_server</span> <span class="nf">server</span><span class="p">(</span><span class="n">options</span><span class="p">.</span><span class="n">address</span><span class="p">(</span><span class="s">&quot;127.0.0.1&quot;</span><span class="p">).</span><span class="n">port</span><span class="p">(</span><span class="s">&quot;8000&quot;</span><span class="p">));</span>
-</pre></div>
-</div>
-<dl class="docutils">
-<dt><code class="docutils literal"><span class="pre">server.run()</span></code></dt>
-<dd>Run the HTTP Server event loop. This function can be run on multiple threads
-following the example:</dd>
+</p>
+</dd></dl>
+
+<dl class="function">
+<dt id="_CPPv2N5boost7network4http16async_connection10set_statusE8status_t">
+<span id="boost::network::http::async_connection::set_status__status_t"></span><span class="target" id="cppnetlibstructboost_1_1network_1_1http_1_1async__connection_1abacc8b9cfa159ad40b955bb5d1e2fa16"></span>void <code class="descname">set_status</code><span class="sig-paren">(</span><a class="reference internal" href="#_CPPv2N5boost7network4http16async_connection8status_tE" title="boost::network::http::async_connection::status_t">status_t</a> <em>new_status</em><span class="sig-paren">)</span><a class="headerlink" href="#_CPPv2N5boost7network4http16async_connection10set_statusE8status_t" title="Permalink to this definition">¶</a></dt>
+<dd><p>Sets the status of the response.</p>
+<p><dl class="docutils">
+<dt><strong>Pre</strong></dt>
+<dd>Headers have not been sent. </dd>
+<dt><strong>Post</strong></dt>
+<dd>Status is set on the response. </dd>
+<dt><strong>Parameters</strong></dt>
+<dd><ul class="breatheparameterlist first last">
+<li><code class="first docutils literal"><span class="pre">new_status</span></code> - <p>The new status for this response. </p>
+</li>
+</ul>
+</dd>
+<dt><strong>Exceptions</strong></dt>
+<dd><ul class="breatheparameterlist first last">
+<li><code class="first docutils literal"><span class="pre">std::logic_error</span></code> - <p>when the precondition is violated. </p>
+</li>
+</ul>
+</dd>
 </dl>
-<div class="highlight-c++"><div class="highlight"><pre><span></span><span class="n">boost</span><span class="o">::</span><span class="kr">thread</span> <span class="n">t1</span><span class="p">(</span><span class="n">boost</span><span class="o">::</span><span class="n">bind</span><span class="p">(</span><span class="o">&amp;</span><span class="n">http_server</span><span class="o">::</span><span class="n">run</span><span class="p">,</span> <span class="o">&amp;</span><span class="n">server</span><span class="p">));</span>
-<span class="n">boost</span><span class="o">::</span><span class="kr">thread</span> <span class="n">t2</span><span class="p">(</span><span class="n">boost</span><span class="o">::</span><span class="n">bind</span><span class="p">(</span><span class="o">&amp;</span><span class="n">http_server</span><span class="o">::</span><span class="n">run</span><span class="p">,</span> <span class="o">&amp;</span><span class="n">server</span><span class="p">));</span>
-<span class="n">server</span><span class="p">.</span><span class="n">run</span><span class="p">();</span>
-<span class="n">t1</span><span class="p">.</span><span class="n">join</span><span class="p">();</span>
-<span class="n">t2</span><span class="p">.</span><span class="n">join</span><span class="p">();</span>
+</p>
+</dd></dl>
+
+<dl class="function">
+<dt>
+<em class="property">template </em>&lt;<em class="property">class</em> Range&gt;</dt>
+<dt id="_CPPv2N5boost7network4http16async_connection5writeER5Range">
+<span id="boost::network::http::async_connection::write__RangeCR"></span><span class="target" id="cppnetlibstructboost_1_1network_1_1http_1_1async__connection_1afcee98fa25e64164a1570da0ed8447e8"></span>void <code class="descname">write</code><span class="sig-paren">(</span>Range <em class="property">const</em> &amp;<em>range</em><span class="sig-paren">)</span><a class="headerlink" href="#_CPPv2N5boost7network4http16async_connection5writeER5Range" title="Permalink to this definition">¶</a></dt>
+<dd><p>Writes a given range of bytes out in order.</p>
+<p>Even though this function looks synchronous, all it does is schedules asynchronous writes to the connection as soon as the range is serialised into appropriately sized buffers.</p>
+<p>To use in your handler, it would look like:</p>
+<p>Example: <div class="highlight-python"><div class="highlight"><pre><span></span>connection-&gt;write(&quot;Hello, world!\n&quot;);
+std::string sample = &quot;I have a string!&quot;;
+connection-&gt;write(sample);
 </pre></div>
 </div>
-<dl class="docutils">
-<dt><code class="docutils literal"><span class="pre">server.stop()</span></code></dt>
-<dd>Stop the HTTP Server acceptor and wait for all pending requests to finish.</dd>
+</p>
+<p>Note that if you want to send custom status and headers, you MUST call set_status and/or set_headers before any calls to write.</p>
+<p><dl class="docutils">
+<dt><strong>Post</strong></dt>
+<dd>Status and headers have been sent, contents in the range have been serialized. </dd>
+<dt><strong>Parameters</strong></dt>
+<dd><ul class="breatheparameterlist first last">
+<li><code class="first docutils literal"><span class="pre">range</span></code> - <p>A Boost.Range <code class="docutils literal"><span class="pre">Single</span> <span class="pre">Pass</span> <span class="pre">Range</span></code> of char&#8217;s for writing. </p>
+</li>
+</ul>
+</dd>
+<dt><strong>Exceptions</strong></dt>
+<dd><ul class="breatheparameterlist first last">
+<li><code class="first docutils literal"><span class="pre">std::system_error</span></code> - <p>The encountered underlying error in previous operations. </p>
+</li>
+</ul>
+</dd>
 </dl>
-</div>
-<div class="section" id="connection-object">
-<h4>Connection Object<a class="headerlink" href="#connection-object" title="Permalink to this headline">¶</a></h4>
-<p>The connection object has its own public member functions which will be the
-primary means for reading from and writing to the connection.</p>
-<dl class="docutils">
-<dt><code class="docutils literal"><span class="pre">template</span> <span class="pre">&lt;class</span> <span class="pre">Range&gt;</span> <span class="pre">write(Range</span> <span class="pre">range)</span></code></dt>
-<dd><p class="first">The connection object exposes a function <code class="docutils literal"><span class="pre">write</span></code> that can be given a
-parameter that adheres to the <a class="reference external" href="http://www.boost.org/libs/range">Boost.Range</a> <code class="docutils literal"><span class="pre">Single</span> <span class="pre">Pass</span> <span class="pre">Range</span></code> Concept.
-The write function, although it looks synchronous, starts of a series of
-asynchronous writes to the connection as soon as the range is serialized to
-appropriately sized buffers.</p>
-<p class="last">To use this in your handler, it would look something like this:</p>
+</p>
+</dd></dl>
+
+<dl class="function">
+<dt>
+<em class="property">template </em>&lt;<em class="property">class</em> Range, <em class="property">class</em> Callback&gt;</dt>
+<dt id="_CPPv2N5boost7network4http16async_connection5writeER5RangeR8Callback">
+<span id="boost::network::http::async_connection::write__RangeCR.CallbackCR"></span><span class="target" id="cppnetlibstructboost_1_1network_1_1http_1_1async__connection_1a76ff807e8802e5297462057e5d619f50"></span>disable_if&lt;is_base_of&lt;asio::const_buffer, <em class="property">typename</em> Range::value_type&gt;, void&gt;::type <code class="descname">write</code><span class="sig-paren">(</span>Range <em class="property">const</em> &amp;<em>range</em>, Callback <em class="property">const</em> &amp;<em>callback</em><span class="sig-paren">)</span><a class="headerlink" href="#_CPPv2N5boost7network4http16async_connection5writeER5RangeR8Callback" title="Permalink to this definition">¶</a></dt>
+<dd><p>Writes a given range out and schedules a completion callback to be invoked when the writes are done. This works similarly to write above.</p>
+<p>This overload is useful for writing streaming applications that send out chunks of data at a time, or for writing data that may not all fit in memory at once.</p>
+<p><dl class="docutils">
+<dt><strong>Post</strong></dt>
+<dd>Status and headers have been sent, contents in the range have been serialized and scheduled for writing through the socket. </dd>
+<dt><strong>Parameters</strong></dt>
+<dd><ul class="breatheparameterlist first last">
+<li><code class="first docutils literal"><span class="pre">range</span></code> - <p>A Boost.Range <code class="docutils literal"><span class="pre">Single</span> <span class="pre">Pass</span> <span class="pre">Range</span></code> of char&#8217;s for writing. </p>
+</li>
+<li><code class="first docutils literal"><span class="pre">callback</span></code> - <p>A function of type <code class="docutils literal"><span class="pre">void(std::error_code)</span></code>. </p>
+</li>
+</ul>
+</dd>
+<dt><strong>Exceptions</strong></dt>
+<dd><ul class="breatheparameterlist first last">
+<li><code class="first docutils literal"><span class="pre">std::system_error</span></code> - <p>The encountered underlying error in previous operations. </p>
+</li>
+</ul>
 </dd>
 </dl>
-<div class="highlight-c++"><div class="highlight"><pre><span></span><span class="n">connection</span><span class="o">-&gt;</span><span class="n">write</span><span class="p">(</span><span class="s">&quot;Hello, world!&quot;</span><span class="p">);</span>
-<span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">sample</span> <span class="o">=</span> <span class="s">&quot;I have a string!&quot;</span><span class="p">;</span>
-<span class="n">connection</span><span class="o">-&gt;</span><span class="n">write</span><span class="p">(</span><span class="n">sample</span><span class="p">);</span>
-</pre></div>
-</div>
-<dl class="docutils">
-<dt><code class="docutils literal"><span class="pre">template</span> <span class="pre">&lt;class</span> <span class="pre">Range,</span> <span class="pre">class</span> <span class="pre">Callback&gt;</span> <span class="pre">void</span> <span class="pre">write(Range</span> <span class="pre">range,</span> <span class="pre">Callback</span> <span class="pre">callback)</span></code></dt>
-<dd>The connection object also exposes a function <code class="docutils literal"><span class="pre">write</span></code> that can be given a
-parameter that adheres to the <a class="reference external" href="http://www.boost.org/libs/range">Boost.Range</a> <code class="docutils literal"><span class="pre">Single</span> <span class="pre">Pass</span> <span class="pre">Range</span></code> Concept, as
-well as a Callback function that returns <code class="docutils literal"><span class="pre">void</span></code> and takes a
-<code class="docutils literal"><span class="pre">boost::system::error_code</span></code> as a parameter. This overload of <code class="docutils literal"><span class="pre">write</span></code> is
-useful for writing streaming applications that send out chunks of data at a
-time, or for writing data that may not all fit in memory right away.</dd>
-<dt><code class="docutils literal"><span class="pre">template</span> <span class="pre">&lt;class</span> <span class="pre">ReadCallback&gt;</span> <span class="pre">void</span> <span class="pre">read(ReadCallback</span> <span class="pre">callback)</span></code></dt>
-<dd><p class="first">The connection object has a function <code class="docutils literal"><span class="pre">read</span></code> which can be used to read more
-information from the connection. This <code class="docutils literal"><span class="pre">read</span></code> function takes in a callback
-that can be assigned to a <a class="reference external" href="http://www.boost.org/libs/function">Boost.Function</a> with the signature
-<code class="docutils literal"><span class="pre">void(input_range,error_code,size_t,connection_ptr)</span></code>. The following list
-shows what the types actually mean:</p>
-<blockquote>
-<div><ul class="simple">
-<li><strong>input_range</strong> &#8211; <code class="docutils literal"><span class="pre">boost::iterator_range&lt;char</span> <span class="pre">const</span> <span class="pre">*&gt;</span></code> : The range
-that denotes the data read from the connection.</li>
-<li><strong>error_code</strong> &#8211; <code class="docutils literal"><span class="pre">boost::system::error_code</span></code> : The error code if
-there were any errors encountered from the read.</li>
-<li><strong>size_t</strong> &#8211; <code class="docutils literal"><span class="pre">std::size_t</span></code> : The number of bytes transferred.</li>
-<li><strong>connection_ptr</strong> &#8211; <code class="docutils literal"><span class="pre">http_server::connection_ptr</span></code> : A handle to the
-current connection, so that it is kept alive at the time of the read
-callback invocation.</li>
+</p>
+</dd></dl>
+
+<dl class="function">
+<dt>
+<em class="property">template </em>&lt;<em class="property">class</em> ConstBufferSeq, <em class="property">class</em> Callback&gt;</dt>
+<dt id="_CPPv2N5boost7network4http16async_connection5writeER14ConstBufferSeqR8Callback">
+<span id="boost::network::http::async_connection::write__ConstBufferSeqCR.CallbackCR"></span><span class="target" id="cppnetlibstructboost_1_1network_1_1http_1_1async__connection_1afa1f4657a1664e67618c25c0fcb484ec"></span>enable_if&lt;is_base_of&lt;asio::const_buffer, <em class="property">typename</em> ConstBufferSeq::value_type&gt;, void&gt;::type <code class="descname">write</code><span class="sig-paren">(</span>ConstBufferSeq <em class="property">const</em> &amp;<em>seq</em>, Callback <em class="property">const</em> &amp;<em>callback</em><span class="sig-paren">)</span><a class="headerlink" href="#_CPPv2N5boost7network4http16async_connection5writeER14ConstBufferSeqR8Callback" title="Permalink to this definition">¶</a></dt>
+<dd><p>Writes a given set of <code class="docutils literal"><span class="pre">asio::const_buffer</span></code>s out using a more efficient implementation.</p>
+<p><dl class="docutils">
+<dt><strong>Parameters</strong></dt>
+<dd><ul class="breatheparameterlist first last">
+<li><code class="first docutils literal"><span class="pre">seq</span></code> - <p>A sequence of <code class="docutils literal"><span class="pre">asio::const_buffer</span></code> objects. </p>
+</li>
+<li><code class="first docutils literal"><span class="pre">callback</span></code> - <p>A function of type <code class="docutils literal"><span class="pre">void(std::error_code)</span></code>. </p>
+</li>
 </ul>
-</div></blockquote>
-<p class="last">This interface is useful when doing reads of uploaded data that can be
-potentially large and may not fit in memory. The read handler is then
-responsible for dealing with the chunks of data available from the
-connection.</p>
 </dd>
-<dt><code class="docutils literal"><span class="pre">void</span> <span class="pre">set_status(status_t</span> <span class="pre">new_status)</span></code></dt>
-<dd>The <code class="docutils literal"><span class="pre">set_status</span></code> function takes a parameter of type <code class="docutils literal"><span class="pre">status_t</span></code> which is
-an enum type nested in <code class="docutils literal"><span class="pre">http_status::connection</span></code> which is given in the
-following code listing.</dd>
 </dl>
-<div class="highlight-c++"><div class="highlight"><pre><span></span><span class="k">enum</span> <span class="n">status_t</span> <span class="p">{</span>
-    <span class="n">ok</span> <span class="o">=</span> <span class="mi">200</span>
-    <span class="p">,</span> <span class="n">created</span> <span class="o">=</span> <span class="mi">201</span>
-    <span class="p">,</span> <span class="n">accepted</span> <span class="o">=</span> <span class="mi">202</span>
-    <span class="p">,</span> <span class="n">no_content</span> <span class="o">=</span> <span class="mi">204</span>
-    <span class="p">,</span> <span class="n">multiple_choices</span> <span class="o">=</span> <span class="mi">300</span>
-    <span class="p">,</span> <span class="n">moved_permanently</span> <span class="o">=</span> <span class="mi">301</span>
-    <span class="p">,</span> <span class="n">moved_temporarily</span> <span class="o">=</span> <span class="mi">302</span>
-    <span class="p">,</span> <span class="n">not_modified</span> <span class="o">=</span> <span class="mi">304</span>
-    <span class="p">,</span> <span class="n">bad_request</span> <span class="o">=</span> <span class="mi">400</span>
-    <span class="p">,</span> <span class="n">unauthorized</span> <span class="o">=</span> <span class="mi">401</span>
-    <span class="p">,</span> <span class="n">forbidden</span> <span class="o">=</span> <span class="mi">403</span>
-    <span class="p">,</span> <span class="n">not_found</span> <span class="o">=</span> <span class="mi">404</span>
-    <span class="p">,</span> <span class="n">not_supported</span> <span class="o">=</span> <span class="mi">405</span>
-    <span class="p">,</span> <span class="n">not_acceptable</span> <span class="o">=</span> <span class="mi">406</span>
-    <span class="p">,</span> <span class="n">internal_server_error</span> <span class="o">=</span> <span class="mi">500</span>
-    <span class="p">,</span> <span class="n">not_implemented</span> <span class="o">=</span> <span class="mi">501</span>
-    <span class="p">,</span> <span class="n">bad_gateway</span> <span class="o">=</span> <span class="mi">502</span>
-    <span class="p">,</span> <span class="n">service_unavailable</span> <span class="o">=</span> <span class="mi">503</span>
-<span class="p">};</span>
+</p>
+</dd></dl>
+
+<dl class="function">
+<dt id="_CPPv2N5boost7network4http16async_connection4readE22read_callback_function">
+<span id="boost::network::http::async_connection::read__read_callback_function"></span><span class="target" id="cppnetlibstructboost_1_1network_1_1http_1_1async__connection_1aa37ecedf061f0cbb25b158918b112e34"></span>void <code class="descname">read</code><span class="sig-paren">(</span><a class="reference internal" href="#_CPPv2N5boost7network4http16async_connection22read_callback_functionE" title="boost::network::http::async_connection::read_callback_function">read_callback_function</a> <em>callback</em><span class="sig-paren">)</span><a class="headerlink" href="#_CPPv2N5boost7network4http16async_connection4readE22read_callback_function" title="Permalink to this definition">¶</a></dt>
+<dd><p>Schedules an asynchronous read from the connection. This is generally useful for handling POST/PUT or other requests that may have data coming in through the HTTP request&#8217;s body in a streaming manner.</p>
+<p>To use this function, the caller needs to provide a callback that handles a chunk of data at a time. The signature of the function (lambda or actual function pointer) should be of the following form: <div class="highlight-python"><div class="highlight"><pre><span></span><span class="n">void</span><span class="p">(</span><span class="n">input_range</span><span class="p">,</span> <span class="n">error_code</span><span class="p">,</span> <span class="n">size_t</span><span class="p">,</span> <span class="n">connection_ptr</span><span class="p">)</span>
 </pre></div>
 </div>
-<div class="admonition note">
-<p class="first admonition-title">Note</p>
-<p class="last">You may set and re-set the status several times as long as you have
-not set the headers or sent data through the connection. If you do this after
-data has already been set, the function will throw an instance of
-<code class="docutils literal"><span class="pre">std::logic_error</span></code>.</p>
-</div>
-<dl class="docutils">
-<dt><code class="docutils literal"><span class="pre">template</span> <span class="pre">&lt;class</span> <span class="pre">Range&gt;</span> <span class="pre">void</span> <span class="pre">set_headers(Range</span> <span class="pre">range)</span></code></dt>
-<dd><p class="first">The <code class="docutils literal"><span class="pre">set_headers</span></code> function takes a Single Pass Range of
-<code class="docutils literal"><span class="pre">boost::network::http::response_header&lt;http::tags::http_async_server&gt;</span></code>
-instances and linearizes them to a buffer with at most
-<code class="docutils literal"><span class="pre">BOOST_NETWORK_HTTP_SERVER_CONNECTION_HEADER_BUFFER_MAX_SIZE</span></code> and
-immediately schedules an asynchronous write once that is done.</p>
-<p class="last">The function throws an instance of <code class="docutils literal"><span class="pre">std::logic_error</span></code> if you try to set
-the headers for a connection more than once.</p>
+</p>
+<p><dl class="docutils">
+<dt><strong>Parameters</strong></dt>
+<dd><ul class="breatheparameterlist first last">
+<li><code class="first docutils literal"><span class="pre">callback</span></code> - <p>Invoked when the read has data ready for processing. </p>
+</li>
+</ul>
+</dd>
+<dt><strong>Exceptions</strong></dt>
+<dd><ul class="breatheparameterlist first last">
+<li><code class="first docutils literal"><span class="pre">std::system_error</span></code> - <p>The underlying error encountered in previous operations. </p>
+</li>
+</ul>
 </dd>
 </dl>
+</p>
+</dd></dl>
+
+<dl class="function">
+<dt id="_CPPv2N5boost7network4http16async_connection6socketEv">
+<span id="boost::network::http::async_connection::socket"></span><span class="target" id="cppnetlibstructboost_1_1network_1_1http_1_1async__connection_1a41131ae961524e54f450dd0b7a0a6615"></span>boost::network::stream_handler &amp;<code class="descname">socket</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#_CPPv2N5boost7network4http16async_connection6socketEv" title="Permalink to this definition">¶</a></dt>
+<dd><p>Returns a reference to the underlying socket. </p>
+</dd></dl>
+
+<dl class="function">
+<dt id="_CPPv2N5boost7network4http16async_connection11thread_poolEv">
+<span id="boost::network::http::async_connection::thread_pool"></span><span class="target" id="cppnetlibstructboost_1_1network_1_1http_1_1async__connection_1a514951b24c7ea036d2c2125cb3f7eb03"></span>utils::thread_pool &amp;<code class="descname">thread_pool</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#_CPPv2N5boost7network4http16async_connection11thread_poolEv" title="Permalink to this definition">¶</a></dt>
+<dd><p>Returns a reference to the thread_pool running this handler. </p>
+</dd></dl>
+
+<dl class="function">
+<dt id="_CPPv2N5boost7network4http16async_connection9has_errorEv">
+<span id="boost::network::http::async_connection::has_error"></span><span class="target" id="cppnetlibstructboost_1_1network_1_1http_1_1async__connection_1a42972c58a62eb4412f4daf8bdf482a5d"></span>bool <code class="descname">has_error</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#_CPPv2N5boost7network4http16async_connection9has_errorEv" title="Permalink to this definition">¶</a></dt>
+<dd><p>Returns whether or not there were errors encountered in previous operations. </p>
+</dd></dl>
+
+<dl class="function">
+<dt id="_CPPv2N5boost7network4http16async_connection5errorEv">
+<span id="boost::network::http::async_connection::error"></span><span class="target" id="cppnetlibstructboost_1_1network_1_1http_1_1async__connection_1a0bd241fd109c6534dfbf073d8bd7988e"></span>optional&lt;std::system_error&gt; <code class="descname">error</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#_CPPv2N5boost7network4http16async_connection5errorEv" title="Permalink to this definition">¶</a></dt>
+<dd><p>Returns the most recent error encountered. </p>
+</dd></dl>
+
 </div>
+</dd></dl>
+
 </div>
 </div>
-<div class="section" id="adding-ssl-support-to-asynchronous-server">
-<h2>Adding SSL support to Asynchronous Server<a class="headerlink" href="#adding-ssl-support-to-asynchronous-server" title="Permalink to this headline">¶</a></h2>
+<div class="section" id="adding-ssl-support-to-the-http-server">
+<h2>Adding SSL support to the HTTP Server<a class="headerlink" href="#adding-ssl-support-to-the-http-server" title="Permalink to this headline">¶</a></h2>
 <p>In order to setup SSL support for an Asynchronous Server, it is best to start from
 a regular Asynchronous Server (see above). Once this server is setup, SSL can be
 enabled by adding a <a class="reference external" href="http://www.boost.org/doc/libs/1_55_0/doc/html/boost_asio/reference/ssl__context.html">Boost.Asio.Ssl.Context</a> to the options. The settings that can be
 used are defined in the link.</p>
 <div class="highlight-c++"><div class="highlight"><pre><span></span><span class="c1">// Initialize SSL context</span>
-<span class="n">boost</span><span class="o">::</span><span class="n">shared_ptr</span><span class="o">&lt;</span><span class="n">boost</span><span class="o">::</span><span class="n">asio</span><span class="o">::</span><span class="n">ssl</span><span class="o">::</span><span class="n">context</span><span class="o">&gt;</span> <span class="n">ctx</span> <span class="o">=</span> <span class="n">boost</span><span class="o">::</span><span class="n">make_shared</span><span class="o">&lt;</span><span class="n">boost</span><span class="o">::</span><span class="n">asio</span><span class="o">::</span><span class="n">ssl</span><span class="o">::</span><span class="n">context</span><span class="o">&gt;</span><span class="p">(</span><span class="n">boost</span><span class="o">::</span><span class="n">asio</span><span class="o">::</span><span class="n">ssl</span><span class="o">::</span><span class="n">context</span><span class="o">::</span><span class="n">sslv23</span><span class="p">);</span>
+<span class="n">std</span><span class="o">::</span><span class="n">shared_ptr</span><span class="o">&lt;</span><span class="n">asio</span><span class="o">::</span><span class="n">ssl</span><span class="o">::</span><span class="n">context</span><span class="o">&gt;</span> <span class="n">ctx</span> <span class="o">=</span>
+    <span class="n">std</span><span class="o">::</span><span class="n">make_shared</span><span class="o">&lt;</span><span class="n">asio</span><span class="o">::</span><span class="n">ssl</span><span class="o">::</span><span class="n">context</span><span class="o">&gt;</span><span class="p">(</span><span class="n">asio</span><span class="o">::</span><span class="n">ssl</span><span class="o">::</span><span class="n">context</span><span class="o">::</span><span class="n">sslv23</span><span class="p">);</span>
 <span class="n">ctx</span><span class="o">-&gt;</span><span class="n">set_options</span><span class="p">(</span>
-            <span class="n">boost</span><span class="o">::</span><span class="n">asio</span><span class="o">::</span><span class="n">ssl</span><span class="o">::</span><span class="n">context</span><span class="o">::</span><span class="n">default_workarounds</span>
-            <span class="o">|</span> <span class="n">boost</span><span class="o">::</span><span class="n">asio</span><span class="o">::</span><span class="n">ssl</span><span class="o">::</span><span class="n">context</span><span class="o">::</span><span class="n">no_sslv2</span>
-            <span class="o">|</span> <span class="n">boost</span><span class="o">::</span><span class="n">asio</span><span class="o">::</span><span class="n">ssl</span><span class="o">::</span><span class="n">context</span><span class="o">::</span><span class="n">single_dh_use</span><span class="p">);</span>
+            <span class="n">asio</span><span class="o">::</span><span class="n">ssl</span><span class="o">::</span><span class="n">context</span><span class="o">::</span><span class="n">default_workarounds</span>
+            <span class="o">|</span> <span class="n">asio</span><span class="o">::</span><span class="n">ssl</span><span class="o">::</span><span class="n">context</span><span class="o">::</span><span class="n">no_sslv3</span>
+            <span class="o">|</span> <span class="n">asio</span><span class="o">::</span><span class="n">ssl</span><span class="o">::</span><span class="n">context</span><span class="o">::</span><span class="n">single_dh_use</span><span class="p">);</span>
 
 <span class="c1">// Set keys</span>
 <span class="n">ctx</span><span class="o">-&gt;</span><span class="n">set_password_callback</span><span class="p">(</span><span class="n">password_callback</span><span class="p">);</span>
 <span class="n">ctx</span><span class="o">-&gt;</span><span class="n">use_certificate_chain_file</span><span class="p">(</span><span class="s">&quot;server.pem&quot;</span><span class="p">);</span>
-<span class="n">ctx</span><span class="o">-&gt;</span><span class="n">use_private_key_file</span><span class="p">(</span><span class="s">&quot;server.pem&quot;</span><span class="p">,</span> <span class="n">boost</span><span class="o">::</span><span class="n">asio</span><span class="o">::</span><span class="n">ssl</span><span class="o">::</span><span class="n">context</span><span class="o">::</span><span class="n">pem</span><span class="p">);</span>
+<span class="n">ctx</span><span class="o">-&gt;</span><span class="n">use_private_key_file</span><span class="p">(</span><span class="s">&quot;server.pem&quot;</span><span class="p">,</span> <span class="n">asio</span><span class="o">::</span><span class="n">ssl</span><span class="o">::</span><span class="n">context</span><span class="o">::</span><span class="n">pem</span><span class="p">);</span>
 <span class="n">ctx</span><span class="o">-&gt;</span><span class="n">use_tmp_dh_file</span><span class="p">(</span><span class="s">&quot;dh512.pem&quot;</span><span class="p">);</span>
 
 <span class="n">handler_type</span> <span class="n">handler</span><span class="p">;</span>
 <span class="n">http_server</span><span class="o">::</span><span class="n">options</span> <span class="n">options</span><span class="p">(</span><span class="n">handler</span><span class="p">);</span>
-<span class="n">options</span><span class="p">.</span><span class="n">thread_pool</span><span class="p">(</span><span class="n">boost</span><span class="o">::</span><span class="n">make_shared</span><span class="o">&lt;</span><span class="n">boost</span><span class="o">::</span><span class="n">network</span><span class="o">::</span><span class="n">utils</span><span class="o">::</span><span class="n">thread_pool</span><span class="o">&gt;</span><span class="p">(</span><span class="mi">2</span><span class="p">));</span>
+<span class="n">options</span><span class="p">.</span><span class="n">thread_pool</span><span class="p">(</span><span class="n">std</span><span class="o">::</span><span class="n">make_shared</span><span class="o">&lt;</span><span class="n">boost</span><span class="o">::</span><span class="n">network</span><span class="o">::</span><span class="n">utils</span><span class="o">::</span><span class="n">thread_pool</span><span class="o">&gt;</span><span class="p">(</span><span class="mi">2</span><span class="p">));</span>
 <span class="n">http_server</span> <span class="nf">server</span><span class="p">(</span><span class="n">options</span><span class="p">.</span><span class="n">address</span><span class="p">(</span><span class="s">&quot;127.0.0.1&quot;</span><span class="p">).</span><span class="n">port</span><span class="p">(</span><span class="s">&quot;8442&quot;</span><span class="p">).</span><span class="n">context</span><span class="p">(</span><span class="n">ctx</span><span class="p">));</span>
 
-<span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">password_callback</span><span class="p">(</span><span class="n">std</span><span class="o">::</span><span class="kt">size_t</span> <span class="n">max_length</span><span class="p">,</span> <span class="n">boost</span><span class="o">::</span><span class="n">asio</span><span class="o">::</span><span class="n">ssl</span><span class="o">::</span><span class="n">context_base</span><span class="o">::</span><span class="n">password_purpose</span> <span class="n">purpose</span><span class="p">)</span> <span class="p">{</span>
+<span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">password_callback</span><span class="p">(</span><span class="n">std</span><span class="o">::</span><span class="kt">size_t</span> <span class="n">max_length</span><span class="p">,</span> <span class="n">asio</span><span class="o">::</span><span class="n">ssl</span><span class="o">::</span><span class="n">context_base</span><span class="o">::</span><span class="n">password_purpose</span> <span class="n">purpose</span><span class="p">)</span> <span class="p">{</span>
     <span class="k">return</span> <span class="n">std</span><span class="o">::</span><span class="n">string</span><span class="p">(</span><span class="s">&quot;test&quot;</span><span class="p">);</span>
 <span class="p">}</span>
 </pre></div>
@@ -690,26 +887,14 @@ <h3><a href="../contents.html">Table Of Contents</a></h3>
   <ul>
 <li><a class="reference internal" href="#">HTTP Server API</a><ul>
 <li><a class="reference internal" href="#general">General</a></li>
-<li><a class="reference internal" href="#implementations">Implementations</a></li>
-<li><a class="reference internal" href="#synchronous-servers">Synchronous Servers</a><ul>
 <li><a class="reference internal" href="#api-documentation">API Documentation</a><ul>
 <li><a class="reference internal" href="#constructor">Constructor</a></li>
+<li><a class="reference internal" href="#server-options">Server Options</a></li>
 <li><a class="reference internal" href="#public-members">Public Members</a></li>
-<li><a class="reference internal" href="#response-object">Response Object</a></li>
-</ul>
-</li>
-</ul>
-</li>
-<li><a class="reference internal" href="#asynchronous-servers">Asynchronous Servers</a><ul>
-<li><a class="reference internal" href="#id5">API Documentation</a><ul>
-<li><a class="reference internal" href="#id6">Constructor</a></li>
-<li><a class="reference internal" href="#id7">Public Members</a></li>
 <li><a class="reference internal" href="#connection-object">Connection Object</a></li>
 </ul>
 </li>
-</ul>
-</li>
-<li><a class="reference internal" href="#adding-ssl-support-to-asynchronous-server">Adding SSL support to Asynchronous Server</a></li>
+<li><a class="reference internal" href="#adding-ssl-support-to-the-http-server">Adding SSL support to the HTTP Server</a></li>
 </ul>
 </li>
 </ul>
@@ -752,7 +937,7 @@ <h3>Navigation</h3>
     </div>
     <div class="footer" role="contentinfo">
         &copy; Copyright 2008-2014, Glyn Matthews, Dean Michael Berris; 2013 Google, Inc..
-      Last updated on Mar 07, 2016.
+      Last updated on Mar 29, 2016.
       Created using <a href="http://sphinx-doc.org/">Sphinx</a> 1.3.6.
     </div>
   </body>
diff --git a/libs/network/doc/html/references.html b/libs/network/doc/html/references.html
index f69029b7b..d372a2c6a 100644
--- a/libs/network/doc/html/references.html
+++ b/libs/network/doc/html/references.html
@@ -116,7 +116,7 @@ <h3>Navigation</h3>
     </div>
     <div class="footer" role="contentinfo">
         &copy; Copyright 2008-2014, Glyn Matthews, Dean Michael Berris; 2013 Google, Inc..
-      Last updated on Mar 07, 2016.
+      Last updated on Mar 29, 2016.
       Created using <a href="http://sphinx-doc.org/">Sphinx</a> 1.3.6.
     </div>
   </body>
diff --git a/libs/network/doc/html/search.html b/libs/network/doc/html/search.html
index dc63b2af5..c360c05d3 100644
--- a/libs/network/doc/html/search.html
+++ b/libs/network/doc/html/search.html
@@ -94,7 +94,7 @@ <h3>Navigation</h3>
     </div>
     <div class="footer" role="contentinfo">
         &copy; Copyright 2008-2014, Glyn Matthews, Dean Michael Berris; 2013 Google, Inc..
-      Last updated on Mar 07, 2016.
+      Last updated on Mar 29, 2016.
       Created using <a href="http://sphinx-doc.org/">Sphinx</a> 1.3.6.
     </div>
   </body>
diff --git a/libs/network/doc/html/searchindex.js b/libs/network/doc/html/searchindex.js
index 84f066190..fa68482ff 100644
--- a/libs/network/doc/html/searchindex.js
+++ b/libs/network/doc/html/searchindex.js
@@ -1 +1 @@
-Search.setIndex({envversion:46,filenames:["contents","examples","examples/http/atom_reader","examples/http/hello_world_client","examples/http/hello_world_server","examples/http/http_client","examples/http/simple_wget","examples/http/twitter_search","getting_started","history","in_depth","in_depth/http","in_depth/http_client_tags","in_depth/message","in_depth/uri","index","reference","reference/http_client","reference/http_request","reference/http_response","reference/http_server","references","techniques","techniques/directives","techniques/polymorphism","techniques/tag_metafunctions","whats_new"],objects:{"":{"boost::network::http::basic_client":[17,1,1,"_CPPv2N5boost7network4http12basic_clientE"],"boost::network::http::basic_client::basic_client":[17,0,1,"_CPPv2N5boost7network4http12basic_client12basic_clientER7options"],"boost::network::http::basic_client::options":[17,2,1,"_CPPv2N5boost7network4http12basic_client7optionsE"],"boost::network::http::basic_client::tag_type":[17,2,1,"_CPPv2N5boost7network4http12basic_client8tag_typeE"],"boost::network::http::basic_client_facade::body_callback_function_type":[17,2,1,"_CPPv2N5boost7network4http19basic_client_facade27body_callback_function_typeE"],"boost::network::http::basic_client_facade::body_generator_function_type":[17,2,1,"_CPPv2N5boost7network4http19basic_client_facade28body_generator_function_typeE"],"boost::network::http::basic_client_facade::clear_resolved_cache":[17,0,1,"_CPPv2N5boost7network4http19basic_client_facade20clear_resolved_cacheEv"],"boost::network::http::basic_client_facade::delete_":[17,0,1,"_CPPv2N5boost7network4http19basic_client_facade7delete_ER7request27body_callback_function_type"],"boost::network::http::basic_client_facade::get":[17,0,1,"_CPPv2N5boost7network4http19basic_client_facade3getER7request27body_callback_function_type"],"boost::network::http::basic_client_facade::head":[17,0,1,"_CPPv2N5boost7network4http19basic_client_facade4headER7request"],"boost::network::http::basic_client_facade::post":[17,0,1,"_CPPv2N5boost7network4http19basic_client_facade4postE7requestR11string_typeR11string_type27body_callback_function_type28body_generator_function_type"],"boost::network::http::basic_client_facade::put":[17,0,1,"_CPPv2N5boost7network4http19basic_client_facade3putE7requestR11string_typeR11string_type27body_callback_function_type28body_generator_function_type"],"boost::network::http::basic_client_facade::request":[17,2,1,"_CPPv2N5boost7network4http19basic_client_facade7requestE"],"boost::network::http::basic_client_facade::response":[17,2,1,"_CPPv2N5boost7network4http19basic_client_facade8responseE"],"boost::network::http::basic_client_facade::string_type":[17,2,1,"_CPPv2N5boost7network4http19basic_client_facade11string_typeE"],"boost::network::http::client":[17,2,1,"_CPPv2N5boost7network4http6clientE"],"boost::network::http::client_options":[17,1,1,"_CPPv2N5boost7network4http14client_optionsE"],"boost::network::http::client_options::always_verify_peer":[17,0,1,"_CPPv2N5boost7network4http14client_options18always_verify_peerEb"],"boost::network::http::client_options::cache_resolved":[17,0,1,"_CPPv2N5boost7network4http14client_options14cache_resolvedEb"],"boost::network::http::client_options::client_options":[17,0,1,"_CPPv2N5boost7network4http14client_options14client_optionsEv"],"boost::network::http::client_options::follow_redirects":[17,0,1,"_CPPv2N5boost7network4http14client_options16follow_redirectsEb"],"boost::network::http::client_options::io_service":[17,0,1,"_CPPv2N5boost7network4http14client_options10io_serviceENSt10shared_ptrIN4asio10io_serviceEEE"],"boost::network::http::client_options::openssl_certificate":[17,0,1,"_CPPv2N5boost7network4http14client_options19openssl_certificateER11string_type"],"boost::network::http::client_options::openssl_certificate_file":[17,0,1,"_CPPv2N5boost7network4http14client_options24openssl_certificate_fileER11string_type"],"boost::network::http::client_options::openssl_ciphers":[17,0,1,"_CPPv2N5boost7network4http14client_options15openssl_ciphersER11string_type"],"boost::network::http::client_options::openssl_options":[17,0,1,"_CPPv2N5boost7network4http14client_options15openssl_optionsEl"],"boost::network::http::client_options::openssl_private_key_file":[17,0,1,"_CPPv2N5boost7network4http14client_options24openssl_private_key_fileER11string_type"],"boost::network::http::client_options::openssl_sni_hostname":[17,0,1,"_CPPv2N5boost7network4http14client_options20openssl_sni_hostnameER11string_type"],"boost::network::http::client_options::openssl_verify_path":[17,0,1,"_CPPv2N5boost7network4http14client_options19openssl_verify_pathER11string_type"],"boost::network::http::client_options::timeout":[17,0,1,"_CPPv2N5boost7network4http14client_options7timeoutEi"]}},objnames:{"0":["cpp","function","C++ function"],"1":["cpp","class","C++ class"],"2":["cpp","type","C++ type"]},objtypes:{"0":"cpp:function","1":"cpp:class","2":"cpp:type"},terms:{"7zip":8,"8bit":17,"abstract":[4,5,24],"boolean":20,"break":[24,26],"byte":[17,20],"case":[4,8,11,13,17,18,19,20,24,25,26],"catch":[2,3,4,6,7,17,26],"char":[2,3,4,5,6,7,15,17,20],"class":[2,4,5,6,10,11,13],"const":[2,4,6,7,11,13,15,17,18,19,20,23],"default":[5,8,11,12,13,17,20,24,25,26],"enum":20,"final":[5,26],"function":[6,7,9,10,11,13],"import":[20,26],"int":[2,3,4,5,6,7,14,15,17,19,20,24],"long":[17,20],"new":[6,7,8,14,15,23,24,25],"public":11,"return":[2,3,4,5,6,7,11,12,13,14,17,18,19,20,23,24,26],"short":[17,26],"static":[8,22,23],"switch":[18,24],"throw":[17,20,26],"true":[17,20],"try":[2,3,4,6,7,17,20],"void":[4,11,13,14,15,17,18,19,20,24,25],"while":[8,9,11,13,17,23,24],abid:[18,23],abl:[8,20],abort:20,about:[4,8,15,18,19,20],abov:[4,6,7,8,11,12,14,17,20,25],absolut:14,abus:23,accept:[15,20,23,26],acceptor:20,access:[2,3,6,9,11,18,19,20,23],accessor:[13,18,19],accord:[5,13,14],account:8,achiev:22,across:[4,17],action:20,activ:[9,11,12,17],actual:[20,26],adapt:13,add:[5,8,13,18,19,26],add_head:[13,18,19],addit:[8,14,23,24],address:[3,4,11,12,15,17,20,21,26],adher:20,adl:[13,25],administr:4,ado:5,advanc:22,affect:17,afford:23,after:[5,14,20],against:20,aid:1,aim:22,alia:19,aliv:[11,12,17,20],all:[1,2,3,4,5,8,11,13,15,17,18,19,20,23,24,26],allow:[5,7,13,15,17,20,23,24,25,26],almost:20,alon:24,along:8,alreadi:[9,18,19,20,26],also:[4,7,8,9,11,12,13,15,17,18,19,20,23,24,25],although:[8,13,20,24,25],alwai:[8,17,20,26],always_verify_p:17,among:25,anchor:18,ani:[4,5,7,8,13,17,19,20,24,26],annoi:9,anoth:[14,20],anymor:25,api:7,append:17,appli:[13,23],applic:[1,2,3,5,6,8,9,15,17,18,19,20],approach:[24,25],appropri:[8,17,18,19,20],aptli:11,area:13,arg:15,argc:[2,3,4,5,6,7],argument:[4,5,6,7,11,13,17],argv:[2,3,4,5,6,7,15],aris:17,around:[17,20],artifact:8,asio:[9,17,20,26],ask:[8,15],assert:14,assign:[13,14,20],associ:[13,17,18,19,20,25],assum:[3,5,8,13,17,18,19,20],assumpt:11,async:26,async_serv:[20,26],asynchron:[],asynchronoushandl:20,atom:1,atom_read:[],attempt:[20,26],attent:23,attitud:7,author:[14,17],avail:[8,9,13,17,19,20,24,26],avoid:26,awai:20,awar:[9,15],back:26,bad_gatewai:20,bad_request:20,barrier:9,base64:26,base:[7,8,13,14,17,23,24,25,26],base_uri:7,bash:14,basic:[13,17,23],basic_cli:[11,17],basic_client_facad:17,basic_messag:10,basic_request:[11,17,18],basic_respons:[11,17,19],basic_serv:11,becaus:[13,20,23,24],becom:9,been:[8,9,17,20],befor:[3,17,20,26],begin:[11,17],behavior:[11,17,24,25],behaviour:7,below:[7,8,11,14,15,17,19,20],berri:9,best:[17,20,21],better:[8,20,26],between:[8,14],bin:14,binari:26,bind:[20,26],bit:[18,19],block:[11,12,17,20],bodi:[3,4,5,6,7,11,13,15],body_:[15,18,19],body_callback_function_typ:17,body_gener:17,body_generator_function_typ:17,body_handl:17,boil:23,bool:[17,20],boost:[2,3,4,5,6,7],boost_1_55_0:8,boost_foreach:2,boost_network_default_tag:26,boost_network_enable_http:[8,17,26],boost_network_http_body_callback:17,boost_network_http_client_default_tag:[17,26],boost_network_http_server_connection_header_buffer_max_s:20,boost_network_no_lib:26,boost_root:8,boostcon:21,both:[1,11,12,17,18,19,20],bother:17,bound:20,branch:[2,8],breakag:26,breath:26,bridg:24,broad:23,broken:14,buffer:[20,25,26],bug:[8,26],build:[],builder:[7,10],built:[1,5,8,17,24,26],burden:8,bz2:8,bzip:8,c_str:[6,7],cach:17,cache_resolv:17,call:[4,8,11,13,17,20,23,25,26],callback:[17,20,26],came:11,can:[1,3,4,5,6,7,8,11,13,14,15,17,19,20,23,24,25],cannot:[17,20],cat:6,caus:[11,12,17,25,26],caveat:8,cellar:8,central:13,cerr:[2,3,4,6,7,11,15],cert:17,certain:[11,13,17,20,23,25],certif:[17,26],chain:23,chainabl:23,chang:[8,11,23,25,26],chapter:22,charact:17,check:[5,8,15,26],choic:8,choos:[8,13,17,18],chose:13,chunk:[20,26],cipher:[17,26],cite:17,clang:[8,26],clariti:5,classifi:14,clear:[13,17],clear_head:[13,18,19],clear_resolved_cach:17,client:[1,2],client_:[15,17],client_fwd:26,client_get_timeout_test:26,client_opt:17,clone:[6,8],close:[2,5,11,15,20],clrf:26,cmake:[1,5],cmake_prefix_path:8,cmakelist:8,code:[],collect:[9,15],com:[2,3,7,8,14,15,17],combin:[24,25],come:[8,17,18,19,23,24],command:[2,3,4,7,8,14],commit:[2,9],common:[1,5,9,13,17],commun:[1,9,15],comp:14,comparison:26,compat:17,compil:[8,17,20,23,26],complet:[5,8],complex:[5,7,8,14,26],compliant:6,compon:[1,6,13,14,25],compos:10,composit:25,compress:5,compulsori:8,comput:[8,20],concept:10,concern:26,concret:23,concurr:20,conduct:26,config:26,configur:[4,8,15,26],conn:20,conncetionptr:20,connect:[2,3,5,8,11,12,15],connection_ptr:20,connectionptr:20,consist:[5,8,9,26],consol:[2,5],constraint:9,construct:[7,13,14,17,18,19,20],constructor:[2,4,5,6,14],contain:[1,4,7,13,19,20,23,25],content_typ:17,context:[20,23,25],context_bas:20,continu:[9,15,20,26],contribut:[15,26],control:[8,20,25],conveni:17,convent:5,convers:13,convert:[13,14,18,19],cooki:17,copi:[6,13,14,17,20,26],copyabl:17,core:13,correct:[11,13,24],correctli:[18,19,26],correspond:15,cost:26,cout:[2,3,5,6,7,11,14,17],cover:[13,26],cpp:[1,2,3,4,5,6,7],cppnetlib:[8,26],cppnetlib_include_dir:8,cppnetlib_librari:8,craft:3,crash:26,creat:[3,4,5,8,14,17,18,19,20,24],creation:23,creativ:24,critial:26,cross:9,ctx:20,current:[14,17,20],custom:[8,17],cycl:17,dangl:26,data:[3,4,11,13,14,17,20,26],date:8,date_tim:8,dberri:8,dboost_root:8,dcmake_build_typ:8,dcmake_c_compil:8,dcmake_cxx_compil:8,deal:[4,17,20,24],dean:9,debug:[8,26],decid:[9,24,25],decis:24,declar:[11,17,18,19],decod:26,dedic:17,deep:23,default_:[11,24,25],default_str:25,default_tag:25,default_workaround:20,default_wstr:25,defin:[4,8,11,13,14,17,20,23,24,25,26],definit:[13,18,20,25],deleg:11,delet:[5,11,17],delete_:17,demand:9,denot:[20,25],depend:[8,11,13,17,18,19,20,26],deprec:[13,26],depth:[],deriv:[17,18,24],derived0:24,derived1:24,describ:[1,14,17,20,22],descript:[11,12,13,14,17,18,19,20],design:[1,15],destin:[13,18,19],destination_:[18,19],destroi:17,destructor:[24,26],detail:[4,5,11,12,13,17,18,19,20],detect:8,determin:[6,11,17,20,25],develop:[1,4,5,6,7],dh512:20,didn:17,differ:[6,8,10,13,14,16,17,18,19,20,23,24,25,26],differenti:[4,20],direct:[5,7,9,10],directive1:23,directive2:23,directive_typ:23,directiven:23,directli:[17,20],directori:[5,8,17],disabl:[20,26],discov:15,discuss:[8,15],dispatch:[11,13,24,25,26],distanc:17,distinct:20,distribut:[8,9,20],dive:[],divis:13,document:[3,7,8,18,19],doe:[4,13,14,17,18,19,20],doesn:[19,26],don:[5,8,11,12,17,25,26],done:[8,11,13,18,20,24,25],dopenssl_root_dir:8,doubl:14,down:[14,23,24],download:[],doxygen:26,dsel:23,dure:17,dynam:[20,22],each:[2,5,8,13,17,20],earlier:[3,24],easi:[3,9,15],easier:[13,17],easili:[9,17],echo:11,echo_serv:11,edit:20,effect:[17,18,19],either:[9,13,17,18,19,20],element:14,els:17,emb:[17,20],embed:[1,4,20],embedd:[11,26],empti:[6,13,26],enabl:[8,9,17,20,25],encapsul:[11,12,13,17,23],encod:[7,18,19,26],encount:[17,20],end:[9,11,17,26],endl:[2,3,4,5,6,7,11,14,17],endpoint:17,enforc:18,enough:[8,23],ensur:[4,13,25],entri:[2,9],enumer:4,environ:[4,8,26],eof:26,equival:25,error:[4,5,15,17,20,26],error_cod:[17,20],especi:[4,20],establish:17,etc:[9,17],even:[13,18,19,23],event:20,eventu:9,everi:[9,13],everyth:14,exact:[7,11],exampl:[],excel:9,except:[2,3,4,6,7,11,12,17,24,26],exist:[2,8,9],expect:17,experiment:26,explain:5,explicit:[13,17,20],explicitli:17,explos:24,expos:20,extend:[9,23,25],extens:[11,23,25],extern:[24,26],facad:26,face:[17,20],facilit:24,fact:5,factori:[13,23,24],fail:26,failur:26,fals:[17,20],famili:25,familiar:[2,6],fan:8,fashion:23,fast:15,featur:[7,8,9,15],feed:1,few:[8,19],field:19,file:[6,8,14,15,17,20],filenam:[6,17],fileserv:26,filesystem:6,fill:17,find:[8,15],find_last_of:6,find_packag:8,finish:[17,20],first:[2,4,5,8,11,13,14,18,24],fit:20,fix:26,flag:26,flaki:26,flexibl:[5,23,25,26],flight:7,fluid:24,follow:[1,3,4,5,6,8,11,13,14,17,18,19,20,23,24,25],follow_redirect:17,foo:[13,24,25],foo_direct:13,forbidden:20,forc:17,foreach:2,fork:8,form:[11,13,14,23,25],format:[21,23,26],forum:8,forward:11,found:[4,5,7,8,9,20],four:19,fragment:[6,14],framework:[4,13],free:[13,20],from:[2,3,4,5,6,7,8,11,13,14,15,17,18,19,20,23,25,26],from_user_nam:7,fstream:6,ftp:[9,14],fulfil:9,full:[8,15,19],fulli:[6,9],functor:[4,11],further:[5,14],fuss:15,futur:[11,12,13,15,17,19,20],gaga:7,gcc:[8,26],gener:[8,9,10,13],get:[2,3,4,5,6,7],get_filenam:6,getstr:7,git:8,github:[2,8,9,14,15,17],give:20,given:[7,11,13,14,18,19,20,24,25],gnu:8,goal:9,googl:[8,15,26],googletest:26,greater:[4,5],greatli:24,group:[8,9,15],grow:15,guid:[8,15,21],gzip:8,had:9,handl:[4,17,20,24,26],handler:[4,11,15],handler_:15,handler_inst:20,handler_typ:20,happi:15,hard:17,hash:7,hasparseerror:7,have:[3,4,7,8,9,11,12,13,17,20,23,24,25,26],head:[5,11,17],header:[2,4,5,6,7,8,11,13,15,17,18,19,20,23,24,25,26],headers_:[11,19],headers_contain:[13,19],headers_container_typ:[18,19],headers_rang:[11,18,19],heart:11,heavi:[8,26],hello:1,hello_world:4,hello_world_cli:3,hello_world_serv:[3,4,26],help:20,here:[4,5,6,7,11,14,17,20,24],hex:26,hidden:23,hierarch:14,high:9,higher:8,histori:[],hoc:26,hold:[11,12,17],home:[8,9],homebrew:8,host:[4,6,8,14,17,18,26],hostnam:[17,20,26],how:[1,3,4,8,14,17,25],howev:[8,11,25],hpp:[2,3,4,5,6,7,14,17,20,25,26],html:6,http:[],http_async_8bit_tcp_resolv:[11,12,17],http_async_8bit_udp_resolv:[11,12,17,26],http_async_serv:20,http_client:[5,11],http_default_8bit_tcp_resolv:[11,12,17],http_default_8bit_udp_resolv:[11,12,17,18,19],http_keepalive_8bit_tcp_resolv:[11,12,17],http_keepalive_8bit_udp_resolv:[11,12,17],http_server:[15,18,19,20],http_statu:20,http_version_major:17,http_version_minor:17,icmp:13,idea:[15,25],identifi:[13,14],if_:25,ignor:25,illustr:25,imagin:3,immedi:[20,23],impl:[4,19],implement:[6,8,10],impli:13,impos:17,improv:26,inadvert:26,inc:26,includ:[2,3,4,5,6,7,14,15,17,18,19,20,23,26],include_directori:8,incompat:8,incorrect:26,increasingli:9,independ:[17,20,23],index:6,indic:[11,12,17],indirect:[23,24],individu:8,info:[14,15],inform:[8,15,20,26],infosystem:14,inherit:[17,25],inherit_linearli:25,initi:[9,17,20,26],inlin:[18,19,23,25],input:[17,23,24],input_rang:20,insid:[11,17,20],instabl:26,instal:[8,26],instanc:[11,13,14,17,18,19,20,25],instanti:20,instead:[17,20,25,26],instruct:[5,8],integ:18,integr:26,intend:[8,15,17,20],intent:9,interact:8,interest:8,interfac:[6,11,12,16,17,18,20,23,26],intermediari:13,intern:[11,17,18,20,25,26],internal_server_error:20,introduc:[5,6,7,17,26],invari:25,invoc:20,invok:[4,8,17,20,26],io_servic:[17,20,26],iostream:[2,3,4,5,6,7,14,23],ipp:[4,19],ipv6:[21,26],is_base_of:25,is_valid:14,issu:[],iter:11,iterator_rang:[17,20],itself:[23,25],jamfil:26,job:8,john:14,join:[8,15,20],json:7,just:[3,4,8,11,13,18,19,25],keep:[2,11,12,17,23,24,25],keepal:26,kei:[17,20,26],kept:[9,20],kind:[1,24],known:[8,14,26],lack:9,ladi:7,lambda:26,languag:9,larg:[20,25],larger:1,later:20,latest:[8,15],layer:[9,15,23,24],lead:23,leak:26,learn:[],least:8,left:[23,25],legend:[13,14,18,19,20],lend:23,less:26,let:[3,4,8,25],level:[8,9],lib:[2,5,8,26],libc:26,libcppnetlib:[8,26],librari:[1,2,7,8,9,13],librt:26,licens:7,lifetim:17,light:[9,15],like:[3,4,7,8,11,13,17,20,23,24,25],line:[2,3,4,5,7,8,14,15,26],linear:20,linger:20,linger_timeout:20,link:[8,20],linux:[],list:[2,4,7,8,15,18,19,20,25],listen:[4,20,26],liter:21,littl:[24,25],load:17,local:8,localhost:3,locat:[8,17],lock:20,log:[4,15],logic:[5,11,13,20,23],logic_error:20,longer:26,look:[3,4,8],lookup:13,loop:20,lot:[8,24,26],low:20,lower:[9,26],lvalu:[13,20],macro:[8,17,26],made:[3,4,17,20,26],mai:[4,8,11,13,17,20],mail:[8,15],mailto:14,main:[2,3,4,5,6,7,8,14,15],maintain:[20,23],major:[9,17,18],make:[2,3,4,5,6,7,8,11,12,17,24,25,26],make_shar:[17,20],makefil:8,manag:[17,20,26],mani:[8,9,17,26],manipul:[13,20],manner:[18,19,20,25],manual:[],master:2,matter:20,max_length:20,mean:[8,13,17,20,26],meant:[13,18,19,20,25],mechan:[11,25],member:[4,11],memori:[8,9,17,20],mere:13,messag:[4,5,9,10],metafunct:[13,22],metaprogram:[8,21],method:[4,5,11],michael:9,microsoft:8,might:[11,25],migrat:9,mikhailberi:8,minim:26,minimum:[15,26],minor:[17,18],miss:9,mistak:17,mit:7,mitig:26,mkdir:8,mode:26,model:[8,13,17,18,19,20,23],modern:15,modif:13,modifi:[7,10],more:[2,3,7,8,9,13],most:[2,6,13,20],mostli:8,motiv:[],move:[17,23],moved_perman:20,moved_temporarili:20,mpl:[25,26],msvc:26,msysgit:8,much:[8,24],multi:4,multibyt:26,multimap:11,multipl:20,multiple_choic:20,must:[8,26],myapplic:8,name:[6,8,11,13,17,18,19,20,26],namespac:[2,3,4,5,6,7,11,14,15,17,18,19,20,25],narrow:[18,19],natur:23,necessari:4,need:[1,4,5,8,9,17,20,24,25],neg:7,negoti:17,nest:[11,13,18,19,20,23,25],netib:17,netlib:[1,2,3,4,5,6,7],network:[1,2,3,4,5,6,7,8,9,11,13,14],never:9,new_statu:20,newer:20,next:[2,3,5,6,20],nich:9,no_cont:20,no_sslv2:20,non:[8,13,14,17,20,26],non_blocking_io:20,none:20,nonetheless:13,nor:13,normal:[],not_accept:20,not_found:20,not_impl:20,not_modifi:20,not_support:20,note:[6,13,14,19,20],noth:24,notic:[11,25],notion:[13,23],now:[2,4,8,17,18,19,26],number:[4,8,11,12,13,17,18,20,25],numer:26,object:[4,5],occur:[18,19],offer:17,offici:[],ofstream:6,older:26,olymp:7,onc:[5,8,17,20,25],onli:[2,7,8,11,12,14,17,19,20,23,24,25,26],opaqu:[14,25],open:9,openssl:[8,17,26],openssl_certif:17,openssl_certificate_fil:17,openssl_ciph:17,openssl_opt:17,openssl_private_key_fil:17,openssl_sni_hostnam:17,openssl_verify_path:17,oper:[4,7,11,13,15,17,18,19,20,23,26],opt:8,option:[4,8,9,15],order:[5,20,23,26],org:[5,6,8,11,14,15],orient:[23,24],origin:[11,25],ostringstream:[3,4],other:[9,13,15,20],otherwis:[8,14,17,18,24],our:[8,9,15,25],out:[8,15,17,20],outliv:17,output:14,outsid:[5,8,17],overal:[17,25],overhaul:26,overload:[4,11,20],overrid:[17,26],overview:10,own:[9,17,20],packag:8,packet:13,page:[7,8,15],pair:[18,19],paper:21,parallel:8,paramet:[8,11,13,17,18,19,20,23,25,26],pars:[2,6,7,11,14,20,26],parse_head:26,parser:[2,6,8,14,26],part:[7,13,14,17,18,19,26],pass:[2,3,4,5,13,17,20,23,25],password_callback:20,password_purpos:20,patch:8,path:[6,8,14,18],pattern:[13,17,20,23,24],payload:[3,13],peer:[17,26],pem:20,pend:[17,20],per:26,percent:7,perform:[3,9,13,17,18,20,26],person:8,pertain:13,phrase:7,piec:17,pipelin:20,place:20,placehold:25,plai:26,plain:24,platform:[8,9,20,26],plenti:9,pod:13,point:[13,25],pointer:[17,20],polymorph:22,pool:[20,26],port:[3,4,6,14,15,18,19,20,26],port_typ:18,portabl:[9,15],possibl:[2,5,15,24],post:[3,5,11,17,26],potenti:20,power:[7,8,14],practic:[1,2,3],pre:4,predefin:11,preprocessor:26,prescrib:8,present:5,previou:[6,8,17],previous:4,primari:[20,25],print:[2,5,11],print_bodi:17,privat:[17,26],problem:24,process:[11,14,26],produc:8,profil:20,program:[1,4,9,14,15,24],programmat:26,progress:15,project:[],prolong:23,proof:20,propag:26,properli:[17,20],properti:[11,13,23,25],protocol:[1,2,3,4,5,6,7,9,10,13,14,15,17,18,19,23],provid:[4,6,7,9,11,12,14,15,17,18,19,25,26],ptr:24,publicli:[18,19,20],publish:2,pull:8,pure:[13,24],purpos:[8,20],put:[11,17,20,26],qualiti:9,queri:[6,7,14,18,26],question:[8,15],radic:26,rang:[17,20],range_iter:11,rapidjson:7,rapidxml:2,rational:23,raw:17,reachabl:25,read:[2,8,20,26],readcallback:20,reader:1,readi:26,real:25,realist:1,realli:3,receiv:[17,20],receive_buffer_s:20,receive_low_watermark:20,recent:[7,8],recommend:8,redirect:17,reduc:8,refactor:[15,26],refer:[4,8,11,13,14,15],reflect:26,regard:26,regex:8,regular:20,rel:14,relat:20,releas:7,relev:3,reli:26,remain:[23,24],remov:[13,18,19,26],remove_head:[13,18,19],repeatedli:9,repetit:26,replac:26,repli:4,report:[],report_abort:20,repositori:[8,15],repres:[17,20],req:20,request:[2,3,4,5,6,7,8,11,15],request_:[15,17],requesthandl:11,requir:[4,8,9,13,14,17,18,19,20,24,26],reset:24,resid:[5,11],resolut:26,resolv:[11,12,17],resourc:[4,6,8],respons:[2,3,4,5,6,7,11,12,15],response_:[15,17],response_head:[11,20],rest:6,result:[2,6,7,13,14,18,19,23,25],retriev:[6,13,14,17,18,19],reus:23,reuse_address:20,review:15,rfc:[5,6,14,21,26],right:[20,25],risk:8,root:[8,18,25],rpc:3,rss:[2,26],rudimentari:23,rule:26,run:[],runtim:24,safe:[4,17],safeti:25,said:14,sake:5,same:[4,7,8,9,11,17,23,24,25],sampl:[8,20],sanitis:26,save:6,scalabl:20,scale:20,schedul:20,scheme:[6,14,18],search:1,second:[11,17,18],section:[13,17,18,19,20],secur:17,see:[4,11,12,17,20,25,26],seen:[4,19],self:23,semant:[13,20,23,24],send:[5,20],send_buffer_s:20,sens:[11,12,17,23],sensit:26,sent:[17,20],separ:[8,26],sequenc:17,seri:[1,20],serial:[20,26],serv:25,server:[1,3],server_:[4,15],server_opt:20,servic:9,service_unavail:20,session:17,set:[1,3,4,7,8,10,13,17,18,19,20,23,24,26],set_head:20,set_opt:20,set_password_callback:20,set_statu:20,setup:20,sever:[20,22],share:[4,11,12,17,20,26],shared_futur:19,shared_ptr:[17,20,26],shell:[3,4,8],shift:23,should:[4,8,11,13,17,20,24,25],show:[1,2,3,14,17,20],shown:[17,20],side:[4,17,24,26],sign:26,signal:5,signatur:[17,20],significantli:20,similar:[2,3,6,11,12,13,17,20,23,25],simpl:[1,2,3,4,5],simple_wget:6,simplest:5,simpli:[6,11,18,23],simplifi:[23,26],sinc:[3,5,25],singl:[4,5,11,17,20,26],single_dh_us:20,site:8,situat:[17,20,23,24],size:[7,20],size_t:[6,20],sizetyp:7,skeleton:25,slash:14,slide:21,slightli:25,sln:8,smart:[17,20],smarter:25,smtp:[9,13],sni:[17,26],snmp:13,soap:9,socket:20,softwar:9,solut:8,some:[2,3,7,8,14,15,18,19,20,22,24,25,26],some_str:17,some_xml_str:3,someth:[11,13,20,23,25],sometim:[13,25],somewher:17,soon:20,sourc:[4,5,8,9,11,13,18,19],source_:[18,19],source_port:[4,26],source_typ:13,source_wrapp:13,sourceforg:9,special:[11,13,18,19,23,24],specif:[4,8,13,14,17,21,26],specifi:[5,6,8,11,12,13,14,17,20],sphinx:26,src:8,ssl:8,sslv23:20,sslv3:26,sstream:3,stabl:[8,15],standalon:[17,24,26],standard:[9,23,26],start:[],startup:26,state:[20,23],static_cast:6,statu:[4,11,19,20,26],status_:19,status_messag:19,status_message_:19,status_t:20,status_typ:20,std:[2,3,4,5,6,7,11,14,15,17,18,19,20,25,26],step:8,still:[8,18,19,20,25,26],stock:4,stock_repli:[4,11,15,20],stop:[20,26],store:[4,13,17,20],str:[3,4],straightforward:[4,15],strategi:[17,24],stream:[5,7,14],strictli:26,string:[3,5,6,11,13,14,15,17,18,19,20,25,26],string_tag:25,string_typ:[4,15,17,18,19,20,25],struct:[4,11,13,15,17,20,23,24,25],structur:[5,25],stuck:8,studi:15,studio:[8,26],style:[6,14],subdirectori:5,subdivid:14,submit:[8,9],subsequ:[18,19,24],substr:6,subtitl:2,subvers:8,sudo:8,suffici:8,suggest:18,suit:8,summar:13,suppli:[11,14,20,26],support:[4,5,7],sure:4,svn:8,swap:[13,14,25],swappabl:[13,14,25],sync_serv:20,synchron:[4,11,12],synchronoushandl:20,syntact:[13,23],syntax:[5,7,10],system:[8,17,20,23],tabl:[11,13,15,17,19,20],tag:[7,11,12,13,14,15,18,19,20,22,24],tag_typ:17,take:[4,6,11,13,14,15,17,20,23,26],taken:20,talk:[18,19],tar:8,tarbal:8,target:[9,23],target_link_librari:8,target_typ:23,tcp:[11,12,17,24],tcp_resolv:17,techniqu:15,tel:14,tell:17,templat:[8,9,10,11],temporari:26,ten:15,term:[13,17,20],test:[8,20,26],text:7,than:[20,25],thei:[8,11,12,13,14,17,25],them:[8,17,18,19,20],therefor:[9,11,17],thi:[2,3,4,5,6,7,8,9,11,12,13,14,15,16,17,18,19,20,22,23,24,25,26],thing:[5,6,8,17,18,19,24,25],third:4,those:[18,19,22],though:[5,8,24],thrash:8,thread:[4,11,12,17,20,26],thread_pool:20,three:[8,10,11,13,17,20],through:[8,11,15,18,20],throughout:26,throught:5,thrown:17,time:[8,17,20,23,26],timeout:[17,20,26],titl:2,tmp:17,togeth:[8,9],tool:8,top:[8,9],tracker:15,tradit:8,trait:[17,19,25],transfer:[20,26],transform:[13,23],translat:25,travi:26,treat:18,tree:5,trivial:[11,23],truli:23,tweet:7,twitter:1,twitter_search:[],two:[4,11,18,20,26],txt:8,type:[9,11,13,14,17,18,19,20,23,24,25],typedef:[4,11,13,15,17,20,25],typenam:[13,18,19,25],typic:[8,11,13,17],udp:[11,12,17],uint16_t:19,ultim:26,unauthor:20,unavoid:24,undefin:17,under:[7,15],undergo:15,underli:[11,13,23,25],underneath:26,understand:20,uniqu:24,unique_ptr:24,unit:26,unix:[8,14],unpack:8,unsign:[4,11,17,18,19,26],unspecifi:[18,19],unstabl:26,unsupport:26,unsupported_tag:25,unzip:8,updat:26,upgrad:[20,26],upload:20,upon:20,upward:26,uri:[5,6,7,8,10,11],uri_io:14,url:[2,3,5,6,8,14,21],usag:[2,3,4,5,6,7,17,20,26],use_certificate_chain_fil:20,use_private_key_fil:20,use_tmp_dh_fil:20,user:[7,8,11,12,14,17,20,23,26],user_info:[6,14],usr:8,usual:[18,19,23],utf:[18,19],util:20,utils_base64_test:26,valid:[8,13,26],valu:[4,7,11,12,13,17,18,19,20,24],vari:[13,24,25],variabl:[8,26],variou:17,vector:[18,20,25],veri:[6,20,26],verif:[17,26],verifi:[17,26],versa:13,version:5,version_:19,version_major:[11,12,17,18],version_minor:[11,12,17,18],via:[3,15,26],vice:13,virtual:24,visibl:11,visual:[8,26],wai:[14,17,20,25],wait:[17,20],wall:26,want:[3,8,13],warn:26,watermark:20,web:[8,9],webservic:3,websit:[5,6,8,15],weight:[9,15],well:[13,20,23,26],were:20,wget:1,what:[2,3,4,6,7,13,15,18,20,24,25],when:[8,9,13,17,20,24,26],where:[3,9,11,13,17,18,20,23,24,25,26],whether:[13,14,17,18,20,24,26],which:[2,3,4,5,8,11,13,14,17,19,20,23,24,25,26],whole:[17,19,25,26],whose:25,wide:[18,19],width:17,window:[],wire:23,wise:17,within:[8,16,20],without:[5,23,26],work:[8,18,19],world:1,would:[4,8,11,13,20,25],wrap:[13,19,24],wrapper:[10,11],write:[3,9,15,17,20,26],written:[15,18,19],wstring:[18,19,25],www:[5,6,11,14,17],xcode:26,xjf:8,xml:[2,3],xmpp:[9,13],xzf:8,yet:[20,25],you:[3,4,5,6,8,11,15,17,20,24,25],your:[8,11,17,20],yourself:8,zip:8,zipfil:8},titles:["Contents","Examples","Atom feed reader","&#8220;Hello world&#8221; HTTP client","&#8220;Hello world&#8221; HTTP server","HTTP client","Simple <cite>wget</cite>","Twitter search","Getting Started","Project history","An in-depth look at the <code class=\"docutils literal\"><span class=\"pre\">cpp-netlib</span></code>","HTTP implementation","&lt;no title&gt;","The message template","The URI class","Getting cpp-netlib","Reference Manual","HTTP Client API","HTTP Request","HTTP Response","HTTP Server API","References","Techniques","Directives","Static and dynamic polymorphism","Tag metafunctions","What&#8217;s New"],titleterms:{"class":14,"function":17,"new":26,"public":20,"static":24,about:21,api:[17,20],asynchron:20,atom:2,atom_read:2,basic_messag:13,bodi:17,boost:8,build:[2,3,4,7,8],builder:14,client:[3,5,11,17,18],cmake:8,code:[2,3,4,5,6,7],concept:[13,14,18,19],connect:20,constructor:[17,20],content:0,cpp:[8,10,15,21,26],depth:10,develop:8,direct:[13,18,19,23],dive:[2,3,4,5,6,7],document:20,download:8,dynam:24,exampl:[1,5,6],featur:17,feed:2,gener:[14,17,20],get:[8,15],handler:17,hello:[3,4,15],histori:9,http:[1,3,4,5,11,17,18,19,20],implement:[11,17,20],issu:8,learn:15,librari:15,linux:8,look:10,manual:16,member:[17,20],messag:13,metafunct:25,metaprogram:25,method:17,modifi:[13,18,19],more:15,motiv:9,netlib:[8,10,15,21,26],network:15,normal:18,object:[9,20],offici:8,option:17,other:21,overview:14,pod:18,polymorph:24,project:[8,9],reader:2,refer:[16,21],releas:8,report:8,request:18,respons:[19,20],run:[2,3,4,5,6,7],search:7,server:[4,11,18,20],simpl:6,sourc:21,special:25,ssl:20,start:8,stream:17,support:[8,20],synchron:20,syntax:14,tag:25,techniqu:22,templat:[13,25],todo:23,twitter:7,twitter_search:7,uri:14,version:8,want:15,wget:6,what:26,window:8,world:[3,4,15],wrapper:[13,18,19]}})
\ No newline at end of file
+Search.setIndex({envversion:46,filenames:["contents","examples","examples/http/atom_reader","examples/http/hello_world_client","examples/http/hello_world_server","examples/http/http_client","examples/http/simple_wget","examples/http/twitter_search","getting_started","index","reference","reference/http_client","reference/http_request","reference/http_response","reference/http_server","references","whats_new"],objects:{"":{"boost::network::http::async_connection":[14,0,1,"_CPPv2N5boost7network4http16async_connectionE"],"boost::network::http::async_connection::accepted":[14,0,1,"_CPPv2N5boost7network4http16async_connection8acceptedE"],"boost::network::http::async_connection::bad_gateway":[14,0,1,"_CPPv2N5boost7network4http16async_connection11bad_gatewayE"],"boost::network::http::async_connection::bad_request":[14,0,1,"_CPPv2N5boost7network4http16async_connection11bad_requestE"],"boost::network::http::async_connection::connection_ptr":[14,2,1,"_CPPv2N5boost7network4http16async_connection14connection_ptrE"],"boost::network::http::async_connection::created":[14,0,1,"_CPPv2N5boost7network4http16async_connection7createdE"],"boost::network::http::async_connection::error":[14,1,1,"_CPPv2N5boost7network4http16async_connection5errorEv"],"boost::network::http::async_connection::forbidden":[14,0,1,"_CPPv2N5boost7network4http16async_connection9forbiddenE"],"boost::network::http::async_connection::has_error":[14,1,1,"_CPPv2N5boost7network4http16async_connection9has_errorEv"],"boost::network::http::async_connection::input_range":[14,2,1,"_CPPv2N5boost7network4http16async_connection11input_rangeE"],"boost::network::http::async_connection::internal_server_error":[14,0,1,"_CPPv2N5boost7network4http16async_connection21internal_server_errorE"],"boost::network::http::async_connection::moved_permanently":[14,0,1,"_CPPv2N5boost7network4http16async_connection17moved_permanentlyE"],"boost::network::http::async_connection::moved_temporarily":[14,0,1,"_CPPv2N5boost7network4http16async_connection17moved_temporarilyE"],"boost::network::http::async_connection::multiple_choices":[14,0,1,"_CPPv2N5boost7network4http16async_connection16multiple_choicesE"],"boost::network::http::async_connection::no_content":[14,0,1,"_CPPv2N5boost7network4http16async_connection10no_contentE"],"boost::network::http::async_connection::not_acceptable":[14,0,1,"_CPPv2N5boost7network4http16async_connection14not_acceptableE"],"boost::network::http::async_connection::not_found":[14,0,1,"_CPPv2N5boost7network4http16async_connection9not_foundE"],"boost::network::http::async_connection::not_implemented":[14,0,1,"_CPPv2N5boost7network4http16async_connection15not_implementedE"],"boost::network::http::async_connection::not_modified":[14,0,1,"_CPPv2N5boost7network4http16async_connection12not_modifiedE"],"boost::network::http::async_connection::not_supported":[14,0,1,"_CPPv2N5boost7network4http16async_connection13not_supportedE"],"boost::network::http::async_connection::ok":[14,0,1,"_CPPv2N5boost7network4http16async_connection2okE"],"boost::network::http::async_connection::partial_content":[14,0,1,"_CPPv2N5boost7network4http16async_connection15partial_contentE"],"boost::network::http::async_connection::precondition_failed":[14,0,1,"_CPPv2N5boost7network4http16async_connection19precondition_failedE"],"boost::network::http::async_connection::read":[14,1,1,"_CPPv2N5boost7network4http16async_connection4readE22read_callback_function"],"boost::network::http::async_connection::read_callback_function":[14,2,1,"_CPPv2N5boost7network4http16async_connection22read_callback_functionE"],"boost::network::http::async_connection::request_timeout":[14,0,1,"_CPPv2N5boost7network4http16async_connection15request_timeoutE"],"boost::network::http::async_connection::service_unavailable":[14,0,1,"_CPPv2N5boost7network4http16async_connection19service_unavailableE"],"boost::network::http::async_connection::set_headers":[14,1,1,"_CPPv2N5boost7network4http16async_connection11set_headersE5Range"],"boost::network::http::async_connection::set_status":[14,1,1,"_CPPv2N5boost7network4http16async_connection10set_statusE8status_t"],"boost::network::http::async_connection::socket":[14,1,1,"_CPPv2N5boost7network4http16async_connection6socketEv"],"boost::network::http::async_connection::space_unavailable":[14,0,1,"_CPPv2N5boost7network4http16async_connection17space_unavailableE"],"boost::network::http::async_connection::status_t":[14,2,1,"_CPPv2N5boost7network4http16async_connection8status_tE"],"boost::network::http::async_connection::thread_pool":[14,1,1,"_CPPv2N5boost7network4http16async_connection11thread_poolEv"],"boost::network::http::async_connection::unauthorized":[14,0,1,"_CPPv2N5boost7network4http16async_connection12unauthorizedE"],"boost::network::http::async_connection::unsatisfiable_range":[14,0,1,"_CPPv2N5boost7network4http16async_connection19unsatisfiable_rangeE"],"boost::network::http::async_connection::write":[14,1,1,"_CPPv2N5boost7network4http16async_connection5writeER5Range"],"boost::network::http::async_server_base::connection":[14,2,1,"_CPPv2N5boost7network4http17async_server_base10connectionE"],"boost::network::http::async_server_base::connection_ptr":[14,2,1,"_CPPv2N5boost7network4http17async_server_base14connection_ptrE"],"boost::network::http::async_server_base::listen":[14,1,1,"_CPPv2N5boost7network4http17async_server_base6listenEv"],"boost::network::http::async_server_base::request":[14,2,1,"_CPPv2N5boost7network4http17async_server_base7requestE"],"boost::network::http::async_server_base::response_header":[14,2,1,"_CPPv2N5boost7network4http17async_server_base15response_headerE"],"boost::network::http::async_server_base::run":[14,1,1,"_CPPv2N5boost7network4http17async_server_base3runEv"],"boost::network::http::async_server_base::stop":[14,1,1,"_CPPv2N5boost7network4http17async_server_base4stopEv"],"boost::network::http::async_server_base::string_type":[14,2,1,"_CPPv2N5boost7network4http17async_server_base11string_typeE"],"boost::network::http::basic_client":[11,0,1,"_CPPv2N5boost7network4http12basic_clientE"],"boost::network::http::basic_client::basic_client":[11,1,1,"_CPPv2N5boost7network4http12basic_client12basic_clientER7options"],"boost::network::http::basic_client::options":[11,2,1,"_CPPv2N5boost7network4http12basic_client7optionsE"],"boost::network::http::basic_client::tag_type":[11,2,1,"_CPPv2N5boost7network4http12basic_client8tag_typeE"],"boost::network::http::basic_client_facade::body_callback_function_type":[11,2,1,"_CPPv2N5boost7network4http19basic_client_facade27body_callback_function_typeE"],"boost::network::http::basic_client_facade::body_generator_function_type":[11,2,1,"_CPPv2N5boost7network4http19basic_client_facade28body_generator_function_typeE"],"boost::network::http::basic_client_facade::clear_resolved_cache":[11,1,1,"_CPPv2N5boost7network4http19basic_client_facade20clear_resolved_cacheEv"],"boost::network::http::basic_client_facade::delete_":[11,1,1,"_CPPv2N5boost7network4http19basic_client_facade7delete_ER7request27body_callback_function_type"],"boost::network::http::basic_client_facade::get":[11,1,1,"_CPPv2N5boost7network4http19basic_client_facade3getER7request27body_callback_function_type"],"boost::network::http::basic_client_facade::head":[11,1,1,"_CPPv2N5boost7network4http19basic_client_facade4headER7request"],"boost::network::http::basic_client_facade::post":[11,1,1,"_CPPv2N5boost7network4http19basic_client_facade4postE7requestR11string_typeR11string_type27body_callback_function_type28body_generator_function_type"],"boost::network::http::basic_client_facade::put":[11,1,1,"_CPPv2N5boost7network4http19basic_client_facade3putE7requestR11string_typeR11string_type27body_callback_function_type28body_generator_function_type"],"boost::network::http::basic_client_facade::request":[11,2,1,"_CPPv2N5boost7network4http19basic_client_facade7requestE"],"boost::network::http::basic_client_facade::response":[11,2,1,"_CPPv2N5boost7network4http19basic_client_facade8responseE"],"boost::network::http::basic_client_facade::string_type":[11,2,1,"_CPPv2N5boost7network4http19basic_client_facade11string_typeE"],"boost::network::http::client":[11,2,1,"_CPPv2N5boost7network4http6clientE"],"boost::network::http::client_options":[11,0,1,"_CPPv2N5boost7network4http14client_optionsE"],"boost::network::http::client_options::always_verify_peer":[11,1,1,"_CPPv2N5boost7network4http14client_options18always_verify_peerEb"],"boost::network::http::client_options::cache_resolved":[11,1,1,"_CPPv2N5boost7network4http14client_options14cache_resolvedEb"],"boost::network::http::client_options::client_options":[11,1,1,"_CPPv2N5boost7network4http14client_options14client_optionsEv"],"boost::network::http::client_options::follow_redirects":[11,1,1,"_CPPv2N5boost7network4http14client_options16follow_redirectsEb"],"boost::network::http::client_options::io_service":[11,1,1,"_CPPv2N5boost7network4http14client_options10io_serviceENSt10shared_ptrIN4asio10io_serviceEEE"],"boost::network::http::client_options::openssl_certificate":[11,1,1,"_CPPv2N5boost7network4http14client_options19openssl_certificateER11string_type"],"boost::network::http::client_options::openssl_certificate_file":[11,1,1,"_CPPv2N5boost7network4http14client_options24openssl_certificate_fileER11string_type"],"boost::network::http::client_options::openssl_ciphers":[11,1,1,"_CPPv2N5boost7network4http14client_options15openssl_ciphersER11string_type"],"boost::network::http::client_options::openssl_options":[11,1,1,"_CPPv2N5boost7network4http14client_options15openssl_optionsEl"],"boost::network::http::client_options::openssl_private_key_file":[11,1,1,"_CPPv2N5boost7network4http14client_options24openssl_private_key_fileER11string_type"],"boost::network::http::client_options::openssl_sni_hostname":[11,1,1,"_CPPv2N5boost7network4http14client_options20openssl_sni_hostnameER11string_type"],"boost::network::http::client_options::openssl_verify_path":[11,1,1,"_CPPv2N5boost7network4http14client_options19openssl_verify_pathER11string_type"],"boost::network::http::client_options::timeout":[11,1,1,"_CPPv2N5boost7network4http14client_options7timeoutEi"],"boost::network::http::server":[14,0,1,"_CPPv2N5boost7network4http6serverE"],"boost::network::http::server::options":[14,2,1,"_CPPv2N5boost7network4http6server7optionsE"],"boost::network::http::server::server_base":[14,2,1,"_CPPv2N5boost7network4http6server11server_baseE"],"boost::network::http::server_options":[14,0,1,"_CPPv2N5boost7network4http14server_optionsE"],"boost::network::http::server_options::address":[14,1,1,"_CPPv2N5boost7network4http14server_options7addressE11string_type"],"boost::network::http::server_options::context":[14,1,1,"_CPPv2N5boost7network4http14server_options7contextENSt10shared_ptrI11ssl_contextEE"],"boost::network::http::server_options::handler":[14,1,1,"_CPPv2N5boost7network4http14server_options7handlerEv"],"boost::network::http::server_options::io_service":[14,1,1,"_CPPv2N5boost7network4http14server_options10io_serviceENSt10shared_ptrIN4asio10io_serviceEEE"],"boost::network::http::server_options::linger":[14,1,1,"_CPPv2N5boost7network4http14server_options6lingerEb"],"boost::network::http::server_options::linger_timeout":[14,1,1,"_CPPv2N5boost7network4http14server_options14linger_timeoutE6size_t"],"boost::network::http::server_options::non_blocking_io":[14,1,1,"_CPPv2N5boost7network4http14server_options15non_blocking_ioEb"],"boost::network::http::server_options::operator=":[14,1,1,"_CPPv2N5boost7network4http14server_optionsaSERK14server_options"],"boost::network::http::server_options::port":[14,1,1,"_CPPv2N5boost7network4http14server_options4portER11string_type"],"boost::network::http::server_options::receive_buffer_size":[14,1,1,"_CPPv2N5boost7network4http14server_options19receive_buffer_sizeEN4asio11socket_base19receive_buffer_sizeE"],"boost::network::http::server_options::receive_low_watermark":[14,1,1,"_CPPv2N5boost7network4http14server_options21receive_low_watermarkEN4asio11socket_base21receive_low_watermarkE"],"boost::network::http::server_options::report_aborted":[14,1,1,"_CPPv2N5boost7network4http14server_options14report_abortedEb"],"boost::network::http::server_options::reuse_address":[14,1,1,"_CPPv2N5boost7network4http14server_options13reuse_addressEb"],"boost::network::http::server_options::send_buffer_size":[14,1,1,"_CPPv2N5boost7network4http14server_options16send_buffer_sizeEN4asio11socket_base16send_buffer_sizeE"],"boost::network::http::server_options::send_low_watermark":[14,1,1,"_CPPv2N5boost7network4http14server_options18send_low_watermarkEN4asio11socket_base18send_low_watermarkE"],"boost::network::http::server_options::server_options":[14,1,1,"_CPPv2N5boost7network4http14server_options14server_optionsER7Handler"],"boost::network::http::server_options::swap":[14,1,1,"_CPPv2N5boost7network4http14server_options4swapER14server_options"],"boost::network::http::server_options::thread_pool":[14,1,1,"_CPPv2N5boost7network4http14server_options11thread_poolENSt10shared_ptrIN5utils11thread_poolEEE"],"boost::network::http::server_options::~server_options":[14,1,1,"_CPPv2N5boost7network4http14server_optionsD0Ev"]}},objnames:{"0":["cpp","class","C++ class"],"1":["cpp","function","C++ function"],"2":["cpp","type","C++ type"]},objtypes:{"0":"cpp:class","1":"cpp:function","2":"cpp:type"},terms:{"7zip":8,"8bit":11,"abstract":[4,5],"break":16,"byte":[11,14],"case":[4,8,11,12,13,16],"catch":[2,3,4,6,7,11,16],"char":[2,3,4,5,6,7,9,11,14],"class":[2,4,5,6,11,12,13,14],"const":[2,4,6,7,9,11,12,13,14],"default":[5,8,11,14,16],"enum":14,"final":[5,16],"function":[6,7],"import":16,"int":[2,3,4,5,6,7,9,11,13],"long":11,"new":[6,7,8],"public":[],"return":[2,3,4,5,6,7,11,12,13,14,16],"short":[11,16],"static":[8,11,16],"switch":12,"throw":[11,16],"true":[11,14],"try":[2,3,4,6,7,11],"void":[4,9,11,12,13,14],"while":[8,11],abid:12,abl:[8,14],abort:14,about:[4,8,12,13],abov:[4,6,7,8,11,14],accept:[9,14,16],acceptor:14,access:[2,3,6,12,13,14],accessor:[12,13],accord:5,account:8,across:[4,11],action:14,activ:11,actual:[14,16],add:[5,8,12,13,16],add_head:[12,13],addit:8,address:[3,4,9,14,15,16],administr:4,ado:5,affect:11,after:5,aid:1,alia:13,all:[1,2,3,4,5,8,9,11,12,13,14,16],allow:[5,7,9,11,14,16],along:8,alreadi:[12,13,14,16],also:[4,7,8,9,11,12,13],although:8,alwai:[8,11,16],always_verify_p:11,anchor:12,ani:[4,5,7,8,11,13,14,16],api:7,append:11,applic:[1,2,3,5,6,8,9,11,12,13,14],appropri:[8,11,12,13,14],arg:9,argc:[2,3,4,5,6,7],argument:[4,5,6,7,11,14],argv:[2,3,4,5,6,7,9],aris:11,around:[11,14],artifact:8,asio:[11,14,16],ask:[8,9],assign:14,associ:[11,12,13,14],assum:[3,5,8,11,12,13,14],async:16,async_connect:14,async_serv:16,async_server_bas:14,asynchron:[11,14,16],atom:1,atom_read:[],attempt:16,attitud:7,author:11,avail:[8,11,13,14,16],avoid:16,awar:9,back:16,bad_gatewai:14,bad_request:14,base64:16,base:[7,8,11,14,16],base_uri:7,basic:11,basic_cli:11,basic_client_facad:11,basic_request:[11,12,14],basic_respons:[11,13],becaus:14,been:[8,11,14],befor:[3,11,14,16],begin:11,behavior:11,behaviour:7,below:[7,8,9,11,13,14],best:[11,14,15],better:[8,14,16],between:8,binari:16,bind:16,bit:[12,13],block:[11,14],bodi:[3,4,5,6,7],body_:[9,12,13],body_callback_function_typ:11,body_gener:11,body_generator_function_typ:11,body_handl:11,bool:[11,14],boost:[2,3,4,5,6,7],boost_1_55_0:8,boost_foreach:2,boost_network_default_tag:16,boost_network_enable_http:[8,11,16],boost_network_http_body_callback:11,boost_network_http_client_default_tag:[11,16],boost_network_no_lib:16,boost_root:8,boostcon:15,both:[1,12,13],bother:11,branch:[2,8],breakag:16,breath:16,buffer:[14,16],buffer_typ:14,bug:[8,16],build:[],builder:[7,16],built:[1,5,8,11,16],burden:8,bz2:8,bzip:8,c_str:[6,7],cach:11,cache_resolv:11,call:[4,8,11,14,16],callback:[11,14,16],caller:14,can:[1,3,4,5,6,7,8,9,11,13,14],cannot:[11,14],cat:6,caus:[11,16],caveat:8,cellar:8,cerr:[2,3,4,6,7,9],cert:11,certain:11,certif:[11,16],chang:[8,16],charact:11,check:[5,8,9,16],choic:8,choos:[8,11,12],chunk:[14,16],cipher:[11,16],cite:11,clang:[8,16],clariti:5,clear:11,clear_head:[12,13],clear_resolved_cach:11,client:[1,2],client_:[9,11],client_fwd:16,client_get_timeout_test:16,client_opt:11,clone:[6,8],close:[2,5,9],clrf:16,cmake:[1,5],cmake_prefix_path:8,cmakelist:8,code:[],collect:9,com:[2,3,7,8,9,11],come:[8,11,12,13,14],command:[2,3,4,7,8],commenc:14,commit:2,common:[1,5,11],commun:[1,9],comparison:16,compat:11,compil:[8,11,16],complet:[5,8,14],complex:[5,7,8,16],compliant:6,compon:[1,6],compress:5,compulsori:8,comput:[8,14],concept:[],concern:16,concurr:14,condit:[],conduct:16,config:16,configur:[4,8,9,14,16],conn:14,conncetionptr:14,connect:[2,3,5,8],connection_ptr:14,connectionptr:14,consist:[5,8,16],consol:[2,5],const_buff:14,const_iter:14,constbufferseq:14,construct:[7,11,12,13,14],constructor:[2,4,5,6],contain:[1,4,7,13,14],content_typ:11,context:14,context_bas:14,continu:[9,14,16],contribut:[9,16],control:[8,14],conveni:[11,14],convent:5,convert:[12,13],cooki:11,copi:[6,11,14,16],copyabl:11,correct:14,correctli:[12,13,16],correspond:9,cost:16,cout:[2,3,5,6,7,11],cover:16,cpp:[1,2,3,4,5,6,7],cppnetlib:[8,16],cppnetlib_include_dir:8,cppnetlib_librari:8,craft:3,crash:16,creat:[3,4,5,8,11,12,13,14],critial:16,ctx:14,current:[11,14],custom:[8,11,14],cycl:11,dangl:16,data:[3,4,11,14,16],date:8,date_tim:8,dberri:8,dboost_root:8,dcmake_build_typ:8,dcmake_c_compil:8,dcmake_cxx_compil:8,deal:[4,11,14],debug:[8,16],declar:[11,12,13],decod:16,dedic:11,default_workaround:14,defin:[4,8,11,14,16],definit:12,delet:[5,11],delete_:11,depend:[8,11,12,13,16],deprec:16,depth:[],deriv:[11,12],describ:[1,11,14],descript:[12,13,14],design:[1,9],destin:[12,13],destination_:[12,13],destroi:11,destructor:[14,16],detail:[4,5,11,12,13,14],detect:8,determin:[6,11],develop:[1,4,5,6,7],dh512:14,didn:11,differ:[6,8,10,11,12,13,16],differenti:4,direct:[5,7],directli:11,directori:[5,8,11],disabl:[14,16],disable_if:14,discov:9,discuss:[8,9],dispatch:16,distanc:11,distribut:8,dive:[],doc:[],document:[3,7,8,12,13],doe:[4,11,12,13,14],doesn:[13,16],don:[5,8,11,16],done:[8,12,14],dopenssl_root_dir:8,download:[],doxygen:16,doxygenclass:[],dure:11,dynam:[11,14],each:[2,5,8,11,14],earlier:3,easi:[3,9],easier:11,easili:11,effect:[11,12,13,14],effici:14,either:[11,12,13,14],element:14,els:11,emb:[11,14],embed:[1,4],embedd:16,empti:[6,16],enabl:[8,11,14],enable_if:14,enable_shared_from_thi:14,encapsul:11,encod:[7,12,13,16],encount:[11,14],end:[11,16],endl:[2,3,4,5,6,7,11],endpoint:11,enforc:12,enough:8,ensur:4,entri:2,enumer:4,environ:[4,8,16],eof:16,error:[4,5,9,11,14,16],error_cod:[11,14],especi:4,establish:11,etc:11,even:[12,13,14],event:14,exact:7,exampl:[],except:[2,3,4,6,7,11,14,16],exist:[2,8],exit:14,expect:11,experiment:16,explain:5,explicit:[11,14],explicitli:[11,14],expos:14,extern:16,facad:16,face:[11,14],fact:5,fail:16,failur:16,fals:[11,14],familiar:[2,6],fan:8,fast:9,featur:[7,8],feed:1,few:[8,13],field:13,file:[6,8,9,11,14],filenam:[6,11],fileserv:16,filesystem:6,fill:11,find:[8,9],find_last_of:6,find_packag:8,finish:[11,14],first:[2,4,5,8,12,14],fit:14,fix:16,flag:16,flaki:16,flexibl:[5,16],flight:7,flush:14,follow:[1,3,4,5,6,8,11,12,13,14],follow_redirect:11,forbidden:14,forc:11,foreach:2,fork:8,form:14,format:[15,16],forum:8,found:[4,5,7,8],four:13,fragment:6,framework:4,free:14,from:[2,3,4,5,6,7,8,9,11,12,13,14,16],from_user_nam:7,fstream:6,full:[8,9,13],fulli:6,functor:4,further:5,fuss:9,futur:[9,11,13],gaga:7,gcc:[8,16],gener:8,get:[2,3,4,5,6,7],get_filenam:6,getstr:7,git:8,github:[2,8,9,11],given:[7,12,13,14],gnu:8,googl:[8,9,16],googletest:16,greater:[4,5],group:[8,9],grow:9,guid:[8,9,15],gzip:8,handl:[4,11,14,16],handler:4,handler_:9,handler_typ:14,happi:9,hard:11,has_error:14,hash:7,hasparseerror:7,have:[3,4,7,8,11,14,16],head:[5,11],header:[2,4,5,6,7,8,9,11,12,13,14,16],headers_:13,headers_contain:13,headers_container_typ:[12,13],headers_rang:[12,13],heavi:[8,16],hello:1,hello_world:4,hello_world_cli:3,hello_world_serv:[3,4,16],here:[4,5,6,7,11,14],hex:16,higher:8,hoc:16,home:8,homebrew:8,host:[4,6,8,11,12,14,16],hostnam:[11,16],how:[1,3,4,8,11],howev:8,hpp:[2,3,4,5,6,7,11,14,16],html:6,http:[],http_async_8bit_udp_resolv:16,http_client:5,http_default_8bit_tcp_resolv:11,http_default_8bit_udp_resolv:[11,12,13],http_server:[9,12,13,14],http_version_major:11,http_version_minor:11,idea:9,imagin:3,impl:[4,13],implement:[6,8],impos:11,improv:16,inadvert:16,inc:16,includ:[2,3,4,5,6,7,9,11,12,13,14,16],include_directori:8,incompat:8,incorrect:16,independ:[11,14],index:6,indic:11,individu:8,info:9,inform:[8,9,16],inherit:[11,14],initi:[11,14,16],inlin:[12,13],input:[11,14],input_rang:14,insid:11,instabl:16,instal:[8,16],instanc:[11,12,13,14],instead:[11,16],instruct:[5,8],integ:12,integr:16,intend:[8,9,11,14],interact:8,interest:8,interfac:[6,10,12,16],intern:[11,12,14,16],internal_server_error:14,introduc:[5,6,7,11,16],invoc:14,invok:[4,8,11,14,16],io_servic:[11,14,16],iostream:[2,3,4,5,6,7],ipp:[4,13],ipv6:[15,16],is_base_of:14,issu:[],iterator_rang:[11,14],jamfil:16,job:8,join:[8,9,14],json:7,just:[3,4,8,12,13],keep:2,keepal:16,kei:[11,14,16],kind:1,known:[8,14,16],ladi:7,lambda:[14,16],larger:1,later:14,latest:[8,9],layer:9,leak:16,learn:[],least:8,legend:[12,13,14],less:16,let:[3,4,8],level:8,lib:[2,5,8,16],libc:16,libcppnetlib:[8,16],librari:[1,2,7,8],librt:16,licens:7,lifetim:11,light:9,like:[3,4,7,8,11,14],line:[2,3,4,5,7,8,9,16],linear:14,linger:14,linger_timeout:14,link:[8,14],linux:[],list:[2,4,7,8,9,12,13],listen:[4,14,16],liter:15,load:11,local:8,localhost:[3,14],locat:[8,11],log:[4,9],logic:5,logic_error:14,longer:16,look:[3,4,8,9,11,14],loop:14,lot:[8,16],low:14,lower:16,macro:[8,11,16],made:[3,4,11,14,16],mai:[4,8,11,14],mail:[8,9],main:[2,3,4,5,6,7,8,9,14],maintain:14,major:[11,12],make:[2,3,4,5,6,7,8,11,16],make_shar:[11,14],makefil:8,manag:[11,16],mani:[8,11,16],manner:[12,13,14],manual:[],master:2,max_length:14,mean:[8,11,14,16],meant:[12,13,14],member:4,memori:[8,11,14],messag:[4,5,9,11,12,13,16],metafunct:11,metaprogram:[8,15],method:[4,5],microsoft:8,mikhailberi:8,minim:16,minimum:[9,16],minor:[11,12],mistak:11,mit:7,mitig:16,mkdir:8,mode:16,model:[8,11,12,13,14],modern:9,modifi:7,more:[2,3,7,8],most:[2,6,14],mostli:8,move:[11,14],moved_perman:14,moved_temporarili:14,mpl:16,msvc:16,msysgit:8,much:8,multi:4,multibyt:16,multipl:14,multiple_choic:14,must:[8,14,16],myapplic:8,name:[6,8,11,12,13,14,16],namespac:[2,3,4,5,6,7,9,11,12,13],narrow:[12,13],necessari:4,need:[1,4,5,8,11,14],neg:7,negoti:11,nest:[12,13],netib:11,netlib:[1,2,3,4,5,6,7],network:[1,2,3,4,5,6,7,8],new_statu:14,next:[2,3,5,6],no_cont:14,no_sslv3:14,non:[8,11,14,16],non_blocking_io:14,none:14,normal:[],not_accept:14,not_found:14,not_impl:14,not_modifi:14,not_support:14,note:[6,13,14],now:[2,4,8,11,12,13,16],nullptr:14,number:[4,8,11,12,14],numer:16,object:[4,5,12,13],occur:[12,13],offer:11,offici:[],ofstream:6,older:16,olymp:7,onc:[5,8,11,14],onli:[2,7,8,11,13,14,16],onto:14,openssl:[8,11,16],openssl_certif:11,openssl_certificate_fil:11,openssl_ciph:11,openssl_opt:11,openssl_private_key_fil:11,openssl_sni_hostnam:11,openssl_verify_path:11,oper:[4,7,9,11,12,13,14,16],opt:8,option:[4,8],order:[5,14,16],org:[5,6,8,9],ostringstream:[3,4],other:[],otherwis:[8,11,12],our:[8,9],out:[8,9,11,14],outliv:11,output:[],outsid:[5,8,11],overal:11,overhaul:16,overload:[4,14],overrid:[11,16],own:[11,14],packag:8,page:[7,8,9],pair:[12,13],paper:15,parallel:8,paramet:[8,11,12,13,14,16],pars:[2,6,7,14,16],parse_head:16,parser:[2,6,8,16],part:[7,11,12,13,16],partial_cont:14,pass:[2,3,4,5,11,14],password_callback:14,password_purpos:14,patch:8,path:[6,8,12],pattern:[11,14],payload:3,peer:[11,16],pem:14,pend:[11,14],per:16,percent:7,perform:[3,11,12,14,16],person:8,phrase:7,piec:11,pipelin:14,place:14,plai:16,platform:[8,16],pod:[],pointer:[11,14],pool:[14,16],port:[3,4,6,9,12,13,14,16],port_typ:12,portabl:9,possibl:[2,5,9],post:[3,5,11,14,16],power:[7,8],practic:[1,2,3],pre:[4,14],precondit:14,precondition_fail:14,preprocessor:16,prescrib:8,present:5,previou:[6,8,11,14],previous:4,print:[2,5],print_bodi:11,privat:[11,16],process:[14,16],produc:8,program:[1,4,9],programmat:16,progress:9,project:[],propag:16,properli:11,protocol:[1,2,3,4,5,6,7,9,11,12,13],provid:[4,6,7,9,11,12,13,14,16],publicli:[12,13],publish:2,pull:8,purpos:[8,14],put:[11,14,16],queri:[6,7,12,16],question:[8,9],radic:16,rang:[11,14],rapidjson:7,rapidxml:2,raw:11,read:[2,8,14,16],read_callback_funct:14,reader:1,readi:[14,16],realist:1,realli:3,receiv:[11,14],receive_buffer_s:14,receive_low_watermark:14,recent:[7,8,14],recommend:8,redirect:11,reduc:8,refactor:[9,16],refer:[4,8],reflect:16,regard:16,regex:8,regular:14,relat:14,releas:7,relev:3,reli:16,remov:[12,13,16],remove_head:[12,13],repetit:16,replac:16,repli:4,report:[],report_abort:14,repositori:[8,9],repres:11,req:14,request:[2,3,4,5,6,7,8],request_:[9,11],request_timeout:14,requir:[4,8,11,12,13,14,16],resid:5,resolut:16,resolv:11,resourc:[4,6,8],respons:[2,3,4,5,6,7],response_:[9,11],response_head:14,rest:6,result:[2,6,7,12,13],retriev:[6,11,12,13],reus:14,reuse_address:14,review:9,rfc:[5,6,15,16],risk:8,root:[8,12],rpc:3,rss:[2,16],rule:16,run:[],safe:[4,11],sake:5,same:[4,7,8,11],sampl:[8,14],sanitis:16,save:6,scalabl:14,scale:14,schedul:14,scheme:[6,12],search:1,second:[11,12],section:[11,12,13,14],secur:11,see:[4,11,14,16],seen:[4,13],send:[5,14],send_buffer_s:14,send_low_watermark:14,sensit:16,sent:[11,14],separ:[8,16],seq:14,sequenc:[11,14],seri:1,serial:[14,16],serialis:14,server:[1,3],server_:[4,9],server_bas:14,server_opt:14,servic:14,service_unavail:14,session:11,set:[1,3,4,7,8,11,12,13,14,16],set_head:14,set_opt:14,set_password_callback:14,set_statu:14,setup:14,share:[4,11,14,16],shared_futur:13,shared_ptr:[11,14,16],shell:[3,4,8],should:[4,8,11,14],show:[1,2,3,11],shown:[11,14],side:[4,11,16],sign:16,signal:5,signatur:[11,14],similar:[2,3,6],similarli:14,simpl:[1,2,3,4,5],simple_wget:6,simplest:5,simpli:[6,12],simplifi:16,sinc:[3,5],singl:[4,5,11,14,16],single_dh_us:14,site:8,situat:11,size:[7,14],size_t:[6,14],sizetyp:7,slide:15,sln:8,smart:[11,14],sni:[11,16],so_ling:14,so_reuse_addr:14,socket:14,socket_bas:14,solut:8,some:[2,3,7,8,9,12,13,16],some_str:11,some_xml_str:3,someth:14,somewher:11,soon:14,sourc:[4,5,8,12,13],source_:[12,13],source_port:[4,16],space_unavail:14,special:[12,13],specif:[4,8,11,15,16],specifi:[5,6,8,11],sphinx:16,src:8,ssl:8,ssl_context:14,sslv23:14,sslv3:16,sstream:3,stabl:[8,9],standalon:[11,16],standard:16,start:[],startup:16,state:14,static_cast:6,statu:[4,13,14,16],status_:13,status_messag:13,status_message_:13,status_t:14,std:[2,3,4,5,6,7,9,11,12,13,14,16],step:8,still:[8,12,13,16],stock:4,stock_repli:[4,9],stop:[14,16],store:[4,11,14],str:[3,4],straightforward:[4,9],strategi:11,stream:[5,7],stream_handl:14,strictli:16,string:[3,5,6,9,11,12,13,14,16],string_typ:[4,9,11,12,13,14],struct:[4,9,11,14],structur:5,stuck:8,studi:[],studio:[8,16],style:6,subdirectori:5,submit:8,subsequ:[12,13],substr:6,subtitl:2,subvers:8,sudo:8,suffici:8,suggest:12,suit:8,suppli:16,support:[4,5,7],sure:4,svn:8,swap:14,synchron:[4,14,16],syntax:[5,7,15],system:[8,11],system_error:14,tabl:[9,11,13,14],tag:[7,9,11,12,13,14,16],tag_typ:11,take:[4,6,9,11,14,16],taken:14,talk:[12,13],tar:8,tarbal:8,target_link_librari:8,tcp:11,tcp_resolv:11,techniqu:9,tell:11,templat:[8,11,12,13,14,15],temporari:16,ten:9,term:[11,14],test:[8,14,16],text:7,thei:[8,11],them:[8,11,12,13,14],therefor:11,thi:[2,3,4,5,6,7,8,9,10,11,12,13,14,16],thing:[5,6,8,11,12,13],third:4,those:[12,13],though:[5,8,14],thrash:8,thread:[4,11,14,16],thread_pool:14,three:[8,11,14],through:[8,9,12,14],throughout:16,throught:5,thrown:11,time:[8,11,14,16],timeout:[11,14,16],titl:2,tmp:11,togeth:8,tool:8,top:8,tracker:9,tradit:8,trait:[11,13],transfer:16,travi:16,treat:12,tree:5,tweet:7,twitter:1,twitter_search:[],two:[4,12,16],txt:8,type:[11,12,13,14],typedef:[4,9,11,14],typenam:[12,13,14],typic:[8,11,14],udp:11,uint16_t:13,ultim:16,unauthor:14,undefin:11,under:[7,9],undergo:9,underli:14,underneath:16,unit:16,unix:8,unpack:8,unsatisfiable_rang:14,unset:14,unsign:[4,11,12,13,16],unspecifi:[12,13],unstabl:16,unsupport:16,unzip:8,updat:16,upgrad:16,upward:16,uri:[5,6,7,8,9,11,12,15,16],url:[2,3,5,6,8,15],usag:[2,3,4,5,6,7,11,14,16],use_certificate_chain_fil:14,use_private_key_fil:14,use_tmp_dh_fil:14,user:[7,8,11,14,16],user_info:6,usr:8,usual:[12,13],utf:[12,13],util:14,utils_base64_test:16,valid:[8,16],valu:[4,7,11,12,13,14],value_typ:14,variabl:[8,16],variou:11,vector:12,veri:[6,16],verif:[11,16],verifi:[11,16],version:5,version_:13,version_major:[11,12],version_minor:[11,12],via:[3,9,16],violat:14,visual:[8,16],wai:11,wait:[11,14],wall:16,want:[3,8],warn:16,watermark:14,web:8,webservic:3,websit:[5,6,8,9],weight:9,well:16,were:14,wget:1,what:[2,3,4,6,7,12],when:[8,11,14,16],where:[3,11,12,14,16],whether:[11,12,14,16],which:[2,3,4,5,8,11,13,14,16],whole:[11,13,16],wide:[12,13],width:11,window:[],wise:11,within:[8,10,14],without:[5,16],work:[8,12,13,14],world:1,would:[4,8,14],wrap:13,wrapper:[],write:[3,9,11,14,16],written:[9,12,13],wstring:[12,13],www:[5,6,11],xcode:16,xjf:8,xml:[2,3],xzf:8,yet:14,you:[3,4,5,6,8,9,11,14],your:[8,11,14],yourself:8,zip:8,zipfil:8},titles:["Contents","Examples","Atom feed reader","&#8220;Hello world&#8221; HTTP client","&#8220;Hello world&#8221; HTTP server","HTTP client","Simple <cite>wget</cite>","Twitter search","Getting Started","Getting cpp-netlib","Reference Manual","HTTP Client API","HTTP Request","HTTP Response","HTTP Server API","References","What&#8217;s New"],titleterms:{"function":11,"new":16,"public":14,about:15,api:[11,14],atom:2,atom_read:2,bodi:11,boost:8,build:[2,3,4,7,8],client:[3,5,11,12],cmake:8,code:[2,3,4,5,6,7],concept:[12,13],connect:14,constructor:[11,14],content:0,cpp:[8,9,15,16],develop:8,direct:[12,13],dive:[2,3,4,5,6,7],document:14,download:8,exampl:[1,5,6],featur:11,feed:2,gener:[11,14],get:[8,9],handler:11,hello:[3,4,9],http:[1,3,4,5,11,12,13,14],implement:11,issu:8,learn:9,librari:9,linux:8,manual:10,member:[11,14],method:11,modifi:[12,13],more:9,netlib:[8,9,15,16],network:9,normal:12,object:14,offici:8,option:[11,14],other:15,pod:12,project:8,reader:2,refer:[10,15],releas:8,report:8,request:12,respons:13,run:[2,3,4,5,6,7],search:7,server:[4,12,14],simpl:6,sourc:15,ssl:14,start:8,stream:11,support:[8,14],twitter:7,twitter_search:7,version:8,want:9,wget:6,what:16,window:8,world:[3,4,9],wrapper:[12,13]}})
\ No newline at end of file
diff --git a/libs/network/doc/html/techniques.html b/libs/network/doc/html/techniques.html
deleted file mode 100644
index 5f11f8582..000000000
--- a/libs/network/doc/html/techniques.html
+++ /dev/null
@@ -1,116 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-
-
-<html xmlns="http://www.w3.org/1999/xhtml">
-  <head>
-    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-    
-    <title>Techniques &mdash; cpp-netlib v0.11.2</title>
-    
-    <link rel="stylesheet" href="_static/pyramid.css" type="text/css" />
-    <link rel="stylesheet" href="_static/pygments.css" type="text/css" />
-    
-    <script type="text/javascript">
-      var DOCUMENTATION_OPTIONS = {
-        URL_ROOT:    './',
-        VERSION:     '0.11.2',
-        COLLAPSE_INDEX: false,
-        FILE_SUFFIX: '.html',
-        HAS_SOURCE:  true
-      };
-    </script>
-    <script type="text/javascript" src="_static/jquery.js"></script>
-    <script type="text/javascript" src="_static/underscore.js"></script>
-    <script type="text/javascript" src="_static/doctools.js"></script>
-    <link rel="top" title="cpp-netlib v0.11.2" href="contents.html" />
-    <link rel="next" title="Tag metafunctions" href="techniques/tag_metafunctions.html" />
-    <link rel="prev" title="HTTP implementation" href="in_depth/http.html" />
-<link rel="stylesheet" href="http://fonts.googleapis.com/css?family=Neuton&amp;subset=latin" type="text/css" media="screen" charset="utf-8" />
-<link rel="stylesheet" href="http://fonts.googleapis.com/css?family=Nobile:regular,italic,bold,bolditalic&amp;subset=latin" type="text/css" media="screen" charset="utf-8" />
-<!--[if lte IE 6]>
-<link rel="stylesheet" href="_static/ie6.css" type="text/css" media="screen" charset="utf-8" />
-<![endif]-->
-
-  </head>
-  <body role="document">
-
-    <div class="related" role="navigation" aria-label="related navigation">
-      <h3>Navigation</h3>
-      <ul>
-        <li class="right" style="margin-right: 10px">
-          <a href="techniques/tag_metafunctions.html" title="Tag metafunctions"
-             accesskey="N">next</a></li>
-        <li class="right" >
-          <a href="in_depth/http.html" title="HTTP implementation"
-             accesskey="P">previous</a> |</li>
-        <li class="nav-item nav-item-0"><a href="contents.html">cpp-netlib v0.11.2</a> &raquo;</li> 
-      </ul>
-    </div>  
-
-    <div class="document">
-      <div class="documentwrapper">
-        <div class="bodywrapper">
-          <div class="body" role="main">
-            
-  <div class="section" id="techniques">
-<h1>Techniques<a class="headerlink" href="#techniques" title="Permalink to this headline">¶</a></h1>
-<p>The <code class="xref py py-mod docutils literal"><span class="pre">cpp-netlib</span></code> uses several advanced techniques to achieve it&#8217;s
-aims.  This chapter describes some of those techniques.</p>
-<div class="toctree-wrapper compound">
-<ul>
-<li class="toctree-l1"><a class="reference internal" href="techniques/tag_metafunctions.html">Tag metafunctions</a></li>
-<li class="toctree-l1"><a class="reference internal" href="techniques/directives.html">Directives</a></li>
-<li class="toctree-l1"><a class="reference internal" href="techniques/polymorphism.html">Static and dynamic polymorphism</a></li>
-</ul>
-</div>
-</div>
-
-
-          </div>
-        </div>
-      </div>
-      <div class="sphinxsidebar" role="navigation" aria-label="main navigation">
-        <div class="sphinxsidebarwrapper">
-  <h4>Previous topic</h4>
-  <p class="topless"><a href="in_depth/http.html"
-                        title="previous chapter">HTTP implementation</a></p>
-  <h4>Next topic</h4>
-  <p class="topless"><a href="techniques/tag_metafunctions.html"
-                        title="next chapter">Tag metafunctions</a></p>
-<div id="searchbox" style="display: none" role="search">
-  <h3>Quick search</h3>
-    <form class="search" action="search.html" method="get">
-      <input type="text" name="q" />
-      <input type="submit" value="Go" />
-      <input type="hidden" name="check_keywords" value="yes" />
-      <input type="hidden" name="area" value="default" />
-    </form>
-    <p class="searchtip" style="font-size: 90%">
-    Enter search terms or a module, class or function name.
-    </p>
-</div>
-<script type="text/javascript">$('#searchbox').show(0);</script>
-        </div>
-      </div>
-      <div class="clearer"></div>
-    </div>
-    <div class="related" role="navigation" aria-label="related navigation">
-      <h3>Navigation</h3>
-      <ul>
-        <li class="right" style="margin-right: 10px">
-          <a href="techniques/tag_metafunctions.html" title="Tag metafunctions"
-             >next</a></li>
-        <li class="right" >
-          <a href="in_depth/http.html" title="HTTP implementation"
-             >previous</a> |</li>
-        <li class="nav-item nav-item-0"><a href="contents.html">cpp-netlib v0.11.2</a> &raquo;</li> 
-      </ul>
-    </div>
-    <div class="footer" role="contentinfo">
-        &copy; Copyright 2008-2014, Glyn Matthews, Dean Michael Berris; 2013 Google, Inc..
-      Last updated on Mar 07, 2016.
-      Created using <a href="http://sphinx-doc.org/">Sphinx</a> 1.3.6.
-    </div>
-  </body>
-</html>
\ No newline at end of file
diff --git a/libs/network/doc/html/techniques/directives.html b/libs/network/doc/html/techniques/directives.html
deleted file mode 100644
index 5323d47cd..000000000
--- a/libs/network/doc/html/techniques/directives.html
+++ /dev/null
@@ -1,191 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-
-
-<html xmlns="http://www.w3.org/1999/xhtml">
-  <head>
-    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-    
-    <title>Directives &mdash; cpp-netlib v0.11.2</title>
-    
-    <link rel="stylesheet" href="../_static/pyramid.css" type="text/css" />
-    <link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
-    
-    <script type="text/javascript">
-      var DOCUMENTATION_OPTIONS = {
-        URL_ROOT:    '../',
-        VERSION:     '0.11.2',
-        COLLAPSE_INDEX: false,
-        FILE_SUFFIX: '.html',
-        HAS_SOURCE:  true
-      };
-    </script>
-    <script type="text/javascript" src="../_static/jquery.js"></script>
-    <script type="text/javascript" src="../_static/underscore.js"></script>
-    <script type="text/javascript" src="../_static/doctools.js"></script>
-    <link rel="top" title="cpp-netlib v0.11.2" href="../contents.html" />
-    <link rel="up" title="Techniques" href="../techniques.html" />
-    <link rel="next" title="Static and dynamic polymorphism" href="polymorphism.html" />
-    <link rel="prev" title="Tag metafunctions" href="tag_metafunctions.html" />
-<link rel="stylesheet" href="http://fonts.googleapis.com/css?family=Neuton&amp;subset=latin" type="text/css" media="screen" charset="utf-8" />
-<link rel="stylesheet" href="http://fonts.googleapis.com/css?family=Nobile:regular,italic,bold,bolditalic&amp;subset=latin" type="text/css" media="screen" charset="utf-8" />
-<!--[if lte IE 6]>
-<link rel="stylesheet" href="../_static/ie6.css" type="text/css" media="screen" charset="utf-8" />
-<![endif]-->
-
-  </head>
-  <body role="document">
-
-    <div class="related" role="navigation" aria-label="related navigation">
-      <h3>Navigation</h3>
-      <ul>
-        <li class="right" style="margin-right: 10px">
-          <a href="polymorphism.html" title="Static and dynamic polymorphism"
-             accesskey="N">next</a></li>
-        <li class="right" >
-          <a href="tag_metafunctions.html" title="Tag metafunctions"
-             accesskey="P">previous</a> |</li>
-        <li class="nav-item nav-item-0"><a href="../contents.html">cpp-netlib v0.11.2</a> &raquo;</li>
-          <li class="nav-item nav-item-1"><a href="../techniques.html" accesskey="U">Techniques</a> &raquo;</li> 
-      </ul>
-    </div>  
-
-    <div class="document">
-      <div class="documentwrapper">
-        <div class="bodywrapper">
-          <div class="body" role="main">
-            
-  <div class="section" id="directives">
-<h1>Directives<a class="headerlink" href="#directives" title="Permalink to this headline">¶</a></h1>
-<p>The <code class="xref py py-mod docutils literal"><span class="pre">cpp-netlib</span></code> uses a technique for allowing message-passing
-semantics in a chainable fashion in the form of directives. The basic
-concept for directives is, in a general sense, an encapsulated
-transformation that can be applied to objects that abide by the
-directive protocol.</p>
-<p>Using the object-oriented notion of message passing, where an object
-accepts a message (usually a function call) we define a simple DSEL in
-order for the protocol to be supported by certain object types. In the
-<code class="xref py py-mod docutils literal"><span class="pre">cpp-netlib</span></code> the protocol implemented is similar to that of the
-standard iostream formatting system:</p>
-<div class="highlight-c++"><div class="highlight"><pre><span></span><span class="n">object</span> <span class="o">&lt;&lt;</span> <span class="n">directive1</span><span class="p">(...)</span>
-       <span class="o">&lt;&lt;</span> <span class="n">directive2</span><span class="p">(...)</span>
-       <span class="p">...</span>
-       <span class="o">&lt;&lt;</span> <span class="n">directiveN</span><span class="p">(...);</span>
-</pre></div>
-</div>
-<p>In <code class="xref py py-mod docutils literal"><span class="pre">cpp-netlib</span></code> the directives are simple function objects that
-take a target object as reference and returns a reference to the same
-object as a result. In code the directive pattern looks like the
-following:</p>
-<div class="highlight-c++"><div class="highlight"><pre><span></span><span class="k">struct</span> <span class="n">directive_type</span> <span class="p">{</span>
-    <span class="k">template</span> <span class="o">&lt;</span><span class="k">class</span> <span class="nc">Input</span><span class="o">&gt;</span>
-    <span class="n">Input</span> <span class="o">&amp;</span> <span class="k">operator</span><span class="p">()(</span><span class="n">Input</span> <span class="o">&amp;</span> <span class="n">input</span><span class="p">)</span> <span class="k">const</span> <span class="p">{</span>
-        <span class="c1">// do something to input</span>
-        <span class="k">return</span> <span class="n">input</span><span class="p">;</span>
-    <span class="p">}</span>
-<span class="p">};</span>
-</pre></div>
-</div>
-<p>To simplify directive creation, usually factory or generator functions
-are defined to return concrete objects of the directive&#8217;s type.</p>
-<div class="highlight-c++"><div class="highlight"><pre><span></span><span class="kr">inline</span>
-<span class="n">directive_type</span> <span class="nf">directive</span><span class="p">(...)</span> <span class="p">{</span>
-    <span class="k">return</span> <span class="n">directive_type</span><span class="p">();</span>
-<span class="p">}</span>
-</pre></div>
-</div>
-<p>The trivial implementation of the directive protocol then boils down
-to the specialization of the shift-left operator on the target type.</p>
-<div class="highlight-c++"><div class="highlight"><pre><span></span><span class="k">template</span> <span class="o">&lt;</span><span class="k">class</span> <span class="nc">Directive</span><span class="o">&gt;</span>
-<span class="kr">inline</span> <span class="n">target_type</span> <span class="o">&amp;</span> <span class="k">operator</span><span class="o">&lt;&lt;</span>
-<span class="p">(</span><span class="n">target_type</span> <span class="o">&amp;</span> <span class="n">x</span><span class="p">,</span> <span class="n">Directive</span> <span class="k">const</span> <span class="o">&amp;</span> <span class="n">f</span><span class="p">)</span> <span class="p">{</span>
-    <span class="k">return</span> <span class="n">f</span><span class="p">(</span><span class="n">x</span><span class="p">);</span>
-<span class="p">}</span>
-</pre></div>
-</div>
-<div class="admonition-todo admonition" id="index-0">
-<p class="first admonition-title">Todo</p>
-<p class="last">An example using a directive.</p>
-</div>
-<p>The rationale for implementing directives include the following:</p>
-<blockquote>
-<div><ul class="simple">
-<li><strong>Encapsulation</strong> - by moving logic into the directive types the
-target object&#8217;s interface can remain rudimentary and even hidden
-to the user&#8217;s immediate attention. Adding this layer of
-indirection also allows for changing the underlying
-implementations while maintaining the same syntactic and semantic
-properties.</li>
-<li><strong>Flexibility</strong> - by allowing the creation of directives that are
-independent from the target object&#8217;s type, generic operations can
-be applied based on the concept being modeled by the target
-type. The flexibility also afforded comes in the directive&#8217;s
-generator function, which can also generate different concrete
-directive specializations based on parameters to the function.</li>
-<li><strong>Extensibility</strong> - because the directives are independent of the
-target object&#8217;s type, new directives can be added and supported
-without having to change the target object at all.</li>
-<li><strong>Reuse</strong> - truly generic directives can then be used for a broad
-set of target object types that model the same concepts supported
-by the directive.  Because the directives are self-contained
-objects, the state and other object references it keeps are only
-accessible to it and can be re-used in different contexts as well.</li>
-</ul>
-</div></blockquote>
-<p>Extending a system that uses directives is trivial in header-only
-systems because new directives are simply additive. The protocol is
-simple and can be applied to a broad class of situations.</p>
-<p>In a header-only library, the static nature of the wiring and chaining
-of the operations lends itself to compiler abuse. A deep enough
-nesting of the directives can lead to prolonged compilation times.</p>
-</div>
-
-
-          </div>
-        </div>
-      </div>
-      <div class="sphinxsidebar" role="navigation" aria-label="main navigation">
-        <div class="sphinxsidebarwrapper">
-  <h4>Previous topic</h4>
-  <p class="topless"><a href="tag_metafunctions.html"
-                        title="previous chapter">Tag metafunctions</a></p>
-  <h4>Next topic</h4>
-  <p class="topless"><a href="polymorphism.html"
-                        title="next chapter">Static and dynamic polymorphism</a></p>
-<div id="searchbox" style="display: none" role="search">
-  <h3>Quick search</h3>
-    <form class="search" action="../search.html" method="get">
-      <input type="text" name="q" />
-      <input type="submit" value="Go" />
-      <input type="hidden" name="check_keywords" value="yes" />
-      <input type="hidden" name="area" value="default" />
-    </form>
-    <p class="searchtip" style="font-size: 90%">
-    Enter search terms or a module, class or function name.
-    </p>
-</div>
-<script type="text/javascript">$('#searchbox').show(0);</script>
-        </div>
-      </div>
-      <div class="clearer"></div>
-    </div>
-    <div class="related" role="navigation" aria-label="related navigation">
-      <h3>Navigation</h3>
-      <ul>
-        <li class="right" style="margin-right: 10px">
-          <a href="polymorphism.html" title="Static and dynamic polymorphism"
-             >next</a></li>
-        <li class="right" >
-          <a href="tag_metafunctions.html" title="Tag metafunctions"
-             >previous</a> |</li>
-        <li class="nav-item nav-item-0"><a href="../contents.html">cpp-netlib v0.11.2</a> &raquo;</li>
-          <li class="nav-item nav-item-1"><a href="../techniques.html" >Techniques</a> &raquo;</li> 
-      </ul>
-    </div>
-    <div class="footer" role="contentinfo">
-        &copy; Copyright 2008-2014, Glyn Matthews, Dean Michael Berris; 2013 Google, Inc..
-      Last updated on Mar 07, 2016.
-      Created using <a href="http://sphinx-doc.org/">Sphinx</a> 1.3.6.
-    </div>
-  </body>
-</html>
\ No newline at end of file
diff --git a/libs/network/doc/html/techniques/polymorphism.html b/libs/network/doc/html/techniques/polymorphism.html
deleted file mode 100644
index 7f0cceb55..000000000
--- a/libs/network/doc/html/techniques/polymorphism.html
+++ /dev/null
@@ -1,189 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-
-
-<html xmlns="http://www.w3.org/1999/xhtml">
-  <head>
-    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-    
-    <title>Static and dynamic polymorphism &mdash; cpp-netlib v0.11.2</title>
-    
-    <link rel="stylesheet" href="../_static/pyramid.css" type="text/css" />
-    <link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
-    
-    <script type="text/javascript">
-      var DOCUMENTATION_OPTIONS = {
-        URL_ROOT:    '../',
-        VERSION:     '0.11.2',
-        COLLAPSE_INDEX: false,
-        FILE_SUFFIX: '.html',
-        HAS_SOURCE:  true
-      };
-    </script>
-    <script type="text/javascript" src="../_static/jquery.js"></script>
-    <script type="text/javascript" src="../_static/underscore.js"></script>
-    <script type="text/javascript" src="../_static/doctools.js"></script>
-    <link rel="top" title="cpp-netlib v0.11.2" href="../contents.html" />
-    <link rel="up" title="Techniques" href="../techniques.html" />
-    <link rel="next" title="Project history" href="../history.html" />
-    <link rel="prev" title="Directives" href="directives.html" />
-<link rel="stylesheet" href="http://fonts.googleapis.com/css?family=Neuton&amp;subset=latin" type="text/css" media="screen" charset="utf-8" />
-<link rel="stylesheet" href="http://fonts.googleapis.com/css?family=Nobile:regular,italic,bold,bolditalic&amp;subset=latin" type="text/css" media="screen" charset="utf-8" />
-<!--[if lte IE 6]>
-<link rel="stylesheet" href="../_static/ie6.css" type="text/css" media="screen" charset="utf-8" />
-<![endif]-->
-
-  </head>
-  <body role="document">
-
-    <div class="related" role="navigation" aria-label="related navigation">
-      <h3>Navigation</h3>
-      <ul>
-        <li class="right" style="margin-right: 10px">
-          <a href="../history.html" title="Project history"
-             accesskey="N">next</a></li>
-        <li class="right" >
-          <a href="directives.html" title="Directives"
-             accesskey="P">previous</a> |</li>
-        <li class="nav-item nav-item-0"><a href="../contents.html">cpp-netlib v0.11.2</a> &raquo;</li>
-          <li class="nav-item nav-item-1"><a href="../techniques.html" accesskey="U">Techniques</a> &raquo;</li> 
-      </ul>
-    </div>  
-
-    <div class="document">
-      <div class="documentwrapper">
-        <div class="bodywrapper">
-          <div class="body" role="main">
-            
-  <div class="section" id="static-and-dynamic-polymorphism">
-<h1>Static and dynamic polymorphism<a class="headerlink" href="#static-and-dynamic-polymorphism" title="Permalink to this headline">¶</a></h1>
-<p>With a header only library, you can only do so much with static
-polymorphism alone. There are some situations where you have to handle
-dynamic polymorphism because of unavoidable runtime-based decision
-making. Although you can deal with the base types that remain static,
-behavior can vary greatly which derived type should be handling the
-situation based on runtime values.</p>
-<p>This situation comes up in the <code class="xref py py-mod docutils literal"><span class="pre">cpp-netlib</span></code> when we decide what
-kind of connection handler to use for a given HTTP URI &#8211; whether it&#8217;s
-plain HTTP or HTTPS.  Although the HTTP semantics are the same for
-HTTP and HTTPS the implementation of the connection handler greatly
-varies on whether to use a plain TCP connection or an SSL-wrapped TCP
-connection.</p>
-<p>The general pattern or technique is to combine tag-based dispatch with
-a strategy factory, all while not requiring any externally built
-libraries. Doing it in a header-only library requires a little
-creativity and additional layers of indirection that you otherwise
-will not need for a library with externally built static/dynamic
-libraries.</p>
-<p>First we define the base type which we want to support dynamic
-behavior with.  There&#8217;s nothing special with the base type, except
-that it supports the tag dispatch earlier defined and has a virtual
-destructor. In code it looks like this:</p>
-<div class="highlight-c++"><div class="highlight"><pre><span></span><span class="k">template</span> <span class="o">&lt;</span><span class="k">class</span> <span class="nc">Tag</span><span class="o">&gt;</span>
-<span class="k">struct</span> <span class="n">base</span> <span class="p">{</span>
-    <span class="k">virtual</span> <span class="kt">void</span> <span class="n">foo</span><span class="p">()</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="c1">// make this an abstract base</span>
-    <span class="k">virtual</span> <span class="o">~</span><span class="n">base</span><span class="p">()</span> <span class="p">{</span>
-        <span class="c1">// do the base destructor thing here.</span>
-    <span class="p">}</span>
-<span class="p">};</span>
-</pre></div>
-</div>
-<p>We then define a set of derived types that specialize the
-implementation of the <code class="docutils literal"><span class="pre">foo</span></code> member function. To facilitate the
-dispatch of the correct type based on an input, we create a strategy
-factory function:</p>
-<div class="highlight-c++"><div class="highlight"><pre><span></span><span class="k">template</span> <span class="o">&lt;</span><span class="k">class</span> <span class="nc">Tag</span><span class="o">&gt;</span>
-<span class="n">unique_ptr</span><span class="o">&lt;</span><span class="n">base</span><span class="o">&lt;</span><span class="n">Tag</span><span class="o">&gt;</span> <span class="o">&gt;</span> <span class="n">strategy</span><span class="p">(</span><span class="kt">int</span> <span class="n">input</span><span class="p">,</span> <span class="n">Tag</span><span class="p">)</span> <span class="p">{</span>
-    <span class="n">unique_ptr</span><span class="o">&lt;</span><span class="n">base</span><span class="o">&lt;</span><span class="n">Tag</span><span class="o">&gt;</span> <span class="o">&gt;</span> <span class="n">ptr</span><span class="p">;</span>
-    <span class="k">switch</span><span class="p">(</span><span class="n">input</span><span class="p">)</span> <span class="p">{</span>
-        <span class="k">case</span> <span class="mi">0</span><span class="o">:</span> <span class="n">ptr</span><span class="p">.</span><span class="n">reset</span><span class="p">(</span><span class="k">new</span> <span class="n">derived0</span><span class="p">());</span> <span class="k">break</span><span class="p">;</span>
-        <span class="k">case</span> <span class="mi">1</span><span class="o">:</span> <span class="n">ptr</span><span class="p">.</span><span class="n">reset</span><span class="p">(</span><span class="k">new</span> <span class="n">derived1</span><span class="p">());</span> <span class="k">break</span><span class="p">;</span>
-        <span class="c1">// ...</span>
-        <span class="k">default</span><span class="o">:</span> <span class="n">ptr</span><span class="p">.</span><span class="n">reset</span><span class="p">(</span><span class="mi">0</span><span class="p">);</span> <span class="k">break</span><span class="p">;</span>
-    <span class="p">}</span>
-    <span class="k">return</span> <span class="n">ptr</span><span class="p">;</span>
-<span class="p">}</span>
-
-<span class="n">unique_ptr</span><span class="o">&lt;</span><span class="n">base</span><span class="o">&lt;</span><span class="n">default_</span><span class="o">&gt;</span> <span class="o">&gt;</span> <span class="n">ptr</span> <span class="o">=</span>
-    <span class="n">strategy</span><span class="p">(</span><span class="n">input</span><span class="p">,</span> <span class="n">default_</span><span class="p">());</span> <span class="c1">// input is a runtime value</span>
-</pre></div>
-</div>
-<p>The strategy factory can be a standalone function, or a static member
-of a factory class that is specialized by tag dispatch. This can be
-done like the following:</p>
-<div class="highlight-c++"><div class="highlight"><pre><span></span><span class="k">template</span> <span class="o">&lt;</span><span class="k">class</span> <span class="nc">Tag</span><span class="o">&gt;</span>
-<span class="k">struct</span> <span class="n">strategy</span><span class="p">;</span>
-
-<span class="k">template</span> <span class="o">&lt;&gt;</span>
-<span class="k">struct</span> <span class="n">strategy</span><span class="o">&lt;</span><span class="n">default_</span><span class="o">&gt;</span> <span class="p">{</span>
-    <span class="k">static</span> <span class="n">unique_ptr</span><span class="o">&lt;</span><span class="n">base</span><span class="o">&lt;</span><span class="n">default_</span><span class="o">&gt;</span> <span class="o">&gt;</span> <span class="n">create</span><span class="p">(</span><span class="kt">int</span> <span class="n">input</span><span class="p">)</span> <span class="p">{</span>
-        <span class="n">unique_ptr</span><span class="o">&lt;</span><span class="n">base</span><span class="o">&lt;</span><span class="n">default_</span><span class="o">&gt;</span> <span class="o">&gt;</span> <span class="n">ptr</span><span class="p">;</span>
-        <span class="k">switch</span><span class="p">(</span><span class="n">input</span><span class="p">)</span> <span class="p">{</span>
-            <span class="k">case</span> <span class="mi">0</span><span class="o">:</span> <span class="n">ptr</span><span class="p">.</span><span class="n">reset</span><span class="p">(</span><span class="k">new</span> <span class="n">derived0</span><span class="p">());</span> <span class="k">break</span><span class="p">;</span>
-            <span class="k">case</span> <span class="mi">1</span><span class="o">:</span> <span class="n">ptr</span><span class="p">.</span><span class="n">reset</span><span class="p">(</span><span class="k">new</span> <span class="n">derived1</span><span class="p">());</span> <span class="k">break</span><span class="p">;</span>
-            <span class="c1">//...</span>
-            <span class="k">default</span><span class="o">:</span> <span class="n">ptr</span><span class="p">.</span><span class="n">reset</span><span class="p">(</span><span class="mi">0</span><span class="p">);</span> <span class="k">break</span><span class="p">;</span>
-        <span class="p">}</span>
-        <span class="k">return</span> <span class="n">ptr</span><span class="p">;</span>
-    <span class="p">}</span>
-<span class="p">};</span>
-</pre></div>
-</div>
-<p>This approach allows the header-only libraries to define new dynamic
-types in subsequent versions of the library while keeping the
-static-dynamic bridge fluid. The only down-side to this is the
-possibility of derived type explosion in case there are a lot of
-different strategies or specializations available &#8211; this though is
-not unique to static-dynamic bridging, but is also a problem with pure
-object oriented programming with dynamic polymorphism.</p>
-</div>
-
-
-          </div>
-        </div>
-      </div>
-      <div class="sphinxsidebar" role="navigation" aria-label="main navigation">
-        <div class="sphinxsidebarwrapper">
-  <h4>Previous topic</h4>
-  <p class="topless"><a href="directives.html"
-                        title="previous chapter">Directives</a></p>
-  <h4>Next topic</h4>
-  <p class="topless"><a href="../history.html"
-                        title="next chapter">Project history</a></p>
-<div id="searchbox" style="display: none" role="search">
-  <h3>Quick search</h3>
-    <form class="search" action="../search.html" method="get">
-      <input type="text" name="q" />
-      <input type="submit" value="Go" />
-      <input type="hidden" name="check_keywords" value="yes" />
-      <input type="hidden" name="area" value="default" />
-    </form>
-    <p class="searchtip" style="font-size: 90%">
-    Enter search terms or a module, class or function name.
-    </p>
-</div>
-<script type="text/javascript">$('#searchbox').show(0);</script>
-        </div>
-      </div>
-      <div class="clearer"></div>
-    </div>
-    <div class="related" role="navigation" aria-label="related navigation">
-      <h3>Navigation</h3>
-      <ul>
-        <li class="right" style="margin-right: 10px">
-          <a href="../history.html" title="Project history"
-             >next</a></li>
-        <li class="right" >
-          <a href="directives.html" title="Directives"
-             >previous</a> |</li>
-        <li class="nav-item nav-item-0"><a href="../contents.html">cpp-netlib v0.11.2</a> &raquo;</li>
-          <li class="nav-item nav-item-1"><a href="../techniques.html" >Techniques</a> &raquo;</li> 
-      </ul>
-    </div>
-    <div class="footer" role="contentinfo">
-        &copy; Copyright 2008-2014, Glyn Matthews, Dean Michael Berris; 2013 Google, Inc..
-      Last updated on Mar 07, 2016.
-      Created using <a href="http://sphinx-doc.org/">Sphinx</a> 1.3.6.
-    </div>
-  </body>
-</html>
\ No newline at end of file
diff --git a/libs/network/doc/html/techniques/tag_metafunctions.html b/libs/network/doc/html/techniques/tag_metafunctions.html
deleted file mode 100644
index 45274f5f4..000000000
--- a/libs/network/doc/html/techniques/tag_metafunctions.html
+++ /dev/null
@@ -1,265 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-
-
-<html xmlns="http://www.w3.org/1999/xhtml">
-  <head>
-    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-    
-    <title>Tag metafunctions &mdash; cpp-netlib v0.11.2</title>
-    
-    <link rel="stylesheet" href="../_static/pyramid.css" type="text/css" />
-    <link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
-    
-    <script type="text/javascript">
-      var DOCUMENTATION_OPTIONS = {
-        URL_ROOT:    '../',
-        VERSION:     '0.11.2',
-        COLLAPSE_INDEX: false,
-        FILE_SUFFIX: '.html',
-        HAS_SOURCE:  true
-      };
-    </script>
-    <script type="text/javascript" src="../_static/jquery.js"></script>
-    <script type="text/javascript" src="../_static/underscore.js"></script>
-    <script type="text/javascript" src="../_static/doctools.js"></script>
-    <link rel="top" title="cpp-netlib v0.11.2" href="../contents.html" />
-    <link rel="up" title="Techniques" href="../techniques.html" />
-    <link rel="next" title="Directives" href="directives.html" />
-    <link rel="prev" title="Techniques" href="../techniques.html" />
-<link rel="stylesheet" href="http://fonts.googleapis.com/css?family=Neuton&amp;subset=latin" type="text/css" media="screen" charset="utf-8" />
-<link rel="stylesheet" href="http://fonts.googleapis.com/css?family=Nobile:regular,italic,bold,bolditalic&amp;subset=latin" type="text/css" media="screen" charset="utf-8" />
-<!--[if lte IE 6]>
-<link rel="stylesheet" href="../_static/ie6.css" type="text/css" media="screen" charset="utf-8" />
-<![endif]-->
-
-  </head>
-  <body role="document">
-
-    <div class="related" role="navigation" aria-label="related navigation">
-      <h3>Navigation</h3>
-      <ul>
-        <li class="right" style="margin-right: 10px">
-          <a href="directives.html" title="Directives"
-             accesskey="N">next</a></li>
-        <li class="right" >
-          <a href="../techniques.html" title="Techniques"
-             accesskey="P">previous</a> |</li>
-        <li class="nav-item nav-item-0"><a href="../contents.html">cpp-netlib v0.11.2</a> &raquo;</li>
-          <li class="nav-item nav-item-1"><a href="../techniques.html" accesskey="U">Techniques</a> &raquo;</li> 
-      </ul>
-    </div>  
-
-    <div class="document">
-      <div class="documentwrapper">
-        <div class="bodywrapper">
-          <div class="body" role="main">
-            
-  <div class="section" id="tag-metafunctions">
-<h1>Tag metafunctions<a class="headerlink" href="#tag-metafunctions" title="Permalink to this headline">¶</a></h1>
-<p>Sometimes you want to vary a function or a type&#8217;s behavior based on a
-static parameter. In the <code class="xref py py-mod docutils literal"><span class="pre">cpp-netlib</span></code> there are a number of
-things you might want to change based on some such parameter &#8211; like
-what the underlying string type should be and how large a buffer
-should be, among other things. The primary way to define this in a
-header-only manner is to use tag-based metafunctions.</p>
-<p>The skeleton of the approach is based on a similar technique for
-defining type traits. In the <code class="xref py py-mod docutils literal"><span class="pre">cpp-netlib</span></code> however the type traits
-are defined on opaque tag types which serve to associate results to a
-family of metafunctions.</p>
-<div class="section" id="template-specialization">
-<h2>Template Specialization<a class="headerlink" href="#template-specialization" title="Permalink to this headline">¶</a></h2>
-<p>To illustrate this point, let&#8217;s define a tag <code class="docutils literal"><span class="pre">default_</span></code> which we use
-to denote the default implementation of a certain type <code class="docutils literal"><span class="pre">foo</span></code>. For
-instance we decide that the default string type we will use for
-<code class="docutils literal"><span class="pre">default_</span></code> tagged <code class="docutils literal"><span class="pre">foo</span></code> specializations will be an
-<code class="docutils literal"><span class="pre">std::string</span></code>.</p>
-<p>In the <code class="xref py py-mod docutils literal"><span class="pre">cpp-netlib</span></code> this is done by defining a <code class="docutils literal"><span class="pre">string</span></code>
-metafunction type that is specialized on the tag <code class="docutils literal"><span class="pre">default_</span></code> whose
-nested <code class="docutils literal"><span class="pre">type</span></code> result is the type <code class="docutils literal"><span class="pre">std::string</span></code>. In code this would
-translate to:</p>
-<div class="highlight-c++"><div class="highlight"><pre><span></span><span class="k">template</span> <span class="o">&lt;</span><span class="k">class</span> <span class="nc">Tag</span><span class="o">&gt;</span>
-<span class="k">struct</span> <span class="n">string</span> <span class="p">{</span>
-    <span class="k">typedef</span> <span class="kt">void</span> <span class="n">type</span><span class="p">;</span>
-<span class="p">};</span>
-
-<span class="k">struct</span> <span class="n">default_</span><span class="p">;</span>
-
-<span class="k">template</span> <span class="o">&lt;&gt;</span>
-<span class="k">struct</span> <span class="n">string</span><span class="o">&lt;</span><span class="n">default_</span><span class="o">&gt;</span> <span class="p">{</span>
-    <span class="k">typedef</span> <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">type</span><span class="p">;</span>
-<span class="p">};</span>
-</pre></div>
-</div>
-</div>
-<div class="section" id="template-metaprogramming">
-<h2>Template Metaprogramming<a class="headerlink" href="#template-metaprogramming" title="Permalink to this headline">¶</a></h2>
-<p>Starting with version 0.7, the tag dispatch mechanism changed slightly to use
-<a class="reference external" href="http://www.boost.org/libs/mpl/index.html">Boost.MPL</a>. The idea is still the same, although we can get a little smarter
-than just using template specializations. Instead of just defining an opaque
-type <code class="docutils literal"><span class="pre">default_</span></code>, we use the Boost.MPL equivalent of a vector to define which
-root types of properties this <code class="docutils literal"><span class="pre">default_</span></code> tag supports. The idea is to make the
-opaque type <code class="docutils literal"><span class="pre">default_</span></code> inherit property tags which the library supports
-internally as definite extension points.</p>
-<p>Our definition of the <code class="docutils literal"><span class="pre">default_</span></code> tag will then look something like the
-following:</p>
-<div class="highlight-c++"><div class="highlight"><pre><span></span><span class="k">typedef</span> <span class="n">mpl</span><span class="o">::</span><span class="n">vector</span><span class="o">&lt;</span><span class="n">default_string</span><span class="o">&gt;</span> <span class="n">default_tags</span><span class="p">;</span>
-
-<span class="k">template</span> <span class="o">&lt;</span><span class="k">class</span> <span class="nc">Tag</span><span class="o">&gt;</span>
-<span class="k">struct</span> <span class="n">components</span><span class="p">;</span>
-
-<span class="k">typedef</span> <span class="n">mpl</span><span class="o">::</span><span class="n">inherit_linearly</span><span class="o">&lt;</span>
-    <span class="n">default_tags</span><span class="p">,</span>
-    <span class="n">mpl</span><span class="o">::</span><span class="n">inherit</span><span class="o">&lt;</span><span class="n">mpl</span><span class="o">::</span><span class="n">placeholders</span><span class="o">::</span><span class="n">_1</span><span class="p">,</span> <span class="n">mpl</span><span class="o">::</span><span class="n">placeholders</span><span class="o">::</span><span class="n">_2</span><span class="o">&gt;</span>
-    <span class="o">&gt;::</span><span class="n">type</span> <span class="n">default_</span><span class="p">;</span>
-
-<span class="k">template</span> <span class="o">&lt;</span><span class="k">class</span> <span class="nc">Tag</span><span class="o">&gt;</span>
-<span class="k">struct</span> <span class="n">components</span><span class="o">&lt;</span><span class="n">default_</span><span class="o">&gt;</span> <span class="p">{</span>
-    <span class="k">typedef</span> <span class="n">default_tags</span> <span class="n">type</span><span class="p">;</span>
-<span class="p">};</span>
-</pre></div>
-</div>
-<p>In the above listing, <code class="docutils literal"><span class="pre">default_string</span></code> is what we call a &#8220;root&#8221; tag which is
-meant to be combined with other &#8220;root&#8221; tags to form composite tags. In this case
-our composite tag is the tag <code class="docutils literal"><span class="pre">default_</span></code>. There are a number of these &#8220;root&#8221;
-tags that <code class="xref py py-mod docutils literal"><span class="pre">cpp-netlib</span></code> provides. These are in the namespace
-<code class="docutils literal"><span class="pre">boost::network::tags</span></code> and are defined in <code class="docutils literal"><span class="pre">boost/network/tags.hpp</span></code>.</p>
-<p>Using this technique we change slightly our definition of the <code class="docutils literal"><span class="pre">string</span></code>
-metafunction class into this:</p>
-<div class="highlight-c++"><div class="highlight"><pre><span></span><span class="k">template</span> <span class="o">&lt;</span><span class="k">class</span> <span class="nc">Tag</span><span class="o">&gt;</span>
-<span class="k">struct</span> <span class="n">unsupported_tag</span><span class="p">;</span>
-
-<span class="k">template</span> <span class="o">&lt;</span><span class="k">class</span> <span class="nc">Tag</span><span class="o">&gt;</span>
-<span class="k">struct</span> <span class="nl">string</span> <span class="p">:</span>
-    <span class="n">mpl</span><span class="o">::</span><span class="n">if_</span><span class="o">&lt;</span>
-        <span class="n">is_base_of</span><span class="o">&lt;</span>
-            <span class="n">tags</span><span class="o">::</span><span class="n">default_string</span><span class="p">,</span>
-            <span class="n">Tag</span>
-        <span class="o">&gt;</span><span class="p">,</span>
-        <span class="n">std</span><span class="o">::</span><span class="n">string</span><span class="p">,</span>
-        <span class="n">unsupported_tag</span><span class="o">&lt;</span><span class="n">Tag</span><span class="o">&gt;</span>
-    <span class="o">&gt;</span>
-<span class="p">{};</span>
-</pre></div>
-</div>
-<p>Notice that we don&#8217;t have the typedef for <code class="docutils literal"><span class="pre">type</span></code> in the body of <code class="docutils literal"><span class="pre">string</span></code>
-anymore, but we do inherit from <code class="docutils literal"><span class="pre">mpl::if_</span></code>. Since <code class="docutils literal"><span class="pre">mpl::if_</span></code> is a template
-metafunction itself, it contains a definition of the resulting <code class="docutils literal"><span class="pre">type</span></code> which
-<code class="docutils literal"><span class="pre">string</span></code> inherits.</p>
-<p>You can see the real definition of the <code class="docutils literal"><span class="pre">string</span></code> metafunction in
-<code class="docutils literal"><span class="pre">boost/network/traits/string.hpp</span></code>.</p>
-</div>
-<div class="section" id="using-tags">
-<h2>Using Tags<a class="headerlink" href="#using-tags" title="Permalink to this headline">¶</a></h2>
-<p>Once we have the defined tag, we can then use this in the definition of our
-types. In the definition of the type <code class="docutils literal"><span class="pre">foo</span></code> we use this type function
-<code class="docutils literal"><span class="pre">string</span></code> and pass the tag type parameter to determine what to use as
-the string type in the context of the type <code class="docutils literal"><span class="pre">foo</span></code>. In code this would
-translate into:</p>
-<div class="highlight-c++"><div class="highlight"><pre><span></span><span class="k">template</span> <span class="o">&lt;</span><span class="k">class</span> <span class="nc">Tag</span><span class="o">&gt;</span>
-<span class="k">struct</span> <span class="n">foo</span> <span class="p">{</span>
-    <span class="k">typedef</span> <span class="k">typename</span> <span class="n">string</span><span class="o">&lt;</span><span class="n">Tag</span><span class="o">&gt;::</span><span class="n">type</span> <span class="n">string_type</span><span class="p">;</span>
-
-    <span class="c1">// .. use string_type where you need a string.</span>
-<span class="p">};</span>
-</pre></div>
-</div>
-<p>Using this approach we can support different types of strings for
-different tags on the type <code class="docutils literal"><span class="pre">foo</span></code>. In case we want to use a different
-type of string for the tag <code class="docutils literal"><span class="pre">default_</span></code> we only change the
-composition of the <code class="docutils literal"><span class="pre">string_tags</span></code> MPL vector. For example, in <code class="xref py py-mod docutils literal"><span class="pre">cpp-netlib</span></code>
-there is a root tag <code class="docutils literal"><span class="pre">default_wstring</span></code> which causes the <code class="docutils literal"><span class="pre">string</span></code> metafunction
-to define <code class="docutils literal"><span class="pre">std::wstring</span></code> as the resulting type.</p>
-<p>The approach also allows for the control of the structure and features
-of types like <code class="docutils literal"><span class="pre">foo</span></code> based on the specialization of the tag. Whole
-type function families can be defined on tags where they are supported
-and ignored in cases where they are not.</p>
-<p>To illustrate let&#8217;s define a new tag <code class="docutils literal"><span class="pre">swappable</span></code>. Given the above
-definition of <code class="docutils literal"><span class="pre">foo</span></code>, we want to make the <code class="docutils literal"><span class="pre">swappable</span></code>-tagged
-<code class="docutils literal"><span class="pre">foo</span></code> define a <code class="docutils literal"><span class="pre">swap</span></code> function that extends the original
-<code class="docutils literal"><span class="pre">default_</span></code>-tagged <code class="docutils literal"><span class="pre">foo</span></code>. In code this would look like:</p>
-<div class="highlight-c++"><div class="highlight"><pre><span></span><span class="k">struct</span> <span class="n">swappable</span><span class="p">;</span>
-
-<span class="k">template</span> <span class="o">&lt;&gt;</span>
-<span class="k">struct</span> <span class="n">foo</span><span class="o">&lt;</span><span class="n">swappable</span><span class="o">&gt;</span> <span class="o">:</span> <span class="n">foo</span><span class="o">&lt;</span><span class="n">default_</span><span class="o">&gt;</span> <span class="p">{</span>
-    <span class="kt">void</span> <span class="n">swap</span><span class="p">(</span><span class="n">foo</span><span class="o">&lt;</span><span class="n">swappable</span><span class="o">&gt;</span> <span class="o">&amp;</span> <span class="n">other</span><span class="p">)</span> <span class="p">{</span>
-        <span class="c1">// ...</span>
-    <span class="p">}</span>
-<span class="p">};</span>
-</pre></div>
-</div>
-<p>We also for example want to enable an ADL-reachable <code class="docutils literal"><span class="pre">swap</span></code> function:</p>
-<div class="highlight-c++"><div class="highlight"><pre><span></span><span class="k">struct</span> <span class="n">swappable</span><span class="p">;</span>
-
-<span class="kr">inline</span>
-<span class="kt">void</span> <span class="nf">swap</span><span class="p">(</span><span class="n">foo</span><span class="o">&lt;</span><span class="n">swappable</span><span class="o">&gt;</span> <span class="o">&amp;</span> <span class="n">left</span><span class="p">,</span> <span class="n">foo</span><span class="o">&lt;</span><span class="n">swappable</span><span class="o">&gt;</span> <span class="o">&amp;</span> <span class="n">right</span><span class="p">)</span> <span class="p">{</span>
-    <span class="n">left</span><span class="p">.</span><span class="n">swap</span><span class="p">(</span><span class="n">right</span><span class="p">);</span>
-<span class="p">}</span>
-</pre></div>
-</div>
-<p>Overall what the tag-based definition approach allows is for static
-definition of extension points that ensures type-safety and
-invariants. This keeps the whole extension mechanism static and yet
-flexible.</p>
-</div>
-</div>
-
-
-          </div>
-        </div>
-      </div>
-      <div class="sphinxsidebar" role="navigation" aria-label="main navigation">
-        <div class="sphinxsidebarwrapper">
-  <h3><a href="../contents.html">Table Of Contents</a></h3>
-  <ul>
-<li><a class="reference internal" href="#">Tag metafunctions</a><ul>
-<li><a class="reference internal" href="#template-specialization">Template Specialization</a></li>
-<li><a class="reference internal" href="#template-metaprogramming">Template Metaprogramming</a></li>
-<li><a class="reference internal" href="#using-tags">Using Tags</a></li>
-</ul>
-</li>
-</ul>
-
-  <h4>Previous topic</h4>
-  <p class="topless"><a href="../techniques.html"
-                        title="previous chapter">Techniques</a></p>
-  <h4>Next topic</h4>
-  <p class="topless"><a href="directives.html"
-                        title="next chapter">Directives</a></p>
-<div id="searchbox" style="display: none" role="search">
-  <h3>Quick search</h3>
-    <form class="search" action="../search.html" method="get">
-      <input type="text" name="q" />
-      <input type="submit" value="Go" />
-      <input type="hidden" name="check_keywords" value="yes" />
-      <input type="hidden" name="area" value="default" />
-    </form>
-    <p class="searchtip" style="font-size: 90%">
-    Enter search terms or a module, class or function name.
-    </p>
-</div>
-<script type="text/javascript">$('#searchbox').show(0);</script>
-        </div>
-      </div>
-      <div class="clearer"></div>
-    </div>
-    <div class="related" role="navigation" aria-label="related navigation">
-      <h3>Navigation</h3>
-      <ul>
-        <li class="right" style="margin-right: 10px">
-          <a href="directives.html" title="Directives"
-             >next</a></li>
-        <li class="right" >
-          <a href="../techniques.html" title="Techniques"
-             >previous</a> |</li>
-        <li class="nav-item nav-item-0"><a href="../contents.html">cpp-netlib v0.11.2</a> &raquo;</li>
-          <li class="nav-item nav-item-1"><a href="../techniques.html" >Techniques</a> &raquo;</li> 
-      </ul>
-    </div>
-    <div class="footer" role="contentinfo">
-        &copy; Copyright 2008-2014, Glyn Matthews, Dean Michael Berris; 2013 Google, Inc..
-      Last updated on Mar 07, 2016.
-      Created using <a href="http://sphinx-doc.org/">Sphinx</a> 1.3.6.
-    </div>
-  </body>
-</html>
\ No newline at end of file
diff --git a/libs/network/doc/html/whats_new.html b/libs/network/doc/html/whats_new.html
index 4cdee36af..b08baf7be 100644
--- a/libs/network/doc/html/whats_new.html
+++ b/libs/network/doc/html/whats_new.html
@@ -358,7 +358,7 @@ <h3>Navigation</h3>
     </div>
     <div class="footer" role="contentinfo">
         &copy; Copyright 2008-2014, Glyn Matthews, Dean Michael Berris; 2013 Google, Inc..
-      Last updated on Mar 07, 2016.
+      Last updated on Mar 29, 2016.
       Created using <a href="http://sphinx-doc.org/">Sphinx</a> 1.3.6.
     </div>
   </body>
diff --git a/libs/network/doc/in_depth.rst b/libs/network/doc/in_depth.rst
deleted file mode 100644
index 39af9a4f4..000000000
--- a/libs/network/doc/in_depth.rst
+++ /dev/null
@@ -1,15 +0,0 @@
-.. _in_depth:
-
-An in-depth look at the :mod:`cpp-netlib`
-=========================================
-
-The :mod:`cpp-netlib` is composed of three different sets of
-functionality: a **message** template, a **URI** template and
-different **protocol** implementations.
-
-.. toctree::
-   :maxdepth: 2
-
-   in_depth/message
-   in_depth/uri
-   in_depth/http
diff --git a/libs/network/doc/in_depth/http.rst b/libs/network/doc/in_depth/http.rst
deleted file mode 100644
index 711bf6b3e..000000000
--- a/libs/network/doc/in_depth/http.rst
+++ /dev/null
@@ -1,180 +0,0 @@
-HTTP implementation
-===================
-
-HTTP client
-```````````
-
-At the heart of the HTTP client implementation is a single class aptly named
-``basic_client``, which is also a template. The template ``basic_client`` takes
-three template parameters:
-
-.. code-block:: c++
-
-    namespace boost { namespace http {
-
-        template <class Tag, unsigned version_major, unsigned version_minor>
-        struct basic_client;
-
-    } // namespace http
-
-    } // namespace boost
-
-The ``Tag`` template parameter follows the same tag-dispatch mechanism to
-determine the behavior of the ``basic_client``. The interface of
-``basic_client`` may change depending on certain properties defined for the tag
-you provide. Below is a table of predefined supported tags you can use in your
-overload of the ``basic_client``:
-
-------------
-
-.. include:: http_client_tags.rst
-
-.. _Boost.Thread: http://www.boost.org/libs/thread
-
-
-The default typedef for the HTTP client that is provided uses the
-``http_async_8bit_udp_resolve`` tag, and implements HTTP 1.1. The exact
-typedef is in the ``boost::network::http`` namespace as the following:
-
-.. code-block:: c++
-
-    namespace boost { namespace network { namespace http {
-
-        typedef basic_client<tags::http_async_8bit_udp_resolve, 1, 1>
-            client;
-
-    }}}
-
-
-This type has nested typedefs for the correct types for the ``basic_request``
-and ``basic_response`` templates. To use the correct types for ``basic_request``
-or ``basic_response`` you can use these nested typedefs like so:
-
-
-.. code-block:: c++
-
-    boost::network::http::client::request request;
-    boost::network::http::client::response response;
-
-    // or...
-    using namespace boost::network;
-    http::client::request request;
-    http::client::response response;
-
-
-Typical use cases for the HTTP client would look something like the following:
-
-
-.. code-block:: c++
-
-    using namespace boost::network;
-    http::request request("http://www.boost.org/");
-    request << header("Connection", "close");
-
-
-The ``basic_client`` implements all HTTP methods as member functions
-(HEAD, GET, POST, PUT, DELETE).  Therefore, the code to make an HTTP
-request looks trivially simple:
-
-
-.. code-block:: c++
-
-    using namespace boost::network;
-    http::client client;
-    http::client::request request("http://www.boost.org/");
-    http::client::response response = client.get(request);
-
-
-Accessing data from ``http::response`` is done using wrappers.
-To get the response headers, we use the ``headers`` wrapper which
-returns, in the default case, a multimap of strings to strings:
-
-
-.. code-block:: c++
-
-    using namespace boost::network;
-    typedef headers_range<http_client::response>::type response_headers;
-    boost::range_iterator<response_headers>::type iterator;
-
-    response_headers headers_ = headers(response);
-    for (iterator it = headers_.begin(); it != headers_.end(); ++it) {
-        std::cout << it->first << ": " << it->second << std::endl;
-    }
-    std::cout << std::endl;
-
-
-HTTP server
-```````````
-
-As with the HTTP client, the HTTP server that is provided with
-cpp-netlib is extensible through the tag mechanism and is embeddable.
-The template class declaration of ``basic_server`` is given below:
-
-
-.. code-block:: c++
-
-    namespace boost { namespace network { namespace http {
-
-        template <class Tag, class RequestHandler> basic_server;
-
-    }}}
-
-
-The second template argument is used to specify the request handler
-type. The request handler type is a functor type which should overload
-the function call operator (``RequestHandler::operator()`` should be
-overloaded) that takes two parameters: the first one being a reference
-to a ``const basic_request<Tag>`` and the second being a reference to
-a ``basic_response<Tag>`` instance.
-
-All the logic for parsing the HTTP request and building the ``const
-basic_request<Tag>`` object resides internally in the ``basic_server``
-template.  Processing the request is delegated to the
-``RequestHandler`` type, and the assumption of which would be that the
-response is formed inside the ``RequestHandler`` function call
-operator overload.
-
-The ``basic_server`` template however is only an underlying
-implementation while the user-visible implementation is the
-``http::server`` template. This simply specializes the
-``basic_server`` template to use the ``default_`` tag and forwards the
-``RequestHandler`` parameter:
-
-.. code-block:: c++
-
-    namespace boost { namespace network { namespace http {
-
-        template <class RequestHandler>
-        class server :
-            public basic_server<default_, RequestHandler> {};
-
-    }}}
-
-To use the forwarding server type you just supply the request handler
-implementation as the parameter. For example, an "echo" server example
-might look something like this:
-
-
-.. code-block:: c++
-
-    using namespace boost::network;
-    struct echo;
-    typedef http::server<echo> echo_server;
-
-    struct echo {
-        void operator () (const echo_server::request &request,
-                          echo_server::response &response) const {
-            std::string ip = source(request);
-            response = echo_server::response::stock_reply(
-                echo_server::response::ok,
-		body(request));
-            std::cerr << "[" << ip << "]: " << request.uri <<
-                " status = " << echo_server::response::ok << '\n';
-        }
-    };
-
-
-Here, all we're doing is returning the original request body with an
-HTTP OK response (200). We are also printing the IP address from where the
-request came from. Notice that we are using a wrapper to access the source of
-the request.
diff --git a/libs/network/doc/in_depth/http_client_tags.rst b/libs/network/doc/in_depth/http_client_tags.rst
deleted file mode 100644
index 5d79ed1ea..000000000
--- a/libs/network/doc/in_depth/http_client_tags.rst
+++ /dev/null
@@ -1,42 +0,0 @@
-+---------------------------------+---------------------------------------------+
-| Tag                             | Description                                 |
-+=================================+=============================================+
-| http_default_8bit_tcp_resolve   | This is the default HTTP implementation tag |
-|                                 | that resolves addresses with a TCP resolver |
-|                                 | and provides a synchronous/blocking HTTP    |
-|                                 | client interface.                           |
-+---------------------------------+---------------------------------------------+
-| http_default_8bit_udp_resolve   | This is similar to the above tag except that|
-|                                 | it specifies the HTTP client to use a UDP   |
-|                                 | resolver. It also provides a synchronous/   |
-|                                 | blocking HTTP client interface.             |
-+---------------------------------+---------------------------------------------+
-| http_keepalive_8bit_tcp_resolve | This tag specifies that the HTTP client by  |
-|                                 | default will keep connections to the server |
-|                                 | alive. It only makes sense if the           |
-|                                 | ``version_major`` and ``version_minor`` are |
-|                                 | both ``1``, to indicate HTTP 1.1. This tag  |
-|                                 | causes the HTTP client to resolve using a   |
-|                                 | TCP resolver and provides a synchronous/    |
-|                                 | blocking HTTP client interface.             |
-+---------------------------------+---------------------------------------------+
-| http_keepalive_8bit_udp_resolve | This is similar to the above tag except that|
-|                                 | it specifies the HTTP client to use a UDP   |
-|                                 | resolver. It also provides a synchronous/   |
-|                                 | blocking HTTP client interface.             |
-+---------------------------------+---------------------------------------------+
-| http_async_8bit_tcp_resolve     | This tag provides an active HTTP client     |
-|                                 | object implementation that uses a TCP       |
-|                                 | resolver. Response objects returned will    |
-|                                 | encapsulate a number of Boost.Thread_       |
-|                                 | shared futures to hold values. Users don't  |
-|                                 | have to see this as they are implementation |
-|                                 | details.                                    |
-+---------------------------------+---------------------------------------------+
-| http_async_8bit_udp_resolve     | This is similar to the above tag except that|
-|                                 | specifies the HTTP client to use a UDP      |
-|                                 | resolver.                                   |
-+---------------------------------+---------------------------------------------+
-
-.. _Boost.Thread: http://www.boost.org/libs/thread
-
diff --git a/libs/network/doc/in_depth/message.rst b/libs/network/doc/in_depth/message.rst
deleted file mode 100644
index 51512314b..000000000
--- a/libs/network/doc/in_depth/message.rst
+++ /dev/null
@@ -1,233 +0,0 @@
-The message template
-====================
-
-One of the core components in the library is the concept and the
-implementation of a common message type. In most (not all) network
-protocols, the concept of a message is central to the definition of
-the protocol. In HTTP, SMTP, XMPP, and even other protocols like SNMP
-and ICMP, there is a common notion of a "packet" or a message. In
-cpp-netlib we chose to implement the concept of a message that has the
-following common parts:
-
-  * **Source** - every message has a source identifier which varies
-    from protocol to protocol.
-
-  * **Destination** - every message has a destination identifier which
-    varies from protocol to protocol.
-
-  * **Headers** - each message is assumed to contain headers, which
-    may be empty in cases where the protocol does not support it, but
-    is nonetheless supported by cpp-netlib messages.
-
-  * **Body** - the content area of a message which varies from
-    protocol to protocol (also sometimes referred to as payload).
-
-This division is purely logical -- in the underlying implementation,
-the message type can choose to have different means of storing the
-data, depending on the type used to tag the message. This section
-covers the `Message Concept`_ as well as the `basic_message`_
-implementation.
-
-Message Concept
-```````````````
-
-.. warning:: The Message framework is deprecated in the 0.11 release, and will
-             be removed in future versions of the library.
-
-The Message Concept specifies what the valid operations on a message
-are as well as what messages look like semantically. The following
-table summarize the operations and syntactic as well as semantic
-properties of messages.
-
-**Legend**
-
-:M: The message type.
-:H: A headers container type.
-:m,n: An instance of **M**.
-:S: A string type.
-:s,k,v: An instance of **S**.
-:O: The source type.
-:D: The destination type.
-:B: The body type.
-:T: The Tag type.
-
-+----------------------------+----------------------+-----------------------------------------+
-| Construct                  | Result               | Description                             |
-+============================+======================+=========================================+
-| ``typename M::tag``        | T                    | The nested tag type.                    |
-+----------------------------+----------------------+-----------------------------------------+
-| ``M()``                    | Instance of M        | Default constructible.                  |
-+----------------------------+----------------------+-----------------------------------------+
-| ``M(m)``                   | Instance of M        | Copy constructible.                     |
-+----------------------------+----------------------+-----------------------------------------+
-| ``m = n;``                 | Reference to m       | Assignable.                             |
-+----------------------------+----------------------+-----------------------------------------+
-| ``swap(m, n);``            | ``void``             | Swappable.                              |
-+----------------------------+----------------------+-----------------------------------------+
-| ``source(m);``             | Convertible to O     | Retrieve the source of ``m``.           |
-+----------------------------+----------------------+-----------------------------------------+
-| ``destination(m);``        | Convertible to D     | Retrieve the destination of ``m``.      |
-+----------------------------+----------------------+-----------------------------------------+
-| ``headers(m);``            | Convertible to H     | Retrieve the headers of ``m``.          |
-+----------------------------+----------------------+-----------------------------------------+
-| ``body(m);``               | Convertible to B     | Retrieve the body of ``m``.             |
-+----------------------------+----------------------+-----------------------------------------+
-| ``m << source(s);``        | ``M &``              | Set the source of ``m``.                |
-+----------------------------+----------------------+-----------------------------------------+
-| ``m << destination(s);``   | ``M &``              | Set the destination of ``m``.           |
-+----------------------------+----------------------+-----------------------------------------+
-| ``m << header(k, v);``     | ``M &``              | Add a header to ``m``.                  |
-+----------------------------+----------------------+-----------------------------------------+
-| ``m << remove_header(k);`` | ``M &``              | Remove a header from ``m``.             |
-+----------------------------+----------------------+-----------------------------------------+
-| ``m << body(s);``          | ``M &``              | Set the body of ``m``.                  |
-+----------------------------+----------------------+-----------------------------------------+
-| ``source(m,s);``           | ``void``             | Set the source of ``m``.                |
-+----------------------------+----------------------+-----------------------------------------+
-| ``destination(m,s);``      | ``void``             | Set the destination of ``m``.           |
-+----------------------------+----------------------+-----------------------------------------+
-| ``add_header(m, k, v);``   | ``void``             | Add a header to ``m``.                  |
-+----------------------------+----------------------+-----------------------------------------+
-| ``remove_header(m, k);``   | ``void``             | Remove a header from ``m``.             |
-+----------------------------+----------------------+-----------------------------------------+
-| ``clear_headers(m);``      | ``void``             | Clear the headers of ``m``.             |
-+----------------------------+----------------------+-----------------------------------------+
-| ``body(m,s);``             | ``M &``              | Set the body of ``m``.                  |
-+----------------------------+----------------------+-----------------------------------------+
-
-Types that model the Message Concept are meant to encapsulate data
-that has a source, a destination, one or more named headers, and a
-body/payload. Because the accessors and the directives are not
-required to be part of the message type that models the Message
-Concept, a message can be implemented as a POD type and have all
-manipulations performed in the directive implementations, as well as
-value transformations done in the accessors.
-
-Directives, Modifiers, and Wrappers
-```````````````````````````````````
-
-In the Message Concept definition there are three basic constructs that follow a
-certain pattern. These patterns are Directives_, Modifiers_, and Wrappers_.
-
-Directives
-~~~~~~~~~~
-
-A directive is a function object that is applied to a Message. Directives
-encapsulate a set of operations that apply to messages. The general requirement
-for a Directive is that it should apply these operations on a message.
-
-A directive may dispatch on the type of the message passed to it at the point of
-the function call. Typically, directives are generated using a factory function
-that returns the correct directive type.
-
-For a given directive ``foo_directive`` a generator function called ``foo`` is
-typically implemented:
-
-.. code-block:: c++
-
-    struct foo_directive {
-        template <class Message>
-        Message & operator()(Message & m) const {
-            // do something to m
-            return m;
-        }
-    };
-
-    foo_directive const foo() {
-        return foo_directive();
-    }
-
-    // to apply a directive, we use the << operator
-    message m;
-    m << foo();
-
-Modifiers
-~~~~~~~~~
-
-A modifier is generally defined as a free function that takes a reference to a
-non-const lvalue message as the first parameter, and any number of parameters.
-In the concept definition of the Message Concept, a modifier follows the form:
-
-.. code-block:: c++
-
-    modifier(message, ...)
-
-Modifiers are meant to imply modifications on a message, which also allows for
-easier dispatch based on Argument Dependent Lookup (ADL_) on the type of the
-message. Note that Directives_ can be implemented in terms of Modifiers and
-vice versa, although that is not required nor specified.
-
-.. _ADL: http://en.wikipedia.org/wiki/Argument-dependent_name_lookup
-
-Wrappers
-~~~~~~~~
-
-A Wrapper is basically an implementation detail that ensures that a given
-message, when wrapped, can be converted to the associated part of the message. A
-wrapper has a type that encapsulates the conversion logic from a message to a
-given type.
-
-An example of a Wrapper would be ``source_wrapper`` which would be returned by a
-call to the wrapper generator function ``source``. An example implementation of
-the ``source_wrapper`` would look like:
-
-.. code-block:: c++
-
-    template <class Tag, template <class> class Message>
-    struct source_wrapper {
-        Message<Tag> const & m;
-        explicit source_wrapper(Message<Tag> const & m)
-        : m(m) {}
-        typedef typename source<Tag>::type source_type;
-        operator source_type const & () {
-            return m.source;
-        }
-        operator source_type const () {
-            return m.source;
-        }
-        operator source_type () {
-            return m.source;
-        }
-    };
-
-    template <class Tag, template <class> class Message>
-    source_wrapper<Tag, Message> const
-    source(Message<Tag> const & message) {
-        return source_wrapper<Tag, Message>(message);
-    }
-
-This pattern is similar to an adapter, but the specific notion of wrapping a
-data type (in this case, an object of a type that models the Message Concept)
-using an intermediary wrapper is what is pertained to by the Wrapper pattern.
-In this case, the Wrapper is ``source_wrapper`` while ``source`` is merely a
-wrapper generator function.
-
-``basic_message``
-`````````````````
-
-The default implementation of a simple type that models the Message
-Concept is available in cpp-netlib. This default implementation is
-named ``basic_message`` which supports a ``Tag`` template
-parameter. The definition of ``basic_message`` looks like this:
-
-.. code-block:: c++
-
-    template <class Tag>
-    class basic_message;
-
-The ``basic_message`` template requires that the following
-tag-dispatched metafunctions are defined for the type ``Tag``:
-
-.. code-block:: c++
-
-    template <class Tag>
-    struct string;
-
-    template <class Tag>
-    struct headers_container;
-
-All the operations defined by the message concept are implemented by
-this basic message type. Other message implementations can either use
-this common message type or specialize it according to whether they
-want to use different containers or whether it's going to be just a
-POD type.
diff --git a/libs/network/doc/in_depth/uri.rst b/libs/network/doc/in_depth/uri.rst
deleted file mode 100644
index 84eca62e2..000000000
--- a/libs/network/doc/in_depth/uri.rst
+++ /dev/null
@@ -1,151 +0,0 @@
-The URI class
-=============
-
-In addition to protocol implementations, the :mod:`cpp-netlib`
-provides a powerful URI class.  The class implements a parser based
-on `RFC 3986`_ and `RFC 2732`_.
-
-Generic URI syntax overview
-```````````````````````````
-
-A generic URI will take the form::
-
-  [scheme:]scheme-specific-part[#fragment]
-
-A URI is known as `absolute` if it specifies the scheme.  Otherwise,
-it is known as a relative URI.  Currently, ``uri`` supports only
-absolute URIs.
-
-URIs can be further classified according to whether they're
-hierarchical or opaque (non-hierarchical).
-
-Some examples of non-hierarchical URIs include::
-
-   mailto:john.doe@example.com
-   news:comp.infosystems.www.servers.unix
-   tel:+1-816-555-1212
-
-The data following the first ``":"`` is said to be opaque to the URI
-parser and requires no further parsing.  By way of example, the
-following shows how a non-hierarchical URI is processed by the parser
-by defining everything after the ``":"`` to be a part of the path:
-
-.. image:: ../_static/mailto_uri.png
-
-A hierarchical URI is identified by a double slash (``"//"``) after
-the scheme and a scheme-specific component, which `RFC 3986`_ defines
-to be::
-
-  [scheme:][//authority][path][?query][#fragment]
-
-The authority component can be further broken down to::
-
-  [user_info@]host[:port]
-
-Examples of hierarchical URIs include::
-
-   http://www.boost.org/
-   file:///bin/bash
-
-The following example, describing a complex URI using FTP, shows how
-a URI is broken down by the parser:
-
-.. image:: ../_static/ftp_uri.png
-
-Note that the ``authority`` is further subdivided into different
-elements.  Another example, using HTTP is given below:
-
-.. image:: ../_static/http_uri.png
-
-The difference here between the path in a hierarchical URI and that in
-the example above for the non-hierarchical URI.
-
-The ``uri`` class
-`````````````````
-
-As of version 0.9.3, ``uri`` supplies a URI parser and builder.
-To use the parser, it's as simple as supplying a string to the
-constructor:
-
-.. code-block:: c++
-
-   using namespace boost::network;
-   uri::uri instance("http://cpp-netlib.github.com/");
-   assert(instance.is_valid());
-   std::cout << "scheme: " << instance.scheme() << std::endl
-             << "host: " << instance.host() << std::endl;
-
-The command-line output of this program will be::
-
-   scheme: http
-   host: cpp-netlib.github.com
-
-The ``uri`` builder
-```````````````````
-
-``uri`` support a stream style syntax to create a URI from it's
-elements.  For example the program:
-
-.. code-block:: c++
-
-   #include <iostream>
-   #include <boost/network/uri.hpp>
-   #include <boost/network/uri/uri_io.hpp>
-   using namespace boost::network;
-
-   int main() {
-       uri::uri url;
-       url << uri::scheme("http")
-           << uri::host("www.github.com")
-           << uri::path("/cpp-netlib");
-       std::cout << url << std::endl;
-       return 0;
-   }
-
-will output::
-
-   http://www.github.com/cpp-netlib
-
-``URI Concept``
-```````````````
-
-**Legend**
-
-:U: The URI type.
-:u,u_: An instance of **M**.
-:S: A string type.
-:s,v: An instance of **S**.
-:T: The Tag type.
-
-+----------------------------+----------------------+-----------------------------------------+
-| Construct                  | Result               | Description                             |
-+============================+======================+=========================================+
-| ``U(u)``                   | Instance of U        | Copy constructible.                     |
-+----------------------------+----------------------+-----------------------------------------+
-| ``U(s)``                   | Instance of U        | Constructible from string.              |
-+----------------------------+----------------------+-----------------------------------------+
-| ``u = u_;``                | Reference to u       | Assignable.                             |
-+----------------------------+----------------------+-----------------------------------------+
-| ``u = s;``                 | Reference to u       | Assignable from string.                 |
-+----------------------------+----------------------+-----------------------------------------+
-| ``swap(u, u_);``           | ``void``             | Swappable.                              |
-+----------------------------+----------------------+-----------------------------------------+
-| ``scheme(u);``             | Convertible to S     | Retrieve the URI scheme of ``u``.       |
-+----------------------------+----------------------+-----------------------------------------+
-| ``user_info(u);``          | Convertible to S     | Retrieve the user info of ``u``.        |
-+----------------------------+----------------------+-----------------------------------------+
-| ``host(u);``               | Convertible to S     | Retrieve the host of ``u``.             |
-+----------------------------+----------------------+-----------------------------------------+
-| ``port(u);``               | Convertible to H     | Retrieve the port of ``u``.             |
-+----------------------------+----------------------+-----------------------------------------+
-| ``path(u);``               | Convertible to S     | Retrieve the path of ``u``.             |
-+----------------------------+----------------------+-----------------------------------------+
-| ``query(u);``              | Convertible to S     | Retrieve the query string of ``u``.     |
-+----------------------------+----------------------+-----------------------------------------+
-| ``fragment(u);``           | Convertible to S     | Retrieve the fragment of ``u``.         |
-+----------------------------+----------------------+-----------------------------------------+
-
-.. _`RFC 3986`: http://tools.ietf.org/html/rfc3986
-.. _`RFC 2368`: http://tools.ietf.org/html/rfc2368
-.. _`RFC 3513`: http://tools.ietf.org/html/rfc3513
-.. _`RFC 2732`: http://tools.ietf.org/html/rfc2732
diff --git a/libs/network/doc/index.rst b/libs/network/doc/index.rst
index fc9e65405..3329b8a30 100644
--- a/libs/network/doc/index.rst
+++ b/libs/network/doc/index.rst
@@ -108,7 +108,6 @@ Want to learn more?
     * :ref:`Take a look at the getting started guide <getting_started>`
     * :ref:`Learn from some simple examples <examples>`
     * :ref:`Find out what's new <whats_new>`
-    * :ref:`Study the library in more depth <in_depth>`
     * :ref:`Discover more through the full reference <reference>`
     * :ref:`Full table of contents <contents>`
 
diff --git a/libs/network/doc/reference/http_server.rst b/libs/network/doc/reference/http_server.rst
index 26ceb9b65..c0022bdda 100644
--- a/libs/network/doc/reference/http_server.rst
+++ b/libs/network/doc/reference/http_server.rst
@@ -5,9 +5,9 @@ HTTP Server API
 General
 -------
 
-:mod:`cpp-netlib` includes and implements two distinct HTTP server
-implementations that you can use and embed in your own applications. Both HTTP
-Server implementations:
+:mod:`cpp-netlib` includes and implements and asynchronous HTTP server
+implementation that you can use and embed in your own applications. The HTTP
+Server implementation:
 
   * **Cannot be copied.** This means you may have to store instances of the HTTP
     Server in dynamic memory if you intend to use them as function parameters or
@@ -15,60 +15,19 @@ Server implementations:
   * **Assume that requests made are independent of each other.** None of the
     HTTP Server implementations support request pipelining (yet) so a single
     connection only deals with a single request.
-  * **Are header-only and are compiled-into your application.** Future releases
-    in case you want to upgrade the implementation you are using in your
-    application will be distributed as header-only implementations, which means
-    you have to re-compile your application to use a newer version of the
-    implementations.
-
-The HTTP Servers have different semantics, and in some cases require different
-APIs from the supplied template parameters.
-
-Implementations
----------------
-
-There are two different user-facing template classes that differentiate the
-`Synchronous Servers`_ from the `Asynchronous Servers`_. Both templates take a
-single template parameter named ``Handler`` which describes the type of the
-Handler function object.
-
-There are two different Handler concepts, one concept for `Synchronous Servers`_
-and another for `Asynchronous Servers`.
-
-The SynchronousHandler concept for `Synchronous Servers`_ is described by the
-following table:
-
----------------
-
-**Legend:**
-
-H
-    The Handler type.
-h
-    An instance of H.
-Req
-    A type that models the Request Concept.
-Res
-    A type that models the Response Concept.
-req
-    An instance of Req.
-res
-    An instance of Res.
-
-+----------------+-------------+----------------------------------------------+
-| Construct      | Return Type | Description                                  |
-+================+=============+==============================================+
-| ``h(req,res)`` | ``void``    | Handle the request; res is passed in as a    |
-|                |             | non-const lvalue, which represents the       |
-|                |             | response to be returned to the client        |
-|                |             | performing the request.                      |
-+----------------+-------------+----------------------------------------------+
-
-More information about the internals of the `Synchronous Servers`_ can be found
-in the following section.
-
-The AsynchronousHandler concept for `Asynchronous Servers`_ is described by the
-following table:
+  * **The Handler instance is invoked asynchronously**. This means the I/O
+    thread used to handle network-related events are free to handle only the
+    I/O related events. This enables the server to scale better as to the
+    number of concurrent connections it can handle.
+  * **The Handler is able to schedule asynchronous actions on the thread pool
+    associated with the server.** This allows handlers to perform multiple
+    asynchronous computations that later on perform writes to the connection.
+  * **The Handler is able to control the (asynchronous) writes to and reads
+    from the HTTP connection.** Because the connection is available to the
+    Handler, that means it can write out chunks of data at a time or stream
+    data through the connection continuously.
+
+The Handler concept for the HTTP Server is described by the following table:
 
 ---------------
 
@@ -95,270 +54,30 @@ conn
 |                  |             | writing to and reading from the connection.|
 +------------------+-------------+--------------------------------------------+
 
-More information about the internals of the `Asynchronous Servers`_ can be found
-in the following section.
-
-Synchronous Servers
--------------------
-
-The synchronous server implementation is represented by the template ``server``
-in namespace ``boost::network::http``. The ``server`` template takes in a single
-template parameter named ``Handler`` which models the SynchronousHandler
-concept (described above).
-
-An instance of Handler is taken in by reference to the constructor of the HTTP
-server. This means the Handler is not copied around and only a single instance
-of the handler is used for all connections and requests performed against the
-HTTP server.
-
-.. warning:: It is important to note that the HTTP server does not implement any
-   locking upon invoking the Handler. In case you have any state in the Handler
-   that will be associated with the synchronous server, you would have to
-   implement your own synchronization internal to the Handler implementation.
-   This matters especially if you run the synchronous server in multiple
-   threads.
-
-The general pattern of usage for the HTTP Server template is shown below:
-
-.. code-block:: c++
-
-    struct handler;
-    typedef boost::network::http::server<handler> http_server;
-
-    struct handler {
-        void operator()(
-            http_server::request const & req,
-            http_server::response & res
-        ) {
-            // do something, and then edit the res object here.
-        }
-    };
-
-More information about the actual HTTP Server API follows in the next section.
-It is important to understand that the HTTP Server is actually embedded in your
-application, which means you can expose almost all your application logic
-through the Handler type, which you can also initialize appropriately.
-
-API Documentation
-~~~~~~~~~~~~~~~~~
-
-The following sections assume that the following file has been included:
-
-.. code-block:: c++
-
-    #include <boost/network/include/http/server.hpp>
-
-And that the following typedef's have been put in place:
-
-.. code-block:: c++
-
-    struct handler_type;
-    typedef boost::network::http::server<handler_type> http_server;
-
-    struct handler_type {
-        void operator()(http_server::request const & request,
-                        http_server::response & response) {
-            // do something here
-        }
-    };
-
-Constructor
-```````````
-
-``explicit http_server(options)``
-    Construct an HTTP Server instance, passing in a ``server_options<Tag,
-    Handler>`` object. The following table shows the supported options in
-    ``server_options<Tag, Handler>``.
-
-+-----------------------+------------------------------------------+--------------------------------------------------------------------------------------------------+
-| Parameter Name        | Type                                     | Description                                                                                      |
-+=======================+==========================================+==================================================================================================+
-| address               | string_type                              | The hostname or IP address from which the server should be bound to. This parameter is required. |
-+-----------------------+------------------------------------------+--------------------------------------------------------------------------------------------------+
-| port                  | string_type                              | The port to which the server should bind and listen to. This parameter is required.              |
-+-----------------------+------------------------------------------+--------------------------------------------------------------------------------------------------+
-| thread_pool           | ``shared_ptr<thread_pool>``              | A shared pointer to an instance of ``boost::network::utils::thread_pool`` -- this is the         |
-|                       |                                          | thread pool from where the handler is invoked. This parameter is only applicable and required    |
-|                       |                                          | for ``async_server`` instances.                                                                  |
-+-----------------------+------------------------------------------+--------------------------------------------------------------------------------------------------+
-| io_service            | ``shared_ptr<io_service>``               | An optional lvalue to an instance of ``boost::asio::io_service`` which allows the server to use  |
-|                       |                                          | an already-constructed ``boost::asio::io_service`` instance instead of instantiating one that it |
-|                       |                                          | manages.                                                                                         |
-+-----------------------+------------------------------------------+--------------------------------------------------------------------------------------------------+
-| reuse_address         | ``bool``                                 | A boolean that specifies whether to re-use the address and port on which the server will be      |
-|                       |                                          | bound to. This enables or disables the socket option for listener sockets. The default is        |
-|                       |                                          | ``false``.                                                                                       |
-+-----------------------+------------------------------------------+--------------------------------------------------------------------------------------------------+
-| report_aborted        | ``bool``                                 | A boolean that specifies whether the listening socket should report aborted connection attempts  |
-|                       |                                          | to the accept handler (an internal detail of cpp-netlib). This is put in place to allow for      |
-|                       |                                          | future-proofing the code in case an optional error handler function is supported in later        |
-|                       |                                          | releases of cpp-netlib. The default is ``false``.                                                |
-+-----------------------+------------------------------------------+--------------------------------------------------------------------------------------------------+
-| receive_buffer_size   | ``int``                                  | The size of the socket's receive buffer. The default is defined by Boost.Asio and is             |
-|                       |                                          | platform-dependent.                                                                              |
-+-----------------------+------------------------------------------+--------------------------------------------------------------------------------------------------+
-| send_buffer_size      | ``int``                                  | The size of the socket's send buffer. The default is defined by Boost.Asio and is                |
-|                       |                                          | platform-dependent.                                                                              |
-+-----------------------+------------------------------------------+--------------------------------------------------------------------------------------------------+
-| receive_low_watermark | ``int``                                  | The size of the socket's low watermark for its receive buffer. The default is defined by         |
-|                       |                                          | Boost.Asio and is platform-dependent.                                                            |
-+-----------------------+------------------------------------------+--------------------------------------------------------------------------------------------------+
-| send_buffer_size      | ``int``                                  | The size of the socket's send low watermark for its send buffer. The default is defined by       |
-|                       |                                          | Boost.Asio and is platform-dependent.                                                            |
-+-----------------------+------------------------------------------+--------------------------------------------------------------------------------------------------+
-| non_blocking_io       | ``bool``                                 | An optional bool to define whether the socket should use non-blocking I/O in case the platform   |
-|                       |                                          | supports it. The default is ``true``.                                                            |
-+-----------------------+------------------------------------------+--------------------------------------------------------------------------------------------------+
-| linger                | ``bool``                                 | An optional bool to determine whether the socket should linger in case there's still data to be  |
-|                       |                                          | sent out at the time of its closing. The default is ``true``.                                    |
-+-----------------------+------------------------------------------+--------------------------------------------------------------------------------------------------+
-| linger_timeout        | ``int``                                  | An optional int to define the timeout to wait for socket closes before it is set to linger.      |
-|                       |                                          | The default is ``0``.                                                                            |
-+-----------------------+------------------------------------------+--------------------------------------------------------------------------------------------------+
-| context               | ``shared_ptr<context>``                  | An optional shared pointer to an instance of ``boost::asio::ssl::context`` -- this contains the  |
-|                       |                                          | settings needed to support SSL. This parameter is only applicable for ``async_server`` instances.|
-+-----------------------+------------------------------------------+--------------------------------------------------------------------------------------------------+
-
-To use the above supported named parameters, you'll have code that looks like the following:
-
-.. code-block:: c++
-
-    using namespace boost::network::http; // parameters are in this namespace
-    handler handler_instance;
-    sync_server<handler>::options options(handler_instance);
-    options.address("0.0.0.0")
-           .port("80")
-           .io_service(boost::make_shared<boost::asio::io_service>())
-           .reuse_address(true);
-    sync_server<handler> instance(options);
-    instance.run();
-
-Public Members
-``````````````
-
-The following definitions assume that a properly constructed ``http_server``
-instance has been constructed in the following manner:
-
-.. code-block:: c++
-
-    handler_type handler;
-    http_server::options options(handler);
-    http_server server(options.address("127.0.0.1").port("8000"));
-
-``server.run()``
-    Run the HTTP Server event loop. This function can be run on multiple threads
-    following the example:
-
-.. code-block:: c++
-
-    boost::thread t1(boost::bind(&http_server::run, &server));
-    boost::thread t2(boost::bind(&http_server::run, &server));
-    server.run();
-    t1.join();
-    t2.join();
-
-``server.stop()``
-    Stop the HTTP Server acceptor and wait for all pending requests to finish.
-
-Response Object
-```````````````
-
-The response object has its own public member functions which can be very
-helpful in certain simple situations.
-
-``response = http_server::response::stock_reply(status, body)``
-    Code like the above should go inside the handler's ``operator()`` overload.
-    The body parameter is an ``std::string``. The status parameter is any of
-    the following values from the ``http_server::response`` enum
-    ``status_type``:
-
-.. code-block:: c++
-
-    enum status_type {
-        ok = 200,
-        created = 201,
-        accepted = 202,
-        no_content = 204,
-        multiple_choices = 300,
-        moved_permanently = 301,
-        moved_temporarily = 302,
-        not_modified = 304,
-        bad_request = 400,
-        unauthorized = 401,
-        forbidden = 403,
-        not_found = 404,
-        not_supported = 405,
-        not_acceptable = 406,
-        internal_server_error = 500,
-        not_implemented = 501,
-        bad_gateway = 502,
-        service_unavailable = 503
-    };
+---------------
 
-The response object also has the following publicly accessible member values
-which can be directly manipulated by the handler.
-
-+------------------+----------------------+------------------------------------+
-| Member Name      | Type                 | Description                        |
-+==================+======================+====================================+
-| status           | ``status_type``      | The HTTP status of the response.   |
-+------------------+----------------------+------------------------------------+
-| headers          | ``vector<header>``   | Vector of headers. [#]_            |
-+------------------+----------------------+------------------------------------+
-| content          | ``string_type`` [#]_ | The contents of the response.      |
-+------------------+----------------------+------------------------------------+
-
-.. [#] A header is a struct of type
-   ``response_header<http::tags::http_server>``. An instance always has the
-   members ``name`` and ``value`` both of which are of type ``string_type``.
-.. [#] ``string_type`` is
-   ``boost::network::string<http::tags::http_server>::type``.
-
-Asynchronous Servers
---------------------
-
-The asynchronous server implementation is significantly different to the
-synchronous server implementation in three ways:
-
-  #. **The Handler instance is invoked asynchronously**. This means the I/O
-     thread used to handle network-related events are free to handle only the
-     I/O related events. This enables the server to scale better as to the
-     number of concurrent connections it can handle.
-  #. **The Handler is able to schedule asynchronous actions on the thread pool
-     associated with the server.** This allows handlers to perform multiple
-     asynchronous computations that later on perform writes to the connection.
-  #. **The Handler is able to control the (asynchronous) writes to and reads from
-     the HTTP connection.** Because the connection is available to the Handler,
-     that means it can write out chunks of data at a time or stream data through
-     the connection continuously.
-
-The asynchronous server is meant to allow for better scalability in terms of the
-number of concurrent connections and for performing asynchronous actions within
-the handlers. If your application does not need to write out information
-asynchronously or perform potentially long computations, then the synchronous
-server gives a generally better performance profile than the asynchronous
-server.
-
-The asynchronous server implementation is available from a single user-facing
-template named ``async_server``. This template takes in a single template
+The HTTP Server is meant to allow for better scalability in terms of the number
+of concurrent connections and for performing asynchronous actions within the
+handlers.  The HTTP Server implementation is available from a single
+user-facing template named ``server``. This template takes in a single template
 parameter which is the type of the Handler to be called once a request has been
 parsed from a connection.
 
-An instance of Handler is taken as a reference to the constructor similar to the
-synchronous server implementation.
+An instance of Handler is taken as a reference to the constructor of the server
+instance.
 
-.. warning:: The asynchronous server implementation, like the synchronous server
-   implementation, does not perform any synchronization on the calls to the
-   Handler invocation. This means if your handler contains or maintains internal
-   state, you are responsible for implementing your own synchronization on
-   accesses to the internal state of the Handler.
+.. warning:: The HTTP Server implementation does not perform any
+   synchronization on the calls to the Handler invocation. This means if your
+   handler contains or maintains internal state, you are responsible for
+   implementing your own synchronization on accesses to the internal state of
+   the Handler.
 
-The general pattern for using the ``async_server`` template is shown below:
+The general pattern for using the ``server`` template is shown below:
 
 .. code-block:: c++
 
     struct handler;
-    typedef boost::network::http::async_server<handler> http_server;
+    typedef boost::network::http::server<handler> http_server;
 
     struct handler {
         void operator()(
@@ -371,7 +90,7 @@ The general pattern for using the ``async_server`` template is shown below:
     };
 
 API Documentation
-~~~~~~~~~~~~~~~~~
+-----------------
 
 The following sections assume that the following file has been included:
 
@@ -395,135 +114,36 @@ And that the following typedef's have been put in place:
     };
 
 Constructor
-```````````
+~~~~~~~~~~~
 
 ``explicit http_server(options)``
     Construct an HTTP server instance passing in a ``server_options<Tag,
     Handler>`` instance.
 
-Public Members
-``````````````
-
-The following definitions assume that a properly constructed ``http_server``
-instance has been constructed in the following manner:
+Server Options
+~~~~~~~~~~~~~~
 
-.. code-block:: c++
-
-    handler_type handler;
-    http_server::options options(handler);
-    options.thread_pool(boost::make_shared<boost::network::utils::thread_pool>(2));
-    http_server server(options.address("127.0.0.1").port("8000"));
-
-``server.run()``
-    Run the HTTP Server event loop. This function can be run on multiple threads
-    following the example:
-
-.. code-block:: c++
+.. doxygenstruct:: boost::network::http::server_options
+   :project: cppnetlib
+   :members:
 
-    boost::thread t1(boost::bind(&http_server::run, &server));
-    boost::thread t2(boost::bind(&http_server::run, &server));
-    server.run();
-    t1.join();
-    t2.join();
+Public Members
+~~~~~~~~~~~~~~
 
-``server.stop()``
-    Stop the HTTP Server acceptor and wait for all pending requests to finish.
+.. doxygenstruct:: boost::network::http::server
+   :project: cppnetlib
+   :members:
+   :undoc-members:
 
 Connection Object
-`````````````````
-
-The connection object has its own public member functions which will be the
-primary means for reading from and writing to the connection.
-
-``template <class Range> write(Range range)``
-    The connection object exposes a function ``write`` that can be given a
-    parameter that adheres to the Boost.Range_ ``Single Pass Range`` Concept.
-    The write function, although it looks synchronous, starts of a series of
-    asynchronous writes to the connection as soon as the range is serialized to
-    appropriately sized buffers.
-
-    To use this in your handler, it would look something like this:
-
-.. code-block:: c++
-
-    connection->write("Hello, world!");
-    std::string sample = "I have a string!";
-    connection->write(sample);
-
-``template <class Range, class Callback> void write(Range range, Callback callback)``
-    The connection object also exposes a function ``write`` that can be given a
-    parameter that adheres to the Boost.Range_ ``Single Pass Range`` Concept, as
-    well as a Callback function that returns ``void`` and takes a
-    ``boost::system::error_code`` as a parameter. This overload of ``write`` is
-    useful for writing streaming applications that send out chunks of data at a
-    time, or for writing data that may not all fit in memory right away.
-
-``template <class ReadCallback> void read(ReadCallback callback)``
-    The connection object has a function ``read`` which can be used to read more
-    information from the connection. This ``read`` function takes in a callback
-    that can be assigned to a Boost.Function_ with the signature
-    ``void(input_range,error_code,size_t,connection_ptr)``. The following list
-    shows what the types actually mean:
-
-      * **input_range** -- ``boost::iterator_range<char const *>`` : The range
-        that denotes the data read from the connection.
-      * **error_code** -- ``boost::system::error_code`` : The error code if
-        there were any errors encountered from the read.
-      * **size_t** -- ``std::size_t`` : The number of bytes transferred.
-      * **connection_ptr** -- ``http_server::connection_ptr`` : A handle to the
-        current connection, so that it is kept alive at the time of the read
-        callback invocation.
-
-    This interface is useful when doing reads of uploaded data that can be
-    potentially large and may not fit in memory. The read handler is then
-    responsible for dealing with the chunks of data available from the
-    connection.
-
-``void set_status(status_t new_status)``
-    The ``set_status`` function takes a parameter of type ``status_t`` which is
-    an enum type nested in ``http_status::connection`` which is given in the
-    following code listing.
-
-.. code-block:: c++
-
-    enum status_t {
-        ok = 200
-        , created = 201
-        , accepted = 202
-        , no_content = 204
-        , multiple_choices = 300
-        , moved_permanently = 301
-        , moved_temporarily = 302
-        , not_modified = 304
-        , bad_request = 400
-        , unauthorized = 401
-        , forbidden = 403
-        , not_found = 404
-        , not_supported = 405
-        , not_acceptable = 406
-        , internal_server_error = 500
-        , not_implemented = 501
-        , bad_gateway = 502
-        , service_unavailable = 503
-    };
-
-.. note:: You may set and re-set the status several times as long as you have
-   not set the headers or sent data through the connection. If you do this after
-   data has already been set, the function will throw an instance of
-   ``std::logic_error``.
-
-``template <class Range> void set_headers(Range range)``
-    The ``set_headers`` function takes a Single Pass Range of
-    ``boost::network::http::response_header<http::tags::http_async_server>``
-    instances and linearizes them to a buffer with at most
-    ``BOOST_NETWORK_HTTP_SERVER_CONNECTION_HEADER_BUFFER_MAX_SIZE`` and
-    immediately schedules an asynchronous write once that is done.
+~~~~~~~~~~~~~~~~~
 
-    The function throws an instance of ``std::logic_error`` if you try to set
-    the headers for a connection more than once.
+.. doxygenstruct:: boost::network::http::async_connection
+   :project: cppnetlib
+   :members:
 
-Adding SSL support to Asynchronous Server
------------------------------------------
+Adding SSL support to the HTTP Server
+-------------------------------------
 
 In order to setup SSL support for an Asynchronous Server, it is best to start from
 a regular Asynchronous Server (see above). Once this server is setup, SSL can be
@@ -533,24 +153,25 @@ used are defined in the link.
 .. code-block:: c++
 
     // Initialize SSL context
-    boost::shared_ptr<boost::asio::ssl::context> ctx = boost::make_shared<boost::asio::ssl::context>(boost::asio::ssl::context::sslv23);
+    std::shared_ptr<asio::ssl::context> ctx =
+        std::make_shared<asio::ssl::context>(asio::ssl::context::sslv23);
     ctx->set_options(
-                boost::asio::ssl::context::default_workarounds
-                | boost::asio::ssl::context::no_sslv2
-                | boost::asio::ssl::context::single_dh_use);
+                asio::ssl::context::default_workarounds
+                | asio::ssl::context::no_sslv3
+                | asio::ssl::context::single_dh_use);
     
     // Set keys
     ctx->set_password_callback(password_callback);
     ctx->use_certificate_chain_file("server.pem");
-    ctx->use_private_key_file("server.pem", boost::asio::ssl::context::pem);
+    ctx->use_private_key_file("server.pem", asio::ssl::context::pem);
     ctx->use_tmp_dh_file("dh512.pem");
     
     handler_type handler;
     http_server::options options(handler);
-    options.thread_pool(boost::make_shared<boost::network::utils::thread_pool>(2));
+    options.thread_pool(std::make_shared<boost::network::utils::thread_pool>(2));
     http_server server(options.address("127.0.0.1").port("8442").context(ctx));
 
-    std::string password_callback(std::size_t max_length, boost::asio::ssl::context_base::password_purpose purpose) {
+    std::string password_callback(std::size_t max_length, asio::ssl::context_base::password_purpose purpose) {
         return std::string("test");
     }
     
diff --git a/libs/network/doc/techniques.rst b/libs/network/doc/techniques.rst
deleted file mode 100644
index b52bf7e36..000000000
--- a/libs/network/doc/techniques.rst
+++ /dev/null
@@ -1,12 +0,0 @@
-Techniques
-==========
-
-The :mod:`cpp-netlib` uses several advanced techniques to achieve it's
-aims.  This chapter describes some of those techniques.
-
-.. toctree::
-   :maxdepth: 1
-
-   techniques/tag_metafunctions
-   techniques/directives
-   techniques/polymorphism
diff --git a/libs/network/doc/techniques/directives.rst b/libs/network/doc/techniques/directives.rst
deleted file mode 100644
index e40882d95..000000000
--- a/libs/network/doc/techniques/directives.rst
+++ /dev/null
@@ -1,92 +0,0 @@
-Directives
-==========
-
-The :mod:`cpp-netlib` uses a technique for allowing message-passing
-semantics in a chainable fashion in the form of directives. The basic
-concept for directives is, in a general sense, an encapsulated
-transformation that can be applied to objects that abide by the
-directive protocol.
-
-Using the object-oriented notion of message passing, where an object
-accepts a message (usually a function call) we define a simple DSEL in
-order for the protocol to be supported by certain object types. In the
-:mod:`cpp-netlib` the protocol implemented is similar to that of the
-standard iostream formatting system:
-
-.. code-block:: c++
-
-    object << directive1(...)
-           << directive2(...)
-           ...
-           << directiveN(...);
-
-In :mod:`cpp-netlib` the directives are simple function objects that
-take a target object as reference and returns a reference to the same
-object as a result. In code the directive pattern looks like the
-following:
-
-.. code-block:: c++
-
-    struct directive_type {
-        template <class Input>
-        Input & operator()(Input & input) const {
-            // do something to input
-            return input;
-        }
-    };
-
-To simplify directive creation, usually factory or generator functions
-are defined to return concrete objects of the directive's type.
-
-.. code-block:: c++
-
-    inline
-    directive_type directive(...) {
-        return directive_type();
-    }
-
-The trivial implementation of the directive protocol then boils down
-to the specialization of the shift-left operator on the target type.
-
-.. code-block:: c++
-
-    template <class Directive>
-    inline target_type & operator<< 
-    (target_type & x, Directive const & f) {
-        return f(x);
-    }
-
-.. todo::
-
-    An example using a directive.
-
-The rationale for implementing directives include the following:
-
-  * **Encapsulation** - by moving logic into the directive types the
-    target object's interface can remain rudimentary and even hidden
-    to the user's immediate attention. Adding this layer of
-    indirection also allows for changing the underlying
-    implementations while maintaining the same syntactic and semantic
-    properties.
-  * **Flexibility** - by allowing the creation of directives that are
-    independent from the target object's type, generic operations can
-    be applied based on the concept being modeled by the target
-    type. The flexibility also afforded comes in the directive's
-    generator function, which can also generate different concrete
-    directive specializations based on parameters to the function.
-  * **Extensibility** - because the directives are independent of the
-    target object's type, new directives can be added and supported
-    without having to change the target object at all.
-  * **Reuse** - truly generic directives can then be used for a broad
-    set of target object types that model the same concepts supported
-    by the directive.  Because the directives are self-contained
-    objects, the state and other object references it keeps are only
-    accessible to it and can be re-used in different contexts as well.
-
-Extending a system that uses directives is trivial in header-only
-systems because new directives are simply additive. The protocol is
-simple and can be applied to a broad class of situations.
-
-In a header-only library, the static nature of the wiring and chaining
-of the operations lends itself to compiler abuse. A deep enough
-nesting of the directives can lead to prolonged compilation times.
diff --git a/libs/network/doc/techniques/polymorphism.rst b/libs/network/doc/techniques/polymorphism.rst
deleted file mode 100644
index d5e42f8c9..000000000
--- a/libs/network/doc/techniques/polymorphism.rst
+++ /dev/null
@@ -1,92 +0,0 @@
-Static and dynamic polymorphism
-===============================
-
-
-With a header only library, you can only do so much with static
-polymorphism alone. There are some situations where you have to handle
-dynamic polymorphism because of unavoidable runtime-based decision
-making. Although you can deal with the base types that remain static,
-behavior can vary greatly which derived type should be handling the
-situation based on runtime values.
-
-This situation comes up in the :mod:`cpp-netlib` when we decide what
-kind of connection handler to use for a given HTTP URI -- whether it's
-plain HTTP or HTTPS.  Although the HTTP semantics are the same for
-HTTP and HTTPS the implementation of the connection handler greatly
-varies on whether to use a plain TCP connection or an SSL-wrapped TCP
-connection.
-
-The general pattern or technique is to combine tag-based dispatch with
-a strategy factory, all while not requiring any externally built
-libraries. Doing it in a header-only library requires a little
-creativity and additional layers of indirection that you otherwise
-will not need for a library with externally built static/dynamic
-libraries.
-
-First we define the base type which we want to support dynamic
-behavior with.  There's nothing special with the base type, except
-that it supports the tag dispatch earlier defined and has a virtual
-destructor. In code it looks like this:
-
-.. code-block:: c++
-
-    template <class Tag>
-    struct base {
-        virtual void foo() = 0; // make this an abstract base
-        virtual ~base() {
-            // do the base destructor thing here.
-        }
-    };
-
-We then define a set of derived types that specialize the
-implementation of the ``foo`` member function. To facilitate the
-dispatch of the correct type based on an input, we create a strategy
-factory function:
-
-.. code-block:: c++
-
-    template <class Tag>
-    unique_ptr<base<Tag> > strategy(int input, Tag) {
-        unique_ptr<base<Tag> > ptr;
-        switch(input) {
-            case 0: ptr.reset(new derived0()); break;
-            case 1: ptr.reset(new derived1()); break;
-            // ...
-            default: ptr.reset(0); break;
-        }
-        return ptr;
-    }
-
-    unique_ptr<base<default_> > ptr =
-        strategy(input, default_()); // input is a runtime value
-
-The strategy factory can be a standalone function, or a static member
-of a factory class that is specialized by tag dispatch. This can be
-done like the following:
-
-.. code-block:: c++
-
-    template <class Tag>
-    struct strategy;
-
-    template <>
-    struct strategy<default_> {
-        static unique_ptr<base<default_> > create(int input) {
-            unique_ptr<base<default_> > ptr;
-            switch(input) {
-                case 0: ptr.reset(new derived0()); break;
-                case 1: ptr.reset(new derived1()); break;
-                //...
-                default: ptr.reset(0); break;
-            }
-            return ptr;
-        }
-    };
-
-This approach allows the header-only libraries to define new dynamic
-types in subsequent versions of the library while keeping the
-static-dynamic bridge fluid. The only down-side to this is the
-possibility of derived type explosion in case there are a lot of
-different strategies or specializations available -- this though is
-not unique to static-dynamic bridging, but is also a problem with pure
-object oriented programming with dynamic polymorphism.
diff --git a/libs/network/doc/techniques/tag_metafunctions.rst b/libs/network/doc/techniques/tag_metafunctions.rst
deleted file mode 100644
index 68edd1449..000000000
--- a/libs/network/doc/techniques/tag_metafunctions.rst
+++ /dev/null
@@ -1,172 +0,0 @@
-Tag metafunctions
-=================
-
-Sometimes you want to vary a function or a type's behavior based on a
-static parameter. In the :mod:`cpp-netlib` there are a number of
-things you might want to change based on some such parameter -- like
-what the underlying string type should be and how large a buffer
-should be, among other things. The primary way to define this in a
-header-only manner is to use tag-based metafunctions.
-
-The skeleton of the approach is based on a similar technique for
-defining type traits. In the :mod:`cpp-netlib` however the type traits
-are defined on opaque tag types which serve to associate results to a
-family of metafunctions.
-
-Template Specialization
------------------------
-
-To illustrate this point, let's define a tag ``default_`` which we use
-to denote the default implementation of a certain type ``foo``. For
-instance we decide that the default string type we will use for
-``default_`` tagged ``foo`` specializations will be an
-``std::string``.
-
-In the :mod:`cpp-netlib` this is done by defining a ``string``
-metafunction type that is specialized on the tag ``default_`` whose
-nested ``type`` result is the type ``std::string``. In code this would
-translate to:
-
-.. code-block:: c++
-
-    template <class Tag>
-    struct string {
-        typedef void type;
-    };
-
-    struct default_;
-
-    template <>
-    struct string<default_> {
-        typedef std::string type;
-    };
-
-Template Metaprogramming
-------------------------
-
-Starting with version 0.7, the tag dispatch mechanism changed slightly to use
-Boost.MPL_. The idea is still the same, although we can get a little smarter
-than just using template specializations. Instead of just defining an opaque
-type ``default_``, we use the Boost.MPL equivalent of a vector to define which
-root types of properties this ``default_`` tag supports. The idea is to make the
-opaque type ``default_`` inherit property tags which the library supports
-internally as definite extension points.
-
-.. _Boost.MPL: http://www.boost.org/libs/mpl/index.html
-
-Our definition of the ``default_`` tag will then look something like the
-following:
-
-.. code-block:: c++
-
-    typedef mpl::vector<default_string> default_tags;
-
-    template <class Tag>
-    struct components;
-
-    typedef mpl::inherit_linearly<
-        default_tags,
-        mpl::inherit<mpl::placeholders::_1, mpl::placeholders::_2>
-        >::type default_;
-
-    template <class Tag>
-    struct components<default_> {
-        typedef default_tags type;
-    };
-
-In the above listing, ``default_string`` is what we call a "root" tag which is
-meant to be combined with other "root" tags to form composite tags. In this case
-our composite tag is the tag ``default_``. There are a number of these "root"
-tags that :mod:`cpp-netlib` provides. These are in the namespace
-``boost::network::tags`` and are defined in ``boost/network/tags.hpp``.
-
-Using this technique we change slightly our definition of the ``string``
-metafunction class into this:
-
-.. code-block:: c++
-
-    template <class Tag>
-    struct unsupported_tag;
-
-    template <class Tag>
-    struct string :
-        mpl::if_<
-            is_base_of<
-                tags::default_string,
-                Tag
-            >,
-            std::string,
-            unsupported_tag<Tag>
-        >
-    {};
-
-Notice that we don't have the typedef for ``type`` in the body of ``string``
-anymore, but we do inherit from ``mpl::if_``. Since ``mpl::if_`` is a template
-metafunction itself, it contains a definition of the resulting ``type`` which
-``string`` inherits.
-
-You can see the real definition of the ``string`` metafunction in
-``boost/network/traits/string.hpp``.
-
-Using Tags
-----------
-
-Once we have the defined tag, we can then use this in the definition of our
-types. In the definition of the type ``foo`` we use this type function
-``string`` and pass the tag type parameter to determine what to use as
-the string type in the context of the type ``foo``. In code this would
-translate into:
-
-.. code-block:: c++
-
-    template <class Tag>
-    struct foo {
-        typedef typename string<Tag>::type string_type;
-
-        // .. use string_type where you need a string.
-    };
-
-Using this approach we can support different types of strings for
-different tags on the type ``foo``. In case we want to use a different
-type of string for the tag ``default_`` we only change the
-composition of the ``string_tags`` MPL vector. For example, in :mod:`cpp-netlib`
-there is a root tag ``default_wstring`` which causes the ``string`` metafunction 
-to define ``std::wstring`` as the resulting type.
-
-The approach also allows for the control of the structure and features
-of types like ``foo`` based on the specialization of the tag. Whole
-type function families can be defined on tags where they are supported
-and ignored in cases where they are not.
-
-To illustrate let's define a new tag ``swappable``. Given the above
-definition of ``foo``, we want to make the ``swappable``-tagged
-``foo`` define a ``swap`` function that extends the original
-``default_``-tagged ``foo``. In code this would look like:
-
-.. code-block:: c++
-
-    struct swappable;
-
-    template <>
-    struct foo<swappable> : foo<default_> {
-        void swap(foo<swappable> & other) {
-            // ...
-        }
-    };
-
-We also for example want to enable an ADL-reachable ``swap`` function:
-
-.. code-block:: c++
-
-    struct swappable;
-
-    inline
-    void swap(foo<swappable> & left, foo<swappable> & right) {
-        left.swap(right);
-    }
-
-Overall what the tag-based definition approach allows is for static
-definition of extension points that ensures type-safety and
-invariants. This keeps the whole extension mechanism static and yet
-flexible.
-