Completable empty = (completableSubscriber -> { The Completable API follows the concepts of the Reactive-Streams. Create, Lift and Transform. The Completable class has three additional standard helper interfaces, now becoming common with all RxJava. Creating a Single. Completable. Creating a Completable. Maybe. Creating a Maybe. RxCocoa traits. Driver. Why is it named Driver; Practical usage example.

Author: Yozshuk Moogusho
Country: Belarus
Language: English (Spanish)
Genre: Politics
Published (Last): 17 July 2008
Pages: 63
PDF File Size: 2.85 Mb
ePub File Size: 3.79 Mb
ISBN: 777-9-13533-883-6
Downloads: 87810
Price: Free* [*Free Regsitration Required]
Uploader: Goramar

Violating the specification may result in undefined behavior. Worker instance for it but we also have to ensure the delayed task can be completanle if necessary. Suppose we update any User crete in the app and comppetable to just notify the server about it.

So you could create a Completable first and then convert it to Observable:. This now allows the wip counter to reach zero and terminate the whole process.

This is perfectly fine and you can use it as is. It contains a mandatory onSubscribe call with a non-null argument followed by, optionally, either an onError with a non-null Throwable or an onCompleted.

Subscribes to this Completable instance and blocks until it terminates, then returns null or the emitted exception if any. Returns a Crrate that runs this Completable and switches to the other Completable in case this Completable doesn’t complete within the given time. In addition, I didn’t list all overloads so please consult with the source code of the class or the Javadoc once it becomes available online. Returns a Completable that retries this Completable in case of an error as long as the predicate returns true.

Clearer RxJava intentions with Single and Completable

In this latter case, the Throwable is delivered to the global error handler via RxJavaPlugins. At this complteable, there is no reason for the others to continue and will be unsubscribed from the challenge. Regardless, what does it take to write such an operator for Completable?


The terminal condition is determined in the evaluator’s onCompleted method: The most versatile one being andThen.

creste Returns a Completable that never calls onError or onComplete. Returns a Completable that delays the subscription to the source CompletableSource by a given amount of time. The reason for this replacement, and the use of MultipleAssignmentSubscription is to avoid unsubscribing the worker too early; a SerialSubscription or a CompositeSubscription would not allow this.

I have written a simple factory for wrapping a Runnable object into an Observable: We have a set of fromXXX method which can take many sources: Finally, we call the evaluator’s onCompleted method to signal no more Completable s students will appear. We can think of a Completable object as a stripped version of Observable where only the creatr events, onError and onCompleted are ever emitted; they may look like an Observable. We achieve this by manually unsubscribe our BooleanSubscription 3 and calling the onCompleted method.

We create the shared done indicator which is set to true once one of the student notifies the teacher about its completion or failure. The Completable class implements the CompletableSource base interface and the default consumer type it interacts with is the CompletableObserver via the subscribe CompletableObserver method. RxJava supports such usage with the standard DisposableCompletableObserver instance. Unsurprisingly, the compliant resolution is to move the creation of the teacher CompletableSubscriber into 8 without any changes to its internals; compleyable, that should indicate it can be shared among the students.

This allows fluent conversion to any other type. There is no such factory method for Observablebut Completable could be made from Runnable. Returns an Observable which first delivers the events of the other Observable then runs this CompletableConsumable.

Returns a Completable which calls the given onComplete callback if this Completable completes. Allows fluent conversion to another type via a function callback. An error event from this Completable will be propagated to the downstream subscriber and will result in skipping the subscription of the Observable. Represents a computation without any value but only indication for completion or exception.


The supplied predicate will receive the exception and should return true if the exception should be dropped and replaced by a onCompleted event. Returns a Completable instance that when subscribed to, subscribes to the Single instance and emits a completion event if the single emits onSuccess or forwards any onError events. We start with an AtomicInteger work-in-progress counter and crfate number 1.

Defers the subscription to a Completable instance returned by a supplier. So our API client now looks like this:. In case of a race between a terminal event and a dispose call, the provided onFinally action is executed once per subscription. With this alias, one can pre-compose common operations and present it to a stream through the usual compose method.

Let’s see the simplest case completablw we know exactly the number of students and any failure should stop the evaluation process: Returns a Completable that retries this Completable as long as it emits an onError event.

Completable (RxJava Javadoc )

Note that if any of the observers to this Completable call dispose, this Completable will cancel the future. In the loop where the student Completable s are subscribed to we can only check if the principal is no longer interested in the evaluation; the value of the wip counter doesn’t help here because it is going to be at least 1 while the loop is running. Handling the onXXX notifications isn’t that complicated either: The Publisher must follow the Reactive-Streams specification.

Many of them have overloads for varargs and Iterable sequences.

This makes sure the wip counter is at least 1 so the terminal condition isn’t met while the loop is running. Returns a Completable instance that if this Completable emits an error, it will emit an onComplete and swallow the throwable.

Posted in: Sex