rax-radix-tree 1.0.1

package/src/rax/rax.h

@@ -0,0 +1,217 @@
+/* Rax -- A radix tree implementation.
+ *
+ * Copyright (c) 2017-2018, Salvatore Sanfilippo <antirez at gmail dot 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.
+ *   * Neither the name of Redis nor the names of its contributors may be used
+ *     to endorse or promote products derived from this software without
+ *     specific prior written permission.
+ *
+ * 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.
+ */
+
+#ifndef RAX_H
+#define RAX_H
+
+#include <stdint.h>
+
+/* Representation of a radix tree as implemented in this file, that contains
+ * the strings "foo", "foobar" and "footer" after the insertion of each
+ * word. When the node represents a key inside the radix tree, we write it
+ * between [], otherwise it is written between ().
+ *
+ * This is the vanilla representation:
+ *
+ *              (f) ""
+ *                \
+ *                (o) "f"
+ *                  \
+ *                  (o) "fo"
+ *                    \
+ *                  [t   b] "foo"
+ *                  /     \
+ *         "foot" (e)     (a) "foob"
+ *                /         \
+ *      "foote" (r)         (r) "fooba"
+ *              /             \
+ *    "footer" []             [] "foobar"
+ *
+ * However, this implementation implements a very common optimization where
+ * successive nodes having a single child are "compressed" into the node
+ * itself as a string of characters, each representing a next-level child,
+ * and only the link to the node representing the last character node is
+ * provided inside the representation. So the above representation is turned
+ * into:
+ *
+ *                  ["foo"] ""
+ *                     |
+ *                  [t   b] "foo"
+ *                  /     \
+ *        "foot" ("er")    ("ar") "foob"
+ *                 /          \
+ *       "footer" []          [] "foobar"
+ *
+ * However this optimization makes the implementation a bit more complex.
+ * For instance if a key "first" is added in the above radix tree, a
+ * "node splitting" operation is needed, since the "foo" prefix is no longer
+ * composed of nodes having a single child one after the other. This is the
+ * above tree and the resulting node splitting after this event happens:
+ *
+ *
+ *                    (f) ""
+ *                    /
+ *                 (i o) "f"
+ *                 /   \
+ *    "firs"  ("rst")  (o) "fo"
+ *              /        \
+ *    "first" []       [t   b] "foo"
+ *                     /     \
+ *           "foot" ("er")    ("ar") "foob"
+ *                    /          \
+ *          "footer" []          [] "foobar"
+ *
+ * Similarly after deletion, if a new chain of nodes having a single child
+ * is created (the chain must also not include nodes that represent keys),
+ * it must be compressed back into a single node.
+ *
+ */
+
+#define RAX_NODE_MAX_SIZE ((1<<29)-1)
+typedef struct raxNode {
+    uint32_t iskey:1;     /* Does this node contain a key? */
+    uint32_t isnull:1;    /* Associated value is NULL (don't store it). */
+    uint32_t iscompr:1;   /* Node is compressed. */
+    uint32_t size:29;     /* Number of children, or compressed string len. */
+    /* Data layout is as follows:
+     *
+     * If node is not compressed we have 'size' bytes, one for each children
+     * character, and 'size' raxNode pointers, point to each child node.
+     * Note how the character is not stored in the children but in the
+     * edge of the parents:
+     *
+     * [header iscompr=0][abc][a-ptr][b-ptr][c-ptr](value-ptr?)
+     *
+     * if node is compressed (iscompr bit is 1) the node has 1 children.
+     * In that case the 'size' bytes of the string stored immediately at
+     * the start of the data section, represent a sequence of successive
+     * nodes linked one after the other, for which only the last one in
+     * the sequence is actually represented as a node, and pointed to by
+     * the current compressed node.
+     *
+     * [header iscompr=1][xyz][z-ptr](value-ptr?)
+     *
+     * Both compressed and not compressed nodes can represent a key
+     * with associated data in the radix tree at any level (not just terminal
+     * nodes).
+     *
+     * If the node has an associated key (iskey=1) and is not NULL
+     * (isnull=0), then after the raxNode pointers poiting to the
+     * children, an additional value pointer is present (as you can see
+     * in the representation above as "value-ptr" field).
+     */
+    unsigned char data[];
+} raxNode;
+
+typedef struct rax {
+    raxNode *head;
+    uint64_t numele;
+    uint64_t numnodes;
+} rax;
+
+/* Stack data structure used by raxLowWalk() in order to, optionally, return
+ * a list of parent nodes to the caller. The nodes do not have a "parent"
+ * field for space concerns, so we use the auxiliary stack when needed. */
+#define RAX_STACK_STATIC_ITEMS 32
+typedef struct raxStack {
+    void **stack; /* Points to static_items or an heap allocated array. */
+    size_t items, maxitems; /* Number of items contained and total space. */
+    /* Up to RAXSTACK_STACK_ITEMS items we avoid to allocate on the heap
+     * and use this static array of pointers instead. */
+    void *static_items[RAX_STACK_STATIC_ITEMS];
+    int oom; /* True if pushing into this stack failed for OOM at some point. */
+} raxStack;
+
+/* Optional callback used for iterators and be notified on each rax node,
+ * including nodes not representing keys. If the callback returns true
+ * the callback changed the node pointer in the iterator structure, and the
+ * iterator implementation will have to replace the pointer in the radix tree
+ * internals. This allows the callback to reallocate the node to perform
+ * very special operations, normally not needed by normal applications.
+ *
+ * This callback is used to perform very low level analysis of the radix tree
+ * structure, scanning each possible node (but the root node), or in order to
+ * reallocate the nodes to reduce the allocation fragmentation (this is the
+ * Redis application for this callback).
+ *
+ * This is currently only supported in forward iterations (raxNext) */
+typedef int (*raxNodeCallback)(raxNode **noderef);
+
+/* Radix tree iterator state is encapsulated into this data structure. */
+#define RAX_ITER_STATIC_LEN 128
+#define RAX_ITER_JUST_SEEKED (1<<0) /* Iterator was just seeked. Return current
+                                       element for the first iteration and
+                                       clear the flag. */
+#define RAX_ITER_EOF (1<<1)    /* End of iteration reached. */
+#define RAX_ITER_SAFE (1<<2)   /* Safe iterator, allows operations while
+                                  iterating. But it is slower. */
+typedef struct raxIterator {
+    int flags;
+    rax *rt;                /* Radix tree we are iterating. */
+    unsigned char *key;     /* The current string. */
+    void *data;             /* Data associated to this key. */
+    size_t key_len;         /* Current key length. */
+    size_t key_max;         /* Max key len the current key buffer can hold. */
+    unsigned char key_static_string[RAX_ITER_STATIC_LEN];
+    raxNode *node;          /* Current node. Only for unsafe iteration. */
+    raxStack stack;         /* Stack used for unsafe iteration. */
+    raxNodeCallback node_cb; /* Optional node callback. Normally set to NULL. */
+} raxIterator;
+
+/* A special pointer returned for not found items. */
+extern void *raxNotFound;
+
+/* Exported API. */
+rax *raxNew(void);
+int raxInsert(rax *rax, unsigned char *s, size_t len, void *data, void **old);
+int raxTryInsert(rax *rax, unsigned char *s, size_t len, void *data, void **old);
+int raxRemove(rax *rax, unsigned char *s, size_t len, void **old);
+void *raxFind(rax *rax, unsigned char *s, size_t len);
+void raxFree(rax *rax);
+void raxFreeWithCallback(rax *rax, void (*free_callback)(void*));
+void raxStart(raxIterator *it, rax *rt);
+int raxSeek(raxIterator *it, const char *op, unsigned char *ele, size_t len);
+int raxNext(raxIterator *it);
+int raxPrev(raxIterator *it);
+int raxUp(raxIterator *it);
+int raxRandomWalk(raxIterator *it, size_t steps);
+int raxCompare(raxIterator *iter, const char *op, unsigned char *key, size_t key_len);
+void raxStop(raxIterator *it);
+int raxEOF(raxIterator *it);
+void raxShow(rax *rax);
+uint64_t raxSize(rax *rax);
+unsigned long raxTouch(raxNode *n);
+void raxSetDebugMsg(int onoff);
+
+/* Internal API. May be used by the node callback in order to access rax nodes
+ * in a low level way, so this function is exported as well. */
+void raxSetData(raxNode *n, void *data);
+
+#endif

package/src/rax/rax_malloc.h

@@ -0,0 +1,43 @@
+/* Rax -- A radix tree implementation.
+ *
+ * Copyright (c) 2017, Salvatore Sanfilippo <antirez at gmail dot 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.
+ *   * Neither the name of Redis nor the names of its contributors may be used
+ *     to endorse or promote products derived from this software without
+ *     specific prior written permission.
+ *
+ * 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.
+ */
+
+/* Allocator selection.
+ *
+ * This file is used in order to change the Rax allocator at compile time.
+ * Just define the following defines to what you want to use. Also add
+ * the include of your alternate allocator if needed (not needed in order
+ * to use the default libc allocator). */
+
+#ifndef RAX_ALLOC_H
+#define RAX_ALLOC_H
+#define rax_malloc malloc
+#define rax_realloc realloc
+#define rax_free free
+#endif

package/src/rax/rax_oom_malloc.h

@@ -0,0 +1,63 @@
+/* Rax -- A radix tree implementation.
+ *
+ * Copyright (c) 2017, Salvatore Sanfilippo <antirez at gmail dot 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.
+ *   * Neither the name of Redis nor the names of its contributors may be used
+ *     to endorse or promote products derived from this software without
+ *     specific prior written permission.
+ *
+ * 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.
+ */
+
+/* Allocator selection.
+ *
+ * This file is used in order to change the Rax allocator at compile time.
+ * Just define the following defines to what you want to use. Also add
+ * the include of your alternate allocator if needed (not needed in order
+ * to use the default libc allocator). */
+
+#ifndef RAX_ALLOC_H
+#define RAX_ALLOC_H
+
+#include <sys/types.h>
+#include <stdlib.h>
+
+void *oom_malloc(char *file, int line, size_t size) {
+    if ((rand() % 20) == 0) {
+        printf("oom_malloc(): returning NULL at %s:%d\n", file, line);
+        return NULL;
+    }
+    return malloc(size);
+}
+
+void *oom_realloc(char *file, int line, void *ptr, size_t size) {
+    if ((rand() % 20) == 0) {
+        printf("oom_remalloc(): returning NULL at %s:%d\n", file, line);
+        return NULL;
+    }
+    return realloc(ptr,size);
+}
+
+#define rax_malloc(sz) oom_malloc(__FILE__,__LINE__,(sz))
+#define rax_realloc(ptr,sz) oom_realloc(__FILE__,__LINE__,(ptr),(sz))
+#define rax_free free
+#endif

package/src/rax/rc4rand.c

@@ -0,0 +1,77 @@
+/* A simple RC4 based RNG that sucks less than the certain libc rand()
+ * implementations, notably the incredibly bad MacOS() implementation.
+ *
+ * Copyright (c) 2018, Salvatore Sanfilippo <antirez at gmail dot 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.
+ */
+
+#include <stdint.h>
+
+/* Initialize the sbox with an initial seed. */
+static unsigned char rc4_sbox[256] = {244, 223, 67, 241, 181, 90, 95, 76, 248, 141, 130, 109, 92, 230, 238, 131, 111, 26, 75, 196, 186, 185, 51, 4, 40, 156, 11, 23, 15, 101, 144, 128, 173, 121, 123, 124, 218, 89, 187, 29, 178, 7, 0, 1, 217, 113, 235, 33, 182, 158, 94, 221, 100, 53, 140, 172, 139, 24, 162, 143, 229, 202, 36, 37, 39, 35, 45, 231, 87, 103, 198, 14, 255, 83, 93, 136, 165, 64, 3, 16, 49, 219, 155, 183, 233, 73, 215, 10, 159, 247, 212, 99, 106, 74, 154, 72, 22, 19, 65, 52, 46, 195, 134, 197, 69, 209, 34, 91, 137, 115, 102, 135, 63, 211, 47, 56, 127, 161, 27, 9, 118, 220, 191, 54, 21, 216, 18, 253, 81, 148, 42, 213, 114, 12, 190, 245, 129, 8, 41, 201, 168, 177, 204, 32, 242, 82, 13, 117, 2, 152, 60, 66, 166, 193, 164, 79, 142, 133, 126, 30, 85, 252, 184, 20, 17, 205, 236, 174, 226, 138, 38, 62, 222, 157, 77, 145, 250, 6, 249, 78, 192, 132, 170, 189, 176, 86, 153, 97, 125, 50, 254, 44, 61, 240, 203, 225, 246, 88, 234, 150, 179, 149, 122, 25, 104, 214, 105, 199, 228, 200, 163, 5, 112, 84, 55, 206, 251, 31, 98, 167, 108, 116, 175, 194, 171, 188, 58, 210, 237, 96, 147, 208, 110, 80, 169, 71, 180, 243, 239, 59, 28, 227, 160, 146, 48, 107, 68, 151, 224, 119, 43, 57, 207, 120, 232, 70};
+
+void rc4srand(uint64_t seed) {
+    /* To seed the RNG in a reproducible way we use a simple
+     * hashing function, together with the swapping idea of the
+     * original RC4 key scheduling algorithm. */
+    for (int j = 0; j < 255; j++) rc4_sbox[j] = j;
+
+    seed ^= 5381;
+    for (int j = 0; j < 256; j++) {
+        seed = ((seed << 5) + seed) + j + 1;
+        int i = seed & 0xff;
+
+        /* Swap sbox[i] and sbox[j]. */
+        unsigned char t = rc4_sbox[j];
+        rc4_sbox[j] = rc4_sbox[i];
+        rc4_sbox[i] = t;
+    }
+}
+
+static void rc4(unsigned char *buf, unsigned long len) {
+    static unsigned int i = 0, j = 0;
+    unsigned int si, sj, x;
+
+    for (x = 0; x < len; x++) {
+	i = (i+1) & 0xff;
+	si = rc4_sbox[i];
+	j = (j + si) & 0xff;
+	sj = rc4_sbox[j];
+	rc4_sbox[i] = sj;
+	rc4_sbox[j] = si;
+	*buf++ = rc4_sbox[(si+sj)&0xff];
+    }
+}
+
+uint32_t rc4rand(void) {
+    uint32_t r;
+    rc4((unsigned char*)&r,sizeof(r));
+    return r;
+}
+
+uint64_t rc4rand64(void) {
+    uint64_t r;
+    rc4((unsigned char*)&r,sizeof(r));
+    return r;
+}

package/src/rax/rc4rand.h

@@ -0,0 +1,9 @@
+#ifndef RC4RAND_H
+#define RC4RAND_H
+
+#include <stdint.h>
+void rc4srand(uint64_t seed);
+uint32_t rc4rand(void);
+uint64_t rc4rand64(void);
+
+#endif

package/src/rax_wrapper.cpp

@@ -0,0 +1,238 @@
+#include <napi.h>
+#include <string>
+#include <iostream>
+
+extern "C" {
+#include "radix_tree.h"
+}
+
+class RaxIterator : public Napi::ObjectWrap<RaxIterator> {
+public:
+  static Napi::Object Init(Napi::Env env, Napi::Object exports);
+  RaxIterator(const Napi::CallbackInfo& info);
+
+private:
+  static Napi::FunctionReference constructor;
+  radix_iterator* iterator;
+  radix_tree* tree;
+  rt_str_t path;
+
+  Napi::Value Next(const Napi::CallbackInfo& info);
+  Napi::Value Prev(const Napi::CallbackInfo& info);
+  Napi::Value Up(const Napi::CallbackInfo& info);
+  Napi::Value Stop(const Napi::CallbackInfo& info);
+
+  friend class RadixTree;
+};
+
+class RadixTree : public Napi::ObjectWrap<RadixTree> {
+public:
+  static Napi::Object Init(Napi::Env env, Napi::Object exports);
+  RadixTree(const Napi::CallbackInfo& info);
+
+private:
+  static Napi::FunctionReference constructor;
+  radix_tree* tree;
+  radix_iterator* treeIt;
+
+  Napi::Value Insert(const Napi::CallbackInfo& info);
+  Napi::Value Remove(const Napi::CallbackInfo& info);
+  Napi::Value Find(const Napi::CallbackInfo& info);
+  Napi::Value Search(const Napi::CallbackInfo& info);
+  void Cleanup(const Napi::CallbackInfo& info);
+};
+
+Napi::FunctionReference RaxIterator::constructor;
+Napi::FunctionReference RadixTree::constructor;
+
+// RaxIterator implementation
+Napi::Object RaxIterator::Init(Napi::Env env, Napi::Object exports) {
+  Napi::HandleScope scope(env);
+
+  Napi::Function func = DefineClass(env, "RaxIterator", {
+    InstanceMethod("next", &RaxIterator::Next),
+    InstanceMethod("prev", &RaxIterator::Prev),
+    InstanceMethod("up", &RaxIterator::Up),
+    InstanceMethod("stop", &RaxIterator::Stop),
+  });
+
+  constructor = Napi::Persistent(func);
+  constructor.SuppressDestruct();
+
+  exports.Set("RaxIterator", func);
+  return exports;
+}
+
+RaxIterator::RaxIterator(const Napi::CallbackInfo& info) : Napi::ObjectWrap<RaxIterator>(info) {
+  Napi::Env env = info.Env();
+  if (info.Length() < 3 || !info[0].IsExternal() || !info[1].IsExternal() || !info[2].IsString()) {
+    Napi::TypeError::New(env, "Invalid arguments").ThrowAsJavaScriptException();
+    return;
+  }
+
+  this->tree = info[0].As<Napi::External<radix_tree>>().Data();
+  this->iterator = info[1].As<Napi::External<radix_iterator>>().Data();
+  
+  // Initialize path
+  std::string pathStr = info[2].As<Napi::String>().Utf8Value();
+  this->path.buf = new unsigned char[pathStr.length()];
+  memcpy(this->path.buf, pathStr.c_str(), pathStr.length());
+  this->path.len = pathStr.length();
+}
+
+Napi::Value RaxIterator::Next(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  int result = raxtree_next(this->iterator, &this->path);
+  return Napi::Number::New(env, result);
+}
+
+Napi::Value RaxIterator::Prev(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  int result = raxtree_prev(this->iterator, &this->path);
+  return Napi::Number::New(env, result);
+}
+
+Napi::Value RaxIterator::Up(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  int result = raxtree_up(this->iterator, &this->path);
+  return Napi::Number::New(env, result);
+}
+
+Napi::Value RaxIterator::Stop(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  raxtree_stop(this->iterator);
+  return env.Undefined();
+}
+
+// RadixTree implementation
+Napi::Object RadixTree::Init(Napi::Env env, Napi::Object exports) {
+  Napi::HandleScope scope(env);
+
+  Napi::Function func = DefineClass(env, "RadixTree", {
+    InstanceMethod("insert", &RadixTree::Insert),
+    InstanceMethod("remove", &RadixTree::Remove),
+    InstanceMethod("find", &RadixTree::Find),
+    InstanceMethod("search", &RadixTree::Search),
+    InstanceMethod("cleanup", &RadixTree::Cleanup),
+  });
+
+  constructor = Napi::Persistent(func);
+  constructor.SuppressDestruct();
+
+  exports.Set("RadixTree", func);
+  return exports;
+}
+
+RadixTree::RadixTree(const Napi::CallbackInfo& info) : Napi::ObjectWrap<RadixTree>(info) {
+  this->tree = raxtree_new();
+  this->treeIt = raxtree_new_it(this->tree);
+}
+
+Napi::Value RadixTree::Insert(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  if (info.Length() < 2) {
+    Napi::TypeError::New(env, "Wrong number of arguments").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+  
+  std::string key = info[0].As<Napi::String>().Utf8Value();
+  
+  if (!info[1].IsNumber()) {
+    Napi::TypeError::New(env, "Second argument must be an integer").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+  
+  int64_t value = info[1].As<Napi::Number>().Int64Value();
+  
+  if (value > INT_MAX || value < INT_MIN) {
+    Napi::RangeError::New(env, "Value is out of range for int").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+  
+  rt_str_t path;
+  path.buf = (unsigned char*)key.c_str();
+  path.len = key.length();
+  
+  int result = raxtree_insert(this->tree, &path, static_cast<int>(value));
+  return Napi::Number::New(env, result);
+}
+
+Napi::Value RadixTree::Remove(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  if (info.Length() < 1) {
+    Napi::TypeError::New(env, "Wrong number of arguments").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+  
+  std::string key = info[0].As<Napi::String>().Utf8Value();
+  
+  rt_str_t path;
+  path.buf = (unsigned char*)key.c_str();
+  path.len = key.length();
+  
+  int result = raxtree_remove(this->tree, &path);
+  
+  return Napi::Number::New(env, result);
+}
+
+Napi::Value RadixTree::Find(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  if (info.Length() < 1) {
+    Napi::TypeError::New(env, "Wrong number of arguments").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+  
+  std::string key = info[0].As<Napi::String>().Utf8Value();
+  
+  rt_str_t path;
+  path.buf = (unsigned char*)key.c_str();
+  path.len = key.length();
+  
+  void* result = raxtree_find(this->tree, &path);
+  
+  if (result == NULL) {
+    return env.Null();
+  }
+  
+  int value = reinterpret_cast<intptr_t>(result);
+  return Napi::Number::New(env, value);
+}
+
+Napi::Value RadixTree::Search(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  if (info.Length() < 1) {
+    Napi::TypeError::New(env, "Wrong number of arguments").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  std::string ele = info[0].As<Napi::String>().Utf8Value();
+  rt_str_t path;
+  path.buf = (unsigned char*)ele.c_str();
+  path.len = ele.length();
+
+  radix_iterator* result = (radix_iterator*)raxtree_search(this->tree, this->treeIt, &path);
+  if (result == NULL) {
+    return env.Null();
+  }
+
+  auto iteratorInstance = RaxIterator::constructor.New({
+    Napi::External<radix_tree>::New(env, this->tree),
+    Napi::External<radix_iterator>::New(env, result),
+    Napi::String::New(env, ele)
+  });
+
+  return iteratorInstance;
+}
+
+void RadixTree::Cleanup(const Napi::CallbackInfo& info) {
+  raxtree_stop(this->treeIt);
+  raxtree_destroy(this->tree);
+}
+
+Napi::Object InitAll(Napi::Env env, Napi::Object exports) {
+  RadixTree::Init(env, exports);
+  RaxIterator::Init(env, exports);
+  return exports;
+}
+
+NODE_API_MODULE(radix_tree, InitAll)