interface VariantMultiMapBase<K,V,Tp>

undocumented

Companion namespace: VariantMultiMapBase

Extends: FastIterable<T>

Implemented by: MultiMapBase<K,V,Tp>, VariantMultiMapBase.NonEmpty<K,V,Tp>

Type parameters

Name	Constraints	Default	Description
K			undocumented
V			undocumented
Tp	VariantMultiMapBase.Types	VariantMultiMapBase.Types	undocumented

Properties

isEmpty

Returns true if the collection is empty.

Definition

readonly isEmpty: boolean;

example

HashMultiMapHashValue.empty<number>().isEmpty      // => true
HashMultiMapHashValue.of([1, 1], [2, 2]).isEmpty   // => false

keyMap

Returns the Map representation of this collection.

Definition

readonly keyMap: WithKeyValue<Tp, K, V>['keyMap'];

example

const m = HashMultiMapHashValue.of([1, 1], [2, 2])
const map: HashMap<number, HashSet.NonEmpty<number>> = m.keyMap

keySize

Returns the number of keys in the collection.

Definition

readonly keySize: number;

example

HashMultiMapHashValue.of([1, 1], [2, 2]).keySize      // => 2
HashMultiMapHashValue.of([1, 1], [1, 2]).keySize      // => 1

size

Returns the number of unique key-value combinations in this collection.

Definition

readonly size: number;

example

HashMultiMapHashValue.of([1, 1], [2, 2]).size       // => 2
HashMultiMapHashValue.of([1, 1], [1, 2]).size       // => 2

Methods

[Symbol.iterator]

Returns a FastIterator instance used to iterate over the values of this Iterable.

Definition

[Symbol.iterator](): FastIterator<T>;

Overrides

FastIterable.[Symbol.iterator]

assumeNonEmpty

Returns the collection as a .NonEmpty type

Definition

assumeNonEmpty(): WithKeyValue<Tp, K, V>['nonEmpty'];

throws

RimbuError.EmptyCollectionAssumedNonEmptyError if the collection is empty

example

HashMultiMapHashValue.empty<number, number>().assumeNonEmpty()   // => throws
const m: HashMultiMapHashValue<number, number> = HashMultiMapHashValue.of([1, 1], [2, 2])
const m2: HashMultiMapHashValue.NonEmpty<number, number> = m     // => compiler error
const m3: HashMultiMapHashValue.NonEmpty<number, number> = m.assumeNonEmpty()

note

returns reference to this collection

filter

Returns a collection containing only those entries that satisfy given pred predicate.

Definition

filter(pred: (entry: [K, V], index: number, halt: () => void) => boolean, options?: {
    negate?: boolean;
  }): WithKeyValue<Tp, K, V>['normal'];

Parameters

Name	Type	Description
pred	(entry: [K, V], index: number, halt: () => void) => boolean	a predicate function receiving: - entry: the next entry - index: the entry index - halt: a function that, when called, ensures no next entries are passed
options	{     negate?: boolean;   }	(optional) an object containing the following properties: - negate: (default: false) when true will negate the predicate

example

HashMultiMapHashValue.of([1, 'a'], [2, 'b'], [1, 'c'])
.filter(entry => entry[0] === 2 || entry[1] === 'c')
.toArray()
// => [[2, 'b'], [1, 'c']]

forEach

Performs given function f for each entry of the collection, using given state as initial traversal state.

Definition

forEach(f: (entry: [K, V], index: number, halt: () => void) => void, options?: {
    state?: TraverseState;
  }): void;

Parameters

Name	Type	Description
f	(entry: [K, V], index: number, halt: () => void) => void	the function to perform for each element, receiving: - entry: the next tuple of a key and value - index: the index of the element - halt: a function that, if called, ensures that no new elements are passed
options	{     state?: TraverseState;   }

example

HashMultiMapHashValue.of([1, 'a'], [2, 'b'], [1, 'c']).forEach((entry, i, halt) => {
console.log([entry[1], entry[0]]);
if (i >= 1) halt();
})
// => logs ['a', 1]  ['c', 1]  (or other order)

note

O(N)

getValues

Returns the value collection associated to the given key.

Definition

getValues<UK = K>(key: RelatedTo<K, UK>): WithKeyValue<Tp, K, V>['keyMapValues'];

Type parameters

Name	Default	Description
UK	K

Parameters

Name	Type	Description
key	RelatedTo<K, UK>	the key to look for

example

const m = HashMultiMapHashValue.of([1, 'a'], [2, 'b'])
m.getValues(1).toArray()    // => ['a']
m.getValues(10).toArray()   // => []

hasEntry

Returns true if the given key has the given value as one of its values in the collection.

Definition

hasEntry<UK = K>(key: RelatedTo<K, UK>, value: V): boolean;

Type parameters

Name	Default	Description
UK	K

Parameters

Name	Type	Description
key	RelatedTo<K, UK>	the key to look for
value	V	the value to look for

example

const m = HashMultiMapHashValue.of([1, 'a'], [2, 'b'])
m.hasEntry(1, 'a')    // => true
m.hasEntry(1, 'b')    // => false

hasKey

Returns true if the given key is present in the collection.

Definition

hasKey<UK = K>(key: RelatedTo<K, UK>): boolean;

Type parameters

Name	Default	Description
UK	K

Parameters

Name	Type	Description
key	RelatedTo<K, UK>	the key to look for

example

const m = HashMultiMapHashValue.of([1, 'a'], [2, 'b'])
m.hasKey(2)    // => true
m.hasKey(3)    // => false

nonEmpty

Returns true if there is at least one entry in the collection, and instructs the compiler to treat the collection as a .NonEmpty type.

Definition

nonEmpty(): this is WithKeyValue<Tp, K, V>['nonEmpty'];

example

const m: HashMultiMapHashValue<number, number> = HashMap.of([1, 1], [2, 2])
m.stream().first(0)     // compiler allows fallback value since the Stream may be empty
if (m.nonEmpty()) {
m.stream().first(0)   // compiler error: fallback value not allowed since Stream is not empty
}

removeEntries

Returns the collection where given entries are removed.

Definition

removeEntries<UK = K, UV = V>(entries: StreamSource<[RelatedTo<K, UK>, RelatedTo<V, UV>]>): WithKeyValue<Tp, K, V>['normal'];

Type parameters

Name	Default	Description
UK	K
UV	V

Parameters

Name	Type	Description
entries	StreamSource<[RelatedTo<K, UK>, RelatedTo<V, UV>]>	a StreamSource containing key-value entries to remove

example

const m = HashMultiMapHashValue.of([1, 'a'], [2, 'b'], [1, 'c'])
m.removeEntries([[2, 'b'], [1, 'd']]).toArray()   // => [[1, 'a'], [1, 'c']]
m.removeEntries([2, 'q']).toArray()               // => [[1, 'a'], [2, 'b'], [1, 'c']]
m.removeEntries(3) === m              // true

note

guarantees same object reference if the key is not present

removeEntry

Returns the collection where given value if removed from the values associated with given key.

Definition

removeEntry<UK = K, UV = V>(key: RelatedTo<K, UK>, value: RelatedTo<V, UV>): WithKeyValue<Tp, K, V>['normal'];

Type parameters

Name	Default	Description
UK	K
UV	V

Parameters

Name	Type	Description
key	RelatedTo<K, UK>	the key of the entry to remove
value	RelatedTo<V, UV>	the value of the entry to remove

example

const m = HashMultiMapHashValue.of([1, 'a'], [2, 'b'], [1, 'c'])
m.removeEntry(2, 'b').toArray()   // => [[1, 'a'], [1, 'c']]
m.removeEntry(2, 'q').toArray()   // => [[1, 'a'], [2, 'b'], [1, 'c']]
m.removeEntry(3, 'a') === m       // true

note

guarantees same object reference if the key is not present

removeKey

Returns the collection where the values associated with given key are removed.

Definition

removeKey<UK = K>(key: RelatedTo<K, UK>): WithKeyValue<Tp, K, V>['normal'];

Type parameters

Name	Default	Description
UK	K

Parameters

Name	Type	Description
key	RelatedTo<K, UK>	the key of the entries to remove

example

const m = HashMultiMapHashValue.of([1, 'a'], [2, 'b'], [1, 'c'])
m.removeKey(2).toArray()   // => [[1, 'a'], [1, 'c']]
m.removeKey(3) === m       // true

note

guarantees same object reference if the key is not present

removeKeyAndGet

Returns a tuple containing the collection of which the given key is removed, and the values that are associated with that key. If the key is not present, it will return undefined instead.

Definition

removeKeyAndGet<UK = K>(key: RelatedTo<K, UK>): [
    WithKeyValue<Tp, K, V>['normal'],
    WithKeyValue<Tp, K, V>['keyMapValuesNonEmpty']
  ] | undefined;

Type parameters

Name	Default	Description
UK	K

Parameters

Name	Type	Description
key	RelatedTo<K, UK>	the key of the entry to remove

example

const m = HashMultiMapHashValue.of([1, 'a'], [2, 'b'])
const result = m.removeKeyAndGet(2)
if (result !== undefined) console.log([result[0].toString(), result[1]])    // => logs [HashMultiMapHashValue(1 => 'a'), HashSet('b')]
console.log(m.removeKeyAndGet(3))                                           // => logs undefined

removeKeys

Returns the collection where the values associated with given keys are removed.

Definition

removeKeys<UK = K>(keys: StreamSource<RelatedTo<K, UK>>): WithKeyValue<Tp, K, V>['normal'];

Type parameters

Name	Default	Description
UK	K

Parameters

Name	Type	Description
keys	StreamSource<RelatedTo<K, UK>>	a StreamSource of keys to remove

example

const m = HashMultiMapHashValue.of([1, 'a'], [2, 'b'], [1, 'c'])
m.removeKeys([2, 10]).toArray()   // => [[1, 'a'], [1, 'c']]
m.removeKeys([10, 11]) === m      // true

note

guarantees same object reference if the key is not present

stream

Returns a Stream containing all entries of this collection as tuples of key and value.

Definition

stream(): Stream<[K, V]>;

example

HashMultiMapHashValue.of([1, 1], [2, 2]).stream().toArray()  // => [[1, 1], [2, 2]]

streamKeys

Returns a Stream containing all keys of this collection.

Definition

streamKeys(): Stream<K>;

example

HashMultiMapHashValue.of([[1, 'a'], [2, 'b']]).streamKeys().toArray()   // => [1, 2]

streamValues

Returns a Stream containing all values of this collection.

Definition

streamValues(): Stream<V>;

example

HashMultiMapHashValue.of([[1, 'a'], [2, 'b']]).streamValues().toArray()   // => ['a', 'b']

toArray

Returns an array containing all entries in this collection.

Definition

toArray(): [K, V][];

example

HashMultiMapHashValue.of([1, 'a'], [2, 'b'], [1, 'c']).toArray()   // => [[1, 'a'], [1, 'c'], [2, 'b']]

note

O(log(N)) @note it is safe to mutate the returned array, however, the array elements are not copied, thus should be treated as read-only

toJSON

Returns a JSON representation of this collection.

Definition

toJSON(): ToJSON<[K, V[]][]>;

example

HashMultiMapHashValue.of([1, 'a'], [2, 'b'], [1, 'c']).toJSON()
// => { dataType: 'HashMultiMapHashValue', value: [[1, ['a', 'c']], [2, ['b']]] }

toString

Returns a string representation of this collection.

Definition

toString(): string;

example

HashMultiMapHashValue.of([1, 'a'], [2, 'b'], [1, 'c']).toString()
// => HashMultiMapHashValue(1 => ['a', 'c'], 2 => ['b'])