rax-radix-tree 1.0.1

package/radix-tree.js

@@ -0,0 +1,284 @@
+const { RadixTree: RaxRadixTree } = require('./build/Release/rax_radix_tree.node');
+const assert = require('assert');
+
+const MATCH_TYPE_EQUALS = 'equals';
+const MATCH_TYPE_PREFIX = 'prefix';
+const MATCH_TYPE_SUFFIX = 'suffix';
+
+/**
+ * Parse path, path supports several patterns:
+ * 1. Without '*', full match
+ * 2. With a single '*', '*' matches any text not containing '/'
+ * 3. With consecutive '**', '**' matches any text
+ * Parsing function, the parsed result includes the following parts:
+ * treePath: The part before the first '*'
+ * path: The input path
+ * matchType: Match type, equals => path without '*'. prefix => path with '*'
+ * pathPattern: Pattern used for secondary regex matching
+ * @param {string} path
+ * @returns {Object} Parsing result
+ */
+function parsePath(path) {
+    const originPath = path;
+    let matchType = MATCH_TYPE_EQUALS;
+    let treePath = path;
+    let pathPattern = undefined;
+
+    const starPattern = /(\*\*|\*)/g;
+    let parts = undefined;
+    if (path.startsWith("*")) {
+        matchType = MATCH_TYPE_SUFFIX;
+        path = path.split('').reverse().join('');
+        parts = path.split(starPattern);
+    } else {
+        parts = path.split(starPattern);
+        matchType = parts.length > 1 ? MATCH_TYPE_PREFIX : MATCH_TYPE_EQUALS;
+    }
+    treePath = parts[0];
+    if (matchType === MATCH_TYPE_PREFIX || matchType === MATCH_TYPE_SUFFIX) {
+        pathPattern = '^' + parts.map((part, index) => {
+            if (part === '**') {
+                return '.*';
+            } else if (part === '*') {
+                return '[^/]*';
+            }
+            return part.replace(/[-\/\\^$+?.()|[\]{}]/g, '\\$&');
+        }).join('') + '$';
+    }
+
+    return {
+        treePath: treePath,
+        path: originPath,
+        pathPattern: pathPattern,
+        matchType: matchType,
+    };
+}
+
+class RadixTree {
+    constructor(routes, matchFunc) {
+        this.originRoutes = routes
+        // Initialize routes array with undefined at index 0 to ensure indexing starts from 1
+        this.routes = [undefined]
+        this.prefixTree = new RaxRadixTree() // Prefix matching
+        this.suffixTree = new RaxRadixTree() // Suffix matching
+        this.equalsMap = {}
+        this.prefixRouteCount = 0;
+        this.suffixRouteCount = 0;
+        this.equalsRouteCount = 0;
+        this.matchFunc = matchFunc
+        this._initRoutes()
+    }
+
+    _initRoute(route, routePath) {
+        const pathInfo = parsePath(routePath)
+        if (!route.methods) {
+            route.methods = ['ALL']
+        }
+        const treePath = pathInfo.treePath
+        const path = pathInfo.path
+        delete pathInfo.path
+
+        if (pathInfo.matchType == MATCH_TYPE_EQUALS) {
+            const routeInfo = Object.assign({pathInfo, path}, route);
+            let index = this.equalsMap[treePath]
+            if (index === undefined) {
+                this.routes.push([routeInfo]);
+                index = this.routes.length - 1;
+                this.equalsMap[treePath] = index;
+            } else {
+                this.routes[index].push(routeInfo);
+            }
+            this.equalsRouteCount++;
+            return
+        }
+
+        pathInfo.pattern = new RegExp(pathInfo.pathPattern);
+        const routeInfo = Object.assign({pathInfo, path}, route);
+        const tree = pathInfo.matchType === MATCH_TYPE_SUFFIX ? this.suffixTree : this.prefixTree;
+        // console.log("pathInfo.matchType: %s, tree: %s", pathInfo.matchType, treePath)
+        let index = tree.find(treePath)
+        if (index === null) {
+            this.routes.push([routeInfo]);
+            index = this.routes.length - 1;
+            tree.insert(treePath, index)
+        } else {
+            assert(index >= 0 && index < this.routes.length);
+            this.routes[index].push(routeInfo);
+        }
+        if (pathInfo.matchType === MATCH_TYPE_PREFIX) {
+            this.prefixRouteCount++;
+        } else if (pathInfo.matchType === MATCH_TYPE_SUFFIX) {
+            this.suffixRouteCount++;
+        }
+    }
+
+    _initRoutes() {
+        for (let route of this.originRoutes) {
+            route = Object.assign({}, route);
+            const routePaths = route.paths;
+            delete route.paths;
+            for(let routePath of routePaths) {
+                this._initRoute(route, routePath)
+            }
+        }
+
+        this._sortAllRoutes();
+    }
+
+    _sortAllRoutes() {
+        for (let routeArray of this.routes) {
+            if (!routeArray) {
+                continue
+            }
+            routeArray.sort((a, b) => {
+                const lengthDiff = b.path.length - a.path.length;
+                if (lengthDiff !== 0) {
+                    return lengthDiff;
+                }
+                // Compare methods only when both a and b have exactly one method
+                if (a.methods.length === 1 && b.methods.length === 1) {
+                    if (a.methods[0] === 'ALL' && b.methods[0] !== 'ALL') {
+                        return 1;  // a should be placed after
+                    } else if (a.methods[0] !== 'ALL' && b.methods[0] === 'ALL') {
+                        return -1;  // b should be placed after
+                    }
+                }
+
+                // Compare hosts (when hosts length is 1)
+                if (a.hosts && a.hosts.length === 1 && b.hosts && b.hosts.length === 1) {
+                    const aIsWildcard = a.hosts[0].startsWith('*');
+                    const bIsWildcard = b.hosts[0].startsWith('*');
+                    if (aIsWildcard && !bIsWildcard) {
+                        return 1;  // a is a wildcard domain, should be placed after
+                    } else if (!aIsWildcard && bIsWildcard) {
+                        return -1;  // b is a wildcard domain, should be placed after
+                    }
+                }
+
+                // If both are 'ALL' or neither is 'ALL', consider them equal
+                return 0;
+            });
+        }
+    }
+    _routeSimpleMatch(routeInfo, reqPath, method) {
+        const { treePath, pattern, matchType } = routeInfo.pathInfo;
+        const routeMethods = routeInfo.methods;
+        // Check method matching
+        if (!routeMethods.includes('ALL') && !routeMethods.includes(method)) {
+            return false;
+        }
+
+        // Path matching logic
+        if (matchType === MATCH_TYPE_EQUALS) {
+            return reqPath === routeInfo.path;
+        } else if (matchType === MATCH_TYPE_SUFFIX) {
+            if (!reqPath.startsWith(treePath)) {
+                return false;
+            }
+            return pattern.test(reqPath);
+        } else if (matchType === MATCH_TYPE_PREFIX) {
+            if (!reqPath.startsWith(treePath)) {
+                return false;
+            }
+            return pattern.test(reqPath);
+        }
+
+        // If no case is matched, return false
+        console.error("No case matched, {matchType: %s, path: %s}", matchType, reqPath)
+        return false;
+    }
+
+    /**
+     * Find all routes that match the given path and method.
+     * @param {string} path - The path to match against.
+     * @param {string} [method=''] - The HTTP method to match (optional).
+     * @returns {Array} An array of matching routes.
+     */
+    findAllRoutes(path, method='') {
+        const allRoutes = [];
+
+        // Hash lookup logic
+        if (this.equalsRouteCount > 0) {
+            const hashIndex = this.equalsMap[path];
+            if (hashIndex !== undefined) {
+                const exactMatchRoutes = this.routes[hashIndex];
+                for (const route of exactMatchRoutes) {
+                    if (this._routeSimpleMatch(route, path, method)) {
+                        allRoutes.push(route);
+                    }
+                }
+            }
+        }
+
+        // Suffix tree lookup logic
+        if (this.suffixRouteCount > 0) {
+            const reversePath = path.split('').reverse().join('');
+            const treeIt = this.suffixTree.search(reversePath);
+            if (treeIt) {
+                let idx;
+                while ((idx = treeIt.up()) !== -1) {
+                    if (idx >= this.routes.length) {
+                        console.error("Index out of range");
+                        break;
+                    }
+                    const routesArr = this.routes[idx];
+                    for (const route of routesArr) {
+                        if (this._routeSimpleMatch(route, reversePath, method)) {
+                            allRoutes.push(route);
+                        }
+                    }
+                }
+            }
+        }
+
+        // Prefix tree lookup logic
+        if (this.prefixRouteCount > 0) {
+            const treeIt = this.prefixTree.search(path);
+            if (treeIt) {
+                let idx;
+                while ((idx = treeIt.up()) !== -1) {
+                    if (idx >= this.routes.length) {
+                        console.error("Index out of range");
+                        break;
+                    }
+                    const routesArr = this.routes[idx];
+                    for (const route of routesArr) {
+                        if (this._routeSimpleMatch(route, path, method)) {
+                            allRoutes.push(route);
+                        }
+                    }
+                }
+            }
+        }
+
+        return allRoutes;
+    }
+
+    /**
+     * Find the first matching route for the given request.
+     * @param {Object} req - The request object containing path and method.
+     * @returns {Object|null} The first matching route, or null if no match is found.
+     */
+    findRoute(req) {
+        const allRoutes = this.findAllRoutes(req.path, req.method, false);
+        if (allRoutes.length === 0) {
+            return null;
+        }
+        if (!this.matchFunc) {
+            return allRoutes[0];
+        }
+
+        // Use matchFunc to test for a match
+        for (const route of allRoutes) {
+            const matched = this.matchFunc(route, req)
+            if (matched) {
+                return route;
+            }
+        }
+
+        return null;
+    }
+};
+
+exports.parsePath = parsePath;
+exports.RadixTree = RadixTree

package/src/radix_tree.c

@@ -0,0 +1,169 @@
+#include <stdlib.h>
+#include <string.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include "radix_tree.h"
+#include "rax/rax.h"
+
+
+radix_tree* raxtree_new()
+{
+    return (radix_tree *)raxNew();
+}
+
+int raxtree_remove(radix_tree* t, rt_str_t *buf)
+{
+    if (t == NULL) {
+        return -1;
+    }
+
+    if (buf == NULL || buf->buf == NULL) {
+        return -2;
+    }
+
+    return raxRemove((rax *)t, buf->buf, buf->len, NULL);
+}
+
+int raxtree_destroy(radix_tree* t)
+{
+    if (t == NULL) {
+        return 0;
+    }
+
+    raxFree(t);
+    return 0;
+}
+
+
+int raxtree_insert(radix_tree* t, const rt_str_t *buf, int idx)
+{
+    void *data = (void *)(intptr_t)idx;
+
+    if (t == NULL) {
+        return -1;
+    }
+
+    if (buf == NULL || buf->buf == NULL) {
+        return -2;
+    }
+
+    return raxInsert((rax *)t, buf->buf, buf->len, data, NULL);
+}
+
+
+void* raxtree_find(radix_tree* t, const rt_str_t *buf)
+{
+    if (t == NULL) {
+        return NULL;
+    }
+
+    if (buf == NULL || buf->buf == NULL) {
+        return NULL;
+    }
+
+    void *res = raxFind((rax *)t, buf->buf, buf->len);
+    if (res == raxNotFound) {
+        return NULL;
+    }
+
+    return res;
+}
+
+
+radix_iterator* raxtree_new_it(radix_tree* t)
+{
+    raxIterator *it = malloc(sizeof(raxIterator));
+    if (it == NULL) {
+        return NULL;
+    }
+
+    raxStart(it, (rax *)t);
+    return (radix_iterator *)it;
+}
+
+
+void* raxtree_search(radix_tree* t, radix_iterator* it, const rt_str_t *buf)
+{
+    raxIterator *iter = (raxIterator *)it;
+    if (it == NULL) {
+        return NULL;
+    }
+
+    raxSeek(iter, "<=", buf->buf, buf->len);
+    return (void *)iter;
+}
+
+
+int raxtree_next(radix_iterator* it, const rt_str_t *buf)
+{
+    raxIterator    *iter = it;
+
+    int res = raxNext(iter);
+    if (!res) {
+        return -1;
+    }
+
+    if (iter->key_len > buf->len ||
+        memcmp(buf->buf, iter->key, iter->key_len) != 0) {
+        return -1;
+    }
+
+    return (int)(intptr_t)iter->data;
+}
+
+
+int raxtree_prev(radix_iterator* it, const rt_str_t *buf)
+{
+    raxIterator    *iter = it;
+    int             res;
+
+    while (1) {
+        res = raxPrev(iter);
+        if (!res) {
+            return -1;
+        }
+
+        if (iter->key_len > buf->len ||
+            memcmp(buf->buf, iter->key, iter->key_len) != 0) {
+            continue;
+        }
+
+        break;
+    }
+
+    return (int)(intptr_t)iter->data;
+}
+
+
+int raxtree_up(radix_iterator* it, const rt_str_t *buf)
+{
+    raxIterator    *iter = it;
+    int             res;
+
+    while (1) {
+        res = raxUp(iter);
+        if (!res) {
+            return -1;
+        }
+
+        if (iter->key_len > buf->len ||
+            memcmp(buf->buf, iter->key, iter->key_len) != 0) {
+            continue;
+        }
+
+        break;
+    }
+
+    return (int)(intptr_t)iter->data;
+}
+
+
+int raxtree_stop(radix_iterator* it)
+{
+    if (!it) {
+        return 0;
+    }
+
+    raxStop(it);
+    return 0;
+}

package/src/radix_tree.h

@@ -0,0 +1,39 @@
+#ifndef __RAX_TREE_H
+#define __RAX_TREE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+#include <stdio.h>
+#include <ctype.h>
+#include "rax/rax.h"
+
+typedef rax radix_tree;
+typedef raxIterator radix_iterator;
+
+typedef struct {
+    size_t          len;
+    unsigned char* buf;
+} rt_str_t;
+
+radix_tree *raxtree_new();
+int raxtree_destroy(radix_tree* t);
+int raxtree_insert(radix_tree* t, const rt_str_t *buf, int idx);
+
+void *raxtree_find(radix_tree* t, const rt_str_t *buf);
+void *raxtree_search(radix_tree* t, radix_iterator* it, const rt_str_t *buf);
+
+radix_iterator* raxtree_new_it(radix_tree* t);
+int raxtree_prev(radix_iterator* it, const rt_str_t *buf);
+int raxtree_next(radix_iterator* it, const rt_str_t *buf);
+int raxtree_up(radix_iterator* it, const rt_str_t *buf);
+int raxtree_stop(radix_iterator* it);
+int raxtree_remove(radix_tree* t, rt_str_t *buf);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

package/src/rax/COPYING

@@ -0,0 +1,9 @@
+Copyright (c) 2017, Salvatore Sanfilippo <antirez@gmail.com>
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/src/rax/Makefile

@@ -0,0 +1,26 @@
+DEBUG?= -g -ggdb
+CFLAGS?= -O2 -Wall -W -std=c99
+LDFLAGS= -lm
+
+# Uncomment the following two lines for coverage testing
+#
+# CFLAGS+=-fprofile-arcs -ftest-coverage
+# LDFLAGS+=-lgcov
+
+all: rax-test rax-oom-test
+
+rax.o: rax.h
+rax-test.o: rax.h
+rax-oom-test.o: rax.h
+
+rax-test: rax-test.o rax.o rc4rand.o crc16.o
+	$(CC) -o $@ $^ $(LDFLAGS) $(DEBUG)
+
+rax-oom-test: rax-oom-test.o rax.o
+	$(CC) -o $@ $^ $(LDFLAGS) $(DEBUG)
+
+.c.o:
+	$(CC) -c $(CFLAGS) $(DEBUG) $<
+
+clean:
+	rm -f rax-test rax-oom-test *.gcda *.gcov *.gcno *.o