ixfx
    Preparing search index...

    Interface IPriorityQueueMutable<V>

    Queue (mutable). See also IQueueImmutable for the immutable version.

    Queues are useful if you want to treat 'older' or 'newer' items differently. Enqueing adds items at the back of the queue, while dequeing removes items from the front (ie. the oldest).

    const q = queue();       // Create
    q.enqueue(`a`, `b`); // Add two strings
    const front = q.dequeue(); // `a` is at the front of queue (oldest)
    const q = queue({capacity: 5, discardPolicy: `newer`});
    
    interface IPriorityQueueMutable<V> {
        dequeue: () => undefined | Readonly<{ item: V; priority: number }>;
        enqueue: (
            ...toAdd: readonly Readonly<{ item: V; priority: number }>[],
        ) => number;
        get isEmpty(): boolean;
        get isFull(): boolean;
        get length(): number;
        get peek(): undefined | V;
        at(index: number): V;
        clear(): void;
        dequeueMax(): undefined | V;
        dequeueMin(): undefined | V;
        peekMax(): undefined | V;
        peekMin(): undefined | V;
        removeWhere(predicate: (item: V) => boolean): number;
        toArray(): readonly Readonly<{ item: V; priority: number }>[];
    }

    Type Parameters

    • V

    Hierarchy (View Summary)

    Implemented by

    Index

    Accessors

    Methods

    • Removes values that match predicate.

      // Eg queue of strings, compare by value
      queue.removeWhere(v => v === `someValue`);

      // Eg queue of objects, compare by reference
      queue.removeWhere(v => v === someTarget);

      // Eg use ixfx function to compare value of objects, regardless of key ordering
      queue.removeWhere(v => isEqualValueIgnoreOrder(v, someTarget));

      Parameters

      • predicate: (item: V) => boolean

      Returns number

      Returns number of items removed.

    Properties

    dequeue: () => undefined | Readonly<{ item: V; priority: number }>

    Dequeues (removes oldest item / item at front of queue)

    Use peek to look at the item at front of queue without removing it.

    Type declaration

      • (): undefined | Readonly<{ item: V; priority: number }>
      • Returns undefined | Readonly<{ item: V; priority: number }>

        Item, or undefined if queue is empty

    enqueue: (
        ...toAdd: readonly Readonly<{ item: V; priority: number }>[],
    ) => number

    Enqueues (adds items to back of queue). If a capacity is set, not all items might be added.

    Type declaration

      • (...toAdd: readonly Readonly<{ item: V; priority: number }>[]): number
      • Parameters

        • ...toAdd: readonly Readonly<{ item: V; priority: number }>[]

        Returns number

        How many items were added