Packages that use Function

• Uses of Function in rx

  Subinterfaces of Function in rx

  Modifier and Type	Interface and Description
  static interface	Observable.OnSubscribe<T> Invoked when Obserable.subscribe is called.
  static interface	Observable.Operator<R,T> Operator function for lifting into an Observable.
  static interface	Observable.Transformer<T,R> Transformer function used by Observable.compose(rx.Observable.Transformer<? super T, ? extends R>).

• Uses of Function in rx.functions

  Subinterfaces of Function in rx.functions

  Modifier and Type	Interface and Description
  interface	Action All Action interfaces extend from this.
  interface	Action0 A zero-argument action.
  interface	Action1<T1> A one-argument action.
  interface	Action2<T1,T2> A two-argument action.
  interface	Action3<T1,T2,T3> A three-argument action.
  interface	Action4<T1,T2,T3,T4> A four-argument action.
  interface	Action5<T1,T2,T3,T4,T5> A five-argument action.
  interface	Action6<T1,T2,T3,T4,T5,T6> A six-argument action.
  interface	Action7<T1,T2,T3,T4,T5,T6,T7> A seven-argument action.
  interface	Action8<T1,T2,T3,T4,T5,T6,T7,T8> An eight-argument action.
  interface	Action9<T1,T2,T3,T4,T5,T6,T7,T8,T9> A nine-argument action.
  interface	ActionN A vector-argument action.
  interface	Func0<R> Represents a function with zero arguments.
  interface	Func1<T1,R> Represents a function with one argument.
  interface	Func2<T1,T2,R> Represents a function with two arguments.
  interface	Func3<T1,T2,T3,R> Represents a function with three arguments.
  interface	Func4<T1,T2,T3,T4,R> Represents a function with four arguments.
  interface	Func5<T1,T2,T3,T4,T5,R> Represents a function with five arguments.
  interface	Func6<T1,T2,T3,T4,T5,T6,R> Represents a function with six arguments.
  interface	Func7<T1,T2,T3,T4,T5,T6,T7,R> Represents a function with seven arguments.
  interface	Func8<T1,T2,T3,T4,T5,T6,T7,T8,R> Represents a function with eight arguments.
  interface	Func9<T1,T2,T3,T4,T5,T6,T7,T8,T9,R> Represents a function with nine arguments.
  interface	FuncN<R> Represents a vector-argument function.

• Uses of Function in rx.internal.operators

  Classes in rx.internal.operators that implement Function

  Modifier and Type	Class and Description
  class	OnSubscribeAmb<T> Given multiple Observables, propagates the one that first emits an item.
  class	OnSubscribeCache<T> This method has similar behavior to Observable.replay() except that this auto-subscribes to the source Observable rather than returning a connectable Observable.
  class	OnSubscribeCombineLatest<T,R> Returns an Observable that combines the emissions of multiple source observables.
  class	OnSubscribeDefer<T> Do not create the Observable until an Observer subscribes; create a fresh Observable on each subscription.
  class	OnSubscribeDelaySubscription<T> Delays the subscription to the source by the given amount, running on the given scheduler.
  class	OnSubscribeDelaySubscriptionWithSelector<T,U> Delays the subscription until the Observable emits an event.
  class	OnSubscribeFromIterable<T> Converts an Iterable sequence into an Observable.
  class	OnSubscribeGroupJoin<T1,T2,D1,D2,R> Corrrelates two sequences when they overlap and groups the results.
  class	OnSubscribeJoin<TLeft,TRight,TLeftDuration,TRightDuration,R> Correlates the elements of two sequences based on overlapping durations.
  class	OnSubscribeMulticastSelector<TInput,TIntermediate,TResult> Returns an observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function.
  class	OnSubscribeRange Emit ints from start to end inclusive.
  class	OnSubscribeRedo<T>
  static class	OnSubscribeRedo.RedoFinite
  static class	OnSubscribeRedo.RetryWithPredicate
  class	OnSubscribeRefCount<T> Returns an observable sequence that stays connected to the source as long as there is at least one subscription to the observable sequence.
  class	OnSubscribeTimerOnce Timer that emits a single 0L and completes after the specified time.
  class	OnSubscribeTimerPeriodically Emit 0L after the initial period and ever increasing number after each period.
  class	OnSubscribeUsing<T,Resource> Constructs an observable sequence that depends on a resource object.
  class	OperatorAll<T> Returns an Observable that emits a Boolean that indicates whether all items emitted by an Observable satisfy a condition.
  class	OperatorAny<T> Returns an Observable that emits true if any element of an observable sequence satisfies a condition, otherwise false.
  class	OperatorAsObservable<T> Hides the identity of another observable.
  class	OperatorBufferWithSingleObservable<T,TClosing> This operation takes values from the specified Observable source and stores them in a buffer until the Observable constructed using the Func0 argument, produces a value.
  class	OperatorBufferWithSize<T> This operation takes values from the specified Observable source and stores them in all active chunks until the buffer contains a specified number of elements.
  class	OperatorBufferWithStartEndObservable<T,TOpening,TClosing> This operation takes values from the specified Observable source and stores them in the currently active chunks.
  class	OperatorBufferWithTime<T> This operation takes values from the specified Observable source and stores them in a buffer.
  class	OperatorCast<T,R> Converts the elements of an observable sequence to the specified type.
  class	OperatorConcat<T> Returns an Observable that emits the items emitted by two or more Observables, one after the other.
  class	OperatorDebounceWithSelector<T,U> Delay the emission via another observable if no new source appears in the meantime.
  class	OperatorDebounceWithTime<T> This operation filters out events which are published too quickly in succession.
  class	OperatorDefaultIfEmpty<T> Returns the elements of the specified sequence or the specified default value in a singleton sequence if the sequence is empty.
  class	OperatorDelay<T> Delays the emission of onNext events by a given amount of time.
  class	OperatorDelayWithSelector<T,V> Delay the subscription and emission of the source items by a per-item observable that fires its first element.
  class	OperatorDematerialize<T> Reverses the effect of OperatorMaterialize by transforming the Notification objects emitted by a source Observable into the items or notifications they represent.
  class	OperatorDistinct<T,U> Returns an Observable that emits all distinct items emitted by the source.
  class	OperatorDistinctUntilChanged<T,U> Returns an Observable that emits all sequentially distinct items emitted by the source.
  class	OperatorDoOnEach<T> Converts the elements of an observable sequence to the specified type.
  class	OperatorDoOnSubscribe<T> This operator modifies an Observable so a given action is invoked when the Observable is subscribed.
  class	OperatorDoOnUnsubscribe<T> This operator modifies an Observable so a given action is invoked when the Observable is unsubscribed.
  class	OperatorElementAt<T> Returns the element at a specified index in a sequence.
  class	OperatorFilter<T> Filters an Observable by discarding any items it emits that do not meet some test.
  class	OperatorFinally<T> Registers an action to be called after an Observable invokes onComplete or onError.
  class	OperatorGroupBy<T,K,R> Groups the items emitted by an Observable according to a specified criterion, and emits these grouped items as Observables, one Observable per group.
  class	OperatorMap<T,R> Applies a function of your choosing to every item emitted by an Observable, and emits the results of this transformation as a new Observable.
  class	OperatorMapNotification<T,R> Applies a function of your choosing to every item emitted by an Observable, and emits the results of this transformation as a new Observable.
  class	OperatorMapPair<T,U,R> An Observable.Operator that pairs up items emitted by a source Observable with the sequence of items emitted by the Observable that is derived from each item by means of a selector, and emits the results of this pairing.
  class	OperatorMaterialize<T> Turns all of the notifications from an Observable into onNext emissions, and marks them with their original notification types within Notification objects.
  class	OperatorMerge<T> Flattens a list of Observables into one Observable, without any transformation.
  class	OperatorMergeDelayError<T> This behaves like OperatorMerge except that if any of the merged Observables notify of an error via onError, mergeDelayError will refrain from propagating that error notification until all of the merged Observables have finished emitting items.
  class	OperatorMergeMaxConcurrent<T> Flattens a list of Observables into one Observable sequence, without any transformation.
  class	OperatorObserveOn<T> Delivers events on the specified Scheduler asynchronously via an unbounded buffer.
  class	OperatorOnBackpressureBuffer<T>
  class	OperatorOnBackpressureDrop<T>
  class	OperatorOnErrorFlatMap<T> Allows inserting onNext events into a stream when onError events are received and continuing the original sequence instead of terminating.
  class	OperatorOnErrorResumeNextViaFunction<T> Instruct an Observable to pass control to another Observable (the return value of a function) rather than invoking onError if it encounters an error.
  class	OperatorOnErrorResumeNextViaObservable<T> Instruct an Observable to pass control to another Observable rather than invoking onError if it encounters an error.
  class	OperatorOnErrorReturn<T> Instruct an Observable to emit a particular item to its Observer's onNext method rather than invoking onError if it encounters an error.
  class	OperatorOnExceptionResumeNextViaObservable<T> Instruct an Observable to pass control to another Observable rather than invoking onError if it encounters an error of type Exception.
  class	OperatorRetryWithPredicate<T>
  class	OperatorSampleWithObservable<T,U> Sample with the help of another observable.
  class	OperatorSampleWithTime<T> Returns an Observable that emits the results of sampling the items emitted by the source Observable at a specified time interval.
  class	OperatorScan<R,T> Returns an Observable that applies a function to the first item emitted by a source Observable, then feeds the result of that function along with the second item emitted by an Observable into the same function, and so on until all items have been emitted by the source Observable, emitting the result of each of these iterations.
  class	OperatorSerialize<T>
  class	OperatorSingle<T> If the Observable completes after emitting a single item that matches a predicate, return an Observable containing that item.
  class	OperatorSkip<T> Returns an Observable that skips the first num items emitted by the source Observable.
  class	OperatorSkipLast<T> Bypasses a specified number of elements at the end of an observable sequence.
  class	OperatorSkipLastTimed<T> Skip delivering values in the time window before the values.
  class	OperatorSkipTimed<T> Skips elements until a specified time elapses.
  class	OperatorSkipUntil<T,U> Skip elements from the source Observable until the secondary observable fires an element.
  class	OperatorSkipWhile<T> Skips any emitted source items as long as the specified condition holds true.
  class	OperatorSubscribeOn<T> Subscribes Observers on the specified Scheduler.
  class	OperatorSwitch<T> Transforms an Observable that emits Observables into a single Observable that emits the items emitted by the most recently published of those Observables.
  class	OperatorTake<T> An Observable that emits the first num items emitted by the source Observable.
  class	OperatorTakeLast<T> Returns an Observable that emits the last count items emitted by the source Observable.
  class	OperatorTakeLastTimed<T> Returns an Observable that emits the last count items emitted by the source Observable.
  class	OperatorTakeTimed<T> Takes values from the source until the specific time ellapses.
  class	OperatorTakeUntil<T,E> Returns an Observable that emits the items from the source Observable until another Observable emits an item.
  class	OperatorTakeWhile<T> Returns an Observable that emits items emitted by the source Observable as long as a specified condition is true.
  class	OperatorThrottleFirst<T> Throttle by windowing a stream and returning the first value in each window.
  class	OperatorTimeInterval<T> Records the time interval between consecutive elements in an observable sequence.
  class	OperatorTimeout<T> Applies a timeout policy for each element in the observable sequence, using the specified scheduler to run timeout timers.
  class	OperatorTimeoutWithSelector<T,U,V> Returns an Observable that mirrors the source Observable.
  class	OperatorTimestamp<T> Wraps each item emitted by a source Observable in a Timestamped object.
  class	OperatorToMap<T,K,V> Maps the elements of the source observable into a java.util.Map instance and emits that once the source observable completes.
  static class	OperatorToMap.DefaultToMapFactory<K,V> The default map factory.
  class	OperatorToMultimap<T,K,V> Maps the elements of the source observable into a multimap (Map<K, Collection<V>>) where each key entry has a collection of the source's values.
  static class	OperatorToMultimap.DefaultMultimapCollectionFactory<K,V> The default collection factory for a key in the multimap returning an ArrayList independent of the key.
  static class	OperatorToMultimap.DefaultToMultimapFactory<K,V> The default multimap factory returning a HashMap.
  class	OperatorToObservableList<T> Returns an Observable that emits a single item, a list composed of all the items emitted by the source Observable.
  class	OperatorToObservableSortedList<T> Return an Observable that emits the items emitted by the source Observable, in a sorted order (each item emitted by the Observable must implement Comparable with respect to all other items in the sequence, or you must pass in a sort function).
  class	OperatorUnsubscribeOn<T> Unsubscribes on the specified Scheduler.
  class	OperatorWindowWithObservable<T,U> Creates non-overlapping windows of items where each window is terminated by an event from a secondary observable and a new window is started immediately.
  class	OperatorWindowWithSize<T> Creates windows of values into the source sequence with skip frequency and size bounds.
  class	OperatorWindowWithStartEndObservable<T,U,V> Creates potentially overlapping windows of the source items where each window is started by a value emitted by an observable and closed when an associated Observable emits a value or completes.
  class	OperatorWindowWithTime<T> Creates windows of values into the source sequence with timed window creation, length and size bounds.
  class	OperatorZip<R> Returns an Observable that emits the results of a function applied to sets of items emitted, in sequence, by two or more other Observables.
  class	OperatorZipIterable<T1,T2,R>