from ac_diskstructs import HashMap

hm = HashMap('/path/to/datafile')

value = hm[1] # Returns `bytes`

hm.delete() # Free memory

const {HashMap} = require('ac-diskstructs');

const hm = new HashMap('/path/to/datafile');

const value = hm.get(1); // Returns `Buffer`

hm.delete(); // Free memory

#include <ac-library/containers/persistent/immutable_hashmap/hashmap.hpp>

NAC::TPersistentImmutableHashMap hm(std::string("/path/to/datafile"), NAC::TPersistentImmutableHashMap::DefaultSeed);

NAC::TBlob value(hm[(uint64_t) 1]);

from ac_diskstructs import HashMap

hm = HashMap('/path/to/datafile', key_type=bytes)

value = hm['one'] # Returns `bytes`

hm.delete() # Free memory

const {HashMap} = require('ac-diskstructs');

const hm = new HashMap('/path/to/datafile', {keyType: Buffer});

const value = hm.get('one'); // Returns `Buffer`

hm.delete(); // Free memory

#include <ac-library/containers/persistent/immutable_hashmap/hashmap.hpp>

NAC::TPersistentImmutableHashMap hm(std::string("/path/to/datafile"), NAC::TPersistentImmutableHashMap::DefaultSeed);

NAC::TBlob value(hm["one"]);

from ac_diskstructs import Heap

heap = Heap('/path/to/datafile')

single_record_matching_prefix = heap["word"] # Returns `bytes`

all_records_matching_prefix = heap.get_all("wo") # Returns iterable over `bytes` objects

for record in all_records_matching_prefix:
    record # `bytes`

all_records_matching_prefix.delete() # Free memory

heap.delete() # Free memory

const {Heap} = require('ac-diskstructs');

const heap = new Heap('/path/to/datafile');

const singleRecordMatchingPrefix = heap.get("word"); // Returns `Buffer`

const allRecordsMatchingPrefix = heap.getAll("wo"); // Returns iterable over `Buffer` objects

for (let record of allRecordsMatchingPrefix) {
  record; // `Buffer`
}

allRecordsMatchingPrefix.delete(); // Free memory

heap.delete(); // Free memory

#include <ac-library/containers/persistent/binary_heap/binary_heap.hpp>

NAC::TPersistentBinaryHeap heap(std::string("/path/to/datafile"));

{
    NAC::TBlob prefix;
    prefix.Append(/* size = */4, "word");

    NAC::TBlob singleRecordMatchingPrefix(heap.Get(prefix));
}

{
    NAC::TBlob shortPrefix;
    shortPrefix.Append(/* size = */2, "wo");

    NAC::TPersistentBinaryHeap::TIterator allRecordsMatchingPrefix(heap.GetAll(shortPrefix));
    NAC::TBlob value;

    while (allRecordsMatchingPrefix.Next(value)) {
        value; // Contains current record
    }
}

from ac_diskstructs import RBTree

rbt = RBTree('/path/to/datafile')

value = rbt['one'] # Returns `bytes`

all_items_matching_prefix = rbt.get_all("wo") # Returns iterable over pairs of `bytes` objects

for (key, value) in all_items_matching_prefix:
    key # `bytes`
    value # `bytes`

all_items_matching_prefix.delete() # Free memory

rbt.delete() # Free memory

const {RBTree} = require('ac-diskstructs');

const rbt = new RBTree('/path/to/datafile');

const value = rbt.get('one'); // Returns `Buffer`

const allItemsMatchingPrefix = rbt.getAll("wo"); // Returns iterable over pairs of `Buffer` objects

for (let [key, value] of allItemsMatchingPrefix) {
  key; // `Buffer`
  value; // `Buffer`
}

allItemsMatchingPrefix.delete(); // Free memory

rbt.delete(); // Free memory

#include <ac-library/containers/rbtree/persistent.hpp>

NAC::TPersistentRBTree rbt(std::string("/path/to/datafile"));
rbt.FindRoot(); // This call is required for opening existing tree!

{
    NAC::TBlob value(rbt["one"]);
}

{
    NAC::TRBTreeBase::TIterator allItemsMatchingPrefix(rbt.GetAll("on"));
    NAC::TBlob key;
    NAC::TBlob value;

    while (allItemsMatchingPrefix.Next(key, value)) {
        key; // Contains current key
        value; // Contains current value
    }
}

from ac_diskstructs import HashMap

bucket_count = 16
hm = HashMap('/path/to/datafile', bucket_count=bucket_count)

hm[1] = 'hello'
hm[2] = 'hi'
hm[3] = 'hey'
hm[4] = 'hola'

hm.close() # Finish write operations
hm.delete() # Free memory

const {HashMap} = require('ac-diskstructs');

const bucketCount = 16;
const hm = new HashMap('/path/to/datafile', {bucketCount});

hm.set(1, 'hello');
hm.set(2, 'hi');
hm.set(3, 'hey');
hm.set(4, 'hola');

hm.close(); // Finish write operations
hm.delete(); // Free memory

#include <ac-library/containers/persistent/immutable_hashmap/hashmap.hpp>

const uint64_t bucketCount(16);
NAC::TPersistentImmutableHashMap hm(std::string("/path/to/datafile"), bucketCount, NAC::TPersistentImmutableHashMap::DefaultSeed);

hm[(uint64_t) 1] = "hello";
hm[(uint64_t) 2] = "hi";
hm[(uint64_t) 3] = "hey";
hm[(uint64_t) 4] = "hola";

hm.Close(); // Finish write operations

from ac_diskstructs import HashMap

bucket_count = 16
hm = HashMap('/path/to/datafile', bucket_count=bucket_count, key_type=bytes)

hm['one'] = 'hello'
hm['two'] = 'hi'
hm['three'] = 'hey'
hm['four'] = 'hola'

hm.close() # Finish write operations
hm.delete() # Free memory

const {HashMap} = require('ac-diskstructs');

const bucketCount = 16;
const hm = new HashMap('/path/to/datafile', {bucketCount, keyType: Buffer});

hm.set('one', 'hello');
hm.set('two', 'hi');
hm.set('three', 'hey');
hm.set('four', 'hola');

hm.close(); // Finish write operations
hm.delete(); // Free memory

#include <ac-library/containers/persistent/immutable_hashmap/hashmap.hpp>

const uint64_t bucketCount(16);
NAC::TPersistentImmutableHashMap hm(std::string("/path/to/datafile"), bucketCount, NAC::TPersistentImmutableHashMap::DefaultSeed);

hm["one"] = "hello";
hm["two"] = "hi";
hm["three"] = "hey";
hm["four"] = "hola";

hm.Close(); // Finish write operations

from ac_diskstructs import Heap

record_size = 4 # Size in BYTES!
heap = Heap('/path/to/datafile', record_size=record_size)

heap.insert("word")
heap.insert("size")
heap.insert("four")

# heap.insert("hello") # Record is longer than record_size == data corruption
# heap.insert("hi") # Record is shorter than record_size == data corruption too

heap.close() # Finish write operations
heap.delete() # Free memory

const {Heap} = require('ac-diskstructs');

const recordSize = 4; // Size in BYTES!
const heap = new Heap('/path/to/datafile', {recordSize});

heap.insert("word");
heap.insert("size");
heap.insert("four");

// heap.insert("hello"); // Record is longer than recordSize == data corruption
// heap.insert("hi"); // Record is shorter than recordSize == data corruption too

heap.close(); // Finish write operations
heap.delete(); // Free memory

#include <ac-library/containers/persistent/binary_heap/binary_heap.hpp>

const uint64_t recordSize(4); // Size in BYTES!
NAC::TPersistentBinaryHeap heap(std::string("/path/to/datafile"), recordSize);

heap.Insert("word");
heap.Insert("size");
heap.Insert("four");

// heap.Insert("hello"); // Record is longer than recordSize == data corruption
// heap.Insert("hi"); // Record is shorter than recordSize == data corruption too

heap.Close(); // Finish write operations

from ac_diskstructs import RBTree

rbt = RBTree('/path/to/datafile', create=True) # use `rw=True` instead of `create=True` to update existing tree

rbt['one'] = 'hello'
rbt['two'] = 'hi'
rbt['three'] = 'hey'
rbt['four'] = 'hola'

rbt.delete() # Free memory

const {RBTree} = require('ac-diskstructs');

const rbt = new RBTree('/path/to/datafile', {create: true}); // use `rw: true` instead of `create: true` to update existing tree

rbt.insert('one', 'hello');
rbt.insert('two', 'hi');
rbt.insert('three', 'hey');
rbt.insert('four', 'hola');

rbt.delete(); // Free memory

#include <ac-library/containers/rbtree/persistent.hpp>

NAC::TPersistentRBTree rbt(std::string("/path/to/datafile"), NAC::TFile::ACCESS_CREATE);
// Or, to update existing tree:
// NAC::TPersistentRBTree rbt(std::string("/path/to/datafile"), NAC::TFile::ACCESS_RDWR);
// rbt.FindRoot(); // This call is required for opening existing tree!
                   // Absence of `FindRoot()` call before updating existing tree
                   // will lead to data corruption.

rbt["one"] = "hello";
rbt["two"] = "hi";
rbt["three"] = "hey";
rbt["four"] = "hola";