refactored, pre-buffer reuse

2026-03-15 14:31:52 +01:00
parent f1beb160aa
commit b0d606cb5f
64 changed files with 888 additions and 400 deletions
@@ -0,0 +1,77 @@
+package dev.relism.routing;
+
+import dev.relism.exceptions.DuplicateNamespaceException;
+import dev.relism.fpr.core.ByteView;
+import dev.relism.http.HttpMethod;
+import dev.relism.models.Request;
+import dev.relism.models.RequestHandler;
+import dev.relism.routing.routers.fastpathrouter.FastPathRouterImpl;
+
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Top-level dispatcher owned by {@link dev.relism.HttpServer}.
+ *
+ * <p>Routing order on each request:
+ * <ol>
+ *   <li>Iterates mounted sub-routers in descending namespace length order (longest prefix first)
+ *       and delegates to the first one whose namespace is a prefix of the request path.</li>
+ *   <li>If no sub-router matches, falls through to the internal {@link FastPathRouterImpl}.</li>
+ * </ol>
+ *
+ * <p>Not intended to be instantiated or subclassed directly — use {@link dev.relism.HttpServer}.
+ */
+public class GlobalRouter extends AbstractRouter {
+    private final Map<String, AbstractRouter> subRoutersMap = new HashMap<>();
+    private final List<AbstractRouter> sortedSubRouters = new ArrayList<>();
+    private final AbstractRouter internalRouter = new FastPathRouterImpl();
+
+    public void mount(String namespace, AbstractRouter router) {
+        String sanitized = PathUtils.sanitize(namespace);
+        if (subRoutersMap.containsKey(sanitized)) throw new DuplicateNamespaceException(sanitized);
+
+        router.setNamespace(sanitized);
+        subRoutersMap.put(sanitized, router);
+        sortedSubRouters.add(router);
+        sortedSubRouters.sort(Comparator.comparingInt((AbstractRouter r) -> r.getNamespaceBytes().length).reversed());
+    }
+
+    @Override
+    public RequestHandler route(Request request) {
+        ByteView path = request.getRequestLine().getPath();
+        for (AbstractRouter sub : sortedSubRouters) {
+            if (startsWith(path, sub.getNamespaceBytes())) {
+                RequestHandler h = sub.route(request);
+                return h != null ? h : sub.getNotFoundHandler();
+            }
+        }
+        RequestHandler h = internalRouter.route(request);
+        return h != null ? h : notFoundHandler;
+    }
+
+    /** Resolves the scoped exception handler for the router that owns the request path. */
+    public ExceptionHandler resolveExceptionHandler(Request request) {
+        ByteView path = request.getRequestLine().getPath();
+        for (AbstractRouter sub : sortedSubRouters) {
+            if (startsWith(path, sub.getNamespaceBytes())) return sub.getExceptionHandler();
+        }
+        return exceptionHandler;
+    }
+
+    @Override
+    protected AbstractRouter addRoute(HttpMethod method, String path, RequestHandler handler) {
+        return internalRouter.addRoute(method, PathUtils.sanitize(path), handler);
+    }
+
+    private static boolean startsWith(ByteView view, byte[] prefix) {
+        if (view.length() < prefix.length) return false;
+        for (int i = 0; i < prefix.length; i++) {
+            if (view.byteAt(i) != prefix[i]) return false;
+        }
+        return true;
+    }
+}