Options
All
  • Public
  • Public/Protected
  • All
Menu

The Observable class is a simple implementation of the Observable pattern.

There's one slight particularity though: a given Observable can notify its observer using a particular mask value, only the Observers registered with this mask value will be notified. This enable a more fine grained execution without having to rely on multiple different Observable objects. For instance you may have a given Observable that have four different types of notifications: Move (mask = 0x01), Stop (mask = 0x02), Turn Right (mask = 0X04), Turn Left (mask = 0X08). A given observer can register itself with only Move and Stop (mask = 0x03), then it will only be notified when one of these two occurs and will never be for Turn Left/Right.

Type Parameters

  • T

Hierarchy

  • Observable

Index

Constructors

  • Creates a new observable

    Type Parameters

    • T

    Parameters

    • Optional onObserverAdded: ((observer: Observer<T>) => void)

      defines a callback to call when a new observer is added

    Returns Observable<T>

Properties

_coroutineScheduler?: CoroutineScheduler<void>

Internal observable-based coroutine scheduler instance.

_eventState: EventState
internal

Accessors

  • Gets the list of observers

    Returns Observer<T>[]

Methods

  • _coroutineSchedulerDispose(): void
  • Internal disposal method for observable-based coroutine scheduler instance.

    Returns void

  • _deferUnregister(observer: Observer<T>): void
  • internal

    Parameters

    Returns void

  • add(callback: ((eventData: T, eventState: EventState) => void), mask?: number, insertFirst?: boolean, scope?: any, unregisterOnFirstCall?: boolean): Nullable<Observer<T>>
  • Create a new Observer with the specified callback

    Parameters

    • callback: ((eventData: T, eventState: EventState) => void)

      the callback that will be executed for that Observer

        • Parameters

          Returns void

    • Optional mask: number

      the mask used to filter observers

    • Optional insertFirst: boolean

      if true the callback will be inserted at the first position, hence executed before the others ones. If false (default behavior) the callback will be inserted at the last position, executed after all the others already present.

    • Optional scope: any

      optional scope for the callback to be called from

    • Optional unregisterOnFirstCall: boolean

      defines if the observer as to be unregistered after the next notification

    Returns Nullable<Observer<T>>

    the new observer created for the callback

  • Create a new Observer with the specified callback and unregisters after the next notification

    Parameters

    • callback: ((eventData: T, eventState: EventState) => void)

      the callback that will be executed for that Observer

        • Parameters

          Returns void

    Returns Nullable<Observer<T>>

    the new observer created for the callback

  • cancelAllCoroutines(): void
  • Cancels all coroutines currently running on this observable

    Returns void

  • clear(): void
  • Clear the list of observers

    Returns void

  • Clone the current observable

    Returns Observable<T>

    a new observable

  • hasObservers(): boolean
  • Gets a boolean indicating if the observable has at least one observer

    Returns boolean

    true is the Observable has at least one Observer registered

  • hasSpecificMask(mask?: number): boolean
  • Does this observable handles observer registered with a given mask

    Parameters

    • Optional mask: number

      defines the mask to be tested

    Returns boolean

    whether or not one observer registered with the given mask is handled

  • makeObserverBottomPriority(observer: Observer<T>): void
  • Moves the observable to the bottom of the observer list making it get called last when notified

    Parameters

    • observer: Observer<T>

      the observer to move

    Returns void

  • makeObserverTopPriority(observer: Observer<T>): void
  • Moves the observable to the top of the observer list making it get called first when notified

    Parameters

    • observer: Observer<T>

      the observer to move

    Returns void

  • notifyObserver(observer: Observer<T>, eventData: T, mask?: number): void
  • Notify a specific observer

    Parameters

    • observer: Observer<T>

      defines the observer to notify

    • eventData: T

      defines the data to be sent to each callback

    • Optional mask: number

      is used to filter observers defaults to -1

    Returns void

  • notifyObservers(eventData: T, mask?: number, target?: any, currentTarget?: any, userInfo?: any): boolean
  • Notify all Observers by calling their respective callback with the given data Will return true if all observers were executed, false if an observer set skipNextObservers to true, then prevent the subsequent ones to execute

    Parameters

    • eventData: T

      defines the data to send to all observers

    • Optional mask: number

      defines the mask of the current notification (observers with incompatible mask (ie mask & observer.mask === 0) will not be notified)

    • Optional target: any

      defines the original target of the state

    • Optional currentTarget: any

      defines the current target of the state

    • Optional userInfo: any

      defines any user info to send to observers

    Returns boolean

    false if the complete observer chain was not processed (because one observer set the skipNextObservers to true)

  • notifyObserversWithPromise(eventData: T, mask?: number, target?: any, currentTarget?: any, userInfo?: any): Promise<T>
  • Calling this will execute each callback, expecting it to be a promise or return a value. If at any point in the chain one function fails, the promise will fail and the execution will not continue. This is useful when a chain of events (sometimes async events) is needed to initialize a certain object and it is crucial that all callbacks will be executed. The order of the callbacks is kept, callbacks are not executed parallel.

    Parameters

    • eventData: T

      The data to be sent to each callback

    • Optional mask: number

      is used to filter observers defaults to -1

    • Optional target: any

      defines the callback target (see EventState)

    • Optional currentTarget: any

      defines he current object in the bubbling phase

    • Optional userInfo: any

      defines any user info to send to observers

    Returns Promise<T>

    will return a Promise than resolves when all callbacks executed successfully.

  • Remove an Observer from the Observable object

    Parameters

    Returns boolean

    false if it doesn't belong to this Observable

  • removeCallback(callback: ((eventData: T, eventState: EventState) => void), scope?: any): boolean
  • Remove a callback from the Observable object

    Parameters

    • callback: ((eventData: T, eventState: EventState) => void)

      the callback to remove

        • Parameters

          Returns void

    • Optional scope: any

      optional scope. If used only the callbacks with this scope will be removed

    Returns boolean

    false if it doesn't belong to this Observable

  • Runs a coroutine asynchronously on this observable

    Parameters

    • coroutine: AsyncCoroutine<void>

      the iterator resulting from having started the coroutine

    Returns Promise<void>

    a promise which will be resolved when the coroutine finishes or rejected if the coroutine is cancelled

  • Create an observable from a Promise.

    Type Parameters

    • T

    • E = Error

    Parameters

    • promise: Promise<T>

      a promise to observe for fulfillment.

    • Optional onErrorObservable: Observable<E>

      an observable to notify if a promise was rejected.

    Returns Observable<T>

    the new Observable

Legend

  • Constructor
  • Property
  • Method
  • Property
  • Method
  • Inherited constructor
  • Static method

Settings

Theme