From 7a7956b7004d5a388a1de91a44f19544267079f3 Mon Sep 17 00:00:00 2001 From: eidheim Date: Mon, 14 Jul 2014 13:27:06 +0200 Subject: [PATCH] removed 'using namespace' from .hpp-files --- server_http.hpp | 74 ++++++++++++++++++++++++------------------------ server_https.hpp | 14 ++++----- 2 files changed, 44 insertions(+), 44 deletions(-) diff --git a/server_http.hpp b/server_http.hpp index f340612..79dcbbb 100644 --- a/server_http.hpp +++ b/server_http.hpp @@ -7,19 +7,17 @@ #include #include -using namespace std; -using namespace boost::asio; - -namespace SimpleWeb { +namespace SimpleWeb { struct Request { - string method, path, http_version; + std::string method, path, http_version; - shared_ptr content; + std::shared_ptr content; - unordered_map header; + std::unordered_map header; }; - typedef map > > resource_type; + typedef std::map > > resource_type; template class ServerBase { @@ -28,7 +26,7 @@ namespace SimpleWeb { resource_type default_resource; - ServerBase(unsigned short port, size_t num_threads=1) : endpoint(ip::tcp::v4(), port), + ServerBase(unsigned short port, size_t num_threads=1) : endpoint(boost::asio::ip::tcp::v4(), port), acceptor(m_io_service, endpoint), num_threads(num_threads) {} void start() { @@ -54,31 +52,31 @@ namespace SimpleWeb { m_io_service.run(); //Wait for the rest of the threads, if any, to finish as well - for(thread& t: threads) { + for(auto& t: threads) { t.join(); } } protected: - io_service m_io_service; - ip::tcp::endpoint endpoint; - ip::tcp::acceptor acceptor; + boost::asio::io_service m_io_service; + boost::asio::ip::tcp::endpoint endpoint; + boost::asio::ip::tcp::acceptor acceptor; //shared_ptr context; size_t num_threads; - vector threads; + std::vector threads; //All resources with default_resource at the end of vector //Created in start() - vector all_resources; + std::vector all_resources; virtual void accept() {} - void process_request_and_respond(shared_ptr socket) { + void process_request_and_respond(std::shared_ptr socket) { //Create new read_buffer for async_read_until() //Shared_ptr is used to pass temporary objects to the asynchronous functions - shared_ptr read_buffer(new boost::asio::streambuf); + std::shared_ptr read_buffer(new boost::asio::streambuf); - async_read_until(*socket, *read_buffer, "\r\n\r\n", + boost::asio::async_read_until(*socket, *read_buffer, "\r\n\r\n", [this, socket, read_buffer](const boost::system::error_code& ec, size_t bytes_transferred) { if(!ec) { //read_buffer->size() is not necessarily the same as bytes_transferred, from Boost-docs: @@ -88,20 +86,21 @@ namespace SimpleWeb { size_t total=read_buffer->size(); //Convert to istream to extract string-lines - istream stream(read_buffer.get()); + std::istream stream(read_buffer.get()); - shared_ptr request(new Request()); + std::shared_ptr request(new Request()); *request=parse_request(stream); size_t num_additional_bytes=total-bytes_transferred; //If content, read that as well if(request->header.count("Content-Length")>0) { - async_read(*socket, *read_buffer, transfer_exactly(stoull(request->header["Content-Length"])-num_additional_bytes), + boost::asio::async_read(*socket, *read_buffer, + boost::asio::transfer_exactly(stoull(request->header["Content-Length"])-num_additional_bytes), [this, socket, read_buffer, request](const boost::system::error_code& ec, size_t bytes_transferred) { if(!ec) { //Store pointer to read_buffer as istream object - request->content=shared_ptr(new istream(read_buffer.get())); + request->content=std::shared_ptr(new std::istream(read_buffer.get())); respond(socket, request); } @@ -114,18 +113,18 @@ namespace SimpleWeb { }); } - Request parse_request(istream& stream) { + Request parse_request(std::istream& stream) { Request request; - regex e("^([^ ]*) ([^ ]*) HTTP/([^ ]*)$"); + std::regex e("^([^ ]*) ([^ ]*) HTTP/([^ ]*)$"); - smatch sm; + std::smatch sm; //First parse request method, path, and HTTP-version from the first line - string line; + std::string line; getline(stream, line); line.pop_back(); - if(regex_match(line, sm, e)) { + if(std::regex_match(line, sm, e)) { request.method=sm[1]; request.path=sm[2]; request.http_version=sm[3]; @@ -136,7 +135,7 @@ namespace SimpleWeb { do { getline(stream, line); line.pop_back(); - matched=regex_match(line, sm, e); + matched=std::regex_match(line, sm, e); if(matched) { request.header[sm[1]]=sm[2]; } @@ -147,19 +146,20 @@ namespace SimpleWeb { return request; } - void respond(shared_ptr socket, shared_ptr request) { + void respond(std::shared_ptr socket, std::shared_ptr request) { //Find path- and method-match, and generate response for(auto res_it: all_resources) { - regex e(res_it->first); - smatch sm_res; - if(regex_match(request->path, sm_res, e)) { + std::regex e(res_it->first); + std::smatch sm_res; + if(std::regex_match(request->path, sm_res, e)) { if(res_it->second.count(request->method)>0) { - shared_ptr write_buffer(new boost::asio::streambuf); - ostream response(write_buffer.get()); + std::shared_ptr write_buffer(new boost::asio::streambuf); + std::ostream response(write_buffer.get()); res_it->second[request->method](response, *request, sm_res); //Capture write_buffer in lambda so it is not destroyed before async_write is finished - async_write(*socket, *write_buffer, [this, socket, request, write_buffer](const boost::system::error_code& ec, size_t bytes_transferred) { + boost::asio::async_write(*socket, *write_buffer, + [this, socket, request, write_buffer](const boost::system::error_code& ec, size_t bytes_transferred) { //HTTP persistent connection (HTTP 1.1): if(!ec && stof(request->http_version)>1.05) process_request_and_respond(socket); @@ -174,7 +174,7 @@ namespace SimpleWeb { template class Server : public ServerBase {}; - typedef ip::tcp::socket HTTP; + typedef boost::asio::ip::tcp::socket HTTP; template<> class Server : public ServerBase { @@ -185,7 +185,7 @@ namespace SimpleWeb { void accept() { //Create new socket for this connection //Shared_ptr is used to pass temporary objects to the asynchronous functions - shared_ptr socket(new HTTP(m_io_service)); + std::shared_ptr socket(new HTTP(m_io_service)); acceptor.async_accept(*socket, [this, socket](const boost::system::error_code& ec) { //Immediately start accepting a new connection diff --git a/server_https.hpp b/server_https.hpp index a0584b0..526584e 100644 --- a/server_https.hpp +++ b/server_https.hpp @@ -5,31 +5,31 @@ #include namespace SimpleWeb { - typedef ssl::stream HTTPS; + typedef boost::asio::ssl::stream HTTPS; template<> class Server : public ServerBase { public: - Server(unsigned short port, size_t num_threads, const string& cert_file, const string& private_key_file) : - ServerBase::ServerBase(port, num_threads), context(ssl::context::sslv23) { + Server(unsigned short port, size_t num_threads, const std::string& cert_file, const std::string& private_key_file) : + ServerBase::ServerBase(port, num_threads), context(boost::asio::ssl::context::sslv23) { context.use_certificate_chain_file(cert_file); - context.use_private_key_file(private_key_file, ssl::context::pem); + context.use_private_key_file(private_key_file, boost::asio::ssl::context::pem); } private: - ssl::context context; + boost::asio::ssl::context context; void accept() { //Create new socket for this connection //Shared_ptr is used to pass temporary objects to the asynchronous functions - shared_ptr socket(new HTTPS(m_io_service, context)); + std::shared_ptr socket(new HTTPS(m_io_service, context)); acceptor.async_accept((*socket).lowest_layer(), [this, socket](const boost::system::error_code& ec) { //Immediately start accepting a new connection accept(); if(!ec) { - (*socket).async_handshake(ssl::stream_base::server, [this, socket](const boost::system::error_code& ec) { + (*socket).async_handshake(boost::asio::ssl::stream_base::server, [this, socket](const boost::system::error_code& ec) { if(!ec) { process_request_and_respond(socket); }