How to use

BufferedOutput

in

org.glassfish.grizzly.streams

@Override
public void ensureBufferCapacity(final int size) throws IOException {
  if (size > bufferSize) {
    throw new IllegalArgumentException("Size exceeds max size limit: " + bufferSize);
  }
  if (getBufferedSize() >= bufferSize) {
    overflow(null);
  }
  if (size == 0) return;
  
  if (buffer != null) {
    final int bufferRemaining = buffer.remaining();
    if (bufferRemaining < size) {
      overflow(null);
      ensureBufferCapacity(size);
    }
  } else {
    buffer = newBuffer(bufferSize);
  }
}

@Override
public GrizzlyFuture<Integer> flush(CompletionHandler<Integer> completionHandler)
    throws IOException {
  return overflow(completionHandler);
}

@Override
public void write(byte data) throws IOException {
  ensureBufferCapacity(1);
  buffer.put(data);
}

  public void close(Integer result) {
    try {
      onClosed();
    } catch (IOException ignored) {
    } finally {
      if (completionHandler != null) {
        completionHandler.completed(result);
      }
      future.result(result);
    }
  }
});

  final GrizzlyFuture<Integer> future = flush0(multiBufferWindow,
      completionHandler);
  buffer.flip();
  final GrizzlyFuture<Integer> future = flush0(buffer,
      completionHandler);
  if (future.isDone() && !buffer.isComposite()) {
return flush0(null, completionHandler);

@Override
public GrizzlyFuture<Integer> flush(CompletionHandler<Integer> completionHandler)
    throws IOException {
  return overflow(completionHandler);
}

@Override
public void write(byte data) throws IOException {
  ensureBufferCapacity(1);
  buffer.put(data);
}

  public void close(Integer result) {
    try {
      onClosed();
    } catch (IOException ignored) {
    } finally {
      if (completionHandler != null) {
        completionHandler.completed(result);
      }
      future.result(result);
    }
  }
});

  final GrizzlyFuture<Integer> future = flush0(multiBufferWindow,
      completionHandler);
  buffer.flip();
  final GrizzlyFuture<Integer> future = flush0(buffer,
      completionHandler);
  if (future.isDone() && !buffer.isComposite()) {
return flush0(null, completionHandler);

@Override
public void ensureBufferCapacity(final int size) throws IOException {
  if (size > bufferSize) {
    throw new IllegalArgumentException("Size exceeds max size limit: " + bufferSize);
  }
  if (getBufferedSize() >= bufferSize) {
    overflow(null);
  }
  if (size == 0) return;
  
  if (buffer != null) {
    final int bufferRemaining = buffer.remaining();
    if (bufferRemaining < size) {
      overflow(null);
      ensureBufferCapacity(size);
    }
  } else {
    buffer = newBuffer(bufferSize);
  }
}

@Override
public GrizzlyFuture<Integer> flush(CompletionHandler<Integer> completionHandler)
    throws IOException {
  return overflow(completionHandler);
}

@Override
public void write(byte data) throws IOException {
  ensureBufferCapacity(1);
  buffer.put(data);
}

  public void close(Integer result) {
    try {
      onClosed();
    } catch (IOException ignored) {
    } finally {
      if (completionHandler != null) {
        completionHandler.completed(result);
      }
      future.result(result);
    }
  }
});

  final GrizzlyFuture<Integer> future = flush0(multiBufferWindow,
      completionHandler);
  buffer.flip();
  final GrizzlyFuture<Integer> future = flush0(buffer,
      completionHandler);
  if (future.isDone() && !buffer.isComposite()) {
return flush0(null, completionHandler);

@Override
public void ensureBufferCapacity(final int size) throws IOException {
  if (size > bufferSize) {
    throw new IllegalArgumentException("Size exceeds max size limit: " + bufferSize);
  }
  if (getBufferedSize() >= bufferSize) {
    overflow(null);
  }
  if (size == 0) return;
  
  if (buffer != null) {
    final int bufferRemaining = buffer.remaining();
    if (bufferRemaining < size) {
      overflow(null);
      ensureBufferCapacity(size);
    }
  } else {
    buffer = newBuffer(bufferSize);
  }
}

@Override
public GrizzlyFuture<Integer> flush(CompletionHandler<Integer> completionHandler)
    throws IOException {
  return overflow(completionHandler);
}

@Override
public void write(byte data) throws IOException {
  ensureBufferCapacity(1);
  buffer.put(data);
}

  public void close(Integer result) {
    try {
      onClosed();
    } catch (IOException ignored) {
    } finally {
      if (completionHandler != null) {
        completionHandler.completed(result);
      }
      future.result(result);
    }
  }
});

  final GrizzlyFuture<Integer> future = flush0(multiBufferWindow,
      completionHandler);
  buffer.flip();
  final GrizzlyFuture<Integer> future = flush0(buffer,
      completionHandler);
  if (future.isDone() && !buffer.isComposite()) {
return flush0(null, completionHandler);

@Override
public void ensureBufferCapacity(final int size) throws IOException {
  if (size > bufferSize) {
    throw new IllegalArgumentException("Size exceeds max size limit: " + bufferSize);
  }
  if (getBufferedSize() >= bufferSize) {
    overflow(null);
  }
  if (size == 0) return;
  
  if (buffer != null) {
    final int bufferRemaining = buffer.remaining();
    if (bufferRemaining < size) {
      overflow(null);
      ensureBufferCapacity(size);
    }
  } else {
    buffer = newBuffer(bufferSize);
  }
}