How to use

asRawStream

method

in

rawhttp.core.body.BodyReader

/**
 * @return the body of the HTTP message as a {@link ChunkedBodyContents} if the body indeed used
 * the chunked transfer coding. If the body was not chunked, this method returns an empty value.
 * @throws IOException if an error occurs while consuming the message body
 */
public Optional<ChunkedBodyContents> asChunkedBodyContents() throws IOException {
  return framedBody.use(
      cl -> Optional.empty(),
      chunked -> Optional.of(chunked.getContents(asRawStream())),
      ct -> Optional.empty());
}

/**
 * @return the body of the HTTP message as a {@link ChunkedBodyContents} if the body indeed used
 * the chunked transfer coding. If the body was not chunked, this method returns an empty value.
 * @throws IOException if an error occurs while consuming the message body
 */
public Optional<ChunkedBodyContents> asChunkedBodyContents() throws IOException {
  return framedBody.use(
      cl -> Optional.empty(),
      chunked -> Optional.of(chunked.getContents(asRawStream())),
      ct -> Optional.empty());
}

/**
 * @return the raw HTTP message's body as bytes.
 * <p>
 * This method does not unframe nor decode the body in case the body is encoded.
 * To get the decoded body, use
 * {@link #decodeBody()} or {@link #decodeBodyToString(Charset)}.
 * @throws IOException if an error occurs while consuming the message body
 */
public byte[] asRawBytes() throws IOException {
  return framedBody.getBodyConsumer().consume(asRawStream());
}

/**
 * @return the raw HTTP message's body as bytes.
 * <p>
 * This method does not unframe nor decode the body in case the body is encoded.
 * To get the decoded body, use
 * {@link #decodeBody()} or {@link #decodeBodyToString(Charset)}.
 * @throws IOException if an error occurs while consuming the message body
 */
public byte[] asRawBytes() throws IOException {
  return framedBody.getBodyConsumer().consume(asRawStream());
}

/**
 * Read the raw HTTP message body, simultaneously writing it to the given output.
 * <p>
 * This method may not validate the full HTTP message before it starts writing it out.
 * To perform a full validation first, call {@link #eager()} to get an eager reader.
 *
 * @param out        to write the HTTP body to
 * @param bufferSize size of the buffer to use for writing, if possible
 * @throws IOException if an error occurs while writing the message
 * @see BodyReader#writeDecodedTo(OutputStream, int)
 */
public void writeTo(OutputStream out, int bufferSize) throws IOException {
  framedBody.getBodyConsumer().consumeInto(asRawStream(), out, bufferSize);
}

/**
 * Read the raw HTTP message body, simultaneously writing it to the given output.
 * <p>
 * This method may not validate the full HTTP message before it starts writing it out.
 * To perform a full validation first, call {@link #eager()} to get an eager reader.
 *
 * @param out        to write the HTTP body to
 * @param bufferSize size of the buffer to use for writing, if possible
 * @throws IOException if an error occurs while writing the message
 * @see BodyReader#writeDecodedTo(OutputStream, int)
 */
public void writeTo(OutputStream out, int bufferSize) throws IOException {
  framedBody.getBodyConsumer().consumeInto(asRawStream(), out, bufferSize);
}

/**
 * Get a lazy stream of chunks if the message body is chunked, or empty otherwise.
 * <p>
 * The last chunk is always the empty chunk, so once the empty chunk is received,
 * trying to consume another chunk will result in an error.
 *
 * @return lazy stream of chunks if the message body is chunked, or empty otherwise.
 * @throws IOException if an error occurs while consuming the body
 */
public Optional<Iterator<ChunkedBodyContents.Chunk>> asChunkStream() throws IOException {
  BodyConsumer consumer = framedBody.getBodyConsumer();
  if (consumer instanceof BodyConsumer.ChunkedBodyConsumer) {
    try {
      return Optional.of(((BodyConsumer.ChunkedBodyConsumer) consumer)
          .consumeLazily(asRawStream()));
    } catch (RuntimeException e) {
      Throwable cause = e.getCause();
      if (cause instanceof IOException) {
        throw (IOException) cause;
      }
      throw e;
    }
  } else {
    return Optional.empty();
  }
}

/**
 * Get a lazy stream of chunks if the message body is chunked, or empty otherwise.
 * <p>
 * The last chunk is always the empty chunk, so once the empty chunk is received,
 * trying to consume another chunk will result in an error.
 *
 * @return lazy stream of chunks if the message body is chunked, or empty otherwise.
 * @throws IOException if an error occurs while consuming the body
 */
public Optional<Iterator<ChunkedBodyContents.Chunk>> asChunkStream() throws IOException {
  BodyConsumer consumer = framedBody.getBodyConsumer();
  if (consumer instanceof BodyConsumer.ChunkedBodyConsumer) {
    try {
      return Optional.of(((BodyConsumer.ChunkedBodyConsumer) consumer)
          .consumeLazily(asRawStream()));
    } catch (RuntimeException e) {
      Throwable cause = e.getCause();
      if (cause instanceof IOException) {
        throw (IOException) cause;
      }
      throw e;
    }
  } else {
    return Optional.empty();
  }
}

public RawHttpResponse<CloseableHttpResponse> send(RawHttpRequest request) throws IOException {
  RequestBuilder builder = RequestBuilder.create(request.getMethod());
  builder.setUri(request.getUri());
  builder.setVersion(toProtocolVersion(request.getStartLine().getHttpVersion()));
  request.getHeaders().getHeaderNames().forEach((name) ->
      request.getHeaders().get(name).forEach(value ->
          builder.addHeader(new BasicHeader(name, value))));
  request.getBody().ifPresent(b -> builder.setEntity(new InputStreamEntity(b.asRawStream())));
  CloseableHttpResponse response = httpClient.execute(builder.build());
  RawHttpHeaders headers = readHeaders(response);
  StatusLine statusLine = adaptStatus(response.getStatusLine());
  @Nullable LazyBodyReader body;
  if (response.getEntity() != null) {
    FramedBody framedBody = http.getFramedBody(statusLine, headers);
    body = new LazyBodyReader(framedBody, response.getEntity().getContent());
  } else {
    body = null;
  }
  return new RawHttpResponse<>(response, request, statusLine, headers, body);
}

/**
 * Read the HTTP message body, simultaneously unframing and decoding it,
 * then writing the decoded body to the given output.
 * <p>
 * This method may not validate the full HTTP message before it starts writing it out.
 * To perform a full validation first, call {@link #eager()} to get an eager reader.
 *
 * @param out        to write the unframed, decoded message body to
 * @param bufferSize size of the buffer to use for writing, if possible
 * @throws IOException              if an error occurs while writing the message
 * @throws UnknownEncodingException if the body is encoded with an encoding that is unknown
 *                                  by the {@link HttpBodyEncodingRegistry}.
 */
public void writeDecodedTo(OutputStream out, int bufferSize) throws IOException {
  DecodingOutputStream decodedStream = framedBody.getBodyDecoder().decoding(out);
  framedBody.getBodyConsumer().consumeDataInto(asRawStream(), decodedStream, bufferSize);
  decodedStream.finishDecoding();
}

/**
 * Read the HTTP message body, simultaneously unframing and decoding it,
 * then writing the decoded body to the given output.
 * <p>
 * This method may not validate the full HTTP message before it starts writing it out.
 * To perform a full validation first, call {@link #eager()} to get an eager reader.
 *
 * @param out        to write the unframed, decoded message body to
 * @param bufferSize size of the buffer to use for writing, if possible
 * @throws IOException              if an error occurs while writing the message
 * @throws UnknownEncodingException if the body is encoded with an encoding that is unknown
 *                                  by the {@link HttpBodyEncodingRegistry}.
 */
public void writeDecodedTo(OutputStream out, int bufferSize) throws IOException {
  DecodingOutputStream decodedStream = framedBody.getBodyDecoder().decoding(out);
  framedBody.getBodyConsumer().consumeDataInto(asRawStream(), decodedStream, bufferSize);
  decodedStream.finishDecoding();
}

InputStream responseStream = response.getBody().map(b -> b.isChunked() ? b.asRawStream() : null)
    .orElseThrow(() ->
        new IllegalStateException("HTTP response does not contain a chunked body"));