Changed private to protected in Server/Client<HTTP/HTTPS> classes, and some cleanup

client_http.hpp

@@ -118,9 +118,9 @@ namespace SimpleWeb {
         }
         
     protected:
-        boost::asio::io_service asio_io_service;
+        boost::asio::io_service io_service;
-        boost::asio::ip::tcp::endpoint asio_endpoint;
+        boost::asio::ip::tcp::endpoint endpoint;
-        boost::asio::ip::tcp::resolver asio_resolver;
+        boost::asio::ip::tcp::resolver resolver;
         
         std::shared_ptr<socket_type> socket;
         bool socket_error;
@@ -129,7 +129,7 @@ namespace SimpleWeb {
         unsigned short port;
                 
         ClientBase(const std::string& host_port, unsigned short default_port) : 
-                asio_resolver(asio_io_service), socket_error(false) {
+                resolver(io_service), socket_error(false) {
             size_t host_end=host_port.find(':');
             if(host_end==std::string::npos) {
                 host=host_port;
@@ -140,7 +140,7 @@ namespace SimpleWeb {
                 port=static_cast<unsigned short>(stoul(host_port.substr(host_end+1)));
             }
 
-            asio_endpoint=boost::asio::ip::tcp::endpoint(boost::asio::ip::tcp::v4(), port);
+            endpoint=boost::asio::ip::tcp::endpoint(boost::asio::ip::tcp::v4(), port);
         }
         
         virtual void connect()=0;
@@ -241,14 +241,14 @@ namespace SimpleWeb {
     class Client<HTTP> : public ClientBase<HTTP> {
     public:
         Client(const std::string& server_port_path) : ClientBase<HTTP>::ClientBase(server_port_path, 80) {
-            socket=std::make_shared<HTTP>(asio_io_service);
+            socket=std::make_shared<HTTP>(io_service);
         }
         
-    private:
+    protected:
         void connect() {
             if(socket_error || !socket->is_open()) {
                 boost::asio::ip::tcp::resolver::query query(host, std::to_string(port));
-                boost::asio::connect(*socket, asio_resolver.resolve(query));
+                boost::asio::connect(*socket, resolver.resolve(query));
                 
                 boost::asio::ip::tcp::no_delay option(true);
                 socket->set_option(option);

client_https.hpp

@@ -13,30 +13,30 @@ namespace SimpleWeb {
         Client(const std::string& server_port_path, bool verify_certificate=true, 
                 const std::string& cert_file=std::string(), const std::string& private_key_file=std::string(), 
                 const std::string& verify_file=std::string()) : 
-                ClientBase<HTTPS>::ClientBase(server_port_path, 443), asio_context(boost::asio::ssl::context::sslv23) {
+                ClientBase<HTTPS>::ClientBase(server_port_path, 443), context(boost::asio::ssl::context::sslv23) {
             if(verify_certificate)
-                asio_context.set_verify_mode(boost::asio::ssl::verify_peer);
+                context.set_verify_mode(boost::asio::ssl::verify_peer);
             else
-                asio_context.set_verify_mode(boost::asio::ssl::verify_none);
+                context.set_verify_mode(boost::asio::ssl::verify_none);
             
             if(cert_file.size()>0 && private_key_file.size()>0) {
-                asio_context.use_certificate_chain_file(cert_file);
+                context.use_certificate_chain_file(cert_file);
-                asio_context.use_private_key_file(private_key_file, boost::asio::ssl::context::pem);
+                context.use_private_key_file(private_key_file, boost::asio::ssl::context::pem);
             }
             
             if(verify_file.size()>0)
-                asio_context.load_verify_file(verify_file);
+                context.load_verify_file(verify_file);
             
-            socket=std::make_shared<HTTPS>(asio_io_service, asio_context);
+            socket=std::make_shared<HTTPS>(io_service, context);
         }
 
-    private:
+    protected:
-        boost::asio::ssl::context asio_context;
+        boost::asio::ssl::context context;
         
         void connect() {
             if(socket_error || !socket->lowest_layer().is_open()) {
                 boost::asio::ip::tcp::resolver::query query(host, std::to_string(port));
-                boost::asio::connect(socket->lowest_layer(), asio_resolver.resolve(query));
+                boost::asio::connect(socket->lowest_layer(), resolver.resolve(query));
                 
                 boost::asio::ip::tcp::no_delay option(true);
                 socket->lowest_layer().set_option(option);

server_http.hpp

@@ -391,7 +391,7 @@ namespace SimpleWeb {
         Server(unsigned short port, size_t num_threads=1, long timeout_request=5, long timeout_content=300) :
                 ServerBase<HTTP>::ServerBase(port, num_threads, timeout_request, timeout_content) {}
         
-    private:
+    protected:
         void accept() {
             //Create new socket for this connection
             //Shared_ptr is used to pass temporary objects to the asynchronous functions

server_https.hpp

@@ -22,7 +22,7 @@ namespace SimpleWeb {
                 context.load_verify_file(verify_file);
         }
 
-    private:
+    protected:
         boost::asio::ssl::context context;
         
         void accept() {