hamok/lib/collections/HamokMap.d.ts

Lightweight Distributed Object Storage on RAFT consensus algorithm

import { EventEmitter } from 'events';
import { HamokConnection } from './HamokConnection';
import { BaseMap } from './BaseMap';
import { HamokMapSnapshot } from '../HamokSnapshot';
export type HamokMapEventMap<K, V> = {
    'insert': [key: K, value: V];
    'update': [key: K, oldValue: V, newValue: V];
    'remove': [key: K, value: V];
    'clear': [];
    'close': [];
};
export declare interface HamokMap<K, V> {
    on<U extends keyof HamokMapEventMap<K, V>>(event: U, listener: (...args: HamokMapEventMap<K, V>[U]) => void): this;
    off<U extends keyof HamokMapEventMap<K, V>>(event: U, listener: (...args: HamokMapEventMap<K, V>[U]) => void): this;
    once<U extends keyof HamokMapEventMap<K, V>>(event: U, listener: (...args: HamokMapEventMap<K, V>[U]) => void): this;
    emit<U extends keyof HamokMapEventMap<K, V>>(event: U, ...args: HamokMapEventMap<K, V>[U]): boolean;
}
/**
 * Replicated storage replicates all entries on all distributed storages
 */
export declare class HamokMap<K, V> extends EventEmitter {
    readonly connection: HamokConnection<K, V>;
    readonly baseMap: BaseMap<K, V>;
    private _closed;
    equalValues: (a: V, b: V) => boolean;
    private _initializing?;
    constructor(connection: HamokConnection<K, V>, baseMap: BaseMap<K, V>, equalValues?: (a: V, b: V) => boolean);
    get id(): string;
    get ready(): Promise<this>;
    get closed(): boolean;
    close(): void;
    get size(): number;
    get isEmpty(): boolean;
    keys(): IterableIterator<K>;
    clear(): Promise<void>;
    get(key: K): V | undefined;
    getAll(keys: IterableIterator<K> | K[]): ReadonlyMap<K, V>;
    set(key: K, value: V): Promise<V | undefined>;
    setAll(entries: ReadonlyMap<K, V>): Promise<ReadonlyMap<K, V>>;
    insert(key: K, value: V): Promise<V | undefined>;
    insertAll(entries: ReadonlyMap<K, V> | [K, V][]): Promise<ReadonlyMap<K, V>>;
    delete(key: K): Promise<boolean>;
    deleteAll(keys: ReadonlySet<K> | K[]): Promise<ReadonlySet<K>>;
    removeIf(key: K, oldValue: V): Promise<boolean>;
    remove(key: K): Promise<boolean>;
    removeAll(keys: ReadonlySet<K> | K[]): Promise<ReadonlyMap<K, V>>;
    updateIf(key: K, value: V, oldValue: V): Promise<boolean>;
    [Symbol.iterator](): IterableIterator<[K, V]>;
    entries(): IterableIterator<[K, V]>;
    values(): IterableIterator<V>;
    /**
     * Exports the storage data
     */
    export(): HamokMapSnapshot;
    import(data: HamokMapSnapshot, eventing?: boolean): void;
    private _import;
    static uint8ArrayToStringCodec: import("../common/HamokCodec").HamokCodec<Uint8Array[], string[]>;
}
//# sourceMappingURL=HamokMap.d.ts.map