hamok/lib/collections/HamokQueue.d.ts

Lightweight Distributed Object Storage on RAFT consensus algorithm

import { HamokConnection } from './HamokConnection';
import { BaseMap } from './BaseMap';
import { HamokQueueSnapshot } from '../HamokSnapshot';
import { EventEmitter } from 'events';
export type HamokQueueEventMap<T> = {
    'empty': [];
    'not-empty': [];
    'close': [];
    'add': [T];
    'remove': [T];
};
export type HamokQueueConfig = {
    queueId: string;
    maxQueueSize?: number;
};
export declare interface HamokQueue<T> {
    on<U extends keyof HamokQueueEventMap<T>>(event: U, listener: (...args: HamokQueueEventMap<T>[U]) => void): this;
    off<U extends keyof HamokQueueEventMap<T>>(event: U, listener: (...args: HamokQueueEventMap<T>[U]) => void): this;
    once<U extends keyof HamokQueueEventMap<T>>(event: U, listener: (...args: HamokQueueEventMap<T>[U]) => void): this;
    emit<U extends keyof HamokQueueEventMap<T>>(event: U, ...args: HamokQueueEventMap<T>[U]): boolean;
}
export declare class HamokQueue<T> extends EventEmitter {
    readonly connection: HamokConnection<number, T>;
    readonly baseMap: BaseMap<number, T>;
    private _head;
    private _tail;
    private _closed;
    private _initializing?;
    constructor(connection: HamokConnection<number, T>, baseMap: BaseMap<number, T>);
    get id(): string;
    get empty(): boolean;
    get size(): number;
    get closed(): boolean;
    get ready(): Promise<this>;
    push(...values: T[]): Promise<void>;
    pop(): Promise<T | undefined>;
    peek(): T | undefined;
    clear(): Promise<void>;
    [Symbol.iterator](): IterableIterator<T>;
    close(): void;
    export(): HamokQueueSnapshot;
    import(snapshot: HamokQueueSnapshot, eventing?: boolean): void;
    private _import;
    private _pop;
    static uint8ArrayToStringCodec: import("../common/HamokCodec").HamokCodec<Uint8Array[], string[]>;
}
//# sourceMappingURL=HamokQueue.d.ts.map