radix_router.hpp

浏览该文件的文档.

#ifndef NEFORCE_NETWORK_HTTP_RADIX_ROUTER_HPP__
#define NEFORCE_NETWORK_HTTP_RADIX_ROUTER_HPP__

 
#include "NeForce/core/functional/function.hpp"
#include "NeForce/network/http/http_server_message.hpp"
NEFORCE_BEGIN_NAMESPACE__
NEFORCE_BEGIN_HTTP__


class route_trie {
public:
    using handler_type = function<void(http_request&, http_response&)>;
 
    struct node {
        string segment;
        unordered_map<string, size_t> children;                
        size_t param_index = numeric_traits<size_t>::max();    
        size_t wildcard_index = numeric_traits<size_t>::max(); 
        string param_name;                                     
        handler_type handler;                                  
        bool has_handler = false;                              
    };
 
private:
    vector<node> nodes_{1};
 
public:
    route_trie() = default;

    void insert(const string& pattern, handler_type handler) {
        if (pattern.empty() || pattern.front() != '/') {
            return;
        }
 
        size_t node_idx = 0;
        size_t pos = 1;
 
        while (pos <= pattern.length()) {
            size_t slash = pattern.find('/', pos);
            if (slash == string::npos) {
                slash = pattern.length();
            }
 
            const string_view segment = pattern.view(pos, slash - pos);
            pos = slash + 1;
 
            if (segment.empty()) {
                continue;
            }
 
            if (segment[0] == ':') {
                string pname(segment.substr(1));
                if (nodes_[node_idx].param_index == numeric_traits<size_t>::max()) {
                    nodes_[node_idx].param_index = nodes_.size();
                    nodes_.emplace_back();
                    nodes_.back().segment = pname;
                }
                node_idx = nodes_[node_idx].param_index;
                nodes_[node_idx].param_name = pname;
            } else if (segment[0] == '*' && segment.length() == 1) {
                if (nodes_[node_idx].wildcard_index == numeric_traits<size_t>::max()) {
                    nodes_[node_idx].wildcard_index = nodes_.size();
                    nodes_.emplace_back();
                    nodes_.back().segment = "*";
                }
                node_idx = nodes_[node_idx].wildcard_index;
            } else {
                string seg(segment);
                auto& children = nodes_[node_idx].children;
                auto it = children.find(seg);
                if (it == children.end()) {
                    children[seg] = nodes_.size();
                    nodes_.emplace_back();
                    nodes_.back().segment = seg;
                    node_idx = nodes_.size() - 1;
                } else {
                    node_idx = it->second;
                }
            }
        }
 
        nodes_[node_idx].handler = move(handler);
        nodes_[node_idx].has_handler = true;
    }

    NEFORCE_NODISCARD handler_type match(const string& path, bool case_sensitive,
                                         vector<pair<string, string>>& params) {
        if (path.empty() || path.front() != '/') {
            return handler_type{};
        }
 
        size_t node_idx = 0;
        size_t pos = 1;
 
        while (pos <= path.length()) {
            size_t slash = path.find('/', pos);
            if (slash == string::npos) {
                slash = path.length();
            }
 
            string_view segment = path.view(pos, slash - pos);
            pos = slash + 1;
 
            if (segment.empty()) {
                continue;
            }
 
            const node& current = nodes_[node_idx];
 
            const string seg_key(segment);
            if (!case_sensitive) {
                bool found = false;
                for (const auto& child: current.children) {
                    string key_lower = child.first;
                    if (key_lower.lowercase() == seg_key.lowercase()) {
                        node_idx = child.second;
                        found = true;
                        break;
                    }
                }
                if (found) {
                    continue;
                }
            } else {
                auto it = current.children.find(seg_key);
                if (it != current.children.end()) {
                    node_idx = it->second;
                    continue;
                }
            }
 
            if (current.param_index != numeric_traits<size_t>::max()) {
                params.emplace_back(nodes_[current.param_index].param_name, string(segment));
                node_idx = current.param_index;
                continue;
            }
 
            if (current.wildcard_index != numeric_traits<size_t>::max()) {
                string remaining;
                remaining.reserve(path.length() - (slash - segment.length()));
                remaining.append(segment);
                if (slash < path.length()) {
                    remaining += path.view(slash);
                }
                params.emplace_back("*", remaining);
                node_idx = current.wildcard_index;
                break;
            }
 
            return handler_type{};
        }
 
        if (nodes_[node_idx].has_handler) {
            return nodes_[node_idx].handler;
        }
        return handler_type{};
    }

    NEFORCE_NODISCARD bool contains_path(const string& path, bool case_sensitive) const {
        if (path.empty() || path.front() != '/') {
            return false;
        }
 
        size_t node_idx = 0;
        size_t pos = 1;
 
        while (pos <= path.length()) {
            size_t slash = path.find('/', pos);
            if (slash == string::npos) {
                slash = path.length();
            }
 
            string_view segment = path.view(pos, slash - pos);
            pos = slash + 1;
 
            if (segment.empty()) {
                continue;
            }
 
            const node& current = nodes_[node_idx];
 
            string seg_key(segment);
            if (!case_sensitive) {
                seg_key = seg_key.lowercase();
                bool found = false;
                for (const auto& child: current.children) {
                    string key_lower = child.first;
                    if (key_lower.lowercase() == seg_key) {
                        node_idx = child.second;
                        found = true;
                        break;
                    }
                }
                if (found) {
                    continue;
                }
            } else {
                auto it = current.children.find(seg_key);
                if (it != current.children.end()) {
                    node_idx = it->second;
                    continue;
                }
            }
 
            if (current.param_index != numeric_traits<size_t>::max()) {
                node_idx = current.param_index;
                continue;
            }
 
            if (current.wildcard_index != numeric_traits<size_t>::max()) {
                return true;
            }
 
            return false;
        }
 
        return nodes_[node_idx].has_handler;
    }

    void clear() {
        nodes_.clear();
        nodes_.emplace_back();
    }

    NEFORCE_NODISCARD size_t size() const noexcept { return nodes_.size(); }
};
 // HTTP
 
NEFORCE_END_HTTP__
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_NETWORK_HTTP_RADIX_ROUTER_HPP__