EngineDatagramSession (SNF4J/Core 1.7.0 API)

java.lang.Object
- org.snf4j.core.IdentifiableObject
- - org.snf4j.core.session.AbstractSession
  - - org.snf4j.core.DatagramSession
    - - org.snf4j.core.EngineDatagramSession

All Implemented Interfaces:

IDatagramSession, IEngineDatagramSession, IEngineSession, ISession

Direct Known Subclasses:

DTLSSession
```
public class EngineDatagramSession
extends DatagramSession
implements IEngineDatagramSession
```
A datagram-oriented session that handles protocols driven by customized protocol engines implementing the IEngine interface.

Author:

SNF4J.ORG

Constructor Summary

Constructors
Constructor and Description
`EngineDatagramSession(IEngine engine, IDatagramHandler handler, ILogger logger)` Constructs a datagram-oriented session associated with a protocol engine and a handler.
`EngineDatagramSession(IEngine engine, SocketAddress remoteAddress, IDatagramHandler handler, ILogger logger)` Constructs a datagram-oriented session associated with a protocol engine and a handler.
`EngineDatagramSession(String name, IEngine engine, IDatagramHandler handler, ILogger logger)` Constructs a named datagram-oriented session associated with a protocol engine and a handler.
`EngineDatagramSession(String name, IEngine engine, SocketAddress remoteAddress, IDatagramHandler handler, ILogger logger)` Constructs a named datagram-oriented session associated with a protocol engine and a handler.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`ByteBuffer`	`allocate(int capacity)` Allocates a byte buffer by using the allocator associated with this session.
`void`	`beginHandshake()` Initiates handshaking (initial or renegotiation) on the protocol engine driving this session.
`void`	`beginLazyHandshake()` Initiates lazy handshaking (initial or renegotiation) on the protocol engine driving this session.
`void`	`close()` Gently closes this session after all pending data waiting for writing are fully flushed.
`void`	`dirtyClose()` Quickly closes this session without flushing any pending data and without following close procedure of an application layer (e.g.
`IFuture<Void>`	`getCloseFuture()` Gets the future that can be use to wait for the completion of the closing phase.
`ICodecPipeline`	`getCodecPipeline()` Gets the codec pipeline that is associated with this session.
`ISessionConfig`	`getConfig()` Gets the configuration of this session.
`IFuture<Void>`	`getCreateFuture()` Gets the future that can be use to wait for the completion of the creation phase.
`long`	`getCreationTime()` Gets the session's creation time in milliseconds.
`IFuture<Void>`	`getEndFuture()` Gets the future that can be use to wait for the completion of the ending phase.
`Object`	`getEngineSession()` Returns an object representing a session in the protocol engine driving this session.
`Executor`	`getExecutor()` Returns the executor that is used to execute delegated tasks required by this session to complete operations that block, or may take an extended period of time to complete.
`IDatagramHandler`	`getHandler()` Gets the datagram-oriented handler associated with this session
`long`	`getLastIoTime()` Gets the time in milliseconds when I/O operation occurred lastly.
`long`	`getLastReadTime()` Gets the time in milliseconds when read operation occurred lastly.
`long`	`getLastWriteTime()` Gets the time in milliseconds when write operation occurred lastly.
`IFuture<Void>`	`getOpenFuture()` Gets the future that can be use to wait for the completion of the opening phase.
`long`	`getReadBytes()` Gets the total number of bytes which were read from this session.
`double`	`getReadBytesThroughput()` Gets the number of read bytes per second.
`IFuture<Void>`	`getReadyFuture()` Gets the future that can be use to wait for the completion of the ready phase.
`SessionState`	`getState()` Gets the current state of this session.
`ISessionTimer`	`getTimer()` Gets the session timer associated with this session.
`long`	`getWrittenBytes()` Gets the total number of bytes which were written to this session.
`double`	`getWrittenBytesThroughput()` Gets the number of written bytes per second.
`boolean`	`isOpen()` Tells if this session is open.
`boolean`	`isReadSuspended()` Tells if read operations are suspended for this session.
`boolean`	`isWriteSuspended()` Tells if write operations are suspended for this session.
`void`	`quickClose()` Quickly closes this session without flushing any pending data.
`void`	`release(ByteBuffer buffer)` Release given byte buffer by the allocator associated with this session.
`void`	`resumeRead()` Resumes read operations for this session.
`void`	`resumeWrite()` Resumes write operations for this session.
`IFuture<Void>`	`send(SocketAddress remoteAddress, byte[] datagram)` Sends a `datagram.length` byte datagram from the specified byte array to a remote end via the datagram-oriented channel associated with this session.
`IFuture<Void>`	`send(SocketAddress remoteAddress, byte[] datagram, int offset, int length)` Sends a `length` byte datagram from the specified byte array to a remote end via the datagram-oriented channel associated with this session.
`IFuture<Void>`	`send(SocketAddress remoteAddress, ByteBuffer datagram)` Sends a `datagram.remaining()` byte datagram from the specified byte buffer to a remote end via the datagram-oriented channel associated with this session.
`IFuture<Void>`	`send(SocketAddress remoteAddress, ByteBuffer datagram, int length)` Sends a `length` byte datagram from the specified byte buffer to a remote end via the datagram-oriented channel associated with this session.
`IFuture<Void>`	`send(SocketAddress remoteAddress, Object msg)` Sends a message to a remote end via the datagram-oriented channel associated with this session.
`void`	`sendnf(SocketAddress remoteAddress, byte[] datagram)` Sends a `datagram.length` byte datagram from the specified byte array to a remote end via the datagram-oriented channel associated with this session.
`void`	`sendnf(SocketAddress remoteAddress, byte[] datagram, int offset, int length)` Sends a `length` byte datagram from the specified byte array to a remote end via the datagram-oriented channel associated with this session.
`void`	`sendnf(SocketAddress remoteAddress, ByteBuffer datagram)` Sends a `datagram.remaining()` byte datagram from the specified byte buffer to a remote end via the datagram-oriented channel associated with this session.
`void`	`sendnf(SocketAddress remoteAddress, ByteBuffer datagram, int length)` Sends a `length` byte datagram from the specified byte buffer to a remote end via the datagram-oriented channel associated with this session.
`void`	`sendnf(SocketAddress remoteAddress, Object msg)` Sends a message to a remote end via the datagram-oriented channel associated with this session.
`void`	`setExecutor(Executor executor)` Sets the executor that will be used to execute delegated tasks required by this session to complete operations that block, or may take an extended period of time to complete.
`void`	`suspendRead()` Suspends read operations for this session.
`void`	`suspendWrite()` Suspends write operations for this session.
`IFuture<Void>`	`write(byte[] datagram)` Writes a `datagram.length` byte datagram from the specified byte array to the datagram-oriented channel associated with this session.
`IFuture<Void>`	`write(byte[] datagram, int offset, int length)` Writes a `length` byte datagram from the specified byte array to the datagram-oriented channel associated with this session.
`IFuture<Void>`	`write(ByteBuffer datagram)` Writes a `datagram.remaining()` byte datagram from the specified byte buffer to the datagram-oriented channel associated with this session.
`IFuture<Void>`	`write(ByteBuffer datagram, int length)` Writes a `length` byte datagram from the specified byte buffer to the datagram-oriented channel associated with this session.
`IFuture<Void>`	`write(Object msg)` Writes a message to the datagram-oriented channel associated with this session.
`void`	`writenf(byte[] datagram)` Writes a `datagram.length` byte datagram from the specified byte array to the datagram-oriented channel associated with this session.
`void`	`writenf(byte[] datagram, int offset, int length)` Writes a `length` byte datagram from the specified byte array to the datagram-oriented channel associated with this session.
`void`	`writenf(ByteBuffer datagram)` Writes a `datagram.remaining()` byte datagram from the specified byte buffer to the datagram-oriented channel associated with this session.
`void`	`writenf(ByteBuffer datagram, int length)` Writes a `length` byte datagram from the specified byte buffer to the datagram-oriented channel associated with this session.
`void`	`writenf(Object msg)` Writes a message to the datagram-oriented channel associated with this session.

Methods inherited from class org.snf4j.core.DatagramSession
getLocalAddress, getParent, getRemoteAddress

Methods inherited from class org.snf4j.core.session.AbstractSession
getAttributes

Methods inherited from class org.snf4j.core.IdentifiableObject
getId, getName, toString

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

Methods inherited from interface org.snf4j.core.session.IDatagramSession
getParent

Methods inherited from interface org.snf4j.core.session.ISession
allocate, getAttributes, getCloseFuture, getCodecPipeline, getConfig, getCreateFuture, getCreationTime, getEndFuture, getId, getLastIoTime, getLastReadTime, getLastWriteTime, getLocalAddress, getName, getOpenFuture, getReadBytes, getReadBytesThroughput, getReadyFuture, getRemoteAddress, getState, getTimer, getWrittenBytes, getWrittenBytesThroughput, isOpen, isReadSuspended, isWriteSuspended, release, resumeRead, resumeWrite, suspendRead, suspendWrite

- Constructor Detail
  - EngineDatagramSession
```
public EngineDatagramSession(String name,
                             IEngine engine,
                             SocketAddress remoteAddress,
                             IDatagramHandler handler,
                             ILogger logger)
```
    Constructs a named datagram-oriented session associated with a protocol engine and a handler. It should be used for sessions that will be associated with a not connected datagram channel.
    
    Parameters:
    
    name - the name for this session, or null if the handler's name should be used for this session's name
    
    engine - the protocol engine driving this session
    
    remoteAddress - the address of the remote peer
    
    handler - the handler that should be associated with this session
    
    logger - the logger used to log messages related with this session
    
    Throws:
    
    IllegalStateException - if no timer was configured. The exception can be ignored by setting the system property IGNORE_NO_SESSION_TIMER_EXCEPTION
  - EngineDatagramSession
```
public EngineDatagramSession(IEngine engine,
                             SocketAddress remoteAddress,
                             IDatagramHandler handler,
                             ILogger logger)
```
    Constructs a datagram-oriented session associated with a protocol engine and a handler. It should be used for sessions that will be associated with a not connected datagram channel.
    
    Parameters:
    
    engine - the protocol engine driving this session
    
    remoteAddress - the address of the remote peer
    
    handler - the handler that should be associated with this session
    
    logger - the logger used to log messages related with this session
    
    Throws:
    
    IllegalStateException - if no timer was configured. The exception can be ignored by setting the system property IGNORE_NO_SESSION_TIMER_EXCEPTION
  - EngineDatagramSession
```
public EngineDatagramSession(String name,
                             IEngine engine,
                             IDatagramHandler handler,
                             ILogger logger)
```
    Constructs a named datagram-oriented session associated with a protocol engine and a handler. It should be used for sessions that will be associated with a connected datagram channel.
    
    Parameters:
    
    name - the name for this session, or null if the handler's name should be used for this session's name
    
    engine - the protocol engine driving this session
    
    handler - the handler that should be associated with this session
    
    logger - the logger used to log messages related with this session
    
    Throws:
    
    IllegalStateException - if no timer was configured. The exception can be ignored by setting the system property IGNORE_NO_SESSION_TIMER_EXCEPTION
  - EngineDatagramSession
```
public EngineDatagramSession(IEngine engine,
                             IDatagramHandler handler,
                             ILogger logger)
```
    Constructs a datagram-oriented session associated with a protocol engine and a handler. It should be used for sessions that will be associated with a connected datagram channel.
    
    Parameters:
    
    engine - the protocol engine driving this session
    
    handler - the handler that should be associated with this session
    
    logger - the logger used to log messages related with this session
    
    Throws:
    
    IllegalStateException - if no timer was configured. The exception can be ignored by setting the system property IGNORE_NO_SESSION_TIMER_EXCEPTION
- Method Detail
  - setExecutor
```
public void setExecutor(Executor executor)
```
    Description copied from interface: IEngineSession
    
    Sets the executor that will be used to execute delegated tasks required by this session to complete operations that block, or may take an extended period of time to complete.
    
    Specified by:
    
    setExecutor in interface IEngineSession
    
    Parameters:
    
    executor - the new executor, or null to use the executor configured in the selector loop that handles this session.
  - getExecutor
```
public Executor getExecutor()
```
    Description copied from interface: IEngineSession
    
    Returns the executor that is used to execute delegated tasks required by this session to complete operations that block, or may take an extended period of time to complete.
    By default, this method returns the executor configured in the selector loop that handles this session, or null.
    
    Specified by:
    
    getExecutor in interface IEngineSession
    
    Returns:
    
    the current executor, or null if the executor is undefined (i.e. the session is not associated with the selector loop and the executor is not set)
  - beginHandshake
```
public void beginHandshake()
```
    Description copied from interface: IEngineSession
    
    Initiates handshaking (initial or renegotiation) on the protocol engine driving this session. After calling this method the handshake will start immediately.
    This method is not needed for the initial handshake, as the wrap and unwrap methods of the protocol engine should initiate it if the handshaking has not already begun.
    The operation is asynchronous.
    
    Specified by:
    
    beginHandshake in interface IEngineSession
  - beginLazyHandshake
```
public void beginLazyHandshake()
```
    Description copied from interface: IEngineSession
    
    Initiates lazy handshaking (initial or renegotiation) on the protocol engine driving this session. After calling this method the handshake will not start immediately. It will start when new data is received from a remote peer or following methods are called: write, writenf, beginHandshake.
    This method is not needed for the initial handshake, as the wrap and unwrap methods of the protocol engine should initiate it if the handshaking has not already begun.
    The operation is asynchronous.
    
    Specified by:
    
    beginLazyHandshake in interface IEngineSession
  - getEngineSession
```
public Object getEngineSession()
```
    Description copied from interface: IEngineSession
    
    Returns an object representing a session in the protocol engine driving this session.
    
    Specified by:
    
    getEngineSession in interface IEngineSession
    
    Returns:
    
    an object representing a session.
  - getHandler
```
public IDatagramHandler getHandler()
```
    Description copied from interface: IDatagramSession
    
    Gets the datagram-oriented handler associated with this session
    
    Specified by:
    
    getHandler in interface IDatagramSession
    
    Specified by:
    
    getHandler in interface ISession
    
    Overrides:
    
    getHandler in class DatagramSession
    
    Returns:
    
    the datagram-oriented handler
  - write
```
public IFuture<Void> write(byte[] datagram)
```
    Description copied from interface: IDatagramSession
    
    Writes a datagram.length byte datagram from the specified byte array to the datagram-oriented channel associated with this session.
    This method may only be invoked if the associated channel's socket is connected, in which case it writes the datagram directly to the socket's peer.
    The operation is asynchronous.
    
    Specified by:
    
    write in interface IDatagramSession
    
    Overrides:
    
    write in class DatagramSession
    
    Parameters:
    
    datagram - the datagram to be written
    
    Returns:
    
    the future associated with this write operation
  - writenf
```
public void writenf(byte[] datagram)
```
    Description copied from interface: IDatagramSession
    
    Writes a datagram.length byte datagram from the specified byte array to the datagram-oriented channel associated with this session.
    This method may only be invoked if the associated channel's socket is connected, in which case it writes the datagram directly to the socket's peer.
    The operation is asynchronous.
    This method should be used whenever there will be no need to synchronize on a future object. This will save some resources and may improve performance.
    
    Specified by:
    
    writenf in interface IDatagramSession
    
    Overrides:
    
    writenf in class DatagramSession
    
    Parameters:
    
    datagram - the datagram to be written
  - write
```
public IFuture<Void> write(byte[] datagram,
                           int offset,
                           int length)
```
    Description copied from interface: IDatagramSession
    
    Writes a length byte datagram from the specified byte array to the datagram-oriented channel associated with this session.
    This method may only be invoked if the associated channel's socket is connected, in which case it writes the datagram directly to the socket's peer.
    The operation is asynchronous.
    
    Specified by:
    
    write in interface IDatagramSession
    
    Overrides:
    
    write in class DatagramSession
    
    Parameters:
    
    datagram - the datagram to be written
    
    offset - offset within the array of the first byte to be written
    
    length - number of bytes to be written
    
    Returns:
    
    the future associated with this write operation
  - writenf
```
public void writenf(byte[] datagram,
                    int offset,
                    int length)
```
    Description copied from interface: IDatagramSession
    
    Writes a length byte datagram from the specified byte array to the datagram-oriented channel associated with this session.
    This method may only be invoked if the associated channel's socket is connected, in which case it writes the datagram directly to the socket's peer.
    The operation is asynchronous.
    This method should be used whenever there will be no need to synchronize on a future object. This will save some resources and may improve performance.
    
    Specified by:
    
    writenf in interface IDatagramSession
    
    Overrides:
    
    writenf in class DatagramSession
    
    Parameters:
    
    datagram - the datagram to be written
    
    offset - offset within the array of the first byte to be written
    
    length - number of bytes to be written
  - write
```
public IFuture<Void> write(ByteBuffer datagram)
```
    Description copied from interface: IDatagramSession
    
    Writes a datagram.remaining() byte datagram from the specified byte buffer to the datagram-oriented channel associated with this session.
    This method may only be invoked if the associated channel's socket is connected, in which case it writes the datagram directly to the socket's peer.
    The operation is asynchronous.
    
    Specified by:
    
    write in interface IDatagramSession
    
    Overrides:
    
    write in class DatagramSession
    
    Parameters:
    
    datagram - the datagram to be written
    
    Returns:
    
    the future associated with this write operation
  - writenf
```
public void writenf(ByteBuffer datagram)
```
    Description copied from interface: IDatagramSession
    
    Writes a datagram.remaining() byte datagram from the specified byte buffer to the datagram-oriented channel associated with this session.
    This method may only be invoked if the associated channel's socket is connected, in which case it writes the datagram directly to the socket's peer.
    The operation is asynchronous.
    This method should be used whenever there will be no need to synchronize on a future object. This will save some resources and may improve performance.
    
    Specified by:
    
    writenf in interface IDatagramSession
    
    Overrides:
    
    writenf in class DatagramSession
    
    Parameters:
    
    datagram - the datagram to be written
  - write
```
public IFuture<Void> write(ByteBuffer datagram,
                           int length)
```
    Description copied from interface: IDatagramSession
    
    Writes a length byte datagram from the specified byte buffer to the datagram-oriented channel associated with this session.
    This method may only be invoked if the associated channel's socket is connected, in which case it writes the datagram directly to the socket's peer.
    The operation is asynchronous.
    
    Specified by:
    
    write in interface IDatagramSession
    
    Overrides:
    
    write in class DatagramSession
    
    Parameters:
    
    datagram - the datagram to be written
    
    length - number of bytes to be written
    
    Returns:
    
    the future associated with this write operation
  - writenf
```
public void writenf(ByteBuffer datagram,
                    int length)
```
    Description copied from interface: IDatagramSession
    
    Writes a length byte datagram from the specified byte buffer to the datagram-oriented channel associated with this session.
    This method may only be invoked if the associated channel's socket is connected, in which case it writes the datagram directly to the socket's peer.
    The operation is asynchronous.
    This method should be used whenever there will be no need to synchronize on a future object. This will save some resources and may improve performance.
    
    Specified by:
    
    writenf in interface IDatagramSession
    
    Overrides:
    
    writenf in class DatagramSession
    
    Parameters:
    
    datagram - the datagram to be written
    
    length - number of bytes to be written
  - write
```
public IFuture<Void> write(Object msg)
```
    Description copied from interface: IDatagramSession
    
    Writes a message to the datagram-oriented channel associated with this session.
    This method may only be invoked if the associated channel's socket is connected, in which case it writes the message directly to the socket's peer.
    The operation is asynchronous.
    This method usually requires that the session has configured a codec pipeline with at least one encoder that accepts the msg as the inbound data. If a codec pipeline is not configured or no encoder accept the msg object it still accepts messages that are of the byte[] or ByteBuffer type.
    
    Specified by:
    
    write in interface IDatagramSession
    
    Overrides:
    
    write in class DatagramSession
    
    Parameters:
    
    msg - the message to be written
    
    Returns:
    
    the future associated with this send operation
  - writenf
```
public void writenf(Object msg)
```
    Description copied from interface: IDatagramSession
    
    Writes a message to the datagram-oriented channel associated with this session.
    This method may only be invoked if the associated channel's socket is connected, in which case it writes the message directly to the socket's peer.
    The operation is asynchronous.
    This method usually requires that the session has configured a codec pipeline with at least one encoder that accepts the msg as the inbound data. If a codec pipeline is not configured or no encoder accept the msg object it still accepts messages that are of the byte[] or ByteBuffer type.
    This method should be used whenever there will be no need to synchronize on a future object. This will save some resources and may improve performance.
    
    Specified by:
    
    writenf in interface IDatagramSession
    
    Overrides:
    
    writenf in class DatagramSession
    
    Parameters:
    
    msg - the message to be written
  - send
```
public IFuture<Void> send(SocketAddress remoteAddress,
                          byte[] datagram)
```
    Description copied from interface: IDatagramSession
    
    Sends a datagram.length byte datagram from the specified byte array to a remote end via the datagram-oriented channel associated with this session.
    If the remoteAddress argument is not null then the method may only be invoked if the associated channel's socket is not connected. In case the argument is null the method will work as the adequate write method.
    The operation is asynchronous.
    
    Specified by:
    
    send in interface IDatagramSession
    
    Overrides:
    
    send in class DatagramSession
    
    Parameters:
    
    remoteAddress - the address of the remote end where the datagram should be sent
    
    datagram - the datagram to be sent
    
    Returns:
    
    the future associated with this send operation
  - sendnf
```
public void sendnf(SocketAddress remoteAddress,
                   byte[] datagram)
```
    Description copied from interface: IDatagramSession
    
    Sends a datagram.length byte datagram from the specified byte array to a remote end via the datagram-oriented channel associated with this session.
    If the remoteAddress argument is not null then the method may only be invoked if the associated channel's socket is not connected. In case the argument is null the method will work as the adequate write method.
    The operation is asynchronous.
    This method should be used whenever there will be no need to synchronize on a future object. This will save some resources and may improve performance.
    
    Specified by:
    
    sendnf in interface IDatagramSession
    
    Overrides:
    
    sendnf in class DatagramSession
    
    Parameters:
    
    remoteAddress - the address of the remote end where the datagram should be sent
    
    datagram - the datagram to be sent
  - send
```
public IFuture<Void> send(SocketAddress remoteAddress,
                          byte[] datagram,
                          int offset,
                          int length)
```
    Description copied from interface: IDatagramSession
    
    Sends a length byte datagram from the specified byte array to a remote end via the datagram-oriented channel associated with this session.
    If the remoteAddress argument is not null then the method may only be invoked if the associated channel's socket is not connected. In case the argument is null the method will work as the adequate write method.
    The operation is asynchronous.
    
    Specified by:
    
    send in interface IDatagramSession
    
    Overrides:
    
    send in class DatagramSession
    
    Parameters:
    
    remoteAddress - the address of the remote end where the datagram should be sent
    
    datagram - the datagram to be sent
    
    offset - offset within the array of the first byte to be sent
    
    length - number of bytes to be sent
    
    Returns:
    
    the future associated with this send operation
  - sendnf
```
public void sendnf(SocketAddress remoteAddress,
                   byte[] datagram,
                   int offset,
                   int length)
```
    Description copied from interface: IDatagramSession
    
    Sends a length byte datagram from the specified byte array to a remote end via the datagram-oriented channel associated with this session.
    If the remoteAddress argument is not null then the method may only be invoked if the associated channel's socket is not connected. In case the argument is null the method will work as the adequate write method.
    The operation is asynchronous.
    This method should be used whenever there will be no need to synchronize on a future object. This will save some resources and may improve performance.
    
    Specified by:
    
    sendnf in interface IDatagramSession
    
    Overrides:
    
    sendnf in class DatagramSession
    
    Parameters:
    
    remoteAddress - the address of the remote end where the datagram should be sent
    
    datagram - the datagram to be sent
    
    offset - offset within the array of the first byte to be sent
    
    length - number of bytes to be sent
  - send
```
public IFuture<Void> send(SocketAddress remoteAddress,
                          ByteBuffer datagram)
```
    Description copied from interface: IDatagramSession
    
    Sends a datagram.remaining() byte datagram from the specified byte buffer to a remote end via the datagram-oriented channel associated with this session.
    If the remoteAddress argument is not null then the method may only be invoked if the associated channel's socket is not connected. In case the argument is null the method will work as the adequate write method.
    The operation is asynchronous.
    
    Specified by:
    
    send in interface IDatagramSession
    
    Overrides:
    
    send in class DatagramSession
    
    Parameters:
    
    remoteAddress - the address of the remote end where the datagram should be sent
    
    datagram - the datagram to be sent
    
    Returns:
    
    the future associated with this send operation
  - sendnf
```
public void sendnf(SocketAddress remoteAddress,
                   ByteBuffer datagram)
```
    Description copied from interface: IDatagramSession
    
    Sends a datagram.remaining() byte datagram from the specified byte buffer to a remote end via the datagram-oriented channel associated with this session.
    If the remoteAddress argument is not null then the method may only be invoked if the associated channel's socket is not connected. In case the argument is null the method will work as the adequate write method.
    The operation is asynchronous.
    This method should be used whenever there will be no need to synchronize on a future object. This will save some resources and may improve performance.
    
    Specified by:
    
    sendnf in interface IDatagramSession
    
    Overrides:
    
    sendnf in class DatagramSession
    
    Parameters:
    
    remoteAddress - the address of the remote end where the datagram should be sent
    
    datagram - the datagram to be sent
  - send
```
public IFuture<Void> send(SocketAddress remoteAddress,
                          ByteBuffer datagram,
                          int length)
```
    Description copied from interface: IDatagramSession
    
    Sends a length byte datagram from the specified byte buffer to a remote end via the datagram-oriented channel associated with this session.
    If the remoteAddress argument is not null then the method may only be invoked if the associated channel's socket is not connected. In case the argument is null the method will work as the adequate write method.
    The operation is asynchronous.
    
    Specified by:
    
    send in interface IDatagramSession
    
    Overrides:
    
    send in class DatagramSession
    
    Parameters:
    
    remoteAddress - the address of the remote end where the datagram should be sent
    
    datagram - the datagram to be sent
    
    length - number of bytes to be sent
    
    Returns:
    
    the future associated with this send operation
  - sendnf
```
public void sendnf(SocketAddress remoteAddress,
                   ByteBuffer datagram,
                   int length)
```
    Description copied from interface: IDatagramSession
    
    Sends a length byte datagram from the specified byte buffer to a remote end via the datagram-oriented channel associated with this session.
    If the remoteAddress argument is not null then the method may only be invoked if the associated channel's socket is not connected. In case the argument is null the method will work as the adequate write method.
    The operation is asynchronous.
    This method should be used whenever there will be no need to synchronize on a future object. This will save some resources and may improve performance.
    
    Specified by:
    
    sendnf in interface IDatagramSession
    
    Overrides:
    
    sendnf in class DatagramSession
    
    Parameters:
    
    remoteAddress - the address of the remote end where the datagram should be sent
    
    datagram - the datagram to be sent
    
    length - number of bytes to be sent
  - send
```
public IFuture<Void> send(SocketAddress remoteAddress,
                          Object msg)
```
    Description copied from interface: IDatagramSession
    
    Sends a message to a remote end via the datagram-oriented channel associated with this session.
    If the remoteAddress argument is not null then the method may only be invoked if the associated channel's socket is not connected. In case the argument is null the method will work as the adequate write method.
    The operation is asynchronous.
    This method usually requires that the session has configured a codec pipeline with at least one encoder that accepts the msg as the inbound data. If a codec pipeline is not configured or no encoder accept the msg object it still accepts messages that are of the byte[] or ByteBuffer type.
    
    Specified by:
    
    send in interface IDatagramSession
    
    Overrides:
    
    send in class DatagramSession
    
    Parameters:
    
    remoteAddress - the address of the remote end where the message should be sent
    
    msg - the message to be sent
    
    Returns:
    
    the future associated with this send operation
  - sendnf
```
public void sendnf(SocketAddress remoteAddress,
                   Object msg)
```
    Description copied from interface: IDatagramSession
    
    Sends a message to a remote end via the datagram-oriented channel associated with this session.
    If the remoteAddress argument is not null then the method may only be invoked if the associated channel's socket is not connected. In case the argument is null the method will work as the adequate write method.
    The operation is asynchronous.
    This method usually requires that the session has configured a codec pipeline with at least one encoder that accepts the msg as the inbound data. If a codec pipeline is not configured or no encoder accept the msg object it still accepts messages that are of the byte[] or ByteBuffer type.
    This method should be used whenever there will be no need to synchronize on a future object. This will save some resources and may improve performance.
    
    Specified by:
    
    sendnf in interface IDatagramSession
    
    Overrides:
    
    sendnf in class DatagramSession
    
    Parameters:
    
    remoteAddress - the address of the remote end where the message should be sent
    
    msg - the message to be sent
  - close
```
public void close()
```
    Description copied from interface: ISession
    
    Gently closes this session after all pending data waiting for writing are fully flushed. This operation is asynchronous.
    After returning from this method any consecutive writes will be simply discarded.
    
    Specified by:
    
    close in interface ISession
    
    Overrides:
    
    close in class DatagramSession
  - quickClose
```
public void quickClose()
```
    Description copied from interface: ISession
    
    Quickly closes this session without flushing any pending data. This operation is asynchronous.
    After returning from this method any consecutive writes will be simply discarded.
    
    Specified by:
    
    quickClose in interface ISession
    
    Overrides:
    
    quickClose in class DatagramSession
  - dirtyClose
```
public void dirtyClose()
```
    Description copied from interface: ISession
    
    Quickly closes this session without flushing any pending data and without following close procedure of an application layer (e.g. SSL/TLS).
    
    Specified by:
    
    dirtyClose in interface ISession
    
    Overrides:
    
    dirtyClose in class DatagramSession
  - getCreateFuture
```
public IFuture<Void> getCreateFuture()
```
    Description copied from interface: ISession
    
    Gets the future that can be use to wait for the completion of the creation phase.
    
    Specified by:
    
    getCreateFuture in interface ISession
    
    Returns:
    
    the future associated with the creation phase of this session
  - getOpenFuture
```
public IFuture<Void> getOpenFuture()
```
    Description copied from interface: ISession
    
    Gets the future that can be use to wait for the completion of the opening phase.
    
    Specified by:
    
    getOpenFuture in interface ISession
    
    Returns:
    
    the future associated with the opening phase of this session
  - getReadyFuture
```
public IFuture<Void> getReadyFuture()
```
    Description copied from interface: ISession
    
    Gets the future that can be use to wait for the completion of the ready phase.
    
    Specified by:
    
    getReadyFuture in interface ISession
    
    Returns:
    
    the future associated with the opening phase of this session
  - getCloseFuture
```
public IFuture<Void> getCloseFuture()
```
    Description copied from interface: ISession
    
    Gets the future that can be use to wait for the completion of the closing phase.
    
    Specified by:
    
    getCloseFuture in interface ISession
    
    Returns:
    
    the future associated with the closing phase of this session
  - getEndFuture
```
public IFuture<Void> getEndFuture()
```
    Description copied from interface: ISession
    
    Gets the future that can be use to wait for the completion of the ending phase.
    
    Specified by:
    
    getEndFuture in interface ISession
    
    Returns:
    
    the future associated with the ending phase of this session
  - getConfig
```
public ISessionConfig getConfig()
```
    Description copied from interface: ISession
    
    Gets the configuration of this session.
    
    Specified by:
    
    getConfig in interface ISession
    
    Returns:
    
    the configuration
  - getCodecPipeline
```
public ICodecPipeline getCodecPipeline()
```
    Description copied from interface: ISession
    
    Gets the codec pipeline that is associated with this session.
    
    Specified by:
    
    getCodecPipeline in interface ISession
    
    Returns:
    
    the codec pipeline or null if the session does not support it
  - getState
```
public SessionState getState()
```
    Description copied from interface: ISession
    
    Gets the current state of this session.
    
    Specified by:
    
    getState in interface ISession
    
    Returns:
    
    the current state
  - isOpen
```
public boolean isOpen()
```
    Description copied from interface: ISession
    Tells if this session is open. It means that the session is able to communicate with the remote end.
    It is equal to:
```
 return getState() == SessionState.OPEN
 
```
    Specified by:
    
    isOpen in interface ISession
    
    Returns:
    
    true if the session is open.
  - suspendRead
```
public void suspendRead()
```
    Description copied from interface: ISession
    
    Suspends read operations for this session.
    
    Specified by:
    
    suspendRead in interface ISession
  - suspendWrite
```
public void suspendWrite()
```
    Description copied from interface: ISession
    
    Suspends write operations for this session.
    
    Specified by:
    
    suspendWrite in interface ISession
  - resumeRead
```
public void resumeRead()
```
    Description copied from interface: ISession
    
    Resumes read operations for this session.
    
    Specified by:
    
    resumeRead in interface ISession
  - resumeWrite
```
public void resumeWrite()
```
    Description copied from interface: ISession
    
    Resumes write operations for this session.
    
    Specified by:
    
    resumeWrite in interface ISession
  - isReadSuspended
```
public boolean isReadSuspended()
```
    Description copied from interface: ISession
    
    Tells if read operations are suspended for this session.
    
    Specified by:
    
    isReadSuspended in interface ISession
    
    Returns:
    
    true if suspended
  - isWriteSuspended
```
public boolean isWriteSuspended()
```
    Description copied from interface: ISession
    
    Tells if write operations are suspended for this session.
    
    Specified by:
    
    isWriteSuspended in interface ISession
    
    Returns:
    
    true if suspended
  - getReadBytes
```
public final long getReadBytes()
```
    Description copied from interface: ISession
    
    Gets the total number of bytes which were read from this session.
    
    Specified by:
    
    getReadBytes in interface ISession
    
    Returns:
    
    the total number of bytes
  - getWrittenBytes
```
public final long getWrittenBytes()
```
    Description copied from interface: ISession
    
    Gets the total number of bytes which were written to this session.
    
    Specified by:
    
    getWrittenBytes in interface ISession
    
    Returns:
    
    the total number of bytes
  - getReadBytesThroughput
```
public final double getReadBytesThroughput()
```
    Description copied from interface: ISession
    
    Gets the number of read bytes per second.
    
    Specified by:
    
    getReadBytesThroughput in interface ISession
    
    Returns:
    
    the number of read bytes per second
  - getWrittenBytesThroughput
```
public final double getWrittenBytesThroughput()
```
    Description copied from interface: ISession
    
    Gets the number of written bytes per second.
    
    Specified by:
    
    getWrittenBytesThroughput in interface ISession
    
    Returns:
    
    the number of written bytes per second
  - getCreationTime
```
public final long getCreationTime()
```
    Description copied from interface: ISession
    
    Gets the session's creation time in milliseconds.
    
    Specified by:
    
    getCreationTime in interface ISession
    
    Returns:
    
    the session's creation time
  - getLastIoTime
```
public final long getLastIoTime()
```
    Description copied from interface: ISession
    
    Gets the time in milliseconds when I/O operation occurred lastly.
    
    Specified by:
    
    getLastIoTime in interface ISession
    
    Returns:
    
    the time of the last I/O operation
  - getLastReadTime
```
public final long getLastReadTime()
```
    Description copied from interface: ISession
    
    Gets the time in milliseconds when read operation occurred lastly.
    
    Specified by:
    
    getLastReadTime in interface ISession
    
    Returns:
    
    the time of the last read operation
  - getLastWriteTime
```
public final long getLastWriteTime()
```
    Description copied from interface: ISession
    
    Gets the time in milliseconds when write operation occurred lastly.
    
    Specified by:
    
    getLastWriteTime in interface ISession
    
    Returns:
    
    the time of the last write operation
  - getTimer
```
public ISessionTimer getTimer()
```
    Description copied from interface: ISession
    
    Gets the session timer associated with this session.
    
    Specified by:
    
    getTimer in interface ISession
    
    Returns:
    
    the session timer
  - allocate
```
public ByteBuffer allocate(int capacity)
```
    Description copied from interface: ISession
    
    Allocates a byte buffer by using the allocator associated with this session.
    
    Specified by:
    
    allocate in interface ISession
    
    Parameters:
    
    capacity - minimal required capacity
    
    Returns:
    
    the allocated byte buffer
  - release
```
public void release(ByteBuffer buffer)
```
    Description copied from interface: ISession
    
    Release given byte buffer by the allocator associated with this session.
    
    Specified by:
    
    release in interface ISession
    
    Parameters:
    
    buffer - the byte buffer being released

Class EngineDatagramSession

Constructor Summary

Method Summary

Methods inherited from class org.snf4j.core.DatagramSession

Methods inherited from class org.snf4j.core.session.AbstractSession

Methods inherited from class org.snf4j.core.IdentifiableObject

Methods inherited from class java.lang.Object

Methods inherited from interface org.snf4j.core.session.IDatagramSession

Methods inherited from interface org.snf4j.core.session.ISession

Constructor Detail

EngineDatagramSession

EngineDatagramSession

EngineDatagramSession

EngineDatagramSession

Method Detail

setExecutor

getExecutor

beginHandshake

beginLazyHandshake

getEngineSession

getHandler

write

writenf

write

writenf

write

writenf

write

writenf

write

writenf

send

sendnf

send

sendnf

send

sendnf

send

sendnf

send

sendnf

close

quickClose

dirtyClose

getCreateFuture

getOpenFuture

getReadyFuture

getCloseFuture

getEndFuture

getConfig

getCodecPipeline

getState

isOpen

suspendRead

suspendWrite

resumeRead

resumeWrite

isReadSuspended

isWriteSuspended

getReadBytes

getWrittenBytes

getReadBytesThroughput

getWrittenBytesThroughput

getCreationTime

getLastIoTime

getLastReadTime

getLastWriteTime

getTimer

allocate

release