serializable-bptree 1.0.4 → 2.0.0

package/README.md

@@ -59,7 +59,7 @@ tree.where({ gt: 0, lt: 4 }) // [{ key: 'a', value: 1 }, { key: 'c', value: 3 }]
 
 ## Why use a `serializable-bptree`?
 
-Firstly, in most cases, there is no need to use a B+tree in JavaScript. This is because there is a great alternative, the Map object. Nonetheless, if you need to retrieve values in a sorted order, a B+tree can be a good solution. These cases are often related to databases, and you may want to store this state not just in memory, but on a remote server or in a file. In this case, `serializable-bptree` can help you.
+Firstly, in most cases, there is no need to use a B+tree in JavaScript. This is because there is a great alternative, the Map object. Nonetheless, if you need to retrieve values in a sorted order, a B+tree can be a good solution. These cases are often related to databases, and you may want to store this state not just in memory, but on a remote server or in a file. In this case, **serializable-bptree** can help you.
 
 ## How to use
 
@@ -77,7 +77,7 @@ import { BPTree } from 'serializable-bptree'
 
 ```html
 <script type="module">
-  import { BPTree } from 'https://cdn.jsdelivr.net/npm/serializable-bptree@1.x.x/dist/esm/index.min.js'
+  import { BPTree, ValueComparator, NumericComparator, StringComparator, InMemoryStoreStrategy } from 'https://cdn.jsdelivr.net/npm/serializable-bptree@1.x.x/dist/esm/index.min.js'
 </script>
 ```
 
@@ -85,15 +85,15 @@ import { BPTree } from 'serializable-bptree'
 
 ### Value comparator
 
-B+tree needs to keep values in sorted order. Therefore, a process to compare the sizes of values is needed, and that role is played by the `ValueComparator`.
+B+tree needs to keep values in sorted order. Therefore, a process to compare the sizes of values is needed, and that role is played by the **ValueComparator**.
 
-Commonly used numerical and string comparisons are natively supported by the `serializable-bptree` library. Use it as follows:
+Commonly used numerical and string comparisons are natively supported by the **serializable-bptree** library. Use it as follows:
 
 ```typescript
 import { NumericComparator, StringComparator } from 'serializable-bptree'
 ```
 
-However, you may want to sort complex objects other than numbers and strings. For example, if you want to sort by the `age` property order of an object, you need to create a new class that inherits from the `ValueComparator` class. Use it as follows:
+However, you may want to sort complex objects other than numbers and strings. For example, if you want to sort by the **age** property order of an object, you need to create a new class that inherits from the **ValueComparator** class. Use it as follows:
 
 ```typescript
 import { ValueComparator } from 'serializable-bptree'
@@ -103,13 +103,15 @@ interface MyObject {
   name: string
 }
 
-class AgeComparator {
+class AgeComparator extends ValueComparator<MyObject> {
   asc(a: MyObject, b: MyObject): number {
     return a.age - b.age
   }
 }
 ```
 
+The **asc** method should return values in ascending order. If the return value is negative, it means that the parameter **a** is smaller than **b**. If the return value is positive, it means that **a** is greater than **b**. If the return value is **0**, it indicates that **a** and **b** are of the same size.
+
 ### Serialize strategy
 
 A B+tree instance is made up of numerous nodes. You would want to store this value when such nodes are created or updated. Let's assume you want to save it to a file.
@@ -132,7 +134,7 @@ What does this method mean? And why do we need to construct such a method?
 
 #### id(): `number`
 
-When a node is created in the B+tree, the node needs a unique value to represent itself. This is the `node.id` attribute, and you can specify this attribute yourself. For example, it could be implemented like this.
+When a node is created in the B+tree, the node needs a unique value to represent itself. This is the **node.id** attribute, and you can specify this attribute yourself. For example, it could be implemented like this.
 
 ```typescript
 id(): number {
@@ -142,7 +144,9 @@ id(): number {
 }
 ```
 
-Or, you could use file input/output to save and load the value of the `before` variable.
+Or, you could use file input/output to save and load the value of the **before** variable.
+
+This method is called before a node is created in the tree. Therefore, it can also be used to allocate space for storing the node.
 
 #### read(id: `number`): `BPTreeNode<K, V>`
 
@@ -158,7 +162,7 @@ read(id: number): BPTreeNode<K, V> {
 }
 ```
 
-This method is called only once when loading a node from a tree instance.
+This method is called only once when loading a node from a tree instance. The loaded node is loaded into memory, and subsequently, when the tree references the node, it operates based on the values in memory **without** re-invoking this method.
 
 #### write(id: `number`, node: `BPTreeNode<K, V>`): `void`
 
@@ -181,7 +185,7 @@ function writeBack(id: number, node: BPTreeNode<K, V>, timer: number) {
 
 ...
 write(id: number, node: BPTreeNode<K, V>): void {
-  const writeBackInterval = 100
+  const writeBackInterval = 10
   writeBack(id, node, writeBackInterval)
 }
 ```
@@ -190,32 +194,32 @@ This kind of delay writing should ideally occur within a few milliseconds. If th
 
 #### readHead(): `SerializeStrategyHead`|`null`
 
-This method is called only once when the tree is created. It's a method to restore the saved tree information. If it is the initial creation and there is no stored root node, it should return `null`.
+This method is called only once when the tree is created. It's a method to restore the saved tree information. If it is the initial creation and there is no stored root node, it should return **null**.
 
-This method should return the value stored in the `writeHead` method.
+This method should return the value stored in the **writeHead** method.
 
 #### writeHead(head: `SerializeStrategyHead`): `void`
 
-This method is called whenever the head information of the tree changes, typically when the root node changes.
+This method is called whenever the head information of the tree changes, typically when the root node changes. This method also works when the tree's **setHeadData** method is called. This is because the method attempts to store head data in the root node.
 
-As a parameter, it receives the header information of the tree. This value should be serialized and stored. Later, the `readHead` method should convert this serialized value into a json format and return it.
+As a parameter, it receives the header information of the tree. This value should be serialized and stored. Later, the **readHead** method should convert this serialized value into a json format and return it.
 
 ### The Default `ValueComparator` and `SerializeStrategy`
 
-To utilize `serializable-bptree`, you need to implement certain functions. However, a few basic helper classes are provided by default.
+To utilize **serializable-bptree**, you need to implement certain functions. However, a few basic helper classes are provided by default.
 
 #### ValueComparator
 
 * `NumericComparator`
 * `StringComparator`
 
-If the values being inserted into the tree are numeric, please use the `NumericComparator` class.
+If the values being inserted into the tree are numeric, please use the **NumericComparator** class.
 
 ```typescript
 import { NumericComparator } from 'serializable-bptree'
 ```
 
-If the values being inserted into the tree can be strings, you can use the `StringComparator` class in this case.
+If the values being inserted into the tree can be strings, you can use the **StringComparator** class in this case.
 
 ```typescript
 import { StringComparator } from 'serializable-bptree'
@@ -225,7 +229,7 @@ import { StringComparator } from 'serializable-bptree'
 
 * `InMemoryStoreStrategy`
 
-As of now, the only class supported by default is the `InMemoryStoreStrategy`. This class is suitable for use when you prefer to operate the tree solely in-memory, similar to a typical B+ tree.
+As of now, the only class supported by default is the **InMemoryStoreStrategy**. This class is suitable for use when you prefer to operate the tree solely in-memory, similar to a typical B+ tree.
 
 ```typescript
 import { InMemoryStoreStrategy } from 'serializable-bptree'