Class ReadonlyRangeMap<V>

Readonly map with entries that contains a range key and a value

Author

David Hsing

Type Parameters

  • V

Implements

  • Omit<ReadonlyMap<RangeMapKey, V>,
        | "forEach"
        | "get"
        | "has"
        | "entries"
        | "keys"
        | "values">

Constructors

constructor

Accessors

[toStringTag] size

Methods

[iterator] entries forEach forEachBreakable forEachIndexing get getByDigit hasAllKeys hasAllValues hasAnyKeys hasAnyValues hasKey hasKeyValue hasValue isEmpty isNotEmpty keys toString values of

Constructors

constructor

  • new ReadonlyRangeMap<V>(entries?, validation?): ReadonlyRangeMap<V>

  • Construct a readonly range map instance

    Type Parameters

    • V

    Parameters

    • Optionalentries: [RangeMapKey | [number, number] | [number, number, boolean, boolean], V][]

      the map entries

    • validation: boolean = true

      whether to compare the ranges to all the ranges previously, to determine if there are any conflicts

    Returns ReadonlyRangeMap<V>

    Example

    const map = new ReadonlyRangeMap([
        [[1, 30], 'green'],
        [[30, 60], 'blue'],
        [[60, 90], 'orange'],
        [[90, 100, true, true], 'red']
    ]);

Accessors

[toStringTag]

  • get [toStringTag](): string

  • Returns the string representation of the map identifier ('ReadonlyRangeMap')

    Returns string

    the string representation of the map identifier

size

  • get size(): number

  • Returns the size of map

    Returns number

    the size of map

Methods

[iterator]

  • [iterator](): IterableIterator<[RangeMapKey, V], any, any>

  • Response for returning the list of key/value to iterate

    Returns IterableIterator<[RangeMapKey, V], any, any>

    Example

    for (const [key, value] of map) {
        console.log(value);
    }

entries

  • entries(): [RangeMapKey, V][]

  • Returns the key/value entries of the map

    Returns [RangeMapKey, V][]

    the key/value entries of the map

forEach

  • forEach(callback, thisArg?): void

  • Processes each entry in the map

    Parameters

    • callback: ((value: V, key: RangeMapKey) => void)

      a callback function that processes each entry

        • (value, key): void

        • Parameters

          Returns void

    • OptionalthisArg: any

      any instance to retrieve 'this' reference in the callback function

    Returns void

    Example

    map.forEach((value, key) => {
        console.log(value);
    });

forEachBreakable

  • forEachBreakable(callback, thisArg?): void

  • Processes each entry in the map with breakable capability

    Parameters

    • callback: ((value: V, key: RangeMapKey) => boolean)

      a callback function that processes each entry. Returning false indicates to break the map iteration

        • (value, key): boolean

        • Parameters

          Returns boolean

    • OptionalthisArg: any

      any instance to retrieve 'this' reference in the callback function

    Returns void

    Example

    map.forEachBreakable((value, key) => {
        return true;
    });

forEachIndexing

  • forEachIndexing(callback, thisArg?): void

  • Processes each entry in the map with index capability

    Parameters

    • callback: ((value: V, key: RangeMapKey, index: number) => void)

      a callback function that processes each entry

        • (value, key, index): void

        • Parameters

          Returns void

    • OptionalthisArg: any

      any instance to retrieve 'this' reference in the callback function

    Returns void

    Example

    map.forEachIndexing((value, key, index) => {
        console.log(index);
    });

get

  • get(key, defaults?): undefined | V

  • Returns the value of the given key

    Parameters

    • key: RangeMapKey | [number, number] | [number, number, boolean, boolean]

      the key to retrieve

    • Optionaldefaults: V

      the default value if not found

    Returns undefined | V

    the value of the given key

    Example

    const map = ReadonlyRangeMap.of([
        [[1, 50, true, true], 'white'],
        [[51, 100, false, true], 'black']
    ]);
    map.get([1, 50, true, true]);    // 'white'
    map.get([51, 100, false, true]);    // 'black'

getByDigit

  • getByDigit(digit, defaults?): undefined | V

  • Returns the value that associated to the number, by determining which bound contains the given number

    Parameters

    • digit: number

      the number to retrieve

    • Optionaldefaults: V

      the default value if not found

    Returns undefined | V

    the value that associated to the number, by determining which bound contains the given number

    Example

    const map = ReadonlyRangeMap.of([
        [[1, 50, true, true], 'white'],
        [[51, 100, false, true], 'black']
    ]);
    map.get(25);    // 'white'
    map.get(200);    // undefined

hasAllKeys

  • hasAllKeys(keys): boolean

  • Returns whether the map contains all the given keys

    Parameters

    • keys: (RangeMapKey | [number, number] | [number, number, boolean, boolean])[]

      the keys to check

    Returns boolean

    whether the map contains all the given keys

    Example

    map.hasAllKeys([[1, 50], [51, 100]]);

hasAllValues

  • hasAllValues(values): boolean

  • Returns whether the map contains all the given values, matching exactly

    Parameters

    • values: V[]

      the values to check

    Returns boolean

    whether the map contains all the given values, matching exactly

    Example

    map.hasAllValues(['red', 'green', 'blue']);

hasAnyKeys

  • hasAnyKeys(keys): boolean

  • Returns whether the map contains any of the given keys

    Parameters

    • keys: (RangeMapKey | [number, number] | [number, number, boolean, boolean])[]

      the keys to check

    Returns boolean

    whether the map contains any of the given keys

    Example

    const map = ReadonlyRangeMap.of([
        [[1, 50, true, true], 'white'],
        [[51, 100, false, true], 'black']
    ]);
    map.hasAnyKeys([[1, 50, true, true], [20, 60]]);    // true

hasAnyValues

  • hasAnyValues(values): boolean

  • Returns whether the map contains any of the given values

    Parameters

    • values: V[]

      the values to check

    Returns boolean

    whether the map contains any of the given values

    Example

    const map = ReadonlyRangeMap.of([
        [[1, 50, true, true], 'white'],
        [[51, 100, false, true], 'black']
    ]);
    map.hasAnyValues(['red', 'black']);    // true
    map.hasAnyValues(['top', 'right']);    // false

hasKey

  • hasKey(key): boolean

  • Returns whether the map contains the given key

    Parameters

    • key: RangeMapKey | [number, number] | [number, number, boolean, boolean]

      the key to check

    Returns boolean

    whether the map contains the given key

    Example

    map.hasKey([1, 30]);

hasKeyValue

  • hasKeyValue(key, value): boolean

  • Returns whether the map contains the given key/value pair

    Parameters

    • key: RangeMapKey | [number, number] | [number, number, boolean, boolean]

      the key to check

    • value: V

      the value to check

    Returns boolean

    whether the map contains the given key/value pair

    Example

    const map = ReadonlyRangeMap.of([
        [[1, 50], 'white']
    ]);
    map.hasKeyValue([1, 50], 'white');    // true
    map.hasKeyValue([1, 50], 'black');    // false

hasValue

  • hasValue(value): boolean

  • Returns whether any entries of the map that contains the given values

    Parameters

    • value: V

      the value to check

    Returns boolean

    whether any entries of the map that contains the given values

    Example

    const map = ReadonlyRangeMap.of([
        [[1, 50, true, true], 'white'],
        [[51, 100, false, true], 'black']
    ]);
    map.hasValue('white');    // true
    map.hasValue('blue');    // false

isEmpty

  • isEmpty(): boolean

  • Returns whether the map is empty

    Returns boolean

    whether the map is empty

isNotEmpty

  • isNotEmpty(): boolean

  • Returns whether the map is not empty

    Returns boolean

    whether the map is not empty

keys

toString

  • toString(): string

  • Returns the string representation of the map elements

    Returns string

    the string representation of the map elements

    Example

    const map = ReadonlyRangeMap.of([
        [[1, 50, true, true], 'white'],
        [[51, 100, false, true], 'black']
    ]);
    console.log(map.toString());    // '[start:1,end:50,startInclusive:true,endInclusive:true]:white;[start:51,end:100,startInclusive:false,endInclusive:true]:black'

values

  • values(): V[]

  • Returns the value array of the map

    Returns V[]

    the value array of the map

Staticof

  • of<V>(entries?, validation?): ReadonlyRangeMap<V>

  • Construct a readonly range map instance

    Type Parameters

    • V

    Parameters

    • Optionalentries: [RangeMapKey | [number, number] | [number, number, boolean, boolean], V][]

      the map entries

    • validation: boolean = true

      whether to compare the ranges to all the ranges previously, to determine if there are any conflicts

    Returns ReadonlyRangeMap<V>

    a readonly multi value map instance

    Example

    const map = ReadonlyRangeMap.of([
       [[1, 30], 'green'],
        [[30, 60], 'blue'],
        [[60, 90], 'orange'],
        [[90, 100, true, true], 'red']
    ]);

Settings

Member Visibility

On This Page

Constructors
Accessors
Methods