express::dispatcher Namespace Reference

Classes
class	ApplicationDispatcher
class	MiddlewareDispatcher
class	RouterDispatcher

Functions
std::string	path_concat (const std::vector< std::string > &stringvec)
std::vector< std::string >	explode (const std::string &s, char delim)
const std::regex &	pathRegex ()
std::smatch	matchResult (const std::string &cpath)
bool	hasResult (const std::string &cpath)
bool	matchFunction (const std::string &cpath, const std::string &reqpath)
void	setParams (const std::string &cpath, express::Request &req)
bool	checkForUrlMatch (const std::string &cpath, const std::string &reqpath)

Function Documentation

checkForUrlMatch()

bool express::dispatcher::checkForUrlMatch	(	const std::string &	cpath,
		const std::string &	reqpath )

Definition at line 166 of file regex_utils.cpp.

                                                                            {
        return hasResult(cpath) && matchFunction(cpath, reqpath);
    }

explode()

std::vector< std::string > express::dispatcher::explode	(	const std::string &	s,
		char	delim )

Definition at line 66 of file regex_utils.cpp.

                                                                     {
        std::vector<std::string> result;
        std::string current;
        int parenDepth = 0;
 
        for (const char ch : input) {
            if (ch == '(') {
                parenDepth++;
                current += ch;
            } else if (ch == ')') {
                parenDepth--;
                current += ch;
            } else if (ch == delim && parenDepth == 0) {
                result.push_back(current);
                current.clear();
            } else {
                current += ch;
            }
        }
 
        if (!current.empty()) {
            result.push_back(current);
        }
 
        return result;
    }

hasResult()

bool express::dispatcher::hasResult

(

const std::string &

cpath

)

Definition at line 108 of file regex_utils.cpp.

                                           {
        std::smatch smatch;
 
        return std::regex_search(cpath, smatch, pathRegex());
    }

matchFunction()

bool express::dispatcher::matchFunction	(	const std::string &	cpath,
		const std::string &	reqpath )

Definition at line 114 of file regex_utils.cpp.

                                                                         {
        std::vector<std::string> explodedString = explode(cpath, '/');
 
        for (std::vector<std::string>::size_type i = 0; i < explodedString.size(); i++) {
            if (explodedString[i].front() == ':') {
                const std::smatch smatch = matchResult(explodedString[i]);
                std::string regex = "(.*)";
 
                if (smatch.size() > 1) {
                    if (smatch[1] != "") {
                        regex = smatch[1];
                    } else if (i == explodedString.size() - 1) {
                        regex = "([^/]+)(/)?$";
                    }
                }
 
                explodedString[i] = regex;
            }
        }
 
        const std::string regexPath = path_concat(explodedString);
 
        return std::regex_match(reqpath, std::regex(regexPath));
    }

matchResult()

std::smatch express::dispatcher::matchResult

(

const std::string &

cpath

)

Definition at line 100 of file regex_utils.cpp.

                                                  {
        std::smatch smatch;
 
        std::regex_search(cpath, smatch, pathRegex());
 
        return smatch;
    }

path_concat()

std::string express::dispatcher::path_concat

(

const std::vector< std::string > &

stringvec

)

Definition at line 54 of file regex_utils.cpp.

                                                                 {
        std::string s;
 
        for (std::vector<std::string>::size_type i = 0; i < stringvec.size(); i++) {
            if (!stringvec[i].empty() && stringvec[i].front() != ' ') {
                s += "\\/" + stringvec[i];
            }
        }
 
        return s;
    }

pathRegex()

const std::regex & express::dispatcher::pathRegex

(

)

Definition at line 94 of file regex_utils.cpp.

                                {
        static const std::regex pathregex(PATH_REGEX);
 
        return pathregex;
    }

setParams()

void express::dispatcher::setParams	(	const std::string &	cpath,
		express::Request &	req )

Definition at line 139 of file regex_utils.cpp.

                                                         {
        std::vector<std::string> explodedString = explode(cpath, '/');
        std::vector<std::string> explodedReqString = explode(req.url, '/');
 
        for (std::vector<std::string>::size_type i = 0; i < explodedString.size() && i < explodedReqString.size(); i++) {
            if (explodedString[i].front() == ':') {
                const std::smatch smatch = matchResult(explodedString[i]);
                std::string regex = "(.*)";
 
                if (smatch.size() > 1) {
                    if (smatch[1] != "") {
                        regex = smatch[1];
                    }
                }
 
                if (std::regex_match(explodedReqString[i], std::regex(regex))) {
                    std::string attributeName = smatch[0];
                    attributeName.erase(0, 1);
                    attributeName.erase((attributeName.length() - static_cast<std::size_t>(smatch[1].length())),
                                        static_cast<std::size_t>(smatch[1].length()));
 
                    req.params[attributeName] = explodedReqString[i];
                }
            }
        }
    }