ChannelHandlerContext

public final class ChannelHandlerContext : ChannelInvoker

Every ChannelHandler has – when added to a ChannelPipeline – a corresponding ChannelHandlerContext which is the way ChannelHandlers can interact with other ChannelHandlers in the pipeline.

Most ChannelHandlers need to send events through the ChannelPipeline which they do by calling the respective method on their ChannelHandlerContext. In fact all the ChannelHandler default implementations just forward the event using the ChannelHandlerContext.

Many events are instrumental for a ChannelHandler‘s life-cycle and it is therefore very important to send them at the right point in time. Often, the right behaviour is to react to an event and then forward it to the next ChannelHandler.

Show on GitHub

pipeline
Undocumented
Declaration
Swift

public let pipeline: ChannelPipeline
Show on GitHub
channel
Undocumented
Declaration
Swift

public var channel: Channel { get }
Show on GitHub
handler
Undocumented
Declaration
Swift

public var handler: ChannelHandler { get }
Show on GitHub
remoteAddress
Undocumented
Declaration
Swift

public var remoteAddress: SocketAddress? { get }
Show on GitHub
localAddress
Undocumented
Declaration
Swift

public var localAddress: SocketAddress? { get }
Show on GitHub
eventLoop
Declaration
Swift

public var eventLoop: EventLoop { get }
Show on GitHub
name
Undocumented
Declaration
Swift

public let name: String
Show on GitHub
fireChannelRegistered()
Send a channelRegistered event to the next (inbound) ChannelHandler in the ChannelPipeline.

Note
For correct operation it is very important to forward any channelRegistered event using this method at the right point in time, that is usually when received.
Declaration
Swift

public func fireChannelRegistered()
Show on GitHub
fireChannelUnregistered()
Send a channelUnregistered event to the next (inbound) ChannelHandler in the ChannelPipeline.

Note
For correct operation it is very important to forward any channelUnregistered event using this method at the right point in time, that is usually when received.
Declaration
Swift

public func fireChannelUnregistered()
Show on GitHub
fireChannelActive()
Send a channelActive event to the next (inbound) ChannelHandler in the ChannelPipeline.

Note
For correct operation it is very important to forward any channelActive event using this method at the right point in time, that is often when received.
Declaration
Swift

public func fireChannelActive()
Show on GitHub
fireChannelInactive()
Send a channelInactive event to the next (inbound) ChannelHandler in the ChannelPipeline.

Note
For correct operation it is very important to forward any channelInactive event using this method at the right point in time, that is often when received.
Declaration
Swift

public func fireChannelInactive()
Show on GitHub
fireChannelRead(_:)
Send data to the next inbound ChannelHandler. The data should be of type ChannelInboundHandler.InboundOut.
Declaration
Swift

public func fireChannelRead(_ data: NIOAny)
Show on GitHub
fireChannelReadComplete()
Signal to the next ChannelHandler that a read burst has finished.
Declaration
Swift

public func fireChannelReadComplete()
Show on GitHub
fireChannelWritabilityChanged()
Send a writabilityChanged event to the next (inbound) ChannelHandler in the ChannelPipeline.

Note
For correct operation it is very important to forward any writabilityChanged event using this method at the right point in time, that is usually when received.
Declaration
Swift

public func fireChannelWritabilityChanged()
Show on GitHub
fireErrorCaught(_:)
Send an error to the next inbound ChannelHandler.
Declaration
Swift

public func fireErrorCaught(_ error: Error)
Show on GitHub
fireUserInboundEventTriggered(_:)
Send a user event to the next inbound ChannelHandler.
Declaration
Swift

public func fireUserInboundEventTriggered(_ event: Any)
Show on GitHub
register(promise:)
Send a register event to the next (outbound) ChannelHandler in the ChannelPipeline.

Note
For correct operation it is very important to forward any register event using this method at the right point in time, that is usually when received.
Declaration
Swift

public func register(promise: EventLoopPromise<Void>?)
Show on GitHub


                    
                    
                    bind(to:promise:)

Send a bind event to the next outbound ChannelHandler in the ChannelPipeline. When the bind event reaches the HeadChannelHandler a ServerSocketChannel will be bound.

Declaration

Swift

public func bind(to address: SocketAddress, promise: EventLoopPromise<Void>?)

Parameters

`address`	The address to bind to.
`promise`	The promise fulfilled when the socket is bound or failed if it cannot be bound.

Show on GitHub


                    
                    
                    connect(to:promise:)

Send a connect event to the next outbound ChannelHandler in the ChannelPipeline. When the connect event reaches the HeadChannelHandler a SocketChannel will be connected.

Declaration

Swift

public func connect(to address: SocketAddress, promise: EventLoopPromise<Void>?)

Parameters

`address`	The address to connect to.
`promise`	The promise fulfilled when the socket is connected or failed if it cannot be connected.

Show on GitHub


                    
                    
                    write(_:promise:)

Send a write event to the next outbound ChannelHandler in the ChannelPipeline. When the write event reaches the HeadChannelHandler the data will be enqueued to be written on the next flush event.

Declaration

Swift

public func write(_ data: NIOAny, promise: EventLoopPromise<Void>?)

Parameters

`data`	The data to write, should be of type `ChannelOutboundHandler.OutboundOut`.
`promise`	The promise fulfilled when the data has been written or failed if it cannot be written.

Show on GitHub


                    
                    
                    flush()

Send a flush event to the next outbound ChannelHandler in the ChannelPipeline. When the flush event reaches the HeadChannelHandler the data previously enqueued will be attempted to be written to the socket.

Declaration

Swift

public func flush()

Parameters


                                promise

The promise fulfilled when the previously written data been flushed or failed if it cannot be flushed.

Show on GitHub


                    
                    
                    writeAndFlush(_:promise:)

Send a write event followed by a flush event to the next outbound ChannelHandler in the ChannelPipeline. When the write event reaches the HeadChannelHandler the data will be enqueued to be written when the flush also reaches the HeadChannelHandler.

Declaration

Swift

public func writeAndFlush(_ data: NIOAny, promise: EventLoopPromise<Void>?)

Parameters

`data`	The data to write, should be of type `ChannelOutboundHandler.OutboundOut`.
`promise`	The promise fulfilled when the previously written data been written and flushed or if that failed.

Show on GitHub

read()
Send a read event to the next outbound ChannelHandler in the ChannelPipeline. When the read event reaches the HeadChannelHandler the interest to read data will be signalled to the Selector. This will subsequently – when data becomes readable – cause channelRead events containing the data being sent through the ChannelPipeline.
Declaration
Swift

public func read()
Show on GitHub


                    
                    
                    close(mode:promise:)

Send a close event to the next outbound ChannelHandler in the ChannelPipeline. When the close event reaches the HeadChannelHandler the socket will be closed.

Declaration

Swift

public func close(mode: CloseMode = .all, promise: EventLoopPromise<Void>?)

Parameters

`mode`	The `CloseMode` to use.
`promise`	The promise fulfilled when the `Channel` has been closed or failed if it the closing failed.

Show on GitHub


                    
                    
                    triggerUserOutboundEvent(_:promise:)

Send a user event to the next outbound ChannelHandler in the ChannelPipeline.

Declaration

Swift

public func triggerUserOutboundEvent(_ event: Any, promise: EventLoopPromise<Void>?)

Parameters

`event`	The user event to send.
`promise`	The promise fulfilled when the user event has been sent or failed if it couldn’t be sent.

Show on GitHub

Synchronous View

RemovalToken
A RemovalToken is handed to a RemovableChannelHandler when its removeHandler function is invoked. A RemovableChannelHandler is then required to remove itself from the ChannelPipeline. The removal process is finalized by handing the RemovalToken to the ChannelHandlerContext.leavePipeline function.
Declaration
Swift

public struct RemovalToken
Show on GitHub


                    
                    
                    leavePipeline(removalToken:)

Synchronously remove the ChannelHandler with the given ChannelHandlerContext.

Note

This function must only be used from a RemovableChannelHandler to remove itself. Calling this method on any other ChannelHandlerContext leads to undefined behaviour.

Declaration

Swift

public func leavePipeline(removalToken: RemovalToken)

Parameters


                                removalToken

The removal token received from RemovableChannelHandler.removeHandler

Show on GitHub