stdexception
diff --git a/‎src/details/http_endpoint.cpp‎
Lines changed: 32 additions & 32 deletions b/‎src/details/http_endpoint.cpp‎
Lines changed: 32 additions & 32 deletions
diff --git a/‎src/http_request.cpp‎
Lines changed: 8 additions & 8 deletions b/‎src/http_request.cpp‎
Lines changed: 8 additions & 8 deletions
diff --git a/‎src/http_response.cpp‎
Lines changed: 1 addition & 1 deletion b/‎src/http_response.cpp‎
Lines changed: 1 addition & 1 deletion
diff --git a/‎src/http_utils.cpp‎
Lines changed: 6 additions & 6 deletions b/‎src/http_utils.cpp‎
Lines changed: 6 additions & 6 deletions
diff --git a/‎src/httpserver/deferred_response.hpp‎
Lines changed: 1 addition & 1 deletion b/‎src/httpserver/deferred_response.hpp‎
Lines changed: 1 addition & 1 deletion
diff --git a/‎src/httpserver/details/http_endpoint.hpp‎
Lines changed: 7 additions & 7 deletions b/‎src/httpserver/details/http_endpoint.hpp‎
Lines changed: 7 additions & 7 deletions
diff --git a/‎src/httpserver/http_request.hpp‎
Lines changed: 8 additions & 9 deletions b/‎src/httpserver/http_request.hpp‎
Lines changed: 8 additions & 9 deletions
@@ -36,7 +36,7 @@ http_endpoint::~http_endpoint()
 {
     if(reg_compiled)
     {
-        regfree(&(this->re_url_normalized));
+        regfree(&re_url_normalized);
     }
 }
 
@@ -50,7 +50,7 @@ http_endpoint::http_endpoint
     family_url(family),
     reg_compiled(false)
 {
-    this->url_normalized = use_regex ? "^/" : "/";
+    url_normalized = use_regex ? "^/" : "/";
     vector<string> parts;
 
 #ifdef CASE_INSENSITIVE
@@ -77,10 +77,10 @@ http_endpoint::http_endpoint
     {
         if(!registration)
         {
-            this->url_normalized += (first ? "" : "/") + parts[i];
+            url_normalized += (first ? "" : "/") + parts[i];
             first = false;
 
-            this->url_pieces.push_back(parts[i]);
+            url_pieces.push_back(parts[i]);
 
             continue;
         }
@@ -89,14 +89,14 @@ http_endpoint::http_endpoint
         {
             if(first)
             {
-                this->url_normalized = (parts[i][0] == '^' ? "" : this->url_normalized) + parts[i];
+                url_normalized = (parts[i][0] == '^' ? "" : url_normalized) + parts[i];
                 first = false;
             }
             else
             {
-                this->url_normalized += "/" + parts[i];
+                url_normalized += "/" + parts[i];
             }
-            this->url_pieces.push_back(parts[i]);
+            url_pieces.push_back(parts[i]);
 
             continue;
         }
@@ -105,23 +105,23 @@ http_endpoint::http_endpoint
             throw std::invalid_argument("Bad URL format");
 
         std::string::size_type bar = parts[i].find_first_of('|');
-        this->url_pars.push_back(parts[i].substr(1, bar != string::npos ? bar - 1 : parts[i].size() - 2));
-        this->url_normalized += (first ? "" : "/") + (bar != string::npos ? parts[i].substr(bar + 1, parts[i].size() - bar - 2) : "([^\\/]+)");
+        url_pars.push_back(parts[i].substr(1, bar != string::npos ? bar - 1 : parts[i].size() - 2));
+        url_normalized += (first ? "" : "/") + (bar != string::npos ? parts[i].substr(bar + 1, parts[i].size() - bar - 2) : "([^\\/]+)");
 
         first = false;
 
-        this->chunk_positions.push_back(i);
+        chunk_positions.push_back(i);
 
-        this->url_pieces.push_back(parts[i]);
+        url_pieces.push_back(parts[i]);
     }
 
     if(use_regex)
     {
-        this->url_normalized += "$";
-        regcomp(&(this->re_url_normalized), url_normalized.c_str(),
+        url_normalized += "$";
+        regcomp(&re_url_normalized, url_normalized.c_str(),
                 REG_EXTENDED|REG_ICASE|REG_NOSUB
         );
-        this->reg_compiled = true;
+        reg_compiled = true;
     }
 }
 
@@ -134,52 +134,52 @@ http_endpoint::http_endpoint(const http_endpoint& h):
     family_url(h.family_url),
     reg_compiled(h.reg_compiled)
 {
-    if(this->reg_compiled)
-        regcomp(&(this->re_url_normalized), url_normalized.c_str(),
+    if(reg_compiled)
+        regcomp(&re_url_normalized, url_normalized.c_str(),
                 REG_EXTENDED|REG_ICASE|REG_NOSUB
         );
 }
 
 http_endpoint& http_endpoint::operator =(const http_endpoint& h)
 {
-    this->url_complete = h.url_complete;
-    this->url_normalized = h.url_normalized;
-    this->family_url = h.family_url;
-    this->reg_compiled = h.reg_compiled;
-    if(this->reg_compiled)
+    url_complete = h.url_complete;
+    url_normalized = h.url_normalized;
+    family_url = h.family_url;
+    reg_compiled = h.reg_compiled;
+    if(reg_compiled)
     {
-        regfree(&(this->re_url_normalized));
+        regfree(&re_url_normalized);
 
-        regcomp(&(this->re_url_normalized), url_normalized.c_str(),
+        regcomp(&re_url_normalized, url_normalized.c_str(),
                 REG_EXTENDED|REG_ICASE|REG_NOSUB
         );
     }
-    this->url_pars = h.url_pars;
-    this->url_pieces = h.url_pieces;
-    this->chunk_positions = h.chunk_positions;
+    url_pars = h.url_pars;
+    url_pieces = h.url_pieces;
+    chunk_positions = h.chunk_positions;
     return *this;
 }
 
 bool http_endpoint::operator <(const http_endpoint& b) const
 {
-    COMPARATOR(this->url_normalized, b.url_normalized, std::toupper);
+    COMPARATOR(url_normalized, b.url_normalized, std::toupper);
 }
 
 bool http_endpoint::match(const http_endpoint& url) const
 {
-    if (!this->reg_compiled) throw std::invalid_argument("Cannot run match. Regex suppressed.");
+    if (!reg_compiled) throw std::invalid_argument("Cannot run match. Regex suppressed.");
 
-    if(!this->family_url || url.url_pieces.size() < this->url_pieces.size())
-        return regexec(&(this->re_url_normalized), url.url_complete.c_str(), 0, NULL, 0) == 0;
+    if(!family_url || url.url_pieces.size() < url_pieces.size())
+        return regexec(&re_url_normalized, url.url_complete.c_str(), 0, NULL, 0) == 0;
 
     string nn = "/";
     bool first = true;
-    for(unsigned int i = 0; i < this->url_pieces.size(); i++)
+    for(unsigned int i = 0; i < url_pieces.size(); i++)
     {
         nn += (first ? "" : "/") + url.url_pieces[i];
         first = false;
     }
-    return regexec(&(this->re_url_normalized), nn.c_str(), 0, NULL, 0) == 0;
+    return regexec(&re_url_normalized, nn.c_str(), 0, NULL, 0) == 0;
 }
 
 };
 
@@ -76,7 +76,7 @@ bool http_request::check_digest_auth(
 const std::string http_request::get_connection_value(const std::string& key, enum MHD_ValueKind kind) const
 {
     const char* header_c = MHD_lookup_connection_value(
-        this->underlying_connection,
+        underlying_connection,
         kind,
         key.c_str()
     );
@@ -103,7 +103,7 @@ const std::map<std::string, std::string, http::header_comparator> http_request::
     std::map<std::string, std::string, http::header_comparator> headers;
 
     MHD_get_connection_values(
-        this->underlying_connection,
+        underlying_connection,
         kind,
         &build_request_header,
         (void*) &headers
@@ -144,9 +144,9 @@ const std::map<std::string, std::string, http::header_comparator> http_request::
 
 const std::string http_request::get_arg(const std::string& key) const
 {
-    std::map<std::string, std::string>::const_iterator it = this->args.find(key);
+    std::map<std::string, std::string>::const_iterator it = args.find(key);
 
-    if(it != this->args.end())
+    if(it != args.end())
     {
         return it->second;
     }
@@ -157,14 +157,14 @@ const std::string http_request::get_arg(const std::string& key) const
 const std::map<std::string, std::string, http::arg_comparator> http_request::get_args() const
 {
     std::map<std::string, std::string, http::arg_comparator> arguments;
-    arguments.insert(this->args.begin(), this->args.end());
+    arguments.insert(args.begin(), args.end());
 
     arguments_accumulator aa;
-    aa.unescaper = this->unescaper;
+    aa.unescaper = unescaper;
     aa.arguments = &arguments;
 
     MHD_get_connection_values(
-        this->underlying_connection,
+        underlying_connection,
         MHD_GET_ARGUMENT_KIND,
         &build_request_args,
         (void*) &aa
@@ -178,7 +178,7 @@ const std::string http_request::get_querystring() const
     std::string querystring = "";
 
     MHD_get_connection_values(
-        this->underlying_connection,
+        underlying_connection,
         MHD_GET_ARGUMENT_KIND,
         &build_request_querystring,
         (void*) &querystring
 
@@ -70,7 +70,7 @@ int http_response::enqueue_response(MHD_Connection* connection, MHD_Response* re
 
 void http_response::shoutCAST()
 {
-    this->response_code |= http::http_utils::shoutcast_response;
+    response_code |= http::http_utils::shoutcast_response;
 }
 
 std::ostream &operator<< (std::ostream &os, const http_response &r)
 
@@ -517,26 +517,26 @@ bool ip_representation::operator <(const ip_representation& b) const
     {
         if (i == 10 || i == 11) continue;
 
-        if (CHECK_BIT(this->mask, i) && CHECK_BIT(b.mask, i))
+        if (CHECK_BIT(mask, i) && CHECK_BIT(b.mask, i))
         {
-            this_score += (16 - i) * this->pieces[i];
+            this_score += (16 - i) * pieces[i];
             b_score += (16 - i) * b.pieces[i];
         }
     }
 
     if (this_score == b_score &&
-       ((this->pieces[10] == 0x00 || this->pieces[10] == 0xFF) && (b.pieces[10] == 0x00 || b.pieces[10] == 0xFF)) &&
-       ((this->pieces[11] == 0x00 || this->pieces[11] == 0xFF) && (b.pieces[11] == 0x00 || b.pieces[11] == 0xFF))
+       ((pieces[10] == 0x00 || pieces[10] == 0xFF) && (b.pieces[10] == 0x00 || b.pieces[10] == 0xFF)) &&
+       ((pieces[11] == 0x00 || pieces[11] == 0xFF) && (b.pieces[11] == 0x00 || b.pieces[11] == 0xFF))
     )
     {
         return false;
     }
 
     for (int i = 10; i < 12; i++)
     {
-        if (CHECK_BIT(this->mask, i) && CHECK_BIT(b.mask, i))
+        if (CHECK_BIT(mask, i) && CHECK_BIT(b.mask, i))
         {
-            this_score += (16 - i) * this->pieces[i];
+            this_score += (16 - i) * pieces[i];
             b_score += (16 - i) * b.pieces[i];
         }
     }
 
@@ -62,7 +62,7 @@ class deferred_response : public string_response
 
         MHD_Response* get_raw_response()
         {
-            return details::get_raw_response_helper((void*) this, &(this->cb));
+            return details::get_raw_response_helper((void*) this, &cb);
         }
 
     private:
 
@@ -85,12 +85,12 @@ class http_endpoint
         **/
         const std::string& get_url_complete() const
         {
-            return this->url_complete;
+            return url_complete;
         }
 
         const std::string& get_url_normalized() const
         {
-            return this->url_normalized;
+            return url_normalized;
         }
 
         /**
@@ -99,7 +99,7 @@ class http_endpoint
         **/
         const std::vector<std::string>& get_url_pars() const
         {
-            return this->url_pars;
+            return url_pars;
         }
 
         /**
@@ -108,7 +108,7 @@ class http_endpoint
         **/
         const std::vector<std::string>& get_url_pieces() const
         {
-            return this->url_pieces;
+            return url_pieces;
         }
 
         /**
@@ -117,17 +117,17 @@ class http_endpoint
         **/
         const std::vector<int>& get_chunk_positions() const
         {
-            return this->chunk_positions;
+            return chunk_positions;
         }
 
         const bool is_family_url() const
         {
-            return this->family_url;
+            return family_url;
         }
 
         const bool is_regex_compiled() const
         {
-            return this->reg_compiled;
+            return reg_compiled;
         }
 
         /**
 
@@ -76,7 +76,7 @@ class http_request
         **/
         const std::string& get_path() const
         {
-            return this->path;
+            return path;
         }
 
         /**
@@ -85,7 +85,7 @@ class http_request
         **/
         const std::vector<std::string> get_path_pieces() const
         {
-            return http::http_utils::tokenize_url(this->path);
+            return http::http_utils::tokenize_url(path);
         }
 
         /**
@@ -95,7 +95,7 @@ class http_request
         **/
         const std::string get_path_piece(int index) const
         {
-            std::vector<std::string> post_path = this->get_path_pieces();
+            std::vector<std::string> post_path = get_path_pieces();
             if(((int)(post_path.size())) > index)
                 return post_path[index];
             return EMPTY;
@@ -107,7 +107,7 @@ class http_request
         **/
         const std::string& get_method() const
         {
-            return this->method;
+            return method;
         }
 
         /**
@@ -167,7 +167,7 @@ class http_request
         **/
         const std::string& get_content() const
         {
-            return this->content;
+            return content;
         }
 
         /**
@@ -190,7 +190,7 @@ class http_request
         **/
         const std::string& get_version() const
         {
-            return this->version;
+            return version;
         }
 
         /**
@@ -264,7 +264,7 @@ class http_request
         **/
         void set_arg(const std::string& key, const std::string& value)
         {
-            this->args[key] = value.substr(0,content_size_limit);
+            args[key] = value.substr(0,content_size_limit);
         }
 
         /**
@@ -275,8 +275,7 @@ class http_request
         **/
         void set_arg(const char* key, const char* value, size_t size)
         {
-            this->args[key] = std::string(value,
-                                          std::min(size, content_size_limit));
+            args[key] = std::string(value, std::min(size, content_size_limit));
         }
 
         /**
Original file line number	Diff line number	Diff line change
`@@ -36,7 +36,7 @@ http_endpoint::~http_endpoint()`
`36`	`36`	`{`
`37`	`37`	`if(reg_compiled)`
`38`	`38`	`{`
`39`		`- regfree(&(this->re_url_normalized));`
	`39`	`+ regfree(&re_url_normalized);`
`40`	`40`	`}`
`41`	`41`	`}`
`42`	`42`
`@@ -50,7 +50,7 @@ http_endpoint::http_endpoint`
`50`	`50`	`family_url(family),`
`51`	`51`	`reg_compiled(false)`
`52`	`52`	`{`
`53`		`- this->url_normalized = use_regex ? "^/" : "/";`
	`53`	`+ url_normalized = use_regex ? "^/" : "/";`
`54`	`54`	`vector<string> parts;`
`55`	`55`
`56`	`56`	`#ifdef CASE_INSENSITIVE`
`@@ -77,10 +77,10 @@ http_endpoint::http_endpoint`
`77`	`77`	`{`
`78`	`78`	`if(!registration)`
`79`	`79`	`{`
`80`		`- this->url_normalized += (first ? "" : "/") + parts[i];`
	`80`	`+ url_normalized += (first ? "" : "/") + parts[i];`
`81`	`81`	`first = false;`
`82`	`82`
`83`		`- this->url_pieces.push_back(parts[i]);`
	`83`	`+ url_pieces.push_back(parts[i]);`
`84`	`84`
`85`	`85`	`continue;`
`86`	`86`	`}`
`@@ -89,14 +89,14 @@ http_endpoint::http_endpoint`
`89`	`89`	`{`
`90`	`90`	`if(first)`
`91`	`91`	`{`
`92`		`- this->url_normalized = (parts[i][0] == '^' ? "" : this->url_normalized) + parts[i];`
	`92`	`+ url_normalized = (parts[i][0] == '^' ? "" : url_normalized) + parts[i];`
`93`	`93`	`first = false;`
`94`	`94`	`}`
`95`	`95`	`else`
`96`	`96`	`{`
`97`		`- this->url_normalized += "/" + parts[i];`
	`97`	`+ url_normalized += "/" + parts[i];`
`98`	`98`	`}`
`99`		`- this->url_pieces.push_back(parts[i]);`
	`99`	`+ url_pieces.push_back(parts[i]);`
`100`	`100`
`101`	`101`	`continue;`
`102`	`102`	`}`
`@@ -105,23 +105,23 @@ http_endpoint::http_endpoint`
`105`	`105`	`throw std::invalid_argument("Bad URL format");`
`106`	`106`
`107`	`107`	`std::string::size_type bar = parts[i].find_first_of('\|');`
`108`		`- this->url_pars.push_back(parts[i].substr(1, bar != string::npos ? bar - 1 : parts[i].size() - 2));`
`109`		`- this->url_normalized += (first ? "" : "/") + (bar != string::npos ? parts[i].substr(bar + 1, parts[i].size() - bar - 2) : "([^\\/]+)");`
	`108`	`+ url_pars.push_back(parts[i].substr(1, bar != string::npos ? bar - 1 : parts[i].size() - 2));`
	`109`	`+ url_normalized += (first ? "" : "/") + (bar != string::npos ? parts[i].substr(bar + 1, parts[i].size() - bar - 2) : "([^\\/]+)");`
`110`	`110`
`111`	`111`	`first = false;`
`112`	`112`
`113`		`- this->chunk_positions.push_back(i);`
	`113`	`+ chunk_positions.push_back(i);`
`114`	`114`
`115`		`- this->url_pieces.push_back(parts[i]);`
	`115`	`+ url_pieces.push_back(parts[i]);`
`116`	`116`	`}`
`117`	`117`
`118`	`118`	`if(use_regex)`
`119`	`119`	`{`
`120`		`- this->url_normalized += "$";`
`121`		`- regcomp(&(this->re_url_normalized), url_normalized.c_str(),`
	`120`	`+ url_normalized += "$";`
	`121`	`+ regcomp(&re_url_normalized, url_normalized.c_str(),`
`122`	`122`	`REG_EXTENDED\|REG_ICASE\|REG_NOSUB`
`123`	`123`	`);`
`124`		`- this->reg_compiled = true;`
	`124`	`+ reg_compiled = true;`
`125`	`125`	`}`
`126`	`126`	`}`
`127`	`127`
`@@ -134,52 +134,52 @@ http_endpoint::http_endpoint(const http_endpoint& h):`
`134`	`134`	`family_url(h.family_url),`
`135`	`135`	`reg_compiled(h.reg_compiled)`
`136`	`136`	`{`
`137`		`- if(this->reg_compiled)`
`138`		`- regcomp(&(this->re_url_normalized), url_normalized.c_str(),`
	`137`	`+ if(reg_compiled)`
	`138`	`+ regcomp(&re_url_normalized, url_normalized.c_str(),`
`139`	`139`	`REG_EXTENDED\|REG_ICASE\|REG_NOSUB`
`140`	`140`	`);`
`141`	`141`	`}`
`142`	`142`
`143`	`143`	`http_endpoint& http_endpoint::operator =(const http_endpoint& h)`
`144`	`144`	`{`
`145`		`- this->url_complete = h.url_complete;`
`146`		`- this->url_normalized = h.url_normalized;`
`147`		`- this->family_url = h.family_url;`
`148`		`- this->reg_compiled = h.reg_compiled;`
`149`		`- if(this->reg_compiled)`
	`145`	`+ url_complete = h.url_complete;`
	`146`	`+ url_normalized = h.url_normalized;`
	`147`	`+ family_url = h.family_url;`
	`148`	`+ reg_compiled = h.reg_compiled;`
	`149`	`+ if(reg_compiled)`
`150`	`150`	`{`
`151`		`- regfree(&(this->re_url_normalized));`
	`151`	`+ regfree(&re_url_normalized);`
`152`	`152`
`153`		`- regcomp(&(this->re_url_normalized), url_normalized.c_str(),`
	`153`	`+ regcomp(&re_url_normalized, url_normalized.c_str(),`
`154`	`154`	`REG_EXTENDED\|REG_ICASE\|REG_NOSUB`
`155`	`155`	`);`
`156`	`156`	`}`
`157`		`- this->url_pars = h.url_pars;`
`158`		`- this->url_pieces = h.url_pieces;`
`159`		`- this->chunk_positions = h.chunk_positions;`
	`157`	`+ url_pars = h.url_pars;`
	`158`	`+ url_pieces = h.url_pieces;`
	`159`	`+ chunk_positions = h.chunk_positions;`
`160`	`160`	`return *this;`
`161`	`161`	`}`
`162`	`162`
`163`	`163`	`bool http_endpoint::operator <(const http_endpoint& b) const`
`164`	`164`	`{`
`165`		`- COMPARATOR(this->url_normalized, b.url_normalized, std::toupper);`
	`165`	`+ COMPARATOR(url_normalized, b.url_normalized, std::toupper);`
`166`	`166`	`}`
`167`	`167`
`168`	`168`	`bool http_endpoint::match(const http_endpoint& url) const`
`169`	`169`	`{`
`170`		`- if (!this->reg_compiled) throw std::invalid_argument("Cannot run match. Regex suppressed.");`
	`170`	`+ if (!reg_compiled) throw std::invalid_argument("Cannot run match. Regex suppressed.");`
`171`	`171`
`172`		`- if(!this->family_url \|\| url.url_pieces.size() < this->url_pieces.size())`
`173`		`- return regexec(&(this->re_url_normalized), url.url_complete.c_str(), 0, NULL, 0) == 0;`
	`172`	`+ if(!family_url \|\| url.url_pieces.size() < url_pieces.size())`
	`173`	`+ return regexec(&re_url_normalized, url.url_complete.c_str(), 0, NULL, 0) == 0;`
`174`	`174`
`175`	`175`	`string nn = "/";`
`176`	`176`	`bool first = true;`
`177`		`- for(unsigned int i = 0; i < this->url_pieces.size(); i++)`
	`177`	`+ for(unsigned int i = 0; i < url_pieces.size(); i++)`
`178`	`178`	`{`
`179`	`179`	`nn += (first ? "" : "/") + url.url_pieces[i];`
`180`	`180`	`first = false;`
`181`	`181`	`}`
`182`		`- return regexec(&(this->re_url_normalized), nn.c_str(), 0, NULL, 0) == 0;`
	`182`	`+ return regexec(&re_url_normalized, nn.c_str(), 0, NULL, 0) == 0;`
`183`	`183`	`}`
`184`	`184`
`185`	`185`	`};`
Original file line number	Diff line number	Diff line change
`@@ -70,7 +70,7 @@ int http_response::enqueue_response(MHD_Connection* connection, MHD_Response* re`
`70`	`70`
`71`	`71`	`void http_response::shoutCAST()`
`72`	`72`	`{`
`73`		`- this->response_code \|= http::http_utils::shoutcast_response;`
	`73`	`+ response_code \|= http::http_utils::shoutcast_response;`
`74`	`74`	`}`
`75`	`75`
`76`	`76`	`std::ostream &operator<< (std::ostream &os, const http_response &r)`
Original file line number	Diff line number	Diff line change
`@@ -517,26 +517,26 @@ bool ip_representation::operator <(const ip_representation& b) const`
`517`	`517`	`{`
`518`	`518`	`if (i == 10 \|\| i == 11) continue;`
`519`	`519`
`520`		`- if (CHECK_BIT(this->mask, i) && CHECK_BIT(b.mask, i))`
	`520`	`+ if (CHECK_BIT(mask, i) && CHECK_BIT(b.mask, i))`
`521`	`521`	`{`
`522`		`- this_score += (16 - i) * this->pieces[i];`
	`522`	`+ this_score += (16 - i) * pieces[i];`
`523`	`523`	`b_score += (16 - i) * b.pieces[i];`
`524`	`524`	`}`
`525`	`525`	`}`
`526`	`526`
`527`	`527`	`if (this_score == b_score &&`
`528`		`- ((this->pieces[10] == 0x00 \|\| this->pieces[10] == 0xFF) && (b.pieces[10] == 0x00 \|\| b.pieces[10] == 0xFF)) &&`
`529`		`- ((this->pieces[11] == 0x00 \|\| this->pieces[11] == 0xFF) && (b.pieces[11] == 0x00 \|\| b.pieces[11] == 0xFF))`
	`528`	`+ ((pieces[10] == 0x00 \|\| pieces[10] == 0xFF) && (b.pieces[10] == 0x00 \|\| b.pieces[10] == 0xFF)) &&`
	`529`	`+ ((pieces[11] == 0x00 \|\| pieces[11] == 0xFF) && (b.pieces[11] == 0x00 \|\| b.pieces[11] == 0xFF))`
`530`	`530`	`)`
`531`	`531`	`{`
`532`	`532`	`return false;`
`533`	`533`	`}`
`534`	`534`
`535`	`535`	`for (int i = 10; i < 12; i++)`
`536`	`536`	`{`
`537`		`- if (CHECK_BIT(this->mask, i) && CHECK_BIT(b.mask, i))`
	`537`	`+ if (CHECK_BIT(mask, i) && CHECK_BIT(b.mask, i))`
`538`	`538`	`{`
`539`		`- this_score += (16 - i) * this->pieces[i];`
	`539`	`+ this_score += (16 - i) * pieces[i];`
`540`	`540`	`b_score += (16 - i) * b.pieces[i];`
`541`	`541`	`}`
`542`	`542`	`}`
Original file line number	Diff line number	Diff line change
`@@ -62,7 +62,7 @@ class deferred_response : public string_response`
`62`	`62`
`63`	`63`	`MHD_Response* get_raw_response()`
`64`	`64`	`{`
`65`		`- return details::get_raw_response_helper((void*) this, &(this->cb));`
	`65`	`+ return details::get_raw_response_helper((void*) this, &cb);`
`66`	`66`	`}`
`67`	`67`
`68`	`68`	`private:`
Original file line number	Diff line number	Diff line change
`@@ -85,12 +85,12 @@ class http_endpoint`
`85`	`85`	`**/`
`86`	`86`	`const std::string& get_url_complete() const`
`87`	`87`	`{`
`88`		`- return this->url_complete;`
	`88`	`+ return url_complete;`
`89`	`89`	`}`
`90`	`90`
`91`	`91`	`const std::string& get_url_normalized() const`
`92`	`92`	`{`
`93`		`- return this->url_normalized;`
	`93`	`+ return url_normalized;`
`94`	`94`	`}`
`95`	`95`
`96`	`96`	`/**`
`@@ -99,7 +99,7 @@ class http_endpoint`
`99`	`99`	`**/`
`100`	`100`	`const std::vector<std::string>& get_url_pars() const`
`101`	`101`	`{`
`102`		`- return this->url_pars;`
	`102`	`+ return url_pars;`
`103`	`103`	`}`
`104`	`104`
`105`	`105`	`/**`
`@@ -108,7 +108,7 @@ class http_endpoint`
`108`	`108`	`**/`
`109`	`109`	`const std::vector<std::string>& get_url_pieces() const`
`110`	`110`	`{`
`111`		`- return this->url_pieces;`
	`111`	`+ return url_pieces;`
`112`	`112`	`}`
`113`	`113`
`114`	`114`	`/**`
`@@ -117,17 +117,17 @@ class http_endpoint`
`117`	`117`	`**/`
`118`	`118`	`const std::vector<int>& get_chunk_positions() const`
`119`	`119`	`{`
`120`		`- return this->chunk_positions;`
	`120`	`+ return chunk_positions;`
`121`	`121`	`}`
`122`	`122`
`123`	`123`	`const bool is_family_url() const`
`124`	`124`	`{`
`125`		`- return this->family_url;`
	`125`	`+ return family_url;`
`126`	`126`	`}`
`127`	`127`
`128`	`128`	`const bool is_regex_compiled() const`
`129`	`129`	`{`
`130`		`- return this->reg_compiled;`
	`130`	`+ return reg_compiled;`
`131`	`131`	`}`
`132`	`132`
`133`	`133`	`/**`
Original file line number	Diff line number	Diff line change
`@@ -76,7 +76,7 @@ class http_request`
`76`	`76`	`**/`
`77`	`77`	`const std::string& get_path() const`
`78`	`78`	`{`
`79`		`- return this->path;`
	`79`	`+ return path;`
`80`	`80`	`}`
`81`	`81`
`82`	`82`	`/**`
`@@ -85,7 +85,7 @@ class http_request`
`85`	`85`	`**/`
`86`	`86`	`const std::vector<std::string> get_path_pieces() const`
`87`	`87`	`{`
`88`		`- return http::http_utils::tokenize_url(this->path);`
	`88`	`+ return http::http_utils::tokenize_url(path);`
`89`	`89`	`}`
`90`	`90`
`91`	`91`	`/**`
`@@ -95,7 +95,7 @@ class http_request`
`95`	`95`	`**/`
`96`	`96`	`const std::string get_path_piece(int index) const`
`97`	`97`	`{`
`98`		`- std::vector<std::string> post_path = this->get_path_pieces();`
	`98`	`+ std::vector<std::string> post_path = get_path_pieces();`
`99`	`99`	`if(((int)(post_path.size())) > index)`
`100`	`100`	`return post_path[index];`
`101`	`101`	`return EMPTY;`
`@@ -107,7 +107,7 @@ class http_request`
`107`	`107`	`**/`
`108`	`108`	`const std::string& get_method() const`
`109`	`109`	`{`
`110`		`- return this->method;`
	`110`	`+ return method;`
`111`	`111`	`}`
`112`	`112`
`113`	`113`	`/**`
`@@ -167,7 +167,7 @@ class http_request`
`167`	`167`	`**/`
`168`	`168`	`const std::string& get_content() const`
`169`	`169`	`{`
`170`		`- return this->content;`
	`170`	`+ return content;`
`171`	`171`	`}`
`172`	`172`
`173`	`173`	`/**`
`@@ -190,7 +190,7 @@ class http_request`
`190`	`190`	`**/`
`191`	`191`	`const std::string& get_version() const`
`192`	`192`	`{`
`193`		`- return this->version;`
	`193`	`+ return version;`
`194`	`194`	`}`
`195`	`195`
`196`	`196`	`/**`
`@@ -264,7 +264,7 @@ class http_request`
`264`	`264`	`**/`
`265`	`265`	`void set_arg(const std::string& key, const std::string& value)`
`266`	`266`	`{`
`267`		`- this->args[key] = value.substr(0,content_size_limit);`
	`267`	`+ args[key] = value.substr(0,content_size_limit);`
`268`	`268`	`}`
`269`	`269`
`270`	`270`	`/**`
`@@ -275,8 +275,7 @@ class http_request`
`275`	`275`	`**/`
`276`	`276`	`void set_arg(const char* key, const char* value, size_t size)`
`277`	`277`	`{`
`278`		`- this->args[key] = std::string(value,`
`279`		`- std::min(size, content_size_limit));`
	`278`	`+ args[key] = std::string(value, std::min(size, content_size_limit));`
`280`	`279`	`}`
`281`	`280`
`282`	`281`	`/**`