How to use

IoFilter$NextFilter

in

org.littleshoot.mina.common

  nextFilter.messageSent(session, message);
} else {
  ByteBuffer byteBuffer = getNextByteBuffer(inputStream);
    nextFilter.messageSent(session, inputStream);
  } else {
    nextFilter.filterWrite(session, new WriteRequest(byteBuffer));

  public void flush() {
    while (!messageQueue.isEmpty()) {
      nextFilter.messageReceived(session, messageQueue.remove(0));
    }
  }
}

  Object message) throws Exception {
if (!(message instanceof ByteBuffer)) {
  nextFilter.messageReceived(session, message);
  return;

  nextFilter.messageSent(session, message);
} else {
  session.setAttribute(CURRENT_STREAM, inputStream);
      .getFuture());
  nextFilter.filterWrite(session, new WriteRequest(byteBuffer));
nextFilter.filterWrite(session, writeRequest);

@Override
public void filterWrite(NextFilter nextFilter, IoSession session,
    WriteRequest writeRequest) throws Exception {
  Object message = writeRequest.getMessage();
  if (message instanceof ByteBuffer) {
    nextFilter.filterWrite(session, writeRequest);
    return;
  }
  ProtocolEncoder encoder = getEncoder(session);
  ProtocolEncoderOutputImpl encoderOut = getEncoderOut(session,
      nextFilter, writeRequest);
  try {
    encoder.encode(session, message, encoderOut);
    encoderOut.flush();
    nextFilter.filterWrite(session, new WriteRequest(
        new MessageByteBuffer(writeRequest.getMessage()),
        writeRequest.getFuture(), writeRequest.getDestination()));
  } catch (Throwable t) {
    ProtocolEncoderException pee;
    if (t instanceof ProtocolEncoderException) {
      pee = (ProtocolEncoderException) t;
    } else {
      pee = new ProtocolEncoderException(t);
    }
    throw pee;
  }
}

@Override
public void sessionClosed(NextFilter nextFilter, IoSession session)
    throws Exception {
  // Call finishDecode() first when a connection is closed.
  ProtocolDecoder decoder = getDecoder(session);
  ProtocolDecoderOutput decoderOut = getDecoderOut(session, nextFilter);
  try {
    decoder.finishDecode(session, decoderOut);
  } catch (Throwable t) {
    ProtocolDecoderException pde;
    if (t instanceof ProtocolDecoderException) {
      pde = (ProtocolDecoderException) t;
    } else {
      pde = new ProtocolDecoderException(t);
    }
    throw pde;
  } finally {
    // Dispose all.
    disposeEncoder(session);
    disposeDecoder(session);
    disposeDecoderOut(session);
    decoderOut.flush();
  }
  nextFilter.sessionClosed(session);
}

protected void processEvent(NextFilter nextFilter, IoSession session,
    EventType type, Object data) {
  if (type == EventType.RECEIVED) {
    nextFilter.messageReceived(session, data);
  } else if (type == EventType.SENT) {
    nextFilter.messageSent(session, data);
  } else if (type == EventType.EXCEPTION) {
    nextFilter.exceptionCaught(session, (Throwable) data);
  } else if (type == EventType.IDLE) {
    nextFilter.sessionIdle(session, (IdleStatus) data);
  } else if (type == EventType.OPENED) {
    nextFilter.sessionOpened(session);
  } else if (type == EventType.CLOSED) {
    nextFilter.sessionClosed(session);
  }
}

public void sessionClosed(NextFilter nextFilter, IoSession session) {
  nextFilter.sessionClosed(session);
}

public void sessionOpened(NextFilter nextFilter, IoSession session) {
  nextFilter.sessionOpened(session);
}

public void sessionCreated(NextFilter nextFilter, IoSession session) {
  nextFilter.sessionCreated(session);
}

public void sessionCreated(NextFilter nextFilter, IoSession session) {
  nextFilter.sessionCreated(session);
}

public void messageReceived(NextFilter nextFilter, IoSession session,
    Object message) throws Exception {
  nextFilter.messageReceived(session, message);
}

public void filterWrite(NextFilter nextFilter, IoSession session,
    WriteRequest writeRequest) throws Exception {
  nextFilter.filterWrite(session, writeRequest);
}

public void sessionCreated(NextFilter nextFilter, IoSession session)
    throws Exception {
  nextFilter.sessionCreated(session);
}

public void sessionClosed(NextFilter nextFilter, IoSession session) {
  SessionLog.info(session, "CLOSED");
  nextFilter.sessionClosed(session);
}

public void filterClose(NextFilter nextFilter, IoSession session)
    throws Exception {
  nextFilter.filterClose(session);
}

public void sessionIdle(NextFilter nextFilter, IoSession session,
    IdleStatus status) {
  nextFilter.sessionIdle(session, status);
}

public void messageSent(NextFilter nextFilter, IoSession session,
    Object message) throws Exception {
  nextFilter.messageSent(session, message);
}

public void exceptionCaught(NextFilter nextFilter, IoSession session,
    Throwable cause) throws Exception {
  nextFilter.exceptionCaught(session, cause);
}

public void sessionClosed(NextFilter nextFilter, IoSession session)
    throws Exception {
  nextFilter.sessionClosed(session);
}