AbstractMaybeAsyncHandlerBridge (Asynchronous Http Client RxJava2 Extras 2.11.0 API)

java.lang.Object
- org.asynchttpclient.extras.rxjava2.maybe.AbstractMaybeAsyncHandlerBridge<T>

Type Parameters:

T - the result type produced by the wrapped AsyncHandler and emitted via RxJava

All Implemented Interfaces:

AsyncHandler<Void>

Direct Known Subclasses:

AbstractMaybeProgressAsyncHandlerBridge, MaybeAsyncHandlerBridge
```
public abstract class AbstractMaybeAsyncHandlerBridge<T>
extends Object
implements AsyncHandler<Void>
```
Abstract base class that bridges events between the Maybe reactive base type and AsyncHandlers.
When an event is received, it's first checked if the Rx stream has been disposed asynchronously. If so, request processing is aborted, otherwise, the event is forwarded to the wrapped handler.
When the request is completed, the result produced by the wrapped instance is forwarded to the Maybe: If the result is null, MaybeEmitter.onComplete() is invoked, MaybeEmitter.onSuccess(Object) otherwise.
Any errors during request processing are forwarded via MaybeEmitter.onError(Throwable).

Nested Class Summary
- Nested classes/interfaces inherited from interface org.asynchttpclient.AsyncHandler
  AsyncHandler.State

Field Summary

Fields
Modifier and Type	Field and Description
`protected io.reactivex.MaybeEmitter<T>`	`emitter` The Rx callback object that receives downstream events and will be queried for its `disposed state` when Async HTTP Client callbacks are invoked.

Constructor Summary

Constructors
Modifier Constructor and Description

protected AbstractMaybeAsyncHandlerBridge(io.reactivex.MaybeEmitter<T> emitter)

Constructors
Modifier	Constructor and Description
`protected`	`AbstractMaybeAsyncHandlerBridge(io.reactivex.MaybeEmitter<T> emitter)`

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`protected abstract AsyncHandler<? extends T>`	`delegate()`
`protected AsyncHandler.State`	`disposed()` Called to indicate that request processing is to be aborted because the linked Rx stream has been disposed.
`AsyncHandler.State`	`onBodyPartReceived(HttpResponseBodyPart content)`
`Void`	`onCompleted()`
`void`	`onConnectionOffer(io.netty.channel.Channel connection)`
`void`	`onConnectionPoolAttempt()`
`void`	`onConnectionPooled(io.netty.channel.Channel connection)`
`AsyncHandler.State`	`onHeadersReceived(io.netty.handler.codec.http.HttpHeaders headers)`
`void`	`onHostnameResolutionAttempt(String name)`
`void`	`onHostnameResolutionFailure(String name, Throwable cause)`
`void`	`onHostnameResolutionSuccess(String name, List<InetSocketAddress> addresses)`
`void`	`onRequestSend(NettyRequest request)`
`void`	`onRetry()`
`AsyncHandler.State`	`onStatusReceived(HttpResponseStatus status)`
`void`	`onTcpConnectAttempt(InetSocketAddress remoteAddress)`
`void`	`onTcpConnectFailure(InetSocketAddress remoteAddress, Throwable cause)`
`void`	`onTcpConnectSuccess(InetSocketAddress remoteAddress, io.netty.channel.Channel connection)`
`void`	`onThrowable(Throwable t)`
`void`	`onTlsHandshakeAttempt()`
`void`	`onTlsHandshakeFailure(Throwable cause)`
`void`	`onTlsHandshakeSuccess(SSLSession sslSession)`
`AsyncHandler.State`	`onTrailingHeadersReceived(io.netty.handler.codec.http.HttpHeaders headers)`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - emitter
```
protected final io.reactivex.MaybeEmitter<T> emitter
```
    The Rx callback object that receives downstream events and will be queried for its disposed state when Async HTTP Client callbacks are invoked.
- Constructor Detail
  - AbstractMaybeAsyncHandlerBridge
```
protected AbstractMaybeAsyncHandlerBridge(io.reactivex.MaybeEmitter<T> emitter)
```
- Method Detail
  - onBodyPartReceived
```
public final AsyncHandler.State onBodyPartReceived(HttpResponseBodyPart content)
                                            throws Exception
```
    Specified by:
    
    onBodyPartReceived in interface AsyncHandler<Void>
    
    Throws:
    
    Exception
  - onStatusReceived
```
public final AsyncHandler.State onStatusReceived(HttpResponseStatus status)
                                          throws Exception
```
    Specified by:
    
    onStatusReceived in interface AsyncHandler<Void>
    
    Throws:
    
    Exception
  - onHeadersReceived
```
public final AsyncHandler.State onHeadersReceived(io.netty.handler.codec.http.HttpHeaders headers)
                                           throws Exception
```
    Specified by:
    
    onHeadersReceived in interface AsyncHandler<Void>
    
    Throws:
    
    Exception
  - onTrailingHeadersReceived
```
public AsyncHandler.State onTrailingHeadersReceived(io.netty.handler.codec.http.HttpHeaders headers)
                                             throws Exception
```
    Specified by:
    
    onTrailingHeadersReceived in interface AsyncHandler<Void>
    
    Throws:
    
    Exception
  - onCompleted
```
public final Void onCompleted()
```
    The value returned by the wrapped AsyncHandler won't be returned by this method, but emtited via RxJava.
    
    Specified by:
    
    onCompleted in interface AsyncHandler<Void>
    
    Returns:
    
    always null
  - onThrowable
```
public final void onThrowable(Throwable t)
```
    The exception will first be propagated to the wrapped AsyncHandler, then emitted via RxJava. If the invocation of the delegate itself throws an exception, both the original exception and the follow-up exception will be wrapped into RxJava's CompositeException and then be emitted.
    
    Specified by:
    
    onThrowable in interface AsyncHandler<Void>
  - onHostnameResolutionAttempt
```
public void onHostnameResolutionAttempt(String name)
```
    Specified by:
    
    onHostnameResolutionAttempt in interface AsyncHandler<Void>
  - onHostnameResolutionSuccess
```
public void onHostnameResolutionSuccess(String name,
                                        List<InetSocketAddress> addresses)
```
    Specified by:
    
    onHostnameResolutionSuccess in interface AsyncHandler<Void>
  - onHostnameResolutionFailure
```
public void onHostnameResolutionFailure(String name,
                                        Throwable cause)
```
    Specified by:
    
    onHostnameResolutionFailure in interface AsyncHandler<Void>
  - onTcpConnectAttempt
```
public void onTcpConnectAttempt(InetSocketAddress remoteAddress)
```
    Specified by:
    
    onTcpConnectAttempt in interface AsyncHandler<Void>
  - onTcpConnectSuccess
```
public void onTcpConnectSuccess(InetSocketAddress remoteAddress,
                                io.netty.channel.Channel connection)
```
    Specified by:
    
    onTcpConnectSuccess in interface AsyncHandler<Void>
  - onTcpConnectFailure
```
public void onTcpConnectFailure(InetSocketAddress remoteAddress,
                                Throwable cause)
```
    Specified by:
    
    onTcpConnectFailure in interface AsyncHandler<Void>
  - onTlsHandshakeAttempt
```
public void onTlsHandshakeAttempt()
```
    Specified by:
    
    onTlsHandshakeAttempt in interface AsyncHandler<Void>
  - onTlsHandshakeSuccess
```
public void onTlsHandshakeSuccess(SSLSession sslSession)
```
    Specified by:
    
    onTlsHandshakeSuccess in interface AsyncHandler<Void>
  - onTlsHandshakeFailure
```
public void onTlsHandshakeFailure(Throwable cause)
```
    Specified by:
    
    onTlsHandshakeFailure in interface AsyncHandler<Void>
  - onConnectionPoolAttempt
```
public void onConnectionPoolAttempt()
```
    Specified by:
    
    onConnectionPoolAttempt in interface AsyncHandler<Void>
  - onConnectionPooled
```
public void onConnectionPooled(io.netty.channel.Channel connection)
```
    Specified by:
    
    onConnectionPooled in interface AsyncHandler<Void>
  - onConnectionOffer
```
public void onConnectionOffer(io.netty.channel.Channel connection)
```
    Specified by:
    
    onConnectionOffer in interface AsyncHandler<Void>
  - onRequestSend
```
public void onRequestSend(NettyRequest request)
```
    Specified by:
    
    onRequestSend in interface AsyncHandler<Void>
  - onRetry
```
public void onRetry()
```
    Specified by:
    
    onRetry in interface AsyncHandler<Void>
  - disposed
```
protected final AsyncHandler.State disposed()
```
    Called to indicate that request processing is to be aborted because the linked Rx stream has been disposed. If the delegate didn't already receive a terminal event, AsyncHandler#onThrowable(Throwable) onThrowable will be called with a DisposedException.
    
    Returns:
    
    always State#ABORT
  - delegate
```
protected abstract AsyncHandler<? extends T> delegate()
```
    Returns:
    
    the wrapped AsyncHandler instance to which calls are delegated

Class AbstractMaybeAsyncHandlerBridge<T>

Nested Class Summary

Nested classes/interfaces inherited from interface org.asynchttpclient.AsyncHandler

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

emitter

Constructor Detail

AbstractMaybeAsyncHandlerBridge

Method Detail

onBodyPartReceived

onStatusReceived

onHeadersReceived

onTrailingHeadersReceived

onCompleted

onThrowable

onHostnameResolutionAttempt

onHostnameResolutionSuccess

onHostnameResolutionFailure

onTcpConnectAttempt

onTcpConnectSuccess

onTcpConnectFailure

onTlsHandshakeAttempt

onTlsHandshakeSuccess

onTlsHandshakeFailure

onConnectionPoolAttempt

onConnectionPooled

onConnectionOffer

onRequestSend

onRetry

disposed

delegate