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)
std::string	path_concat (const std::string &first, const std::string &second)

Function Documentation

checkForUrlMatch()

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

Definition at line 146 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 46 of file regex_utils.cpp.

                                                                 {
        std::vector<std::string> result;
        std::istringstream iss(s);
 
        for (std::string token; std::getline(iss, token, delim);) {
            result.push_back(std::move(token));
        }
 
        return result;
    }

hasResult()

bool express::dispatcher::hasResult

(

const std::string &

cpath

)

Definition at line 72 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 78 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];
                    }
                }
 
                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 64 of file regex_utils.cpp.

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

path_concat() [1/2]

std::string express::dispatcher::path_concat	(	const std::string &	first,
		const std::string &	second )

Definition at line 128 of file regex_utils.cpp.

                                                                           {
        std::string result;
 
        if (first.back() == '/' && second.front() == '/') {
            result = first + second.substr(1);
        } else if (first.back() != '/' && second.front() != '/') {
            result = first + '/' + second;
        } else {
            result = first + second;
        }
 
        if (result.length() > 1 && result.back() == '/') {
            result.pop_back();
        }
 
        return result;
    }

path_concat() [2/2]

std::string express::dispatcher::path_concat

(

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

stringvec

)

Definition at line 34 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 58 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 101 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];
                }
            }
        }
    }