RoutingHttpWebApp.hpp

Go to the documentation of this file.

// @formatter:off
//
// Balau core C++ library
//
// Copyright (C) 2017 Bora Software (contact@borasoftware.com)
//
// Licensed under the Boost Software License - Version 1.0 - August 17th, 2003.
// See the LICENSE file for the full license text.
//


#ifndef COM_BORA_SOFTWARE__BALAU_NETWORK_HTTP_SERVER_HTTP_WEB_APPS__ROUTING_HTTP_WEB_APP
#define COM_BORA_SOFTWARE__BALAU_NETWORK_HTTP_SERVER_HTTP_WEB_APPS__ROUTING_HTTP_WEB_APP

#include <Balau/Container/ObjectTrie.hpp>
#include <Balau/Network/Http/Server/HttpWebApp.hpp>

namespace Balau::Network::Http::HttpWebApps {

class RoutingHttpWebApp : public HttpWebApp {
    public: using HttpWebAppPtr = std::shared_ptr<HttpWebApp>;

    public: using Value = std::tuple<std::string, HttpWebAppPtr, HttpWebAppPtr, HttpWebAppPtr>;

    public: using Node = Container::ObjectTrieNode<Value>;

    public: using Routing = Container::ObjectTrie<Value>;

    public: static constexpr size_t KeyIndex = 0;
    public: static constexpr size_t GetHandlerIndex = 1;
    public: static constexpr size_t HeadHandlerIndex = 2;
    public: static constexpr size_t PostHandlerIndex = 3;

    public: RoutingHttpWebApp(Routing && routing_) : routing(std::move(routing_)) {}

    public: void handleGetRequest(HttpSession & session,
                                  const StringRequest & request,
                                  std::map<std::string, std::string> & variables) override {
        HttpWebApp * handler = resolve(session, request);

        if (handler != nullptr) {
            handler->handleGetRequest(session, request, variables);
        }
    }

    public: void handleHeadRequest(HttpSession & session,
                                   const StringRequest & request,
                                   std::map<std::string, std::string> & variables) override {
        HttpWebApp * handler = resolve(session, request);

        if (handler != nullptr) {
            handler->handleHeadRequest(session, request, variables);
        }
    }

    public: void handlePostRequest(HttpSession & session,
                                   const StringRequest & request,
                                   std::map<std::string, std::string> & variables) override {
        HttpWebApp * handler = resolve(session, request);

        if (handler != nullptr) {
            handler->handlePostRequest(session, request, variables);
        }
    }


    //private: HttpWebApp * resolve(HttpSession & session, const StringRequest & request);
    private: HttpWebApp * resolve(HttpSession & session, const StringRequest & request) {
        const std::string_view & path = std::string_view(request.target().data(), request.target().length());
        auto pathComponents = Util::Strings::split(path, "/");
        std::vector<std::string_view> components;
        components.reserve(pathComponents.size() + 1);
        components.emplace_back("");
        Util::Vectors::append(components, pathComponents);

        Node * node = routing.findNearest(components, [] (auto & lhs, auto & rhs) { return std::get<KeyIndex>(lhs) == rhs; }, false);

        if (node != nullptr) {
            HttpWebApp * handler;

            switch (request.method()) {
                case Method::get: {
                    handler = std::get<GetHandlerIndex>(node->value).get();
                    break;
                }

                case Method::head: {
                    handler = std::get<HeadHandlerIndex>(node->value).get();
                    break;
                }

                case Method::post: {
                    handler = std::get<PostHandlerIndex>(node->value).get();
                    break;
                }

                default: {
                    handler = nullptr;
                    break;
                }
            }

            if (handler != nullptr) {
                return handler;
            }
        }

        // No handler found for method.
        sendNotFoundResponse(session, request);
        return nullptr;
    }

    private: void sendNotFoundResponse(HttpSession & session, const StringRequest & request);

    private: Routing routing;
};

template <typename HandlerT, typename ... ParamT>
inline RoutingHttpWebApp::Value routingNode(const std::string & key, ParamT && ... param) {
    auto handler = std::shared_ptr<HttpWebApp>(new HandlerT(std::move(param) ...));
    return RoutingHttpWebApp::Value(key, handler, handler, handler);
}

template <typename HandlerT>
inline RoutingHttpWebApp::Value routingNode(const std::string & key) {
    auto handler = std::shared_ptr<HttpWebApp>(new HandlerT);
    return RoutingHttpWebApp::Value(key, handler, handler, handler);
}

inline RoutingHttpWebApp::Value routingNode(const std::string & key) {
    auto handler = std::shared_ptr<HttpWebApp>(nullptr);
    return RoutingHttpWebApp::Value(key, handler, handler, handler);
}

} // namespace Balau::Network::Http::HttpWebApps

#endif // COM_BORA_SOFTWARE__BALAU_NETWORK_HTTP_SERVER_HTTP_WEB_APPS__ROUTING_HTTP_WEB_APP