PooledConnection (RxJava Javadoc 0.5.3)

java.lang.Object
- io.reactivex.netty.channel.Connection<R,W>
- - io.reactivex.netty.client.pool.PooledConnection<R,W>

Type Parameters:

R - Type of object that is read from this connection.

W - Type of object that is written to this connection.

All Implemented Interfaces:

ChannelOperations<W>
```
public class PooledConnection<R,W>
extends Connection<R,W>
```
An implementation of Connection which is pooled and reused. It is required to call reuse(Subscriber) for reusing this connection.

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static interface`	`PooledConnection.Owner` A contract for the owner of the `PooledConnection` to which any instance of `PooledConnection` must be returned after use.

Field Summary

Fields
Modifier and Type Field and Description

static io.netty.util.AttributeKey<java.lang.Long> DYNAMIC_CONN_KEEP_ALIVE_TIMEOUT_MS
- Fields inherited from class io.reactivex.netty.channel.Connection
  CONNECTION_ATTRIBUTE_KEY, markAwarePipeline
- Fields inherited from interface io.reactivex.netty.channel.ChannelOperations
  FLUSH_ON_EACH_BYTES, FLUSH_ON_EACH_FILE_REGION, FLUSH_ON_EACH_STRING, FLUSH_ONLY_ON_READ_COMPLETE

Fields
Modifier and Type	Field and Description
`static io.netty.util.AttributeKey<java.lang.Long>`	`DYNAMIC_CONN_KEEP_ALIVE_TIMEOUT_MS`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`<RR,WW> Connection<RR,WW>`	`addChannelHandlerAfter(io.netty.util.concurrent.EventExecutorGroup group, java.lang.String baseName, java.lang.String name, io.netty.channel.ChannelHandler handler)` Adds a `ChannelHandler` to `ChannelPipeline` for this connection.
`<RR,WW> Connection<RR,WW>`	`addChannelHandlerAfter(java.lang.String baseName, java.lang.String name, io.netty.channel.ChannelHandler handler)` Adds a `ChannelHandler` to `ChannelPipeline` for this connection.
`<RR,WW> Connection<RR,WW>`	`addChannelHandlerBefore(io.netty.util.concurrent.EventExecutorGroup group, java.lang.String baseName, java.lang.String name, io.netty.channel.ChannelHandler handler)` Adds a `ChannelHandler` to `ChannelPipeline` for this connection.
`<RR,WW> Connection<RR,WW>`	`addChannelHandlerBefore(java.lang.String baseName, java.lang.String name, io.netty.channel.ChannelHandler handler)` Adds a `ChannelHandler` to `ChannelPipeline` for this connection.
`<RR,WW> Connection<RR,WW>`	`addChannelHandlerFirst(io.netty.util.concurrent.EventExecutorGroup group, java.lang.String name, io.netty.channel.ChannelHandler handler)` Adds a `ChannelHandler` to `ChannelPipeline` for this connection.
`<RR,WW> Connection<RR,WW>`	`addChannelHandlerFirst(java.lang.String name, io.netty.channel.ChannelHandler handler)` Adds a `ChannelHandler` to `ChannelPipeline` for this connection.
`<RR,WW> Connection<RR,WW>`	`addChannelHandlerLast(io.netty.util.concurrent.EventExecutorGroup group, java.lang.String name, io.netty.channel.ChannelHandler handler)` Adds a `ChannelHandler` to `ChannelPipeline` for this connection.
`<RR,WW> Connection<RR,WW>`	`addChannelHandlerLast(java.lang.String name, io.netty.channel.ChannelHandler handler)` Adds a `ChannelHandler` to `ChannelPipeline` for this connection.
`rx.Observable<java.lang.Void>`	`close()` Flushes any pending writes and closes the connection.
`rx.Observable<java.lang.Void>`	`close(boolean flush)` Closes this channel after flushing all pending writes.
`rx.Observable<java.lang.Void>`	`closeListener()` Returns an `Observable` that completes when this connection is closed.
`void`	`closeNow()` Closes the connection immediately.
`static <R,W> PooledConnection<R,W>`	`create(PooledConnection.Owner owner, long maxIdleTimeMillis, Connection<R,W> unpooledDelegate)`
`void`	`flush()` Flushes any pending writes on this connection by calling `Channel.flush()`.
`io.netty.channel.ChannelPipeline`	`getChannelPipeline()` Returns the `ChannelPipeline` for this connection.
`boolean`	`isReused()` Returns `true` if this connection is reused at least once.
`boolean`	`isUsable()` Returns whether this connection is safe to be used at this moment.
`<RR,WW> Connection<RR,WW>`	`pipelineConfigurator(rx.functions.Action1<io.netty.channel.ChannelPipeline> pipelineConfigurator)` Configures the `ChannelPipeline` for this channel, using the passed `pipelineConfigurator`.
`void`	`reuse(rx.Subscriber<? super PooledConnection<R,W>> connectionSubscriber)` This method must be called for reusing the connection i.e.
`<RR> Connection<RR,W>`	`transformRead(rx.Observable.Transformer<R,RR> transformer)` Transforms this connection's input stream using the passed `transformer` to create a new `Connection` instance.
`<WW> Connection<R,WW>`	`transformWrite(AllocatingTransformer<WW,W> transformer)` Transforms this connection to enable writing a different object type.
`rx.Observable<java.lang.Void>`	`write(rx.Observable<W> msgs)` On subscription of the returned `Observable`, writes the passed message stream on the underneath channel.
`rx.Observable<java.lang.Void>`	`write(rx.Observable<W> msgs, rx.functions.Func1<W,java.lang.Boolean> flushSelector)` On subscription of the returned `Observable`, writes the passed message stream on the underneath channel and flushes the channel, everytime, `flushSelector` returns `true` .
`rx.Observable<java.lang.Void>`	`writeAndFlushOnEach(rx.Observable<W> msgs)` On subscription of the returned `Observable`, writes the passed message stream on the underneath channel and flushes the channel, on every write.
`rx.Observable<java.lang.Void>`	`writeBytes(rx.Observable<byte[]> msgs)` On subscription of the returned `Observable`, writes the passed message stream on the underneath channel.
`rx.Observable<java.lang.Void>`	`writeBytes(rx.Observable<byte[]> msgs, rx.functions.Func1<byte[],java.lang.Boolean> flushSelector)` On subscription of the returned `Observable`, writes the passed message stream on the underneath channel and flushes the channel, everytime, `flushSelector` returns `true` .
`rx.Observable<java.lang.Void>`	`writeBytesAndFlushOnEach(rx.Observable<byte[]> msgs)` On subscription of the returned `Observable`, writes the passed message stream on the underneath channel and flushes the channel, on every write.
`rx.Observable<java.lang.Void>`	`writeFileRegion(rx.Observable<io.netty.channel.FileRegion> msgs)` On subscription of the returned `Observable`, writes the passed message stream on the underneath channel.
`rx.Observable<java.lang.Void>`	`writeFileRegion(rx.Observable<io.netty.channel.FileRegion> msgs, rx.functions.Func1<io.netty.channel.FileRegion,java.lang.Boolean> flushSelector)` On subscription of the returned `Observable`, writes the passed message stream on the underneath channel and flushes the channel, everytime, `flushSelector` returns `true` .
`rx.Observable<java.lang.Void>`	`writeFileRegionAndFlushOnEach(rx.Observable<io.netty.channel.FileRegion> msgs)` On subscription of the returned `Observable`, writes the passed message stream on the underneath channel and flushes the channel, on every write.
`rx.Observable<java.lang.Void>`	`writeString(rx.Observable<java.lang.String> msgs)` On subscription of the returned `Observable`, writes the passed message stream on the underneath channel.
`rx.Observable<java.lang.Void>`	`writeString(rx.Observable<java.lang.String> msgs, rx.functions.Func1<java.lang.String,java.lang.Boolean> flushSelector)` On subscription of the returned `Observable`, writes the passed message stream on the underneath channel and flushes the channel, everytime, `flushSelector` returns `true` .
`rx.Observable<java.lang.Void>`	`writeStringAndFlushOnEach(rx.Observable<java.lang.String> msgs)` On subscription of the returned `Observable`, writes the passed message stream on the underneath channel and flushes the channel, on every write.

Methods inherited from class io.reactivex.netty.channel.Connection
connectCloseToChannelClose, getInput, getResettableChannelPipeline, ignoreInput, unsafeNettyChannel

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

- Field Detail
  - DYNAMIC_CONN_KEEP_ALIVE_TIMEOUT_MS
```
public static final io.netty.util.AttributeKey<java.lang.Long> DYNAMIC_CONN_KEEP_ALIVE_TIMEOUT_MS
```
- Method Detail
  - write
```
public rx.Observable<java.lang.Void> write(rx.Observable<W> msgs)
```
    Description copied from interface: ChannelOperations
    
    On subscription of the returned Observable, writes the passed message stream on the underneath channel.
    Flush.
    All writes will be flushed on completion of the passed Observable
    
    Parameters:
    
    msgs - Stream of messages to write.
    
    Returns:
    
    Observable representing the result of this write. Every subscription to this Observable will replay the write on the channel.
  - write
```
public rx.Observable<java.lang.Void> write(rx.Observable<W> msgs,
                                           rx.functions.Func1<W,java.lang.Boolean> flushSelector)
```
    Description copied from interface: ChannelOperations
    
    On subscription of the returned Observable, writes the passed message stream on the underneath channel and flushes the channel, everytime, flushSelector returns true . Any writes issued before subscribing, will also be flushed. However, the returned Observable will not capture the result of those writes, i.e. if the other writes, fail and this write does not, the returned Observable will not fail.
    
    Parameters:
    
    msgs - Message stream to write.
    
    flushSelector - A Func1 which is invoked for every item emitted from msgs. Channel is flushed, iff this function returns, true.
    
    Returns:
    
    An Observable representing the result of this write. Every subscription to this Observable will write the passed messages and flush all pending writes, when the flushSelector returns true
  - writeAndFlushOnEach
```
public rx.Observable<java.lang.Void> writeAndFlushOnEach(rx.Observable<W> msgs)
```
    Description copied from interface: ChannelOperations
    
    On subscription of the returned Observable, writes the passed message stream on the underneath channel and flushes the channel, on every write. Any writes issued before subscribing, will also be flushed. However, the returned Observable will not capture the result of those writes, i.e. if the other writes, fail and this write does not, the returned Observable will not fail.
    
    Parameters:
    
    msgs - Message stream to write.
    
    Returns:
    
    An Observable representing the result of this write. Every subscription to this Observable will write the passed messages and flush all pending writes, on every write.
  - writeString
```
public rx.Observable<java.lang.Void> writeString(rx.Observable<java.lang.String> msgs)
```
    Description copied from interface: ChannelOperations
    
    On subscription of the returned Observable, writes the passed message stream on the underneath channel.
    Flush.
    All writes will be flushed on completion of the passed Observable
    
    Parameters:
    
    msgs - Stream of messages to write.
    
    Returns:
    
    Observable representing the result of this write. Every subscription to this Observable will replay the write on the channel.
  - writeString
```
public rx.Observable<java.lang.Void> writeString(rx.Observable<java.lang.String> msgs,
                                                 rx.functions.Func1<java.lang.String,java.lang.Boolean> flushSelector)
```
    Description copied from interface: ChannelOperations
    
    On subscription of the returned Observable, writes the passed message stream on the underneath channel and flushes the channel, everytime, flushSelector returns true . Any writes issued before subscribing, will also be flushed. However, the returned Observable will not capture the result of those writes, i.e. if the other writes, fail and this write does not, the returned Observable will not fail.
    
    Parameters:
    
    msgs - Message stream to write.
    
    flushSelector - A Func1 which is invoked for every item emitted from msgs. Channel is flushed, iff this function returns, true.
    
    Returns:
    
    An Observable representing the result of this write. Every subscription to this Observable will write the passed messages and flush all pending writes, when the flushSelector returns true
  - writeStringAndFlushOnEach
```
public rx.Observable<java.lang.Void> writeStringAndFlushOnEach(rx.Observable<java.lang.String> msgs)
```
    Description copied from interface: ChannelOperations
    
    On subscription of the returned Observable, writes the passed message stream on the underneath channel and flushes the channel, on every write. Any writes issued before subscribing, will also be flushed. However, the returned Observable will not capture the result of those writes, i.e. if the other writes, fail and this write does not, the returned Observable will not fail.
    
    Parameters:
    
    msgs - Message stream to write.
    
    Returns:
    
    An Observable representing the result of this write. Every subscription to this Observable will write the passed messages and flush all pending writes, on every write.
  - writeBytes
```
public rx.Observable<java.lang.Void> writeBytes(rx.Observable<byte[]> msgs)
```
    Description copied from interface: ChannelOperations
    
    On subscription of the returned Observable, writes the passed message stream on the underneath channel.
    Flush.
    All writes will be flushed on completion of the passed Observable
    
    Parameters:
    
    msgs - Stream of messages to write.
    
    Returns:
    
    Observable representing the result of this write. Every subscription to this Observable will replay the write on the channel.
  - writeBytes
```
public rx.Observable<java.lang.Void> writeBytes(rx.Observable<byte[]> msgs,
                                                rx.functions.Func1<byte[],java.lang.Boolean> flushSelector)
```
    Description copied from interface: ChannelOperations
    
    On subscription of the returned Observable, writes the passed message stream on the underneath channel and flushes the channel, everytime, flushSelector returns true . Any writes issued before subscribing, will also be flushed. However, the returned Observable will not capture the result of those writes, i.e. if the other writes, fail and this write does not, the returned Observable will not fail.
    
    Parameters:
    
    msgs - Message stream to write.
    
    flushSelector - A Func1 which is invoked for every item emitted from msgs. Channel is flushed, iff this function returns, true.
    
    Returns:
    
    An Observable representing the result of this write. Every subscription to this Observable will write the passed messages and flush all pending writes, when the flushSelector returns true
  - writeBytesAndFlushOnEach
```
public rx.Observable<java.lang.Void> writeBytesAndFlushOnEach(rx.Observable<byte[]> msgs)
```
    Description copied from interface: ChannelOperations
    
    On subscription of the returned Observable, writes the passed message stream on the underneath channel and flushes the channel, on every write. Any writes issued before subscribing, will also be flushed. However, the returned Observable will not capture the result of those writes, i.e. if the other writes, fail and this write does not, the returned Observable will not fail.
    
    Parameters:
    
    msgs - Message stream to write.
    
    Returns:
    
    An Observable representing the result of this write. Every subscription to this Observable will write the passed messages and flush all pending writes, on every write.
  - writeFileRegion
```
public rx.Observable<java.lang.Void> writeFileRegion(rx.Observable<io.netty.channel.FileRegion> msgs)
```
    Description copied from interface: ChannelOperations
    
    On subscription of the returned Observable, writes the passed message stream on the underneath channel.
    Flush.
    All writes will be flushed on completion of the passed Observable
    
    Parameters:
    
    msgs - Stream of messages to write.
    
    Returns:
    
    Observable representing the result of this write. Every subscription to this Observable will replay the write on the channel.
  - writeFileRegion
```
public rx.Observable<java.lang.Void> writeFileRegion(rx.Observable<io.netty.channel.FileRegion> msgs,
                                                     rx.functions.Func1<io.netty.channel.FileRegion,java.lang.Boolean> flushSelector)
```
    Description copied from interface: ChannelOperations
    
    On subscription of the returned Observable, writes the passed message stream on the underneath channel and flushes the channel, everytime, flushSelector returns true . Any writes issued before subscribing, will also be flushed. However, the returned Observable will not capture the result of those writes, i.e. if the other writes, fail and this write does not, the returned Observable will not fail.
    
    Parameters:
    
    msgs - Message stream to write.
    
    flushSelector - A Func1 which is invoked for every item emitted from msgs. Channel is flushed, iff this function returns, true.
    
    Returns:
    
    An Observable representing the result of this write. Every subscription to this Observable will write the passed messages and flush all pending writes, when the flushSelector returns true
  - writeFileRegionAndFlushOnEach
```
public rx.Observable<java.lang.Void> writeFileRegionAndFlushOnEach(rx.Observable<io.netty.channel.FileRegion> msgs)
```
    Description copied from interface: ChannelOperations
    
    On subscription of the returned Observable, writes the passed message stream on the underneath channel and flushes the channel, on every write. Any writes issued before subscribing, will also be flushed. However, the returned Observable will not capture the result of those writes, i.e. if the other writes, fail and this write does not, the returned Observable will not fail.
    
    Parameters:
    
    msgs - Message stream to write.
    
    Returns:
    
    An Observable representing the result of this write. Every subscription to this Observable will write the passed messages and flush all pending writes, on every write.
  - flush
```
public void flush()
```
    Description copied from interface: ChannelOperations
    
    Flushes any pending writes on this connection by calling Channel.flush(). This can be used for implementing any custom flusing strategies that otherwise can not be implemented by methods like ChannelOperations.write(Observable, Func1).
  - close
```
public rx.Observable<java.lang.Void> close()
```
    Description copied from interface: ChannelOperations
    
    Flushes any pending writes and closes the connection. Same as calling close(true)
    
    Returns:
    
    Observable representing the result of close.
  - close
```
public rx.Observable<java.lang.Void> close(boolean flush)
```
    Description copied from interface: ChannelOperations
    
    Closes this channel after flushing all pending writes.
    
    Returns:
    
    Observable representing the result of close and flush.
  - closeNow
```
public void closeNow()
```
    Description copied from interface: ChannelOperations
    
    Closes the connection immediately. Same as calling ChannelOperations.close() and subscribing to the returned Observable
  - closeListener
```
public rx.Observable<java.lang.Void> closeListener()
```
    Description copied from interface: ChannelOperations
    
    Returns an Observable that completes when this connection is closed.
    
    Returns:
    
    An Observable that completes when this connection is closed.
  - addChannelHandlerAfter
```
public <RR,WW> Connection<RR,WW> addChannelHandlerAfter(java.lang.String baseName,
                                                        java.lang.String name,
                                                        io.netty.channel.ChannelHandler handler)
```
    Description copied from class: Connection
    
    Adds a ChannelHandler to ChannelPipeline for this connection. The specified handler is added after an existing handler with the passed baseName in the pipeline as specified by ChannelPipeline.addAfter(String, String, ChannelHandler) For better flexibility of pipeline modification, the method Connection.pipelineConfigurator(Action1) will be more convenient.
    
    Specified by:
    
    addChannelHandlerAfter in class Connection<R,W>
    
    Parameters:
    
    baseName - the name of the existing handler
    
    name - Name of the handler.
    
    handler - Handler instance to add.
    
    Returns:
    
    this.
  - addChannelHandlerAfter
```
public <RR,WW> Connection<RR,WW> addChannelHandlerAfter(io.netty.util.concurrent.EventExecutorGroup group,
                                                        java.lang.String baseName,
                                                        java.lang.String name,
                                                        io.netty.channel.ChannelHandler handler)
```
    Description copied from class: Connection
    
    Adds a ChannelHandler to ChannelPipeline for this connection. The specified handler is added after an existing handler with the passed baseName in the pipeline as specified by ChannelPipeline.addAfter(EventExecutorGroup, String, String, ChannelHandler) For better flexibility of pipeline modification, the method Connection.pipelineConfigurator(Action1) will be more convenient.
    
    Specified by:
    
    addChannelHandlerAfter in class Connection<R,W>
    
    Parameters:
    
    group - the EventExecutorGroup which will be used to execute the ChannelHandler methods
    
    baseName - the name of the existing handler
    
    name - the name of the handler to append
    
    handler - Handler instance to add.
    
    Returns:
    
    this.
  - addChannelHandlerBefore
```
public <RR,WW> Connection<RR,WW> addChannelHandlerBefore(java.lang.String baseName,
                                                         java.lang.String name,
                                                         io.netty.channel.ChannelHandler handler)
```
    Description copied from class: Connection
    
    Adds a ChannelHandler to ChannelPipeline for this connection. The specified handler is added before an existing handler with the passed baseName in the pipeline as specified by ChannelPipeline.addBefore(String, String, ChannelHandler) For better flexibility of pipeline modification, the method Connection.pipelineConfigurator(Action1) will be more convenient.
    
    Specified by:
    
    addChannelHandlerBefore in class Connection<R,W>
    
    Parameters:
    
    baseName - the name of the existing handler
    
    name - Name of the handler.
    
    handler - Handler instance to add.
    
    Returns:
    
    this.
  - addChannelHandlerBefore
```
public <RR,WW> Connection<RR,WW> addChannelHandlerBefore(io.netty.util.concurrent.EventExecutorGroup group,
                                                         java.lang.String baseName,
                                                         java.lang.String name,
                                                         io.netty.channel.ChannelHandler handler)
```
    Description copied from class: Connection
    
    Adds a ChannelHandler to ChannelPipeline for this connection. The specified handler is added before an existing handler with the passed baseName in the pipeline as specified by ChannelPipeline.addBefore(EventExecutorGroup, String, String, ChannelHandler) For better flexibility of pipeline modification, the method Connection.pipelineConfigurator(Action1) will be more convenient.
    
    Specified by:
    
    addChannelHandlerBefore in class Connection<R,W>
    
    Parameters:
    
    group - the EventExecutorGroup which will be used to execute the ChannelHandler methods
    
    baseName - the name of the existing handler
    
    name - the name of the handler to append
    
    handler - Handler instance to add.
    
    Returns:
    
    this.
  - addChannelHandlerFirst
```
public <RR,WW> Connection<RR,WW> addChannelHandlerFirst(io.netty.util.concurrent.EventExecutorGroup group,
                                                        java.lang.String name,
                                                        io.netty.channel.ChannelHandler handler)
```
    Description copied from class: Connection
    
    Adds a ChannelHandler to ChannelPipeline for this connection. The specified handler is added at the first position of the pipeline as specified by ChannelPipeline.addFirst(EventExecutorGroup, String, ChannelHandler) For better flexibility of pipeline modification, the method Connection.pipelineConfigurator(Action1) will be more convenient.
    
    Specified by:
    
    addChannelHandlerFirst in class Connection<R,W>
    
    Parameters:
    
    group - the EventExecutorGroup which will be used to execute the ChannelHandler methods
    
    name - the name of the handler to append
    
    handler - Handler instance to add.
    
    Returns:
    
    this.
  - addChannelHandlerFirst
```
public <RR,WW> Connection<RR,WW> addChannelHandlerFirst(java.lang.String name,
                                                        io.netty.channel.ChannelHandler handler)
```
    Description copied from class: Connection
    
    Adds a ChannelHandler to ChannelPipeline for this connection. The specified handler is added at the first position of the pipeline as specified by ChannelPipeline.addFirst(String, ChannelHandler) For better flexibility of pipeline modification, the method Connection.pipelineConfigurator(Action1) will be more convenient.
    
    Specified by:
    
    addChannelHandlerFirst in class Connection<R,W>
    
    Parameters:
    
    name - Name of the handler.
    
    handler - Handler instance to add.
    
    Returns:
    
    this.
  - addChannelHandlerLast
```
public <RR,WW> Connection<RR,WW> addChannelHandlerLast(io.netty.util.concurrent.EventExecutorGroup group,
                                                       java.lang.String name,
                                                       io.netty.channel.ChannelHandler handler)
```
    Description copied from class: Connection
    
    Adds a ChannelHandler to ChannelPipeline for this connection. The specified handler is added at the last position of the pipeline as specified by ChannelPipeline.addLast(EventExecutorGroup, String, ChannelHandler) For better flexibility of pipeline modification, the method Connection.pipelineConfigurator(Action1) will be more convenient.
    
    Specified by:
    
    addChannelHandlerLast in class Connection<R,W>
    
    Parameters:
    
    group - the EventExecutorGroup which will be used to execute the ChannelHandler methods
    
    name - the name of the handler to append
    
    handler - Handler instance to add.
    
    Returns:
    
    this.
  - addChannelHandlerLast
```
public <RR,WW> Connection<RR,WW> addChannelHandlerLast(java.lang.String name,
                                                       io.netty.channel.ChannelHandler handler)
```
    Description copied from class: Connection
    
    Adds a ChannelHandler to ChannelPipeline for this connection. The specified handler is added at the last position of the pipeline as specified by ChannelPipeline.addLast(String, ChannelHandler) For better flexibility of pipeline modification, the method Connection.pipelineConfigurator(Action1) will be more convenient.
    
    Specified by:
    
    addChannelHandlerLast in class Connection<R,W>
    
    Parameters:
    
    name - Name of the handler.
    
    handler - Handler instance to add.
    
    Returns:
    
    this.
  - pipelineConfigurator
```
public <RR,WW> Connection<RR,WW> pipelineConfigurator(rx.functions.Action1<io.netty.channel.ChannelPipeline> pipelineConfigurator)
```
    Description copied from class: Connection
    
    Configures the ChannelPipeline for this channel, using the passed pipelineConfigurator.
    
    Specified by:
    
    pipelineConfigurator in class Connection<R,W>
    
    Parameters:
    
    pipelineConfigurator - Action to configure ChannelPipeline.
    
    Returns:
    
    this.
  - transformRead
```
public <RR> Connection<RR,W> transformRead(rx.Observable.Transformer<R,RR> transformer)
```
    Description copied from class: Connection
    
    Transforms this connection's input stream using the passed transformer to create a new Connection instance.
    
    Specified by:
    
    transformRead in class Connection<R,W>
    
    Type Parameters:
    
    RR - New type of the input stream.
    
    Parameters:
    
    transformer - Transformer to transform the input stream.
    
    Returns:
    
    A new connection instance with the transformed read stream.
  - transformWrite
```
public <WW> Connection<R,WW> transformWrite(AllocatingTransformer<WW,W> transformer)
```
    Description copied from class: Connection
    
    Transforms this connection to enable writing a different object type.
    
    Specified by:
    
    transformWrite in interface ChannelOperations<W>
    
    Specified by:
    
    transformWrite in class Connection<R,W>
    
    Type Parameters:
    
    WW - New object types to be written to the connection.
    
    Parameters:
    
    transformer - Transformer to transform objects written to the channel.
    
    Returns:
    
    A new connection instance with the new write type.
  - isUsable
```
public boolean isUsable()
```
    Returns whether this connection is safe to be used at this moment.
    This makes sure that the underlying netty's channel is active as returned by Channel.isActive() and it has not passed the maximum idle time in the pool.
    
    Returns:
    
    true if the connection is usable.
  - reuse
```
public void reuse(rx.Subscriber<? super PooledConnection<R,W>> connectionSubscriber)
```
    This method must be called for reusing the connection i.e. for sending this connection to the passed subscriber.
    
    Parameters:
    
    connectionSubscriber - Subscriber for the pooled connection for reuse.
  - create
```
public static <R,W> PooledConnection<R,W> create(PooledConnection.Owner owner,
                                                 long maxIdleTimeMillis,
                                                 Connection<R,W> unpooledDelegate)
```
  - isReused
```
public boolean isReused()
```
    Returns true if this connection is reused at least once.
    
    Returns:
    
    true if this connection is reused at least once.
  - getChannelPipeline
```
public io.netty.channel.ChannelPipeline getChannelPipeline()
```
    Description copied from class: Connection
    
    Returns the ChannelPipeline for this connection.
    
    Overrides:
    
    getChannelPipeline in class Connection<R,W>
    
    Returns:
    
    ChannelPipeline for this connection.

RxJava

Class PooledConnection<R,W>

Nested Class Summary

Field Summary

Fields inherited from class io.reactivex.netty.channel.Connection

Fields inherited from interface io.reactivex.netty.channel.ChannelOperations

Method Summary

Methods inherited from class io.reactivex.netty.channel.Connection

Methods inherited from class java.lang.Object

Field Detail

DYNAMIC_CONN_KEEP_ALIVE_TIMEOUT_MS

Method Detail

write

Flush.

write

writeAndFlushOnEach

writeString

Flush.

writeString

writeStringAndFlushOnEach

writeBytes

Flush.

writeBytes

writeBytesAndFlushOnEach

writeFileRegion

Flush.

writeFileRegion

writeFileRegionAndFlushOnEach

flush

close

close

closeNow

closeListener

addChannelHandlerAfter

addChannelHandlerAfter

addChannelHandlerBefore

addChannelHandlerBefore

addChannelHandlerFirst

addChannelHandlerFirst

addChannelHandlerLast

addChannelHandlerLast

pipelineConfigurator

transformRead

transformWrite

isUsable

reuse

create

isReused

getChannelPipeline