From 3b4bf01a7dd9e16f1df00c70b87a533a3cd17797 Mon Sep 17 00:00:00 2001
From: Antony Woods <acron1@gmail.com>
Date: Mon, 22 Sep 2014 21:34:22 +0100
Subject: [PATCH 01/11] URL params are now present as a ci_map variable of
 request

---
 examples/example.cpp   | 14 ++++++++-
 include/http_request.h |  5 ++--
 include/parser.h       | 67 +++++++++++++++++++++++++++++++++++++++++-
 3 files changed, 82 insertions(+), 4 deletions(-)

diff --git a/examples/example.cpp b/examples/example.cpp
index b360adb8b..9f482af08 100644
--- a/examples/example.cpp
+++ b/examples/example.cpp
@@ -68,8 +68,20 @@ int main()
         return crow::response{os.str()};
     });
 
+    CROW_ROUTE(app, "/params")
+    ([](const crow::request& req){
+        std::ostringstream os;
+        os << "Params:\n";
+        for (auto& i : req.url_params) {
+            os << "key = " << i.first << ", val = " << i.second << '\n';
+        }
+        return crow::response{os.str()};
+    });
+
+    
+
     // ignore all log
-    crow::logger::setLogLevel(crow::LogLevel::CRITICAL);
+    crow::logger::setLogLevel(crow::LogLevel::DEBUG);
     //crow::logger::setHandler(std::make_shared<ExampleLogHandler>());
 
     app.port(18080)
diff --git a/include/http_request.h b/include/http_request.h
index 331bc80ac..24edb66fb 100644
--- a/include/http_request.h
+++ b/include/http_request.h
@@ -20,6 +20,7 @@ namespace crow
     {
         HTTPMethod method;
         std::string url;
+        ci_map url_params;
         ci_map headers;
         std::string body;
 
@@ -30,8 +31,8 @@ namespace crow
         {
         }
 
-        request(HTTPMethod method, std::string url, ci_map headers, std::string body)
-            : method(method), url(std::move(url)), headers(std::move(headers)), body(std::move(body))
+        request(HTTPMethod method, std::string url, ci_map url_params, ci_map headers, std::string body)
+            : method(method), url(std::move(url)), url_params(std::move(url_params)), headers(std::move(headers)), body(std::move(body))
         {
         }
 
diff --git a/include/parser.h b/include/parser.h
index 869061cfb..bda4594a9 100644
--- a/include/parser.h
+++ b/include/parser.h
@@ -3,6 +3,8 @@
 #include <string>
 #include <unordered_map>
 #include <boost/algorithm/string.hpp>
+#include <boost/tokenizer.hpp>
+#include <algorithm>
 
 #include "http_request.h"
 
@@ -11,6 +13,62 @@ namespace crow
     template <typename Handler>
     struct HTTPParser : public http_parser
     {
+        template<const char delimiter>
+        struct tokenize_by_char
+        {
+            template<typename It>
+            bool operator()(It& next, It end, std::string & tok)
+            {
+                if (next == end)
+                    return false;
+                const char dels = delimiter;
+                const char* del = &dels;
+                auto pos = std::search(next, end, del, del + 1);
+                tok.assign(next, pos);
+                next = pos;
+                if (next != end)
+                    std::advance(next, 1);
+                return true;
+            }
+
+            void reset() {}
+        };
+
+        static ci_map get_url_params(std::string url)
+        {
+            const char url_delimiter = '&';
+            const char param_delimiter = '=';
+            ci_map ret;
+
+            int qMarkPos = url.find("?");
+            if(!(qMarkPos >=0 && qMarkPos != (url.length()-1))) {
+                return ret;
+            }
+            
+            auto params = url.substr(qMarkPos+1);
+
+            // substitute ';' for '&' for recommended process of delimintation
+            // (http://www.w3.org/TR/1999/REC-html401-19991224/appendix/notes.html#h-B.2.2)
+            std::replace(params.begin(), params.end(), ';', url_delimiter);                
+
+            // url tokenizer
+            for (auto i : boost::tokenizer<tokenize_by_char<url_delimiter>>(params)) {
+                std::string key, value; 
+                auto parts = boost::tokenizer<tokenize_by_char<param_delimiter>>(i);
+                int count = 0;
+                for(auto p = parts.begin(); p != parts.end(); ++p, ++count) {
+                    if(count == 0){
+                        key = *p;
+                    } else {
+                        value = *p;
+                    }
+                }
+                ret.insert(std::make_pair(key, value));
+            }
+            
+            return ret;
+        }
+
         static int on_message_begin(http_parser* self_)
         {
             HTTPParser* self = static_cast<HTTPParser*>(self_);
@@ -21,6 +79,10 @@ namespace crow
         {
             HTTPParser* self = static_cast<HTTPParser*>(self_);
             self->url.insert(self->url.end(), at, at+length);
+
+            // url params
+            self->url_params = get_url_params(self->url);
+
             return 0;
         }
         static int on_header_field(http_parser* self_, const char* at, size_t length)
@@ -115,6 +177,7 @@ namespace crow
             header_field.clear();
             header_value.clear();
             headers.clear();
+            url_params.clear();
             body.clear();
         }
 
@@ -130,7 +193,7 @@ namespace crow
 
         request to_request() const
         {
-            return request{(HTTPMethod)method, std::move(url), std::move(headers), std::move(body)};
+            return request{(HTTPMethod)method, std::move(url), std::move(url_params), std::move(headers), std::move(body)};
         }
 
         bool check_version(int major, int minor) const
@@ -139,10 +202,12 @@ namespace crow
         }
 
         std::string url;
+
         int header_building_state = 0;
         std::string header_field;
         std::string header_value;
         ci_map headers;
+        ci_map url_params;
         std::string body;
 
         Handler* handler_;

From 6890436742c89a01d00f26f796becb5e81c26e0b Mon Sep 17 00:00:00 2001
From: Antony Woods <acron1@gmail.com>
Date: Tue, 23 Sep 2014 21:02:26 +0100
Subject: [PATCH 02/11] Fixed sign comparisson warning

---
 include/parser.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/include/parser.h b/include/parser.h
index bda4594a9..00bb155c7 100644
--- a/include/parser.h
+++ b/include/parser.h
@@ -40,7 +40,7 @@ namespace crow
             const char param_delimiter = '=';
             ci_map ret;
 
-            int qMarkPos = url.find("?");
+            unsigned int qMarkPos = url.find("?");
             if(!(qMarkPos >=0 && qMarkPos != (url.length()-1))) {
                 return ret;
             }

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: [PATCH 03/11] Wrapped qs_parse as query_string and added tests

---
 README.md                 |   18 +
 amalgamate/crow_all.h     | 1882 ++++++++++++++++++++++---------------
 examples/example.cpp      |   17 +-
 include/http_connection.h |    2 +-
 include/http_request.h    |    8 +-
 include/parser.h          |   73 +-
 include/query_string.h    |  305 ++++++
 include/routing.h         |    7 +-
 tests/unittest.cpp        |  117 +++
 9 files changed, 1570 insertions(+), 859 deletions(-)
 create mode 100644 include/query_string.h

diff --git a/README.md b/README.md
index c6fa8a458..1400c0da8 100644
--- a/README.md
+++ b/README.md
@@ -115,3 +115,21 @@ ctest
 #### OSX
     brew install boost google-perftools
 
+### Attributions
+
+Crow uses the following libraries.
+
+    qs_parse
+
+    https://github.com/bartgrantham/qs_parse
+
+    Copyright (c) 2010 Bart Grantham
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to deal
+    in the Software without restriction, including without limitation the rights
+    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+    copies of the Software, and to permit persons to whom the Software is
+    furnished to do so, subject to the following conditions:
+    The above copyright notice and this permission notice shall be included in
+    all copies or substantial portions of the Software.
+
diff --git a/amalgamate/crow_all.h b/amalgamate/crow_all.h
index d73276566..a567b5a4b 100644
--- a/amalgamate/crow_all.h
+++ b/amalgamate/crow_all.h
@@ -1,3 +1,824 @@
+#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
+                    ? 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<>;
+        };
+
+        // 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>
+
+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
+
+
+#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>
+
+
+
+
+using namespace std;
+
+namespace crow
+{
+    enum class LogLevel
+    {
+        DEBUG,
+        INFO,
+        WARNING,
+        ERROR,
+        CRITICAL,
+    };
+
+    class ILogHandler {
+        public:
+            virtual void log(string message, LogLevel level) = 0;
+    };
+
+    class CerrLogHandler : public ILogHandler {
+        public:
+            void log(string message, LogLevel level) override {
+                cerr << message;
+            }
+    };
+
+    class logger {
+
+        private:
+            //
+            static 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);
+            }
+
+        public:
+
+
+            logger(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_ << 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;
+            }
+
+            //
+            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
 
 //#define CROW_JSON_NO_ERROR_CHECK
@@ -4584,276 +5405,6 @@ http_parser_version(void) {
 
 
 
-#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
-
-#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
-                {
-                    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;
-            }
-
-            // 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();
-            }
-
-            // 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;
-            }
-
-            // 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 <cstdio>
-#include <cstdlib>
-#include <ctime>
-#include <iostream>
-#include <sstream>
-
-
-
-
-using namespace std;
-
-namespace crow
-{
-    enum class LogLevel
-    {
-        DEBUG,
-        INFO,
-        WARNING,
-        ERROR,
-        CRITICAL,
-    };
-
-    class ILogHandler {
-        public:
-            virtual void log(string message, LogLevel level) = 0;
-    };
-
-    class CerrLogHandler : public ILogHandler {
-        public:
-            void log(string message, LogLevel level) override {
-                cerr << message;
-            }
-    };
-
-    class logger {
-
-        private:
-            //
-            static 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);
-            }
-
-        public:
-
-
-            logger(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_ << 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;
-            }
-
-            //
-            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>
@@ -4947,298 +5498,80 @@ namespace crow
 
 #pragma once
 
-#include <cstdint>
-#include <stdexcept>
-#include <tuple>
-#include <type_traits>
+#include <string>
+#include <boost/date_time/local_time/local_time.hpp>
+#include <boost/filesystem.hpp>
 
 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;
-		}
+    // 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);
+            }
 
-		class const_str
-		{
-			const char * const begin_;
-			unsigned size_;
+            // 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;
+            }
 
-			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]; 
-			}
+            // 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();
+            }
 
-			constexpr operator const char *() const { 
-				return begin_; 
-			}
+            // 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;
+            }
 
-			constexpr const char* begin() const { return begin_; }
-			constexpr const char* end() const { return begin_ + size_; }
+            // boolean equal operator
+            friend bool operator==(const DateTime& left, const DateTime& right)
+            {
+                return (left.m_dt == right.m_dt);
+            }
 
-			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
-                    ? 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<>;
-        };
-
-        // 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
-        {
-        };
-	}
+        private:
+            boost::local_time::local_date_time m_dt;
+    };
 }
 
 
@@ -5372,6 +5705,43 @@ 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
+
+
+
 
 
 
@@ -5393,7 +5763,9 @@ namespace crow
     struct request
     {
         HTTPMethod method;
+        std::string raw_url;
         std::string url;
+        query_string url_params;
         ci_map headers;
         std::string body;
 
@@ -5404,8 +5776,8 @@ namespace crow
         {
         }
 
-        request(HTTPMethod method, std::string url, ci_map headers, std::string body)
-            : method(method), url(std::move(url)), headers(std::move(headers)), body(std::move(body))
+        request(HTTPMethod method, std::string raw_url, std::string url, query_string url_params, ci_map headers, std::string body)
+            : method(method), raw_url(std::move(raw_url)), url(std::move(url)), url_params(std::move(url_params)), headers(std::move(headers)), body(std::move(body))
         {
         }
 
@@ -5429,6 +5801,8 @@ namespace crow
 #include <string>
 #include <unordered_map>
 #include <boost/algorithm/string.hpp>
+#include <boost/tokenizer.hpp>
+#include <algorithm>
 
 
 
@@ -5447,7 +5821,7 @@ namespace crow
         static int on_url(http_parser* self_, const char* at, size_t length)
         {
             HTTPParser* self = static_cast<HTTPParser*>(self_);
-            self->url.insert(self->url.end(), at, at+length);
+            self->raw_url.insert(self->raw_url.end(), at, at+length);
             return 0;
         }
         static int on_header_field(http_parser* self_, const char* at, size_t length)
@@ -5503,6 +5877,11 @@ namespace crow
         static int on_message_complete(http_parser* self_)
         {
             HTTPParser* self = static_cast<HTTPParser*>(self_);
+
+            // url params
+            self->url = self->raw_url.substr(0, self->raw_url.find("?"));
+            self->url_params = query_string(self->raw_url);
+
             self->process_message();
             return 0;
         }
@@ -5538,10 +5917,12 @@ namespace crow
         void clear()
         {
             url.clear();
+            raw_url.clear();
             header_building_state = 0;
             header_field.clear();
             header_value.clear();
             headers.clear();
+            url_params.clear();
             body.clear();
         }
 
@@ -5557,7 +5938,7 @@ namespace crow
 
         request to_request() const
         {
-            return request{(HTTPMethod)method, std::move(url), std::move(headers), std::move(body)};
+            return request{(HTTPMethod)method, std::move(raw_url), std::move(url), std::move(url_params), std::move(headers), std::move(body)};
         }
 
         bool check_version(int major, int minor) const
@@ -5565,11 +5946,14 @@ namespace crow
             return http_major == major && http_minor == minor;
         }
 
+        std::string raw_url;
         std::string url;
+
         int header_building_state = 0;
         std::string header_field;
         std::string header_value;
         ci_map headers;
+        query_string url_params;
         std::string body;
 
         Handler* handler_;
@@ -5696,185 +6080,6 @@ namespace crow
 
 
 
-#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
-                {
-                    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 after_handle(request& req, response& res, context& ctx)
-        {
-            for(auto& cookie:ctx.cookies_to_add)
-            {
-                res.add_header("Set-Cookie", cookie.first + "=" + cookie.second);
-            }
-        }
-    };
-
-    /*
-    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
-
-    }
-
-    SimpleApp
-    */
-}
-
-
-
 #pragma once
 
 #include <cstdint>
@@ -6505,16 +6710,13 @@ public:
 
         void handle(const request& req, response& res)
         {
-            // remove url params            
-            auto editedUrl = req.url.substr(0, req.url.find("?"));
-
-            auto found = trie_.find(editedUrl);
+            auto found = trie_.find(req.url);
 
             unsigned rule_index = found.first;
 
             if (!rule_index)
             {
-				CROW_LOG_DEBUG << "Cannot match rules " << editedUrl;
+				CROW_LOG_DEBUG << "Cannot match rules " << req.url;
                 res = response(404);
 				res.end();
                 return;
@@ -6542,62 +6744,180 @@ public:
 
 
 #pragma once
+#include <boost/algorithm/string/trim.hpp>
+
 
 
 
 
 namespace crow
 {
-    namespace detail
+    // 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
     {
-        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
+        struct 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;
+            std::unordered_map<std::string, std::string> jar;
+            std::unordered_map<std::string, std::string> cookies_to_add;
 
-            template <typename T> 
-            typename T::context& get()
+            std::string get_cookie(const std::string& key)
             {
-                return static_cast<typename T::context&>(*this);
+                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);
             }
         };
 
-        template <>
-        struct partial_context<>
+        void before_handle(request& req, response& res, context& ctx)
         {
-            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()
+            int count = req.headers.count("Cookie");
+            if (!count)
+                return;
+            if (count > 1)
             {
-                return static_cast<typename T::context&>(*this);
+                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
+                {
+                    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 after_handle(request& req, response& res, context& ctx)
+        {
+            for(auto& cookie:ctx.cookies_to_add)
+            {
+                res.add_header("Set-Cookie", cookie.first + "=" + cookie.second);
+            }
+        }
+    };
+
+    /*
+    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
+    */
 }
 
 
@@ -6844,7 +7164,7 @@ namespace crow
 
         void complete_request()
         {
-            CROW_LOG_INFO << "Response: " << this << ' ' << req_.url << ' ' << res.code << ' ' << close_connection_;
+            CROW_LOG_INFO << "Response: " << this << ' ' << req_.raw_url << ' ' << res.code << ' ' << close_connection_;
 
             if (need_to_call_after_handlers_)
             {
diff --git a/examples/example.cpp b/examples/example.cpp
index 9f482af08..f9d006e0b 100644
--- a/examples/example.cpp
+++ b/examples/example.cpp
@@ -71,14 +71,19 @@ int main()
     CROW_ROUTE(app, "/params")
     ([](const crow::request& req){
         std::ostringstream os;
-        os << "Params:\n";
-        for (auto& i : req.url_params) {
-            os << "key = " << i.first << ", val = " << i.second << '\n';
+        os << "Params: " << req.url_params << "\n\n"; 
+        os << "The key 'foo' was " << (req.url_params.get("foo") == nullptr ? "not " : "") << "found.\n";
+        if(req.url_params.get("pew") != nullptr) {
+            double countD = boost::lexical_cast<double>(req.url_params.get("pew"));
+            os << "The value of 'pew' is " <<  countD << '\n';
+        }
+        auto count = req.url_params.get_list("count");
+        os << "The key 'count' contains " << count.size() << " value(s).\n";
+        for(const auto& countVal : count) {
+            os << " - " << countVal << '\n';
         }
         return crow::response{os.str()};
-    });
-
-    
+    });    
 
     // ignore all log
     crow::logger::setLogLevel(crow::LogLevel::DEBUG);
diff --git a/include/http_connection.h b/include/http_connection.h
index 016c2705d..537be894b 100644
--- a/include/http_connection.h
+++ b/include/http_connection.h
@@ -232,7 +232,7 @@ namespace crow
 
         void complete_request()
         {
-            CROW_LOG_INFO << "Response: " << this << ' ' << req_.url << ' ' << res.code << ' ' << close_connection_;
+            CROW_LOG_INFO << "Response: " << this << ' ' << req_.raw_url << ' ' << res.code << ' ' << close_connection_;
 
             if (need_to_call_after_handlers_)
             {
diff --git a/include/http_request.h b/include/http_request.h
index 24edb66fb..1319b2d0b 100644
--- a/include/http_request.h
+++ b/include/http_request.h
@@ -2,6 +2,7 @@
 
 #include "common.h"
 #include "ci_map.h"
+#include "query_string.h"
 
 namespace crow
 {
@@ -19,8 +20,9 @@ namespace crow
     struct request
     {
         HTTPMethod method;
+        std::string raw_url;
         std::string url;
-        ci_map url_params;
+        query_string url_params;
         ci_map headers;
         std::string body;
 
@@ -31,8 +33,8 @@ namespace crow
         {
         }
 
-        request(HTTPMethod method, std::string url, ci_map url_params, ci_map headers, std::string body)
-            : method(method), url(std::move(url)), url_params(std::move(url_params)), headers(std::move(headers)), body(std::move(body))
+        request(HTTPMethod method, std::string raw_url, std::string url, query_string url_params, ci_map headers, std::string body)
+            : method(method), raw_url(std::move(raw_url)), url(std::move(url)), url_params(std::move(url_params)), headers(std::move(headers)), body(std::move(body))
         {
         }
 
diff --git a/include/parser.h b/include/parser.h
index 00bb155c7..6ead8fd0e 100644
--- a/include/parser.h
+++ b/include/parser.h
@@ -13,62 +13,6 @@ namespace crow
     template <typename Handler>
     struct HTTPParser : public http_parser
     {
-        template<const char delimiter>
-        struct tokenize_by_char
-        {
-            template<typename It>
-            bool operator()(It& next, It end, std::string & tok)
-            {
-                if (next == end)
-                    return false;
-                const char dels = delimiter;
-                const char* del = &dels;
-                auto pos = std::search(next, end, del, del + 1);
-                tok.assign(next, pos);
-                next = pos;
-                if (next != end)
-                    std::advance(next, 1);
-                return true;
-            }
-
-            void reset() {}
-        };
-
-        static ci_map get_url_params(std::string url)
-        {
-            const char url_delimiter = '&';
-            const char param_delimiter = '=';
-            ci_map ret;
-
-            unsigned int qMarkPos = url.find("?");
-            if(!(qMarkPos >=0 && qMarkPos != (url.length()-1))) {
-                return ret;
-            }
-            
-            auto params = url.substr(qMarkPos+1);
-
-            // substitute ';' for '&' for recommended process of delimintation
-            // (http://www.w3.org/TR/1999/REC-html401-19991224/appendix/notes.html#h-B.2.2)
-            std::replace(params.begin(), params.end(), ';', url_delimiter);                
-
-            // url tokenizer
-            for (auto i : boost::tokenizer<tokenize_by_char<url_delimiter>>(params)) {
-                std::string key, value; 
-                auto parts = boost::tokenizer<tokenize_by_char<param_delimiter>>(i);
-                int count = 0;
-                for(auto p = parts.begin(); p != parts.end(); ++p, ++count) {
-                    if(count == 0){
-                        key = *p;
-                    } else {
-                        value = *p;
-                    }
-                }
-                ret.insert(std::make_pair(key, value));
-            }
-            
-            return ret;
-        }
-
         static int on_message_begin(http_parser* self_)
         {
             HTTPParser* self = static_cast<HTTPParser*>(self_);
@@ -78,11 +22,7 @@ namespace crow
         static int on_url(http_parser* self_, const char* at, size_t length)
         {
             HTTPParser* self = static_cast<HTTPParser*>(self_);
-            self->url.insert(self->url.end(), at, at+length);
-
-            // url params
-            self->url_params = get_url_params(self->url);
-
+            self->raw_url.insert(self->raw_url.end(), at, at+length);
             return 0;
         }
         static int on_header_field(http_parser* self_, const char* at, size_t length)
@@ -138,6 +78,11 @@ namespace crow
         static int on_message_complete(http_parser* self_)
         {
             HTTPParser* self = static_cast<HTTPParser*>(self_);
+
+            // url params
+            self->url = self->raw_url.substr(0, self->raw_url.find("?"));
+            self->url_params = query_string(self->raw_url);
+
             self->process_message();
             return 0;
         }
@@ -173,6 +118,7 @@ namespace crow
         void clear()
         {
             url.clear();
+            raw_url.clear();
             header_building_state = 0;
             header_field.clear();
             header_value.clear();
@@ -193,7 +139,7 @@ namespace crow
 
         request to_request() const
         {
-            return request{(HTTPMethod)method, std::move(url), std::move(url_params), std::move(headers), std::move(body)};
+            return request{(HTTPMethod)method, std::move(raw_url), std::move(url), std::move(url_params), std::move(headers), std::move(body)};
         }
 
         bool check_version(int major, int minor) const
@@ -201,13 +147,14 @@ namespace crow
             return http_major == major && http_minor == minor;
         }
 
+        std::string raw_url;
         std::string url;
 
         int header_building_state = 0;
         std::string header_field;
         std::string header_value;
         ci_map headers;
-        ci_map url_params;
+        query_string url_params;
         std::string body;
 
         Handler* handler_;
diff --git a/include/query_string.h b/include/query_string.h
new file mode 100644
index 000000000..5a42782d0
--- /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
diff --git a/include/routing.h b/include/routing.h
index d81426619..ca881928c 100644
--- a/include/routing.h
+++ b/include/routing.h
@@ -623,16 +623,13 @@ public:
 
         void handle(const request& req, response& res)
         {
-            // remove url params            
-            auto editedUrl = req.url.substr(0, req.url.find("?"));
-
-            auto found = trie_.find(editedUrl);
+            auto found = trie_.find(req.url);
 
             unsigned rule_index = found.first;
 
             if (!rule_index)
             {
-				CROW_LOG_DEBUG << "Cannot match rules " << editedUrl;
+				CROW_LOG_DEBUG << "Cannot match rules " << req.url;
                 res = response(404);
 				res.end();
                 return;
diff --git a/tests/unittest.cpp b/tests/unittest.cpp
index 818032fb5..87acb525a 100644
--- a/tests/unittest.cpp
+++ b/tests/unittest.cpp
@@ -11,6 +11,7 @@
 #include "json.h"
 #include "mustache.h"
 #include "middleware.h"
+#include "query_string.h"
 
 using namespace std;
 using namespace crow;
@@ -758,6 +759,122 @@ TEST(bug_quick_repeated_request)
     server.stop();
 }
 
+TEST(simple_url_params)
+{
+    static char buf[2048];
+
+    SimpleApp app;
+
+    query_string last_url_params;
+
+    CROW_ROUTE(app, "/params")
+    ([&last_url_params](const crow::request& req){
+        last_url_params = move(req.url_params);
+        return "OK";
+    });
+
+    ///params?h=1&foo=bar&lol&count[]=1&count[]=4&pew=5.2
+
+    decltype(app)::server_t server(&app, 45451);
+    auto _ = async(launch::async, [&]{server.run();});
+    asio::io_service is;
+    std::string sendmsg;
+
+    // check single presence
+    sendmsg = "GET /params?foobar\r\n\r\n";
+    {
+        asio::ip::tcp::socket c(is);
+        c.connect(asio::ip::tcp::endpoint(asio::ip::address::from_string("127.0.0.1"), 45451));
+        c.send(asio::buffer(sendmsg));
+        c.receive(asio::buffer(buf, 2048));
+        c.close();
+
+        ASSERT_TRUE(last_url_params.get("missing") == nullptr);
+        ASSERT_TRUE(last_url_params.get("foobar") != nullptr);
+    }
+    // check multiple presence
+    sendmsg = "GET /params?foo&bar&baz\r\n\r\n";
+    {
+        asio::ip::tcp::socket c(is);
+        c.connect(asio::ip::tcp::endpoint(asio::ip::address::from_string("127.0.0.1"), 45451));
+        c.send(asio::buffer(sendmsg));
+        c.receive(asio::buffer(buf, 2048));
+        c.close();
+
+        ASSERT_TRUE(last_url_params.get("missing") == nullptr);
+        ASSERT_TRUE(last_url_params.get("foo") != nullptr);
+        ASSERT_TRUE(last_url_params.get("bar") != nullptr);
+        ASSERT_TRUE(last_url_params.get("baz") != nullptr);
+    }
+    // check single value
+    sendmsg = "GET /params?hello=world\r\n\r\n";
+    {
+        asio::ip::tcp::socket c(is);
+        c.connect(asio::ip::tcp::endpoint(asio::ip::address::from_string("127.0.0.1"), 45451));
+        c.send(asio::buffer(sendmsg));
+        c.receive(asio::buffer(buf, 2048));
+        c.close();        
+
+        ASSERT_EQUAL(string(last_url_params.get("hello")), "world");
+    }
+    // check multiple value
+    sendmsg = "GET /params?hello=world&left=right&up=down\r\n\r\n";
+    {
+        asio::ip::tcp::socket c(is);
+        c.connect(asio::ip::tcp::endpoint(asio::ip::address::from_string("127.0.0.1"), 45451));
+        c.send(asio::buffer(sendmsg));
+        c.receive(asio::buffer(buf, 2048));
+        c.close();
+
+        ASSERT_EQUAL(string(last_url_params.get("hello")), "world");
+        ASSERT_EQUAL(string(last_url_params.get("left")), "right");
+        ASSERT_EQUAL(string(last_url_params.get("up")),  "down");
+    }
+    // check multiple value, multiple types
+    sendmsg = "GET /params?int=100&double=123.45&boolean=1\r\n\r\n";
+    {
+        asio::ip::tcp::socket c(is);
+        c.connect(asio::ip::tcp::endpoint(asio::ip::address::from_string("127.0.0.1"), 45451));
+        c.send(asio::buffer(sendmsg));
+        c.receive(asio::buffer(buf, 2048));        
+        c.close();    
+
+        ASSERT_EQUAL(boost::lexical_cast<int>(last_url_params.get("int")), 100);
+        ASSERT_EQUAL(boost::lexical_cast<double>(last_url_params.get("double")), 123.45);
+        ASSERT_EQUAL(boost::lexical_cast<bool>(last_url_params.get("boolean")), true);
+    }
+    // check single array value
+    sendmsg = "GET /params?tmnt[]=leonardo\r\n\r\n";
+    {
+        asio::ip::tcp::socket c(is);
+
+        c.connect(asio::ip::tcp::endpoint(asio::ip::address::from_string("127.0.0.1"), 45451));
+        c.send(asio::buffer(sendmsg));
+        c.receive(asio::buffer(buf, 2048));
+        c.close();        
+        
+        ASSERT_TRUE(last_url_params.get("tmnt") == nullptr);
+        ASSERT_EQUAL(last_url_params.get_list("tmnt").size(), 1);
+        ASSERT_EQUAL(string(last_url_params.get_list("tmnt")[0]), "leonardo");
+    }
+    // check multiple array value
+    sendmsg = "GET /params?tmnt[]=leonardo&tmnt[]=donatello&tmnt[]=raphael\r\n\r\n";
+    {
+        asio::ip::tcp::socket c(is);
+
+        c.connect(asio::ip::tcp::endpoint(asio::ip::address::from_string("127.0.0.1"), 45451));
+        c.send(asio::buffer(sendmsg));
+        c.receive(asio::buffer(buf, 2048));
+        c.close();        
+        
+        ASSERT_EQUAL(last_url_params.get_list("tmnt").size(), 3);
+        ASSERT_EQUAL(string(last_url_params.get_list("tmnt")[0]), "leonardo");
+        ASSERT_EQUAL(string(last_url_params.get_list("tmnt")[1]), "donatello");
+        ASSERT_EQUAL(string(last_url_params.get_list("tmnt")[2]), "raphael");
+    }
+    server.stop();
+}
+
 int main()
 {
     return testmain();

From baa115a76d4f9a9dde8e99d19fc86d2f98622973 Mon Sep 17 00:00:00 2001
From: Antony Woods <acron1@gmail.com>
Date: Wed, 15 Oct 2014 18:20:48 +0100
Subject: [PATCH 04/11] Removed http-parser submodule

---
 .gitmodules | 3 ---
 http-parser | 1 -
 2 files changed, 4 deletions(-)
 delete mode 160000 http-parser

diff --git a/.gitmodules b/.gitmodules
index 95da8a700..e69de29bb 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -1,3 +0,0 @@
-[submodule "http-parser"]
-	path = http-parser
-	url = https://github.com/joyent/http-parser
diff --git a/http-parser b/http-parser
deleted file mode 160000
index 5b951d74b..000000000
--- a/http-parser
+++ /dev/null
@@ -1 +0,0 @@
-Subproject commit 5b951d74bd66ec9d38448e0a85b1cf8b85d97db3

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: [PATCH 05/11] Removed instance of 'using namespace std'

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

diff --git a/include/logging.h b/include/logging.h
index 8f5b833b5..ad1f4bcb5 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 5a42782d0..afc112ee0 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

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: [PATCH 06/11] 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(-)

diff --git a/amalgamate/crow_all.h b/amalgamate/crow_all.h
index 43a3af4fd..743eb5238 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 f9d006e0b..d7a4736f2 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 ad1f4bcb5..0d7707188 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 afc112ee0..2d53ea0f1 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;

From 5c5c8fb4f59a1235e5093056814f7d272c049ab5 Mon Sep 17 00:00:00 2001
From: ipknHama <ipknhama@gmail.com>
Date: Fri, 24 Oct 2014 01:18:29 +0900
Subject: [PATCH 07/11] 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  | 1636 ++++++++++++++++++++--------------------
 include/query_string.h |  103 +--
 2 files changed, 875 insertions(+), 864 deletions(-)

diff --git a/amalgamate/crow_all.h b/amalgamate/crow_all.h
index 743eb5238..2c7613d31 100644
--- a/amalgamate/crow_all.h
+++ b/amalgamate/crow_all.h
@@ -1,338 +1,17 @@
-#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<>;
-        };
-
-        // 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.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.
@@ -361,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';
         }
@@ -394,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';
         }
@@ -406,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;
@@ -460,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
@@ -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
 
@@ -5403,6 +4895,274 @@ http_parser_version(void) {
 
 
 
+#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
+
+#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
+                {
+                    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;
+            }
+
+            // 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();
+            }
+
+            // 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;
+            }
+
+            // 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 <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
 
 #include <boost/asio.hpp>
@@ -5496,80 +5256,300 @@ namespace crow
 
 #pragma once
 
-#include <string>
-#include <boost/date_time/local_time/local_time.hpp>
-#include <boost/filesystem.hpp>
+#include <cstdint>
+#include <stdexcept>
+#include <tuple>
+#include <type_traits>
 
 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);
-            }
+	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;
+		}
 
-            // 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;
-            }
+		class const_str
+		{
+			const char * const begin_;
+			unsigned size_;
 
-            // 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();
-            }
+			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]; 
+			}
 
-            // 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;
-            }
+			constexpr operator const char *() const { 
+				return begin_; 
+			}
 
-            // boolean equal operator
-            friend bool operator==(const DateTime& left, const DateTime& right)
-            {
-                return (left.m_dt == right.m_dt);
-            }
+			constexpr const char* begin() const { return begin_; }
+			constexpr const char* end() const { return begin_ + size_; }
 
-        private:
-            boost::local_time::local_date_time m_dt;
-    };
+			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<>;
+        };
+
+        // 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
+        {
+        };
+	}
 }
 
 
@@ -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
-
 
 
 
@@ -6078,6 +6023,185 @@ namespace crow
 
 
 
+#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
+                {
+                    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 after_handle(request& req, response& res, context& ctx)
+        {
+            for(auto& cookie:ctx.cookies_to_add)
+            {
+                res.add_header("Set-Cookie", cookie.first + "=" + cookie.second);
+            }
+        }
+    };
+
+    /*
+    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
+
+    }
+
+    SimpleApp
+    */
+}
+
+
+
 #pragma once
 
 #include <cstdint>
@@ -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;
+            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;
 
-            std::string get_cookie(const std::string& key)
+            template <typename T> 
+            typename T::context& get()
             {
-                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);
+                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;
+            template <int>
+            using partial = partial_context;
+        };
 
-                std::string value;
+        template <int N, typename Context, typename Container, typename CurrentMW, typename ... Middlewares>
+        bool middleware_call_helper(Container& middlewares, request& req, response& res, Context& ctx);
 
-                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
-                {
-                    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 after_handle(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
         {
-            for(auto& cookie:ctx.cookies_to_add)
+            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()
             {
-                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 2d53ea0f1..d0a93ea9d 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

From 023455ba58cabfc7afc3e99c399c7c25c0a643cb Mon Sep 17 00:00:00 2001
From: ipknHama <ipknhama@gmail.com>
Date: Fri, 24 Oct 2014 01:20:19 +0900
Subject: [PATCH 08/11] add building test for crow_all.h

---
 examples/CMakeLists.txt | 4 ++++
 tests/unittest.cpp      | 1 +
 2 files changed, 5 insertions(+)

diff --git a/examples/CMakeLists.txt b/examples/CMakeLists.txt
index 2d449e4bf..1fcec94b4 100644
--- a/examples/CMakeLists.txt
+++ b/examples/CMakeLists.txt
@@ -9,6 +9,10 @@ if (Tcmalloc_FOUND)
 target_link_libraries(example ${Tcmalloc_LIBRARIES})
 endif(Tcmalloc_FOUND)
 
+add_executable(example_with_all example_with_all.cpp)
+#target_link_libraries(example crow)
+target_link_libraries(example_with_all ${Boost_LIBRARIES} )
+
 add_custom_command(OUTPUT example_test.py
         COMMAND ${CMAKE_COMMAND} -E
         copy ${PROJECT_SOURCE_DIR}/example_test.py ${CMAKE_CURRENT_BINARY_DIR}/example_test.py
diff --git a/tests/unittest.cpp b/tests/unittest.cpp
index 1a157429e..4dec72754 100644
--- a/tests/unittest.cpp
+++ b/tests/unittest.cpp
@@ -863,6 +863,7 @@ TEST(simple_url_params)
 
         ASSERT_TRUE(last_url_params.get("missing") == nullptr);
         ASSERT_TRUE(last_url_params.get("foobar") != nullptr);
+        ASSERT_TRUE(last_url_params.get_list("missing").empty());
     }
     // check multiple presence
     sendmsg = "GET /params?foo&bar&baz\r\n\r\n";

From 111b34631253b2e1922222899fbec71861448482 Mon Sep 17 00:00:00 2001
From: ipknHama <ipknhama@gmail.com>
Date: Fri, 24 Oct 2014 02:12:03 +0900
Subject: [PATCH 09/11] add missing example_with_all.cpp file

---
 examples/example_with_all.cpp | 94 +++++++++++++++++++++++++++++++++++
 1 file changed, 94 insertions(+)
 create mode 100644 examples/example_with_all.cpp

diff --git a/examples/example_with_all.cpp b/examples/example_with_all.cpp
new file mode 100644
index 000000000..55e271503
--- /dev/null
+++ b/examples/example_with_all.cpp
@@ -0,0 +1,94 @@
+#include "../amalgamate/crow_all.h"
+
+#include <sstream>
+
+class ExampleLogHandler : public crow::ILogHandler {
+    public:
+        void log(std::string message, crow::LogLevel level) override {
+//            cerr << "ExampleLogHandler -> " << message;
+        }
+};
+
+int main()
+{
+    crow::SimpleApp app;
+
+    CROW_ROUTE(app, "/")
+        .name("hello")
+    ([]{
+        return "Hello World!";
+    });
+
+    CROW_ROUTE(app, "/about")
+    ([](){
+        return "About Crow example.";
+    });
+
+    // simple json response
+    CROW_ROUTE(app, "/json")
+    ([]{
+        crow::json::wvalue x;
+        x["message"] = "Hello, World!";
+        return x;
+    });
+
+    CROW_ROUTE(app,"/hello/<int>")
+    ([](int count){
+        if (count > 100)
+            return crow::response(400);
+        std::ostringstream os;
+        os << count << " bottles of beer!";
+        return crow::response(os.str());
+    });
+
+    CROW_ROUTE(app,"/add/<int>/<int>")
+    ([](const crow::request& req, crow::response& res, int a, int b){
+        std::ostringstream os;
+        os << a+b;
+        res.write(os.str());
+        res.end();
+    });
+
+    // Compile error with message "Handler type is mismatched with URL paramters"
+    //CROW_ROUTE(app,"/another/<int>")
+    //([](int a, int b){
+        //return crow::response(500);
+    //});
+
+    // more json example
+    CROW_ROUTE(app, "/add_json")
+    ([](const crow::request& req){
+        auto x = crow::json::load(req.body);
+        if (!x)
+            return crow::response(400);
+        int sum = x["a"].i()+x["b"].i();
+        std::ostringstream os;
+        os << sum;
+        return crow::response{os.str()};
+    });
+
+    CROW_ROUTE(app, "/params")
+    ([](const crow::request& req){
+        std::ostringstream os;
+        os << "Params: " << req.url_params << "\n\n"; 
+        os << "The key 'foo' was " << (req.url_params.get("foo") == nullptr ? "not " : "") << "found.\n";
+        if(req.url_params.get("pew") != nullptr) {
+            double countD = boost::lexical_cast<double>(req.url_params.get("pew"));
+            os << "The value of 'pew' is " <<  countD << '\n';
+        }
+        auto count = req.url_params.get_list("count");
+        os << "The key 'count' contains " << count.size() << " value(s).\n";
+        for(const auto& countVal : count) {
+            os << " - " << countVal << '\n';
+        }
+        return crow::response{os.str()};
+    });    
+
+    // ignore all log
+    crow::logger::setLogLevel(crow::LogLevel::DEBUG);
+    //crow::logger::setHandler(std::make_shared<ExampleLogHandler>());
+
+    app.port(18080)
+        .multithreaded()
+        .run();
+}

From bdc9dd8d480b2d116b80f795f38cc8ed28dbb93d Mon Sep 17 00:00:00 2001
From: ipknHama <ipknhama@gmail.com>
Date: Fri, 24 Oct 2014 02:45:34 +0900
Subject: [PATCH 10/11] added missing header for amalgate

---
 include/common.h          | 1 +
 include/http_connection.h | 1 +
 include/http_server.h     | 1 +
 include/json.h            | 1 +
 include/routing.h         | 1 +
 5 files changed, 5 insertions(+)

diff --git a/include/common.h b/include/common.h
index 5720b46b5..d19076aff 100644
--- a/include/common.h
+++ b/include/common.h
@@ -1,5 +1,6 @@
 #pragma once
 
+#include <vector>
 #include <string>
 #include <stdexcept>
 #include "utility.h"
diff --git a/include/http_connection.h b/include/http_connection.h
index 537be894b..d88bc253b 100644
--- a/include/http_connection.h
+++ b/include/http_connection.h
@@ -5,6 +5,7 @@
 #include <boost/array.hpp>
 #include <atomic>
 #include <chrono>
+#include <vector>
 
 #include "http_parser_merged.h"
 
diff --git a/include/http_server.h b/include/http_server.h
index 484aa83df..2241decd3 100644
--- a/include/http_server.h
+++ b/include/http_server.h
@@ -5,6 +5,7 @@
 #include <cstdint>
 #include <atomic>
 #include <future>
+#include <vector>
 
 #include <memory>
 
diff --git a/include/json.h b/include/json.h
index 9306e2aa0..d79fe8866 100644
--- a/include/json.h
+++ b/include/json.h
@@ -10,6 +10,7 @@
 #include <boost/lexical_cast.hpp>
 #include <boost/algorithm/string/predicate.hpp>
 #include <boost/operators.hpp>
+#include <vector>
 
 #if defined(__GNUG__) || defined(__clang__)
 #define crow_json_likely(x) __builtin_expect(x, 1)
diff --git a/include/routing.h b/include/routing.h
index 87d492b43..9f607f173 100644
--- a/include/routing.h
+++ b/include/routing.h
@@ -6,6 +6,7 @@
 #include <unordered_map>
 #include <memory>
 #include <boost/lexical_cast.hpp>
+#include <vector>
 
 #include "common.h"
 #include "http_response.h"

From 4b3b8070e75ce0fc181e5c012c47da2a1e7a918e Mon Sep 17 00:00:00 2001
From: ipknHama <ipknhama@gmail.com>
Date: Fri, 24 Oct 2014 04:17:20 +0900
Subject: [PATCH 11/11] added missing header for amalgate

---
 include/ci_map.h             | 2 ++
 include/common.h             | 1 +
 include/middleware_context.h | 2 ++
 include/parser.h             | 1 +
 4 files changed, 6 insertions(+)

diff --git a/include/ci_map.h b/include/ci_map.h
index 9b48f0bf2..155d54f72 100644
--- a/include/ci_map.h
+++ b/include/ci_map.h
@@ -1,6 +1,8 @@
 #pragma once
 
+#include <boost/algorithm/string/predicate.hpp>
 #include <boost/functional/hash.hpp>
+#include <unordered_map>
 
 namespace crow
 {
diff --git a/include/common.h b/include/common.h
index d19076aff..619f4d5c9 100644
--- a/include/common.h
+++ b/include/common.h
@@ -3,6 +3,7 @@
 #include <vector>
 #include <string>
 #include <stdexcept>
+#include <iostream>
 #include "utility.h"
 
 namespace crow
diff --git a/include/middleware_context.h b/include/middleware_context.h
index 980a8216b..daaaa5c7d 100644
--- a/include/middleware_context.h
+++ b/include/middleware_context.h
@@ -1,6 +1,8 @@
 #pragma once
 
 #include "utility.h"
+#include "http_request.h"
+#include "http_response.h"
 
 namespace crow
 {
diff --git a/include/parser.h b/include/parser.h
index 6ead8fd0e..f6b748b55 100644
--- a/include/parser.h
+++ b/include/parser.h
@@ -6,6 +6,7 @@
 #include <boost/tokenizer.hpp>
 #include <algorithm>
 
+#include "http_parser_merged.h"
 #include "http_request.h"
 
 namespace crow