Test for Less Copy Connection Write

This commit basically is a test for the case where the range passed to
the call to connection::write is actually a Boost.Asio const_buffer
derivative. This removes the requirement to make copies of the range
passed into the call to connection::write. This is a backward-compatible
change which means code that used to work with the range-based solution
will still be supported while Boost.Asio const_buffer derivatives passed
in will be supported as first-class elements that get used be the
implementation directly.

Note: Boost.Asio const_buffers explicitly do not own the memory that has
been wrapped to it. Care should be taken when passing in Boost.Asio
const_buffer sequences into the connection::write interface to make sure
that the data is still accessible until at least the provided callback
is provided.

Note: Backported from 0.9-devel into 0.8-devel.

Author: deanberris

boost/network/protocol/http/server/async_connection.hpp

@@ -666,10 +666,13 @@ namespace boost { namespace network { namespace http {
             if (error_encountered)
                 boost::throw_exception(boost::system::system_error(*error_encountered));
 
+            boost::function<void(boost::system::error_code)> callback_function =
+                    callback;
+
             boost::function<void()> continuation = boost::bind(
-                &async_connection<Tag,Handler>::write_vec_impl<ConstBufferSeq, Callback>
+                &async_connection<Tag,Handler>::write_vec_impl<ConstBufferSeq, boost::function<void(boost::system::error_code)> >
                 ,async_connection<Tag,Handler>::shared_from_this()
-                ,seq, callback, temporaries, buffers
+                ,seq, callback_function, temporaries, buffers
             );
 
             if (!headers_already_sent && !headers_in_progress) {
@@ -686,7 +689,7 @@ namespace boost { namespace network { namespace http {
                 ,boost::bind(
                     &async_connection<Tag,Handler>::handle_write
                     ,async_connection<Tag,Handler>::shared_from_this()
-                    ,callback
+                    ,callback_function
                     ,temporaries
                     ,buffers
                     ,asio::placeholders::error

libs/network/test/http_server_async_less_copy.cpp

@@ -0,0 +1,72 @@
+
+// Copyright 2010 Dean Michael Berris. 
+// 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)
+
+#define BOOST_TEST_MODULE HTTP Asynchronous Server Tests
+
+#include <boost/config/warning_disable.hpp>
+#include <boost/network/include/http/server.hpp>
+#include <boost/network/utils/thread_pool.hpp>
+#include <boost/range/algorithm/find_if.hpp>
+
+namespace net = boost::network;
+namespace http = boost::network::http;
+namespace utils = boost::network::utils;
+
+struct async_hello_world;
+typedef http::async_server<async_hello_world> server;
+
+struct async_hello_world {
+
+    struct is_content_length {
+        template <class Header>
+        bool operator()(Header const & header) {
+            return boost::iequals(name(header), "content-length");
+        }
+    };
+
+    void operator()(server::request const & request, server::connection_ptr connection) {
+        static server::response_header headers[] = {
+            {"Connection", "close"}
+            , {"Content-Type", "text/plain"}
+            , {"Server", "cpp-netlib/0.9-devel"}
+        };
+        if (request.method == "HEAD") {
+            connection->set_status(server::connection::ok);
+            connection->set_headers(boost::make_iterator_range(headers, headers+3));
+        } else {
+            if (request.method == "PUT" || request.method == "POST") {
+                static std::string bad_request("Bad Request.");
+                server::request::headers_container_type::iterator found =
+                    boost::find_if(request.headers, is_content_length());
+                if (found == request.headers.end()) {
+                    connection->set_status(server::connection::bad_request);
+                    connection->set_headers(boost::make_iterator_range(headers, headers+3));
+                    connection->write(bad_request);
+                    return;
+                }
+            }
+            static char const * hello_world = "Hello, World!";
+            connection->set_status(server::connection::ok);
+            connection->set_headers(boost::make_iterator_range(headers, headers+3));
+            connection->write(
+                    boost::asio::const_buffers_1(hello_world, 13)
+                    , boost::bind(&async_hello_world::error, this, _1));
+        }
+    }
+
+    void error(boost::system::error_code const & ec) {
+        // do nothing here.
+    }
+};
+
+int main(int argc, char * argv[]) {
+    utils::thread_pool thread_pool(2); 
+    async_hello_world handler;
+    server instance("127.0.0.1", "8000", handler, thread_pool, http::_reuse_address=true);
+    instance.run();
+    return 0;
+}
+