Class Observable<T>
Type Parameters
T
Hierarchy
- Observable
Index
Constructors
Properties
Accessors
Methods
Constructors
constructor
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
Parameters
observer: Observer<T>
Returns void
Optional notifyIfTriggered: boolean
If set to true the observable will notify when an observer was added if the observable was already triggered.
Returns Observable<T>
Properties
Optional _coroutine
Internal observable-based coroutine scheduler instance.
notify
If set to true the observable will notify when an observer was added if the observable was already triggered. This is helpful to single-state observables like the scene onReady or the dispose observable.
Accessors
observers
Gets the list of observers Note that observers that were recently deleted may still be present in the list because they are only really deleted on the next javascript tick!
Returns Observer<T>[]
Methods
Optional _coroutine
Internal disposal method for observable-based coroutine scheduler instance.
Returns void
addSearch playground for add
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
eventData: T
eventState: EventState
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
add
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
eventData: T
eventState: EventState
Returns void
Returns Nullable<Observer<T>>
the new observer created for the callback
cancel
Cancels all coroutines currently running on this observable
Returns void
clean
Clean the last notified state - both the internal last value and the has-notified flag
Returns void
clearSearch playground for clear
Clear the list of observers
Returns void
cloneSearch playground for clone
Clone the current observable
Returns Observable<T>
a new observable
has
Gets a boolean indicating if the observable has at least one observer
Returns boolean
true is the Observable has at least one Observer registered
has
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
make
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
make
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
notify
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
notify
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)
notify
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.
removeSearch playground for remove
remove
Remove a callback from the Observable object
Parameters
callback: ((eventData: T, eventState: EventState) => void)
the callback to remove
Parameters
eventData: T
eventState: EventState
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
run
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
Static From
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
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.