Class MappedComparableList<T, U>

capacityIncSize

Readonlyitems

capacity

• get capacity(): number

  Returns number

• set capacity(value: number): void

  Parameters

  • value: number

  Returns void

count

• get count(): number

  Returns number

• set count(value: number): void

  Parameters

  • value: number

  Returns void

lastIndex

• get lastIndex(): number

  Returns number

[iterator]

• "[iterator]"(): Iterator<T>

  Returns Iterator<T>

binaryFindAny

• binaryFindAny(compareToFn: CompareItemFn<T>): BinaryFind.Result

  Parameters

  • compareToFn: CompareItemFn<T>

  Returns BinaryFind.Result

binaryFindEarliest

• binaryFindEarliest(compareToFn: CompareItemFn<T>): BinaryFind.Result

  Parameters

  • compareToFn: CompareItemFn<T>

  Returns BinaryFind.Result

binaryFindLatest

• binaryFindLatest(compareToFn: CompareItemFn<T>): BinaryFind.Result

  Parameters

  • compareToFn: CompareItemFn<T>

  Returns BinaryFind.Result

binarySearchAny

• binarySearchAny(item: T, compareItemsFtn?: CompareFtn<T>): BinarySearchResult

  Parameters

  • item: T
  • OptionalcompareItemsFtn: CompareFtn<T>

  Returns BinarySearchResult

binarySearchEarliest

• binarySearchEarliest(
      item: T,
      compareItemsFtn?: CompareFtn<T>,
  ): BinarySearchResult

  Parameters

  • item: T
  • OptionalcompareItemsFtn: CompareFtn<T>

  Returns BinarySearchResult

binarySearchLatest

• binarySearchLatest(item: T, compareItemsFtn?: CompareFtn<T>): BinarySearchResult

  Parameters

  • item: T
  • OptionalcompareItemsFtn: CompareFtn<T>

  Returns BinarySearchResult

compareItems

• compareItems(left: T, right: T): ComparisonResult

  Parameters

  • left: T
  • right: T

  Returns ComparisonResult

exchange

• exchange(index1: number, index2: number): void

  Parameters

  • index1: number
  • index2: number

  Returns void

find

• find(predicate: (value: T, index: number) => boolean): undefined | T

  Parameters

  • predicate: (value: T, index: number) => boolean

  Returns undefined | T

findIndex

• findIndex(predicate: (value: T, index: number) => boolean): number

  Parameters

  • predicate: (value: T, index: number) => boolean

  Returns number

first

• first(): T

  Returns T

getAt

• getAt(index: number): T

  Parameters

  • index: number

  Returns T

has

• has(predicate: (value: T, index: number) => boolean): boolean

  Parameters

  • predicate: (value: T, index: number) => boolean

  Returns boolean

indexOf

• indexOf(value: T): number

  Parameters

  • value: T

  Returns number

last

• last(): T

  Returns T

move

• move(fromIndex: number, toIndex: number): void

  Parameters

  • fromIndex: number
  • toIndex: number

  Returns void

moveRange

• moveRange(fromIndex: number, toIndex: number, count: number): void

  Parameters

  • fromIndex: number
  • toIndex: number
  • count: number

  Returns void

rangeToArray

• rangeToArray(index: number, count: number): T[]

  Parameters

  • index: number
  • count: number

  Returns T[]

setGrowthCapacity

• setGrowthCapacity(growth: number): void

  Parameters

  • growth: number

  Returns void

setMinimumCapacity

• setMinimumCapacity(value: number): void

  Parameters

  • value: number

  Returns void

shift

• shift(): undefined | T

  Returns undefined | T

sort

• sort(compareItemsFtn?: CompareFtn<T>): void

  Parameters

  • OptionalcompareItemsFtn: CompareFtn<T>

  Returns void

subscribeListChangeEvent

• subscribeListChangeEvent(handler: ListChangeEventHandler): number

  Parameters

  • handler: ListChangeEventHandler

  Returns number

toArray

• toArray(): T[]

  Returns T[]

trimExcess

• trimExcess(): void

  Returns void

unsubscribeListChangeEvent

• unsubscribeListChangeEvent(subscriptionId: SubscriptionId): void

  Parameters

  • subscriptionId: SubscriptionId

  Returns void