How to use

FeedableBodyGenerator

in

org.asynchttpclient.request.body.generator

@Override
public boolean feed(ByteBuf buffer, boolean isLast) throws Exception {
 return feedableBodyGenerator.feed(buffer, isLast);
}

@Override
public void setListener(FeedListener listener) {
 feedListener = listener;
 feedableBodyGenerator.setListener(listener);
}

public StreamedBody(FeedableBodyGenerator bodyGenerator, long contentLength) {
 this.body = bodyGenerator.createBody();
 this.subscriber = new SimpleSubscriber(bodyGenerator);
 this.contentLength = contentLength;
}

if (bg instanceof FeedableBodyGenerator) {
  final FeedableBodyGenerator feedableBodyGenerator = (FeedableBodyGenerator) bg;
  feedableBodyGenerator.writeChunkBoundaries();
  feedableBodyGenerator.setListener(new FeedListener() {
    @Override
    public void onContentAdded() {

@Override
public void writeChunkBoundaries() {
  feedableBodyGenerator.writeChunkBoundaries();
}

 @Override
 public void onComplete() {
  try {
   feeder.feed(Unpooled.EMPTY_BUFFER, true);
  } catch (Exception e) {
   LOGGER.info("Ignoring exception occurred while completing stream processing.", e);
   this.subscription.cancel();
  }
 }
}

if (bg instanceof FeedableBodyGenerator && !(bg instanceof ReactiveStreamsBodyGenerator)) {
 final ChunkedWriteHandler chunkedWriteHandler = channel.pipeline().get(ChunkedWriteHandler.class);
 FeedableBodyGenerator.class.cast(bg).setListener(new FeedListener() {
  @Override
  public void onContentAdded() {

public StreamedBody(Publisher<ByteBuffer> publisher, FeedableBodyGenerator bodyGenerator) {
  this.body = bodyGenerator.createBody();
  this.subscriber = new SimpleSubscriber(bodyGenerator);
}

@Override
public void onNext(ByteBuf b) {
 assertNotNull(b, "bytebuf");
 try {
  feeder.feed(b, false);
 } catch (Exception e) {
  LOGGER.error("Exception occurred while processing element in stream.", e);
  subscription.cancel();
 }
}

@Override
public void setListener(FeedListener listener) {
  feedListener.set(listener);
  feedableBodyGenerator.setListener(listener);
}

private void feed(FeedableBodyGenerator feedableBodyGenerator, InputStream is) throws Exception {
 try (InputStream inputStream = is) {
  byte[] buffer = new byte[512];
  for (int i; (i = inputStream.read(buffer)) > -1; ) {
   byte[] chunk = new byte[i];
   System.arraycopy(buffer, 0, chunk, 0, i);
   feedableBodyGenerator.feed(Unpooled.wrappedBuffer(chunk), false);
  }
 }
 feedableBodyGenerator.feed(Unpooled.EMPTY_BUFFER, true);
}

@Override
public void feed(ByteBuffer buffer, boolean isLast) {
  feedableBodyGenerator.feed(buffer, isLast);
}

@Override
public void onNext(ByteBuffer t) {
  if (t == null) throw null;
  try {
    feeder.feed(t, false);
  } catch (Exception e) {
    LOGGER.error("Exception occurred while processing element in stream.", e);
    subscription.cancel();
  }
}

  @Override
  public void onComplete() {
    try {
     feeder.feed(EMPTY, true);
    } 
    catch (Exception e) {
      LOGGER.info("Ignoring exception occurred while completing stream processing.", e);
      this.subscription.cancel();
    }
  }
}