Options
All
  • Public
  • Public/Protected
  • All
Menu

Class TaskPollerObservable<T>

Type parameters

  • T

Hierarchy

  • Observable<T>
    • TaskPollerObservable

Implements

  • Subscribable<T>

Index

Modules

Constructors

Properties

Accessors

Methods

Constructors

constructor

  • new TaskPollerObservable(request: Observable<T>, scheduler?: Scheduler, timerInterval?: number): TaskPollerObservable

Properties

_isScalar

_isScalar: boolean

Protected operator

operator: Operator<any, T>

Private request

request: Observable<T>

Private Optional scheduler

scheduler: Scheduler

Protected source

source: Observable<any>

Private Optional timerInterval

timerInterval: number

Static _catch

_catch: _catch

Static _do

_do: _do

Static _finally

_finally: _finally

Static _switch

_switch: _switch

Static audit

audit: audit

Static auditTime

auditTime: auditTime

Static buffer

buffer: buffer

Static bufferCount

bufferCount: bufferCount

Static bufferTime

bufferTime: bufferTime

Static bufferToggle

bufferToggle: bufferToggle

Static bufferWhen

bufferWhen: bufferWhen

Static catch

catch: _catch

Static combineAll

combineAll: combineAll

Static combineLatest

combineLatest: combineLatest

Static concat

concat: concat

Static concatAll

concatAll: concatAll

Static concatMap

concatMap: concatMap

Static concatMapTo

concatMapTo: concatMapTo

Static count

count: count

Static create

create: Function

Creates a new cold Observable by calling the Observable constructor

static

true

owner

Observable

method

create

param

the subscriber function to be passed to the Observable constructor

returns

a new cold observable

Static debounce

debounce: debounce

Static debounceTime

debounceTime: debounceTime

Static defaultIfEmpty

defaultIfEmpty: defaultIfEmpty

Static delay

delay: delay

Static delayWhen

delayWhen: delayWhen

Static dematerialize

dematerialize: dematerialize

Static distinct

distinct: distinct

Static distinctUntilChanged

distinctUntilChanged: distinctUntilChanged

Static distinctUntilKeyChanged

distinctUntilKeyChanged: distinctUntilKeyChanged

Static do

do: _do

Static elementAt

elementAt: elementAt

Static every

every: every

Static exhaust

exhaust: exhaust

Static exhaustMap

exhaustMap: exhaustMap

Static expand

expand: expand

Static filter

filter: filter

Static finally

finally: _finally

Static find

find: find

Static findIndex

findIndex: findIndex

Static first

first: first

Static flatMap

flatMap: mergeMap

Static flatMapTo

flatMapTo: mergeMapTo

Static groupBy

groupBy: groupBy

Static if

if: create

Static ignoreElements

ignoreElements: ignoreElements

Static isEmpty

isEmpty: isEmpty

Static last

last: last

Static let

let: letProto

Static letBind

letBind: letProto

Static map

map: map

Static mapTo

mapTo: mapTo

Static materialize

materialize: materialize

Static max

max: max

Static merge

merge: merge

Static mergeAll

mergeAll: mergeAll

Static mergeMap

mergeMap: mergeMap

Static mergeMapTo

mergeMapTo: mergeMapTo

Static mergeScan

mergeScan: mergeScan

Static min

min: min

Static multicast

multicast: multicast

Static observeOn

observeOn: observeOn

Static onErrorResumeNext

onErrorResumeNext: onErrorResumeNext

Static pairwise

pairwise: pairwise

Static partition

partition: partition

Static pluck

pluck: pluck

Static publish

publish: publish

Static publishBehavior

publishBehavior: publishBehavior

Static publishLast

publishLast: publishLast

Static publishReplay

publishReplay: publishReplay

Static race

race: race

Static reduce

reduce: reduce

Static repeat

repeat: repeat

Static repeatWhen

repeatWhen: repeatWhen

Static retry

retry: retry

Static retryWhen

retryWhen: retryWhen

Static sample

sample: sample

Static sampleTime

sampleTime: sampleTime

Static scan

scan: scan

Static sequenceEqual

sequenceEqual: sequenceEqual

Static share

share: share

Static shareReplay

shareReplay: shareReplay

Static single

single: single

Static skip

skip: skip

Static skipLast

skipLast: skipLast

Static skipUntil

skipUntil: skipUntil

Static skipWhile

skipWhile: skipWhile

Static startWith

startWith: startWith

Static subscribeOn

subscribeOn: subscribeOn

Static switch

switch: _switch

Static switchMap

switchMap: switchMap

Static switchMapTo

switchMapTo: switchMapTo

Static take

take: take

Static takeLast

takeLast: takeLast

Static takeUntil

takeUntil: takeUntil

Static takeWhile

takeWhile: takeWhile

Static throttle

throttle: throttle

Static throttleTime

throttleTime: throttleTime

Static throw

throw: create

Static timeInterval

timeInterval: timeInterval

Static timeout

timeout: timeout

Static timeoutWith

timeoutWith: timeoutWith

Static timestamp

timestamp: timestamp

Static toArray

toArray: toArray

Static window

window: window

Static windowCount

windowCount: windowCount

Static windowTime

windowTime: windowTime

Static windowToggle

windowToggle: windowToggle

Static windowWhen

windowWhen: windowWhen

Static withLatestFrom

withLatestFrom: withLatestFrom

Static zip

zip: zipProto

Static zipAll

zipAll: zipAll

Accessors

innerObservable

  • get innerObservable(): Observable<T>

Methods

Protected _subscribe

  • _subscribe(subscriber: Subscriber<T>): TeardownLogic

Protected _trySubscribe

  • _trySubscribe(sink: Subscriber<T>): TeardownLogic

  • Parameters

    • sink: Subscriber<T>

    Returns TeardownLogic

forEach

  • forEach(next: function, PromiseCtor?: PromiseConstructor): Promise<void>
  • method

    forEach

    Parameters

    • next: function

      a handler for each value emitted by the observable

        • (value: T): void

        • Parameters

          • value: T

          Returns void

    • Optional PromiseCtor: PromiseConstructor

    Returns Promise<void>

    a promise that either resolves on observable completion or rejects with the handled error

lift

  • lift<R>(operator: Operator<T, R>): Observable<R>

  • Creates a new Observable, with this Observable as the source, and the passed operator defined as the new observable's operator.

    method

    lift

    Type parameters

    • R

    Parameters

    • operator: Operator<T, R>

      the operator defining the operation to take on the observable

    Returns Observable<R>

    a new observable with the Operator applied

pipe

  • pipe(): Observable<T>
  • pipe<A>(op1: OperatorFunction<T, A>): Observable<A>
  • pipe<A, B>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>): Observable<B>
  • pipe<A, B, C>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>): Observable<C>
  • pipe<A, B, C, D>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>): Observable<D>
  • pipe<A, B, C, D, E>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>): Observable<E>
  • pipe<A, B, C, D, E, F>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>): Observable<F>
  • pipe<A, B, C, D, E, F, G>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>, op7: OperatorFunction<F, G>): Observable<G>
  • pipe<A, B, C, D, E, F, G, H>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>, op7: OperatorFunction<F, G>, op8: OperatorFunction<G, H>): Observable<H>
  • pipe<A, B, C, D, E, F, G, H, I>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>, op7: OperatorFunction<F, G>, op8: OperatorFunction<G, H>, op9: OperatorFunction<H, I>): Observable<I>

  • Returns Observable<T>

  • Type parameters

    • A

    Parameters

    • op1: OperatorFunction<T, A>

    Returns Observable<A>

  • Type parameters

    • A

    • B

    Parameters

    • op1: OperatorFunction<T, A>
    • op2: OperatorFunction<A, B>

    Returns Observable<B>

  • Type parameters

    • A

    • B

    • C

    Parameters

    • op1: OperatorFunction<T, A>
    • op2: OperatorFunction<A, B>
    • op3: OperatorFunction<B, C>

    Returns Observable<C>

  • Type parameters

    • A

    • B

    • C

    • D

    Parameters

    • op1: OperatorFunction<T, A>
    • op2: OperatorFunction<A, B>
    • op3: OperatorFunction<B, C>
    • op4: OperatorFunction<C, D>

    Returns Observable<D>

  • Type parameters

    • A

    • B

    • C

    • D

    • E

    Parameters

    • op1: OperatorFunction<T, A>
    • op2: OperatorFunction<A, B>
    • op3: OperatorFunction<B, C>
    • op4: OperatorFunction<C, D>
    • op5: OperatorFunction<D, E>

    Returns Observable<E>

  • Type parameters

    • A

    • B

    • C

    • D

    • E

    • F

    Parameters

    • op1: OperatorFunction<T, A>
    • op2: OperatorFunction<A, B>
    • op3: OperatorFunction<B, C>
    • op4: OperatorFunction<C, D>
    • op5: OperatorFunction<D, E>
    • op6: OperatorFunction<E, F>

    Returns Observable<F>

  • Type parameters

    • A

    • B

    • C

    • D

    • E

    • F

    • G

    Parameters

    • op1: OperatorFunction<T, A>
    • op2: OperatorFunction<A, B>
    • op3: OperatorFunction<B, C>
    • op4: OperatorFunction<C, D>
    • op5: OperatorFunction<D, E>
    • op6: OperatorFunction<E, F>
    • op7: OperatorFunction<F, G>

    Returns Observable<G>

  • Type parameters

    • A

    • B

    • C

    • D

    • E

    • F

    • G

    • H

    Parameters

    • op1: OperatorFunction<T, A>
    • op2: OperatorFunction<A, B>
    • op3: OperatorFunction<B, C>
    • op4: OperatorFunction<C, D>
    • op5: OperatorFunction<D, E>
    • op6: OperatorFunction<E, F>
    • op7: OperatorFunction<F, G>
    • op8: OperatorFunction<G, H>

    Returns Observable<H>

  • Type parameters

    • A

    • B

    • C

    • D

    • E

    • F

    • G

    • H

    • I

    Parameters

    • op1: OperatorFunction<T, A>
    • op2: OperatorFunction<A, B>
    • op3: OperatorFunction<B, C>
    • op4: OperatorFunction<C, D>
    • op5: OperatorFunction<D, E>
    • op6: OperatorFunction<E, F>
    • op7: OperatorFunction<F, G>
    • op8: OperatorFunction<G, H>
    • op9: OperatorFunction<H, I>

    Returns Observable<I>

subscribe

  • subscribe(observer?: PartialObserver<T>): Subscription
  • subscribe(next?: function, error?: function, complete?: function): Subscription

  • Parameters

    • Optional observer: PartialObserver<T>

    Returns Subscription

  • Parameters

    • Optional next: function
        • (value: T): void

        • Parameters

          • value: T

          Returns void

    • Optional error: function
        • (error: any): void

        • Parameters

          • error: any

          Returns void

    • Optional complete: function
        • (): void

        • Returns void

    Returns Subscription

toPromise

  • toPromise<T>(this: Observable<T>): Promise<T>
  • toPromise<T>(this: Observable<T>, PromiseCtor: PromiseConstructor): Promise<T>
  • toPromise<T>(this: Observable<T>, PromiseCtor: PromiseConstructorLike): Promise<T>

  • Type parameters

    • T

    Parameters

    • this: Observable<T>

    Returns Promise<T>

  • Type parameters

    • T

    Parameters

    • this: Observable<T>
    • PromiseCtor: PromiseConstructor

    Returns Promise<T>

  • Type parameters

    • T

    Parameters

    • this: Observable<T>
    • PromiseCtor: PromiseConstructorLike

    Returns Promise<T>

Generated using TypeDoc