PHP 클래스 Rx\Observable

상속: implements rx\ObservableInterface

보호된 프로퍼티들

프로퍼티	타입	설명
$observers
$started

공개 메소드들

메소드	설명
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.

메소드 상세

asObservable() 공개 메소드

Hides the identity of an observable sequence.

public asObservable ( ) : Rx\Observable\AnonymousObservable
리턴	Rx\Observable\AnonymousObservable	An observable sequence that hides the identity of the source sequence.

average() 공개 메소드

Computes the average of an observable sequence of values.

public average ( ) : Rx\Observable\AnonymousObservable
리턴	Rx\Observable\AnonymousObservable

bufferWithCount() 공개 메소드

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
리턴	Rx\Observable\AnonymousObservable

catchError() 공개 메소드

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

public catchError ( callable $selector ) : Rx\Observable\AnonymousObservable
$selector	callable
리턴	Rx\Observable\AnonymousObservable

combineLatest() 공개 메소드

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
리턴	Rx\Observable\AnonymousObservable

concat() 공개 메소드

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

public concat ( rx\ObservableInterface $observable ) : Rx\Observable\AnonymousObservable
$observable	rx\ObservableInterface
리턴	Rx\Observable\AnonymousObservable

concatAll() 공개 메소드

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

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

concatMap() 공개 메소드

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
리턴	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() 공개 메소드

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
리턴	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() 공개 메소드

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
리턴	Rx\Observable\AnonymousObservable

create() 공개 정적인 메소드

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.
리턴	Rx\Observable\AnonymousObservable	The observable sequence with the specified implementation for the subscribe method.

defaultIfEmpty() 공개 메소드

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

public defaultIfEmpty ( rx\ObservableInterface $observable ) : Rx\Observable\AnonymousObservable
$observable	rx\ObservableInterface
리턴	Rx\Observable\AnonymousObservable

defer() 공개 정적인 메소드

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
리턴	Rx\Observable\AnonymousObservable

delay() 공개 메소드

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
리턴	Rx\Observable\AnonymousObservable

dematerialize() 공개 메소드

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

public dematerialize ( ) : Rx\Observable\AnonymousObservable
리턴	Rx\Observable\AnonymousObservable

distinct() 공개 메소드

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
리턴	Rx\Observable\AnonymousObservable

distinctKey() 공개 메소드

Variant of distinct that takes a key selector

public distinctKey ( callable $keySelector, callable $comparer = null ) : Rx\Observable\AnonymousObservable
$keySelector	callable
$comparer	callable
리턴	Rx\Observable\AnonymousObservable

distinctUntilChanged() 공개 메소드

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
리턴	Rx\Observable\AnonymousObservable

distinctUntilKeyChanged() 공개 메소드

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
리턴	Rx\Observable\AnonymousObservable

doOnCompleted() 공개 메소드

public doOnCompleted ( callable $onCompleted ) : Rx\Observable\AnonymousObservable
$onCompleted	callable
리턴	Rx\Observable\AnonymousObservable

doOnEach() 공개 메소드

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
리턴	Rx\Observable\AnonymousObservable

doOnError() 공개 메소드

public doOnError ( callable $onError ) : Rx\Observable\AnonymousObservable
$onError	callable
리턴	Rx\Observable\AnonymousObservable

doOnNext() 공개 메소드

public doOnNext ( callable $onNext ) : Rx\Observable\AnonymousObservable
$onNext	callable
리턴	Rx\Observable\AnonymousObservable

emptyObservable() 공개 정적인 메소드

Returns an empty observable sequence.

public static emptyObservable ( ) : Rx\Observable\EmptyObservable
리턴	Rx\Observable\EmptyObservable	An observable sequence with no elements.

error() 공개 정적인 메소드

Returns an observable sequence that terminates with an exception.

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

filter() 공개 메소드

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

public filter ( callable $predicate ) : Rx\Observable\AnonymousObservable
$predicate	callable
리턴	Rx\Observable\AnonymousObservable

flatMap() 공개 메소드

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
리턴	Rx\Observable\AnonymousObservable

flatMapLatest() 공개 메소드

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
리턴	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() 공개 메소드

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.
리턴	Rx\Observable\AnonymousObservable

fromArray() 공개 정적인 메소드

Converts an array to an observable sequence

public static fromArray ( array $array ) : Rx\Observable\ArrayObservable
$array	array
리턴	Rx\Observable\ArrayObservable

fromIterator() 공개 정적인 메소드

Converts an Iterator into an observable sequence

public static fromIterator ( Iterator $iterator ) : IteratorObservable
$iterator	Iterator
리턴	Rx\Observable\IteratorObservable

groupBy() 공개 메소드

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
리턴	Rx\Observable\AnonymousObservable

groupByUntil() 공개 메소드

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
리턴	Rx\Observable\AnonymousObservable

interval() 공개 정적인 메소드

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
리턴	Rx\Observable\IntervalObservable	An observable sequence that produces a value after each period.

just() 공개 정적인 메소드

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.
리턴	Rx\Observable\AnonymousObservable	An observable sequence with the single element.

lift() 공개 메소드

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
리턴	Rx\Observable\AnonymousObservable

map() 공개 메소드

Takes a transforming function that operates on each element.

public map ( callable $selector ) : Rx\Observable\AnonymousObservable
$selector	callable
리턴	Rx\Observable\AnonymousObservable

mapTo() 공개 메소드

Maps every value to the same value every time

public mapTo ( $value ) : Rx\Observable\AnonymousObservable
$value
리턴	Rx\Observable\AnonymousObservable

mapWithIndex() 공개 메소드

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

public mapWithIndex ( callable $selector ) : Rx\Observable\AnonymousObservable
$selector	callable
리턴	Rx\Observable\AnonymousObservable

materialize() 공개 메소드

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

public materialize ( ) : Rx\Observable\AnonymousObservable
리턴	Rx\Observable\AnonymousObservable

max() 공개 메소드

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

public max ( callable $comparer = null ) : Rx\Observable\AnonymousObservable
$comparer	callable
리턴	Rx\Observable\AnonymousObservable

merge() 공개 메소드

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
리턴	Rx\Observable\AnonymousObservable

mergeAll() 공개 정적인 메소드

Merges an observable sequence of observables into an observable sequence.

public static mergeAll ( rx\ObservableInterface $sources ) : Rx\Observable\AnonymousObservable
$sources	rx\ObservableInterface
리턴	Rx\Observable\AnonymousObservable

min() 공개 메소드

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

public min ( callable $comparer = null ) : Rx\Observable\AnonymousObservable
$comparer	callable
리턴	Rx\Observable\AnonymousObservable

multicast() 공개 메소드

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
리턴	Rx\Observable\ConnectableObservable \| Rx\Observable\MulticastObservable

multicastWithSelector() 공개 메소드

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
리턴	Rx\Observable\ConnectableObservable \| Rx\Observable\MulticastObservable

never() 공개 정적인 메소드

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

public static never ( ) : Rx\Observable\NeverObservable
리턴	Rx\Observable\NeverObservable	An observable sequence whose observers will never get called.

partition() 공개 메소드

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
리턴	Rx\Observable\AnonymousObservable[]

pluck() 공개 메소드

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
리턴	Observable

publish() 공개 메소드

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

public publish ( callable $selector = null ) : Rx\Observable\ConnectableObservable \| Rx\Observable\MulticastObservable
$selector	callable
리턴	Rx\Observable\ConnectableObservable \| Rx\Observable\MulticastObservable

publishLast() 공개 메소드

This operator is a specialization of Multicast using a AsyncSubject.

public publishLast ( callable $selector = null ) : Rx\Observable\ConnectableObservable \| Rx\Observable\MulticastObservable
$selector	callable
리턴	Rx\Observable\ConnectableObservable \| Rx\Observable\MulticastObservable

publishValue() 공개 메소드

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
리턴	Rx\Observable\ConnectableObservable \| Rx\Observable\MulticastObservable

race() 공개 정적인 메소드

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

public static race ( array $observables ) : Rx\Observable\AnonymousObservable
$observables	array
리턴	Rx\Observable\AnonymousObservable

range() 공개 정적인 메소드

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
리턴	Rx\Observable\RangeObservable

reduce() 공개 메소드

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.
리턴	Rx\Observable\AnonymousObservable	- An observable sequence containing a single element with the final accumulator value.

removeObserver() 공개 메소드

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

repeat() 공개 메소드

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
리턴	Rx\Observable\AnonymousObservable \| Rx\Observable\EmptyObservable

repeatWhen() 공개 메소드

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
리턴	Rx\Observable\AnonymousObservable \| Rx\Observable\EmptyObservable

replay() 공개 메소드

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
리턴	Rx\Observable\ConnectableObservable \| Rx\Observable\MulticastObservable

retry() 공개 메소드

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
리턴	Rx\Observable\AnonymousObservable

retryWhen() 공개 메소드

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
리턴	Rx\Observable\AnonymousObservable

scan() 공개 메소드

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
리턴	Rx\Observable\AnonymousObservable

select() 공개 메소드

Alias for Map

public select ( callable $selector ) : Rx\Observable\AnonymousObservable
$selector	callable
리턴	Rx\Observable\AnonymousObservable

selectMany() 공개 메소드

Alias for flatMap

public selectMany ( $selector ) : Rx\Observable\AnonymousObservable
$selector
리턴	Rx\Observable\AnonymousObservable

shareReplay() 공개 메소드

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
리턴	Rx\Observable\RefCountObservable

shareValue() 공개 메소드

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
리턴	Rx\Observable\RefCountObservable

skip() 공개 메소드

public skip ( integer $count ) : Rx\Observable\AnonymousObservable
$count	integer
리턴	Rx\Observable\AnonymousObservable

skipLast() 공개 메소드

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.
리턴	Rx\Observable\AnonymousObservable	An observable sequence containing the source sequence elements except for the bypassed ones at the end.

skipUntil() 공개 메소드

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.
리턴	Rx\Observable\AnonymousObservable	An observable sequence containing the elements of the source sequence starting from the point the other sequence triggered propagation.

skipWhile() 공개 메소드

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.
리턴	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() 공개 메소드

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.
리턴	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() 공개 정적인 메소드

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
리턴	Rx\Observable\AnonymousObservable

startWith() 공개 메소드

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
리턴	Rx\Observable\AnonymousObservable

startWithArray() 공개 메소드

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
리턴	Rx\Observable\AnonymousObservable

subscribeCallback() 공개 메소드

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() 공개 메소드

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
리턴	Rx\Observable\AnonymousObservable

sum() 공개 메소드

Computes the sum of a sequence of values

public sum ( ) : Rx\Observable\AnonymousObservable
리턴	Rx\Observable\AnonymousObservable

switchFirst() 공개 메소드

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
리턴	Rx\Observable\AnonymousObservable	- An Observable sequence that is the result of concatenating non-overlapping items emitted by an Observable of Observables.

switchLatest() 공개 메소드

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
리턴	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() 공개 메소드

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
리턴	Rx\Observable\AnonymousObservable \| Rx\Observable\EmptyObservable

takeLast() 공개 메소드

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

public takeLast ( $count ) : Rx\Observable\AnonymousObservable
$count
리턴	Rx\Observable\AnonymousObservable

takeUntil() 공개 메소드

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.
리턴	Rx\Observable\AnonymousObservable	- An observable sequence containing the elements of the source sequence up to the point the other sequence interrupted further propagation.

takeWhile() 공개 메소드

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
리턴	Rx\Observable\AnonymousObservable

takeWhileWithIndex() 공개 메소드

public takeWhileWithIndex ( callable $predicate ) : Rx\Observable\AnonymousObservable
$predicate	callable
리턴	Rx\Observable\AnonymousObservable

throttle() 공개 메소드

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
리턴	Rx\Observable\AnonymousObservable

timeout() 공개 메소드

public timeout ( $timeout, rx\ObservableInterface $timeoutObservable = null, rx\SchedulerInterface $scheduler = null ) : Rx\Observable\AnonymousObservable
$timeout
$timeoutObservable	rx\ObservableInterface
$scheduler	rx\SchedulerInterface
리턴	Rx\Observable\AnonymousObservable

timer() 공개 정적인 메소드

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
리턴	Rx\Observable\TimerObservable

timestamp() 공개 메소드

Records the timestamp for each value in an observable sequence.

public timestamp ( rx\SchedulerInterface $scheduler = null ) : Rx\Observable\AnonymousObservable
$scheduler	rx\SchedulerInterface
리턴	Rx\Observable\AnonymousObservable

toArray() 공개 메소드

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
리턴	Rx\Observable\AnonymousObservable	An observable sequence containing a single element with a list containing all the elements of the source sequence.

where() 공개 메소드

Alias for filter

public where ( callable $predicate ) : Rx\Observable\AnonymousObservable
$predicate	callable
리턴	Rx\Observable\AnonymousObservable

zip() 공개 메소드

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
리턴	Rx\Observable\AnonymousObservable

프로퍼티 상세

$observers 보호되어 있는 프로퍼티

protected $observers

$started 보호되어 있는 프로퍼티

protected $started

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