serializable-bptree 1.0.1 → 1.0.3

package/README.md

@@ -41,7 +41,7 @@ class FileStoreStrategy extends SerializeStrategy<K, V> {
 
 const order = 5
 const tree = new BPTree(
-  new SerializeStrategy(order),
+  new FileStoreStrategy(order),
   new NumericComparator()
 )
 

package/dist/cjs/index.js

@@ -189,7 +189,8 @@ var BPTree = class {
   leftestNode() {
     let node = this.root;
     while (!node.leaf) {
-      node = node.keys[0];
+      const keys = node.keys;
+      node = this.getNode(keys[0]);
     }
     return node;
   }
@@ -198,14 +199,15 @@ var BPTree = class {
     while (!node.leaf) {
       for (let i = 0, len = node.values.length; i < len; i++) {
         const nValue = node.values[i];
+        const k = node.keys;
         if (this.comparator.isSame(value, nValue)) {
-          node = node.keys[i + 1];
+          node = this.getNode(k[i + 1]);
           break;
         } else if (this.comparator.isLower(value, nValue)) {
-          node = node.keys[i];
+          node = this.getNode(k[i]);
           break;
         } else if (i + 1 === node.values.length) {
-          node = node.keys[i + 1];
+          node = this.getNode(k[i + 1]);
           break;
         }
       }
@@ -257,7 +259,7 @@ var BPTree = class {
   }
   _insertInParent(node, value, pointer) {
     if (this.root === node) {
-      const root = this._createNode([node, pointer], [value]);
+      const root = this._createNode([node.id, pointer.id], [value]);
       this.root = root;
       node.parent = root.id;
       pointer.parent = root.id;
@@ -270,9 +272,9 @@ var BPTree = class {
     const parentNode = this.getNode(node.parent);
     for (let i = 0, len = parentNode.keys.length; i < len; i++) {
       const nKeys = parentNode.keys[i];
-      if (nKeys === node) {
+      if (nKeys === node.id) {
         parentNode.values.splice(i, 0, value);
-        parentNode.keys.splice(i + 1, 0, pointer);
+        parentNode.keys.splice(i + 1, 0, pointer.id);
         this._setUpdates(parentNode);
         if (parentNode.keys.length > this.order) {
           const parentPointer = this._createNode([], []);
@@ -288,12 +290,14 @@ var BPTree = class {
           }
           parentNode.keys = parentNode.keys.slice(0, mid + 1);
           for (const k of parentNode.keys) {
-            const key = k;
-            key.parent = parentNode.id;
+            const node2 = this.getNode(k);
+            node2.parent = parentNode.id;
+            this._setUpdates(node2);
           }
           for (const k of parentPointer.keys) {
-            const key = k;
-            key.parent = parentPointer.id;
+            const node2 = this.getNode(k);
+            node2.parent = parentPointer.id;
+            this._setUpdates(node2);
           }
           this._insertInParent(parentNode, midValue, parentPointer);
           this._setCreates(parentPointer);
@@ -494,7 +498,8 @@ var BPTree = class {
    */
   delete(key, value) {
     const node = this._insertableNode(value);
-    for (let i = 0, len = node.values.length; i < len; i++) {
+    let i = node.values.length;
+    while (i--) {
       const nValue = node.values[i];
       if (this.comparator.isSame(value, nValue)) {
         const keys = node.keys[i];
@@ -541,7 +546,7 @@ var BPTree = class {
     }
     if (this.root === node && node.keys.length === 1) {
       const keys = node.keys;
-      this.root = keys[0];
+      this.root = this.getNode(keys[0]);
       this.root.parent = 0;
       this._setHeadUpdate(this._headState);
       this._setUpdates(this.root);
@@ -557,13 +562,13 @@ var BPTree = class {
       let postK = null;
       for (let i = 0, len = parentNode.keys.length; i < len; i++) {
         const nKey = parentNode.keys[i];
-        if (nKey === node) {
+        if (nKey === node.id) {
           if (i > 0) {
-            prevNode = parentNode.keys[i - 1];
+            prevNode = this.getNode(parentNode.keys[i - 1]);
             prevK = parentNode.values[i - 1];
           }
           if (i < parentNode.keys.length - 1) {
-            nextNode = parentNode.keys[i + 1];
+            nextNode = this.getNode(parentNode.keys[i + 1]);
             postK = parentNode.values[i];
           }
         }
@@ -603,10 +608,12 @@ var BPTree = class {
         if (!pointer.leaf) {
           const keys = pointer.keys;
           for (const key2 of keys) {
-            key2.parent = pointer.id;
+            const node2 = this.getNode(key2);
+            node2.parent = pointer.id;
+            this._setUpdates(node2);
           }
         }
-        this._deleteEntry(this.getNode(node.parent), node, guess);
+        this._deleteEntry(this.getNode(node.parent), node.id, guess);
         this._setUpdates(pointer);
       } else {
         if (isPredecessor) {
@@ -679,24 +686,24 @@ var BPTree = class {
           this._setUpdates(pointer);
         }
         if (!pointer.leaf) {
-          const keys = pointer.keys;
-          for (const key2 of keys) {
-            key2.parent = pointer.id;
-            this._setUpdates(pointer);
+          for (const key2 of pointer.keys) {
+            const n = this.getNode(key2);
+            n.parent = pointer.id;
+            this._setUpdates(n);
           }
         }
         if (!node.leaf) {
-          const keys = node.keys;
-          for (const key2 of keys) {
-            key2.parent = node.id;
-            this._setUpdates(node);
+          for (const key2 of node.keys) {
+            const n = this.getNode(key2);
+            n.parent = node.id;
+            this._setUpdates(n);
           }
         }
         if (!parentNode.leaf) {
-          const keys = parentNode.keys;
-          for (const key2 of keys) {
-            key2.parent = parentNode.id;
-            this._setUpdates(parentNode);
+          for (const key2 of parentNode.keys) {
+            const n = this.getNode(key2);
+            n.parent = parentNode.id;
+            this._setUpdates(n);
           }
         }
       }

package/dist/esm/index.js

@@ -158,7 +158,8 @@ var BPTree = class {
   leftestNode() {
     let node = this.root;
     while (!node.leaf) {
-      node = node.keys[0];
+      const keys = node.keys;
+      node = this.getNode(keys[0]);
     }
     return node;
   }
@@ -167,14 +168,15 @@ var BPTree = class {
     while (!node.leaf) {
       for (let i = 0, len = node.values.length; i < len; i++) {
         const nValue = node.values[i];
+        const k = node.keys;
         if (this.comparator.isSame(value, nValue)) {
-          node = node.keys[i + 1];
+          node = this.getNode(k[i + 1]);
           break;
         } else if (this.comparator.isLower(value, nValue)) {
-          node = node.keys[i];
+          node = this.getNode(k[i]);
           break;
         } else if (i + 1 === node.values.length) {
-          node = node.keys[i + 1];
+          node = this.getNode(k[i + 1]);
           break;
         }
       }
@@ -226,7 +228,7 @@ var BPTree = class {
   }
   _insertInParent(node, value, pointer) {
     if (this.root === node) {
-      const root = this._createNode([node, pointer], [value]);
+      const root = this._createNode([node.id, pointer.id], [value]);
       this.root = root;
       node.parent = root.id;
       pointer.parent = root.id;
@@ -239,9 +241,9 @@ var BPTree = class {
     const parentNode = this.getNode(node.parent);
     for (let i = 0, len = parentNode.keys.length; i < len; i++) {
       const nKeys = parentNode.keys[i];
-      if (nKeys === node) {
+      if (nKeys === node.id) {
         parentNode.values.splice(i, 0, value);
-        parentNode.keys.splice(i + 1, 0, pointer);
+        parentNode.keys.splice(i + 1, 0, pointer.id);
         this._setUpdates(parentNode);
         if (parentNode.keys.length > this.order) {
           const parentPointer = this._createNode([], []);
@@ -257,12 +259,14 @@ var BPTree = class {
           }
           parentNode.keys = parentNode.keys.slice(0, mid + 1);
           for (const k of parentNode.keys) {
-            const key = k;
-            key.parent = parentNode.id;
+            const node2 = this.getNode(k);
+            node2.parent = parentNode.id;
+            this._setUpdates(node2);
           }
           for (const k of parentPointer.keys) {
-            const key = k;
-            key.parent = parentPointer.id;
+            const node2 = this.getNode(k);
+            node2.parent = parentPointer.id;
+            this._setUpdates(node2);
           }
           this._insertInParent(parentNode, midValue, parentPointer);
           this._setCreates(parentPointer);
@@ -463,7 +467,8 @@ var BPTree = class {
    */
   delete(key, value) {
     const node = this._insertableNode(value);
-    for (let i = 0, len = node.values.length; i < len; i++) {
+    let i = node.values.length;
+    while (i--) {
       const nValue = node.values[i];
       if (this.comparator.isSame(value, nValue)) {
         const keys = node.keys[i];
@@ -510,7 +515,7 @@ var BPTree = class {
     }
     if (this.root === node && node.keys.length === 1) {
       const keys = node.keys;
-      this.root = keys[0];
+      this.root = this.getNode(keys[0]);
       this.root.parent = 0;
       this._setHeadUpdate(this._headState);
       this._setUpdates(this.root);
@@ -526,13 +531,13 @@ var BPTree = class {
       let postK = null;
       for (let i = 0, len = parentNode.keys.length; i < len; i++) {
         const nKey = parentNode.keys[i];
-        if (nKey === node) {
+        if (nKey === node.id) {
           if (i > 0) {
-            prevNode = parentNode.keys[i - 1];
+            prevNode = this.getNode(parentNode.keys[i - 1]);
             prevK = parentNode.values[i - 1];
           }
           if (i < parentNode.keys.length - 1) {
-            nextNode = parentNode.keys[i + 1];
+            nextNode = this.getNode(parentNode.keys[i + 1]);
             postK = parentNode.values[i];
           }
         }
@@ -572,10 +577,12 @@ var BPTree = class {
         if (!pointer.leaf) {
           const keys = pointer.keys;
           for (const key2 of keys) {
-            key2.parent = pointer.id;
+            const node2 = this.getNode(key2);
+            node2.parent = pointer.id;
+            this._setUpdates(node2);
           }
         }
-        this._deleteEntry(this.getNode(node.parent), node, guess);
+        this._deleteEntry(this.getNode(node.parent), node.id, guess);
         this._setUpdates(pointer);
       } else {
         if (isPredecessor) {
@@ -648,24 +655,24 @@ var BPTree = class {
           this._setUpdates(pointer);
         }
         if (!pointer.leaf) {
-          const keys = pointer.keys;
-          for (const key2 of keys) {
-            key2.parent = pointer.id;
-            this._setUpdates(pointer);
+          for (const key2 of pointer.keys) {
+            const n = this.getNode(key2);
+            n.parent = pointer.id;
+            this._setUpdates(n);
           }
         }
         if (!node.leaf) {
-          const keys = node.keys;
-          for (const key2 of keys) {
-            key2.parent = node.id;
-            this._setUpdates(node);
+          for (const key2 of node.keys) {
+            const n = this.getNode(key2);
+            n.parent = node.id;
+            this._setUpdates(n);
           }
         }
         if (!parentNode.leaf) {
-          const keys = parentNode.keys;
-          for (const key2 of keys) {
-            key2.parent = parentNode.id;
-            this._setUpdates(parentNode);
+          for (const key2 of parentNode.keys) {
+            const n = this.getNode(key2);
+            n.parent = parentNode.id;
+            this._setUpdates(n);
           }
         }
       }

package/dist/typings/BPTree.d.ts

@@ -1,7 +1,6 @@
 import { BinarySearch } from './utils/BinarySearch';
 import { ValueComparator } from './ValueComparator';
 import { SerializeStrategy } from './SerializeStrategy';
-type BPTreeNodeKey<K, V> = K[] | BPTreeNode<K, V>;
 type BPTreeCondition<V> = {
     gt?: V;
     lt?: V;
@@ -14,21 +13,30 @@ type BPTreePair<K, V> = {
     key: K;
     value: V;
 };
+export type BPTreeUnknownNode<K, V> = BPTreeInternalNode<K, V> | BPTreeLeafNode<K, V>;
 export interface BPTreeNode<K, V> {
     id: number;
-    keys: BPTreeNodeKey<K, V>[];
+    keys: number[] | K[][];
     values: V[];
     leaf: boolean;
     parent: number;
     next: number;
 }
+export interface BPTreeInternalNode<K, V> extends BPTreeNode<K, V> {
+    leaf: false;
+    keys: number[];
+}
+export interface BPTreeLeafNode<K, V> extends BPTreeNode<K, V> {
+    leaf: true;
+    keys: K[][];
+}
 export declare class BPTree<K, V> {
     protected readonly strategy: SerializeStrategy<K, V>;
     protected readonly comparator: ValueComparator<V>;
     protected readonly search: BinarySearch<V>;
     protected readonly order: number;
-    protected readonly nodes: Map<number, BPTreeNode<K, V>>;
-    protected root: BPTreeNode<K, V>;
+    protected readonly nodes: Map<number, BPTreeUnknownNode<K, V>>;
+    protected root: BPTreeUnknownNode<K, V>;
     private readonly _creates;
     private readonly _updates;
     private _updatedHead;
@@ -46,8 +54,8 @@ export declare class BPTree<K, V> {
     private _emitHeadUpdates;
     private _emitCreates;
     private _emitUpdates;
-    protected getNode(id: number): BPTreeNode<K, V>;
-    protected leftestNode(): BPTreeNode<K, V>;
+    protected getNode(id: number): BPTreeUnknownNode<K, V>;
+    protected leftestNode(): BPTreeLeafNode<K, V>;
     private _insertableNode;
     /**
      * It returns whether there is a value in the tree.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "serializable-bptree",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "Store the B+tree flexibly, not only in-memory.",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",