optimize trie

Author: Shfdis

.gitignore

@@ -18,11 +18,11 @@ compile_commands.json
 echo_server
 
 # IDE/Editor
-.cache/
-.vscode/
-.idea/
-.agents/
-.codex/
+*.cache/
+*.vscode/
+*.idea/
+*.agents/
+*.codex/
 *.swp
 *.swo
 *~

server/include/trie.h

@@ -3,25 +3,38 @@
 #include <functional>
 #include <memory>
 #include <optional>
+#include <string>
+#include <string_view>
 #include <unordered_map>
+#include <vector>
 namespace HTTP {
 using RespondType = std::function<ResponseData(const RequestData &)>;
 class Trie {
+  struct StringHash {
+    using is_transparent = void;
+    size_t operator()(std::string_view value) const noexcept;
+  };
+  struct StringEqual {
+    using is_transparent = void;
+    bool operator()(std::string_view lhs, std::string_view rhs) const noexcept;
+  };
   struct Node {
-    std::unordered_map<char, std::unique_ptr<Node>> children;
+    std::unordered_map<std::string, std::unique_ptr<Node>, StringHash,
+                       StringEqual>
+        children;
+    std::unique_ptr<Node> wildcard;
     std::optional<RespondType> handlers[5];
     Node() = default;
-    bool any = false;
-    Node &Move(char c);
-    const Node &Move(char c) const;
+    Node &Move(std::string_view segment);
   };
   std::unique_ptr<Node> root_ = std::make_unique<Node>();
 
 public:
   Trie() = default;
   Trie(Trie &&rhs);
   Trie &operator=(Trie &&rhs);
-  const Node &GetRoot();
   void AddRequest(Method type, RespondType function, std::string_view path);
+  RespondType Match(Method method, std::string_view path,
+                    std::vector<std::string> &urlVariables) const;
 };
 } // namespace HTTP

server/src/server.cpp

@@ -259,8 +259,8 @@ CoFuture<void> Server::GetHandler(RequestData &data, ReadIterator &iter, Respond
   if (*iter != '/') {
     throw HTTPError(400, "Invalid request");
   }
-  auto current = &trie_.GetRoot();
-  bool inVariable = false;
+  std::string path;
+  path.reserve(64);
   while (true) {
     co_await iter.Ensure();
     if (!iter) {
@@ -270,23 +270,10 @@ CoFuture<void> Server::GetHandler(RequestData &data, ReadIterator &iter, Respond
     if (c == ' ' || c == '?') {
       break;
     }
-    if (!current->children.contains(c) && current->any) {
-      if (!inVariable) {
-        inVariable = true;
-        data.urlVariables.push_back("");
-      }
-      data.urlVariables.back().push_back(c);
-      co_await ++iter;
-      continue;
-    }
-    inVariable = false;
-    current = &current->Move(c);
+    path.push_back(c);
     co_await ++iter;
   }
-  if (!current->handlers[data.method]) {
-    throw HTTPError(404, "Not found");
-  }
-  handler = *current->handlers[data.method];
+  handler = trie_.Match(data.method, path, data.urlVariables);
   co_return;
 }
 

server/src/trie.cpp

@@ -2,32 +2,87 @@
 #include "http_error.h"
 #include "request_data.h"
 namespace HTTP {
-Trie::Node &Trie::Node::Move(char c) {
-  if (c == '*') {
-    any = true;
-    return *this;
-  }
-  if (!children.contains(c)) {
-    children[c] = std::make_unique<Node>();
-  }
-  return *children[c];
+
+size_t Trie::StringHash::operator()(std::string_view value) const noexcept {
+  return std::hash<std::string_view>{}(value);
 }
-const Trie::Node &Trie::Node::Move(char c) const {
-  try {
-    return *children.at(c);
-  } catch (...) {
-    throw HTTPError(404, "Not found");
+
+bool Trie::StringEqual::operator()(std::string_view lhs,
+                                   std::string_view rhs) const noexcept {
+  return lhs == rhs;
+}
+
+Trie::Node &Trie::Node::Move(std::string_view segment) {
+  if (segment == "*") {
+    if (!wildcard) {
+      wildcard = std::make_unique<Node>();
+    }
+    return *wildcard;
+  }
+
+  auto child = children.find(segment);
+  if (child == children.end()) {
+    auto [inserted, _] =
+        children.emplace(std::string{segment}, std::make_unique<Node>());
+    child = inserted;
   }
+  return *child->second;
 }
+
 void Trie::AddRequest(Method method, RespondType respond,
                       std::string_view path) {
   Node *current = root_.get();
-  for (auto c : path) {
-    current = &current->Move(c);
+  size_t position = path.starts_with('/') ? 1 : 0;
+  while (position < path.size()) {
+    const size_t next = path.find('/', position);
+    const auto segment =
+        next == std::string_view::npos
+            ? path.substr(position)
+            : path.substr(position, next - position);
+    current = &current->Move(segment);
+    if (next == std::string_view::npos) {
+      break;
+    }
+    position = next + 1;
   }
   current->handlers[method] = respond;
 }
-const Trie::Node &Trie::GetRoot() { return *root_; }
+
+RespondType Trie::Match(Method method, std::string_view path,
+                        std::vector<std::string> &urlVariables) const {
+  const Node *current = root_.get();
+  urlVariables.clear();
+
+  size_t position = path.starts_with('/') ? 1 : 0;
+  while (position < path.size()) {
+    const size_t next = path.find('/', position);
+    const auto segment =
+        next == std::string_view::npos
+            ? path.substr(position)
+            : path.substr(position, next - position);
+
+    const auto child = current->children.find(segment);
+    if (child != current->children.end()) {
+      current = child->second.get();
+    } else if (current->wildcard) {
+      urlVariables.emplace_back(segment);
+      current = current->wildcard.get();
+    } else {
+      throw HTTPError(404, "Not found");
+    }
+
+    if (next == std::string_view::npos) {
+      break;
+    }
+    position = next + 1;
+  }
+
+  if (!current->handlers[method]) {
+    throw HTTPError(404, "Not found");
+  }
+  return *current->handlers[method];
+}
+
 Trie::Trie(Trie &&rhs) { root_ = std::move(rhs.root_); }
 Trie &Trie::operator=(Trie &&rhs) {
   root_ = std::move(rhs.root_);