Class Stream<T>

constructor

• new Stream<T>(...value: T[]): Stream<T>

  Type Parameters

  • T

  Parameters

  • ...value: T[]

  Returns Stream<T>

_limits

value

[iterator]

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

  returns an observable of the given stream

  Returns Iterator<T>

allMatch

• allMatch(fn: Matchable<T>): boolean

  returns true if all elmements produce true on a call to fn(element)

  Parameters

  • fn: Matchable<T>

  Returns boolean

anyMatch

• anyMatch(fn: Matchable<T>): boolean

  returns true if there is at least one element where a call fn(element) produces true

  Parameters

  • fn: Matchable<T>

  Returns boolean

collect

• collect(collector: ICollector<T, any>): any

  Collect the elements with a collector given There are a number of collectors provided

  Parameters

  • collector: ICollector<T, any>

  Returns any

concat

• concat(...toAppend: IStream<T>[]): Stream<T>

  concat for streams, so that you can concat two streams together

  Parameters

  • ...toAppend: IStream<T>[]

  Returns Stream<T>

current

• current(): ITERATION_STATUS | T

  returns the currently element selected in the stream

  Returns ITERATION_STATUS | T

each

• each(fn: (data: T, pos?: number) => boolean | void): void

  Iterate over all elements in the stream and do some processing via fn

  Parameters

  • fn: (data: T, pos?: number) => boolean | void

    takes a single element and if it returns false then further processing is stopped

  Returns void

filter

• filter(fn?: (data: T) => boolean): Stream<T>

  filtering, takes an element in and is processed by fn. If it returns false then further processing on this element is skipped if it returns true it is passed down the chain.

  Parameters

  • Optionalfn: (data: T) => boolean

  Returns Stream<T>

first

• first(): Optional<T>

  returns the first element in the stream is given as Optional

  Returns Optional<T>

flatMap

• flatMap<R>(fn?: (data: T) => any[] | R): Stream<any>

  Takes an element in and returns a set of something the set then is flatted into a single stream to be further processed

  Type Parameters

  • R

  Parameters

  • Optionalfn: (data: T) => any[] | R

  Returns Stream<any>

hasNext

• hasNext(): boolean

  Returns boolean

  true if additional data is present false if not

last

• last(): Optional<T>

  Returns the last stream element (note in endless streams without filtering and limiting you will never reach that point hence producing an endless loop)

  Returns Optional<T>

limits

• limits(end: number): Stream<T>

  Limits the stream to a certain number of elements

  Parameters

  • end: number

    the limit of the stream

  Returns Stream<T>

lookAhead

• lookAhead(cnt?: number): ITERATION_STATUS | T

  looks ahead cnt without changing the internal data "pointers" of the data source (this is mostly needed by possibly infinite constructs like lazy streams, because they do not know by definition their boundaries)

  Parameters

  • cnt: number = 1

    the elements to look ahead

  Returns ITERATION_STATUS | T

  either the element or ITERATION_STATUS.EO_STRM if we hit the end of the stream before finding the "cnt" element

map

• map<R>(fn?: (data: T) => R): Stream<R>

  maps a single element into another via fn

  Type Parameters

  • R

  Parameters

  • Optionalfn: (data: T) => R

    function which takes one element in and returns another

  Returns Stream<R>

next

• next(): ITERATION_STATUS | T

  returns the next element in the stream

  Returns ITERATION_STATUS | T

noneMatch

• noneMatch(fn: Matchable<T>): boolean

  returns true if no elmements produce true on a call to fn(element)

  Parameters

  • fn: Matchable<T>

  Returns boolean

onElem

• onElem(fn: (data: T, pos?: number) => boolean | void): Stream<T>

  Perform the operation fn on a single element in the stream at a time then pass the stream over for further processing This is basically an intermediate point in the stream with further processing happening later, do not use this method to gather data or iterate over all date for processing (for the second case each has to be used)

  Parameters

  • fn: (data: T, pos?: number) => boolean | void

    the processing function, if it returns false, further processing is stopped

  Returns Stream<T>

reduce

• reduce<V>(fn: Reducable<T, T | V>, startVal?: V | null): Optional<T | V>

  functional reduce... takes two elements in the stream and reduces to one from left to right

  Type Parameters

  • V

  Parameters

  • fn: Reducable<T, T | V>

    the reduction function for instance (val1,val2) => val1l+val2

  • startVal: V | null = null

    an optional starting value, if provided the the processing starts with this element and further goes down into the stream, if not, then the first two elements are taken as reduction starting point

  Returns Optional<T | V>

reset

• reset(): void

  resets the position to the beginning

  Returns void

sort

• sort(comparator: Comparator<T>): IStream<T>

  sort on the stream, this is a special case of an endpoint, so your data which is fed in needs to be limited otherwise it will fail it still returns a stream for further processing

  Parameters

  • comparator: Comparator<T>

  Returns IStream<T>

Staticof

• of<T>(...data: T[]): Stream<T>

  Type Parameters

  • T

  Parameters

  • ...data: T[]

  Returns Stream<T>

StaticofArr

• ofArr<T>(data: T[]): Stream<T>

  chunk-safe factory, takes the backing array directly instead of spreading it into the call (Stream.of(...largeArray) overflows the argument stack on large arrays)

  Type Parameters

  • T

  Parameters

  • data: T[]

    the array to stream over

  Returns Stream<T>

StaticofAssoc

• ofAssoc<T>(data: { [key: string]: T }): Stream<[string, T]>

  Type Parameters

  • T

  Parameters

  • data: { [key: string]: T }

  Returns Stream<[string, T]>

StaticofConfig

• ofConfig(value: Config): Stream<[string, any]>

  Parameters

  • value: Config

  Returns Stream<[string, any]>

StaticofDataSource

• ofDataSource<T>(dataSource: IStreamDataSource<T>): Stream<T>

  Type Parameters

  • T

  Parameters

  • dataSource: IStreamDataSource<T>

  Returns Stream<T>

StaticofDomQuery

• ofDomQuery(value: DomQuery): Stream<DomQuery>

  Parameters

  • value: DomQuery

  Returns Stream<DomQuery>