Method write

libminifi/src/io/ZlibStream.cpp:64–107

}

int ZlibCompressStream::write(const uint8_t* value, int size) {
  gsl_Expects(size >= 0);
  if (state_ != ZlibStreamState::INITIALIZED) {
    logger_->log_error("writeData called in invalid ZlibCompressStream state, state is %hhu", state_);
    return -1;
  }

  strm_.next_in = const_cast<uint8_t*>(value);
  strm_.avail_in = size;

  /*
   * deflate consumes all input data it can (i.e. if it has enough output buffer it never leaves input data unconsumed)
   * and fills the output buffer to the brim every time it can. This means that the proper way to use deflate is to
   * watch avail_out: once deflate does not have to fill it to the brim, then it has consumed all data we have provided
   * to it, and does not need more output buffer for the time being.
   * When we have no more input data, we must call deflate with Z_FINISH to make it empty its internal buffers and
   * close the compressed stream.
   */
  do {
    logger_->log_trace("writeData has %u B of input data left", strm_.avail_in);

    strm_.next_out = outputBuffer_.data();
    strm_.avail_out = gsl::narrow<uInt>(outputBuffer_.size());

    int flush = value == nullptr ? Z_FINISH : Z_NO_FLUSH;
    logger_->log_trace("calling deflate with flush %d", flush);

    int ret = deflate(&strm_, flush);
    if (ret == Z_STREAM_ERROR) {
      logger_->log_error("deflate failed, error code: %d", ret);
      state_ = ZlibStreamState::ERRORED;
      return -1;
    }
    int output_size = gsl::narrow<int>(outputBuffer_.size() - strm_.avail_out);
    logger_->log_trace("deflate produced %d B of output data", output_size);
    if (output_->write(outputBuffer_.data(), output_size) != output_size) {
      logger_->log_error("Failed to write to underlying stream");
      state_ = ZlibStreamState::ERRORED;
      return -1;
    }
  } while (strm_.avail_out == 0);

  return size;
}

void ZlibCompressStream::close() {
  if (state_ == ZlibStreamState::INITIALIZED) {