Class ChangeSubscribableComparableList<T, U>

Type Parameters

out T extends U
in U = T

Hierarchy (View Summary)

ComparableList<T, U>
- ChangeSubscribableComparableList
  - MappedComparableList

Implements

RecordList<T>

Constructors

constructor

new ChangeSubscribableComparableList<out T, in U = T>(
compareItemsFtn?: CompareFtn<U>,
): ChangeSubscribableComparableList<T, U>
Type Parameters
- out T
- in U = T
Parameters
- OptionalcompareItemsFtn: CompareFtn<U>
Returns ChangeSubscribableComparableList<T, U>
Inherited from ComparableList.constructor

Properties

capacityIncSize

capacityIncSize: undefined | number

`Readonly`items

items: T[] = ...

Accessors

capacity

get capacity(): number
Returns number
Inherited from ComparableList.capacity
set capacity(value: number): void
Parameters
- value: number
Returns void
Inherited from ComparableList.capacity

count

get count(): number
Returns number
Implementation of RecordList.count
Inherited from ComparableList.count
set count(value: number): void
Parameters
- value: number
Returns void
Implementation of RecordList.count
Inherited from ComparableList.count

lastIndex

get lastIndex(): number
Returns number
Inherited from ComparableList.lastIndex

Methods

[iterator]

"[iterator]"(): Iterator<T>
Returns Iterator<T>
Inherited from ComparableList.[iterator]

add

add(value: T): number
Parameters
- value: T
Returns number
Overrides ComparableList.add

addRange

addRange(values: readonly T[]): void
Parameters
- values: readonly T[]
Returns void
Overrides ComparableList.addRange

addSubRange

addSubRange(
    values: readonly T[],
    rangeStartIndex: number,
    rangeCount: number,
): void
Parameters
- values: readonly T[]
- rangeStartIndex: number
- rangeCount: number
Returns void
Overrides ComparableList.addSubRange

addUndefinedRange

addUndefinedRange(undefinedValueCount: number): void
Parameters
- undefinedValueCount: number
Returns void
Overrides ComparableList.addUndefinedRange

binaryFindAny

binaryFindAny(compareToFn: CompareItemFn<T>): BinaryFind.Result
Parameters
- compareToFn: CompareItemFn<T>
Returns BinaryFind.Result
Inherited from ComparableList.binaryFindAny

binaryFindEarliest

binaryFindEarliest(compareToFn: CompareItemFn<T>): BinaryFind.Result
Parameters
- compareToFn: CompareItemFn<T>
Returns BinaryFind.Result
Inherited from ComparableList.binaryFindEarliest

binaryFindLatest

binaryFindLatest(compareToFn: CompareItemFn<T>): BinaryFind.Result
Parameters
- compareToFn: CompareItemFn<T>
Returns BinaryFind.Result
Inherited from ComparableList.binaryFindLatest

binarySearchAny

binarySearchAny(item: T, compareItemsFtn?: CompareFtn<T>): BinarySearchResult
Parameters
- item: T
- OptionalcompareItemsFtn: CompareFtn<T>
Returns BinarySearchResult
Inherited from ComparableList.binarySearchAny

binarySearchEarliest

binarySearchEarliest(
item: T,
compareItemsFtn?: CompareFtn<T>,
): BinarySearchResult
Parameters
- item: T
- OptionalcompareItemsFtn: CompareFtn<T>
Returns BinarySearchResult
Inherited from ComparableList.binarySearchEarliest

binarySearchLatest

binarySearchLatest(item: T, compareItemsFtn?: CompareFtn<T>): BinarySearchResult
Parameters
- item: T
- OptionalcompareItemsFtn: CompareFtn<T>
Returns BinarySearchResult
Inherited from ComparableList.binarySearchLatest

clear

clear(): void
Returns void
Overrides ComparableList.clear

clone

clone(): ChangeSubscribableComparableList<T, U>
Returns ChangeSubscribableComparableList<T, U>
Overrides ComparableList.clone

compareItems

compareItems(left: T, right: T): ComparisonResult
Parameters
- left: T
- right: T
Returns ComparisonResult
Inherited from ComparableList.compareItems

contains

contains(value: T): boolean
Parameters
- value: T
Returns boolean
Inherited from ComparableList.contains

exchange

exchange(index1: number, index2: number): void
Parameters
- index1: number
- index2: number
Returns void
Overrides ComparableList.exchange

extract

extract(value: T): T
Parameters
- value: T
Returns T
Inherited from ComparableList.extract

find

find(predicate: (value: T, index: number) => boolean): undefined | T
Parameters
- predicate: (value: T, index: number) => boolean
Returns undefined | T
Inherited from ComparableList.find

findIndex

findIndex(predicate: (value: T, index: number) => boolean): number
Parameters
- predicate: (value: T, index: number) => boolean
Returns number
Inherited from ComparableList.findIndex

first

first(): T
Returns T
Inherited from ComparableList.first

getAt

getAt(index: number): T
Parameters
- index: number
Returns T
Implementation of RecordList.getAt
Inherited from ComparableList.getAt

has

has(predicate: (value: T, index: number) => boolean): boolean
Parameters
- predicate: (value: T, index: number) => boolean
Returns boolean
Inherited from ComparableList.has

indexOf

indexOf(value: T): number
Parameters
- value: T
Returns number
Implementation of RecordList.indexOf
Inherited from ComparableList.indexOf

insert

insert(index: number, value: T): void
Parameters
- index: number
- value: T
Returns void
Overrides ComparableList.insert

insertRange

insertRange(index: number, values: readonly T[]): void
Parameters
- index: number
- values: readonly T[]
Returns void
Overrides ComparableList.insertRange

insertSubRange

insertSubRange(
    index: number,
    values: readonly T[],
    subRangeStartIndex: number,
    subRangeCount: number,
): void
Parameters
- index: number
- values: readonly T[]
- subRangeStartIndex: number
- subRangeCount: number
Returns void
Overrides ComparableList.insertSubRange

last

last(): T
Returns T
Inherited from ComparableList.last

move

move(fromIndex: number, toIndex: number): void
Parameters
- fromIndex: number
- toIndex: number
Returns void
Overrides ComparableList.move

moveRange

moveRange(fromIndex: number, toIndex: number, count: number): void
Parameters
- fromIndex: number
- toIndex: number
- count: number
Returns void
Overrides ComparableList.moveRange

rangeToArray

rangeToArray(index: number, count: number): T[]
Parameters
- index: number
- count: number
Returns T[]
Inherited from ComparableList.rangeToArray

remove

remove(value: T): void
Parameters
- value: T
Returns void
Overrides ComparableList.remove

removeAtIndex

removeAtIndex(index: number): void
Parameters
- index: number
Returns void
Overrides ComparableList.removeAtIndex

removeAtIndices

removeAtIndices(removeIndices: number[]): void
Parameters
- removeIndices: number[]
Returns void
Overrides ComparableList.removeAtIndices

removeItems

removeItems(removeItems: readonly T[]): void
Parameters
- removeItems: readonly T[]
Returns void
Overrides ComparableList.removeItems

removeRange

removeRange(index: number, deleteCount: number): void
Parameters
- index: number
- deleteCount: number
Returns void
Overrides ComparableList.removeRange

setAt

setAt(index: number, value: T): void
Parameters
- index: number
- value: T
Returns void
Overrides ComparableList.setAt

setGrowthCapacity

setGrowthCapacity(growth: number): void
Parameters
- growth: number
Returns void
Inherited from ComparableList.setGrowthCapacity

setMinimumCapacity

setMinimumCapacity(value: number): void
Parameters
- value: number
Returns void
Inherited from ComparableList.setMinimumCapacity

shift

shift(): undefined | T
Returns undefined | T
Inherited from ComparableList.shift

sort

sort(compareItemsFtn?: CompareFtn<T>): void
Parameters
- OptionalcompareItemsFtn: CompareFtn<T>
Returns void
Inherited from ComparableList.sort

subscribeListChangeEvent

subscribeListChangeEvent(handler: ListChangeEventHandler): number
Parameters
- handler: ListChangeEventHandler
Returns number
Implementation of RecordList.subscribeListChangeEvent

toArray

toArray(): T[]
Returns T[]
Implementation of RecordList.toArray
Inherited from ComparableList.toArray

trimExcess

trimExcess(): void
Returns void
Inherited from ComparableList.trimExcess

unsubscribeListChangeEvent

unsubscribeListChangeEvent(subscriptionId: SubscriptionId): void
Parameters
- subscriptionId: SubscriptionId
Returns void
Implementation of RecordList.unsubscribeListChangeEvent