remove unnecessary else statements

Server/RequestParser.cpp

@@ -38,11 +38,13 @@ boost::tuple<boost::tribool, char*> RequestParser::Parse(
     Request& req,
     char* begin,
     char* end,
-    http::CompressionType * compressionType
+    http::CompressionType * compressionType)
-) {
+{
-    while (begin != end) {
+    while (begin != end)
+    {
         boost::tribool result = consume(req, *begin++, compressionType);
-        if (result || !result){
+        if (result || !result)
+        {
             return boost::make_tuple(result, begin);
         }
     }
@@ -50,193 +52,216 @@ boost::tuple<boost::tribool, char*> RequestParser::Parse(
     return boost::make_tuple(result, begin);
 }
 
-boost::tribool RequestParser::consume(
+boost::tribool RequestParser::consume(Request& req, char input, http::CompressionType * compressionType)
-    Request& req, char input,
+{
-    http::CompressionType * compressionType
+    switch (state_)
-) {
+    {
-    switch (state_) {
     case method_start:
-        if (!isChar(input) || isCTL(input) || isTSpecial(input)) {
+        if (!isChar(input) || isCTL(input) || isTSpecial(input))
+        {
             return false;
-        } else {
-            state_ = method;
-            return boost::indeterminate;
         }
+        state_ = method;
+        return boost::indeterminate;
     case method:
-        if (input == ' ') {
+        if (input == ' ')
+        {
             state_ = uri;
             return boost::indeterminate;
-        } else if (!isChar(input) || isCTL(input) || isTSpecial(input)) {
-            return false;
-        } else {
-            return boost::indeterminate;
         }
+        if (!isChar(input) || isCTL(input) || isTSpecial(input))
+        {
+            return false;
+        }
+        return boost::indeterminate;
     case uri_start:
-        if (isCTL(input)) {
+        if (isCTL(input))
+        {
             return false;
-        } else {
-            state_ = uri;
-            req.uri.push_back(input);
-            return boost::indeterminate;
         }
+        state_ = uri;
+        req.uri.push_back(input);
+        return boost::indeterminate;
     case uri:
-        if (input == ' ') {
+        if (input == ' ')
+        {
             state_ = http_version_h;
             return boost::indeterminate;
-        } else if (isCTL(input)) {
-            return false;
-        } else {
-            req.uri.push_back(input);
-            return boost::indeterminate;
         }
+        if (isCTL(input))
+        {
+            return false;
+        }
+        req.uri.push_back(input);
+        return boost::indeterminate;
     case http_version_h:
-        if (input == 'H') {
+        if (input == 'H')
+        {
             state_ = http_version_t_1;
             return boost::indeterminate;
-        } else {
-            return false;
         }
+        return false;
     case http_version_t_1:
-        if (input == 'T') {
+        if (input == 'T')
+        {
             state_ = http_version_t_2;
             return boost::indeterminate;
-        } else {
-            return false;
         }
+        return false;
     case http_version_t_2:
-        if (input == 'T') {
+        if (input == 'T')
+        {
             state_ = http_version_p;
             return boost::indeterminate;
-        } else {
-            return false;
         }
+        return false;
     case http_version_p:
-        if (input == 'P') {
+        if (input == 'P')
+        {
             state_ = http_version_slash;
             return boost::indeterminate;
-        } else {
-            return false;
         }
+        return false;
     case http_version_slash:
-        if (input == '/') {
+        if (input == '/')
+        {
             state_ = http_version_major_start;
             return boost::indeterminate;
-        } else {
-            return false;
         }
+        return false;
     case http_version_major_start:
-        if (isDigit(input)) {
+        if (isDigit(input))
+        {
             state_ = http_version_major;
             return boost::indeterminate;
-        } else {
-            return false;
         }
+        return false;
     case http_version_major:
-        if (input == '.') {
+        if (input == '.')
+        {
             state_ = http_version_minor_start;
             return boost::indeterminate;
-        } else if (isDigit(input)) {
-            return boost::indeterminate;
-        } else {
-            return false;
         }
+        if (isDigit(input))
+        {
+            return boost::indeterminate;
+        }
+        return false;
     case http_version_minor_start:
-        if (isDigit(input)) {
+        if (isDigit(input))
+        {
             state_ = http_version_minor;
             return boost::indeterminate;
-        } else {
-            return false;
         }
+        return false;
     case http_version_minor:
-        if (input == '\r') {
+        if (input == '\r')
+        {
             state_ = expecting_newline_1;
             return boost::indeterminate;
-        } else if (isDigit(input)) {
+        }
+        if (isDigit(input))
+        {
             return boost::indeterminate;
         }
-        else {
+        return false;
-            return false;
-        }
     case expecting_newline_1:
-        if (input == '\n') {
+        if (input == '\n')
+        {
             state_ = header_line_start;
             return boost::indeterminate;
-        } else {
-            return false;
         }
+        return false;
     case header_line_start:
-        if(header.name == "Accept-Encoding") {
+        if(header.name == "Accept-Encoding")
+        {
             /* giving gzip precedence over deflate */
-            if(header.value.find("deflate") != std::string::npos)
+            if (header.value.find("deflate") != std::string::npos)
+            {
                 *compressionType = deflateRFC1951;
-            if(header.value.find("gzip") != std::string::npos)
+            }
+            if (header.value.find("gzip") != std::string::npos)
+            {
                 *compressionType = gzipRFC1952;
+            }
         }
 
-        if("Referer" == header.name)
+        if ("Referer" == header.name)
+        {
             req.referrer = header.value;
+        }
 
-        if("User-Agent" == header.name)
+        if ("User-Agent" == header.name)
+        {
             req.agent = header.value;
+        }
 
-        if (input == '\r') {
+        if (input == '\r')
+        {
             state_ = expecting_newline_3;
             return boost::indeterminate;
-        } else if (!isChar(input) || isCTL(input) || isTSpecial(input)) {
-            return false;
-        } else {
-            state_ = header_name;
-            header.Clear();
-            header.name.push_back(input);
-            return boost::indeterminate;
         }
+        if (!isChar(input) || isCTL(input) || isTSpecial(input))
+        {
+            return false;
+        }
+        state_ = header_name;
+        header.Clear();
+        header.name.push_back(input);
+        return boost::indeterminate;
     case header_lws:
-        if (input == '\r') {
+        if (input == '\r')
+        {
             state_ = expecting_newline_2;
             return boost::indeterminate;
-        } else if (input == ' ' || input == '\t') {
+        }
+        if (input == ' ' || input == '\t')
+        {
             return boost::indeterminate;
         }
-        else if (isCTL(input)) {
+        if (isCTL(input)) {
             return false;
-        } else {
-            state_ = header_value;
-            return boost::indeterminate;
         }
+        state_ = header_value;
+        return boost::indeterminate;
     case header_name:
-        if (input == ':') {
+        if (input == ':')
+        {
             state_ = space_before_header_value;
             return boost::indeterminate;
-        } else if (!isChar(input) || isCTL(input) || isTSpecial(input)) {
-            return false;
-        } else {
-            header.name.push_back(input);
-            return boost::indeterminate;
         }
+        if (!isChar(input) || isCTL(input) || isTSpecial(input))
+        {
+            return false;
+        }
+        header.name.push_back(input);
+        return boost::indeterminate;
     case space_before_header_value:
-        if (input == ' ') {
+        if (input == ' ')
+        {
             state_ = header_value;
             return boost::indeterminate;
-        } else {
-            return false;
         }
+        return false;
     case header_value:
-        if (input == '\r') {
+        if (input == '\r')
+        {
             state_ = expecting_newline_2;
             return boost::indeterminate;
-        } else if (isCTL(input)) {
-            return false;
-        } else {
-            header.value.push_back(input);
-            return boost::indeterminate;
         }
+        if (isCTL(input))
+        {
+            return false;
+        }
+        header.value.push_back(input);
+        return boost::indeterminate;
     case expecting_newline_2:
-        if (input == '\n') {
+        if (input == '\n')
+        {
             state_ = header_line_start;
             return boost::indeterminate;
-        } else {
-            return false;
         }
+        return false;
     case expecting_newline_3:
         return (input == '\n');
     default:
@@ -244,27 +269,32 @@ boost::tribool RequestParser::consume(
     }
 }
 
-inline bool RequestParser::isChar(int c) {
+inline bool RequestParser::isChar(int c)
+{
     return c >= 0 && c <= 127;
 }
 
-inline bool RequestParser::isCTL(int c) {
+inline bool RequestParser::isCTL(int c)
+{
     return (c >= 0 && c <= 31) || (c == 127);
 }
 
-inline bool RequestParser::isTSpecial(int c) {
+inline bool RequestParser::isTSpecial(int c)
-    switch (c) {
+{
-    case '(': case ')': case '<': case '>': case '@':
+    switch (c)
-    case ',': case ';': case ':': case '\\': case '"':
+    {
-    case '/': case '[': case ']': case '?': case '=':
+        case '(': case ')': case '<': case '>': case '@':
-    case '{': case '}': case ' ': case '\t':
+        case ',': case ';': case ':': case '\\': case '"':
-        return true;
+        case '/': case '[': case ']': case '?': case '=':
-    default:
+        case '{': case '}': case ' ': case '\t':
-        return false;
+            return true;
+        default:
+            return false;
     }
 }
 
-inline bool RequestParser::isDigit(int c) {
+inline bool RequestParser::isDigit(int c)
+{
     return c >= '0' && c <= '9';
 }