Continuation of std'ification.

I've run into some issues with Boost.Test ToT with Apple's Clang
compiler (4.5). It seems that the way Boost.Test is using preprocessor
programming is undesirable to Clang.

Author: deanberris

include/network/protocol/http/client.hpp

@@ -10,7 +10,7 @@
 #include <network/version.hpp>
 #include <network/protocol/http/client/options.hpp>
 
-#include <asio/io_service.hpp>
+#include <boost/asio/io_service.hpp>
 #include <network/protocol/http/client/facade.hpp>
 #include <network/protocol/http/client/macros.hpp>
 #include <network/protocol/http/request.hpp>

include/network/protocol/http/client/base.hpp

@@ -23,7 +23,7 @@ class client_options;
 
 struct client_base {
   typedef
-    std::function<void(boost::iterator_range<char const *> const &, asio::error_code const &)>
+    std::function<void(boost::iterator_range<char const *> const &, boost::system::error_code const &)>
     body_callback_function_type;
 
   client_base();

include/network/protocol/http/client/base.ipp

@@ -11,8 +11,8 @@
 #include <functional>
 #include <network/protocol/http/client/base.hpp>
 #include <network/protocol/http/client/options.hpp>
-#include <asio/io_service.hpp>
-#include <asio/strand.hpp>
+#include <boost/asio/io_service.hpp>
+#include <boost/asio/strand.hpp>
 #include <network/protocol/http/client/connection_manager.hpp>
 #include <network/protocol/http/client/simple_connection_manager.hpp>
 #include <network/protocol/http/request.hpp>
@@ -22,7 +22,7 @@ namespace network { namespace http {
 
 struct client_base_pimpl {
   typedef
-    std::function<void(boost::iterator_range<char const *> const &, asio::error_code const &)>
+    std::function<void(boost::iterator_range<char const *> const &, boost::system::error_code const &)>
     body_callback_function_type;
   client_base_pimpl(client_options const &options);
   response const request_skeleton(request const & request_,
@@ -34,20 +34,20 @@ struct client_base_pimpl {
   ~client_base_pimpl();
  private:
   client_options options_;
-  asio::io_service * service_ptr;
-  boost::shared_ptr<asio::io_service::work> sentinel_;
-  boost::shared_ptr<std::thread> lifetime_thread_;
-  boost::shared_ptr<connection_manager> connection_manager_;
+  boost::asio::io_service * service_ptr;
+  std::shared_ptr<boost::asio::io_service::work> sentinel_;
+  std::shared_ptr<std::thread> lifetime_thread_;
+  std::shared_ptr<connection_manager> connection_manager_;
   bool owned_service_;
 };
 
 client_base::client_base()
-: pimpl(new (std::nothrow) client_base_pimpl(client_options())) {
+: pimpl(new  client_base_pimpl(client_options())) {
   NETWORK_MESSAGE("client_base::client_base()");
 }
 
 client_base::client_base(client_options const &options)
-: pimpl(new (std::nothrow) client_base_pimpl(options)) {
+: pimpl(new  client_base_pimpl(options)) {
   NETWORK_MESSAGE("client_base::client_base(client_options const &)");
 }
 
@@ -78,17 +78,17 @@ client_base_pimpl::client_base_pimpl(client_options const &options)
   NETWORK_MESSAGE("client_base_pimpl::client_base_pimpl(client_options const &)");
   if (service_ptr == 0) {
     NETWORK_MESSAGE("creating owned io_service.");
-    service_ptr = new(std::nothrow) asio::io_service;
+    service_ptr = new boost::asio::io_service;
     owned_service_ = true;
   }
   if (!connection_manager_.get()) {
     NETWORK_MESSAGE("creating owned simple_connection_manager");
     connection_manager_.reset(
-        new (std::nothrow) simple_connection_manager(options));
+        new  simple_connection_manager(options));
   }
-  sentinel_.reset(new (std::nothrow) asio::io_service::work(*service_ptr));
+  sentinel_.reset(new  boost::asio::io_service::work(*service_ptr));
   auto local_ptr = service_ptr;
-  lifetime_thread_.reset(new (std::nothrow) std::thread([local_ptr]() { local_ptr->run(); }));
+  lifetime_thread_.reset(new  std::thread([local_ptr]() { local_ptr->run(); }));
   if (!lifetime_thread_.get())
     BOOST_THROW_EXCEPTION(std::runtime_error("Cannot allocate client lifetime thread; not enough memory."));
 }
@@ -114,7 +114,7 @@ response const client_base_pimpl::request_skeleton(
   )
 {
   NETWORK_MESSAGE("client_base_pimpl::request_skeleton(...)");
-  boost::shared_ptr<client_connection> connection_;
+  std::shared_ptr<client_connection> connection_;
   connection_ = connection_manager_->get_connection(*service_ptr, request_, options_);
   return connection_->send_request(method, request_, get_body, callback, options);
 }

include/network/protocol/http/client/connection/async_normal.hpp

@@ -9,14 +9,14 @@
 #ifndef NETWORK_PROTOCOL_HTTP_IMPL_HTTP_ASYNC_CONNECTION_HPP_20100601
 #define NETWORK_PROTOCOL_HTTP_IMPL_HTTP_ASYNC_CONNECTION_HPP_20100601
 
-#include <boost/shared_ptr.hpp>
-#include <boost/scoped_ptr.hpp>
+#include <memory>
+#include <utility>
 #include <network/protocol/http/client/client_connection.hpp>
-#include <boost/enable_shared_from_this.hpp>
 
-namespace asio {
+namespace boost { namespace asio {
 class io_service;
 }  // namespace asio
+}  // namespace boost
 
 namespace network { namespace http {
 
@@ -28,11 +28,11 @@ struct connection_delegate;
 struct http_async_connection_pimpl;
 
 struct http_async_connection : client_connection
-                             , boost::enable_shared_from_this<http_async_connection> {
+                             , std::enable_shared_from_this<http_async_connection> {
   using client_connection::callback_type;
-  http_async_connection(boost::shared_ptr<resolver_delegate> resolver_delegate,
-                        boost::shared_ptr<connection_delegate> connection_delegate,
-                        asio::io_service & io_service,
+  http_async_connection(std::shared_ptr<resolver_delegate> resolver_delegate,
+                        std::shared_ptr<connection_delegate> connection_delegate,
+                        boost::asio::io_service & io_service,
                         bool follow_redirects);
   http_async_connection * clone() const;
   virtual response send_request(std::string const & method,
@@ -43,8 +43,8 @@ struct http_async_connection : client_connection
   virtual void reset();  // override
   virtual ~http_async_connection();
  private:
-  explicit http_async_connection(boost::shared_ptr<http_async_connection_pimpl>);
-  boost::shared_ptr<http_async_connection_pimpl> pimpl;
+  explicit http_async_connection(std::shared_ptr<http_async_connection_pimpl>);
+  std::shared_ptr<http_async_connection_pimpl> pimpl;
 };
 
 } // namespace http