express::dispatcher Namespace Reference

Classes
struct	MountMatchResult
class	ScopedPathStrip
class	ScopedParams
class	ApplicationDispatcher
class	MiddlewareDispatcher
class	RouterDispatcher

Functions
bool	isParamNameChar (const char c)
bool	routeNeedsRegex (std::string_view path)
bool	isRegexMetaToEscape (const char c)
void	appendEscapedLiteral (std::string &out, const char c)
bool	extractBalancedParenInner (std::string_view s, const std::size_t openPos, std::string &innerOut, std::size_t &closePosOut)
std::string	makeInnerGroupsNonCapturing (std::string_view pattern)
int	hexToInt (const char c)
bool	decodeURIComponent (std::string_view in, std::string &out)
std::string	decodeQueryComponent (std::string_view in)
bool	matchAndFillParamsAndConsume (const std::regex &rx, const std::vector< std::string > &names, std::string_view reqPath, std::map< std::string, std::string > &params, std::size_t &consumedLength, bool &decodeError)
std::unordered_map< std::string, std::string >	parseQuery (std::string_view qs)
std::pair< std::regex, std::vector< std::string > >	compileParamRegex (std::string_view mountPath, bool isPrefix, bool strictRouting, bool caseInsensitive)
bool	boundaryPrefix (std::string_view path, std::string_view base, bool caseInsensitive)
bool	equalPath (std::string_view a, std::string_view b, bool caseInsensitive)
std::string_view	trimOneTrailingSlash (std::string_view s)
void	splitPathAndQuery (std::string_view url, std::string_view &path, std::string_view &query)
bool	methodMatches (std::string_view requestMethod, const std::string &mountMethod)
std::string	joinMountPath (std::string_view parentMountPath, std::string_view relativeMountPath)
static MountMatchResult	matchMountPointImpl (express::Controller &controller, const std::string &absoluteMountPath, const express::MountPoint &mountPoint, std::regex *cachedRegex, std::vector< std::string > *cachedNames, bool strictRouting, bool caseInsensitiveRouting)
MountMatchResult	matchMountPoint (express::Controller &controller, const std::string &absoluteMountPath, const express::MountPoint &mountPoint, std::regex &cachedRegex, std::vector< std::string > &cachedNames, bool strictRouting, bool caseInsensitiveRouting)
bool	ieq (char a, char b)

Function Documentation

appendEscapedLiteral()

void express::dispatcher::appendEscapedLiteral ( std::string & out, const char c )

inline

Definition at line 105 of file regex_utils.cpp.

                                                                   {
        if (isRegexMetaToEscape(c)) {
            out.push_back('\\');
        }
        out.push_back(c);
    }

References isRegexMetaToEscape().

Referenced by compileParamRegex().

Here is the call graph for this function:

Here is the caller graph for this function:

boundaryPrefix()

bool express::dispatcher::boundaryPrefix ( std::string_view path, std::string_view base, bool caseInsensitive )

inline

Definition at line 527 of file regex_utils.cpp.

                                                                                               {
        // Normalize: an empty base is equivalent to "/"
        if (base.empty()) {
            base = "/";
        }
 
        // Special case: base "/" matches any absolute path
        if (base.size() == 1 && base[0] == '/') {
            return !path.empty() && path.front() == '/';
        }
 
        // Base longer than path cannot match
        if (base.size() > path.size()) {
            return false;
        }
 
        auto eq = [&](char a, char b) {
            return !caseInsensitive ? (a == b)
                                    : (std::tolower(static_cast<unsigned char>(a)) == std::tolower(static_cast<unsigned char>(b)));
        };
 
        // Check prefix characters
        for (size_t i = 0; i < base.size(); ++i) {
            if (!eq(path[i], base[i])) {
                return false;
            }
        }
 
        // Boundary: either exact match, or next char is a '/'
        return (path.size() == base.size()) || (path[base.size()] == '/');
    }

Referenced by matchMountPointImpl().

Here is the caller graph for this function:

compileParamRegex()

std::pair< std::regex, std::vector< std::string > > express::dispatcher::compileParamRegex ( std::string_view mountPath, bool isPrefix, bool strictRouting, bool caseInsensitive )

inline

Definition at line 339 of file regex_utils.cpp.

                                                                                                         {
        // Express v4 string route patterns support:
        //  - named params:           /users/:id
        //  - custom param patterns:  /users/:id(\d+)
        //  - param modifiers:        ?, +, *   e.g. /:id?  /:path+  /:path*
        //  - wildcards:              *         e.g. /ab*cd  /hello/world(/*)?
        //  - grouping:               ()        (converted to non-capturing by default)
        //  - operators:              ? +       (regex-like, per Express examples)
 
        std::string rx;
        rx.reserve(mountPath.size() * 2U + 32U);
        rx.push_back('^');
 
        std::vector<std::string> names;
        names.reserve(4);
 
        std::size_t splatIndex = 0;
 
        for (std::size_t i = 0; i < mountPath.size();) {
            const char c = mountPath[i];
 
            // Backslash escapes the next char literally.
            if (c == '\\') {
                if (i + 1 < mountPath.size()) {
                    appendEscapedLiteral(rx, mountPath[i + 1]);
                    i += 2;
                } else {
                    appendEscapedLiteral(rx, c);
                    ++i;
                }
                continue;
            }
 
            // Named parameter: :name, optionally :name(<regex>) and modifier ? + *
            if (c == ':') {
                std::size_t j = i + 1;
                while (j < mountPath.size() && isParamNameChar(mountPath[j])) {
                    ++j;
                }
 
                if (j == i + 1) {
                    // Lone ':' -> treat as literal.
                    appendEscapedLiteral(rx, c);
                    ++i;
                    continue;
                }
 
                std::string name(mountPath.substr(i + 1, j - (i + 1)));
                std::string paramPattern = "[^/]+";
 
                // Custom regex in parentheses: :name(<pattern>)
                if (j < mountPath.size() && mountPath[j] == '(') {
                    std::string inner;
                    std::size_t closePos = 0;
                    if (extractBalancedParenInner(mountPath, j, inner, closePos)) {
                        paramPattern = makeInnerGroupsNonCapturing(inner);
                        j = closePos + 1;
                    }
                }
 
                char modifier = '\0';
                if (j < mountPath.size() && (mountPath[j] == '?' || mountPath[j] == '+' || mountPath[j] == '*')) {
                    modifier = mountPath[j];
                    ++j;
                }
 
                // If the previous output ended with '/', include the delimiter in optional/repeat
                // to emulate Express segment-parameter behaviour.
                const bool hasLeadingSlash = (!rx.empty() && rx.back() == '/');
 
                if (hasLeadingSlash && (modifier == '?' || modifier == '+' || modifier == '*')) {
                    rx.pop_back();
 
                    if (modifier == '?') {
                        rx.append("(?:/(");
                        rx.append(paramPattern);
                        rx.append("))?");
                    } else if (modifier == '+') {
                        rx.append("/(");
                        rx.append(paramPattern);
                        rx.append("(?:/");
                        rx.append(paramPattern);
                        rx.append(")*)");
                    } else { // '*'
                        rx.append("(?:/(");
                        rx.append(paramPattern);
                        rx.append("(?:/");
                        rx.append(paramPattern);
                        rx.append(")*))?");
                    }
                } else {
                    if (modifier == '?') {
                        rx.append("(");
                        rx.append(paramPattern);
                        rx.append(")?");
                    } else if (modifier == '+') {
                        rx.append("(");
                        rx.append(paramPattern);
                        rx.append("(?:/");
                        rx.append(paramPattern);
                        rx.append(")*)");
                    } else if (modifier == '*') {
                        rx.append("(");
                        rx.append(paramPattern);
                        rx.append("(?:/");
                        rx.append(paramPattern);
                        rx.append(")*)?");
                    } else {
                        rx.append("(");
                        rx.append(paramPattern);
                        rx.append(")");
                    }
                }
 
                names.emplace_back(std::move(name));
                i = j;
                continue;
            }
 
            // Express wildcard token '*': matches any sequence including '/'.
            if (c == '*') {
                rx.append("(.*)");
                names.emplace_back(std::to_string(splatIndex++)); // Express-style numeric params
                ++i;
                continue;
            }
 
            // Grouping: convert to non-capturing by default to keep capture numbering stable.
            if (c == '(') {
                if (i + 1 < mountPath.size() && mountPath[i + 1] == '?') {
                    // Keep special groups as-is.
                    rx.push_back('(');
                } else {
                    rx.append("(?:");
                }
                ++i;
                continue;
            }
 
            if (c == ')') {
                rx.push_back(')');
                ++i;
                continue;
            }
 
            // Operators allowed by Express v4 string routes.
            if (c == '?' || c == '+') {
                rx.push_back(c);
                ++i;
                continue;
            }
 
            // Ordinary literal.
            appendEscapedLiteral(rx, c);
            ++i;
        }
 
        if (isPrefix) {
            rx.append("(?:/|$)"); // boundary prefix
        } else {
            if (!strictRouting) {
                rx.append("/?"); // allow single trailing slash
            }
            rx.push_back('$');
        }
 
        std::regex::flag_type flags = std::regex::ECMAScript;
        if (caseInsensitive) {
            flags |= std::regex::icase;
        }
 
        try {
            std::regex re(rx, flags);
            // Cache sentinel: allow caching even for regex routes without capture groups.
            if (names.empty()) {
                names.emplace_back("__compiled");
            }
            return {std::move(re), std::move(names)};
        } catch (const std::regex_error&) {
            std::regex re("a^", flags); // match-nothing
            if (names.empty()) {
                names.emplace_back("__compiled");
            }
 
            return {std::move(re), std::move(names)};
        }
    }

References appendEscapedLiteral(), extractBalancedParenInner(), isParamNameChar(), and makeInnerGroupsNonCapturing().

Referenced by matchMountPointImpl().

Here is the call graph for this function:

Here is the caller graph for this function:

decodeQueryComponent()

std::string express::dispatcher::decodeQueryComponent ( std::string_view in )

inline

Definition at line 258 of file regex_utils.cpp.

                                                             {
        std::string out;
        out.reserve(in.size());
 
        for (std::size_t i = 0; i < in.size(); ++i) {
            const char c = in[i];
            if (c == '+') {
                out.push_back(' ');
                continue;
            }
            if (c == '%' && i + 2 < in.size()) {
                const int hi = hexToInt(in[i + 1]);
                const int lo = hexToInt(in[i + 2]);
                if (hi >= 0 && lo >= 0) {
                    out.push_back(static_cast<char>((hi << 4) | lo));
                    i += 2;
                    continue;
                }
            }
            out.push_back(c);
        }
 
        return out;
    }

References hexToInt().

Referenced by parseQuery().

Here is the call graph for this function:

Here is the caller graph for this function:

decodeURIComponent()

bool express::dispatcher::decodeURIComponent ( std::string_view in, std::string & out )

inline

Definition at line 233 of file regex_utils.cpp.

                                                                      {
        out.clear();
        out.reserve(in.size());
 
        for (std::size_t i = 0; i < in.size(); ++i) {
            if (in[i] == '%') {
                if (i + 2 >= in.size()) {
                    return false;
                }
 
                const int hi = hexToInt(in[i + 1]);
                const int lo = hexToInt(in[i + 2]);
                if (hi < 0 || lo < 0) {
                    return false;
                }
                out.push_back(static_cast<char>((hi << 4) | lo));
                i += 2;
                continue;
            }
            out.push_back(in[i]);
        }
 
        return true;
    }

References hexToInt().

Referenced by matchAndFillParamsAndConsume().

Here is the call graph for this function:

Here is the caller graph for this function:

equalPath()

bool express::dispatcher::equalPath ( std::string_view a, std::string_view b, bool caseInsensitive )

inline

Definition at line 559 of file regex_utils.cpp.

                                                                                    {
        if (a.size() != b.size()) {
            return false;
        }
        for (size_t i = 0; i < a.size(); ++i) {
            if (!caseInsensitive ? (a[i] != b[i]) : !ieq(a[i], b[i])) {
                return false;
            }
        }
        return true;
    }

References ieq().

Referenced by matchMountPointImpl().

Here is the call graph for this function:

Here is the caller graph for this function:

extractBalancedParenInner()

bool express::dispatcher::extractBalancedParenInner ( std::string_view s, const std::size_t openPos, std::string & innerOut, std::size_t & closePosOut )

inline

Definition at line 113 of file regex_utils.cpp.

                                                                                                                                  {
        if (openPos >= s.size() || s[openPos] != '(') {
            return false;
        }
 
        bool escaped = false;
        bool inCharClass = false;
        int depth = 0;
 
        for (std::size_t i = openPos; i < s.size(); ++i) {
            const char c = s[i];
 
            if (escaped) {
                escaped = false;
                continue;
            }
 
            if (c == '\\') {
                escaped = true;
                continue;
            }
 
            if (inCharClass) {
                if (c == ']') {
                    inCharClass = false;
                }
                continue;
            }
 
            if (c == '[') {
                inCharClass = true;
                continue;
            }
 
            if (c == '(') {
                ++depth;
                continue;
            }
 
            if (c == ')') {
                --depth;
                if (depth == 0) {
                    closePosOut = i;
                    innerOut.assign(s.substr(openPos + 1, closePosOut - openPos - 1));
                    return true;
                }
                continue;
            }
        }
 
        return false;
    }

Referenced by compileParamRegex().

Here is the caller graph for this function:

hexToInt()

int express::dispatcher::hexToInt ( const char c )

inline

Definition at line 220 of file regex_utils.cpp.

                                      {
        if (c >= '0' && c <= '9') {
            return c - '0';
        }
        if (c >= 'a' && c <= 'f') {
            return c - 'a' + 10;
        }
        if (c >= 'A' && c <= 'F') {
            return c - 'A' + 10;
        }
        return -1;
    }

Referenced by decodeQueryComponent(), and decodeURIComponent().

Here is the caller graph for this function:

ieq()

bool express::dispatcher::ieq ( char a, char b )

inline

Definition at line 66 of file regex_utils.h.

                                    {
        return std::tolower(static_cast<unsigned char>(a)) == std::tolower(static_cast<unsigned char>(b));
    }

Referenced by equalPath().

Here is the caller graph for this function:

isParamNameChar()

bool express::dispatcher::isParamNameChar ( const char c )

inline

Definition at line 59 of file regex_utils.cpp.

                                              {
        const unsigned char uc = static_cast<unsigned char>(c);
        return (std::isalnum(uc) != 0) || (c == '_');
    }

Referenced by compileParamRegex().

Here is the caller graph for this function:

isRegexMetaToEscape()

bool express::dispatcher::isRegexMetaToEscape ( const char c )

inline

Definition at line 83 of file regex_utils.cpp.

                                                  {
        switch (c) {
            case '.':
            case '^':
            case '$':
            case '|':
            case '(':
            case ')':
            case '[':
            case ']':
            case '{':
            case '}':
            case '*':
            case '+':
            case '?':
            case '\\':
                return true;
            default:
                return false;
        }
    }

Referenced by appendEscapedLiteral().

Here is the caller graph for this function:

joinMountPath()

std::string express::dispatcher::joinMountPath	(	std::string_view	parentMountPath,
		std::string_view	relativeMountPath )

Definition at line 597 of file regex_utils.cpp.

                                                                                              {
        if (parentMountPath.empty()) {
            return std::string(relativeMountPath);
        }
        if (relativeMountPath.empty()) {
            return std::string(parentMountPath);
        }
 
        const bool parentSlash = (!parentMountPath.empty() && parentMountPath.back() == '/');
        const bool relSlash = (!relativeMountPath.empty() && relativeMountPath.front() == '/');
 
        if (parentSlash && relSlash) {
            // Special-case root: "/" + "/x" must become "/x", not "//x".
            if (parentMountPath.size() == 1) {
                return std::string(relativeMountPath);
            }
            return std::string(parentMountPath) + std::string(relativeMountPath.substr(1));
        }
        if (!parentSlash && !relSlash) {
            return std::string(parentMountPath) + "/" + std::string(relativeMountPath);
        }
        return std::string(parentMountPath) + std::string(relativeMountPath);
    }

Referenced by express::dispatcher::ApplicationDispatcher::getRoutes(), express::dispatcher::MiddlewareDispatcher::getRoutes(), and express::dispatcher::ScopedPathStrip::ScopedPathStrip().

Here is the caller graph for this function:

makeInnerGroupsNonCapturing()

std::string express::dispatcher::makeInnerGroupsNonCapturing ( std::string_view pattern )

inline

Definition at line 168 of file regex_utils.cpp.

                                                                         {
        std::string out;
        out.reserve(pattern.size());
 
        bool escaped = false;
        bool inCharClass = false;
 
        for (std::size_t i = 0; i < pattern.size(); ++i) {
            const char c = pattern[i];
 
            if (escaped) {
                out.push_back(c);
                escaped = false;
                continue;
            }
 
            if (c == '\\') {
                out.push_back(c);
                escaped = true;
                continue;
            }
 
            if (inCharClass) {
                out.push_back(c);
                if (c == ']') {
                    inCharClass = false;
                }
                continue;
            }
 
            if (c == '[') {
                out.push_back(c);
                inCharClass = true;
                continue;
            }
 
            if (c == '(') {
                // Preserve special constructs like (?:...), (?=...), (?!...), (?<=...), etc.
                if ((i + 1) < pattern.size() && pattern[i + 1] == '?') {
                    out.push_back('(');
                } else {
                    out.append("(?:");
                }
                continue;
            }
 
            out.push_back(c);
        }
 
        return out;
    }

Referenced by compileParamRegex().

Here is the caller graph for this function:

matchAndFillParamsAndConsume()

bool express::dispatcher::matchAndFillParamsAndConsume ( const std::regex & rx, const std::vector< std::string > & names, std::string_view reqPath, std::map< std::string, std::string > & params, std::size_t & consumedLength, bool & decodeError )

inline

Definition at line 283 of file regex_utils.cpp.

                                                                {
        decodeError = false;
        std::cmatch m;
        if (!std::regex_search(reqPath.begin(), reqPath.end(), m, rx)) {
            consumedLength = 0;
            return false;
        }
        consumedLength = static_cast<std::size_t>(m.length(0));
        const size_t g = (!m.empty()) ? (m.size() - 1) : 0;
        const size_t n = std::min(names.size(), g);
        std::string decoded;
        for (size_t i = 0; i < n; ++i) {
            if (!names[i].empty() && m[i + 1].matched) {
                if (!decodeURIComponent(m[i + 1].str(), decoded)) {
                    decodeError = true;
                    params.clear();
                    return true;
                }
                params[names[i]] = decoded;
            }
        }
        return true;
    }

References decodeURIComponent().

Referenced by matchMountPointImpl().

Here is the call graph for this function:

Here is the caller graph for this function:

matchMountPoint()

MountMatchResult express::dispatcher::matchMountPoint	(	express::Controller &	controller,
		const std::string &	absoluteMountPath,
		const express::MountPoint &	mountPoint,
		std::regex &	cachedRegex,
		std::vector< std::string > &	cachedNames,
		bool	strictRouting,
		bool	caseInsensitiveRouting )

Definition at line 701 of file regex_utils.cpp.

                                                                  {
        return matchMountPointImpl(
            controller, absoluteMountPath, mountPoint, &cachedRegex, &cachedNames, strictRouting, caseInsensitiveRouting);
    }

References matchMountPointImpl().

Referenced by express::dispatcher::ApplicationDispatcher::dispatch(), express::dispatcher::MiddlewareDispatcher::dispatch(), and express::dispatcher::RouterDispatcher::dispatch().

Here is the call graph for this function:

Here is the caller graph for this function:

matchMountPointImpl()

MountMatchResult express::dispatcher::matchMountPointImpl ( express::Controller & controller, const std::string & absoluteMountPath, const express::MountPoint & mountPoint, std::regex * cachedRegex, std::vector< std::string > * cachedNames, bool strictRouting, bool caseInsensitiveRouting )

static

Definition at line 621 of file regex_utils.cpp.

                                                                             {
        MountMatchResult result;
        result.isPrefix = (mountPoint.method == "use");
 
        // Split mount & request into path + query
        std::string_view mountPath;
        std::string_view ignoredMountQuery;
        splitPathAndQuery(absoluteMountPath, mountPath, ignoredMountQuery);
        std::string_view requestPath;
        std::string_view requestQueryString;
        splitPathAndQuery(controller.getRequest()->url, requestPath, requestQueryString);
        result.requestQueryPairs = parseQuery(requestQueryString);
 
        // Normalize single trailing slash if not strict
        if (!strictRouting) {
            mountPath = trimOneTrailingSlash(mountPath);
            requestPath = trimOneTrailingSlash(requestPath);
        }
        if (mountPath.empty()) {
            mountPath = "/";
        }
 
        result.requestPath = requestPath;
 
        bool pathMatches = false;
 
        if (routeNeedsRegex(mountPath)) {
            bool decodeError = false;
            std::size_t matchLen = 0;
 
            // Param mount: optionally compile once, match once, fill params, and record matched prefix length
            if (cachedRegex != nullptr && cachedNames != nullptr) {
                if (cachedNames->empty()) {
                    auto compiled = compileParamRegex(mountPath,
                                                      /*isPrefix*/ result.isPrefix,
                                                      strictRouting,
                                                      caseInsensitiveRouting);
                    *cachedRegex = std::move(compiled.first);
                    *cachedNames = std::move(compiled.second);
                }
                pathMatches = matchAndFillParamsAndConsume(*cachedRegex, *cachedNames, requestPath, result.params, matchLen, decodeError);
            } else {
                auto [rx, names] = compileParamRegex(mountPath,
                                                     /*isPrefix*/ result.isPrefix,
                                                     strictRouting,
                                                     caseInsensitiveRouting);
                pathMatches = matchAndFillParamsAndConsume(rx, names, requestPath, result.params, matchLen, decodeError);
            }
 
            if (pathMatches) {
                result.decodeError = decodeError;
            }
 
            if (pathMatches && result.isPrefix) {
                result.consumedLength = matchLen;
            }
        } else {
            if (result.isPrefix) {
                // Literal boundary prefix
                pathMatches = boundaryPrefix(requestPath, mountPath, caseInsensitiveRouting);
                if (pathMatches) {
                    result.consumedLength = (mountPath.size() == 1 && mountPath[0] == '/') ? 0 : mountPath.size();
                }
            } else {
                // End-anchored equality
                pathMatches = equalPath(requestPath, mountPath, caseInsensitiveRouting);
            }
        }
 
        result.requestMatched = pathMatches;
 
        return result;
    }

References boundaryPrefix(), compileParamRegex(), express::dispatcher::MountMatchResult::consumedLength, express::dispatcher::MountMatchResult::decodeError, equalPath(), express::Controller::getRequest(), express::dispatcher::MountMatchResult::isPrefix, matchAndFillParamsAndConsume(), express::MountPoint::method, express::dispatcher::MountMatchResult::params, parseQuery(), express::dispatcher::MountMatchResult::requestMatched, express::dispatcher::MountMatchResult::requestPath, express::dispatcher::MountMatchResult::requestQueryPairs, routeNeedsRegex(), splitPathAndQuery(), trimOneTrailingSlash(), and express::Request::url.

Referenced by matchMountPoint().

Here is the call graph for this function:

Here is the caller graph for this function:

methodMatches()

bool express::dispatcher::methodMatches	(	std::string_view	requestMethod,
		const std::string &	mountMethod )

Definition at line 589 of file regex_utils.cpp.

                                                                                   {
        // Express v4: HEAD falls back to GET handlers if no explicit HEAD was mounted before.
        if (requestMethod == "HEAD" && mountMethod == "GET") {
            return true;
        }
        return (mountMethod == "use") || (mountMethod == "all") || (requestMethod == mountMethod);
    }

Referenced by express::dispatcher::ApplicationDispatcher::dispatch(), express::dispatcher::MiddlewareDispatcher::dispatch(), and express::dispatcher::RouterDispatcher::dispatch().

Here is the caller graph for this function:

parseQuery()

std::unordered_map< std::string, std::string > express::dispatcher::parseQuery ( std::string_view qs )

inline

Definition at line 312 of file regex_utils.cpp.

                                                                                {
        std::unordered_map<std::string, std::string> m;
        std::size_t i = 0;
        while (i < qs.size()) {
            const std::size_t amp = qs.find('&', i);
            const std::string_view pair = (amp == std::string_view::npos) ? qs.substr(i) : qs.substr(i, amp - i);
            const std::size_t eq = pair.find('=');
 
            const std::string_view rawKey = (eq == std::string_view::npos) ? pair : pair.substr(0, eq);
            const std::string_view rawVal = (eq == std::string_view::npos) ? std::string_view{} : pair.substr(eq + 1);
 
            const std::string key = decodeQueryComponent(rawKey);
            const std::string val = decodeQueryComponent(rawVal);
 
            if (!key.empty()) {
                m[key] = val; // last value wins
            }
 
            if (amp == std::string_view::npos) {
                break;
            }
            i = amp + 1;
        }
        return m;
    }

References decodeQueryComponent().

Referenced by matchMountPointImpl().

Here is the call graph for this function:

Here is the caller graph for this function:

routeNeedsRegex()

bool express::dispatcher::routeNeedsRegex ( std::string_view path )

inline

Definition at line 65 of file regex_utils.cpp.

                                                     {
        for (const char c : path) {
            switch (c) {
                case ':':
                case '*':
                case '?':
                case '+':
                case '(':
                case ')':
                case '\\':
                    return true;
                default:
                    break;
            }
        }
        return false;
    }

Referenced by matchMountPointImpl().

Here is the caller graph for this function:

splitPathAndQuery()

void express::dispatcher::splitPathAndQuery ( std::string_view url, std::string_view & path, std::string_view & query )

inline

Definition at line 578 of file regex_utils.cpp.

                                                                                                   {
        const std::size_t qpos = url.find('?');
        if (qpos == std::string_view::npos) {
            path = url;
            query = {};
        } else {
            path = url.substr(0, qpos);
            query = url.substr(qpos + 1);
        }
    }

Referenced by matchMountPointImpl(), and express::dispatcher::ScopedPathStrip::ScopedPathStrip().

Here is the caller graph for this function:

trimOneTrailingSlash()

std::string_view express::dispatcher::trimOneTrailingSlash ( std::string_view s )

inline

Definition at line 571 of file regex_utils.cpp.

                                                                 {
        if (s.size() > 1 && s.back() == '/') {
            return std::string_view(s.data(), s.size() - 1);
        }
        return s;
    }

Referenced by matchMountPointImpl(), and express::dispatcher::ScopedPathStrip::ScopedPathStrip().

Here is the caller graph for this function: