Updated server and connection so that they don't use the using directives at namespace scope.

glynos · glynos · commit 19d697386c26 · 2010-03-17T20:16:08.000+01:00
diff --git a/boost/network/protocol/http/connection.hpp b/boost/network/protocol/http/connection.hpp
@@ -30,29 +30,18 @@
 
 namespace boost { namespace network { namespace http {
 
-    using boost::asio::io_service;
-    namespace system = boost::system;
-    using boost::asio::ip::tcp;
-    using boost::array;
-    using boost::tribool;
-    using boost::tuple;
-    namespace tuples = boost::tuples;
-    using boost::tuples::tie;
-    using boost::bind;
-    using boost::to_lower_copy;
-
     template <class Tag, class Handler>
     struct connection : boost::enable_shared_from_this<connection<Tag,Handler> > {
 
-        connection(io_service & service, Handler & handler)
+        connection(boost::asio::io_service & service, Handler & handler)
         : service_(service)
         , handler_(handler)
         , socket_(service_)
         , wrapper_(service_)
         {
         }
 
-        tcp::socket & socket() {
+        boost::asio::ip::tcp::socket & socket() {
             return socket_;
         }
 
@@ -62,13 +51,14 @@ namespace boost { namespace network { namespace http {
             // and then pass that request object to the
             // handler_ instance.
             //
+            using boost::asio::ip::tcp;
             boost::system::error_code option_error;
             socket_.set_option(tcp::no_delay(true), option_error);
-            if (option_error) handler_.log(system::system_error(option_error).what());
+            if (option_error) handler_.log(boost::system::system_error(option_error).what());
             socket_.async_read_some(
                 boost::asio::buffer(buffer_),
                 wrapper_.wrap(
-                    bind(
+                    boost::bind(
                         &connection<Tag,Handler>::handle_read_headers,
                         connection<Tag,Handler>::shared_from_this(),
                         boost::asio::placeholders::error,
@@ -83,14 +73,14 @@ namespace boost { namespace network { namespace http {
         struct is_content_length {
             template <class Header>
             bool operator()(Header const & header) {
-                return to_lower_copy(header.name) == "content-length";
+                return boost::to_lower_copy(header.name) == "content-length";
             }
         };
 
-        void handle_read_headers(system::error_code const &ec, size_t bytes_transferred) {
+        void handle_read_headers(boost::system::error_code const &ec, size_t bytes_transferred) {
             if (!ec) {
-                tribool done;
-                array<char, BOOST_HTTP_SERVER_BUFFER_SIZE>::iterator new_start;
+                boost::tribool done;
+                boost::array<char, BOOST_HTTP_SERVER_BUFFER_SIZE>::iterator new_start;
                 tie(done,new_start) = parser_.parse_headers(request_, buffer_.data(), buffer_.data() + bytes_transferred);
                 if (done) {
                     if (request_.method[0] == 'P') {
@@ -107,7 +97,7 @@ namespace boost { namespace network { namespace http {
                                 socket_,
                                 response_.to_buffers(),
                                 wrapper_.wrap(
-                                    bind(
+                                    boost::bind(
                                         &connection<Tag,Handler>::handle_write,
                                         connection<Tag,Handler>::shared_from_this(),
                                         boost::asio::placeholders::error
@@ -127,7 +117,7 @@ namespace boost { namespace network { namespace http {
                                 socket_,
                                 response_.to_buffers(),
                                 wrapper_.wrap(
-                                    bind(
+                                    boost::bind(
                                         &connection<Tag,Handler>::handle_write,
                                         connection<Tag,Handler>::shared_from_this(),
                                         boost::asio::placeholders::error
@@ -146,7 +136,7 @@ namespace boost { namespace network { namespace http {
                                 socket_.async_read_some(
                                     boost::asio::buffer(buffer_),
                                     wrapper_.wrap(
-                                        bind(
+                                        boost::bind(
                                             &connection<Tag,Handler>::handle_read_body_contents,
                                             connection<Tag,Handler>::shared_from_this(),
                                             boost::asio::placeholders::error,
@@ -164,7 +154,7 @@ namespace boost { namespace network { namespace http {
                             socket_,
                             response_.to_buffers(),
                             wrapper_.wrap(
-                                bind(
+                                boost::bind(
                                     &connection<Tag,Handler>::handle_write,
                                     connection<Tag,Handler>::shared_from_this(),
                                     boost::asio::placeholders::error
@@ -177,7 +167,7 @@ namespace boost { namespace network { namespace http {
                             socket_,
                             response_.to_buffers(),
                             wrapper_.wrap(
-                                bind(
+                                boost::bind(
                                     &connection<Tag,Handler>::handle_write,
                                     connection<Tag,Handler>::shared_from_this(),
                                     boost::asio::placeholders::error
@@ -191,7 +181,7 @@ namespace boost { namespace network { namespace http {
                         socket_,
                         response_.to_buffers(),
                         wrapper_.wrap(
-                            bind(
+                            boost::bind(
                                 &connection<Tag,Handler>::handle_write,
                                 connection<Tag,Handler>::shared_from_this(),
                                 boost::asio::placeholders::error
@@ -202,7 +192,7 @@ namespace boost { namespace network { namespace http {
                     socket_.async_read_some(
                         boost::asio::buffer(buffer_),
                         wrapper_.wrap(
-                            bind(
+                            boost::bind(
                                 &connection<Tag,Handler>::handle_read_headers,
                                 connection<Tag,Handler>::shared_from_this(),
                                 boost::asio::placeholders::error,
@@ -218,7 +208,7 @@ namespace boost { namespace network { namespace http {
         void handle_read_body_contents(boost::system::error_code const & ec, size_t bytes_to_read, size_t bytes_transferred) {
             if (!ec) {
                 size_t difference = bytes_to_read - bytes_transferred;
-                array<char,BOOST_HTTP_SERVER_BUFFER_SIZE>::iterator start = buffer_.begin(),
+                boost::array<char,BOOST_HTTP_SERVER_BUFFER_SIZE>::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);
@@ -228,7 +218,7 @@ namespace boost { namespace network { namespace http {
                         socket_,
                         response_.to_buffers(),
                         wrapper_.wrap(
-                            bind(
+                            boost::bind(
                                 &connection<Tag,Handler>::handle_write,
                                 connection<Tag,Handler>::shared_from_this(),
                                 boost::asio::placeholders::error
@@ -239,7 +229,7 @@ namespace boost { namespace network { namespace http {
                     socket_.async_read_some(
                         boost::asio::buffer(buffer_),
                         wrapper_.wrap(
-                            bind(
+                            boost::bind(
                                 &connection<Tag,Handler>::handle_read_body_contents,
                                 connection<Tag,Handler>::shared_from_this(),
                                 boost::asio::placeholders::error,
@@ -255,17 +245,18 @@ namespace boost { namespace network { namespace http {
 
         void handle_write(boost::system::error_code const & ec) {
             if (!ec) {
+                using boost::asio::ip::tcp;
                 boost::system::error_code ignored_ec;
                 socket_.shutdown(tcp::socket::shutdown_both, ignored_ec);
                 socket_.close(ignored_ec);
             }
         }
 
-        io_service & service_;
+        boost::asio::io_service & service_;
         Handler & handler_;
-        tcp::socket socket_;
-        io_service::strand wrapper_;
-        array<char,BOOST_HTTP_SERVER_BUFFER_SIZE> buffer_;
+        boost::asio::ip::tcp::socket socket_;
+        boost::asio::io_service::strand wrapper_;
+        boost::array<char,BOOST_HTTP_SERVER_BUFFER_SIZE> buffer_;
         request_parser parser_;
         basic_request<Tag> request_;
         basic_response<Tag> response_;
diff --git a/boost/network/protocol/http/server.hpp b/boost/network/protocol/http/server.hpp
@@ -1,5 +1,6 @@
 // Copyright 2009 (c) Tarro, Inc.
 // Copyright 2009 (c) Dean Michael Berris <mikhailberis@gmail.com>
+// Copyright 2010 (c) Glyn Matthews
 // Copyright 2003-2008 (c) Chris Kholhoff
 // Distributed under the Boost Software License, Version 1.0.
 // (See accompanying file LICENSE_1_0.txt or copy at
@@ -11,28 +12,27 @@
 
 #include <boost/shared_ptr.hpp>
 #include <boost/bind.hpp>
-#include <string>
 #include <boost/asio/ip/tcp.hpp>
 #include <boost/network/protocol/http/connection.hpp>
+#include <boost/network/traits/string.hpp>
 
 namespace boost { namespace network { namespace http {
 
-    using boost::shared_ptr;
-    using std::string;
-    using boost::asio::ip::tcp;
-    using boost::bind;
-
     template <class Tag, class Handler>
     struct basic_server {
+        typedef typename string<Tag>::type string_type;
         typedef basic_request<Tag> request;
         typedef basic_response<Tag> response;
 
-        basic_server(string const & address, string const & port, Handler & handler)
+        basic_server(string_type const & address,
+                     string_type const & port,
+                     Handler & handler)
         : handler_(handler)
         , service_()
         , acceptor_(service_)
         , new_connection(new connection<Tag,Handler>(service_, handler))
         {
+            using boost::asio::ip::tcp;
             tcp::resolver resolver(service_);
             tcp::resolver::query query(address, port);
             tcp::endpoint endpoint = *resolver.resolve(query);
@@ -41,7 +41,8 @@ namespace boost { namespace network { namespace http {
             acceptor_.bind(endpoint);
             acceptor_.listen();
             acceptor_.async_accept(new_connection->socket(),
-                bind(&basic_server<Tag,Handler>::handle_accept, this, boost::asio::placeholders::error));
+                boost::bind(&basic_server<Tag,Handler>::handle_accept,
+                            this, boost::asio::placeholders::error));
         }
 
         void run() {
@@ -56,27 +57,30 @@ namespace boost { namespace network { namespace http {
         private:
 
         Handler & handler_;
-        io_service service_;
-        tcp::acceptor acceptor_;
-        shared_ptr<connection<Tag,Handler> > new_connection;
+        boost::asio::io_service service_;
+        boost::asio::ip::tcp::acceptor acceptor_;
+        boost::shared_ptr<connection<Tag,Handler> > new_connection;
 
         void handle_accept(boost::system::error_code const & ec) {
             if (!ec) {
                 new_connection->start();
                 new_connection.reset(new connection<Tag,Handler>(service_, handler_));
                 acceptor_.async_accept(new_connection->socket(),
-                    bind(&basic_server<Tag,Handler>::handle_accept, this, boost::asio::placeholders::error));
+                    boost::bind(&basic_server<Tag,Handler>::handle_accept,
+                                this, boost::asio::placeholders::error));
             }
         }
     };
 
     template <class Handler>
     struct server : basic_server<tags::http_server, Handler> {
-        server(string const & address, string const & port, Handler & handler)
-        : basic_server<tags::http_server,Handler>(address, port, handler) {}
+        typedef basic_server<tags::http_server, Handler> server_base;
 
-        typedef typename basic_server<tags::http_server,Handler>::request request;
-        typedef typename basic_server<tags::http_server,Handler>::response response;
+        server(typename server_base::string_type const & address,
+               typename server_base::string_type const & port,
+               Handler & handler)
+            : server_base(address, port, handler) {}
+        
     };
 
 } // namespace http
diff --git a/libs/network/example/uri.cpp b/libs/network/example/uri.cpp
@@ -7,34 +7,34 @@
 
 //[ uri_main
 /*`
-  
+  This is a simple program that validates a URI.
  */
 #include <boost/network/uri.hpp>
+#include <boost/network/uri/http/uri.hpp>
 #include <string>
 #include <iostream>
 
-using namespace std;
-using namespace boost::network::uri;
-
 
 int main(int argc, char * argv[]) {
-    string input;
-    cout << "Please enter a URI to parse: ";
-    cin >> input;
-
-    /*<< Create >>*/
-    uri uri_(input);
-    /*<< Create >>*/
-    cout << "You've entered " 
-        << (valid(uri_)? string("a valid") : string("an invalid"))
-        << " URI!" << endl;
-
-    /*<< Create >>*/
-    http::uri http_uri_(input);
-    /*<< Create >>*/
-    cout << "It's also "
-        << (valid(http_uri_)? string("a valid HTTP URI") : string("an invalid HTTP URI."))
-        << "!" << endl;
+    std::string input;
+    std::cout << "Please enter a URI to parse: ";
+    std::cin >> input;
+
+    /*<< Create a `boost::network::uri::uri` object from the input.  >>*/
+    boost::network::uri::uri uri_(input);
+    /*<< Check if it's a valid URI. >>*/
+    std::cout << "You've entered " 
+              << (boost::network::uri::valid(uri_)?
+                  std::string("a valid") : std::string("an invalid"))
+              << " URI!" << std::endl;
+
+    /*<< Create a `boost::network::http::uri` object from the input. >>*/
+    boost::network::uri::http::uri http_uri_(input);
+    /*<< Check if it's a valid HTTP URI. >>*/
+    std::cout << "It's also "
+              << (boost::network::uri::valid(http_uri_)?
+                  std::string("a valid HTTP URI") : std::string("an invalid HTTP URI."))
+              << "!" << std::endl;
 
     return EXIT_SUCCESS;
 }
