How to use

TCPNIOServerConnection$RegisterAcceptedChannelCompletionHandler

in

org.glassfish.grizzly.nio.transport

/**
 * Asynchronously accept a {@link Connection}
 *
 * @return {@link Future}
 * @throws java.io.IOException
 */
protected GrizzlyFuture<Connection> acceptAsync() throws IOException {
  if (!isOpen()) {
    throw new IOException("Connection is closed");
  }
  synchronized (acceptSync) {
    final FutureImpl<Connection> future = SafeFutureImpl.create();
    final SocketChannel acceptedChannel = doAccept();
    if (acceptedChannel != null) {
      configureAcceptedChannel(acceptedChannel);
      final TCPNIOConnection clientConnection =
          createClientConnection(acceptedChannel);
      registerAcceptedChannel(clientConnection,
          new RegisterAcceptedChannelCompletionHandler(future),
          0);
    } else {
      acceptListener = future;
      enableIOEvent(IOEvent.SERVER_ACCEPT);
    }
    return future;
  }
}

    new RegisterAcceptedChannelCompletionHandler(acceptListener),
    0);
acceptListener = null;

    new RegisterAcceptedChannelCompletionHandler(acceptListener),
    0);
acceptListener = null;

    new RegisterAcceptedChannelCompletionHandler(acceptListener),
    0);
acceptListener = null;

    new RegisterAcceptedChannelCompletionHandler(acceptListener),
    0);
acceptListener = null;

    new RegisterAcceptedChannelCompletionHandler(acceptListener),
    0);
acceptListener = null;

    new RegisterAcceptedChannelCompletionHandler(acceptListener),
    0);
acceptListener = null;

    new RegisterAcceptedChannelCompletionHandler(acceptListener),
    0);
acceptListener = null;

    new RegisterAcceptedChannelCompletionHandler(acceptListener),
    0);
acceptListener = null;

    new RegisterAcceptedChannelCompletionHandler(acceptListener),
    0);
acceptListener = null;

    new RegisterAcceptedChannelCompletionHandler(acceptListener),
    0);
acceptListener = null;

    new RegisterAcceptedChannelCompletionHandler(acceptListener),
    0);
acceptListener = null;

    new RegisterAcceptedChannelCompletionHandler(acceptListener),
    0);
acceptListener = null;

/**
 * Asynchronously accept a {@link Connection}
 *
 * @return {@link Future}
 * @throws java.io.IOException
 */
protected GrizzlyFuture<Connection> acceptAsync() throws IOException {
  if (!isOpen()) {
    throw new IOException("Connection is closed");
  }
  synchronized (acceptSync) {
    final FutureImpl<Connection> future = SafeFutureImpl.create();
    final SocketChannel acceptedChannel = doAccept();
    if (acceptedChannel != null) {
      configureAcceptedChannel(acceptedChannel);
      final TCPNIOConnection clientConnection =
          createClientConnection(acceptedChannel);
      registerAcceptedChannel(clientConnection,
          new RegisterAcceptedChannelCompletionHandler(future),
          0);
    } else {
      acceptListener = future;
      enableIOEvent(IOEvent.SERVER_ACCEPT);
    }
    return future;
  }
}

/**
 * Asynchronously accept a {@link Connection}
 *
 * @return {@link Future}
 * @throws java.io.IOException
 */
protected GrizzlyFuture<Connection> acceptAsync() throws IOException {
  if (!isOpen()) {
    throw new IOException("Connection is closed");
  }
  synchronized (acceptSync) {
    final FutureImpl<Connection> future = SafeFutureImpl.create();
    final SocketChannel acceptedChannel = doAccept();
    if (acceptedChannel != null) {
      configureAcceptedChannel(acceptedChannel);
      final TCPNIOConnection clientConnection =
          createClientConnection(acceptedChannel);
      registerAcceptedChannel(clientConnection,
          new RegisterAcceptedChannelCompletionHandler(future),
          0);
    } else {
      acceptListener = future;
      enableIOEvent(IOEvent.SERVER_ACCEPT);
    }
    return future;
  }
}

/**
 * Asynchronously accept a {@link Connection}
 *
 * @return {@link Future}
 * @throws java.io.IOException
 */
protected GrizzlyFuture<Connection> acceptAsync() throws IOException {
  if (!isOpen()) {
    throw new IOException("Connection is closed");
  }
  synchronized (acceptSync) {
    final FutureImpl<Connection> future = SafeFutureImpl.create();
    final SocketChannel acceptedChannel = doAccept();
    if (acceptedChannel != null) {
      configureAcceptedChannel(acceptedChannel);
      final TCPNIOConnection clientConnection =
          createClientConnection(acceptedChannel);
      registerAcceptedChannel(clientConnection,
          new RegisterAcceptedChannelCompletionHandler(future),
          0);
    } else {
      acceptListener = future;
      enableIOEvent(IOEvent.SERVER_ACCEPT);
    }
    return future;
  }
}

/**
 * Asynchronously accept a {@link Connection}
 *
 * @return {@link Future}
 * @throws java.io.IOException
 */
protected GrizzlyFuture<Connection> acceptAsync() throws IOException {
  if (!isOpen()) {
    throw new IOException("Connection is closed");
  }
  synchronized (acceptSync) {
    final FutureImpl<Connection> future = SafeFutureImpl.create();
    final SocketChannel acceptedChannel = doAccept();
    if (acceptedChannel != null) {
      configureAcceptedChannel(acceptedChannel);
      final TCPNIOConnection clientConnection =
          createClientConnection(acceptedChannel);
      registerAcceptedChannel(clientConnection,
          new RegisterAcceptedChannelCompletionHandler(future),
          0);
    } else {
      acceptListener = future;
      enableIOEvent(IOEvent.SERVER_ACCEPT);
    }
    return future;
  }
}

/**
 * Asynchronously accept a {@link Connection}
 *
 * @return {@link Future}
 * @throws java.io.IOException
 */
protected GrizzlyFuture<Connection> acceptAsync() throws IOException {
  if (!isOpen()) {
    throw new IOException("Connection is closed");
  }
  synchronized (acceptSync) {
    final FutureImpl<Connection> future = SafeFutureImpl.create();
    final SocketChannel acceptedChannel = doAccept();
    if (acceptedChannel != null) {
      configureAcceptedChannel(acceptedChannel);
      final TCPNIOConnection clientConnection =
          createClientConnection(acceptedChannel);
      registerAcceptedChannel(clientConnection,
          new RegisterAcceptedChannelCompletionHandler(future),
          0);
    } else {
      acceptListener = future;
      enableIOEvent(IOEvent.SERVER_ACCEPT);
    }
    return future;
  }
}

/**
 * Asynchronously accept a {@link Connection}
 *
 * @return {@link Future}
 * @throws java.io.IOException
 */
protected GrizzlyFuture<Connection> acceptAsync() throws IOException {
  if (!isOpen()) {
    throw new IOException("Connection is closed");
  }
  synchronized (acceptSync) {
    final FutureImpl<Connection> future = SafeFutureImpl.create();
    final SocketChannel acceptedChannel = doAccept();
    if (acceptedChannel != null) {
      configureAcceptedChannel(acceptedChannel);
      final TCPNIOConnection clientConnection =
          createClientConnection(acceptedChannel);
      registerAcceptedChannel(clientConnection,
          new RegisterAcceptedChannelCompletionHandler(future),
          0);
    } else {
      acceptListener = future;
      enableIOEvent(IOEvent.SERVER_ACCEPT);
    }
    return future;
  }
}

/**
 * Asynchronously accept a {@link Connection}
 *
 * @return {@link Future}
 * @throws java.io.IOException
 */
protected GrizzlyFuture<Connection> acceptAsync() throws IOException {
  if (!isOpen()) {
    throw new IOException("Connection is closed");
  }
  synchronized (acceptSync) {
    final FutureImpl<Connection> future = SafeFutureImpl.create();
    final SocketChannel acceptedChannel = doAccept();
    if (acceptedChannel != null) {
      configureAcceptedChannel(acceptedChannel);
      final TCPNIOConnection clientConnection =
          createClientConnection(acceptedChannel);
      registerAcceptedChannel(clientConnection,
          new RegisterAcceptedChannelCompletionHandler(future),
          0);
    } else {
      acceptListener = future;
      enableIOEvent(IOEvent.SERVER_ACCEPT);
    }
    return future;
  }
}