httprouter.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_HTTP
#include <promeki/namespace.h>
#include <promeki/string.h>
#include <promeki/list.h>
#include <promeki/hashmap.h>
#include <promeki/httpmethod.h>
#include <promeki/httprequest.h>
#include <promeki/httpresponse.h>
#include <promeki/httphandler.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class HttpRouter {
        public:
                HttpRouter();
 
                ~HttpRouter();
 
                void route(const String &pattern, const HttpMethod &method, HttpHandlerFunc handler);
 
                void route(const String &pattern, const HttpMethod &method, HttpHandler::Ptr handler);
 
                void any(const String &pattern, HttpHandlerFunc handler);
                void any(const String &pattern, HttpHandler::Ptr handler);
 
                void use(HttpMiddleware middleware);
 
                void setNotFoundHandler(HttpHandlerFunc handler);
 
                void setMethodNotAllowedHandler(HttpHandlerFunc handler);
 
                void dispatch(HttpRequest &request, HttpResponse &response) const;
 
                int routeCount() const;
 
                bool hasRoutes() const { return routeCount() > 0; }
 
                void clear();
 
        private:
                struct PatternSegment {
                                using List = ::promeki::List<PatternSegment>;
                                enum Kind {
                                        Literal,
                                        Param,
                                        Greedy
                                };
                                Kind   kind = Literal;
                                String text; 
                };
 
                struct Pattern {
                                using List = ::promeki::List<Pattern>;
                                String               source;
                                PatternSegment::List segments;
                                bool                 trailingSlash = false;
                                bool                 isExact = true; 
                };
 
                struct Route {
                                using List = ::promeki::List<Route>;
                                Pattern          pattern;
                                int              methodValue = -1; 
                                HttpHandler::Ptr handler;
                };
 
                static Pattern compilePattern(const String &source);
                static bool    matchPattern(const Pattern &pattern, const String &path,
                                            HashMap<String, String> &paramsOut);
                static int     patternScore(const Pattern &pattern);
 
                void runChain(HttpRequest &request, HttpResponse &response, HttpHandlerFunc terminal) const;
 
                static void defaultNotFound(const HttpRequest &request, HttpResponse &response);
                static void defaultMethodNotAllowed(const HttpRequest &request, HttpResponse &response);
 
                Route::List        _routes;
                HttpMiddlewareList _middleware;
                HttpHandlerFunc    _notFound;
                HttpHandlerFunc    _methodNotAllowed;
};
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_HTTP