From 06842721d7da53a2235e6e4071760588ec285f90 Mon Sep 17 00:00:00 2001
From: Antony Woods <acron1@gmail.com>
Date: Tue, 14 Oct 2014 09:48:35 +0100
Subject: Wrapped qs_parse as query_string and added tests

---
 include/query_string.h | 305 +++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 305 insertions(+)
 create mode 100644 include/query_string.h

(limited to 'include/query_string.h')

diff --git a/include/query_string.h b/include/query_string.h
new file mode 100644
index 0000000..5a42782
--- /dev/null
+++ b/include/query_string.h
@@ -0,0 +1,305 @@
+#pragma once
+
+#include <stdio.h>
+#include <string>
+
+using namespace std;
+
+// ----------------------------------------------------------------------------
+// qs_parse (modified)
+// 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, register 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);
+
+
+/*  Used by qs_parse to decode the value portion of a k/v pair  */
+int qs_decode(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);
+
+
+/*  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);
+
+// 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 ISHEX(x)    ((((x)>='0'&&(x)<='9') || ((x)>='A'&&(x)<='F') || ((x)>='a'&&(x)<='f')) ? 1 : 0)
+#define HEX2DEC(x)  (((x)>='0'&&(x)<='9') ? (x)-48 : ((x)>='A'&&(x)<='F') ? (x)-55 : ((x)>='a'&&(x)<='f') ? (x)-87 : 0)
+#define ISQSCHR(x) ((((x)=='=')||((x)=='#')||((x)=='&')||((x)=='\0')) ? 0 : 1)
+
+int qs_strncmp(const char * s, const char * qs, register size_t n)
+{
+    int i=0;
+    register unsigned char u1, u2, unyb, lnyb;
+
+    while(n-- > 0)
+    {
+        u1 = (unsigned char) *s++;
+        u2 = (unsigned char) *qs++;
+
+        if ( ! ISQSCHR(u1) ) {  u1 = '\0';  }
+        if ( ! ISQSCHR(u2) ) {  u2 = '\0';  }
+
+        if ( u1 == '+' ) {  u1 = ' ';  }
+        if ( u1 == '%' ) // easier/safer than scanf
+        {
+            unyb = (unsigned char) *s++;
+            lnyb = (unsigned char) *s++;
+            if ( ISHEX(unyb) && ISHEX(lnyb) )
+                u1 = (HEX2DEC(unyb) * 16) + HEX2DEC(lnyb);
+            else
+                u1 = '\0';
+        }
+
+        if ( u2 == '+' ) {  u2 = ' ';  }
+        if ( u2 == '%' ) // easier/safer than scanf
+        {
+            unyb = (unsigned char) *qs++;
+            lnyb = (unsigned char) *qs++;
+            if ( ISHEX(unyb) && ISHEX(lnyb) )
+                u2 = (HEX2DEC(unyb) * 16) + HEX2DEC(lnyb);
+            else
+                u2 = '\0';
+        }
+
+        if ( u1 != u2 )
+            return u1 - u2;
+        if ( u1 == '\0' )
+            return 0;
+        i++;
+    }
+    if ( ISQSCHR(*qs) )
+        return -1;
+    else
+        return 0;
+}
+
+
+int qs_parse(char * qs, char * qs_kv[], int qs_kv_size)
+{
+    int i, j;
+    char * substr_ptr;
+
+    for(i=0; i<qs_kv_size; i++)  qs_kv[i] = NULL;
+
+    // find the beginning of the k/v substrings
+    if ( (substr_ptr = strchr(qs, '?')) != NULL )
+        substr_ptr++;
+    else
+        substr_ptr = qs;
+
+    i=0;
+    while(i<qs_kv_size)
+    {
+        qs_kv[i] = substr_ptr;
+        j = strcspn(substr_ptr, "&");
+        if ( substr_ptr[j] == '\0' ) {  break;  }
+        substr_ptr += j + 1;
+        i++;
+    }
+    i++;  // x &'s -> means x iterations of this loop -> means *x+1* k/v pairs
+
+    // 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] == '&' )  // blank value: skip decoding
+            substr_ptr[0] = '\0';
+        else
+            qs_decode(++substr_ptr);
+    }
+
+#ifdef _qsSORTING
+// TODO: qsort qs_kv, using qs_strncmp() for the comparison
+#endif
+
+    return i;
+}
+
+
+int qs_decode(char * qs)
+{
+    int i=0, j=0;
+
+    while( ISQSCHR(qs[j]) )
+    {
+        if ( qs[j] == '+' ) {  qs[i] = ' ';  }
+        else if ( qs[j] == '%' ) // easier/safer than scanf
+        {
+            if ( ! ISHEX(qs[j+1]) || ! ISHEX(qs[j+2]) )
+            {
+                qs[i] = '\0';
+                return i;
+            }
+            qs[i] = (HEX2DEC(qs[j+1]) * 16) + HEX2DEC(qs[j+2]);
+            j+=2;
+        }
+        else
+        {
+            qs[i] = qs[j];
+        }
+        i++;  j++;
+    }
+    qs[i] = '\0';
+
+    return i;
+}
+
+
+char * qs_k2v(const char * key, char * const * qs_kv, int qs_kv_size, int nth = 0)
+{
+    int i;
+    size_t key_len, skip;
+
+    key_len = 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 )
+        {
+            skip = strcspn(qs_kv[i], "=");
+            if ( qs_kv[i][skip] == '=' )
+                skip++;
+            // return (zero-char value) ? ptr to trailing '\0' : ptr to value
+            if(nth == 0)
+                return qs_kv[i] + skip;
+            else 
+                --nth;
+        }
+    }
+#endif  // _qsSORTING
+
+    return NULL;
+}
+
+
+char * qs_scanvalue(const char * key, const char * qs, char * val, size_t val_len)
+{
+    size_t i, key_len;
+    const char * tmp;
+
+    // find the beginning of the k/v substrings
+    if ( (tmp = strchr(qs, '?')) != NULL )
+        qs = tmp + 1;
+
+    key_len = strlen(key);
+    while(qs[0] != '#' && qs[0] != '\0')
+    {
+        if ( qs_strncmp(key, qs, key_len) == 0 )
+            break;
+        qs += strcspn(qs, "&") + 1;
+    }
+
+    if ( qs[0] == '\0' ) return NULL;
+
+    qs += strcspn(qs, "=&#");
+    if ( qs[0] == '=' )
+    {
+        qs++;
+        i = strcspn(qs, "&=#");
+        strncpy(val, qs, (val_len-1)<(i+1) ? (val_len-1) : (i+1));
+        qs_decode(val);
+    }
+    else
+    {
+        if ( val_len > 0 )
+            val[0] = '\0';
+    }
+
+    return val;
+}
+// ----------------------------------------------------------------------------
+
+// TODO to save allocs, capping url size to 2048 seems sane and reasonable but
+// crow should *technically* return a 413 if a URL is longer than this.
+#define MAX_URL_SIZE (2048)
+
+#define NUM_KV_PAIRS (256)
+#define VAL_SIZE (256)
+
+namespace crow 
+{
+    class query_string
+    {
+    public:
+        query_string()
+        {
+
+        }
+        query_string(std::string url)
+        {
+            if(url.length() <= MAX_URL_SIZE) {
+                memset(_url, 0, MAX_URL_SIZE); // overkill?            
+                memcpy(_url, url.c_str(), url.length());
+            }
+            _kv_size = qs_parse(_url, _kv_pairs, NUM_KV_PAIRS);
+        }
+        void clear() {
+            _url[0] = 0;
+        }
+
+        friend ostream& operator<<(ostream& os, const query_string& qs)
+        {
+            os << "[ ";
+            for(int i = 0; i < qs._kv_size; ++i) {
+                os << qs._kv_pairs[i];
+                if((i + 1) < qs._kv_size) {
+                    os << ", ";
+                }
+            }
+            os << " ]";
+            return os;
+
+        }
+
+        char* get (const string name) const
+        {
+            char* ret = qs_k2v(name.c_str(), _kv_pairs, _kv_size);
+            return ret != 0 ? ret : nullptr;
+        }
+
+        vector<char*> get_list (const string name) const
+        {
+            vector<char*> ret;
+            string plus = name + "[]";            
+            char* tmp = nullptr;
+            int count = 0;
+            do
+            {
+                tmp = qs_k2v(plus.c_str(), _kv_pairs, _kv_size, count++);
+                if(tmp != nullptr) {
+                    ret.push_back(tmp);
+                }
+            } while(tmp != nullptr);
+            return move(ret);
+        }
+
+
+    private:
+        char    _url[MAX_URL_SIZE];
+        char*   _kv_pairs[NUM_KV_PAIRS];
+        int     _kv_size;
+    };
+
+} // end namespace
\ No newline at end of file
-- 
cgit v1.2.3-54-g00ecf


From 3a2d22dfe068553931ae86d0477eac3d07aa4668 Mon Sep 17 00:00:00 2001
From: Antony Woods <acron1@gmail.com>
Date: Wed, 22 Oct 2014 09:34:30 +0100
Subject: Removed instance of 'using namespace std'

---
 include/logging.h      | 14 ++++++--------
 include/query_string.h |  8 +++-----
 2 files changed, 9 insertions(+), 13 deletions(-)

(limited to 'include/query_string.h')

diff --git a/include/logging.h b/include/logging.h
index 8f5b833..ad1f4bc 100644
--- a/include/logging.h
+++ b/include/logging.h
@@ -9,8 +9,6 @@
 
 #include "settings.h"
 
-using namespace std;
-
 namespace crow
 {
     enum class LogLevel
@@ -24,12 +22,12 @@ namespace crow
 
     class ILogHandler {
         public:
-            virtual void log(string message, LogLevel level) = 0;
+            virtual void log(std::string message, LogLevel level) = 0;
     };
 
     class CerrLogHandler : public ILogHandler {
         public:
-            void log(string message, LogLevel level) override {
+            void log(std::string message, LogLevel level) override {
                 cerr << message;
             }
     };
@@ -38,18 +36,18 @@ namespace crow
 
         private:
             //
-            static string timestamp()
+            static std::string timestamp()
             {
                 char date[32];
                   time_t t = time(0);
                   strftime(date, sizeof(date), "%Y-%m-%d %H:%M:%S", gmtime(&t));
-                  return string(date);
+                  return std::string(date);
             }
 
         public:
 
 
-            logger(string prefix, LogLevel level) : level_(level) {
+            logger(std::string prefix, LogLevel level) : level_(level) {
     #ifdef CROW_ENABLE_LOGGING
                     stringstream_ << "(" << timestamp() << ") [" << prefix << "] ";
     #endif
@@ -104,7 +102,7 @@ namespace crow
             }
 
             //
-            ostringstream stringstream_;
+            std::ostringstream stringstream_;
             LogLevel level_;
     };
 }
diff --git a/include/query_string.h b/include/query_string.h
index 5a42782..afc112e 100644
--- a/include/query_string.h
+++ b/include/query_string.h
@@ -3,8 +3,6 @@
 #include <stdio.h>
 #include <string>
 
-using namespace std;
-
 // ----------------------------------------------------------------------------
 // qs_parse (modified)
 // https://github.com/bartgrantham/qs_parse
@@ -273,16 +271,16 @@ namespace crow
 
         }
 
-        char* get (const string name) const
+        char* get (const std::string name) const
         {
             char* ret = qs_k2v(name.c_str(), _kv_pairs, _kv_size);
             return ret != 0 ? ret : nullptr;
         }
 
-        vector<char*> get_list (const string name) const
+        vector<char*> get_list (const std::string name) const
         {
             vector<char*> ret;
-            string plus = name + "[]";            
+            std::string plus = name + "[]";            
             char* tmp = nullptr;
             int count = 0;
             do
-- 
cgit v1.2.3-54-g00ecf


From ada303970732f00e2d3017b726effad65d27a4d2 Mon Sep 17 00:00:00 2001
From: Antony Woods <acron1@gmail.com>
Date: Wed, 22 Oct 2014 09:40:33 +0100
Subject: Fixed compiler errors and inlines some of the qs_parse functions

---
 amalgamate/crow_all.h  | 40 ++++++++++++++++++----------------------
 examples/example.cpp   |  2 +-
 include/logging.h      |  4 ++--
 include/query_string.h | 16 ++++++++--------
 4 files changed, 29 insertions(+), 33 deletions(-)

(limited to 'include/query_string.h')

diff --git a/amalgamate/crow_all.h b/amalgamate/crow_all.h
index 43a3af4..743eb52 100644
--- a/amalgamate/crow_all.h
+++ b/amalgamate/crow_all.h
@@ -327,8 +327,6 @@ template <typename F, typename Set>
 #include <stdio.h>
 #include <string>
 
-using namespace std;
-
 // ----------------------------------------------------------------------------
 // qs_parse (modified)
 // https://github.com/bartgrantham/qs_parse
@@ -367,7 +365,7 @@ char * qs_scanvalue(const char * key, const char * qs, char * val, size_t val_le
 #define HEX2DEC(x)  (((x)>='0'&&(x)<='9') ? (x)-48 : ((x)>='A'&&(x)<='F') ? (x)-55 : ((x)>='a'&&(x)<='f') ? (x)-87 : 0)
 #define ISQSCHR(x) ((((x)=='=')||((x)=='#')||((x)=='&')||((x)=='\0')) ? 0 : 1)
 
-int qs_strncmp(const char * s, const char * qs, register size_t n)
+inline int qs_strncmp(const char * s, const char * qs, register size_t n)
 {
     int i=0;
     register unsigned char u1, u2, unyb, lnyb;
@@ -415,7 +413,7 @@ int qs_strncmp(const char * s, const char * qs, register size_t n)
 }
 
 
-int qs_parse(char * qs, char * qs_kv[], int qs_kv_size)
+inline int qs_parse(char * qs, char * qs_kv[], int qs_kv_size)
 {
     int i, j;
     char * substr_ptr;
@@ -458,7 +456,7 @@ int qs_parse(char * qs, char * qs_kv[], int qs_kv_size)
 }
 
 
-int qs_decode(char * qs)
+inline int qs_decode(char * qs)
 {
     int i=0, j=0;
 
@@ -487,7 +485,7 @@ int qs_decode(char * qs)
 }
 
 
-char * qs_k2v(const char * key, char * const * qs_kv, int qs_kv_size, int nth = 0)
+inline char * qs_k2v(const char * key, char * const * qs_kv, int qs_kv_size, int nth = 0)
 {
     int i;
     size_t key_len, skip;
@@ -518,7 +516,7 @@ char * qs_k2v(const char * key, char * const * qs_kv, int qs_kv_size, int nth =
 }
 
 
-char * qs_scanvalue(const char * key, const char * qs, char * val, size_t val_len)
+inline char * qs_scanvalue(const char * key, const char * qs, char * val, size_t val_len)
 {
     size_t i, key_len;
     const char * tmp;
@@ -583,7 +581,7 @@ namespace crow
             _url[0] = 0;
         }
 
-        friend ostream& operator<<(ostream& os, const query_string& qs)
+        friend std::ostream& operator<<(std::ostream& os, const query_string& qs)
         {
             os << "[ ";
             for(int i = 0; i < qs._kv_size; ++i) {
@@ -597,16 +595,16 @@ namespace crow
 
         }
 
-        char* get (const string name) const
+        char* get (const std::string name) const
         {
             char* ret = qs_k2v(name.c_str(), _kv_pairs, _kv_size);
             return ret != 0 ? ret : nullptr;
         }
 
-        vector<char*> get_list (const string name) const
+        std::vector<char*> get_list (const std::string name) const
         {
-            vector<char*> ret;
-            string plus = name + "[]";            
+            std::vector<char*> ret;
+            std::string plus = name + "[]";            
             char* tmp = nullptr;
             int count = 0;
             do
@@ -702,8 +700,6 @@ namespace crow
 
 
 
-using namespace std;
-
 namespace crow
 {
     enum class LogLevel
@@ -717,13 +713,13 @@ namespace crow
 
     class ILogHandler {
         public:
-            virtual void log(string message, LogLevel level) = 0;
+            virtual void log(std::string message, LogLevel level) = 0;
     };
 
     class CerrLogHandler : public ILogHandler {
         public:
-            void log(string message, LogLevel level) override {
-                cerr << message;
+            void log(std::string message, LogLevel level) override {
+                std::cerr << message;
             }
     };
 
@@ -731,18 +727,18 @@ namespace crow
 
         private:
             //
-            static string timestamp()
+            static std::string timestamp()
             {
                 char date[32];
                   time_t t = time(0);
                   strftime(date, sizeof(date), "%Y-%m-%d %H:%M:%S", gmtime(&t));
-                  return string(date);
+                  return std::string(date);
             }
 
         public:
 
 
-            logger(string prefix, LogLevel level) : level_(level) {
+            logger(std::string prefix, LogLevel level) : level_(level) {
     #ifdef CROW_ENABLE_LOGGING
                     stringstream_ << "(" << timestamp() << ") [" << prefix << "] ";
     #endif
@@ -751,7 +747,7 @@ namespace crow
             ~logger() {
     #ifdef CROW_ENABLE_LOGGING
                 if(level_ >= get_current_log_level()) {
-                    stringstream_ << endl;
+                    stringstream_ << std::endl;
                     get_handler_ref()->log(stringstream_.str(), level_);
                 }
     #endif
@@ -797,7 +793,7 @@ namespace crow
             }
 
             //
-            ostringstream stringstream_;
+            std::ostringstream stringstream_;
             LogLevel level_;
     };
 }
diff --git a/examples/example.cpp b/examples/example.cpp
index f9d006e..d7a4736 100644
--- a/examples/example.cpp
+++ b/examples/example.cpp
@@ -5,7 +5,7 @@
 
 class ExampleLogHandler : public crow::ILogHandler {
     public:
-        void log(string message, crow::LogLevel level) override {
+        void log(std::string message, crow::LogLevel level) override {
 //            cerr << "ExampleLogHandler -> " << message;
         }
 };
diff --git a/include/logging.h b/include/logging.h
index ad1f4bc..0d77071 100644
--- a/include/logging.h
+++ b/include/logging.h
@@ -28,7 +28,7 @@ namespace crow
     class CerrLogHandler : public ILogHandler {
         public:
             void log(std::string message, LogLevel level) override {
-                cerr << message;
+                std::cerr << message;
             }
     };
 
@@ -56,7 +56,7 @@ namespace crow
             ~logger() {
     #ifdef CROW_ENABLE_LOGGING
                 if(level_ >= get_current_log_level()) {
-                    stringstream_ << endl;
+                    stringstream_ << std::endl;
                     get_handler_ref()->log(stringstream_.str(), level_);
                 }
     #endif
diff --git a/include/query_string.h b/include/query_string.h
index afc112e..2d53ea0 100644
--- a/include/query_string.h
+++ b/include/query_string.h
@@ -41,7 +41,7 @@ char * qs_scanvalue(const char * key, const char * qs, char * val, size_t val_le
 #define HEX2DEC(x)  (((x)>='0'&&(x)<='9') ? (x)-48 : ((x)>='A'&&(x)<='F') ? (x)-55 : ((x)>='a'&&(x)<='f') ? (x)-87 : 0)
 #define ISQSCHR(x) ((((x)=='=')||((x)=='#')||((x)=='&')||((x)=='\0')) ? 0 : 1)
 
-int qs_strncmp(const char * s, const char * qs, register size_t n)
+inline int qs_strncmp(const char * s, const char * qs, register size_t n)
 {
     int i=0;
     register unsigned char u1, u2, unyb, lnyb;
@@ -89,7 +89,7 @@ int qs_strncmp(const char * s, const char * qs, register size_t n)
 }
 
 
-int qs_parse(char * qs, char * qs_kv[], int qs_kv_size)
+inline int qs_parse(char * qs, char * qs_kv[], int qs_kv_size)
 {
     int i, j;
     char * substr_ptr;
@@ -132,7 +132,7 @@ int qs_parse(char * qs, char * qs_kv[], int qs_kv_size)
 }
 
 
-int qs_decode(char * qs)
+inline int qs_decode(char * qs)
 {
     int i=0, j=0;
 
@@ -161,7 +161,7 @@ int qs_decode(char * qs)
 }
 
 
-char * qs_k2v(const char * key, char * const * qs_kv, int qs_kv_size, int nth = 0)
+inline char * qs_k2v(const char * key, char * const * qs_kv, int qs_kv_size, int nth = 0)
 {
     int i;
     size_t key_len, skip;
@@ -192,7 +192,7 @@ char * qs_k2v(const char * key, char * const * qs_kv, int qs_kv_size, int nth =
 }
 
 
-char * qs_scanvalue(const char * key, const char * qs, char * val, size_t val_len)
+inline char * qs_scanvalue(const char * key, const char * qs, char * val, size_t val_len)
 {
     size_t i, key_len;
     const char * tmp;
@@ -257,7 +257,7 @@ namespace crow
             _url[0] = 0;
         }
 
-        friend ostream& operator<<(ostream& os, const query_string& qs)
+        friend std::ostream& operator<<(std::ostream& os, const query_string& qs)
         {
             os << "[ ";
             for(int i = 0; i < qs._kv_size; ++i) {
@@ -277,9 +277,9 @@ namespace crow
             return ret != 0 ? ret : nullptr;
         }
 
-        vector<char*> get_list (const std::string name) const
+        std::vector<char*> get_list (const std::string name) const
         {
-            vector<char*> ret;
+            std::vector<char*> ret;
             std::string plus = name + "[]";            
             char* tmp = nullptr;
             int count = 0;
-- 
cgit v1.2.3-54-g00ecf


From 5c5c8fb4f59a1235e5093056814f7d272c049ab5 Mon Sep 17 00:00:00 2001
From: ipknHama <ipknhama@gmail.com>
Date: Fri, 24 Oct 2014 01:18:29 +0900
Subject: improve code quality

add missing includes (for amalgation)
remove register keyword (remove clang warning)
change define names to avoid name collision
remove url size limit from query_string.h
change MAX_KV_PAIRS define to const variable
add & to arguments
readability improve (although it requires additional allocation)
---
 amalgamate/crow_all.h  | 1958 ++++++++++++++++++++++++------------------------
 include/query_string.h |  103 +--
 2 files changed, 1036 insertions(+), 1025 deletions(-)

(limited to 'include/query_string.h')

diff --git a/amalgamate/crow_all.h b/amalgamate/crow_all.h
index 743eb52..2c7613d 100644
--- a/amalgamate/crow_all.h
+++ b/amalgamate/crow_all.h
@@ -1,476 +1,155 @@
 #pragma once
 
-#include <cstdint>
-#include <stdexcept>
-#include <tuple>
-#include <type_traits>
+#include <stdio.h>
+#include <string.h>
+#include <string>
+#include <vector>
+#include <iostream>
 
-namespace crow
-{
-	namespace black_magic
-	{
-		struct OutOfRange
-		{
-			OutOfRange(unsigned pos, unsigned length) {}
-		};
-		constexpr unsigned requires_in_range( unsigned i, unsigned len )
-		{
-			return i >= len ? throw OutOfRange(i, len) : i;
-		}
+// ----------------------------------------------------------------------------
+// qs_parse (modified)
+// 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);
 
-		class const_str
-		{
-			const char * const begin_;
-			unsigned size_;
 
-			public:
-			template< unsigned N >
-				constexpr const_str( const char(&arr)[N] ) : begin_(arr), size_(N - 1) {
-					static_assert( N >= 1, "not a string literal");
-				}
-			constexpr char operator[]( unsigned i ) const { 
-				return requires_in_range(i, size_), begin_[i]; 
-			}
+/*  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);
 
-			constexpr operator const char *() const { 
-				return begin_; 
-			}
 
-			constexpr const char* begin() const { return begin_; }
-			constexpr const char* end() const { return begin_ + size_; }
+/*  Used by qs_parse to decode the value portion of a k/v pair  */
+int qs_decode(char * qs);
 
-			constexpr unsigned size() const { 
-				return size_; 
-			}
-		};
 
+/*  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);
 
-		constexpr unsigned find_closing_tag(const_str s, unsigned p)
-		{
-			return s[p] == '>' ? p : find_closing_tag(s, p+1);
-		}
 
-        constexpr bool is_valid(const_str s, unsigned i = 0, int f = 0)
-        {
-            return 
-                i == s.size()
-                    ? f == 0 :
-                f < 0 || f >= 2
-                    ? false :
-                s[i] == '<'
-                    ? is_valid(s, i+1, f+1) :
-                s[i] == '>'
-                    ? is_valid(s, i+1, f-1) :
-                is_valid(s, i+1, f);
-        }
+/*  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);
 
-        constexpr bool is_equ_p(const char* a, const char* b, unsigned n)
-        {
-            return
-                *a == 0 && *b == 0 && n == 0 
-                    ? true :
-                (*a == 0 || *b == 0)
-                    ? false :
-                n == 0
-                    ? true :
-                *a != *b
-                    ? false :
-                is_equ_p(a+1, b+1, n-1);
-        }
+// TODO: implement sorting of the qs_kv array; for now ensure it's not compiled
+#undef _qsSORTING
 
-        constexpr bool is_equ_n(const_str a, unsigned ai, const_str b, unsigned bi, unsigned n)
-        {
-            return 
-                ai + n > a.size() || bi + n > b.size() 
-                    ? false :
-                n == 0 
-                    ? true : 
-                a[ai] != b[bi] 
-                    ? false : 
-                is_equ_n(a,ai+1,b,bi+1,n-1);
-        }
+// isxdigit _is_ available in <ctype.h>, but let's avoid another header instead
+#define CROW_QS_ISHEX(x)    ((((x)>='0'&&(x)<='9') || ((x)>='A'&&(x)<='F') || ((x)>='a'&&(x)<='f')) ? 1 : 0)
+#define CROW_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) ((((x)=='=')||((x)=='#')||((x)=='&')||((x)=='\0')) ? 0 : 1)
 
-        constexpr bool is_int(const_str s, unsigned i)
-        {
-            return is_equ_n(s, i, "<int>", 0, 5);
-        }
+inline int qs_strncmp(const char * s, const char * qs, size_t n)
+{
+    int i=0;
+    unsigned char u1, u2, unyb, lnyb;
 
-        constexpr bool is_uint(const_str s, unsigned i)
-        {
-            return is_equ_n(s, i, "<uint>", 0, 6);
-        }
+    while(n-- > 0)
+    {
+        u1 = (unsigned char) *s++;
+        u2 = (unsigned char) *qs++;
 
-        constexpr bool is_float(const_str s, unsigned i)
-        {
-            return is_equ_n(s, i, "<float>", 0, 7) ||
-                is_equ_n(s, i, "<double>", 0, 8);
-        }
+        if ( ! CROW_QS_ISQSCHR(u1) ) {  u1 = '\0';  }
+        if ( ! CROW_QS_ISQSCHR(u2) ) {  u2 = '\0';  }
 
-        constexpr bool is_str(const_str s, unsigned i)
+        if ( u1 == '+' ) {  u1 = ' ';  }
+        if ( u1 == '%' ) // easier/safer than scanf
         {
-            return is_equ_n(s, i, "<str>", 0, 5) ||
-                is_equ_n(s, i, "<string>", 0, 8);
+            unyb = (unsigned char) *s++;
+            lnyb = (unsigned char) *s++;
+            if ( CROW_QS_ISHEX(unyb) && CROW_QS_ISHEX(lnyb) )
+                u1 = (CROW_QS_HEX2DEC(unyb) * 16) + CROW_QS_HEX2DEC(lnyb);
+            else
+                u1 = '\0';
         }
 
-        constexpr bool is_path(const_str s, unsigned i)
+        if ( u2 == '+' ) {  u2 = ' ';  }
+        if ( u2 == '%' ) // easier/safer than scanf
         {
-            return is_equ_n(s, i, "<path>", 0, 6);
+            unyb = (unsigned char) *qs++;
+            lnyb = (unsigned char) *qs++;
+            if ( CROW_QS_ISHEX(unyb) && CROW_QS_ISHEX(lnyb) )
+                u2 = (CROW_QS_HEX2DEC(unyb) * 16) + CROW_QS_HEX2DEC(lnyb);
+            else
+                u2 = '\0';
         }
 
-        constexpr uint64_t get_parameter_tag(const_str s, unsigned p = 0)
-        {
-            return
-                p == s.size() 
-                    ?  0 :
-                s[p] == '<' ? ( 
-                    is_int(s, p)
-                        ? get_parameter_tag(s, find_closing_tag(s, p)) * 6 + 1 :
-                    is_uint(s, p)
-                        ? get_parameter_tag(s, find_closing_tag(s, p)) * 6 + 2 :
-                    is_float(s, p)
-                        ? get_parameter_tag(s, find_closing_tag(s, p)) * 6 + 3 :
-                    is_str(s, p)
-                        ? get_parameter_tag(s, find_closing_tag(s, p)) * 6 + 4 :
-                    is_path(s, p)
-                        ? get_parameter_tag(s, find_closing_tag(s, p)) * 6 + 5 :
-                    throw std::runtime_error("invalid parameter type")
-                    ) : 
-                get_parameter_tag(s, p+1);
-        }
+        if ( u1 != u2 )
+            return u1 - u2;
+        if ( u1 == '\0' )
+            return 0;
+        i++;
+    }
+    if ( CROW_QS_ISQSCHR(*qs) )
+        return -1;
+    else
+        return 0;
+}
 
-        template <typename ... T>
-        struct S
-        {
-            template <typename U>
-            using push = S<U, T...>;
-            template <typename U>
-            using push_back = S<T..., U>;
-            template <template<typename ... Args> class U>
-            using rebind = U<T...>;
-        };
-template <typename F, typename Set>
-        struct CallHelper;
-        template <typename F, typename ...Args>
-        struct CallHelper<F, S<Args...>>
-        {
-            template <typename F1, typename ...Args1, typename = 
-                decltype(std::declval<F1>()(std::declval<Args1>()...))
-                >
-            static char __test(int);
 
-            template <typename ...>
-            static int __test(...);
+inline int qs_parse(char * qs, char * qs_kv[], int qs_kv_size)
+{
+    int i, j;
+    char * substr_ptr;
 
-            static constexpr bool value = sizeof(__test<F, Args...>(0)) == sizeof(char);
-        };
+    for(i=0; i<qs_kv_size; i++)  qs_kv[i] = NULL;
 
+    // find the beginning of the k/v substrings
+    if ( (substr_ptr = strchr(qs, '?')) != NULL )
+        substr_ptr++;
+    else
+        substr_ptr = qs;
 
-        template <int N>
-        struct single_tag_to_type
-        {
-        };
+    i=0;
+    while(i<qs_kv_size)
+    {
+        qs_kv[i] = substr_ptr;
+        j = strcspn(substr_ptr, "&");
+        if ( substr_ptr[j] == '\0' ) {  break;  }
+        substr_ptr += j + 1;
+        i++;
+    }
+    i++;  // x &'s -> means x iterations of this loop -> means *x+1* k/v pairs
 
-        template <>
-        struct single_tag_to_type<1>
-        {
-            using type = int64_t;
-        };
+    // 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] == '&' )  // blank value: skip decoding
+            substr_ptr[0] = '\0';
+        else
+            qs_decode(++substr_ptr);
+    }
 
-        template <>
-        struct single_tag_to_type<2>
-        {
-            using type = uint64_t;
-        };
+#ifdef _qsSORTING
+// TODO: qsort qs_kv, using qs_strncmp() for the comparison
+#endif
 
-        template <>
-        struct single_tag_to_type<3>
-        {
-            using type = double;
-        };
-
-        template <>
-        struct single_tag_to_type<4>
-        {
-            using type = std::string;
-        };
-
-        template <>
-        struct single_tag_to_type<5>
-        {
-            using type = std::string;
-        };
-
-
-        template <uint64_t Tag> 
-        struct arguments
-        {
-            using subarguments = typename arguments<Tag/6>::type;
-            using type = 
-                typename subarguments::template push<typename single_tag_to_type<Tag%6>::type>;
-        };
-
-        template <> 
-        struct arguments<0>
-        {
-            using type = S<>;
-        };
-
-        template <typename ... T>
-        struct last_element_type
-        {
-            using type = typename std::tuple_element<sizeof...(T)-1, std::tuple<T...>>::type;
-        };
-
-
-        template <>
-        struct last_element_type<>
-        {
-        };
-
-
-        // from http://stackoverflow.com/questions/13072359/c11-compile-time-array-with-logarithmic-evaluation-depth
-        template<class T> using Invoke = typename T::type;
-
-        template<unsigned...> struct seq{ using type = seq; };
-
-        template<class S1, class S2> struct concat;
-
-        template<unsigned... I1, unsigned... I2>
-        struct concat<seq<I1...>, seq<I2...>>
-          : seq<I1..., (sizeof...(I1)+I2)...>{};
-
-        template<class S1, class S2>
-        using Concat = Invoke<concat<S1, S2>>;
-
-        template<unsigned N> struct gen_seq;
-        template<unsigned N> using GenSeq = Invoke<gen_seq<N>>;
-
-        template<unsigned N>
-        struct gen_seq : Concat<GenSeq<N/2>, GenSeq<N - N/2>>{};
-
-        template<> struct gen_seq<0> : seq<>{};
-        template<> struct gen_seq<1> : seq<0>{};
-
-        template <typename Seq, typename Tuple> 
-        struct pop_back_helper;
-
-        template <unsigned ... N, typename Tuple>
-        struct pop_back_helper<seq<N...>, Tuple>
-        {
-            template <template <typename ... Args> class U>
-            using rebind = U<typename std::tuple_element<N, Tuple>::type...>;
-        };
-
-        template <typename ... T>
-        struct pop_back //: public pop_back_helper<typename gen_seq<sizeof...(T)-1>::type, std::tuple<T...>>
-        {
-            template <template <typename ... Args> class U>
-            using rebind = typename pop_back_helper<typename gen_seq<sizeof...(T)-1>::type, std::tuple<T...>>::template rebind<U>;
-        };
-
-        template <>
-        struct pop_back<>
-        {
-            template <template <typename ... Args> class U>
-            using rebind = U<>;
-        };
-
-        // from http://stackoverflow.com/questions/2118541/check-if-c0x-parameter-pack-contains-a-type
-        template < typename Tp, typename... List >
-        struct contains : std::true_type {};
-
-        template < typename Tp, typename Head, typename... Rest >
-        struct contains<Tp, Head, Rest...>
-        : std::conditional< std::is_same<Tp, Head>::value,
-            std::true_type,
-            contains<Tp, Rest...>
-        >::type {};
-
-        template < typename Tp >
-        struct contains<Tp> : std::false_type {};
-
-        template <typename T>
-        struct empty_context
-        {
-        };
-	}
-}
-
-
-
-#pragma once
-// settings for crow
-// TODO - replace with runtime config. libucl?
-
-/* #ifdef - enables debug mode */
-#define CROW_ENABLE_DEBUG
-
-/* #ifdef - enables logging */
-#define CROW_ENABLE_LOGGING
-
-/* #define - specifies log level */
-/*
-	DEBUG 		= 0
-	INFO 		= 1
-	WARNING		= 2
-	ERROR		= 3
-	CRITICAL 	= 4
-
-    default to INFO
-*/
-#define CROW_LOG_LEVEL 1
-
-
-
-#pragma once
-
-#include <stdio.h>
-#include <string>
-
-// ----------------------------------------------------------------------------
-// qs_parse (modified)
-// 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, register 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);
-
-
-/*  Used by qs_parse to decode the value portion of a k/v pair  */
-int qs_decode(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);
-
-
-/*  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);
-
-// 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 ISHEX(x)    ((((x)>='0'&&(x)<='9') || ((x)>='A'&&(x)<='F') || ((x)>='a'&&(x)<='f')) ? 1 : 0)
-#define HEX2DEC(x)  (((x)>='0'&&(x)<='9') ? (x)-48 : ((x)>='A'&&(x)<='F') ? (x)-55 : ((x)>='a'&&(x)<='f') ? (x)-87 : 0)
-#define ISQSCHR(x) ((((x)=='=')||((x)=='#')||((x)=='&')||((x)=='\0')) ? 0 : 1)
-
-inline int qs_strncmp(const char * s, const char * qs, register size_t n)
-{
-    int i=0;
-    register unsigned char u1, u2, unyb, lnyb;
-
-    while(n-- > 0)
-    {
-        u1 = (unsigned char) *s++;
-        u2 = (unsigned char) *qs++;
-
-        if ( ! ISQSCHR(u1) ) {  u1 = '\0';  }
-        if ( ! ISQSCHR(u2) ) {  u2 = '\0';  }
-
-        if ( u1 == '+' ) {  u1 = ' ';  }
-        if ( u1 == '%' ) // easier/safer than scanf
-        {
-            unyb = (unsigned char) *s++;
-            lnyb = (unsigned char) *s++;
-            if ( ISHEX(unyb) && ISHEX(lnyb) )
-                u1 = (HEX2DEC(unyb) * 16) + HEX2DEC(lnyb);
-            else
-                u1 = '\0';
-        }
-
-        if ( u2 == '+' ) {  u2 = ' ';  }
-        if ( u2 == '%' ) // easier/safer than scanf
-        {
-            unyb = (unsigned char) *qs++;
-            lnyb = (unsigned char) *qs++;
-            if ( ISHEX(unyb) && ISHEX(lnyb) )
-                u2 = (HEX2DEC(unyb) * 16) + HEX2DEC(lnyb);
-            else
-                u2 = '\0';
-        }
-
-        if ( u1 != u2 )
-            return u1 - u2;
-        if ( u1 == '\0' )
-            return 0;
-        i++;
-    }
-    if ( ISQSCHR(*qs) )
-        return -1;
-    else
-        return 0;
-}
-
-
-inline int qs_parse(char * qs, char * qs_kv[], int qs_kv_size)
-{
-    int i, j;
-    char * substr_ptr;
-
-    for(i=0; i<qs_kv_size; i++)  qs_kv[i] = NULL;
-
-    // find the beginning of the k/v substrings
-    if ( (substr_ptr = strchr(qs, '?')) != NULL )
-        substr_ptr++;
-    else
-        substr_ptr = qs;
-
-    i=0;
-    while(i<qs_kv_size)
-    {
-        qs_kv[i] = substr_ptr;
-        j = strcspn(substr_ptr, "&");
-        if ( substr_ptr[j] == '\0' ) {  break;  }
-        substr_ptr += j + 1;
-        i++;
-    }
-    i++;  // x &'s -> means x iterations of this loop -> means *x+1* k/v pairs
-
-    // 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] == '&' )  // blank value: skip decoding
-            substr_ptr[0] = '\0';
-        else
-            qs_decode(++substr_ptr);
-    }
-
-#ifdef _qsSORTING
-// TODO: qsort qs_kv, using qs_strncmp() for the comparison
-#endif
-
-    return i;
-}
+    return i;
+}
 
 
 inline int qs_decode(char * qs)
 {
     int i=0, j=0;
 
-    while( ISQSCHR(qs[j]) )
+    while( CROW_QS_ISQSCHR(qs[j]) )
     {
         if ( qs[j] == '+' ) {  qs[i] = ' ';  }
         else if ( qs[j] == '%' ) // easier/safer than scanf
         {
-            if ( ! ISHEX(qs[j+1]) || ! ISHEX(qs[j+2]) )
+            if ( ! CROW_QS_ISHEX(qs[j+1]) || ! CROW_QS_ISHEX(qs[j+2]) )
             {
                 qs[i] = '\0';
                 return i;
             }
-            qs[i] = (HEX2DEC(qs[j+1]) * 16) + HEX2DEC(qs[j+2]);
+            qs[i] = (CROW_QS_HEX2DEC(qs[j+1]) * 16) + CROW_QS_HEX2DEC(qs[j+2]);
             j+=2;
         }
         else
@@ -553,269 +232,82 @@ inline char * qs_scanvalue(const char * key, const char * qs, char * val, size_t
 }
 // ----------------------------------------------------------------------------
 
-// TODO to save allocs, capping url size to 2048 seems sane and reasonable but
-// crow should *technically* return a 413 if a URL is longer than this.
-#define MAX_URL_SIZE (2048)
-
-#define NUM_KV_PAIRS (256)
-#define VAL_SIZE (256)
 
 namespace crow 
 {
     class query_string
     {
     public:
+        static const int MAX_KEY_VALUE_PAIRS_COUNT = 256;
+
         query_string()
         {
 
         }
+
         query_string(std::string url)
+            : url_(std::move(url))
         {
-            if(url.length() <= MAX_URL_SIZE) {
-                memset(_url, 0, MAX_URL_SIZE); // overkill?            
-                memcpy(_url, url.c_str(), url.length());
-            }
-            _kv_size = qs_parse(_url, _kv_pairs, NUM_KV_PAIRS);
+            if (url_.empty())
+                return;
+
+            key_value_pairs_.resize(MAX_KEY_VALUE_PAIRS_COUNT);
+
+            int count = qs_parse(&url_[0], &key_value_pairs_[0], MAX_KEY_VALUE_PAIRS_COUNT);
+            key_value_pairs_.resize(count);
         }
-        void clear() {
-            _url[0] = 0;
+
+        void clear() 
+        {
+            key_value_pairs_.clear();
+            url_.clear();
         }
 
         friend std::ostream& operator<<(std::ostream& os, const query_string& qs)
         {
             os << "[ ";
-            for(int i = 0; i < qs._kv_size; ++i) {
-                os << qs._kv_pairs[i];
-                if((i + 1) < qs._kv_size) {
+            for(size_t i = 0; i < qs.key_value_pairs_.size(); ++i) {
+                if (i)
                     os << ", ";
-                }
+                os << qs.key_value_pairs_[i];
             }
             os << " ]";
             return os;
 
         }
 
-        char* get (const std::string name) const
+        char* get (const std::string& name) const
         {
-            char* ret = qs_k2v(name.c_str(), _kv_pairs, _kv_size);
-            return ret != 0 ? ret : nullptr;
+            char* ret = qs_k2v(name.c_str(), key_value_pairs_.data(), key_value_pairs_.size());
+            return ret;
         }
 
-        std::vector<char*> get_list (const std::string name) const
+        std::vector<char*> get_list (const std::string& name) const
         {
             std::vector<char*> ret;
             std::string plus = name + "[]";            
-            char* tmp = nullptr;
+            char* element = nullptr;
+
             int count = 0;
-            do
+            while(1)
             {
-                tmp = qs_k2v(plus.c_str(), _kv_pairs, _kv_size, count++);
-                if(tmp != nullptr) {
-                    ret.push_back(tmp);
-                }
-            } while(tmp != nullptr);
-            return move(ret);
+                element = qs_k2v(plus.c_str(), key_value_pairs_.data(), key_value_pairs_.size(), count++);
+                if (!element)
+                    break;
+                ret.push_back(element);
+            }
+            return ret;
         }
 
 
     private:
-        char    _url[MAX_URL_SIZE];
-        char*   _kv_pairs[NUM_KV_PAIRS];
-        int     _kv_size;
+        std::string url_;
+        std::vector<char*> key_value_pairs_;
     };
 
 } // end namespace
 
 
-#pragma once
-
-
-
-
-namespace crow
-{
-    namespace detail
-    {
-        template <typename ... Middlewares>
-        struct partial_context
-            : public black_magic::pop_back<Middlewares...>::template rebind<partial_context>
-            , public black_magic::last_element_type<Middlewares...>::type::context
-        {
-            using parent_context = typename black_magic::pop_back<Middlewares...>::template rebind<::crow::detail::partial_context>;
-            template <int N>
-            using partial = typename std::conditional<N == sizeof...(Middlewares)-1, partial_context, typename parent_context::template partial<N>>::type;
-
-            template <typename T> 
-            typename T::context& get()
-            {
-                return static_cast<typename T::context&>(*this);
-            }
-        };
-
-        template <>
-        struct partial_context<>
-        {
-            template <int>
-            using partial = partial_context;
-        };
-
-        template <int N, typename Context, typename Container, typename CurrentMW, typename ... Middlewares>
-        bool middleware_call_helper(Container& middlewares, request& req, response& res, Context& ctx);
-
-        template <typename ... Middlewares>
-        struct context : private partial_context<Middlewares...>
-        //struct context : private Middlewares::context... // simple but less type-safe
-        {
-            template <int N, typename Context, typename Container>
-            friend typename std::enable_if<(N==0)>::type after_handlers_call_helper(Container& middlewares, Context& ctx, request& req, response& res);
-            template <int N, typename Context, typename Container>
-            friend typename std::enable_if<(N>0)>::type after_handlers_call_helper(Container& middlewares, Context& ctx, request& req, response& res);
-
-            template <int N, typename Context, typename Container, typename CurrentMW, typename ... Middlewares2>
-            friend bool middleware_call_helper(Container& middlewares, request& req, response& res, Context& ctx);
-
-            template <typename T> 
-            typename T::context& get()
-            {
-                return static_cast<typename T::context&>(*this);
-            }
-
-            template <int N>
-            using partial = typename partial_context<Middlewares...>::template partial<N>;
-        };
-    }
-}
-
-
-
-#pragma once
-
-#include <string>
-#include <cstdio>
-#include <cstdlib>
-#include <ctime>
-#include <iostream>
-#include <sstream>
-
-
-
-
-namespace crow
-{
-    enum class LogLevel
-    {
-        DEBUG,
-        INFO,
-        WARNING,
-        ERROR,
-        CRITICAL,
-    };
-
-    class ILogHandler {
-        public:
-            virtual void log(std::string message, LogLevel level) = 0;
-    };
-
-    class CerrLogHandler : public ILogHandler {
-        public:
-            void log(std::string message, LogLevel level) override {
-                std::cerr << message;
-            }
-    };
-
-    class logger {
-
-        private:
-            //
-            static std::string timestamp()
-            {
-                char date[32];
-                  time_t t = time(0);
-                  strftime(date, sizeof(date), "%Y-%m-%d %H:%M:%S", gmtime(&t));
-                  return std::string(date);
-            }
-
-        public:
-
-
-            logger(std::string prefix, LogLevel level) : level_(level) {
-    #ifdef CROW_ENABLE_LOGGING
-                    stringstream_ << "(" << timestamp() << ") [" << prefix << "] ";
-    #endif
-
-            }
-            ~logger() {
-    #ifdef CROW_ENABLE_LOGGING
-                if(level_ >= get_current_log_level()) {
-                    stringstream_ << std::endl;
-                    get_handler_ref()->log(stringstream_.str(), level_);
-                }
-    #endif
-            }
-
-            //
-            template <typename T>
-            logger& operator<<(T const &value) {
-
-    #ifdef CROW_ENABLE_LOGGING
-                if(level_ >= get_current_log_level()) {
-                    stringstream_ << value;
-                }
-    #endif
-                return *this;
-            }
-
-            //
-            static void setLogLevel(LogLevel level) {
-                get_log_level_ref() = level;
-            }
-
-            static void setHandler(ILogHandler* handler) {
-                get_handler_ref() = handler;
-            }
-
-            static LogLevel get_current_log_level() {
-                return get_log_level_ref();
-            }
-
-        private:
-            //
-            static LogLevel& get_log_level_ref()
-            {
-                static LogLevel current_level = (LogLevel)CROW_LOG_LEVEL;
-                return current_level;
-            }
-            static ILogHandler*& get_handler_ref()
-            {
-                static CerrLogHandler default_handler;
-                static ILogHandler* current_handler = &default_handler;
-                return current_handler;
-            }
-
-            //
-            std::ostringstream stringstream_;
-            LogLevel level_;
-    };
-}
-
-#define CROW_LOG_CRITICAL   \
-        if (crow::logger::get_current_log_level() <= crow::LogLevel::CRITICAL) \
-            crow::logger("CRITICAL", crow::LogLevel::CRITICAL)
-#define CROW_LOG_ERROR      \
-        if (crow::logger::get_current_log_level() <= crow::LogLevel::ERROR) \
-            crow::logger("ERROR   ", crow::LogLevel::ERROR)
-#define CROW_LOG_WARNING    \
-        if (crow::logger::get_current_log_level() <= crow::LogLevel::WARNING) \
-            crow::logger("WARNING ", crow::LogLevel::WARNING)
-#define CROW_LOG_INFO       \
-        if (crow::logger::get_current_log_level() <= crow::LogLevel::INFO) \
-            crow::logger("INFO    ", crow::LogLevel::INFO)
-#define CROW_LOG_DEBUG      \
-        if (crow::logger::get_current_log_level() <= crow::LogLevel::DEBUG) \
-            crow::logger("DEBUG   ", crow::LogLevel::DEBUG)
-
-
-
 
 #pragma once
 
@@ -5405,171 +4897,659 @@ http_parser_version(void) {
 
 #pragma once
 
-#include <boost/asio.hpp>
-#include <deque>
-#include <functional>
-#include <chrono>
-#include <thread>
-
-
-
+#include <boost/functional/hash.hpp>
 
 namespace crow
 {
-    namespace detail 
+    struct ci_hash
     {
-        // fast timer queue for fixed tick value.
-        class dumb_timer_queue
+        size_t operator()(const std::string& key) const
         {
-        public:
-            // tls based queue to avoid locking
-            static dumb_timer_queue& get_current_dumb_timer_queue()
+            std::size_t seed = 0;
+            std::locale locale;
+
+            for(auto c : key)
             {
-                thread_local dumb_timer_queue q;
-                return q;
+                boost::hash_combine(seed, std::toupper(c, locale));
             }
 
-            using key = std::pair<dumb_timer_queue*, int>;
+            return seed;
+        }
+    };
 
-            void cancel(key& k)
-            {
-                auto self = k.first;
-                k.first = nullptr;
-                if (!self)
-                    return;
+    struct ci_key_eq
+    {
+        bool operator()(const std::string& l, const std::string& r) const
+        {
+            return boost::iequals(l, r);
+        }
+    };
 
-                unsigned int index = (unsigned int)(k.second - self->step_);
-                if (index < self->dq_.size())
-                    self->dq_[index].second = nullptr;
-            }
+    using ci_map = std::unordered_multimap<std::string, std::string, ci_hash, ci_key_eq>;
+}
 
-            key add(std::function<void()> f)
-            {
-                dq_.emplace_back(std::chrono::steady_clock::now(), std::move(f));
-                int ret = step_+dq_.size()-1;
 
-                CROW_LOG_DEBUG << "timer add inside: " << this << ' ' << ret ;
-                return {this, ret};
-            }
 
-            void process()
-            {
-                if (!io_service_)
-                    return;
+#pragma once
 
-                auto now = std::chrono::steady_clock::now();
-                while(!dq_.empty())
+#include <string>
+#include <boost/date_time/local_time/local_time.hpp>
+#include <boost/filesystem.hpp>
+
+namespace crow
+{
+    // code from http://stackoverflow.com/questions/2838524/use-boost-date-time-to-parse-and-create-http-dates
+    class DateTime
+    {
+        public:
+            DateTime()
+                : m_dt(boost::local_time::local_sec_clock::local_time(boost::local_time::time_zone_ptr()))
+            {
+            }
+            DateTime(const std::string& path)
+                : DateTime()
+            {
+                from_file(path);
+            }
+
+            // return datetime string
+            std::string str()
+            {
+                static const std::locale locale_(std::locale::classic(), new boost::local_time::local_time_facet("%a, %d %b %Y %H:%M:%S GMT") );
+                std::string result;
+                try
                 {
-                    auto& x = dq_.front();
-                    if (now - x.first < std::chrono::seconds(tick))
-                        break;
-                    if (x.second)
-                    {
-                        CROW_LOG_DEBUG << "timer call: " << this << ' ' << step_;
-                        // we know that timer handlers are very simple currenty; call here
-                        x.second();
-                    }
-                    dq_.pop_front();
-                    step_++;
+                    std::stringstream ss;
+                    ss.imbue(locale_);
+                    ss << m_dt;
+                    result = ss.str();
+                }
+                catch (std::exception& e)
+                {
+                    std::cerr << "Exception: " << e.what() << std::endl;
                 }
+                return result;
             }
 
-            void set_io_service(boost::asio::io_service& io_service)
+            // update datetime from file mod date
+            std::string from_file(const std::string& path)
             {
-                io_service_ = &io_service;
+                try
+                {
+                    boost::filesystem::path p(path);
+                    boost::posix_time::ptime pt = boost::posix_time::from_time_t(
+                            boost::filesystem::last_write_time(p));
+                    m_dt = boost::local_time::local_date_time(pt, boost::local_time::time_zone_ptr());
+                }
+                catch (std::exception& e)
+                {
+                    std::cout << "Exception: " << e.what() << std::endl;
+                }
+                return str();
             }
 
-        private:
-            dumb_timer_queue() noexcept
+            // parse datetime string
+            void parse(const std::string& dt)
             {
+                static const std::locale locale_(std::locale::classic(), new boost::local_time::local_time_facet("%a, %d %b %Y %H:%M:%S GMT") );
+                std::stringstream ss(dt);
+                ss.imbue(locale_);
+                ss >> m_dt;
             }
 
-            int tick{5};
-            boost::asio::io_service* io_service_{};
-            std::deque<std::pair<decltype(std::chrono::steady_clock::now()), std::function<void()>>> dq_;
-            int step_{};
-        };
-    }
+            // boolean equal operator
+            friend bool operator==(const DateTime& left, const DateTime& right)
+            {
+                return (left.m_dt == right.m_dt);
+            }
+
+        private:
+            boost::local_time::local_date_time m_dt;
+    };
 }
 
 
 
+#pragma once
+// settings for crow
+// TODO - replace with runtime config. libucl?
+
+/* #ifdef - enables debug mode */
+#define CROW_ENABLE_DEBUG
+
+/* #ifdef - enables logging */
+#define CROW_ENABLE_LOGGING
+
+/* #define - specifies log level */
+/*
+	DEBUG 		= 0
+	INFO 		= 1
+	WARNING		= 2
+	ERROR		= 3
+	CRITICAL 	= 4
+
+    default to INFO
+*/
+#define CROW_LOG_LEVEL 1
+
+
+
 #pragma once
 
 #include <string>
-#include <boost/date_time/local_time/local_time.hpp>
-#include <boost/filesystem.hpp>
+#include <cstdio>
+#include <cstdlib>
+#include <ctime>
+#include <iostream>
+#include <sstream>
+
+
+
 
 namespace crow
 {
-    // code from http://stackoverflow.com/questions/2838524/use-boost-date-time-to-parse-and-create-http-dates
-    class DateTime
+    enum class LogLevel
     {
+        DEBUG,
+        INFO,
+        WARNING,
+        ERROR,
+        CRITICAL,
+    };
+
+    class ILogHandler {
         public:
-            DateTime()
-                : m_dt(boost::local_time::local_sec_clock::local_time(boost::local_time::time_zone_ptr()))
+            virtual void log(std::string message, LogLevel level) = 0;
+    };
+
+    class CerrLogHandler : public ILogHandler {
+        public:
+            void log(std::string message, LogLevel level) override {
+                std::cerr << message;
+            }
+    };
+
+    class logger {
+
+        private:
+            //
+            static std::string timestamp()
             {
+                char date[32];
+                  time_t t = time(0);
+                  strftime(date, sizeof(date), "%Y-%m-%d %H:%M:%S", gmtime(&t));
+                  return std::string(date);
             }
-            DateTime(const std::string& path)
-                : DateTime()
+
+        public:
+
+
+            logger(std::string prefix, LogLevel level) : level_(level) {
+    #ifdef CROW_ENABLE_LOGGING
+                    stringstream_ << "(" << timestamp() << ") [" << prefix << "] ";
+    #endif
+
+            }
+            ~logger() {
+    #ifdef CROW_ENABLE_LOGGING
+                if(level_ >= get_current_log_level()) {
+                    stringstream_ << std::endl;
+                    get_handler_ref()->log(stringstream_.str(), level_);
+                }
+    #endif
+            }
+
+            //
+            template <typename T>
+            logger& operator<<(T const &value) {
+
+    #ifdef CROW_ENABLE_LOGGING
+                if(level_ >= get_current_log_level()) {
+                    stringstream_ << value;
+                }
+    #endif
+                return *this;
+            }
+
+            //
+            static void setLogLevel(LogLevel level) {
+                get_log_level_ref() = level;
+            }
+
+            static void setHandler(ILogHandler* handler) {
+                get_handler_ref() = handler;
+            }
+
+            static LogLevel get_current_log_level() {
+                return get_log_level_ref();
+            }
+
+        private:
+            //
+            static LogLevel& get_log_level_ref()
             {
-                from_file(path);
+                static LogLevel current_level = (LogLevel)CROW_LOG_LEVEL;
+                return current_level;
+            }
+            static ILogHandler*& get_handler_ref()
+            {
+                static CerrLogHandler default_handler;
+                static ILogHandler* current_handler = &default_handler;
+                return current_handler;
             }
 
-            // return datetime string
-            std::string str()
-            {
-                static const std::locale locale_(std::locale::classic(), new boost::local_time::local_time_facet("%a, %d %b %Y %H:%M:%S GMT") );
-                std::string result;
-                try
-                {
-                    std::stringstream ss;
-                    ss.imbue(locale_);
-                    ss << m_dt;
-                    result = ss.str();
-                }
-                catch (std::exception& e)
-                {
-                    std::cerr << "Exception: " << e.what() << std::endl;
-                }
-                return result;
-            }
+            //
+            std::ostringstream stringstream_;
+            LogLevel level_;
+    };
+}
+
+#define CROW_LOG_CRITICAL   \
+        if (crow::logger::get_current_log_level() <= crow::LogLevel::CRITICAL) \
+            crow::logger("CRITICAL", crow::LogLevel::CRITICAL)
+#define CROW_LOG_ERROR      \
+        if (crow::logger::get_current_log_level() <= crow::LogLevel::ERROR) \
+            crow::logger("ERROR   ", crow::LogLevel::ERROR)
+#define CROW_LOG_WARNING    \
+        if (crow::logger::get_current_log_level() <= crow::LogLevel::WARNING) \
+            crow::logger("WARNING ", crow::LogLevel::WARNING)
+#define CROW_LOG_INFO       \
+        if (crow::logger::get_current_log_level() <= crow::LogLevel::INFO) \
+            crow::logger("INFO    ", crow::LogLevel::INFO)
+#define CROW_LOG_DEBUG      \
+        if (crow::logger::get_current_log_level() <= crow::LogLevel::DEBUG) \
+            crow::logger("DEBUG   ", crow::LogLevel::DEBUG)
+
+
+
+
+#pragma once
+
+#include <boost/asio.hpp>
+#include <deque>
+#include <functional>
+#include <chrono>
+#include <thread>
+
+
+
+
+namespace crow
+{
+    namespace detail 
+    {
+        // fast timer queue for fixed tick value.
+        class dumb_timer_queue
+        {
+        public:
+            // tls based queue to avoid locking
+            static dumb_timer_queue& get_current_dumb_timer_queue()
+            {
+                thread_local dumb_timer_queue q;
+                return q;
+            }
+
+            using key = std::pair<dumb_timer_queue*, int>;
+
+            void cancel(key& k)
+            {
+                auto self = k.first;
+                k.first = nullptr;
+                if (!self)
+                    return;
+
+                unsigned int index = (unsigned int)(k.second - self->step_);
+                if (index < self->dq_.size())
+                    self->dq_[index].second = nullptr;
+            }
+
+            key add(std::function<void()> f)
+            {
+                dq_.emplace_back(std::chrono::steady_clock::now(), std::move(f));
+                int ret = step_+dq_.size()-1;
+
+                CROW_LOG_DEBUG << "timer add inside: " << this << ' ' << ret ;
+                return {this, ret};
+            }
+
+            void process()
+            {
+                if (!io_service_)
+                    return;
+
+                auto now = std::chrono::steady_clock::now();
+                while(!dq_.empty())
+                {
+                    auto& x = dq_.front();
+                    if (now - x.first < std::chrono::seconds(tick))
+                        break;
+                    if (x.second)
+                    {
+                        CROW_LOG_DEBUG << "timer call: " << this << ' ' << step_;
+                        // we know that timer handlers are very simple currenty; call here
+                        x.second();
+                    }
+                    dq_.pop_front();
+                    step_++;
+                }
+            }
+
+            void set_io_service(boost::asio::io_service& io_service)
+            {
+                io_service_ = &io_service;
+            }
+
+        private:
+            dumb_timer_queue() noexcept
+            {
+            }
+
+            int tick{5};
+            boost::asio::io_service* io_service_{};
+            std::deque<std::pair<decltype(std::chrono::steady_clock::now()), std::function<void()>>> dq_;
+            int step_{};
+        };
+    }
+}
+
+
+
+#pragma once
+
+#include <cstdint>
+#include <stdexcept>
+#include <tuple>
+#include <type_traits>
+
+namespace crow
+{
+	namespace black_magic
+	{
+		struct OutOfRange
+		{
+			OutOfRange(unsigned pos, unsigned length) {}
+		};
+		constexpr unsigned requires_in_range( unsigned i, unsigned len )
+		{
+			return i >= len ? throw OutOfRange(i, len) : i;
+		}
+
+		class const_str
+		{
+			const char * const begin_;
+			unsigned size_;
+
+			public:
+			template< unsigned N >
+				constexpr const_str( const char(&arr)[N] ) : begin_(arr), size_(N - 1) {
+					static_assert( N >= 1, "not a string literal");
+				}
+			constexpr char operator[]( unsigned i ) const { 
+				return requires_in_range(i, size_), begin_[i]; 
+			}
+
+			constexpr operator const char *() const { 
+				return begin_; 
+			}
+
+			constexpr const char* begin() const { return begin_; }
+			constexpr const char* end() const { return begin_ + size_; }
+
+			constexpr unsigned size() const { 
+				return size_; 
+			}
+		};
+
+
+		constexpr unsigned find_closing_tag(const_str s, unsigned p)
+		{
+			return s[p] == '>' ? p : find_closing_tag(s, p+1);
+		}
+
+        constexpr bool is_valid(const_str s, unsigned i = 0, int f = 0)
+        {
+            return 
+                i == s.size()
+                    ? f == 0 :
+                f < 0 || f >= 2
+                    ? false :
+                s[i] == '<'
+                    ? is_valid(s, i+1, f+1) :
+                s[i] == '>'
+                    ? is_valid(s, i+1, f-1) :
+                is_valid(s, i+1, f);
+        }
+
+        constexpr bool is_equ_p(const char* a, const char* b, unsigned n)
+        {
+            return
+                *a == 0 && *b == 0 && n == 0 
+                    ? true :
+                (*a == 0 || *b == 0)
+                    ? false :
+                n == 0
+                    ? true :
+                *a != *b
+                    ? false :
+                is_equ_p(a+1, b+1, n-1);
+        }
+
+        constexpr bool is_equ_n(const_str a, unsigned ai, const_str b, unsigned bi, unsigned n)
+        {
+            return 
+                ai + n > a.size() || bi + n > b.size() 
+                    ? false :
+                n == 0 
+                    ? true : 
+                a[ai] != b[bi] 
+                    ? false : 
+                is_equ_n(a,ai+1,b,bi+1,n-1);
+        }
+
+        constexpr bool is_int(const_str s, unsigned i)
+        {
+            return is_equ_n(s, i, "<int>", 0, 5);
+        }
+
+        constexpr bool is_uint(const_str s, unsigned i)
+        {
+            return is_equ_n(s, i, "<uint>", 0, 6);
+        }
+
+        constexpr bool is_float(const_str s, unsigned i)
+        {
+            return is_equ_n(s, i, "<float>", 0, 7) ||
+                is_equ_n(s, i, "<double>", 0, 8);
+        }
+
+        constexpr bool is_str(const_str s, unsigned i)
+        {
+            return is_equ_n(s, i, "<str>", 0, 5) ||
+                is_equ_n(s, i, "<string>", 0, 8);
+        }
+
+        constexpr bool is_path(const_str s, unsigned i)
+        {
+            return is_equ_n(s, i, "<path>", 0, 6);
+        }
+
+        constexpr uint64_t get_parameter_tag(const_str s, unsigned p = 0)
+        {
+            return
+                p == s.size() 
+                    ?  0 :
+                s[p] == '<' ? ( 
+                    is_int(s, p)
+                        ? get_parameter_tag(s, find_closing_tag(s, p)) * 6 + 1 :
+                    is_uint(s, p)
+                        ? get_parameter_tag(s, find_closing_tag(s, p)) * 6 + 2 :
+                    is_float(s, p)
+                        ? get_parameter_tag(s, find_closing_tag(s, p)) * 6 + 3 :
+                    is_str(s, p)
+                        ? get_parameter_tag(s, find_closing_tag(s, p)) * 6 + 4 :
+                    is_path(s, p)
+                        ? get_parameter_tag(s, find_closing_tag(s, p)) * 6 + 5 :
+                    throw std::runtime_error("invalid parameter type")
+                    ) : 
+                get_parameter_tag(s, p+1);
+        }
+
+        template <typename ... T>
+        struct S
+        {
+            template <typename U>
+            using push = S<U, T...>;
+            template <typename U>
+            using push_back = S<T..., U>;
+            template <template<typename ... Args> class U>
+            using rebind = U<T...>;
+        };
+template <typename F, typename Set>
+        struct CallHelper;
+        template <typename F, typename ...Args>
+        struct CallHelper<F, S<Args...>>
+        {
+            template <typename F1, typename ...Args1, typename = 
+                decltype(std::declval<F1>()(std::declval<Args1>()...))
+                >
+            static char __test(int);
+
+            template <typename ...>
+            static int __test(...);
+
+            static constexpr bool value = sizeof(__test<F, Args...>(0)) == sizeof(char);
+        };
+
+
+        template <int N>
+        struct single_tag_to_type
+        {
+        };
+
+        template <>
+        struct single_tag_to_type<1>
+        {
+            using type = int64_t;
+        };
+
+        template <>
+        struct single_tag_to_type<2>
+        {
+            using type = uint64_t;
+        };
+
+        template <>
+        struct single_tag_to_type<3>
+        {
+            using type = double;
+        };
+
+        template <>
+        struct single_tag_to_type<4>
+        {
+            using type = std::string;
+        };
+
+        template <>
+        struct single_tag_to_type<5>
+        {
+            using type = std::string;
+        };
+
+
+        template <uint64_t Tag> 
+        struct arguments
+        {
+            using subarguments = typename arguments<Tag/6>::type;
+            using type = 
+                typename subarguments::template push<typename single_tag_to_type<Tag%6>::type>;
+        };
+
+        template <> 
+        struct arguments<0>
+        {
+            using type = S<>;
+        };
+
+        template <typename ... T>
+        struct last_element_type
+        {
+            using type = typename std::tuple_element<sizeof...(T)-1, std::tuple<T...>>::type;
+        };
+
+
+        template <>
+        struct last_element_type<>
+        {
+        };
+
+
+        // from http://stackoverflow.com/questions/13072359/c11-compile-time-array-with-logarithmic-evaluation-depth
+        template<class T> using Invoke = typename T::type;
+
+        template<unsigned...> struct seq{ using type = seq; };
+
+        template<class S1, class S2> struct concat;
+
+        template<unsigned... I1, unsigned... I2>
+        struct concat<seq<I1...>, seq<I2...>>
+          : seq<I1..., (sizeof...(I1)+I2)...>{};
+
+        template<class S1, class S2>
+        using Concat = Invoke<concat<S1, S2>>;
+
+        template<unsigned N> struct gen_seq;
+        template<unsigned N> using GenSeq = Invoke<gen_seq<N>>;
+
+        template<unsigned N>
+        struct gen_seq : Concat<GenSeq<N/2>, GenSeq<N - N/2>>{};
+
+        template<> struct gen_seq<0> : seq<>{};
+        template<> struct gen_seq<1> : seq<0>{};
+
+        template <typename Seq, typename Tuple> 
+        struct pop_back_helper;
+
+        template <unsigned ... N, typename Tuple>
+        struct pop_back_helper<seq<N...>, Tuple>
+        {
+            template <template <typename ... Args> class U>
+            using rebind = U<typename std::tuple_element<N, Tuple>::type...>;
+        };
+
+        template <typename ... T>
+        struct pop_back //: public pop_back_helper<typename gen_seq<sizeof...(T)-1>::type, std::tuple<T...>>
+        {
+            template <template <typename ... Args> class U>
+            using rebind = typename pop_back_helper<typename gen_seq<sizeof...(T)-1>::type, std::tuple<T...>>::template rebind<U>;
+        };
+
+        template <>
+        struct pop_back<>
+        {
+            template <template <typename ... Args> class U>
+            using rebind = U<>;
+        };
 
-            // update datetime from file mod date
-            std::string from_file(const std::string& path)
-            {
-                try
-                {
-                    boost::filesystem::path p(path);
-                    boost::posix_time::ptime pt = boost::posix_time::from_time_t(
-                            boost::filesystem::last_write_time(p));
-                    m_dt = boost::local_time::local_date_time(pt, boost::local_time::time_zone_ptr());
-                }
-                catch (std::exception& e)
-                {
-                    std::cout << "Exception: " << e.what() << std::endl;
-                }
-                return str();
-            }
+        // from http://stackoverflow.com/questions/2118541/check-if-c0x-parameter-pack-contains-a-type
+        template < typename Tp, typename... List >
+        struct contains : std::true_type {};
 
-            // parse datetime string
-            void parse(const std::string& dt)
-            {
-                static const std::locale locale_(std::locale::classic(), new boost::local_time::local_time_facet("%a, %d %b %Y %H:%M:%S GMT") );
-                std::stringstream ss(dt);
-                ss.imbue(locale_);
-                ss >> m_dt;
-            }
+        template < typename Tp, typename Head, typename... Rest >
+        struct contains<Tp, Head, Rest...>
+        : std::conditional< std::is_same<Tp, Head>::value,
+            std::true_type,
+            contains<Tp, Rest...>
+        >::type {};
 
-            // boolean equal operator
-            friend bool operator==(const DateTime& left, const DateTime& right)
-            {
-                return (left.m_dt == right.m_dt);
-            }
+        template < typename Tp >
+        struct contains<Tp> : std::false_type {};
 
-        private:
-            boost::local_time::local_date_time m_dt;
-    };
+        template <typename T>
+        struct empty_context
+        {
+        };
+	}
 }
 
 
@@ -5703,41 +5683,6 @@ constexpr crow::HTTPMethod operator "" _method(const char* str, size_t len)
 
 #pragma once
 
-#include <boost/functional/hash.hpp>
-
-namespace crow
-{
-    struct ci_hash
-    {
-        size_t operator()(const std::string& key) const
-        {
-            std::size_t seed = 0;
-            std::locale locale;
-
-            for(auto c : key)
-            {
-                boost::hash_combine(seed, std::toupper(c, locale));
-            }
-
-            return seed;
-        }
-    };
-
-    struct ci_key_eq
-    {
-        bool operator()(const std::string& l, const std::string& r) const
-        {
-            return boost::iequals(l, r);
-        }
-    };
-
-    using ci_map = std::unordered_multimap<std::string, std::string, ci_hash, ci_key_eq>;
-}
-
-
-
-#pragma once
-
 
 
 
@@ -6045,35 +5990,214 @@ namespace crow
             body += body_part;
         }
 
-        void end()
-        {
-            if (!completed_)
-            {
-                completed_ = true;
-                
-                if (complete_request_handler_)
+        void end()
+        {
+            if (!completed_)
+            {
+                completed_ = true;
+                
+                if (complete_request_handler_)
+                {
+                    complete_request_handler_();
+                }
+            }
+        }
+
+        void end(const std::string& body_part)
+        {
+            body += body_part;
+            end();
+        }
+
+        bool is_alive()
+        {
+            return is_alive_helper_ && is_alive_helper_();
+        }
+
+        private:
+            bool completed_{};
+            std::function<void()> complete_request_handler_;
+            std::function<bool()> is_alive_helper_;
+    };
+}
+
+
+
+#pragma once
+#include <boost/algorithm/string/trim.hpp>
+
+
+
+
+
+namespace crow
+{
+    // Any middleware requires following 3 members:
+
+    // struct context;
+    //      storing data for the middleware; can be read from another middleware or handlers
+
+    // before_handle
+    //      called before handling the request.
+    //      if res.end() is called, the operation is halted. 
+    //      (still call after_handle of this middleware)
+    //      2 signatures:
+    //      void before_handle(request& req, response& res, context& ctx)
+    //          if you only need to access this middlewares context.
+    //      template <typename AllContext>
+    //      void before_handle(request& req, response& res, context& ctx, AllContext& all_ctx)
+    //          you can access another middlewares' context by calling `all_ctx.template get<MW>()'
+    //          ctx == all_ctx.template get<CurrentMiddleware>()
+
+    // after_handle
+    //      called after handling the request.
+    //      void after_handle(request& req, response& res, context& ctx)
+    //      template <typename AllContext>
+    //      void after_handle(request& req, response& res, context& ctx, AllContext& all_ctx)
+
+    struct CookieParser
+    {
+        struct context
+        {
+            std::unordered_map<std::string, std::string> jar;
+            std::unordered_map<std::string, std::string> cookies_to_add;
+
+            std::string get_cookie(const std::string& key)
+            {
+                if (jar.count(key))
+                    return jar[key];
+                return {};
+            }
+
+            void set_cookie(const std::string& key, const std::string& value)
+            {
+                cookies_to_add.emplace(key, value);
+            }
+        };
+
+        void before_handle(request& req, response& res, context& ctx)
+        {
+            int count = req.headers.count("Cookie");
+            if (!count)
+                return;
+            if (count > 1)
+            {
+                res.code = 400;
+                res.end();
+                return;
+            }
+            std::string cookies = req.get_header_value("Cookie");
+            size_t pos = 0;
+            while(pos < cookies.size())
+            {
+                size_t pos_equal = cookies.find('=', pos);
+                if (pos_equal == cookies.npos)
+                    break;
+                std::string name = cookies.substr(pos, pos_equal-pos);
+                boost::trim(name);
+                pos = pos_equal+1;
+                while(pos < cookies.size() && cookies[pos] == ' ') pos++;
+                if (pos == cookies.size())
+                    break;
+
+                std::string value;
+
+                if (cookies[pos] == '"')
+                {
+                    int dquote_meet_count = 0;
+                    pos ++;
+                    size_t pos_dquote = pos-1;
+                    do
+                    {
+                        pos_dquote = cookies.find('"', pos_dquote+1);
+                        dquote_meet_count ++;
+                    } while(pos_dquote < cookies.size() && cookies[pos_dquote-1] == '\\');
+                    if (pos_dquote == cookies.npos)
+                        break;
+
+                    if (dquote_meet_count == 1)
+                        value = cookies.substr(pos, pos_dquote - pos);
+                    else
+                    {
+                        value.clear();
+                        value.reserve(pos_dquote-pos);
+                        for(size_t p = pos; p < pos_dquote; p++)
+                        {
+                            // FIXME minimal escaping
+                            if (cookies[p] == '\\' && p + 1 < pos_dquote)
+                            {
+                                p++;
+                                if (cookies[p] == '\\' || cookies[p] == '"')
+                                    value += cookies[p];
+                                else
+                                {
+                                    value += '\\';
+                                    value += cookies[p];
+                                }
+                            }
+                            else
+                                value += cookies[p];
+                        }
+                    }
+
+                    ctx.jar.emplace(std::move(name), std::move(value));
+                    pos = cookies.find(";", pos_dquote+1);
+                    if (pos == cookies.npos)
+                        break;
+                    pos++;
+                    while(pos < cookies.size() && cookies[pos] == ' ') pos++;
+                    if (pos == cookies.size())
+                        break;
+                }
+                else
                 {
-                    complete_request_handler_();
+                    size_t pos_semicolon = cookies.find(';', pos);
+                    value = cookies.substr(pos, pos_semicolon - pos);
+                    boost::trim(value);
+                    ctx.jar.emplace(std::move(name), std::move(value));
+                    pos = pos_semicolon;
+                    if (pos == cookies.npos)
+                        break;
+                    pos ++;
+                    while(pos < cookies.size() && cookies[pos] == ' ') pos++;
+                    if (pos == cookies.size())
+                        break;
                 }
             }
         }
 
-        void end(const std::string& body_part)
+        void after_handle(request& req, response& res, context& ctx)
         {
-            body += body_part;
-            end();
+            for(auto& cookie:ctx.cookies_to_add)
+            {
+                res.add_header("Set-Cookie", cookie.first + "=" + cookie.second);
+            }
         }
+    };
 
-        bool is_alive()
-        {
-            return is_alive_helper_ && is_alive_helper_();
-        }
+    /*
+    App<CookieParser, AnotherJarMW> app;
+    A B C
+    A::context
+        int aa;
 
-        private:
-            bool completed_{};
-            std::function<void()> complete_request_handler_;
-            std::function<bool()> is_alive_helper_;
-    };
+    ctx1 : public A::context
+    ctx2 : public ctx1, public B::context
+    ctx3 : public ctx2, public C::context
+
+    C depends on A
+
+    C::handle
+        context.aaa
+
+    App::context : private CookieParser::contetx, ... 
+    {
+        jar
+
+    }
+
+    SimpleApp
+    */
 }
 
 
@@ -6756,180 +6880,62 @@ public:
 
 
 #pragma once
-#include <boost/algorithm/string/trim.hpp>
-
 
 
 
 
 namespace crow
 {
-    // Any middleware requires following 3 members:
-
-    // struct context;
-    //      storing data for the middleware; can be read from another middleware or handlers
-
-    // before_handle
-    //      called before handling the request.
-    //      if res.end() is called, the operation is halted. 
-    //      (still call after_handle of this middleware)
-    //      2 signatures:
-    //      void before_handle(request& req, response& res, context& ctx)
-    //          if you only need to access this middlewares context.
-    //      template <typename AllContext>
-    //      void before_handle(request& req, response& res, context& ctx, AllContext& all_ctx)
-    //          you can access another middlewares' context by calling `all_ctx.template get<MW>()'
-    //          ctx == all_ctx.template get<CurrentMiddleware>()
-
-    // after_handle
-    //      called after handling the request.
-    //      void after_handle(request& req, response& res, context& ctx)
-    //      template <typename AllContext>
-    //      void after_handle(request& req, response& res, context& ctx, AllContext& all_ctx)
-
-    struct CookieParser
+    namespace detail
     {
-        struct context
+        template <typename ... Middlewares>
+        struct partial_context
+            : public black_magic::pop_back<Middlewares...>::template rebind<partial_context>
+            , public black_magic::last_element_type<Middlewares...>::type::context
         {
-            std::unordered_map<std::string, std::string> jar;
-            std::unordered_map<std::string, std::string> cookies_to_add;
-
-            std::string get_cookie(const std::string& key)
-            {
-                if (jar.count(key))
-                    return jar[key];
-                return {};
-            }
+            using parent_context = typename black_magic::pop_back<Middlewares...>::template rebind<::crow::detail::partial_context>;
+            template <int N>
+            using partial = typename std::conditional<N == sizeof...(Middlewares)-1, partial_context, typename parent_context::template partial<N>>::type;
 
-            void set_cookie(const std::string& key, const std::string& value)
+            template <typename T> 
+            typename T::context& get()
             {
-                cookies_to_add.emplace(key, value);
+                return static_cast<typename T::context&>(*this);
             }
         };
 
-        void before_handle(request& req, response& res, context& ctx)
+        template <>
+        struct partial_context<>
         {
-            int count = req.headers.count("Cookie");
-            if (!count)
-                return;
-            if (count > 1)
-            {
-                res.code = 400;
-                res.end();
-                return;
-            }
-            std::string cookies = req.get_header_value("Cookie");
-            size_t pos = 0;
-            while(pos < cookies.size())
-            {
-                size_t pos_equal = cookies.find('=', pos);
-                if (pos_equal == cookies.npos)
-                    break;
-                std::string name = cookies.substr(pos, pos_equal-pos);
-                boost::trim(name);
-                pos = pos_equal+1;
-                while(pos < cookies.size() && cookies[pos] == ' ') pos++;
-                if (pos == cookies.size())
-                    break;
-
-                std::string value;
+            template <int>
+            using partial = partial_context;
+        };
 
-                if (cookies[pos] == '"')
-                {
-                    int dquote_meet_count = 0;
-                    pos ++;
-                    size_t pos_dquote = pos-1;
-                    do
-                    {
-                        pos_dquote = cookies.find('"', pos_dquote+1);
-                        dquote_meet_count ++;
-                    } while(pos_dquote < cookies.size() && cookies[pos_dquote-1] == '\\');
-                    if (pos_dquote == cookies.npos)
-                        break;
+        template <int N, typename Context, typename Container, typename CurrentMW, typename ... Middlewares>
+        bool middleware_call_helper(Container& middlewares, request& req, response& res, Context& ctx);
 
-                    if (dquote_meet_count == 1)
-                        value = cookies.substr(pos, pos_dquote - pos);
-                    else
-                    {
-                        value.clear();
-                        value.reserve(pos_dquote-pos);
-                        for(size_t p = pos; p < pos_dquote; p++)
-                        {
-                            // FIXME minimal escaping
-                            if (cookies[p] == '\\' && p + 1 < pos_dquote)
-                            {
-                                p++;
-                                if (cookies[p] == '\\' || cookies[p] == '"')
-                                    value += cookies[p];
-                                else
-                                {
-                                    value += '\\';
-                                    value += cookies[p];
-                                }
-                            }
-                            else
-                                value += cookies[p];
-                        }
-                    }
+        template <typename ... Middlewares>
+        struct context : private partial_context<Middlewares...>
+        //struct context : private Middlewares::context... // simple but less type-safe
+        {
+            template <int N, typename Context, typename Container>
+            friend typename std::enable_if<(N==0)>::type after_handlers_call_helper(Container& middlewares, Context& ctx, request& req, response& res);
+            template <int N, typename Context, typename Container>
+            friend typename std::enable_if<(N>0)>::type after_handlers_call_helper(Container& middlewares, Context& ctx, request& req, response& res);
 
-                    ctx.jar.emplace(std::move(name), std::move(value));
-                    pos = cookies.find(";", pos_dquote+1);
-                    if (pos == cookies.npos)
-                        break;
-                    pos++;
-                    while(pos < cookies.size() && cookies[pos] == ' ') pos++;
-                    if (pos == cookies.size())
-                        break;
-                }
-                else
-                {
-                    size_t pos_semicolon = cookies.find(';', pos);
-                    value = cookies.substr(pos, pos_semicolon - pos);
-                    boost::trim(value);
-                    ctx.jar.emplace(std::move(name), std::move(value));
-                    pos = pos_semicolon;
-                    if (pos == cookies.npos)
-                        break;
-                    pos ++;
-                    while(pos < cookies.size() && cookies[pos] == ' ') pos++;
-                    if (pos == cookies.size())
-                        break;
-                }
-            }
-        }
+            template <int N, typename Context, typename Container, typename CurrentMW, typename ... Middlewares2>
+            friend bool middleware_call_helper(Container& middlewares, request& req, response& res, Context& ctx);
 
-        void after_handle(request& req, response& res, context& ctx)
-        {
-            for(auto& cookie:ctx.cookies_to_add)
+            template <typename T> 
+            typename T::context& get()
             {
-                res.add_header("Set-Cookie", cookie.first + "=" + cookie.second);
+                return static_cast<typename T::context&>(*this);
             }
-        }
-    };
-
-    /*
-    App<CookieParser, AnotherJarMW> app;
-    A B C
-    A::context
-        int aa;
-
-    ctx1 : public A::context
-    ctx2 : public ctx1, public B::context
-    ctx3 : public ctx2, public C::context
-
-    C depends on A
-
-    C::handle
-        context.aaa
-
-    App::context : private CookieParser::contetx, ... 
-    {
-        jar
 
+            template <int N>
+            using partial = typename partial_context<Middlewares...>::template partial<N>;
+        };
     }
-
-    SimpleApp
-    */
 }
 
 
diff --git a/include/query_string.h b/include/query_string.h
index 2d53ea0..d0a93ea 100644
--- a/include/query_string.h
+++ b/include/query_string.h
@@ -1,14 +1,17 @@
 #pragma once
 
 #include <stdio.h>
+#include <string.h>
 #include <string>
+#include <vector>
+#include <iostream>
 
 // ----------------------------------------------------------------------------
 // qs_parse (modified)
 // 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, register size_t n);
+int qs_strncmp(const char * s, const char * qs, size_t n);
 
 
 /*  Finds the beginning of each key/value pair and stores a pointer in qs_kv.
@@ -37,30 +40,30 @@ char * qs_scanvalue(const char * key, const char * qs, char * val, size_t val_le
 #undef _qsSORTING
 
 // isxdigit _is_ available in <ctype.h>, but let's avoid another header instead
-#define ISHEX(x)    ((((x)>='0'&&(x)<='9') || ((x)>='A'&&(x)<='F') || ((x)>='a'&&(x)<='f')) ? 1 : 0)
-#define HEX2DEC(x)  (((x)>='0'&&(x)<='9') ? (x)-48 : ((x)>='A'&&(x)<='F') ? (x)-55 : ((x)>='a'&&(x)<='f') ? (x)-87 : 0)
-#define ISQSCHR(x) ((((x)=='=')||((x)=='#')||((x)=='&')||((x)=='\0')) ? 0 : 1)
+#define CROW_QS_ISHEX(x)    ((((x)>='0'&&(x)<='9') || ((x)>='A'&&(x)<='F') || ((x)>='a'&&(x)<='f')) ? 1 : 0)
+#define CROW_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) ((((x)=='=')||((x)=='#')||((x)=='&')||((x)=='\0')) ? 0 : 1)
 
-inline int qs_strncmp(const char * s, const char * qs, register size_t n)
+inline int qs_strncmp(const char * s, const char * qs, size_t n)
 {
     int i=0;
-    register unsigned char u1, u2, unyb, lnyb;
+    unsigned char u1, u2, unyb, lnyb;
 
     while(n-- > 0)
     {
         u1 = (unsigned char) *s++;
         u2 = (unsigned char) *qs++;
 
-        if ( ! ISQSCHR(u1) ) {  u1 = '\0';  }
-        if ( ! ISQSCHR(u2) ) {  u2 = '\0';  }
+        if ( ! CROW_QS_ISQSCHR(u1) ) {  u1 = '\0';  }
+        if ( ! CROW_QS_ISQSCHR(u2) ) {  u2 = '\0';  }
 
         if ( u1 == '+' ) {  u1 = ' ';  }
         if ( u1 == '%' ) // easier/safer than scanf
         {
             unyb = (unsigned char) *s++;
             lnyb = (unsigned char) *s++;
-            if ( ISHEX(unyb) && ISHEX(lnyb) )
-                u1 = (HEX2DEC(unyb) * 16) + HEX2DEC(lnyb);
+            if ( CROW_QS_ISHEX(unyb) && CROW_QS_ISHEX(lnyb) )
+                u1 = (CROW_QS_HEX2DEC(unyb) * 16) + CROW_QS_HEX2DEC(lnyb);
             else
                 u1 = '\0';
         }
@@ -70,8 +73,8 @@ inline int qs_strncmp(const char * s, const char * qs, register size_t n)
         {
             unyb = (unsigned char) *qs++;
             lnyb = (unsigned char) *qs++;
-            if ( ISHEX(unyb) && ISHEX(lnyb) )
-                u2 = (HEX2DEC(unyb) * 16) + HEX2DEC(lnyb);
+            if ( CROW_QS_ISHEX(unyb) && CROW_QS_ISHEX(lnyb) )
+                u2 = (CROW_QS_HEX2DEC(unyb) * 16) + CROW_QS_HEX2DEC(lnyb);
             else
                 u2 = '\0';
         }
@@ -82,7 +85,7 @@ inline int qs_strncmp(const char * s, const char * qs, register size_t n)
             return 0;
         i++;
     }
-    if ( ISQSCHR(*qs) )
+    if ( CROW_QS_ISQSCHR(*qs) )
         return -1;
     else
         return 0;
@@ -136,17 +139,17 @@ inline int qs_decode(char * qs)
 {
     int i=0, j=0;
 
-    while( ISQSCHR(qs[j]) )
+    while( CROW_QS_ISQSCHR(qs[j]) )
     {
         if ( qs[j] == '+' ) {  qs[i] = ' ';  }
         else if ( qs[j] == '%' ) // easier/safer than scanf
         {
-            if ( ! ISHEX(qs[j+1]) || ! ISHEX(qs[j+2]) )
+            if ( ! CROW_QS_ISHEX(qs[j+1]) || ! CROW_QS_ISHEX(qs[j+2]) )
             {
                 qs[i] = '\0';
                 return i;
             }
-            qs[i] = (HEX2DEC(qs[j+1]) * 16) + HEX2DEC(qs[j+2]);
+            qs[i] = (CROW_QS_HEX2DEC(qs[j+1]) * 16) + CROW_QS_HEX2DEC(qs[j+2]);
             j+=2;
         }
         else
@@ -229,75 +232,77 @@ inline char * qs_scanvalue(const char * key, const char * qs, char * val, size_t
 }
 // ----------------------------------------------------------------------------
 
-// TODO to save allocs, capping url size to 2048 seems sane and reasonable but
-// crow should *technically* return a 413 if a URL is longer than this.
-#define MAX_URL_SIZE (2048)
-
-#define NUM_KV_PAIRS (256)
-#define VAL_SIZE (256)
 
 namespace crow 
 {
     class query_string
     {
     public:
+        static const int MAX_KEY_VALUE_PAIRS_COUNT = 256;
+
         query_string()
         {
 
         }
+
         query_string(std::string url)
+            : url_(std::move(url))
         {
-            if(url.length() <= MAX_URL_SIZE) {
-                memset(_url, 0, MAX_URL_SIZE); // overkill?            
-                memcpy(_url, url.c_str(), url.length());
-            }
-            _kv_size = qs_parse(_url, _kv_pairs, NUM_KV_PAIRS);
+            if (url_.empty())
+                return;
+
+            key_value_pairs_.resize(MAX_KEY_VALUE_PAIRS_COUNT);
+
+            int count = qs_parse(&url_[0], &key_value_pairs_[0], MAX_KEY_VALUE_PAIRS_COUNT);
+            key_value_pairs_.resize(count);
         }
-        void clear() {
-            _url[0] = 0;
+
+        void clear() 
+        {
+            key_value_pairs_.clear();
+            url_.clear();
         }
 
         friend std::ostream& operator<<(std::ostream& os, const query_string& qs)
         {
             os << "[ ";
-            for(int i = 0; i < qs._kv_size; ++i) {
-                os << qs._kv_pairs[i];
-                if((i + 1) < qs._kv_size) {
+            for(size_t i = 0; i < qs.key_value_pairs_.size(); ++i) {
+                if (i)
                     os << ", ";
-                }
+                os << qs.key_value_pairs_[i];
             }
             os << " ]";
             return os;
 
         }
 
-        char* get (const std::string name) const
+        char* get (const std::string& name) const
         {
-            char* ret = qs_k2v(name.c_str(), _kv_pairs, _kv_size);
-            return ret != 0 ? ret : nullptr;
+            char* ret = qs_k2v(name.c_str(), key_value_pairs_.data(), key_value_pairs_.size());
+            return ret;
         }
 
-        std::vector<char*> get_list (const std::string name) const
+        std::vector<char*> get_list (const std::string& name) const
         {
             std::vector<char*> ret;
             std::string plus = name + "[]";            
-            char* tmp = nullptr;
+            char* element = nullptr;
+
             int count = 0;
-            do
+            while(1)
             {
-                tmp = qs_k2v(plus.c_str(), _kv_pairs, _kv_size, count++);
-                if(tmp != nullptr) {
-                    ret.push_back(tmp);
-                }
-            } while(tmp != nullptr);
-            return move(ret);
+                element = qs_k2v(plus.c_str(), key_value_pairs_.data(), key_value_pairs_.size(), count++);
+                if (!element)
+                    break;
+                ret.push_back(element);
+            }
+            return ret;
         }
 
 
     private:
-        char    _url[MAX_URL_SIZE];
-        char*   _kv_pairs[NUM_KV_PAIRS];
-        int     _kv_size;
+        std::string url_;
+        std::vector<char*> key_value_pairs_;
     };
 
-} // end namespace
\ No newline at end of file
+} // end namespace
-- 
cgit v1.2.3-54-g00ecf