proxygen: proxygen::ZstdStreamDecompressor Class Reference

#include <ZstdStreamDecompressor.h>

Public Member Functions
	ZstdStreamDecompressor (size_t, std::string)

	~ZstdStreamDecompressor ()

std::unique_ptr< folly::IOBuf >	decompress (const folly::IOBuf *in)

ZstdStatusType	getStatus ()

Public Attributes
ZstdStatusType	status_

Private Attributes
ZSTD_DStream *	dStream_ {nullptr}

ZSTD_DDict *	dDict_ {nullptr}

size_t	totalLen_ {0}

size_t	totalDec_ {0}

Detailed Description

Definition at line 37 of file ZstdStreamDecompressor.h.

Constructor & Destructor Documentation

ZstdStreamDecompressor::ZstdStreamDecompressor	(	size_t	totalLen,
		std::string	dictStr
	)

explicit

Definition at line 21 of file ZstdStreamDecompressor.cpp.

References dDict_, dStream_, proxygen::ERROR, and status_.

   : totalLen_(totalLen) {
   dStream_ = ZSTD_createDStream();
   if (dictStr != "") {
     dDict_ = ZSTD_createDDict(&dictStr, dictStr.length());
     if (dStream_ == nullptr || dDict_ == nullptr ||
         ZSTD_isError(ZSTD_initDStream_usingDDict(dStream_, dDict_))) {
       status_ = ZstdStatusType::ERROR;
     }
   } else {
     if (dStream_ == nullptr ||
         ZSTD_isError(ZSTD_initDStream(dStream_))) {
       status_ = ZstdStatusType::ERROR;
     }
   }
 }

ZstdStreamDecompressor::~ZstdStreamDecompressor ( )

Definition at line 38 of file ZstdStreamDecompressor.cpp.

References dDict_, and dStream_.

                                                 {
   if (dStream_) {
     ZSTD_freeDStream(dStream_);
   }
   if (dDict_) {
     ZSTD_freeDDict(dDict_);
   }
 }

Member Function Documentation

std::unique_ptr< folly::IOBuf > ZstdStreamDecompressor::decompress ( const folly::IOBuf * in )

Definition at line 47 of file ZstdStreamDecompressor.cpp.

References proxygen::CONTINUE, folly::IOBuf::create(), dStream_, proxygen::ERROR, gmock_output_test::output, folly::gen::range(), status_, proxygen::SUCCESS, totalDec_, totalLen_, and uint8_t.

                         {
   if (dStream_ == nullptr) {
     status_ = ZstdStatusType::ERROR;
     return nullptr;
   }
 
   auto out = folly::IOBuf::create(ZSTD_DStreamOutSize());
 
   size_t buffOutSize = ZSTD_DStreamOutSize();
   std::unique_ptr<unsigned char[]> buffOut(new unsigned char[buffOutSize]);
   auto appender = folly::io::Appender(out.get(), buffOutSize);
 
   for (const folly::ByteRange range : *in) {
     ZSTD_inBuffer input = {range.data(), range.size(), 0};
     while (input.pos < input.size) {
       ZSTD_outBuffer output = {buffOut.get(), buffOutSize, 0};
       size_t toRead = ZSTD_decompressStream(dStream_, &output, &input);
 
       if (ZSTD_isError(toRead)) {
         status_ = ZstdStatusType::ERROR;
         return nullptr;
       }
 
       if (toRead == 0) {
         ZSTD_resetDStream(dStream_);
       }
 
       if (output.pos > 0) {
         size_t copied =
           appender.pushAtMost((const uint8_t*)output.dst, output.pos);
         CHECK(copied == output.pos);
       }
       totalDec_ += input.size;
 
       if (totalDec_ < totalLen_) {
         status_ = ZstdStatusType::CONTINUE;
       } else if (totalDec_ > totalLen_) {
         status_ = ZstdStatusType::ERROR;
       } else {
         status_ = ZstdStatusType::SUCCESS;
       }
     }
   }
 
   return out;
 }