Class ComparableList<T, U>

constructor

• new ComparableList<out T, in U = T>(
      compareItemsFtn?: CompareFtn<U>,
  ): ComparableList<T, U>

  Type Parameters

  • out T
  • in U = T

  Parameters

  • OptionalcompareItemsFtn: CompareFtn<U>

  Returns ComparableList<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>

add

• add(value: T): number

  Parameters

  • value: T

  Returns number

addRange

• addRange(values: readonly T[]): void

  Parameters

  • values: readonly T[]

  Returns void

addSubRange

• addSubRange(
      values: readonly T[],
      subRangeStartIndex: number,
      subRangeCount: number,
  ): void

  Parameters

  • values: readonly T[]
  • subRangeStartIndex: number
  • subRangeCount: number

  Returns void

addUndefinedRange

• addUndefinedRange(undefinedValueCount: number): void

  Parameters

  • undefinedValueCount: number

  Returns void

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

clear

• clear(): void

  Returns void

clone

• clone(): ComparableList<T, U>

  Returns ComparableList<T, U>

compareItems

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

  Parameters

  • left: T
  • right: T

  Returns ComparisonResult

contains

• contains(value: T): boolean

  Parameters

  • value: T

  Returns boolean

exchange

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

  Parameters

  • index1: number
  • index2: number

  Returns void

extract

• extract(value: T): T

  Parameters

  • value: T

  Returns T

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

insert

• insert(index: number, value: T): void

  Parameters

  • index: number
  • value: T

  Returns void

insertRange

• insertRange(index: number, values: readonly T[]): void

  Parameters

  • index: number
  • values: readonly T[]

  Returns void

insertSubRange

• insertSubRange(
      index: number,
      values: readonly T[],
      subRangeStartIndex: number,
      subRangeCount: number,
  ): void

  Parameters

  • index: number
  • values: readonly T[]
  • subRangeStartIndex: number
  • subRangeCount: number

  Returns void

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[]

remove

• remove(value: T): void

  Parameters

  • value: T

  Returns void

removeAtIndex

• removeAtIndex(index: number): void

  Parameters

  • index: number

  Returns void

removeAtIndices

• removeAtIndices(
      removeIndices: number[],
      beforeRemoveRangeCallBack?: BeforeRemoveRangeCallBack,
  ): void

  Parameters

  • removeIndices: number[]
  • OptionalbeforeRemoveRangeCallBack: BeforeRemoveRangeCallBack

  Returns void

removeItems

• removeItems(
      removeItems: readonly T[],
      beforeRemoveRangeCallBack?: BeforeRemoveRangeCallBack,
  ): void

  Parameters

  • removeItems: readonly T[]
  • OptionalbeforeRemoveRangeCallBack: BeforeRemoveRangeCallBack

  Returns void

removeRange

• removeRange(index: number, deleteCount: number): void

  Parameters

  • index: number
  • deleteCount: number

  Returns void

setAt

• setAt(index: number, value: T): void

  Parameters

  • index: number
  • value: T

  Returns void

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

toArray

• toArray(): T[]

  Returns T[]

trimExcess

• trimExcess(): void

  Returns void