ixfx
    Preparing search index...

    Class MapOfSimpleMutable<V>

    A simple mutable map of arrays, without events. It can store multiple values under the same key.

    For a fancier approaches, consider ofArrayMutable, ofCircularMutable or ofSetMutable.

    Example

    const m = mapOfSimpleMutable();
    m.add(`hello`, 1, 2, 3); // Adds numbers under key `hello`
    m.delete(`hello`);       // Deletes everything under `hello`

    const hellos = m.get(`hello`); // Get list of items under `hello`

    Constructor takes a groupBy parameter, which yields a string key for a value. This is the basis by which values are keyed when using addValues.

    Constructor takes a valueEq parameter, which compares values. This is used when checking if a value exists under a key, for example.

    Type Parameters

    • V

      Type of items

    Hierarchy

    • MapOfSimpleBase<V>
      • MapOfSimpleMutable

    Implements

    Constructors

    constructor

    Properties

    groupBy map valueEq

    Accessors

    isEmpty lengthKeys

    Methods

    addKeyedValues addValue clear count debugString delete deleteByValue deleteKeyValue entries entriesFlat firstKeyByValue get has hasKeyValue keys keysAndCounts setValues values valuesFlat

    Constructors

    constructor

    • new MapOfSimpleMutable<V>(
          groupBy?: (value: V) => string,
          valueEq?: IsEqual<V>,
          initial?: [string, readonly V[]][],
      ): MapOfSimpleMutable<V>

      Constructor

      Type Parameters

      • V

      Parameters

      • groupBy: (value: V) => string = defaultKeyer

        Creates keys for values when using addValue. By default uses JSON.stringify

      • valueEq: IsEqual<V> = ...

        Compare values. By default uses JS logic for equality

      • initial: [string, readonly V[]][] = []

      Returns MapOfSimpleMutable<V>

    Properties

    Protected ReadonlygroupBy

    groupBy: (value: V) => string

    Protectedmap

    map: Map<string, readonly V[]>

    ProtectedvalueEq

    valueEq: IsEqual<V>

    Accessors

    isEmpty

    • get isEmpty(): boolean

      True if empty

      Returns boolean

    lengthKeys

    • get lengthKeys(): number

      Returns the count of keys.

      Returns number

    Methods

    addKeyedValues

    • addKeyedValues(key: string, ...values: readonly V[]): void

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

      Parameters

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

      Returns void

    addValue

    • addValue(...values: readonly V[]): void

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

      Parameters

      • ...values: readonly V[]

        Adds several values

      Returns void

    clear

    count

    • count(key: string): number

      Return number of values stored under key. Returns 0 if key is not found.

      Parameters

      • key: string

      Returns number

    debugString

    • debugString(): string

      Debug dump of contents

      Returns string

    delete

    • delete(key: string): boolean

      Deletes all values under key,

      Parameters

      • key: string

      Returns boolean

      True if key was found and values stored

    deleteByValue

    • deleteByValue(value: V): boolean

      Deletes value regardless of key.

      Uses the constructor-defined equality function.

      Parameters

      • value: V

        Value to delete

      Returns boolean

    deleteKeyValue

    • deleteKeyValue(key: string, value: V): boolean

      Delete value under a particular key

      Parameters

      • key: string
      • value: V

      Returns boolean

      True if value was found under key

    entries

    • entries(): IterableIterator<[key: string, value: V[]]>

      Iterate over keys and array of values for that key

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

    entriesFlat

    • entriesFlat(): IterableIterator<[key: string, value: V]>

      Iterate over all entries

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

    firstKeyByValue

    • firstKeyByValue(value: V, eq?: IsEqual<V>): undefined | string

      Returns first key that contains value

      Parameters

      Returns undefined | string

    get

    • get(key: string): IterableIterator<V>

      Get all values under key

      Parameters

      • key: string

      Returns IterableIterator<V>

    has

    • has(key: string): boolean

      Returns true if key exists

      Parameters

      • key: string

      Returns boolean

    hasKeyValue

    • hasKeyValue(key: string, value: V): boolean

      Returns true if value exists under key.

      Parameters

      • key: string

        Key

      • value: V

        Value to seek under key

      Returns boolean

      True if value exists under key.

    keys

    • keys(): IterableIterator<string>

      Iterate over all keys

      Returns IterableIterator<string>

    keysAndCounts

    • keysAndCounts(): IterableIterator<[string, number]>

      Iterate over keys and length of values stored under keys

      Returns IterableIterator<[string, number]>

    setValues

    • setValues(key: string, values: readonly V[]): void

      Set values to key. Previous data stored under key is thrown away.

      Parameters

      • key: string
      • values: readonly V[]

      Returns void

    values

    • values(): IterableIterator<readonly V[]>

      Yields the values for each key in sequence, returning an array. Use valuesFlat to iterate over all keys regardless of key.

      Returns IterableIterator<readonly V[]>

    valuesFlat

    • valuesFlat(): IterableIterator<V>

      Iterate over all values (regardless of key). Use values to iterate over a set of values per key

      Returns IterableIterator<V>

    Settings

    Member Visibility

    On This Page

    Constructors
    Properties
    Accessors
    Methods