rename variable to be more telling that it's not a type but a variable

Server/Connection.cpp

@@ -67,14 +67,15 @@ void Connection::handle_read(const boost::system::error_code &error, std::size_t
     // no error detected, let's parse the request
     compression_type compression_type(no_compression);
     osrm::tribool result;
-    std::tie(result, compression_type) = RequestParser().parse(
+    std::tie(result, compression_type) =
-        request, incoming_data_buffer.data(), incoming_data_buffer.data() + bytes_transferred);
+        RequestParser().parse(current_request, incoming_data_buffer.data(),
+                              incoming_data_buffer.data() + bytes_transferred);
 
     // the request has been parsed
     if (result == osrm::tribool::yes)
     {
-        request.endpoint = TCP_socket.remote_endpoint().address();
+        current_request.endpoint = TCP_socket.remote_endpoint().address();
-        request_handler.handle_request(request, reply);
+        request_handler.handle_request(current_request, current_reply);
 
         // Header compression_header;
         std::vector<char> compressed_output;
@@ -85,24 +86,26 @@ void Connection::handle_read(const boost::system::error_code &error, std::size_t
         {
         case deflate_rfc1951:
             // use deflate for compression
-            reply.headers.insert(reply.headers.begin(), {"Content-Encoding", "deflate"});
+            current_reply.headers.insert(current_reply.headers.begin(),
-            compressed_output = compress_buffers(reply.content, compression_type);
+                                         {"Content-Encoding", "deflate"});
-            reply.set_size(static_cast<unsigned>(compressed_output.size()));
+            compressed_output = compress_buffers(current_reply.content, compression_type);
-            output_buffer = reply.headers_to_buffers();
+            current_reply.set_size(static_cast<unsigned>(compressed_output.size()));
+            output_buffer = current_reply.headers_to_buffers();
             output_buffer.push_back(boost::asio::buffer(compressed_output));
             break;
         case gzip_rfc1952:
             // use gzip for compression
-            reply.headers.insert(reply.headers.begin(), {"Content-Encoding", "gzip"});
+            current_reply.headers.insert(current_reply.headers.begin(),
-            compressed_output = compress_buffers(reply.content, compression_type);
+                                         {"Content-Encoding", "gzip"});
-            reply.set_size(static_cast<unsigned>(compressed_output.size()));
+            compressed_output = compress_buffers(current_reply.content, compression_type);
-            output_buffer = reply.headers_to_buffers();
+            current_reply.set_size(static_cast<unsigned>(compressed_output.size()));
+            output_buffer = current_reply.headers_to_buffers();
             output_buffer.push_back(boost::asio::buffer(compressed_output));
             break;
         case no_compression:
             // don't use any compression
-            reply.set_uncompressed_size();
+            current_reply.set_uncompressed_size();
-            output_buffer = reply.to_buffers();
+            output_buffer = current_reply.to_buffers();
             break;
         }
         // write result to stream
@@ -113,10 +116,10 @@ void Connection::handle_read(const boost::system::error_code &error, std::size_t
     }
     else if (result == osrm::tribool::no)
     { // request is not parseable
-        reply = reply::stock_reply(reply::bad_request);
+        current_reply = reply::stock_reply(reply::bad_request);
 
         boost::asio::async_write(
-            TCP_socket, reply.to_buffers(),
+            TCP_socket, current_reply.to_buffers(),
             strand.wrap(boost::bind(&Connection::handle_write, this->shared_from_this(),
                                     boost::asio::placeholders::error)));
     }

server/request_parser.cpp

@@ -35,7 +35,7 @@ namespace http
 {
 
 RequestParser::RequestParser()
-    : state(internal_state::method_start), header({"", ""}), compression_type(no_compression)
+    : state(internal_state::method_start), header({"", ""}), selected_compression(no_compression)
 {
 }
 
@@ -47,11 +47,11 @@ RequestParser::parse(request &current_request, char *begin, char *end)
         osrm::tribool result = consume(current_request, *begin++);
         if (result != osrm::tribool::indeterminate)
         {
-            return std::make_tuple(result, compression_type);
+            return std::make_tuple(result, selected_compression);
         }
     }
     osrm::tribool result = osrm::tribool::indeterminate;
-    return std::make_tuple(result, compression_type);
+    return std::make_tuple(result, selected_compression);
 }
 
 osrm::tribool RequestParser::consume(request &current_request, const char input)
@@ -180,11 +180,11 @@ osrm::tribool RequestParser::consume(request &current_request, const char input)
             /* giving gzip precedence over deflate */
             if (boost::icontains(header.value, "deflate"))
             {
-                compression_type = deflate_rfc1951;
+                selected_compression = deflate_rfc1951;
             }
             if (boost::icontains(header.value, "gzip"))
             {
-                compression_type = gzip_rfc1952;
+                selected_compression = gzip_rfc1952;
             }
         }
 

server/request_parser.hpp

@@ -84,7 +84,7 @@ class RequestParser
     } state;
 
     header header;
-    compression_type compression_type;
+    compression_type selected_compression;
 };
 
 } // namespace http