ixfx
    Preparing search index...

    Interface IMapOfImmutable<V>

    Like a Map but multiple values can be stored for each key. Immutable. Duplicate values can be added to the same or even a several keys.

    Adding

    // Add one or more values using the predefined key function to generate a key
    map = map.addValue(value1, value2, ...);
    // Add one or more values under a specified key
    map = map.addKeyedValues(key, value1, value2, ...);

    Finding/accessing

    // Returns all values stored under key
    map.get(key);
    // Returns the first key where value is found, or _undefined_ if not found
    map.findKeyForValue(value);
    // Returns _true_ if value is stored under key
    map.hasKeyValue(key, value);
    // Returns _true_ if map contains key
    map.has(key);

    Removing

    // Removes everything
    map = map.clear();
    // Delete values under key. Returns _true_ if key was found.
    map = map.delete(key);
    // Deletes specified value under key. Returns _true_ if found.
    map = map.deleteKeyValue(key, value);

    Metadata about the map:

    map.isEmpty;         // True/false
    map.lengthMax; // Largest count of items under any key
    map.count(key); // Count of items stored under key, or 0 if key is not present.
    map.keys(); // Returns a string array of keys
    map.keysAndCounts(); // Returns an array of [string,number] for all keys and number of values for each key
    map.debugString(); // Returns a human-readable string dump of the contents

    Type of data structure managing values

    interface IMapOfImmutable<V> {
        get isEmpty(): boolean;
        addKeyedValues(key: string, ...values: readonly V[]): IMapOfImmutable<V>;
        addValue(...values: readonly V[]): IMapOfImmutable<V>;
        clear(): IMapOfImmutable<V>;
        count(key: string): number;
        delete(key: string): IMapOfImmutable<V>;
        deleteByValue(value: V): IMapOfImmutable<V>;
        deleteKeyValue(key: string, value: V): IMapOfImmutable<V>;
        entries(): IterableIterator<[key: string, value: V[]]>;
        entriesFlat(): IterableIterator<readonly [string, V]>;
        firstKeyByValue(value: V, eq?: IsEqual<V>): undefined | string;
        get(key: string): IterableIterator<V>;
        has(key: string): boolean;
        hasKeyValue(key: string, value: V, eq?: IsEqual<V>): boolean;
        keys(): IterableIterator<string>;
        keysAndCounts(): IterableIterator<readonly [string, number]>;
        valuesFlat(): IterableIterator<V>;
    }

    Type Parameters

    • V

      Values stored under keys

    Hierarchy (View Summary)

    Implemented by

    Accessors

    • get isEmpty(): boolean

      Returns true if the map is empty

      Returns boolean

    Methods

    • Adds several values under the same key. Duplicate values are permitted, depending on implementation.

      Parameters

      • key: string
      • ...values: readonly V[]

      Returns IMapOfImmutable<V>

    • Adds a value, automatically extracting a key via the groupBy function assigned in the constructor options.

      Parameters

      • ...values: readonly V[]

        Adds several values

      Returns IMapOfImmutable<V>

    • Returns the number of values stored under key, or 0 if key is not present.

      Parameters

      • key: string

        Key

      Returns number

    • Returns IterableIterator<[key: string, value: V[]]>

    • Iterates over key-value pairs. Unlike a normal map, the same key may appear several times.

      Returns IterableIterator<readonly [string, V]>

    • Finds the first key where value is stored. Note: value could be stored in multiple keys

      Parameters

      Returns undefined | string

      Key, or undefined if value not found

    • Iterates over all values stored under key

      Parameters

      • key: string

      Returns IterableIterator<V>

    • Returns true if key has any values

      Parameters

      • key: string

      Returns boolean

    • Returns true if value is stored under key.

      Parameters

      • key: string

        Key

      • value: V

        Value

      • Optionaleq: IsEqual<V>

      Returns boolean

    • Iterates over all keys

      Returns IterableIterator<string>

    • Iteates over all keys and the count of values therein

      Returns IterableIterator<readonly [string, number]>

    • Iterates over all values, regardless of key. Same value may re-appear if it's stored under different keys.

      Returns IterableIterator<V>