io.vertx.rxjava3

Class MaybeHelper

java.lang.Object

io.vertx.rxjava3.MaybeHelper

public class MaybeHelper
extends Object

Author:

Julien Viet

Constructor Summary

Constructors

Constructor and Description
MaybeHelper()

Method Summary

Modifier and Type	Method and Description
static <T> MaybeObserver<T>	nullObserver()
static <T> Future<T>	toFuture(Maybe<T> maybe) Adapts an RxJava2 Maybe<T> to a Vert.x Future.
static <T,U> Future<U>	toFuture(Maybe<T> maybe, java.util.function.Function<T,U> adapter) Like toFuture(Maybe) but with an adapter of the result.
static <T> Maybe<T>	toMaybe(java.util.function.Consumer<Handler<AsyncResult<T>>> handler) Returns a Maybe that, when subscribed, uses the provided handler to adapt a callback-based asynchronous method.
static <T> MaybeObserver<T>	toObserver(Handler<AsyncResult<T>> handler) Adapts an Vert.x Handler<AsyncResult<T>> to an RxJava2 MaybeObserver.
static <T> MaybeTransformer<Buffer,T>	unmarshaller(Class<T> mappedType)
static <T> MaybeTransformer<Buffer,T>	unmarshaller(Class<T> mappedType, ObjectCodec mapper)
static <T> MaybeTransformer<Buffer,T>	unmarshaller(TypeReference<T> mappedTypeRef)
static <T> MaybeTransformer<Buffer,T>	unmarshaller(TypeReference<T> mappedTypeRef, ObjectCodec mapper)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

MaybeHelper

public MaybeHelper()

Method Detail

nullObserver

public static <T> MaybeObserver<T> nullObserver()

Returns:

a MaybeObserver that does nothing

toMaybe

public static <T> Maybe<T> toMaybe(java.util.function.Consumer<Handler<AsyncResult<T>>> handler)

Returns a Maybe that, when subscribed, uses the provided handler to adapt a callback-based asynchronous method.

For example:

 
 io.vertx.core.Vertx vertx = Vertx.vertx();
 Maybe<String> blockingMethodResult = MaybeHelper.toMaybe(handler -> vertx.<String>executeBlocking(fut -> fut.complete(invokeBlocking()), handler));
 

This is useful when using RxJava without the Vert.x Rxified API or your own asynchronous methods.

Parameters:

handler - the code executed when the returned Maybe is subscribed

toObserver

public static <T> MaybeObserver<T> toObserver(Handler<AsyncResult<T>> handler)

Adapts an Vert.x Handler<AsyncResult<T>> to an RxJava2 MaybeObserver.

The returned observer can be subscribed to an Maybe.subscribe(MaybeObserver).

Parameters:

handler - the handler to adapt

Returns:

the observer

toFuture

public static <T> Future<T> toFuture(Maybe<T> maybe)

Adapts an RxJava2 Maybe<T> to a Vert.x Future.

The maybe will be immediately subscribed and the returned future will be updated with the result of the single.

Parameters:

maybe - the single to adapt

Returns:

the future

toFuture

public static <T,U> Future<U> toFuture(Maybe<T> maybe,
                                       java.util.function.Function<T,U> adapter)

Like toFuture(Maybe) but with an adapter of the result.

unmarshaller

public static <T> MaybeTransformer<Buffer,T> unmarshaller(Class<T> mappedType)

unmarshaller

public static <T> MaybeTransformer<Buffer,T> unmarshaller(TypeReference<T> mappedTypeRef)

unmarshaller

public static <T> MaybeTransformer<Buffer,T> unmarshaller(Class<T> mappedType,
                                                          ObjectCodec mapper)

unmarshaller

public static <T> MaybeTransformer<Buffer,T> unmarshaller(TypeReference<T> mappedTypeRef,
                                                          ObjectCodec mapper)