Class RangeMap<V>

Map with entries that contains a range key and a value

Author

David Hsing

Type Parameters

Implements

Omit<
    Map<RangeMapKey, V>,

        | "delete"
        | "forEach"
        | "get"
        | "has"
        | "set"
        | "entries"
        | "keys"
        | "values"
        | "push",
>

Index

Constructors

constructor

new RangeMap<V>(
    entries?: [
        RangeMapKey
        | [number, number]
        | [number, number, boolean, boolean],
        V,
    ][],
    validation?: boolean,
): RangeMap<V>
Construct a 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 RangeMap<V>
Example
```
const map = new RangeMap([
    [[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 ('RangeMap')

Returns string
the string representation of the map identifier

Implementation of Omit.[toStringTag]

size

get size(): number
Returns the size of map

Returns number
the size of map

Implementation of Omit.size

Methods

[iterator]

"[iterator]"(): IterableIterator<[RangeMapKey, V]>
Response for returning the list of key/value to iterate

Returns IterableIterator<[RangeMapKey, V]>
Example
```
for (const [key, value] of map) {
    console.log(value);
}
```
Implementation of Omit.[iterator]

clear

clear(): void
Clears the map

Returns void
Implementation of Omit.clear

deleteByKey

deleteByKey(
key: RangeMapKey | [number, number] | [number, number, boolean, boolean],
): boolean
Deletes the entry with the given key
Parameters
- key: RangeMapKey | [number, number] | [number, number, boolean, boolean]
  the key to delete
Returns boolean
whether the entry has been deleted
Example
```
map.deleteByKey([1, 50]);
```

deleteByKeys

deleteByKeys(
    keys: (
        RangeMapKey
        | [number, number]
        | [number, number, boolean, boolean]
    )[],
): boolean
Deletes all the entries with the given keys
Parameters
- keys: (RangeMapKey | [number, number] | [number, number, boolean, boolean])[]
  the keys to delete
Returns boolean
whether any of the entries has been deleted
Example
```
map.deleteByKeys([[1, 30], [30, 50]]);
```

deleteByValue

deleteByValue(value: V): boolean
Deletes the entry/entries with the given value
Parameters
- value: V
  the value to delete
Returns boolean
whether the entry/entries has been deleted
Example
```
map.deleteByValue('red');
```

deleteByValues

deleteByValues(values: V[]): boolean
Deletes all the entries with the given values
Parameters
- values: V[]
  the values to delete
Returns boolean
whether any of the entries has been deleted
Example
```
map.deleteByValues(['green', 'blue']);
```

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: (value?: V, key?: RangeMapKey) => void, thisArg?: any): void
Processes each entry in the map
Parameters
- callback: (value?: V, key?: RangeMapKey) => void
  a callback function that processes each entry
- 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: (value?: V, key?: RangeMapKey) => boolean,
thisArg?: any,
): 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
- OptionalthisArg: any
  any instance to retrieve 'this' reference in the callback function
Returns void
Example
```
map.forEachBreakable((value, key) => {
    return true;
});
```

forEachIndexing

forEachIndexing(
callback: (value?: V, key?: RangeMapKey, index?: number) => void,
thisArg?: any,
): 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
- 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: RangeMapKey | [number, number] | [number, number, boolean, boolean],
defaults?: V,
): 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 = RangeMap.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: number, defaults?: V): 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 = RangeMap.of([
    [[1, 50, true, true], 'white'],
    [[51, 100, false, true], 'black']
]);
map.getByDigit(25);    // 'white'
map.getByDigit(50);    // 'white'
map.getByDigit(51);    // undefined
map.getByDigit(52);    // 'black'
map.getByDigit(200);    // undefined
```

hasAllKeys

hasAllKeys(
    keys: (
        RangeMapKey
        | [number, number]
        | [number, number, boolean, boolean]
    )[],
): 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: V[]): 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: (
        RangeMapKey
        | [number, number]
        | [number, number, boolean, boolean]
    )[],
): 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 = RangeMap.of([
    [[1, 50, true, true], 'white'],
    [[51, 100, false, true], 'black']
]);
map.hasAnyKeys([[1, 50, true, true], [20, 60]]);    // true
```

hasAnyValues

hasAnyValues(values: V[]): 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 = RangeMap.of([
    [[1, 50, true, true], 'white'],
    [[51, 100, false, true], 'black']
]);
map.hasAnyValues(['red', 'black']);    // true
map.hasAnyValues(['top', 'right']);    // false

hasKey

hasKey(
key: RangeMapKey | [number, number] | [number, number, boolean, boolean],
): 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: RangeMapKey | [number, number] | [number, number, boolean, boolean],
value: V,
): 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 = RangeMap.of([
    [[1, 50], 'white']
]);
map.hasKeyValue([1, 50], 'white');    // true
map.hasKeyValue([1, 50], 'black');    // false
```

hasValue

hasValue(value: V): 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 = RangeMap.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

keys(): RangeMapKey[]
Returns the keys of the map

Returns RangeMapKey[]
the keys of the map

set

set(
    key: RangeMapKey | [number, number] | [number, number, boolean, boolean],
    value: V,
    validation?: boolean,
): void
Sets the value of the given key
Parameters
- key: RangeMapKey | [number, number] | [number, number, boolean, boolean]
  the key to set
- value: V
  the value to set
- validation: boolean = true
  whether to compare the range to all the ranges previously, to determine if there are any conflicts
Returns void
Example
```
map.set([60, 80, true, true], 'volcano');
```

toString

toString(): string

Returns the string representation of the map elements

Returns string

the string representation of the map elements

Example

const map = RangeMap.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

`Static`of

of<V>(
    entries?: [
        RangeMapKey
        | [number, number]
        | [number, number, boolean, boolean],
        V,
    ][],
    validation?: boolean,
): RangeMap<V>
Construct a 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 RangeMap<V>
a range map instance
Example
```
const map = RangeMap.of([
    [[1, 30], 'green'],
    [[30, 60], 'blue'],
    [[60, 90], 'orange'],
    [[90, 100, true, true], 'red']
]);
```

Class RangeMap<V>

Author

Type Parameters

Implements

Index

Constructors

Accessors

Methods

Constructors

constructor

Type Parameters

Parameters

Returns RangeMap<V>

Example

Accessors

[toStringTag]

Returns string

size

Returns number

Methods

[iterator]

Returns IterableIterator<[RangeMapKey, V]>

Example

clear

Returns void

deleteByKey

Parameters

Returns boolean

Example

deleteByKeys

Parameters

Returns boolean

Example

deleteByValue

Parameters

Returns boolean

Example

deleteByValues

Parameters

Returns boolean

Example

entries

Returns [RangeMapKey, V][]

forEach

Parameters

Returns void

Example

forEachBreakable

Parameters

Returns void

Example

forEachIndexing

Parameters

Returns void

Example

get

Parameters

Returns undefined | V

Example

getByDigit

Parameters

Returns undefined | V

Example

hasAllKeys

Parameters

Returns boolean

Example

hasAllValues

Parameters

Returns boolean

Example

hasAnyKeys

Parameters

Returns boolean

Example

hasAnyValues

Parameters

Returns boolean

Example

hasKey

`Static`of