express::dispatcher::RouterDispatcher Class Reference

#include <RouterDispatcher.h>

Inheritance diagram for express::dispatcher::RouterDispatcher:

Collaboration diagram for express::dispatcher::RouterDispatcher:

Public Member Functions
std::list< express::Route > &	getRoutes ()
std::list< std::string >	getRoutes (const std::string &parentMountPath, const MountPoint &mountPoint) const
bool	setStrictRouting (bool strictRouting)
bool	getStrictRouting () const
bool	setCaseInsensitiveRouting (bool caseInsensitiveRouting)
bool	getCaseInsensitiveRouting () const
Public Member Functions inherited from express::Dispatcher
	Dispatcher (const Dispatcher &)=delete
Dispatcher &	operator= (const Dispatcher &)=delete
	Dispatcher ()=default
virtual	~Dispatcher ()
bool	dispatchNext (Controller &controller, const std::string &parentMountPath)

Private Member Functions
bool	dispatch (express::Controller &controller, const std::string &parentMountPath, const express::MountPoint &mountPoint) override
std::list< std::string >	getRoutes (const std::string &parentMountPath, const MountPoint &mountPoint, bool strictRouting) const override

Private Attributes
std::list< express::Route >	routes
bool	strictRouting = false
bool	caseInsensitiveRouting = false
std::regex	regex
std::vector< std::string >	names

Additional Inherited Members
Protected Attributes inherited from express::Dispatcher
std::shared_ptr< Route >	nextRoute = nullptr

Detailed Description

Definition at line 62 of file RouterDispatcher.h.

Member Function Documentation

dispatch()

bool express::dispatcher::RouterDispatcher::dispatch ( express::Controller &  controller, const std::string &  parentMountPath, const express::MountPoint &  mountPoint  )

overrideprivatevirtual

Implements express::Dispatcher.

Definition at line 94 of file RouterDispatcher.cpp.

                                                                                                                                   {
        bool dispatched = false;
 
        const std::string absoluteMountPath = parentMountPath + mountPoint.relativeMountPath;
 
        // Split mount & request into path + query
        std::string_view mountPath;
        std::string_view mountQueryString;
        splitPathAndQuery(absoluteMountPath, mountPath, mountQueryString);
        const std::unordered_map<std::string, std::string> requiredQueryPairs = parseQuery(mountQueryString);
 
        std::string_view requestPath;
        std::string_view requestQueryString;
        splitPathAndQuery(controller.getRequest()->originalUrl, requestPath, requestQueryString);
        const std::unordered_map<std::string, std::string> requestQueryPairs = parseQuery(requestQueryString);
 
        // Normalize single trailing slash if not strict
        if (!controller.getStrictRouting()) {
            mountPath = trimOneTrailingSlash(mountPath);
            requestPath = trimOneTrailingSlash(requestPath);
        }
        if (mountPath.empty()) {
            mountPath = "/";
        }
 
        // Router is **prefix** with boundary (like app.use)
        bool pathMatches = false;
        if (absoluteMountPath.find(':') != std::string::npos) {
            if (regex.mark_count() == 0) {
                LOG(TRACE) << "RouterDispatcher: precompiled regex";
                std::tie(regex, names) = compileParamRegex(mountPath,
                                                           /*isPrefix*/ true,
                                                           controller.getStrictRouting(),
                                                           controller.getCaseInsensitiveRouting());
            } else {
                LOG(TRACE) << "RouterDispatcher: using precompiled regex";
            }
 
            pathMatches = matchAndFillParams(regex, names, requestPath, *controller.getRequest());
        } else {
            pathMatches = boundaryPrefix(requestPath, mountPath, controller.getCaseInsensitiveRouting());
        }
        const bool queryMatches = querySupersetMatches(requestQueryPairs, requiredQueryPairs);
 
        const bool requestMatched = (pathMatches && queryMatches);
 
        LOG(TRACE) << controller.getResponse()->getSocketContext()->getSocketConnection()->getConnectionName()
                   << " HTTP Express: router -> " << (requestMatched ? "MATCH" : "NO MATCH");
        LOG(TRACE) << "           RequestMethod: " << controller.getRequest()->method;
        LOG(TRACE) << "              RequestUrl: " << controller.getRequest()->url;
        LOG(TRACE) << "             RequestPath: " << controller.getRequest()->path;
        LOG(TRACE) << "       AbsoluteMountPath: " << absoluteMountPath;
        LOG(TRACE) << "           StrictRouting: " << controller.getStrictRouting();
        LOG(TRACE) << "  CaseInsensitiveRouting: " << controller.getCaseInsensitiveRouting();
 
        if (requestMatched) {
            // Compute remainder and temporarily **rewrite req.path** for subtree
            std::size_t consumedLength = 0;
            if (absoluteMountPath.find(':') != std::string::npos) {
                // Run (or reuse) the param regex match and take its full-match length
                std::cmatch regexMatches;
                auto [regex, names] =
                    compileParamRegex(mountPath, /*isPrefix*/ true, controller.getStrictRouting(), controller.getCaseInsensitiveRouting());
                if (!std::regex_search(requestPath.begin(), requestPath.end(), regexMatches, regex)) {
                    return false; // should not happen because pathMatches was true, but be safe
                }
                consumedLength = static_cast<std::size_t>(regexMatches.length(0)); // <-- ACTUAL matched prefix
            } else {
                // Literal boundary prefix: consume exactly the base length
                consumedLength = mountPath.size();
            }
 
            // Now compute remainder using 'consumedLength'
            std::string_view remainderPath{};
            if (requestPath.size() > consumedLength) {
                remainderPath = requestPath.substr(consumedLength);
                if (!remainderPath.empty() && remainderPath.front() == '/') {
                    remainderPath.remove_prefix(1);
                }
            }
 
            auto& req = *controller.getRequest();
            const std::string previousPathBackup = req.path;
            req.path = remainderPath.empty() ? "/" : ("/" + std::string(remainderPath));
 
            req.queries.insert(requestQueryPairs.begin(), requestQueryPairs.end());
 
            for (Route& route : routes) {
                const bool oldStrictRouting = controller.setStrictRouting(strictRouting);
 
                dispatched = route.dispatch(controller, absoluteMountPath);
 
                controller.setStrictRouting(oldStrictRouting);
 
                if (dispatched) {
                    LOG(TRACE) << "Express: R - Dispatched";
 
                    break;
                }
                if (controller.nextRouterCalled()) {
                    LOG(TRACE) << "Express: R - NextRouter called - breaking dispatching";
 
                    break;
                }
            }
 
            req.path = previousPathBackup;
        }
 
        return dispatched;
    }

References express::dispatcher::boundaryPrefix(), express::dispatcher::compileParamRegex(), express::Route::dispatch(), express::Controller::getCaseInsensitiveRouting(), core::socket::stream::SocketConnection::getConnectionName(), express::Controller::getRequest(), express::Controller::getResponse(), core::socket::stream::SocketContext::getSocketConnection(), express::Response::getSocketContext(), express::Controller::getStrictRouting(), express::dispatcher::matchAndFillParams(), express::Request::method, names, express::Controller::nextRouterCalled(), express::Request::originalUrl, express::dispatcher::parseQuery(), express::Request::path, express::Request::queries, express::dispatcher::querySupersetMatches(), express::MountPoint::relativeMountPath, routes, express::Controller::setStrictRouting(), express::dispatcher::splitPathAndQuery(), strictRouting, express::dispatcher::trimOneTrailingSlash(), and express::Request::url.

Here is the call graph for this function:

getCaseInsensitiveRouting()

bool express::dispatcher::RouterDispatcher::getCaseInsensitiveRouting

(

)

const

Definition at line 89 of file RouterDispatcher.cpp.

                                                           {
        return caseInsensitiveRouting;
    }

References caseInsensitiveRouting.

Referenced by express::RootRoute::dispatch(), and express::RootRoute::setCaseInsensitiveRouting().

Here is the caller graph for this function:

getRoutes() [1/3]

std::list< Route > & express::dispatcher::RouterDispatcher::getRoutes

(

)

Definition at line 65 of file RouterDispatcher.cpp.

                                                {
        return routes;
    }

References routes.

Referenced by express::RootRoute::routes().

Here is the caller graph for this function:

getRoutes() [2/3]

std::list< std::string > express::dispatcher::RouterDispatcher::getRoutes	(	const std::string &	parentMountPath,
		const MountPoint &	mountPoint
	)		const

Definition at line 206 of file RouterDispatcher.cpp.

                                                                                                                       {
        return getRoutes(parentMountPath, mountPoint, strictRouting);
    }

References getRoutes(), and strictRouting.

Referenced by express::RootRoute::getRoutes().

Here is the call graph for this function:

Here is the caller graph for this function:

getRoutes() [3/3]

std::list< std::string > express::dispatcher::RouterDispatcher::getRoutes ( const std::string &  parentMountPath, const MountPoint &  mountPoint, bool  strictRouting  ) const

overrideprivatevirtual

Implements express::Dispatcher.

Definition at line 211 of file RouterDispatcher.cpp.

                                                                                                                        {
        std::list<std::string> collectedRoutes;
 
        for (const Route& route : routes) {
            collectedRoutes.splice(
                collectedRoutes.end(),
                route.getRoute(parentMountPath + "$" + mountPoint.relativeMountPath + "$", this->strictRouting ? true : strictRouting));
        }
 
        return collectedRoutes;
    }

References express::Route::getRoute(), express::MountPoint::relativeMountPath, routes, and strictRouting.

Referenced by getRoutes().

Here is the call graph for this function:

Here is the caller graph for this function:

getStrictRouting()

bool express::dispatcher::RouterDispatcher::getStrictRouting

(

)

const

Definition at line 77 of file RouterDispatcher.cpp.

                                                  {
        return strictRouting;
    }

References strictRouting.

Referenced by express::RootRoute::dispatch(), and express::RootRoute::setStrictRouting().

Here is the caller graph for this function:

setCaseInsensitiveRouting()

bool express::dispatcher::RouterDispatcher::setCaseInsensitiveRouting

(

bool

caseInsensitiveRouting

)

Definition at line 81 of file RouterDispatcher.cpp.

                                                                                {
        const bool oldCaseInsensitiveRouting = this->caseInsensitiveRouting;
 
        this->caseInsensitiveRouting = caseInsensitiveRouting;
 
        return oldCaseInsensitiveRouting;
    }

References caseInsensitiveRouting.

Referenced by express::RootRoute::setCaseInsensitiveRouting().

Here is the caller graph for this function:

setStrictRouting()

bool express::dispatcher::RouterDispatcher::setStrictRouting

(

bool

strictRouting

)

Definition at line 69 of file RouterDispatcher.cpp.

                                                              {
        const bool oldStrictRouting = this->strictRouting;
 
        this->strictRouting = strictRouting;
 
        return oldStrictRouting;
    }

References strictRouting.

Referenced by express::RootRoute::setStrictRouting().

Here is the caller graph for this function:

Member Data Documentation

caseInsensitiveRouting

bool express::dispatcher::RouterDispatcher::caseInsensitiveRouting = false

private

Definition at line 82 of file RouterDispatcher.h.

Referenced by getCaseInsensitiveRouting(), and setCaseInsensitiveRouting().

names

std::vector<std::string> express::dispatcher::RouterDispatcher::names

private

Definition at line 85 of file RouterDispatcher.h.

Referenced by dispatch().

regex

std::regex express::dispatcher::RouterDispatcher::regex

private

Definition at line 84 of file RouterDispatcher.h.

routes

std::list<express::Route> express::dispatcher::RouterDispatcher::routes

private

Definition at line 79 of file RouterDispatcher.h.

Referenced by dispatch(), getRoutes(), and getRoutes().

strictRouting

bool express::dispatcher::RouterDispatcher::strictRouting = false

private

Definition at line 81 of file RouterDispatcher.h.

Referenced by dispatch(), getRoutes(), getRoutes(), getStrictRouting(), and setStrictRouting().

---

The documentation for this class was generated from the following files:

• express/dispatcher/RouterDispatcher.h
• express/dispatcher/RouterDispatcher.cpp