Skip to main content

interface TableBase<R,C,V,Tp>

undocumented

Companion namespace: TableBase

Extends: VariantTableBase<R,C,V,Tp>

Implemented by: TableEmpty<R,C,V,Tp>, Table<R,C,V>, HashTableSortedColumn<R,C,V>, SortedTableHashColumn<R,C,V>, TableBase.NonEmpty<R,C,V,Tp>, SortedTableSortedColumn<R,C,V>, HashTableHashColumn<R,C,V>

Type parameters

NameConstraintsDefaultDescription
Rundocumented
Cundocumented
Vundocumented
TpTableBase.Types TableBase.Typesundocumented

Properties

amountRows

Returns the amount of rows in the collection.

Definition

readonly amountRows: number;

example
HashTableHashColumn.empty<number, number, number>().rowSize   // => 0
HashTableHashColumn.of([1, 2, 3], [1, 4, 5]).rowSize // => 1

Overrides

VariantTableBase.amountRows

context

Returns the context associated to this collection instance.

Definition

readonly context: WithRow<Tp, R, C, V>['context'];

isEmpty

Returns true if the collection is empty.

Definition

readonly isEmpty: boolean;

example
HashTableHashColumn.empty<number, number, number>().isEmpty   // => true
HashTableHashColumn.of([1, 2, 3], [1, 4, 5]).isEmpty // => false

Overrides

VariantTableBase.isEmpty

rowMap

Returns the Map representation of this collection.

Definition

readonly rowMap: WithRow<Tp, R, C, V>['rowMap'];

example
const m = HashTableHashColumn.of([1, 2, 3], [1, 4, 5])
const map: HashMap<number, HashMap.NonEmpty<number, number>> = m.rowMap

Overrides

VariantTableBase.rowMap

size

Returns the amount of entries in the collection.

Definition

readonly size: number;

example
HashTableHashColumn.empty<number, number, number>().size   // => 0
HashTableHashColumn.of([1, 2, 3], [1, 4, 5]).size // => 2

Overrides

VariantTableBase.size

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]

addEntries

Returns the collection with the given entries added.

Definitions

addEntries(entries: StreamSource.NonEmpty<readonly [R, C, V]>): WithRow<Tp, R, C, V>['nonEmpty'];

addEntries(entries: StreamSource<readonly [R, C, V]>): WithRow<Tp, R, C, V>['normal'];

Parameters

NameTypeDescription
entriesStreamSource.NonEmpty<readonly [R, C, V]>a `StreamSource containing entries to add
example
const t = HashTableHashColumn.of([1, 2, 3])
t.addEntries([[1, 4, 5], [2, 6, 8]]).toArray()
// => [[1, 2, 3], [1, 4, 5], [2, 6, 8]]

addEntry

Returns the collection with the given entry added.

Definition

addEntry(entry: readonly [R, C, V]): WithRow<Tp, R, C, V>['nonEmpty'];

Parameters

NameTypeDescription
entryreadonly [R, C, V]the entry to add
example
const t = HashTableHashColumn.of([1, 2, 3], [1, 4, 5])
t.addEntry([2, 6, 8]).toArray() // => [[1, 2, 3], [1, 4, 5], [2, 6, 8]]

assumeNonEmpty

Returns the collection as a .NonEmpty type

Definition

assumeNonEmpty(): WithRow<Tp, R, C, V>['nonEmpty'];

throws

RimbuError.EmptyCollectionAssumedNonEmptyError if the collection is empty

example
HashTableHashColumn.empty<number, number, number>().assumeNonEmpty()   // => throws
const m: Table<number, number, number> = HashTableHashColumn.of([1, 2, 3], [1, 4, 5])
const m2: Table.NonEmpty<number, number> = m // => compiler error
const m3: Table.NonEmpty<number, number> = m.assumeNonEmpty()
note

returns reference to this collection

Overrides

VariantTableBase.assumeNonEmpty

filter

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

Definition

filter(pred: (entry: [R, C, V], index: number, halt: () => void) => boolean): WithRow<Tp, R, C, V>['normal'];

Parameters

NameTypeDescription
pred(entry: [R, C, V], index: number, halt: () => void) => booleana predicate function receiving:
- entry: the next entry
- index: the entry index
- halt: a function that, when called, ensures no next elements are passed
example
HashTableHashColumn.of([1, 2, 3], [1, 4, 5], [2, 3, 5])
.filter(entry => entry[2] === 5).toArray()
// => [[1, 4, 5], [2, 3, 5]]

Overrides

VariantTableBase.filter

filterRows

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

Definition

filterRows(pred: (entry: readonly [R, WithRow<Tp, R, C, V>['rowNonEmpty']], index: number, halt: () => void) => boolean): WithRow<Tp, R, C, V>['normal'];

Parameters

NameTypeDescription
pred(entry: readonly [R, WithRow<Tp, R, C, V>['rowNonEmpty']], index: number, halt: () => void) => booleana predicate function receiving:
- entry: the next entry of the row key and a collection representing its columns and values
- index: the entry index - halt: a function that, when called, ensures no next elements are passed
example
HashTableHashColumn.of([1, 2, 3], [1, 4, 5], [2, 3, 5])
.filterRows((rowKey, values) => rowKey === 1 && values.hasKey(4)).toArray()
// => [[1, 2, 3], [1, 4, 5]]

Overrides

VariantTableBase.filterRows

forEach

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

Definition

forEach(f: (entry: [R, C, V], index: number, halt: () => void) => void, state?: TraverseState): void;

Parameters

NameTypeDescription
f(entry: [R, C, V], index: number, halt: () => void) => voidthe function to perform for each entry, receiving:
- entry: the next tuple of a row key, column key, and value
- index: the index of the element
- halt: a function that, if called, ensures that no new elements are passed
stateTraverseState(optional) the traverse state
example
HashTableHashColumn.of([1, 2, 3], [1, 4, 5], [2, 3, 5])
.forEach((entry, i, halt) => {
console.log([entry]);
if (i >= 1) halt();
})
// => logs [1, 2, 3] [1, 4, 5]
note

O(N)

Overrides

VariantTableBase.forEach

get

Returns the value at given row and column keys, or the otherwise value if no value is present.

Definitions

get<UR = R, UC = C>(row: RelatedTo<R, UR>, column: RelatedTo<C, UC>): V | undefined;

get<UR, UC, O>(row: RelatedTo<R, UR>, column: RelatedTo<C, UC>, otherwise: OptLazy<O>): V | O;

Type parameters

NameDefaultDescription
URR
UCC

Parameters

NameTypeDescription
rowRelatedTo<R, UR>the row key
columnRelatedTo<C, UC>the column key
example
const t = HashTableHashColumn.of([1, 2, 3], [1, 4, 5])
t.get(10, 1) // => undefined
t.get(10, 1, 0) // => 0
t.get(1, 2) // => 3
t.get(1, 2, 0) // => 3

Overrides

VariantTableBase.get

getRow

Returns a map containing the column keys and values in the given row.

Definition

getRow<UR = R>(row: RelatedTo<R, UR>): WithRow<Tp, R, C, V>['row'];

Type parameters

NameDefaultDescription
URR

Parameters

NameTypeDescription
rowRelatedTo<R, UR>the row key
example
const t = HashTableHashColumn.of([1, 2, 3], [1, 4, 5])
t.getRow(10).toArray() // => []
t.getRow(1).toArray() // => [[2, 3], [4, 5]]

Overrides

VariantTableBase.getRow

hasRowKey

Returns true if given row key is in the collection.

Definition

hasRowKey<UR = R>(row: RelatedTo<R, UR>): boolean;

Type parameters

NameDefaultDescription
URR

Parameters

NameTypeDescription
rowRelatedTo<R, UR>the row key to look for
example
const t = HashTableHashColumn.of([1, 2, 3], [1, 4, 5])
t.hasRowKey(10) // => false
t.hasRowKey(1) // => true

Overrides

VariantTableBase.hasRowKey

hasValueAt

Returns true if the collection has a value for given row and column keys.

Definition

hasValueAt<UR = R, UC = C>(row: RelatedTo<R, UR>, column: RelatedTo<C, UC>): boolean;

Type parameters

NameDefaultDescription
URR
UCC

Parameters

NameTypeDescription
rowRelatedTo<R, UR>the row key
columnRelatedTo<C, UC>the column key
example
const t = HashTableHashColumn.of([1, 2, 3], [1, 4, 5])
t.hasValueAt(10, 1) // => false
t.hasValueAt(1, 4) // => true

Overrides

VariantTableBase.hasValueAt

mapValues

Returns a collection with the same row and column keys, but where the given mapFun function is applied to each entry value.

Definition

mapValues<V2>(mapFun: (value: V, row: R, column: C) => V2): (Tp & Row<R, C, V2>)['normal'];

Type parameters

NameDescription
V2

Parameters

NameTypeDescription
mapFun(value: V, row: R, column: C) => V2a function taking a value and a row and column key, and returning a new value
example
HashTableHashColumn.of([1, 2, 3], [1, 4, 5], [2, 3, 5])
.mapValues(value => value * 2)
// => [[1, 2, 6], [1, 4, 10], [2, 3, 10]]

Overrides

VariantTableBase.mapValues

modifyAt

Returns the collection with the value at given row and column keys modified according to given options.

Definition

modifyAt(row: R, column: C, options: {
    ifNew?: OptLazyOr<V, Token>;
    ifExists?: (value: V, remove: Token) => V | Token;
  }): WithRow<Tp, R, C, V>['normal'];

Parameters

NameTypeDescription
rowRthe row key
columnCthe column key
options{
    ifNew?: OptLazyOr<V, Token>;
    ifExists?: (value: V, remove: Token) => V | Token;
  }
an object containing the following information:
- ifNew: (optional) if the given row-column combination has no value in the collection, this value or function will be used to generate new values. If a function returning the token argument is given, no new entry is created.
- ifExists: (optional) if the row-column combination has a value, this function is called with the current value to return a new value. As a second argument, a remove token is given. If the function returns this token, the current entry is removed.
example
const t = HashTableHashColumn.of([1, 2, 3], [1, 4, 5])
t.modifyAt(2, 5, { ifNew: 8 }).toArray()
// => [[1, 2, 3], [1, 4, 5], [2, 5, 8]]
t.modifyAt(2, 5, { ifNew: (none) => 1 < 2 ? none : 8 }).toArray()
// => [[1, 2, 3], [1, 4, 5]]
t.modifyAt(1, 2, { ifExists: (v) => v * 2 }).toArray()
// => [[1, 2, 6], [1, 4, 5]]
t.modifyAt(1, 2, { ifExists: (v, remove) => remove }).toArray()
// => [[1, 4, 5]]

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 WithRow<Tp, R, C, V>['nonEmpty'];

example
const m: Table<number, number> = HashTableHashColumn.of([1, 2, 3], [1, 4, 5])
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
}

Overrides

VariantTableBase.nonEmpty

remove

Returns the collection where the value at given row and column keys is removed.

Definition

remove<UR = R, UC = C>(row: RelatedTo<R, UR>, column: RelatedTo<C, UC>): WithRow<Tp, R, C, V>['normal'];

Type parameters

NameDefaultDescription
URR
UCC

Parameters

NameTypeDescription
rowRelatedTo<R, UR>the row key
columnRelatedTo<C, UC>the column key
example
const t = HashTableHashColumn.of([1, 2, 3], [1, 4, 5])
t.remove(10, 11).toArray() // => [[1, 2, 3], [1, 4, 5]]
t.remove(1, 4).toArray() // => [[1, 2, 3]]

Overrides

VariantTableBase.remove

removeAndGet

Returns a tuple containing the collection with the value at given row and column removed, and the removed value. If no such value is found, it returns undefined.

Definition

removeAndGet<UR = R, UC = C>(row: RelatedTo<R, UR>, column: RelatedTo<C, UC>): [WithRow<Tp, R, C, V>['normal'], V] | undefined;

Type parameters

NameDefaultDescription
URR
UCC

Parameters

NameTypeDescription
rowRelatedTo<R, UR>the row key
columnRelatedTo<C, UC>the column key
example
const t = HashTableHashColumn.of([1, 2, 3], [1, 4, 5])
t.removeAndGet(10, 11) // => undefined
t.removeAndGet(1, 2) // => [HashTableHashColumn([1, 4, 5]), 3]

Overrides

VariantTableBase.removeAndGet

removeEntries

Returns the collection where the given entries are removed.

Definition

removeEntries<UR = R, UC = C>(entries: StreamSource<[RelatedTo<R, UR>, RelatedTo<C, UC>]>): WithRow<Tp, R, C, V>['normal'];

Type parameters

NameDefaultDescription
URR
UCC

Parameters

NameTypeDescription
entriesStreamSource<[RelatedTo<R, UR>, RelatedTo<C, UC>]>a StreamSource of table entries
example
const t = HashTableHashColumn.of([1, 2, 3], [1, 4, 5])
t.removeEntries([[6, 7, 8], [7, 8, 9]]).toArray() // => [[1, 2, 3], [1, 4, 5]]
t.removeEntries([[6, 7, 8], [1, 2, 3]]).toArray() // => [[1, 4, 5]]

Overrides

VariantTableBase.removeEntries

removeRow

Returns the collection where all values in given row are removed.

Definition

removeRow<UR = R>(row: RelatedTo<R, UR>): WithRow<Tp, R, C, V>['normal'];

Type parameters

NameDefaultDescription
URR

Parameters

NameTypeDescription
rowRelatedTo<R, UR>the row key
example
const t = HashTableHashColumn.of([1, 2, 3], [1, 4, 5], [2, 2, 3])
t.removeRow(10).toArray() // => [[1, 2, 3], [1, 4, 5], [2, 2, 3]]
t.removeRow(1).toArray() // => [[2, 2, 3]]

Overrides

VariantTableBase.removeRow

removeRowAndGet

Returns a tuple containing the collection with the values at given row removed, and a map containing the removed columns and values. If no such row is found, it returns undefined.

Definition

removeRowAndGet<UR = R>(row: RelatedTo<R, UR>): [WithRow<Tp, R, C, V>['normal'], WithRow<Tp, R, C, V>['rowNonEmpty']] | undefined;

Type parameters

NameDefaultDescription
URR

Parameters

NameTypeDescription
rowRelatedTo<R, UR>the row key
example
const t = HashTableHashColumn.of([1, 2, 3], [1, 4, 5])
t.removeRowAndGet(10) // => undefined
t.removeRowAndGet(1) // => [HashTableHashColumn(), HashMap(2 => 3, 4 => 5)]

Overrides

VariantTableBase.removeRowAndGet

removeRows

Returns the collection where the values for each row key in given rows are removed.

Definition

removeRows<UR = R>(rows: StreamSource<RelatedTo<R, UR>>): WithRow<Tp, R, C, V>['normal'];

Type parameters

NameDefaultDescription
URR

Parameters

NameTypeDescription
rowsStreamSource<RelatedTo<R, UR>>a StreamSource of row keys
example
const t = HashTableHashColumn.of([1, 2, 3], [1, 4, 5])
t.removeRows([10, 11]).toArray() // => [[1, 2, 3], [1, 4, 5]]
t.removeRows([1, 10]).toArray() // => []

Overrides

VariantTableBase.removeRows

set

Returns the collection where the given value is associated with the given row and column keys.

Definition

set(row: R, column: C, value: V): WithRow<Tp, R, C, V>['nonEmpty'];

Parameters

NameTypeDescription
rowRthe row key
columnCthe column key
valueVthe value to add
example
const t = HashTableHashColumn.of([1, 2, 3], [1, 4, 5])
t.set(1, 2, 10).toArray() // => [[1, 2, 10], [1, 4, 5]]
t.set(2, 6, 8).toArray() // => [[1, 2, 3], [1, 4, 5], [2, 6, 8]]

stream

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

Definition

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

example
HashTableHashColumn.of([1, 2, 3], [1, 4, 5]).stream().toArray()
// => [[1, 2, 3], [1, 4, 5]]

Overrides

VariantTableBase.stream

streamRows

Returns a Stream containing all row keys of this collection.

Definition

streamRows(): Stream<R>;

example
HashTableHashColumn.of([1, 2, 3], [1, 4, 5]).streamRows().toArray()
// => [1]

Overrides

VariantTableBase.streamRows

streamValues

Returns a Stream containing all values of this collection.

Definition

streamValues(): Stream<V>;

example
HashTableHashColumn.of([1, 2, 3], [1, 4, 5]).streamValues().toArray()
// => [3, 5]

Overrides

VariantTableBase.streamValues

toArray

Returns an array containing all entries in this collection.

Definition

toArray(): [R, C, V][];

example
HashTableHashColumn.of([1, 2, 3], [1, 4, 5]).toArray()
// => [[1, 2, 3], [1, 4, 5]]
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

Overrides

VariantTableBase.toArray

toBuilder

Returns a builder object containing the entries of this collection.

Definition

toBuilder(): WithRow<Tp, R, C, V>['builder'];

example
const builder: HashTableHashColumn.Builder<number, number, number>
= HashTableHashColumn.of([1, 2, 3], [1, 4, 5]).toBuilder()

toJSON

Returns a JSON representation of this collection.

Definition

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

example
HashTableHashColumn.of([1, 2, 3], [1, 4, 5]).toJSON()
// => { dataType: 'HashTableHashColumn', value: [1, [ [2, 3], [4, 5] ] ] }

Overrides

VariantTableBase.toJSON

toString

Returns a string representation of this collection.

Definition

toString(): string;

example
HashTableHashColumn.of([1, 2, 3], [1, 4, 5]).toString()
// => HashTableHashColumn([1, 2] -> 3, [1, 4] -> 5)

Overrides

VariantTableBase.toString

updateAt

Returns the collection with the value at given row and column keys updated according to the given update function.

Definition

updateAt<UR = R, UC = C>(row: RelatedTo<R, UR>, column: RelatedTo<C, UC>, update: Update<V>): WithRow<Tp, R, C, V>['normal'];

Type parameters

NameDefaultDescription
URR
UCC

Parameters

NameTypeDescription
rowRelatedTo<R, UR>the row key
columnRelatedTo<C, UC>the column key
updateUpdate<V>a function taking the current value and returning a new value
example
const t = HashTableHashColumn.of([1, 2, 3], [1, 4, 5])
t.updateAt(1, 2, v => v * 2).toArray()
// => [[1, 2, 6], [1, 4, 5]]
t.updateAt(3, 4, v => v * 2)
// => [[1, 2, 3], [1, 4, 5]]