interface BiMultiMapBase<K,V,Tp>

undocumented

Companion namespace: BiMultiMapBase

Extends: FastIterable<T>

Implemented by: BiMultiMap<K,V>, BiMultiMapEmpty<K,V,Tp>, HashBiMultiMap<K,V>, SortedBiMultiMap<K,V>, BiMultiMapBase.NonEmpty<K,V,Tp>

Type parameters

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

Properties

context

Returns the context associated to this collection instance.

Definition

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

isEmpty

Returns false since this collection is known to be non-empty.

Definition

readonly isEmpty: boolean;

example

HashBiMultiMap.of([1, 1], [2, 2]).isEmpty   // => false

keySize

Returns the number of keys

Definition

readonly keySize: number;

example

HashBiMultiMap.of([1, 10], [1, 20]).keySize       // => 1

keyValueMultiMap

Returns the MultiMap representation of the key to value mapping.

Definition

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

example

HashBiMultiMap.of([1, 10], [1, 20]).keyValueMap.toArray()
// => [[1, [10, 20]]

size

Returns the number of entries

Definition

readonly size: number;

example

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

valueKeyMultiMap

Returns the MultiMap representation of the value to key mapping.

Definition

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

example

HashBiMultiMap.of([10, 1], [20, 1]).valueKeyMap.toArray()
// => [[1, [10, 20]]

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]

add

Returns the collection with the given key associated to the given value.

Definition

add(key: K, value: V): WithKeyValue<Tp, K, V>['nonEmpty'];

Parameters

Name	Type	Description
key	K	the entry key to add
value	V	the entry value to add

example

HashBiMultiMap.of([1, 1], [2, 2]).add(1, 2).toArray()
// => [[1, 1], [1, 2], [2, 2]]

addEntries

Returns the collection with the entries from the given StreamSource entries added.

Definitions

addEntries(entries: StreamSource.NonEmpty<readonly [K, V]>): WithKeyValue<Tp, K, V>['nonEmpty'];

addEntries(entries: StreamSource<readonly [K, V]>): WithKeyValue<Tp, K, V>['normal'];

Parameters

Name	Type	Description
entries	StreamSource.NonEmpty<readonly [K, V]>	a StreamSource containing tuples with a key and value

example

HashBiMultiMap.of([1, 1]).addEntries([[2, 2], [1, 3]]).toArray()
// => [[1, 1], [1, 3], [2, 2]]

assumeNonEmpty

Returns the collection as a .NonEmpty type

Definition

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

throws

RimbuError.EmptyCollectionAssumedNonEmptyError if the collection is empty

example

HashBiMultiMap.empty<number, number>().assumeNonEmpty()   // => throws
const m: HashBiMultiMap<number, number> = HashBiMultiMap.of([1, 1], [2, 2])
const m2: HashBiMultiMap.NonEmpty<number, number> = m     // => compiler error
const m3: HashBiMultiMap.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 elements are passed
options	{     negate?: boolean;   }	(optional) an object containing the following properties: - negate: (default: false) when true will negate the given predicate

example

HashBiMultiMap.of([1, 'a'], [2, 'b'], [3, 'c']).filter(entry => entry[0] === 2 || entry[1] === 'c').toArray()
// => [[2, 'b'], [3, '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 entry, 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;   }	(optional) an object containing the following properties: - state: (optional) the traversal state

example

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

note

O(N)

getKeys

Returns a collection containing the keys associated with the given value.

Definition

getKeys<UV = V>(value: RelatedTo<V, UV>): WithKeyValue<Tp, K, V>['valueMultiMapValues'];

Type parameters

Name	Default	Description
UV	V

Parameters

Name	Type	Description
value	RelatedTo<V, UV>	the value of which to find the keys

example

const m = HashBiMultiMap.of([1, 1], [2, 1]);
m.getKeys(1).toArray()
// => [1, 2]
m.getKeys(5).toArray()
// => []

getValues

Returns a collection containing the values associated with the given key.

Definition

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

Type parameters

Name	Default	Description
UK	K

Parameters

Name	Type	Description
key	RelatedTo<K, UK>	the key of which to find the values

example

const m = HashBiMultiMap.of([1, 1], [1, 2]);
m.getValues(1).toArray()
// => [1, 2]
m.getValues(5).toArray()
// => []

hasEntry

Returns true if the given key and value entry is in the collection.

Definition

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

Type parameters

Name	Default	Description
UK	K
UV	V

Parameters

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

example

const m = HashBiMultiMap.of([1, 'a'], [2, 'b'])
m.hasEntry(2, 'b')    // => true
m.hasEntry(2, 'c')    // => 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 = HashBiMultiMap.of([1, 'a'], [2, 'b'])
m.hasKey(2)    // => true
m.hasKey(3)    // => false

hasValue

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

Definition

hasValue<UV = V>(key: RelatedTo<V, UV>): boolean;

Type parameters

Name	Default	Description
UV	V

Parameters

Name	Type	Description
key	RelatedTo<V, UV>

example

const m = HashBiMultiMap.of([1, 'a'], [2, 'b'])
m.hasKey('a')    // => true
m.hasKey('z')    // => 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: HashBiMultiMap<number, number> = HashBiMultiMap.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 the entries in the given entries StreamSource are removed if present.

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 entries to remove

example

const m = HashBiMultiMap.of([1, 1], [2, 2])
m.removeEntries([[2, 2], [2, 3]]).toArray()     // => [[1, 1]]
m.removeEntries([[1, 2], [4, 3]]).toArray()     // => [[1, 1], [2, 2]]
m.removeEntries([[3, 3]]) === m                 // => true

removeEntry

Returns the collection where the entry with given key or value is removed if present.

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 entry key
value	RelatedTo<V, UV>	the entry value

example

const m = HashBiMultiMap.of([1, 1], [2, 2])
m.removeEntry(2, 2).toArray()     // => [[1, 1]]
m.removeEntry(1, 2).toArray()     // => [[1, 1], [2, 2]]
m.removeEntry(3, 3) === m         // => true

removeKey

Returns the collection where the entries associated with given key are removed if it was part of the collection.

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 = HashBiMultiMap.of([1, 1], [1, 2])
m.removeKey(2).toArray()   // => [1, 2]
m.removeKey(3) === m       // true

note

guarantees same object reference if the key is not present

removeKeys

Returns the collection where the entries associated with each key in given keys are removed if they were present.

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 = HashBiMultiMap.of([1, 1], [2, 2])
m.removeKeys([1, 3]).toArray()     // => [[2, 2]]
m.removeKeys([1, 3, 2]).toArray()  // => []
m.removeKeys([3, 4, 5]) === m      // => true

note

guarantees same object reference if none of the keys are present

removeValue

Returns the collection where the entries associated with given value are removed if it was part of the collection.

Definition

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

Type parameters

Name	Default	Description
UV	V

Parameters

Name	Type	Description
value	RelatedTo<V, UV>	the value of the entries to remove

example

const m = HashBiMultiMap.of([1, 2], [2, 2])
m.removeValue(2).toArray()   // => [1, 2]
m.removeValue(3) === m       // true

note

guarantees same object reference if the key is not present

removeValues

Returns the collection where the entries associated with each value in given values are removed if they were present.

Definition

removeValues<UV = V>(values: StreamSource<RelatedTo<V, UV>>): WithKeyValue<Tp, K, V>['normal'];

Type parameters

Name	Default	Description
UV	V

Parameters

Name	Type	Description
values	StreamSource<RelatedTo<V, UV>>	a StreamSource of values to remove

example

const m = HashBiMultiMap.of([1, 1], [2, 2])
m.removeValues([1, 3]).toArray()     // => [[2, 2]]
m.removeValues([1, 3, 2]).toArray()  // => []
m.removeValues([3, 4, 5]) === m      // => true

note

guarantees same object reference if none of the keys are present

setKeys

Returns the collection with the keys from the given keys StreamSource associated with the given value.

Definitions

setKeys(value: V, keys: StreamSource.NonEmpty<K>): WithKeyValue<Tp, K, V>['nonEmpty'];

setKeys(value: V, keys: StreamSource<K>): WithKeyValue<Tp, K, V>['normal'];

Parameters

Name	Type	Description
value	V	the entry value
keys	StreamSource.NonEmpty<K>	a StreamSource containing keys to associate with the given value

example

HashBiMultiMap.of([1, 1]).setKeys(1, [2, 3]).toArray()
// => [[1, 1], [2, 1], [3, 1]]

setValues

Returns the collection with the values from the given values StreamSource associated with the given key.

Definitions

setValues(key: K, values: StreamSource.NonEmpty<V>): WithKeyValue<Tp, K, V>['nonEmpty'];

setValues(key: K, values: StreamSource<V>): WithKeyValue<Tp, K, V>['normal'];

Parameters

Name	Type	Description
key	K	the entry key
values	StreamSource.NonEmpty<V>	a StreamSource containing values to associate with the given key

example

HashBiMultiMap.of([1, 1]).setValues(1, [2, 3]).toArray()
// => [[1, 1], [1, 2], [1, 3]]

stream

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

Definition

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

example

HashBiMultiMap.of([1, 10], [1, 20]).stream().toArray()  // => [[1, 10], [1, 20]]

streamKeys

Returns a Stream containing all keys of this collection.

Definition

streamKeys(): Stream<K>;

example

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

streamValues

Returns a Stream containing all values of this collection.

Definition

streamValues(): Stream<V>;

example

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

toArray

Returns an array containing all entries in this collection.

Definition

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

example

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

note

O(log(N))

toBuilder

Returns a builder object containing the entries of this collection.

Definition

toBuilder(): WithKeyValue<Tp, K, V>['builder'];

example

const builder: HashBiMultiMap.Builder<number, string> = HashBiMultiMap.of([1, 'a'], [2, 'b']).toBuilder()

toJSON

Returns a JSON representation of this collection.

Definition

toJSON(): ToJSON<[K, V[]][], this['context']['typeTag']>;

example

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

toString

Returns a string representation of this collection.

Definition

toString(): string;

example

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