Cleanup include folder into crow subfolder

- only crow.h is exposed now

examples/example.cpp

@@ -1,5 +1,4 @@
 #include "crow.h"
-#include "json.h"
 
 #include <sstream>
 

examples/example_chat.cpp

@@ -1,6 +1,4 @@
 #include "crow.h"
-#include "json.h"
-#include "mustache.h"
 #include <string>
 #include <vector>
 #include <chrono>

examples/example_vs.cpp

@@ -1,5 +1,4 @@
 #include "crow.h"
-#include "json.h"
 
 #include <sstream>
 

examples/websocket/example_ws.cpp

@@ -1,6 +1,4 @@
 #include "crow.h"
-#include "mustache.h"
-#include "websocket.h"
 #include <unordered_set>
 #include <mutex>
 

include/crow.h

@@ -1,242 +1,23 @@
 #pragma once
-
-#include <chrono>
-#include <string>
-#include <functional>
-#include <memory>
-#include <future>
-#include <cstdint>
-#include <type_traits>
-#include <thread>
-
-#include "settings.h"
-#include "logging.h"
-#include "utility.h"
-#include "routing.h"
-#include "middleware_context.h"
-#include "http_request.h"
-#include "http_server.h"
-
-
-#ifdef CROW_MSVC_WORKAROUND
-#define CROW_ROUTE(app, url) app.route_dynamic(url)
-#else
-#define CROW_ROUTE(app, url) app.route<crow::black_magic::get_parameter_tag(url)>(url)
-#endif
-
-namespace crow
-{
-#ifdef CROW_ENABLE_SSL
-    using ssl_context_t = boost::asio::ssl::context;
-#endif
-    template <typename ... Middlewares>
-    class Crow
-    {
-    public:
-        using self_t = Crow;
-        using server_t = Server<Crow, SocketAdaptor, Middlewares...>;
-#ifdef CROW_ENABLE_SSL
-        using ssl_server_t = Server<Crow, SSLAdaptor, Middlewares...>;
-#endif
-        Crow()
-        {
-        }
-
-		template <typename Adaptor> 
-        void handle_upgrade(const request& req, response& res, Adaptor&& adaptor)
-        {
-            router_.handle_upgrade(req, res, adaptor);
-        }
-
-        void handle(const request& req, response& res)
-        {
-            router_.handle(req, res);
-        }
-
-        DynamicRule& route_dynamic(std::string&& rule)
-        {
-            return router_.new_rule_dynamic(std::move(rule));
-        }
-
-        template <uint64_t Tag>
-        auto route(std::string&& rule)
-            -> typename std::result_of<decltype(&Router::new_rule_tagged<Tag>)(Router, std::string&&)>::type
-        {
-            return router_.new_rule_tagged<Tag>(std::move(rule));
-        }
-
-        self_t& port(std::uint16_t port)
-        {
-            port_ = port;
-            return *this;
-        }
-
-        self_t& bindaddr(std::string bindaddr)
-        {
-            bindaddr_ = bindaddr;
-            return *this;
-        }
-
-        self_t& multithreaded()
-        {
-            return concurrency(std::thread::hardware_concurrency());
-        }
-
-        self_t& concurrency(std::uint16_t concurrency)
-        {
-            if (concurrency < 1)
-                concurrency = 1;
-            concurrency_ = concurrency;
-            return *this;
-        }
-
-        void validate()
-        {
-            router_.validate();
-        }
-
-        void run()
-        {
-            validate();
-#ifdef CROW_ENABLE_SSL
-            if (use_ssl_)
-            {
-                ssl_server_ = std::move(std::unique_ptr<ssl_server_t>(new ssl_server_t(this, bindaddr_, port_, &middlewares_, concurrency_, &ssl_context_)));
-                ssl_server_->set_tick_function(tick_interval_, tick_function_);
-                ssl_server_->run();
-            }
-            else
-#endif
-            {
-                server_ = std::move(std::unique_ptr<server_t>(new server_t(this, bindaddr_, port_, &middlewares_, concurrency_, nullptr)));
-                server_->set_tick_function(tick_interval_, tick_function_);
-                server_->run();
-            }
-        }
-
-        void stop()
-        {
-#ifdef CROW_ENABLE_SSL
-            if (use_ssl_)
-            {
-                ssl_server_->stop();
-            }
-            else
-#endif
-            {
-                server_->stop();
-            }
-        }
-
-        void debug_print()
-        {
-            CROW_LOG_DEBUG << "Routing:";
-            router_.debug_print();
-        }
-
-#ifdef CROW_ENABLE_SSL
-        self_t& ssl_file(const std::string& crt_filename, const std::string& key_filename)
-        {
-            use_ssl_ = true;
-            ssl_context_.set_verify_mode(boost::asio::ssl::verify_peer);
-            ssl_context_.use_certificate_file(crt_filename, ssl_context_t::pem);
-            ssl_context_.use_private_key_file(key_filename, ssl_context_t::pem);
-            ssl_context_.set_options(
-                    boost::asio::ssl::context::default_workarounds
-                          | boost::asio::ssl::context::no_sslv2
-                          | boost::asio::ssl::context::no_sslv3
-                    );
-            return *this;
-        }
-
-        self_t& ssl_file(const std::string& pem_filename)
-        {
-            use_ssl_ = true;
-            ssl_context_.set_verify_mode(boost::asio::ssl::verify_peer);
-            ssl_context_.load_verify_file(pem_filename);
-            ssl_context_.set_options(
-                    boost::asio::ssl::context::default_workarounds
-                          | boost::asio::ssl::context::no_sslv2
-                          | boost::asio::ssl::context::no_sslv3
-                    );
-            return *this;
-        }
-
-        self_t& ssl(boost::asio::ssl::context&& ctx)
-        {
-            use_ssl_ = true;
-            ssl_context_ = std::move(ctx);
-            return *this;
-        }
-
-
-        bool use_ssl_{false};
-        ssl_context_t ssl_context_{boost::asio::ssl::context::sslv23};
-
-#else
-        template <typename T, typename ... Remain>
-        self_t& ssl_file(T&&, Remain&&...)
-        {
-            // We can't call .ssl() member function unless CROW_ENABLE_SSL is defined.
-            static_assert(
-                    // make static_assert dependent to T; always false
-                    std::is_base_of<T, void>::value,
-                    "Define CROW_ENABLE_SSL to enable ssl support.");
-            return *this;
-        }
-
-        template <typename T>
-        self_t& ssl(T&&)
-        {
-            // We can't call .ssl() member function unless CROW_ENABLE_SSL is defined.
-            static_assert(
-                    // make static_assert dependent to T; always false
-                    std::is_base_of<T, void>::value,
-                    "Define CROW_ENABLE_SSL to enable ssl support.");
-            return *this;
-        }
-#endif
-
-        // middleware
-        using context_t = detail::context<Middlewares...>;
-        template <typename T>
-        typename T::context& get_context(const request& req)
-        {
-            static_assert(black_magic::contains<T, Middlewares...>::value, "App doesn't have the specified middleware type.");
-            auto& ctx = *reinterpret_cast<context_t*>(req.middleware_context);
-            return ctx.template get<T>();
-        }
-
-        template <typename T>
-        T& get_middleware()
-        {
-            return utility::get_element_by_type<T, Middlewares...>(middlewares_);
-        }
-
-        template <typename Duration, typename Func>
-        self_t& tick(Duration d, Func f) {
-            tick_interval_ = std::chrono::duration_cast<std::chrono::milliseconds>(d);
-            tick_function_ = f;
-            return *this;
-        }
-
-    private:
-        uint16_t port_ = 80;
-        uint16_t concurrency_ = 1;
-        std::string bindaddr_ = "0.0.0.0";
-        Router router_;
-
-        std::chrono::milliseconds tick_interval_;
-        std::function<void()> tick_function_;
-
-        std::tuple<Middlewares...> middlewares_;
-
-#ifdef CROW_ENABLE_SSL
-        std::unique_ptr<ssl_server_t> ssl_server_;
-#endif
-        std::unique_ptr<server_t> server_;
-    };
-    template <typename ... Middlewares>
-    using App = Crow<Middlewares...>;
-    using SimpleApp = Crow<>;
-}
+#include "crow/query_string.h"
+#include "crow/http_parser_merged.h"
+#include "crow/ci_map.h"
+#include "crow/TinySHA1.hpp"
+#include "crow/settings.h"
+#include "crow/socket_adaptors.h"
+#include "crow/json.h"
+#include "crow/mustache.h"
+#include "crow/logging.h"
+#include "crow/dumb_timer_queue.h"
+#include "crow/utility.h"
+#include "crow/common.h"
+#include "crow/http_request.h"
+#include "crow/websocket.h"
+#include "crow/parser.h"
+#include "crow/http_response.h"
+#include "crow/middleware.h"
+#include "crow/routing.h"
+#include "crow/middleware_context.h"
+#include "crow/http_connection.h"
+#include "crow/http_server.h"
+#include "crow/app.h"

include/crow/app.h

@@ -0,0 +1,242 @@
+#pragma once
+
+#include <chrono>
+#include <string>
+#include <functional>
+#include <memory>
+#include <future>
+#include <cstdint>
+#include <type_traits>
+#include <thread>
+
+#include "crow/settings.h"
+#include "crow/logging.h"
+#include "crow/utility.h"
+#include "crow/routing.h"
+#include "crow/middleware_context.h"
+#include "crow/http_request.h"
+#include "crow/http_server.h"
+
+
+#ifdef CROW_MSVC_WORKAROUND
+#define CROW_ROUTE(app, url) app.route_dynamic(url)
+#else
+#define CROW_ROUTE(app, url) app.route<crow::black_magic::get_parameter_tag(url)>(url)
+#endif
+
+namespace crow
+{
+#ifdef CROW_ENABLE_SSL
+    using ssl_context_t = boost::asio::ssl::context;
+#endif
+    template <typename ... Middlewares>
+    class Crow
+    {
+    public:
+        using self_t = Crow;
+        using server_t = Server<Crow, SocketAdaptor, Middlewares...>;
+#ifdef CROW_ENABLE_SSL
+        using ssl_server_t = Server<Crow, SSLAdaptor, Middlewares...>;
+#endif
+        Crow()
+        {
+        }
+
+		template <typename Adaptor> 
+        void handle_upgrade(const request& req, response& res, Adaptor&& adaptor)
+        {
+            router_.handle_upgrade(req, res, adaptor);
+        }
+
+        void handle(const request& req, response& res)
+        {
+            router_.handle(req, res);
+        }
+
+        DynamicRule& route_dynamic(std::string&& rule)
+        {
+            return router_.new_rule_dynamic(std::move(rule));
+        }
+
+        template <uint64_t Tag>
+        auto route(std::string&& rule)
+            -> typename std::result_of<decltype(&Router::new_rule_tagged<Tag>)(Router, std::string&&)>::type
+        {
+            return router_.new_rule_tagged<Tag>(std::move(rule));
+        }
+
+        self_t& port(std::uint16_t port)
+        {
+            port_ = port;
+            return *this;
+        }
+
+        self_t& bindaddr(std::string bindaddr)
+        {
+            bindaddr_ = bindaddr;
+            return *this;
+        }
+
+        self_t& multithreaded()
+        {
+            return concurrency(std::thread::hardware_concurrency());
+        }
+
+        self_t& concurrency(std::uint16_t concurrency)
+        {
+            if (concurrency < 1)
+                concurrency = 1;
+            concurrency_ = concurrency;
+            return *this;
+        }
+
+        void validate()
+        {
+            router_.validate();
+        }
+
+        void run()
+        {
+            validate();
+#ifdef CROW_ENABLE_SSL
+            if (use_ssl_)
+            {
+                ssl_server_ = std::move(std::unique_ptr<ssl_server_t>(new ssl_server_t(this, bindaddr_, port_, &middlewares_, concurrency_, &ssl_context_)));
+                ssl_server_->set_tick_function(tick_interval_, tick_function_);
+                ssl_server_->run();
+            }
+            else
+#endif
+            {
+                server_ = std::move(std::unique_ptr<server_t>(new server_t(this, bindaddr_, port_, &middlewares_, concurrency_, nullptr)));
+                server_->set_tick_function(tick_interval_, tick_function_);
+                server_->run();
+            }
+        }
+
+        void stop()
+        {
+#ifdef CROW_ENABLE_SSL
+            if (use_ssl_)
+            {
+                ssl_server_->stop();
+            }
+            else
+#endif
+            {
+                server_->stop();
+            }
+        }
+
+        void debug_print()
+        {
+            CROW_LOG_DEBUG << "Routing:";
+            router_.debug_print();
+        }
+
+#ifdef CROW_ENABLE_SSL
+        self_t& ssl_file(const std::string& crt_filename, const std::string& key_filename)
+        {
+            use_ssl_ = true;
+            ssl_context_.set_verify_mode(boost::asio::ssl::verify_peer);
+            ssl_context_.use_certificate_file(crt_filename, ssl_context_t::pem);
+            ssl_context_.use_private_key_file(key_filename, ssl_context_t::pem);
+            ssl_context_.set_options(
+                    boost::asio::ssl::context::default_workarounds
+                          | boost::asio::ssl::context::no_sslv2
+                          | boost::asio::ssl::context::no_sslv3
+                    );
+            return *this;
+        }
+
+        self_t& ssl_file(const std::string& pem_filename)
+        {
+            use_ssl_ = true;
+            ssl_context_.set_verify_mode(boost::asio::ssl::verify_peer);
+            ssl_context_.load_verify_file(pem_filename);
+            ssl_context_.set_options(
+                    boost::asio::ssl::context::default_workarounds
+                          | boost::asio::ssl::context::no_sslv2
+                          | boost::asio::ssl::context::no_sslv3
+                    );
+            return *this;
+        }
+
+        self_t& ssl(boost::asio::ssl::context&& ctx)
+        {
+            use_ssl_ = true;
+            ssl_context_ = std::move(ctx);
+            return *this;
+        }
+
+
+        bool use_ssl_{false};
+        ssl_context_t ssl_context_{boost::asio::ssl::context::sslv23};
+
+#else
+        template <typename T, typename ... Remain>
+        self_t& ssl_file(T&&, Remain&&...)
+        {
+            // We can't call .ssl() member function unless CROW_ENABLE_SSL is defined.
+            static_assert(
+                    // make static_assert dependent to T; always false
+                    std::is_base_of<T, void>::value,
+                    "Define CROW_ENABLE_SSL to enable ssl support.");
+            return *this;
+        }
+
+        template <typename T>
+        self_t& ssl(T&&)
+        {
+            // We can't call .ssl() member function unless CROW_ENABLE_SSL is defined.
+            static_assert(
+                    // make static_assert dependent to T; always false
+                    std::is_base_of<T, void>::value,
+                    "Define CROW_ENABLE_SSL to enable ssl support.");
+            return *this;
+        }
+#endif
+
+        // middleware
+        using context_t = detail::context<Middlewares...>;
+        template <typename T>
+        typename T::context& get_context(const request& req)
+        {
+            static_assert(black_magic::contains<T, Middlewares...>::value, "App doesn't have the specified middleware type.");
+            auto& ctx = *reinterpret_cast<context_t*>(req.middleware_context);
+            return ctx.template get<T>();
+        }
+
+        template <typename T>
+        T& get_middleware()
+        {
+            return utility::get_element_by_type<T, Middlewares...>(middlewares_);
+        }
+
+        template <typename Duration, typename Func>
+        self_t& tick(Duration d, Func f) {
+            tick_interval_ = std::chrono::duration_cast<std::chrono::milliseconds>(d);
+            tick_function_ = f;
+            return *this;
+        }
+
+    private:
+        uint16_t port_ = 80;
+        uint16_t concurrency_ = 1;
+        std::string bindaddr_ = "0.0.0.0";
+        Router router_;
+
+        std::chrono::milliseconds tick_interval_;
+        std::function<void()> tick_function_;
+
+        std::tuple<Middlewares...> middlewares_;
+
+#ifdef CROW_ENABLE_SSL
+        std::unique_ptr<ssl_server_t> ssl_server_;
+#endif
+        std::unique_ptr<server_t> server_;
+    };
+    template <typename ... Middlewares>
+    using App = Crow<Middlewares...>;
+    using SimpleApp = Crow<>;
+}

include/crow/common.h

@@ -4,7 +4,7 @@
 #include <string>
 #include <stdexcept>
 #include <iostream>
-#include "utility.h"
+#include "crow/utility.h"
 
 namespace crow
 {

include/crow/dumb_timer_queue.h

@@ -6,7 +6,7 @@
 #include <chrono>
 #include <thread>
 
-#include "logging.h"
+#include "crow/logging.h"
 
 namespace crow
 {

include/crow/http_connection.h

@@ -7,15 +7,15 @@
 #include <chrono>
 #include <vector>
 
-#include "http_parser_merged.h"
+#include "crow/http_parser_merged.h"
 
-#include "parser.h"
-#include "http_response.h"
-#include "logging.h"
-#include "settings.h"
-#include "dumb_timer_queue.h"
-#include "middleware_context.h"
-#include "socket_adaptors.h"
+#include "crow/parser.h"
+#include "crow/http_response.h"
+#include "crow/logging.h"
+#include "crow/settings.h"
+#include "crow/dumb_timer_queue.h"
+#include "crow/middleware_context.h"
+#include "crow/socket_adaptors.h"
 
 namespace crow
 {

include/crow/http_request.h

@@ -1,10 +1,11 @@
 #pragma once
 
-#include "common.h"
-#include "ci_map.h"
-#include "query_string.h"
 #include <boost/asio.hpp>
 
+#include "crow/common.h"
+#include "crow/ci_map.h"
+#include "crow/query_string.h"
+
 namespace crow
 {
     template <typename T>

include/crow/http_response.h

@@ -1,9 +1,10 @@
 #pragma once
 #include <string>
 #include <unordered_map>
-#include "json.h"
-#include "http_request.h"
-#include "ci_map.h"
+
+#include "crow/json.h"
+#include "crow/http_request.h"
+#include "crow/ci_map.h"
 
 namespace crow
 {

include/crow/http_server.h

@@ -13,9 +13,9 @@
 
 #include <memory>
 
-#include "http_connection.h"
-#include "logging.h"
-#include "dumb_timer_queue.h"
+#include "crow/http_connection.h"
+#include "crow/logging.h"
+#include "crow/dumb_timer_queue.h"
 
 namespace crow
 {

include/crow/json.h

@@ -12,7 +12,7 @@
 #include <boost/operators.hpp>
 #include <vector>
 
-#include "settings.h"
+#include "crow/settings.h"
 
 #if defined(__GNUG__) || defined(__clang__)
 #define crow_json_likely(x) __builtin_expect(x, 1)

include/crow/logging.h

@@ -7,7 +7,7 @@
 #include <iostream>
 #include <sstream>
 
-#include "settings.h"
+#include "crow/settings.h"
 
 namespace crow
 {

include/crow/middleware.h

@@ -1,7 +1,7 @@
 #pragma once
 #include <boost/algorithm/string/trim.hpp>
-#include "http_request.h"
-#include "http_response.h"
+#include "crow/http_request.h"
+#include "crow/http_response.h"
 
 namespace crow
 {

include/crow/middleware_context.h

@@ -1,8 +1,8 @@
 #pragma once
 
-#include "utility.h"
-#include "http_request.h"
-#include "http_response.h"
+#include "crow/utility.h"
+#include "crow/http_request.h"
+#include "crow/http_response.h"
 
 namespace crow
 {

include/crow/mustache.h

@@ -4,7 +4,7 @@
 #include <fstream>
 #include <iterator>
 #include <functional>
-#include "json.h"
+#include "crow/json.h"
 namespace crow
 {
     namespace mustache

include/crow/parser.h

@@ -6,8 +6,8 @@
 #include <boost/tokenizer.hpp>
 #include <algorithm>
 
-#include "http_parser_merged.h"
-#include "http_request.h"
+#include "crow/http_parser_merged.h"
+#include "crow/http_request.h"
 
 namespace crow
 {

include/crow/query_string.h

@@ -6,6 +6,8 @@
 #include <vector>
 #include <iostream>
 
+namespace crow
+{
 // ----------------------------------------------------------------------------
 // qs_parse (modified)
 // https://github.com/bartgrantham/qs_parse
@@ -231,6 +233,7 @@ inline char * qs_scanvalue(const char * key, const char * qs, char * val, size_t
 
     return val;
 }
+}
 // ----------------------------------------------------------------------------
 
 

include/crow/routing.h

@@ -8,12 +8,12 @@
 #include <boost/lexical_cast.hpp>
 #include <vector>
 
-#include "common.h"
-#include "http_response.h"
-#include "http_request.h"
-#include "utility.h"
-#include "logging.h"
-#include "websocket.h"
+#include "crow/common.h"
+#include "crow/http_response.h"
+#include "crow/http_request.h"
+#include "crow/utility.h"
+#include "crow/logging.h"
+#include "crow/websocket.h"
 
 namespace crow
 {

include/crow/socket_adaptors.h

@@ -3,7 +3,7 @@
 #ifdef CROW_ENABLE_SSL
 #include <boost/asio/ssl.hpp>
 #endif
-#include "settings.h"
+#include "crow/settings.h"
 namespace crow
 {
     using namespace boost;

include/crow/utility.h

@@ -8,7 +8,7 @@
 #include <functional>
 #include <string>
 
-#include "settings.h"
+#include "crow/settings.h"
 
 namespace crow
 {

include/crow/websocket.h

@@ -1,8 +1,8 @@
 #pragma once
 #include <boost/algorithm/string/predicate.hpp>
-#include "socket_adaptors.h"
-#include "http_request.h"
-#include "TinySHA1.hpp"
+#include "crow/socket_adaptors.h"
+#include "crow/http_request.h"
+#include "crow/TinySHA1.hpp"
 
 namespace crow
 {

tests/template/mustachetest.cpp

@@ -2,8 +2,8 @@
 #include <fstream>
 #include <string>
 #include <iterator>
-#include "mustache.h"
-#include "json.h"
+#include "crow/mustache.h"
+#include "crow/json.h"
 using namespace std;
 using namespace crow;
 using namespace crow::mustache;

tests/unittest.cpp

@@ -3,16 +3,9 @@
 #include <iostream>
 #include <sstream>
 #include <vector>
-#include "settings.h"
+#include "crow.h"
 #undef CROW_LOG_LEVEL
 #define CROW_LOG_LEVEL 0
-#include "routing.h"
-#include "utility.h"
-#include "crow.h"
-#include "json.h"
-#include "mustache.h"
-#include "middleware.h"
-#include "query_string.h"
 
 using namespace std;
 using namespace crow;