diff --git a/crow/include/crow/query_string.h b/crow/include/crow/query_string.h
index 5e28e18..0606994 100644
--- a/crow/include/crow/query_string.h
+++ b/crow/include/crow/query_string.h
@@ -12,45 +12,45 @@
 // https://github.com/bartgrantham/qs_parse
 // ----------------------------------------------------------------------------
 /*  Similar to strncmp, but handles URL-encoding for either string  */
-int qs_strncmp(const char* s, const char* qs, size_t n);
+int qsStrncmp(const char* s, const char* qs, size_t n);
 
 /*  Finds the beginning of each key/value pair and stores a pointer in qs_kv.
  *  Also decodes the value portion of the k/v pair *in-place*.  In a future
  *  enhancement it will also have a compile-time option of sorting qs_kv
  *  alphabetically by key.  */
-int qs_parse(char* qs, char* qs_kv[], int qs_kv_size);
+int qsParse(char* qs, char* qs_kv[], int qs_kv_size);
 
 /*  Used by qs_parse to decode the value portion of a k/v pair  */
-int qs_decode(char* qs);
+int qsDecode(char* qs);
 
 /*  Looks up the value according to the key on a pre-processed query string
  *  A future enhancement will be a compile-time option to look up the key
  *  in a pre-sorted qs_kv array via a binary search.  */
 // char * qs_k2v(const char * key, char * qs_kv[], int qs_kv_size);
-char* qs_k2v(const char* key, char* const* qs_kv, int qs_kv_size, int nth);
+char* qsK2v(const char* key, char* const* qs_kv, int qs_kv_size, int nth);
 
 /*  Non-destructive lookup of value, based on key.  User provides the
  *  destinaton string and length.  */
-char* qs_scanvalue(const char* key, const char* qs, char* val, size_t val_len);
+char* qsScanvalue(const char* key, const char* qs, char* val, size_t val_len);
 
 // TODO: implement sorting of the qs_kv array; for now ensure it's not compiled
 #undef _qsSORTING
 
 // isxdigit _is_ available in <ctype.h>, but let's avoid another header instead
-#define CROW_QS_ISHEX(x)                                        \
+#define BMCWEB_QS_ISHEX(x)                                      \
   ((((x) >= '0' && (x) <= '9') || ((x) >= 'A' && (x) <= 'F') || \
     ((x) >= 'a' && (x) <= 'f'))                                 \
        ? 1                                                      \
        : 0)
-#define CROW_QS_HEX2DEC(x)                   \
+#define BMCWEB_QS_HEX2DEC(x)                 \
   (((x) >= '0' && (x) <= '9')                \
        ? (x)-48                              \
        : ((x) >= 'A' && (x) <= 'F') ? (x)-55 \
                                     : ((x) >= 'a' && (x) <= 'f') ? (x)-87 : 0)
-#define CROW_QS_ISQSCHR(x) \
+#define BMCWEB_QS_ISQSCHR(x) \
   ((((x) == '=') || ((x) == '#') || ((x) == '&') || ((x) == '\0')) ? 0 : 1)
 
-inline int qs_strncmp(const char* s, const char* qs, size_t n) {
+inline int qsStrncmp(const char* s, const char* qs, size_t n) {
   int i = 0;
   unsigned char u1, u2, unyb, lnyb;
 
@@ -58,10 +58,10 @@
     u1 = static_cast<unsigned char>(*s++);
     u2 = static_cast<unsigned char>(*qs++);
 
-    if (!CROW_QS_ISQSCHR(u1)) {
+    if (!BMCWEB_QS_ISQSCHR(u1)) {
       u1 = '\0';
     }
-    if (!CROW_QS_ISQSCHR(u2)) {
+    if (!BMCWEB_QS_ISQSCHR(u2)) {
       u2 = '\0';
     }
 
@@ -72,8 +72,8 @@
     {
       unyb = static_cast<unsigned char>(*s++);
       lnyb = static_cast<unsigned char>(*s++);
-      if (CROW_QS_ISHEX(unyb) && CROW_QS_ISHEX(lnyb)) {
-        u1 = (CROW_QS_HEX2DEC(unyb) * 16) + CROW_QS_HEX2DEC(lnyb);
+      if (BMCWEB_QS_ISHEX(unyb) && BMCWEB_QS_ISHEX(lnyb)) {
+        u1 = (BMCWEB_QS_HEX2DEC(unyb) * 16) + BMCWEB_QS_HEX2DEC(lnyb);
       } else {
         u1 = '\0';
       }
@@ -86,8 +86,8 @@
     {
       unyb = static_cast<unsigned char>(*qs++);
       lnyb = static_cast<unsigned char>(*qs++);
-      if (CROW_QS_ISHEX(unyb) && CROW_QS_ISHEX(lnyb)) {
-        u2 = (CROW_QS_HEX2DEC(unyb) * 16) + CROW_QS_HEX2DEC(lnyb);
+      if (BMCWEB_QS_ISHEX(unyb) && BMCWEB_QS_ISHEX(lnyb)) {
+        u2 = (BMCWEB_QS_HEX2DEC(unyb) * 16) + BMCWEB_QS_HEX2DEC(lnyb);
       } else {
         u2 = '\0';
       }
@@ -101,37 +101,37 @@
     }
     i++;
   }
-  if (CROW_QS_ISQSCHR(*qs)) {
+  if (BMCWEB_QS_ISQSCHR(*qs)) {
     return -1;
   } else {
     return 0;
   }
 }
 
-inline int qs_parse(char* qs, char* qs_kv[], int qs_kv_size) {
+inline int qsParse(char* qs, char* qs_kv[], int qs_kv_size) {
   int i, j;
-  char* substr_ptr;
+  char* substrPtr;
 
   for (i = 0; i < qs_kv_size; i++) {
     qs_kv[i] = NULL;
   }
 
   // find the beginning of the k/v substrings or the fragment
-  substr_ptr = qs + strcspn(qs, "?#");
-  if (substr_ptr[0] != '\0') {
-    substr_ptr++;
+  substrPtr = qs + strcspn(qs, "?#");
+  if (substrPtr[0] != '\0') {
+    substrPtr++;
   } else {
     return 0;  // no query or fragment
   }
 
   i = 0;
   while (i < qs_kv_size) {
-    qs_kv[i] = substr_ptr;
-    j = strcspn(substr_ptr, "&");
-    if (substr_ptr[j] == '\0') {
+    qs_kv[i] = substrPtr;
+    j = strcspn(substrPtr, "&");
+    if (substrPtr[j] == '\0') {
       break;
     }
-    substr_ptr += j + 1;
+    substrPtr += j + 1;
     i++;
   }
   i++;  // x &'s -> means x iterations of this loop -> means *x+1* k/v pairs
@@ -139,12 +139,12 @@
   // we only decode the values in place, the keys could have '='s in them
   // which will hose our ability to distinguish keys from values later
   for (j = 0; j < i; j++) {
-    substr_ptr = qs_kv[j] + strcspn(qs_kv[j], "=&#");
-    if (substr_ptr[0] == '&' ||
-        substr_ptr[0] == '\0') {  // blank value: skip decoding
-      substr_ptr[0] = '\0';
+    substrPtr = qs_kv[j] + strcspn(qs_kv[j], "=&#");
+    if (substrPtr[0] == '&' ||
+        substrPtr[0] == '\0') {  // blank value: skip decoding
+      substrPtr[0] = '\0';
     } else {
-      qs_decode(++substr_ptr);
+      qsDecode(++substrPtr);
     }
   }
 
@@ -155,19 +155,20 @@
   return i;
 }
 
-inline int qs_decode(char* qs) {
+inline int qsDecode(char* qs) {
   int i = 0, j = 0;
 
-  while (CROW_QS_ISQSCHR(qs[j])) {
+  while (BMCWEB_QS_ISQSCHR(qs[j])) {
     if (qs[j] == '+') {
       qs[i] = ' ';
     } else if (qs[j] == '%')  // easier/safer than scanf
     {
-      if (!CROW_QS_ISHEX(qs[j + 1]) || !CROW_QS_ISHEX(qs[j + 2])) {
+      if (!BMCWEB_QS_ISHEX(qs[j + 1]) || !BMCWEB_QS_ISHEX(qs[j + 2])) {
         qs[i] = '\0';
         return i;
       }
-      qs[i] = (CROW_QS_HEX2DEC(qs[j + 1]) * 16) + CROW_QS_HEX2DEC(qs[j + 2]);
+      qs[i] =
+          (BMCWEB_QS_HEX2DEC(qs[j + 1]) * 16) + BMCWEB_QS_HEX2DEC(qs[j + 2]);
       j += 2;
     } else {
       qs[i] = qs[j];
@@ -180,19 +181,19 @@
   return i;
 }
 
-inline char* qs_k2v(const char* key, char* const* qs_kv, int qs_kv_size,
-                    int nth = 0) {
+inline char* qsK2v(const char* key, char* const* qs_kv, int qs_kv_size,
+                   int nth = 0) {
   int i;
-  size_t key_len, skip;
+  size_t keyLen, skip;
 
-  key_len = strlen(key);
+  keyLen = strlen(key);
 
 #ifdef _qsSORTING
 // TODO: binary search for key in the sorted qs_kv
 #else   // _qsSORTING
   for (i = 0; i < qs_kv_size; i++) {
     // we rely on the unambiguous '=' to find the value in our k/v pair
-    if (qs_strncmp(key, qs_kv[i], key_len) == 0) {
+    if (qsStrncmp(key, qs_kv[i], keyLen) == 0) {
       skip = strcspn(qs_kv[i], "=");
       if (qs_kv[i][skip] == '=') {
         skip++;
@@ -210,9 +211,9 @@
   return NULL;
 }
 
-inline char* qs_scanvalue(const char* key, const char* qs, char* val,
-                          size_t val_len) {
-  size_t i, key_len;
+inline char* qsScanvalue(const char* key, const char* qs, char* val,
+                         size_t val_len) {
+  size_t i, keyLen;
   const char* tmp;
 
   // find the beginning of the k/v substrings
@@ -220,9 +221,9 @@
     qs = tmp + 1;
   }
 
-  key_len = strlen(key);
+  keyLen = strlen(key);
   while (qs[0] != '#' && qs[0] != '\0') {
-    if (qs_strncmp(key, qs, key_len) == 0) {
+    if (qsStrncmp(key, qs, keyLen) == 0) {
       break;
     }
     qs += strcspn(qs, "&") + 1;
@@ -237,7 +238,7 @@
     qs++;
     i = strcspn(qs, "&=#");
     strncpy(val, qs, (val_len - 1) < (i + 1) ? (val_len - 1) : (i + 1));
-    qs_decode(val);
+    qsDecode(val);
   } else {
     if (val_len > 0) {
       val[0] = '\0';
@@ -250,83 +251,81 @@
 // ----------------------------------------------------------------------------
 
 namespace crow {
-class query_string {
+class QueryString {
  public:
-  static const int MAX_KEY_VALUE_PAIRS_COUNT = 256;
+  static const int maxKeyValuePairsCount = 256;
 
-  query_string() = default;
+  QueryString() = default;
 
-  query_string(const query_string& qs) : url_(qs.url_) {
-    for (auto p : qs.key_value_pairs_) {
-      key_value_pairs_.push_back(
-          const_cast<char*>(p - qs.url_.c_str() + url_.c_str()));
+  QueryString(const QueryString& qs) : url(qs.url) {
+    for (auto p : qs.keyValuePairs) {
+      keyValuePairs.push_back(
+          const_cast<char*>(p - qs.url.c_str() + url.c_str()));
     }
   }
 
-  query_string& operator=(const query_string& qs) {
-    url_ = qs.url_;
-    key_value_pairs_.clear();
-    for (auto p : qs.key_value_pairs_) {
-      key_value_pairs_.push_back(
-          const_cast<char*>(p - qs.url_.c_str() + url_.c_str()));
+  QueryString& operator=(const QueryString& qs) {
+    url = qs.url;
+    keyValuePairs.clear();
+    for (auto p : qs.keyValuePairs) {
+      keyValuePairs.push_back(
+          const_cast<char*>(p - qs.url.c_str() + url.c_str()));
     }
     return *this;
   }
 
-  query_string& operator=(query_string&& qs) {
-    key_value_pairs_ = std::move(qs.key_value_pairs_);
-    auto* old_data = const_cast<char*>(qs.url_.c_str());
-    url_ = std::move(qs.url_);
-    for (auto& p : key_value_pairs_) {
-      p += const_cast<char*>(url_.c_str()) - old_data;
+  QueryString& operator=(QueryString&& qs) {
+    keyValuePairs = std::move(qs.keyValuePairs);
+    auto* oldData = const_cast<char*>(qs.url.c_str());
+    url = std::move(qs.url);
+    for (auto& p : keyValuePairs) {
+      p += const_cast<char*>(url.c_str()) - oldData;
     }
     return *this;
   }
 
-  explicit query_string(std::string url) : url_(std::move(url)) {
-    if (url_.empty()) {
+  explicit QueryString(std::string url) : url(std::move(url)) {
+    if (url.empty()) {
       return;
     }
 
-    key_value_pairs_.resize(MAX_KEY_VALUE_PAIRS_COUNT);
+    keyValuePairs.resize(maxKeyValuePairsCount);
 
-    int count =
-        qs_parse(&url_[0], &key_value_pairs_[0], MAX_KEY_VALUE_PAIRS_COUNT);
-    key_value_pairs_.resize(count);
+    int count = qsParse(&url[0], &keyValuePairs[0], maxKeyValuePairsCount);
+    keyValuePairs.resize(count);
   }
 
   void clear() {
-    key_value_pairs_.clear();
-    url_.clear();
+    keyValuePairs.clear();
+    url.clear();
   }
 
-  friend std::ostream& operator<<(std::ostream& os, const query_string& qs) {
+  friend std::ostream& operator<<(std::ostream& os, const QueryString& qs) {
     os << "[ ";
-    for (size_t i = 0; i < qs.key_value_pairs_.size(); ++i) {
+    for (size_t i = 0; i < qs.keyValuePairs.size(); ++i) {
       if (i != 0u) {
         os << ", ";
       }
-      os << qs.key_value_pairs_[i];
+      os << qs.keyValuePairs[i];
     }
     os << " ]";
     return os;
   }
 
   char* get(const std::string& name) const {
-    char* ret =
-        qs_k2v(name.c_str(), key_value_pairs_.data(), key_value_pairs_.size());
+    char* ret = qsK2v(name.c_str(), keyValuePairs.data(), keyValuePairs.size());
     return ret;
   }
 
-  std::vector<char*> get_list(const std::string& name) const {
+  std::vector<char*> getList(const std::string& name) const {
     std::vector<char*> ret;
     std::string plus = name + "[]";
     char* element = nullptr;
 
     int count = 0;
     while (1) {
-      element = qs_k2v(plus.c_str(), key_value_pairs_.data(),
-                       key_value_pairs_.size(), count++);
+      element = qsK2v(plus.c_str(), keyValuePairs.data(), keyValuePairs.size(),
+                      count++);
       if (element == nullptr) {
         break;
       }
@@ -336,8 +335,8 @@
   }
 
  private:
-  std::string url_;
-  std::vector<char*> key_value_pairs_;
+  std::string url;
+  std::vector<char*> keyValuePairs;
 };
 
 }  // namespace crow