PHP Class Rx\Observable

Inheritance: implements rx\ObservableInterface

Afficher le fichier Open project: ReactiveX/RxPHP Class Usage Examples

Protected Properties

Свойство	Type	Description
$observers
$started

Méthodes publiques

Méthode	Description
asObservable ( ) : Rx\Observable\AnonymousObservable	Hides the identity of an observable sequence.
average ( ) : Rx\Observable\AnonymousObservable	Computes the average of an observable sequence of values.
bufferWithCount ( $count, integer $skip = null ) : Rx\Observable\AnonymousObservable	Projects each element of an observable sequence into zero or more buffers which are produced based on element count information.
catchError ( callable $selector ) : Rx\Observable\AnonymousObservable	Continues an observable sequence that is terminated by an exception with the next observable sequence.
combineLatest ( array $observables, callable $selector = null ) : Rx\Observable\AnonymousObservable	Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element. Observables need to be an array.
concat ( rx\ObservableInterface $observable ) : Rx\Observable\AnonymousObservable	Concatenate an observable sequence onto the end of the source observable.
concatAll ( ) : Rx\Observable\AnonymousObservable	Concatenates a sequence of observable sequences into a single observable sequence.
concatMap ( callable $selector, callable $resultSelector = null ) : Rx\Observable\AnonymousObservable	Projects each element of an observable sequence to an observable sequence and concatenates the resulting observable sequences into one observable sequence.
concatMapTo ( rx\ObservableInterface $observable, callable $resultSelector = null ) : Rx\Observable\AnonymousObservable	Projects each element of the source observable sequence to the other observable sequence and merges the resulting observable sequences into one observable sequence.
count ( callable $predicate = null ) : Rx\Observable\AnonymousObservable	Returns an observable sequence containing a value that represents how many elements in the specified observable sequence satisfy a condition if provided, else the count of items.
create ( callable $subscribeAction ) : Rx\Observable\AnonymousObservable	Creates an observable sequence from a specified subscribeAction callable implementation.
defaultIfEmpty ( rx\ObservableInterface $observable ) : Rx\Observable\AnonymousObservable	Returns the specified value of an observable if the sequence is empty.
defer ( callable $factory ) : Rx\Observable\AnonymousObservable	Returns an observable sequence that invokes the specified factory function whenever a new observer subscribes.
delay ( $delay, rx\SchedulerInterface \| null $scheduler = null ) : Rx\Observable\AnonymousObservable	Time shifts the observable sequence by dueTime. The relative time intervals between the values are preserved.
dematerialize ( ) : Rx\Observable\AnonymousObservable	Dematerializes the explicit notification values of an observable sequence as implicit notifications.
distinct ( callable $comparer = null ) : Rx\Observable\AnonymousObservable	Returns an observable sequence that contains only distinct elements according to the keySelector and the comparer. Usage of this operator should be considered carefully due to the maintenance of an internal lookup structure which can grow large.
distinctKey ( callable $keySelector, callable $comparer = null ) : Rx\Observable\AnonymousObservable	Variant of distinct that takes a key selector
distinctUntilChanged ( callable $comparer = null ) : Rx\Observable\AnonymousObservable	A variant of distinct that only compares emitted items from the source Observable against their immediate predecessors in order to determine whether or not they are distinct.
distinctUntilKeyChanged ( callable $keySelector = null, callable $comparer = null ) : Rx\Observable\AnonymousObservable	Variant of distinctUntilChanged that takes a key selector and the comparer.
doOnCompleted ( callable $onCompleted ) : Rx\Observable\AnonymousObservable
doOnEach ( rx\ObserverInterface $observer ) : Rx\Observable\AnonymousObservable	Invokes an action for each element in the observable sequence and invokes an action upon graceful or exceptional termination of the observable sequence.
doOnError ( callable $onError ) : Rx\Observable\AnonymousObservable
doOnNext ( callable $onNext ) : Rx\Observable\AnonymousObservable
emptyObservable ( ) : Rx\Observable\EmptyObservable	Returns an empty observable sequence.
error ( Exception $error ) : Rx\Observable\ErrorObservable	Returns an observable sequence that terminates with an exception.
filter ( callable $predicate ) : Rx\Observable\AnonymousObservable	Emit only those items from an Observable that pass a predicate test.
flatMap ( callable $selector ) : Rx\Observable\AnonymousObservable	Projects each element of an observable sequence to an observable sequence and merges the resulting observable sequences into one observable sequence.
flatMapLatest ( callable $selector, rx\SchedulerInterface $scheduler = null ) : Rx\Observable\AnonymousObservable	Bypasses a specified number of elements in an observable sequence and then returns the remaining elements.
flatMapTo ( rx\ObservableInterface $observable ) : Rx\Observable\AnonymousObservable	Projects each element of the source observable sequence to the other observable sequence and merges the resulting observable sequences into one observable sequence.
fromArray ( array $array ) : Rx\Observable\ArrayObservable	Converts an array to an observable sequence
fromIterator ( Iterator $iterator ) : IteratorObservable	Converts an Iterator into an observable sequence
groupBy ( callable $keySelector, callable $elementSelector = null, callable $keySerializer = null ) : Rx\Observable\AnonymousObservable	Groups the elements of an observable sequence according to a specified key selector function and comparer and selects the resulting elements by using a specified function.
groupByUntil ( callable $keySelector, callable $elementSelector = null, callable $durationSelector = null, callable $keySerializer = null ) : Rx\Observable\AnonymousObservable	Groups the elements of an observable sequence according to a specified key selector function and comparer and selects the resulting elements by using a specified function.
interval ( $interval, rx\SchedulerInterface \| null $scheduler = null ) : Rx\Observable\IntervalObservable	Returns an Observable that emits an infinite sequence of ascending integers starting at 0, with a constant interval of time of your choosing between emissions.
just ( mixed $value ) : Rx\Observable\AnonymousObservable	Returns an observable sequence that contains a single element.
lift ( callable $operatorFactory ) : Rx\Observable\AnonymousObservable	Lifts a function to the current Observable and returns a new Observable that when subscribed to will pass the values of the current Observable through the Operator function.
map ( callable $selector ) : Rx\Observable\AnonymousObservable	Takes a transforming function that operates on each element.
mapTo ( $value ) : Rx\Observable\AnonymousObservable	Maps every value to the same value every time
mapWithIndex ( callable $selector ) : Rx\Observable\AnonymousObservable	Maps operator variant that calls the map selector with the index and value
materialize ( ) : Rx\Observable\AnonymousObservable	Materializes the implicit notifications of an observable sequence as explicit notifications.
max ( callable $comparer = null ) : Rx\Observable\AnonymousObservable	Returns the maximum value in an observable sequence according to the specified comparer.
merge ( rx\ObservableInterface $otherObservable ) : Rx\Observable\AnonymousObservable	Combine an Observable together with another Observable by merging their emissions into a single Observable.
mergeAll ( rx\ObservableInterface $sources ) : Rx\Observable\AnonymousObservable	Merges an observable sequence of observables into an observable sequence.
min ( callable $comparer = null ) : Rx\Observable\AnonymousObservable	Returns the minimum value in an observable sequence according to the specified comparer.
multicast ( Rx\Subject\Subject $subject, null $selector = null, rx\SchedulerInterface $scheduler = null ) : Rx\Observable\ConnectableObservable \| Rx\Observable\MulticastObservable	Multicasts the source sequence notifications through an instantiated subject into all uses of the sequence within a selector function. Each subscription to the resulting sequence causes a separate multicast invocation, exposing the sequence resulting from the selector function's invocation. For specializations with fixed subject types, see Publish, PublishLast, and Replay.
multicastWithSelector ( callable $subjectSelector, null $selector = null ) : Rx\Observable\ConnectableObservable \| Rx\Observable\MulticastObservable	Multicasts the source sequence notifications through an instantiated subject from a subject selector factory, into all uses of the sequence within a selector function. Each subscription to the resulting sequence causes a separate multicast invocation, exposing the sequence resulting from the selector function's invocation.
never ( ) : Rx\Observable\NeverObservable	Returns a non-terminating observable sequence, which can be used to denote an infinite duration.
partition ( callable $predicate ) : Rx\Observable\AnonymousObservable[]	Returns two observables which partition the observations of the source by the given function.
pluck ( mixed $property ) : Observable	Returns an Observable containing the value of a specified array index (if array) or property (if object) from all elements in the Observable sequence. If a property can't be resolved the observable will error.
publish ( callable $selector = null ) : Rx\Observable\ConnectableObservable \| Rx\Observable\MulticastObservable	Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence.
publishLast ( callable $selector = null ) : Rx\Observable\ConnectableObservable \| Rx\Observable\MulticastObservable	Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence containing only the last notification.
publishValue ( mixed $initialValue, callable $selector = null ) : Rx\Observable\ConnectableObservable \| Rx\Observable\MulticastObservable	Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence and starts with initialValue.
race ( array $observables ) : Rx\Observable\AnonymousObservable	Propagates the observable sequence that reacts first. Also known as 'amb'.
range ( $start, $count, rx\SchedulerInterface $scheduler = null ) : RangeObservable	Generates an observable sequence of integral numbers within a specified range, using the specified scheduler to send out observer messages.
reduce ( callable $accumulator, mixed $seed = null ) : Rx\Observable\AnonymousObservable	Applies an accumulator function over an observable sequence, returning the result of the aggregation as a single element in the result sequence.
removeObserver ( rx\ObserverInterface $observer )
repeat ( integer $count ) : Rx\Observable\AnonymousObservable \| Rx\Observable\EmptyObservable	Generates an observable sequence that repeats the given element the specified number of times.
repeatWhen ( callable $notifier ) : Rx\Observable\AnonymousObservable \| Rx\Observable\EmptyObservable	Returns an Observable that emits the same values as the source Observable with the exception of an onCompleted.
replay ( callable $selector = null, integer \| null $bufferSize = null, integer \| null $windowSize = null, rx\SchedulerInterface $scheduler = null ) : Rx\Observable\ConnectableObservable \| Rx\Observable\MulticastObservable	Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum time length for the replay buffer.
retry ( integer $retryCount ) : Rx\Observable\AnonymousObservable	Repeats the source observable sequence the specified number of times or until it successfully terminates.
retryWhen ( callable $notifier ) : Rx\Observable\AnonymousObservable	Repeats the source observable sequence on error when the notifier emits a next value. If the source observable errors and the notifier completes, it will complete the source sequence.
scan ( callable $accumulator, null $seed = null ) : Rx\Observable\AnonymousObservable	Applies an accumulator function over an observable sequence and returns each intermediate result.
select ( callable $selector ) : Rx\Observable\AnonymousObservable	Alias for Map
selectMany ( $selector ) : Rx\Observable\AnonymousObservable	Alias for flatMap
share ( ) : Rx\Observable\RefCountObservable	Returns an observable sequence that shares a single subscription to the underlying sequence.
shareReplay ( integer $bufferSize, integer $windowSize = null, rx\SchedulerInterface $scheduler = null ) : Rx\Observable\RefCountObservable	Returns an observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum time length for the replay buffer.
shareValue ( $initialValue ) : Rx\Observable\RefCountObservable	Returns an observable sequence that shares a single subscription to the underlying sequence and starts with an initialValue.
skip ( integer $count ) : Rx\Observable\AnonymousObservable
skipLast ( integer $count ) : Rx\Observable\AnonymousObservable	Bypasses a specified number of elements at the end of an observable sequence.
skipUntil ( rx\ObservableInterface $other ) : Rx\Observable\AnonymousObservable	Returns the values from the source observable sequence only after the other observable sequence produces a value.
skipWhile ( callable $predicate ) : Rx\Observable\AnonymousObservable	Bypasses elements in an observable sequence as long as a specified condition is true and then returns the remaining elements.
skipWhileWithIndex ( callable $predicate ) : Rx\Observable\AnonymousObservable	Bypasses elements in an observable sequence as long as a specified condition is true and then returns the remaining elements. The element's index is used in the logic of the predicate function.
start ( callable $action, rx\SchedulerInterface $scheduler = null ) : Rx\Observable\AnonymousObservable	Invokes the specified function asynchronously on the specified scheduler, surfacing the result through an observable sequence.
startWith ( mixed $startValue ) : Rx\Observable\AnonymousObservable	Prepends a value to an observable sequence with an argument of a signal value to prepend.
startWithArray ( array $startArray ) : Rx\Observable\AnonymousObservable	Prepends a sequence of values to an observable sequence with an argument of an array of values to prepend.
subscribe ( rx\ObserverInterface $observer, $scheduler = null )
subscribeCallback ( callable $onNext = null, callable $onError = null, callable $onCompleted = null, rx\SchedulerInterface $scheduler = null )
subscribeOn ( rx\SchedulerInterface $scheduler ) : Rx\Observable\AnonymousObservable	Wraps the source sequence in order to run its subscription and unsubscription logic on the specified scheduler.
sum ( ) : Rx\Observable\AnonymousObservable	Computes the sum of a sequence of values
switchFirst ( ) : Rx\Observable\AnonymousObservable	Receives an Observable of Observables and propagates the first Observable exclusively until it completes before it begins subscribes to the next Observable. Observables that come before the current Observable completes will be dropped and will not propagate.
switchLatest ( rx\SchedulerInterface $scheduler = null ) : Rx\Observable\AnonymousObservable	Transforms an observable sequence of observable sequences into an observable sequence producing values only from the most recent observable sequence.
take ( integer $count ) : Rx\Observable\AnonymousObservable \| Rx\Observable\EmptyObservable	Returns a specified number of contiguous elements from the start of an observable sequence
takeLast ( $count ) : Rx\Observable\AnonymousObservable	Returns a specified number of contiguous elements from the end of an observable sequence.
takeUntil ( rx\ObservableInterface $other ) : Rx\Observable\AnonymousObservable	Returns the values from the source observable sequence until the other observable sequence produces a value.
takeWhile ( callable $predicate ) : Rx\Observable\AnonymousObservable	Returns elements from an observable sequence as long as a specified condition is true. It takes as a parameter a a callback to test each source element for a condition. The callback predicate is called with the value of the element.
takeWhileWithIndex ( callable $predicate ) : Rx\Observable\AnonymousObservable	Returns elements from an observable sequence as long as a specified condition is true. It takes as a parameter a a callback to test each source element for a condition. The callback predicate is called with the index and the value of the element.
throttle ( $throttleDuration, null $scheduler = null ) : Rx\Observable\AnonymousObservable	Returns an Observable that emits only the first item emitted by the source Observable during sequential time windows of a specified duration.
timeout ( $timeout, rx\ObservableInterface $timeoutObservable = null, rx\SchedulerInterface $scheduler = null ) : Rx\Observable\AnonymousObservable
timer ( integer $dueTime, rx\SchedulerInterface $scheduler = null ) : TimerObservable	Returns an observable sequence that produces a value after dueTime has elapsed.
timestamp ( rx\SchedulerInterface $scheduler = null ) : Rx\Observable\AnonymousObservable	Records the timestamp for each value in an observable sequence.
toArray ( ) : Rx\Observable\AnonymousObservable	Creates an observable sequence containing a single element which is an array containing all the elements of the source sequence.
where ( callable $predicate ) : Rx\Observable\AnonymousObservable	Alias for filter
zip ( array $observables, callable $selector = null ) : Rx\Observable\AnonymousObservable	Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index. If the result selector function is omitted, a list with the elements of the observable sequences at corresponding indexes will be yielded.

Method Details

asObservable() public méthode

Hides the identity of an observable sequence.

public asObservable ( ) : Rx\Observable\AnonymousObservable
Résultat	Rx\Observable\AnonymousObservable	An observable sequence that hides the identity of the source sequence.

average() public méthode

Computes the average of an observable sequence of values.

public average ( ) : Rx\Observable\AnonymousObservable
Résultat	Rx\Observable\AnonymousObservable

bufferWithCount() public méthode

Projects each element of an observable sequence into zero or more buffers which are produced based on element count information.

public bufferWithCount ( $count, integer $skip = null ) : Rx\Observable\AnonymousObservable
$count
$skip	integer
Résultat	Rx\Observable\AnonymousObservable

catchError() public méthode

Continues an observable sequence that is terminated by an exception with the next observable sequence.

public catchError ( callable $selector ) : Rx\Observable\AnonymousObservable
$selector	callable
Résultat	Rx\Observable\AnonymousObservable

combineLatest() public méthode

If the result selector is omitted, a list with the elements will be yielded.

public combineLatest ( array $observables, callable $selector = null ) : Rx\Observable\AnonymousObservable
$observables	array
$selector	callable
Résultat	Rx\Observable\AnonymousObservable

concat() public méthode

Concatenate an observable sequence onto the end of the source observable.

public concat ( rx\ObservableInterface $observable ) : Rx\Observable\AnonymousObservable
$observable	rx\ObservableInterface
Résultat	Rx\Observable\AnonymousObservable

concatAll() public méthode

Concatenates a sequence of observable sequences into a single observable sequence.

public concatAll ( ) : Rx\Observable\AnonymousObservable
Résultat	Rx\Observable\AnonymousObservable	The observable sequence that merges the elements of the inner sequences.

concatMap() public méthode

Projects each element of an observable sequence to an observable sequence and concatenates the resulting observable sequences into one observable sequence.

public concatMap ( callable $selector, callable $resultSelector = null ) : Rx\Observable\AnonymousObservable
$selector	callable	A transform function to apply to each element from the source sequence onto. The selector is called with the following information: - the value of the element - the index of the element - the Observable object being subscribed
$resultSelector	callable	A transform function to apply to each element of the intermediate sequence. The resultSelector is called with the following information: - the value of the outer element - the value of the inner element - the index of the outer element - the index of the inner element
Résultat	Rx\Observable\AnonymousObservable	- An observable sequence whose elements are the result of invoking the one-to-many transform function collectionSelector on each element of the input sequence and then mapping each of those sequence elements and their corresponding source element to a result element.

concatMapTo() public méthode

Projects each element of the source observable sequence to the other observable sequence and merges the resulting observable sequences into one observable sequence.

public concatMapTo ( rx\ObservableInterface $observable, callable $resultSelector = null ) : Rx\Observable\AnonymousObservable
$observable	rx\ObservableInterface	- An an observable sequence to project each element from the source sequence onto.
$resultSelector	callable	A transform function to apply to each element of the intermediate sequence. The resultSelector is called with the following information: - the value of the outer element - the value of the inner element - the index of the outer element - the index of the inner element
Résultat	Rx\Observable\AnonymousObservable	An observable sequence whose elements are the result of invoking the one-to-many transform function collectionSelector on each element of the input sequence and then mapping each of those sequence elements and their corresponding source element to a result element.

count() public méthode

Returns an observable sequence containing a value that represents how many elements in the specified observable sequence satisfy a condition if provided, else the count of items.

public count ( callable $predicate = null ) : Rx\Observable\AnonymousObservable
$predicate	callable
Résultat	Rx\Observable\AnonymousObservable

create() public static méthode

Creates an observable sequence from a specified subscribeAction callable implementation.

public static create ( callable $subscribeAction ) : Rx\Observable\AnonymousObservable
$subscribeAction	callable	Implementation of the resulting observable sequence's subscribe method.
Résultat	Rx\Observable\AnonymousObservable	The observable sequence with the specified implementation for the subscribe method.

defaultIfEmpty() public méthode

Returns the specified value of an observable if the sequence is empty.

public defaultIfEmpty ( rx\ObservableInterface $observable ) : Rx\Observable\AnonymousObservable
$observable	rx\ObservableInterface
Résultat	Rx\Observable\AnonymousObservable

defer() public static méthode

Returns an observable sequence that invokes the specified factory function whenever a new observer subscribes.

public static defer ( callable $factory ) : Rx\Observable\AnonymousObservable
$factory	callable
Résultat	Rx\Observable\AnonymousObservable

delay() public méthode

Time shifts the observable sequence by dueTime. The relative time intervals between the values are preserved.

public delay ( $delay, rx\SchedulerInterface \| null $scheduler = null ) : Rx\Observable\AnonymousObservable
$delay
$scheduler	rx\SchedulerInterface \| null
Résultat	Rx\Observable\AnonymousObservable

dematerialize() public méthode

Dematerializes the explicit notification values of an observable sequence as implicit notifications.

public dematerialize ( ) : Rx\Observable\AnonymousObservable
Résultat	Rx\Observable\AnonymousObservable

distinct() public méthode

Returns an observable sequence that contains only distinct elements according to the keySelector and the comparer. Usage of this operator should be considered carefully due to the maintenance of an internal lookup structure which can grow large.

public distinct ( callable $comparer = null ) : Rx\Observable\AnonymousObservable
$comparer	callable
Résultat	Rx\Observable\AnonymousObservable

distinctKey() public méthode

Variant of distinct that takes a key selector

public distinctKey ( callable $keySelector, callable $comparer = null ) : Rx\Observable\AnonymousObservable
$keySelector	callable
$comparer	callable
Résultat	Rx\Observable\AnonymousObservable

distinctUntilChanged() public méthode

A variant of distinct that only compares emitted items from the source Observable against their immediate predecessors in order to determine whether or not they are distinct.

public distinctUntilChanged ( callable $comparer = null ) : Rx\Observable\AnonymousObservable
$comparer	callable
Résultat	Rx\Observable\AnonymousObservable

distinctUntilKeyChanged() public méthode

Variant of distinctUntilChanged that takes a key selector and the comparer.

public distinctUntilKeyChanged ( callable $keySelector = null, callable $comparer = null ) : Rx\Observable\AnonymousObservable
$keySelector	callable
$comparer	callable
Résultat	Rx\Observable\AnonymousObservable

doOnCompleted() public méthode

public doOnCompleted ( callable $onCompleted ) : Rx\Observable\AnonymousObservable
$onCompleted	callable
Résultat	Rx\Observable\AnonymousObservable

doOnEach() public méthode

This method can be used for debugging, logging, etc. of query behavior by intercepting the message stream to run arbitrary actions for messages on the pipeline. When using doOnEach, it is important to note that the Observer may receive additional events after a stream has completed or errored (such as when useing a repeat or resubscribing). If you are using an Observable that extends the AbstractObservable, you will not receive these events. For this special case, use the DoObserver. doOnNext, doOnError, and doOnCompleted uses the DoObserver internally and will receive these additional events.

public doOnEach ( rx\ObserverInterface $observer ) : Rx\Observable\AnonymousObservable
$observer	rx\ObserverInterface
Résultat	Rx\Observable\AnonymousObservable

doOnError() public méthode

public doOnError ( callable $onError ) : Rx\Observable\AnonymousObservable
$onError	callable
Résultat	Rx\Observable\AnonymousObservable

doOnNext() public méthode

public doOnNext ( callable $onNext ) : Rx\Observable\AnonymousObservable
$onNext	callable
Résultat	Rx\Observable\AnonymousObservable

emptyObservable() public static méthode

Returns an empty observable sequence.

public static emptyObservable ( ) : Rx\Observable\EmptyObservable
Résultat	Rx\Observable\EmptyObservable	An observable sequence with no elements.

error() public static méthode

Returns an observable sequence that terminates with an exception.

public static error ( Exception $error ) : Rx\Observable\ErrorObservable
$error	Exception
Résultat	Rx\Observable\ErrorObservable	The observable sequence that terminates exceptionally with the specified exception object.

filter() public méthode

Emit only those items from an Observable that pass a predicate test.

public filter ( callable $predicate ) : Rx\Observable\AnonymousObservable
$predicate	callable
Résultat	Rx\Observable\AnonymousObservable

flatMap() public méthode

Projects each element of an observable sequence to an observable sequence and merges the resulting observable sequences into one observable sequence.

public flatMap ( callable $selector ) : Rx\Observable\AnonymousObservable
$selector	callable
Résultat	Rx\Observable\AnonymousObservable

flatMapLatest() public méthode

Transform the items emitted by an Observable into Observables, and mirror those items emitted by the most-recently transformed Observable. The flatMapLatest operator is similar to the flatMap and concatMap methods described above, however, rather than emitting all of the items emitted by all of the Observables that the operator generates by transforming items from the source Observable, flatMapLatest instead emits items from each such transformed Observable only until the next such Observable is emitted, then it ignores the previous one and begins emitting items emitted by the new one.

public flatMapLatest ( callable $selector, rx\SchedulerInterface $scheduler = null ) : Rx\Observable\AnonymousObservable
$selector	callable	- A transform function to apply to each source element.
$scheduler	rx\SchedulerInterface
Résultat	Rx\Observable\AnonymousObservable	- An observable sequence which transforms the items emitted by an Observable into Observables, and mirror those items emitted by the most-recently transformed Observable.

flatMapTo() public méthode

Projects each element of the source observable sequence to the other observable sequence and merges the resulting observable sequences into one observable sequence.

public flatMapTo ( rx\ObservableInterface $observable ) : Rx\Observable\AnonymousObservable
$observable	rx\ObservableInterface	- An an observable sequence to project each element from the source sequence onto.
Résultat	Rx\Observable\AnonymousObservable

fromArray() public static méthode

Converts an array to an observable sequence

public static fromArray ( array $array ) : Rx\Observable\ArrayObservable
$array	array
Résultat	Rx\Observable\ArrayObservable

fromIterator() public static méthode

Converts an Iterator into an observable sequence

public static fromIterator ( Iterator $iterator ) : IteratorObservable
$iterator	Iterator
Résultat	Rx\Observable\IteratorObservable

groupBy() public méthode

Groups the elements of an observable sequence according to a specified key selector function and comparer and selects the resulting elements by using a specified function.

public groupBy ( callable $keySelector, callable $elementSelector = null, callable $keySerializer = null ) : Rx\Observable\AnonymousObservable
$keySelector	callable
$elementSelector	callable
$keySerializer	callable
Résultat	Rx\Observable\AnonymousObservable

groupByUntil() public méthode

Groups the elements of an observable sequence according to a specified key selector function and comparer and selects the resulting elements by using a specified function.

public groupByUntil ( callable $keySelector, callable $elementSelector = null, callable $durationSelector = null, callable $keySerializer = null ) : Rx\Observable\AnonymousObservable
$keySelector	callable
$elementSelector	callable
$durationSelector	callable
$keySerializer	callable
Résultat	Rx\Observable\AnonymousObservable

interval() public static méthode

Returns an Observable that emits an infinite sequence of ascending integers starting at 0, with a constant interval of time of your choosing between emissions.

public static interval ( $interval, rx\SchedulerInterface \| null $scheduler = null ) : Rx\Observable\IntervalObservable
$interval		int Period for producing the values in the resulting sequence (specified as an integer denoting milliseconds).
$scheduler	rx\SchedulerInterface \| null
Résultat	Rx\Observable\IntervalObservable	An observable sequence that produces a value after each period.

just() public static méthode

Returns an observable sequence that contains a single element.

public static just ( mixed $value ) : Rx\Observable\AnonymousObservable
$value	mixed	Single element in the resulting observable sequence.
Résultat	Rx\Observable\AnonymousObservable	An observable sequence with the single element.

lift() public méthode

Lifts a function to the current Observable and returns a new Observable that when subscribed to will pass the values of the current Observable through the Operator function.

public lift ( callable $operatorFactory ) : Rx\Observable\AnonymousObservable
$operatorFactory	callable
Résultat	Rx\Observable\AnonymousObservable

map() public méthode

Takes a transforming function that operates on each element.

public map ( callable $selector ) : Rx\Observable\AnonymousObservable
$selector	callable
Résultat	Rx\Observable\AnonymousObservable

mapTo() public méthode

Maps every value to the same value every time

public mapTo ( $value ) : Rx\Observable\AnonymousObservable
$value
Résultat	Rx\Observable\AnonymousObservable

mapWithIndex() public méthode

Maps operator variant that calls the map selector with the index and value

public mapWithIndex ( callable $selector ) : Rx\Observable\AnonymousObservable
$selector	callable
Résultat	Rx\Observable\AnonymousObservable

materialize() public méthode

Materializes the implicit notifications of an observable sequence as explicit notifications.

public materialize ( ) : Rx\Observable\AnonymousObservable
Résultat	Rx\Observable\AnonymousObservable

max() public méthode

Returns the maximum value in an observable sequence according to the specified comparer.

public max ( callable $comparer = null ) : Rx\Observable\AnonymousObservable
$comparer	callable
Résultat	Rx\Observable\AnonymousObservable

merge() public méthode

Combine an Observable together with another Observable by merging their emissions into a single Observable.

public merge ( rx\ObservableInterface $otherObservable ) : Rx\Observable\AnonymousObservable
$otherObservable	rx\ObservableInterface
Résultat	Rx\Observable\AnonymousObservable

mergeAll() public static méthode

Merges an observable sequence of observables into an observable sequence.

public static mergeAll ( rx\ObservableInterface $sources ) : Rx\Observable\AnonymousObservable
$sources	rx\ObservableInterface
Résultat	Rx\Observable\AnonymousObservable

min() public méthode

Returns the minimum value in an observable sequence according to the specified comparer.

public min ( callable $comparer = null ) : Rx\Observable\AnonymousObservable
$comparer	callable
Résultat	Rx\Observable\AnonymousObservable

multicast() public méthode

Multicasts the source sequence notifications through an instantiated subject into all uses of the sequence within a selector function. Each subscription to the resulting sequence causes a separate multicast invocation, exposing the sequence resulting from the selector function's invocation. For specializations with fixed subject types, see Publish, PublishLast, and Replay.

public multicast ( Rx\Subject\Subject $subject, null $selector = null, rx\SchedulerInterface $scheduler = null ) : Rx\Observable\ConnectableObservable \| Rx\Observable\MulticastObservable
$subject	Rx\Subject\Subject
$selector	null
$scheduler	rx\SchedulerInterface
Résultat	Rx\Observable\ConnectableObservable \| Rx\Observable\MulticastObservable

multicastWithSelector() public méthode

For specializations with fixed subject types, see Publish, PublishLast, and Replay.

public multicastWithSelector ( callable $subjectSelector, null $selector = null ) : Rx\Observable\ConnectableObservable \| Rx\Observable\MulticastObservable
$subjectSelector	callable
$selector	null
Résultat	Rx\Observable\ConnectableObservable \| Rx\Observable\MulticastObservable

never() public static méthode

Returns a non-terminating observable sequence, which can be used to denote an infinite duration.

public static never ( ) : Rx\Observable\NeverObservable
Résultat	Rx\Observable\NeverObservable	An observable sequence whose observers will never get called.

partition() public méthode

The first will trigger observations for those values for which the predicate returns true. The second will trigger observations for those values where the predicate returns false. The predicate is executed once for each subscribed observer. Both also propagate all error observations arising from the source and each completes when the source completes.

public partition ( callable $predicate ) : Rx\Observable\AnonymousObservable[]
$predicate	callable
Résultat	Rx\Observable\AnonymousObservable[]

pluck() public méthode

Returns an Observable containing the value of a specified array index (if array) or property (if object) from all elements in the Observable sequence. If a property can't be resolved the observable will error.

public pluck ( mixed $property ) : Observable
$property	mixed
Résultat	Observable

publish() public méthode

This operator is a specialization of Multicast using a regular Subject.

public publish ( callable $selector = null ) : Rx\Observable\ConnectableObservable \| Rx\Observable\MulticastObservable
$selector	callable
Résultat	Rx\Observable\ConnectableObservable \| Rx\Observable\MulticastObservable

publishLast() public méthode

This operator is a specialization of Multicast using a AsyncSubject.

public publishLast ( callable $selector = null ) : Rx\Observable\ConnectableObservable \| Rx\Observable\MulticastObservable
$selector	callable
Résultat	Rx\Observable\ConnectableObservable \| Rx\Observable\MulticastObservable

publishValue() public méthode

This operator is a specialization of Multicast using a BehaviorSubject.

public publishValue ( mixed $initialValue, callable $selector = null ) : Rx\Observable\ConnectableObservable \| Rx\Observable\MulticastObservable
$initialValue	mixed
$selector	callable
Résultat	Rx\Observable\ConnectableObservable \| Rx\Observable\MulticastObservable

race() public static méthode

Propagates the observable sequence that reacts first. Also known as 'amb'.

public static race ( array $observables ) : Rx\Observable\AnonymousObservable
$observables	array
Résultat	Rx\Observable\AnonymousObservable

range() public static méthode

Generates an observable sequence of integral numbers within a specified range, using the specified scheduler to send out observer messages.

public static range ( $start, $count, rx\SchedulerInterface $scheduler = null ) : RangeObservable
$start
$count
$scheduler	rx\SchedulerInterface
Résultat	Rx\Observable\RangeObservable

reduce() public méthode

The specified seed value is used as the initial accumulator value.

public reduce ( callable $accumulator, mixed $seed = null ) : Rx\Observable\AnonymousObservable
$accumulator	callable	- An accumulator function to be invoked on each element.
$seed	mixed	[optional] - The initial accumulator value.
Résultat	Rx\Observable\AnonymousObservable	- An observable sequence containing a single element with the final accumulator value.

removeObserver() public méthode

public removeObserver ( rx\ObserverInterface $observer )
$observer	rx\ObserverInterface

repeat() public méthode

Generates an observable sequence that repeats the given element the specified number of times.

public repeat ( integer $count ) : Rx\Observable\AnonymousObservable \| Rx\Observable\EmptyObservable
$count	integer
Résultat	Rx\Observable\AnonymousObservable \| Rx\Observable\EmptyObservable

repeatWhen() public méthode

An onCompleted notification from the source will result in the emission of a count item to the Observable provided as an argument to the notificationHandler function. If that Observable calls onComplete or onError then repeatWhen will call onCompleted or onError on the child subscription. Otherwise, this Observable will resubscribe to the source observable.

public repeatWhen ( callable $notifier ) : Rx\Observable\AnonymousObservable \| Rx\Observable\EmptyObservable
$notifier	callable
Résultat	Rx\Observable\AnonymousObservable \| Rx\Observable\EmptyObservable

replay() public méthode

This operator is a specialization of Multicast using a ReplaySubject.

public replay ( callable $selector = null, integer \| null $bufferSize = null, integer \| null $windowSize = null, rx\SchedulerInterface $scheduler = null ) : Rx\Observable\ConnectableObservable \| Rx\Observable\MulticastObservable
$selector	callable
$bufferSize	integer \| null
$windowSize	integer \| null
$scheduler	rx\SchedulerInterface
Résultat	Rx\Observable\ConnectableObservable \| Rx\Observable\MulticastObservable

retry() public méthode

If the retry count is not specified, it retries indefinitely. Note if you encounter an error and want it to retry once, then you must use ->retry(2).

public retry ( integer $retryCount ) : Rx\Observable\AnonymousObservable
$retryCount	integer
Résultat	Rx\Observable\AnonymousObservable

retryWhen() public méthode

Repeats the source observable sequence on error when the notifier emits a next value. If the source observable errors and the notifier completes, it will complete the source sequence.

public retryWhen ( callable $notifier ) : Rx\Observable\AnonymousObservable
$notifier	callable
Résultat	Rx\Observable\AnonymousObservable

scan() public méthode

The optional seed value is used as the initial accumulator value.

public scan ( callable $accumulator, null $seed = null ) : Rx\Observable\AnonymousObservable
$accumulator	callable
$seed	null
Résultat	Rx\Observable\AnonymousObservable

select() public méthode

Alias for Map

public select ( callable $selector ) : Rx\Observable\AnonymousObservable
$selector	callable
Résultat	Rx\Observable\AnonymousObservable

selectMany() public méthode

Alias for flatMap

public selectMany ( $selector ) : Rx\Observable\AnonymousObservable
$selector
Résultat	Rx\Observable\AnonymousObservable

shareReplay() public méthode

This operator is a specialization of replay which creates a subscription when the number of observers goes from zero to one, then shares that subscription with all subsequent observers until the number of observers returns to zero, at which point the subscription is disposed.

public shareReplay ( integer $bufferSize, integer $windowSize = null, rx\SchedulerInterface $scheduler = null ) : Rx\Observable\RefCountObservable
$bufferSize	integer
$windowSize	integer
$scheduler	rx\SchedulerInterface
Résultat	Rx\Observable\RefCountObservable

shareValue() public méthode

This operator is a specialization of publishValue which creates a subscription when the number of observers goes from zero to one, then shares that subscription with all subsequent observers until the number of observers returns to zero, at which point the subscription is disposed.

public shareValue ( $initialValue ) : Rx\Observable\RefCountObservable
$initialValue
Résultat	Rx\Observable\RefCountObservable

skip() public méthode

public skip ( integer $count ) : Rx\Observable\AnonymousObservable
$count	integer
Résultat	Rx\Observable\AnonymousObservable

skipLast() public méthode

This operator accumulates a queue with a length enough to store the first count elements. As more elements are received, elements are taken from the front of the queue and produced on the result sequence. This causes elements to be delayed.

public skipLast ( integer $count ) : Rx\Observable\AnonymousObservable
$count	integer	Number of elements to bypass at the end of the source sequence.
Résultat	Rx\Observable\AnonymousObservable	An observable sequence containing the source sequence elements except for the bypassed ones at the end.

skipUntil() public méthode

Returns the values from the source observable sequence only after the other observable sequence produces a value.

public skipUntil ( rx\ObservableInterface $other ) : Rx\Observable\AnonymousObservable
$other	rx\ObservableInterface	The observable sequence that triggers propagation of elements of the source sequence.
Résultat	Rx\Observable\AnonymousObservable	An observable sequence containing the elements of the source sequence starting from the point the other sequence triggered propagation.

skipWhile() public méthode

Bypasses elements in an observable sequence as long as a specified condition is true and then returns the remaining elements.

public skipWhile ( callable $predicate ) : Rx\Observable\AnonymousObservable
$predicate	callable	A function to test each element for a condition.
Résultat	Rx\Observable\AnonymousObservable	An observable sequence that contains the elements from the input sequence starting at the first element in the linear series that does not pass the test specified by predicate.

skipWhileWithIndex() public méthode

Bypasses elements in an observable sequence as long as a specified condition is true and then returns the remaining elements. The element's index is used in the logic of the predicate function.

public skipWhileWithIndex ( callable $predicate ) : Rx\Observable\AnonymousObservable
$predicate	callable	A function to test each element for a condition; the first parameter of the function represents the index of the source element, the second parameter is the value.
Résultat	Rx\Observable\AnonymousObservable	An observable sequence that contains the elements from the input sequence starting at the first element in the linear series that does not pass the test specified by predicate.

start() public static méthode

Invokes the specified function asynchronously on the specified scheduler, surfacing the result through an observable sequence.

public static start ( callable $action, rx\SchedulerInterface $scheduler = null ) : Rx\Observable\AnonymousObservable
$action	callable
$scheduler	rx\SchedulerInterface
Résultat	Rx\Observable\AnonymousObservable

startWith() public méthode

Prepends a value to an observable sequence with an argument of a signal value to prepend.

public startWith ( mixed $startValue ) : Rx\Observable\AnonymousObservable
$startValue	mixed
Résultat	Rx\Observable\AnonymousObservable

startWithArray() public méthode

Prepends a sequence of values to an observable sequence with an argument of an array of values to prepend.

public startWithArray ( array $startArray ) : Rx\Observable\AnonymousObservable
$startArray	array
Résultat	Rx\Observable\AnonymousObservable

subscribeCallback() public méthode

public subscribeCallback ( callable $onNext = null, callable $onError = null, callable $onCompleted = null, rx\SchedulerInterface $scheduler = null )
$onNext	callable
$onError	callable
$onCompleted	callable
$scheduler	rx\SchedulerInterface

subscribeOn() public méthode

Wraps the source sequence in order to run its subscription and unsubscription logic on the specified scheduler.

public subscribeOn ( rx\SchedulerInterface $scheduler ) : Rx\Observable\AnonymousObservable
$scheduler	rx\SchedulerInterface
Résultat	Rx\Observable\AnonymousObservable

sum() public méthode

Computes the sum of a sequence of values

public sum ( ) : Rx\Observable\AnonymousObservable
Résultat	Rx\Observable\AnonymousObservable

switchFirst() public méthode

This operator is similar to concatAll() except that it will not hold onto Observables that come in before the current one is finished completed.

public switchFirst ( ) : Rx\Observable\AnonymousObservable
Résultat	Rx\Observable\AnonymousObservable	- An Observable sequence that is the result of concatenating non-overlapping items emitted by an Observable of Observables.

switchLatest() public méthode

Transforms an observable sequence of observable sequences into an observable sequence producing values only from the most recent observable sequence.

public switchLatest ( rx\SchedulerInterface $scheduler = null ) : Rx\Observable\AnonymousObservable
$scheduler	rx\SchedulerInterface
Résultat	Rx\Observable\AnonymousObservable	- The observable sequence that at any point in time produces the elements of the most recent inner observable sequence that has been received.

take() public méthode

Returns a specified number of contiguous elements from the start of an observable sequence

public take ( integer $count ) : Rx\Observable\AnonymousObservable \| Rx\Observable\EmptyObservable
$count	integer
Résultat	Rx\Observable\AnonymousObservable \| Rx\Observable\EmptyObservable

takeLast() public méthode

Returns a specified number of contiguous elements from the end of an observable sequence.

public takeLast ( $count ) : Rx\Observable\AnonymousObservable
$count
Résultat	Rx\Observable\AnonymousObservable

takeUntil() public méthode

Returns the values from the source observable sequence until the other observable sequence produces a value.

public takeUntil ( rx\ObservableInterface $other ) : Rx\Observable\AnonymousObservable
$other	rx\ObservableInterface	- other Observable sequence that terminates propagation of elements of the source sequence.
Résultat	Rx\Observable\AnonymousObservable	- An observable sequence containing the elements of the source sequence up to the point the other sequence interrupted further propagation.

takeWhile() public méthode

Returns elements from an observable sequence as long as a specified condition is true. It takes as a parameter a a callback to test each source element for a condition. The callback predicate is called with the value of the element.

public takeWhile ( callable $predicate ) : Rx\Observable\AnonymousObservable
$predicate	callable
Résultat	Rx\Observable\AnonymousObservable

takeWhileWithIndex() public méthode

public takeWhileWithIndex ( callable $predicate ) : Rx\Observable\AnonymousObservable
$predicate	callable
Résultat	Rx\Observable\AnonymousObservable

throttle() public méthode

If items are emitted on the source observable prior to the expiration of the time period, the last item emitted on the source observable will be emitted.

public throttle ( $throttleDuration, null $scheduler = null ) : Rx\Observable\AnonymousObservable
$throttleDuration
$scheduler	null
Résultat	Rx\Observable\AnonymousObservable

timeout() public méthode

public timeout ( $timeout, rx\ObservableInterface $timeoutObservable = null, rx\SchedulerInterface $scheduler = null ) : Rx\Observable\AnonymousObservable
$timeout
$timeoutObservable	rx\ObservableInterface
$scheduler	rx\SchedulerInterface
Résultat	Rx\Observable\AnonymousObservable

timer() public static méthode

Returns an observable sequence that produces a value after dueTime has elapsed.

public static timer ( integer $dueTime, rx\SchedulerInterface $scheduler = null ) : TimerObservable
$dueTime	integer	- milliseconds
$scheduler	rx\SchedulerInterface
Résultat	Rx\Observable\TimerObservable

timestamp() public méthode

Records the timestamp for each value in an observable sequence.

public timestamp ( rx\SchedulerInterface $scheduler = null ) : Rx\Observable\AnonymousObservable
$scheduler	rx\SchedulerInterface
Résultat	Rx\Observable\AnonymousObservable

toArray() public méthode

Creates an observable sequence containing a single element which is an array containing all the elements of the source sequence.

public toArray ( ) : Rx\Observable\AnonymousObservable
Résultat	Rx\Observable\AnonymousObservable	An observable sequence containing a single element with a list containing all the elements of the source sequence.

where() public méthode

Alias for filter

public where ( callable $predicate ) : Rx\Observable\AnonymousObservable
$predicate	callable
Résultat	Rx\Observable\AnonymousObservable

zip() public méthode

Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index. If the result selector function is omitted, a list with the elements of the observable sequences at corresponding indexes will be yielded.

public zip ( array $observables, callable $selector = null ) : Rx\Observable\AnonymousObservable
$observables	array
$selector	callable
Résultat	Rx\Observable\AnonymousObservable

Property Details

$observers protected_oe property

protected $observers

$started protected_oe property

protected $started

public share ( ) : Rx\Observable\RefCountObservable
Résultat	Rx\Observable\RefCountObservable	An observable sequence that contains the elements of a sequence produced by multicasting the source sequence.