AsyncOrderedQuery Class

Package: @esfx/async-iter-query

Represents an ordered sequence of elements.

Declaration

export declare class AsyncOrderedQuery<T> extends AsyncQuery<T> implements AsyncOrderedIterable<T> 

Inheritance

AsyncQuery<T>

AsyncOrderedQuery

Inherited Members

_fromAsync(source)

_fromAsync(source)

_fromAsync(source, provider)

_fromAsync(source, provider)

_fromAsync(source)

_fromAsync(source)

_fromAsync(source)

_fromSync(source)

_fromSync(source)

_fromSync(source, provider)

_fromSync(source, provider)

_fromSync(source)

_fromSync(source)

_fromSync(source)

[Symbol.asyncIterator]()

constructor(source)

append(value)

average()

average(elementSelector)

break(predicate)

concat(right)

concat(right)

consume(iterator, options)

continuous(value)

copyTo(dest, start, count)

corresponds(right, equaler)

corresponds(right, equaler)

correspondsBy(right, keySelector, keyEqualer)

correspondsBy(right, leftKeySelector, rightKeySelector, keyEqualer)

count(predicate)

defaultIfEmpty(defaultValue)

distinct(equaler)

distinctBy(keySelector, keyEqualer)

drop(count)

dropRight(count)

dropUntil(predicate)

dropWhile(predicate)

elementAt(offset)

empty()

endsWith(right, equaler)

endsWith(right, equaler)

every(predicate)

except(right, equaler)

exceptBy(right, keySelector, keyEqualer)

exclude(values)

filter(predicate)

filter(predicate)

filterBy(keySelector, predicate)

filterDefined()

filterDefinedBy(keySelector)

filterNot(predicate)

filterNot(predicate)

filterNotBy(keySelector, predicate)

filterNotDefinedBy(keySelector)

first(predicate)

first(predicate)

flatMap(projection)

flatMap(projection, resultSelector)

forEach(callback)

from(source)

from(source)

from(source, provider)

from(source, provider)

from(source)

from(source)

from(source)

fullJoin(inner, outerKeySelector, innerKeySelector, resultSelector, keyEqualer)

generate(count, generator)

groupBy(keySelector, keyEqualer)

groupBy(keySelector, elementSelector, keyEqualer)

groupBy(keySelector, elementSelector, resultSelector, keyEqualer)

groupBy(keySelector, elementSelector, resultSelector, keyEqualer)

groupJoin(inner, outerKeySelector, innerKeySelector, resultSelector, keyEqualer)

includes(value, equaler)

includes(value, equaler)

includesSequence(right, equaler)

includesSequence(right, equaler)

intersect(right, equaler)

intersect(right, equaler)

intersectBy(right, keySelector, keyEqualer)

intersectBy(right, keySelector, keyEqualer)

into(callback)

join(inner, outerKeySelector, innerKeySelector, resultSelector, keyEqualer)

last(predicate)

last(predicate)

map(selector)

materialize()

max(comparer)

maxBy(keySelector, keyComparer)

min(comparer)

minBy(keySelector, keyComparer)

nth(offset)

of(elements)

once(value)

orderBy(keySelector, comparer)

orderByDescending(keySelector, comparer)

pageBy(pageSize)

pageBy(pageSize, pageSelector)

patch(start, skipCount, range)

prepend(value)

range(start, end, increment)

reduce(accumulator)

reduce(accumulator, seed, resultSelector)

reduce(accumulator, seed, resultSelector)

reduceRight(accumulator)

reduceRight(accumulator, seed, resultSelector)

reduceRight(accumulator, seed, resultSelector)

relativeComplement(right, equaler)

relativeComplementBy(right, keySelector, keyEqualer)

repeat(value, count)

reverse()

scan(accumulator)

scan(accumulator, seed)

scanRight(accumulator)

scanRight(accumulator, seed)

select(selector)

selectMany(projection)

selectMany(projection, resultSelector)

single(predicate)

single(predicate)

skip(count)

skipRight(count)

skipUntil(predicate)

skipWhile(predicate)

some(predicate)

span(predicate)

span(predicate)

spanMap(keySelector, keyEqualer)

spanMap(keySelector, elementSelector, keyEqualer)

spanMap(keySelector, elementSelector, spanSelector, keyEqualer)

spanMap(keySelector, elementSelector, spanSelector, keyEqualer)

spanUntil(predicate)

startsWith(right, equaler)

startsWith(right, equaler)

sum()

sum(elementSelector)

symmetricDifference(right, equaler)

symmetricDifference(right, equaler)

symmetricDifferenceBy(right, keySelector, keyEqualer)

symmetricDifferenceBy(right, keySelector, keyEqualer)

take(count)

takeRight(count)

takeUntil(predicate)

takeWhile(predicate)

takeWhile(predicate)

tap(callback)

through(callback)

toArray()

toArray(elementSelector)

toHashMap(keySelector, keyEqualer)

toHashMap(keySelector, elementSelector, keyEqualer)

toHashSet(equaler)

toHashSet(elementSelector, equaler)

toHierarchy(provider)

toLookup(keySelector, keyEqualer)

toLookup(keySelector, elementSelector, keyEqualer)

toMap(keySelector)

toMap(keySelector, elementSelector)

toObject(prototype, keySelector)

toObject(prototype, keySelector)

toObject(prototype, keySelector)

toObject(prototype, keySelector)

toObject(prototype, keySelector, elementSelector, descriptorSelector)

toObject(prototype, keySelector, elementSelector, descriptorSelector)

toObject(prototype, keySelector, elementSelector, descriptorSelector)

toObject(prototype, keySelector, elementSelector, descriptorSelector)

toObject(prototype, keySelector, elementSelector, descriptorSelector)

toSet()

toSet(elementSelector)

union(right, equaler)

union(right, equaler)

unionBy(right, keySelector, keyEqualer)

unionBy(right, keySelector, keyEqualer)

unzip()

unzip(partSelector)

where(predicate)

where(predicate)

whereBy(keySelector, predicate)

whereDefined()

whereDefinedBy(keySelector)

whereNot(predicate)

whereNot(predicate)

whereNotBy(keySelector, predicate)

whereNotDefinedBy(keySelector)

zip(right)

zip(right, selector)

Constructors

constructor(source)

Constructs a new instance of the AsyncOrderedQuery class

Declaration

constructor(source: AsyncOrderedIterable<T> | OrderedIterable<T>);

Parameters

source

AsyncOrderedIterable<T> | OrderedIterable<T>

Methods

[AsyncOrderedIterable.thenByAsync](keySelector, comparer, descending)

Declaration

[AsyncOrderedIterable.thenByAsync]<K>(keySelector: (element: T) => K, comparer: Comparison<K> | Comparer<K>, descending: boolean): AsyncOrderedIterable<T>;

Type Parameters

K

Parameters

keySelector

(element: T) => K

comparer

Comparison<K> | Comparer<K>

descending

boolean

Returns

AsyncOrderedIterable<T>

thenBy(keySelector, comparer)

Creates a subsequent ordered subquery whose elements are sorted in ascending order by the provided key.

Declaration

thenBy<K>(keySelector: (element: T) => K, comparer?: Comparison<K> | Comparer<K>): AsyncOrderedQuery<T>;

Type Parameters

K

Parameters

keySelector

(element: T) => K

A callback used to select the key for an element.

comparer

Comparison<K> | Comparer<K>

An optional callback used to compare two keys. Order

Returns

AsyncOrderedQuery<T>

thenByDescending(keySelector, comparer)

Creates a subsequent ordered subquery whose elements are sorted in descending order by the provided key.

Declaration

thenByDescending<K>(keySelector: (element: T) => K, comparer?: Comparison<K> | Comparer<K>): AsyncOrderedQuery<T>;

Type Parameters

K

Parameters

keySelector

(element: T) => K

A callback used to select the key for an element.

comparer

Comparison<K> | Comparer<K>

An optional callback used to compare two keys. Order

Returns

AsyncOrderedQuery<T>