proxygen::ZlibStreamCompressor Class Reference

#include <ZlibStreamCompressor.h>

Public Member Functions
	ZlibStreamCompressor (ZlibCompressionType type, int level)
	~ZlibStreamCompressor ()
void	init (ZlibCompressionType type, int level)
std::unique_ptr< folly::IOBuf >	compress (const folly::IOBuf *in, bool trailer=true)
int	getStatus ()
bool	hasError ()
bool	finished ()

Private Attributes
ZlibCompressionType	type_ {ZlibCompressionType::NONE}
int	level_ {Z_DEFAULT_COMPRESSION}
z_stream	zlibStream_
int	status_ {-1}

Detailed Description

Definition at line 25 of file ZlibStreamCompressor.h.

Constructor & Destructor Documentation

proxygen::ZlibStreamCompressor::ZlibStreamCompressor ( ZlibCompressionType  type, int  level  )

explicit

Definition at line 95 of file ZlibStreamCompressor.cpp.

References init().

    : status_(Z_OK) {
  init(type, level);
}

proxygen::ZlibStreamCompressor::~ZlibStreamCompressor

(

)

Definition at line 100 of file ZlibStreamCompressor.cpp.

References proxygen::NONE, status_, type_, and zlibStream_.

                                            {
  if (type_ != ZlibCompressionType::NONE) {
    status_ = deflateEnd(&zlibStream_);
  }
}

Member Function Documentation

std::unique_ptr< IOBuf > proxygen::ZlibStreamCompressor::compress	(	const folly::IOBuf *	in,
		bool	trailer = true
	)

Definition at line 109 of file ZlibStreamCompressor.cpp.

References folly::io::addOutputBuffer(), folly::FATAL, folly::IOBuf::prev(), folly::gen::range(), status_, folly::IOBuf::trimEnd(), uint32_t, uint64_t, uint8_t, and zlibStream_.

Referenced by compressThenDecompress().

                                                                    {
  auto bufferLength = FLAGS_zlib_compressor_buffer_growth;

  auto out = addOutputBuffer(&zlibStream_, bufferLength);

  for (auto& range : *in) {
    uint64_t remaining = range.size();
    uint64_t written = 0;
    while (remaining) {
      uint32_t step = remaining;
      zlibStream_.next_in = const_cast<uint8_t*>(range.data() + written);
      zlibStream_.avail_in = step;
      remaining -= step;
      written += step;

      while (zlibStream_.avail_in != 0) {
        status_ = deflateHelper(&zlibStream_, out.get(), Z_NO_FLUSH);
        if (status_ != Z_OK) {
          DLOG(FATAL) << "Deflate failed: " << zlibStream_.msg;
          return nullptr;
        }
      }
    }
  }

  if (trailer) {
    do {
      status_ = deflateHelper(&zlibStream_, out.get(), Z_FINISH);
    } while (status_ == Z_OK);

    if (status_ != Z_STREAM_END) {
      DLOG(FATAL) << "Deflate failed: " << zlibStream_.msg;
      return nullptr;
    }
  } else {
    do {
      status_ = deflateHelper(&zlibStream_, out.get(), Z_SYNC_FLUSH);
    } while (zlibStream_.avail_out == 0);

    if (status_ != Z_OK) {
      DLOG(FATAL) << "Deflate failed: " << zlibStream_.msg;
      return nullptr;
    }
  }

  out->prev()->trimEnd(zlibStream_.avail_out);

  zlibStream_.next_out = Z_NULL;
  zlibStream_.avail_out = 0;

  return out;
}

bool proxygen::ZlibStreamCompressor::finished ( )

inline

Definition at line 40 of file ZlibStreamCompressor.h.

{ return status_ == Z_STREAM_END; }

int proxygen::ZlibStreamCompressor::getStatus ( )

inline

Definition at line 36 of file ZlibStreamCompressor.h.

Referenced by compressThenDecompress().

{ return status_; }

bool proxygen::ZlibStreamCompressor::hasError ( )

inline

Definition at line 38 of file ZlibStreamCompressor.h.

Referenced by compressThenDecompress().

{ return status_ != Z_OK && status_ != Z_STREAM_END; }

void proxygen::ZlibStreamCompressor::init	(	ZlibCompressionType	type,
		int	level
	)

Definition at line 51 of file ZlibStreamCompressor.cpp.

References proxygen::ERROR, folly::NONE, type, and type_.

Referenced by ZlibStreamCompressor().

                                                                       {

  DCHECK(type_ == ZlibCompressionType::NONE)
      << "Attempt to re-initialize compression stream";

  type_ = type;
  level_ = level;
  status_ = Z_OK;

  zlibStream_.zalloc = Z_NULL;
  zlibStream_.zfree = Z_NULL;
  zlibStream_.opaque = Z_NULL;
  zlibStream_.total_in = 0;
  zlibStream_.next_in = Z_NULL;
  zlibStream_.avail_in = 0;
  zlibStream_.avail_out = 0;
  zlibStream_.next_out = Z_NULL;

  DCHECK(level_ == Z_DEFAULT_COMPRESSION ||
         (level_ >= Z_NO_COMPRESSION && level_ <= Z_BEST_COMPRESSION))
      << "Invalid Zlib compression level. level=" << level_;

  switch (type_) {
  case ZlibCompressionType::GZIP:
    status_ = deflateInit2(&zlibStream_,
                           level_,
                           Z_DEFLATED,
                           static_cast<int32_t>(type),
                           MAX_MEM_LEVEL,
                           Z_DEFAULT_STRATEGY);
    break;
  case ZlibCompressionType::DEFLATE:
    status_ = deflateInit(&zlibStream_, level);
    break;
  default:
    DCHECK(false) << "Unsupported zlib compression type.";
    break;
  }

  if (status_ != Z_OK) {
    LOG(ERROR) << "error initializing zlib stream. r=" << status_;
  }
}

Member Data Documentation

int proxygen::ZlibStreamCompressor::level_ {Z_DEFAULT_COMPRESSION}

private

Definition at line 44 of file ZlibStreamCompressor.h.

int proxygen::ZlibStreamCompressor::status_ {-1}

private

Definition at line 46 of file ZlibStreamCompressor.h.

Referenced by compress(), and ~ZlibStreamCompressor().

ZlibCompressionType proxygen::ZlibStreamCompressor::type_ {ZlibCompressionType::NONE}

private

Definition at line 43 of file ZlibStreamCompressor.h.

Referenced by ~ZlibStreamCompressor().

z_stream proxygen::ZlibStreamCompressor::zlibStream_

private

Definition at line 45 of file ZlibStreamCompressor.h.

Referenced by compress(), and ~ZlibStreamCompressor().

---

The documentation for this class was generated from the following files:

• proxygen/lib/utils/ZlibStreamCompressor.h
• proxygen/lib/utils/ZlibStreamCompressor.cpp