public:

OptionsStub();

OptionsStub(const OptionsStub &) = delete;

OptionsStub &operator=(const OptionsStub &) = delete;

~OptionsStub();

public:

StatusStub();

StatusStub(const StatusStub &);

StatusStub &operator=(const StatusStub &);

~StatusStub();

bool ok();

public:

inline CycleTimer() : real_time_us_(0) {}

inline ~CycleTimer() = default;

inline void Start() {

#ifdef WIN32

QueryPerformanceCounter(&start_);

#else

::gettimeofday(&start_, nullptr);

#endif

}

inline void Stop() {

#ifdef WIN32

LARGE_INTEGER stop;

LARGE_INTEGER frequency;

QueryPerformanceCounter(&stop);

QueryPerformanceFrequency(&frequency);

double elapsed = static_cast<double>(stop.QuadPart - start_.QuadPart) /

frequency.QuadPart;

real_time_us_ += elapsed * 1e6 + 0.5;

#else

struct ::timeval stop;

::gettimeofday(&stop, nullptr);

real_time_us_ += 1000000 * (stop.tv_sec - start_.tv_sec);

real_time_us_ += (stop.tv_usec - start_.tv_usec);

#endif

}

inline double Get() { return real_time_us_ * 1e-6; }

private:

int64_t real_time_us_;

#ifdef WIN32

LARGE_INTEGER start_;

#else

struct ::timeval start_;

#endif

public:

inline LogMessage() = default;

~LogMessage();

LogMessage &operator<<(const std::string &message);

LogMessage &operator<<(int number);

public:

inline LogMessageCrash() = default;

~LogMessageCrash();

public:

inline LogMessageVoidify() = default;

inline ~LogMessageVoidify() = default;

// This has to be an operator with a precedence lower than << but

// higher than ?:

inline void operator&(const LogMessage &) {}

public:

ZLib();

~ZLib();

// Wipe a ZLib object to a virgin state. This differs from Reset()

// in that it also breaks any state.

void Reinit();

// Call this to make a zlib buffer as good as new. Here's the only

// case where they differ:

// CompressChunk(a); CompressChunk(b); CompressChunkDone(); vs

// CompressChunk(a); Reset(); CompressChunk(b); CompressChunkDone();

// You'll want to use Reset(), then, when you interrupt a compress

// (or uncompress) in the middle of a chunk and want to start over.

void Reset();

// According to the zlib manual, when you Compress, the destination

// buffer must have size at least src + .1%*src + 12. This function

// helps you calculate that. Augment this to account for a potential

// gzip header and footer, plus a few bytes of slack.

static int MinCompressbufSize(int uncompress_size) {

return uncompress_size + uncompress_size/1000 + 40;

}

// Compresses the source buffer into the destination buffer.

// sourceLen is the byte length of the source buffer.

// Upon entry, destLen is the total size of the destination buffer,

// which must be of size at least MinCompressbufSize(sourceLen).

// Upon exit, destLen is the actual size of the compressed buffer.

//

// This function can be used to compress a whole file at once if the

// input file is mmap'ed.

//

// Returns Z_OK if success, Z_MEM_ERROR if there was not

// enough memory, Z_BUF_ERROR if there was not enough room in the

// output buffer. Note that if the output buffer is exactly the same

// size as the compressed result, we still return Z_BUF_ERROR.

// (check CL#1936076)

int Compress(Bytef *dest, uLongf *destLen,

const Bytef *source, uLong sourceLen);

// Uncompresses the source buffer into the destination buffer.

// The destination buffer must be long enough to hold the entire

// decompressed contents.

//

// Returns Z_OK on success, otherwise, it returns a zlib error code.

int Uncompress(Bytef *dest, uLongf *destLen,

const Bytef *source, uLong sourceLen);

// Uncompress data one chunk at a time -- ie you can call this

// more than once. To get this to work you need to call per-chunk

// and "done" routines.

//

// Returns Z_OK if success, Z_MEM_ERROR if there was not

// enough memory, Z_BUF_ERROR if there was not enough room in the

// output buffer.

int UncompressAtMost(Bytef *dest, uLongf *destLen,

const Bytef *source, uLong *sourceLen);

// Checks gzip footer information, as needed. Mostly this just

// makes sure the checksums match. Whenever you call this, it

// will assume the last 8 bytes from the previous UncompressChunk

// call are the footer. Returns true iff everything looks ok.

bool UncompressChunkDone();

private:

int InflateInit(); // sets up the zlib inflate structure

int DeflateInit(); // sets up the zlib deflate structure

// These init the zlib data structures for compressing/uncompressing

int CompressInit(Bytef *dest, uLongf *destLen,

const Bytef *source, uLong *sourceLen);

int UncompressInit(Bytef *dest, uLongf *destLen,

const Bytef *source, uLong *sourceLen);

// Initialization method to be called if we hit an error while

// uncompressing. On hitting an error, call this method before

// returning the error.

void UncompressErrorInit();

// Helper function for Compress

int CompressChunkOrAll(Bytef *dest, uLongf *destLen,

const Bytef *source, uLong sourceLen,

int flush_mode);

int CompressAtMostOrAll(Bytef *dest, uLongf *destLen,

const Bytef *source, uLong *sourceLen,

int flush_mode);

// Likewise for UncompressAndUncompressChunk

int UncompressChunkOrAll(Bytef *dest, uLongf *destLen,

const Bytef *source, uLong sourceLen,

int flush_mode);

int UncompressAtMostOrAll(Bytef *dest, uLongf *destLen,

const Bytef *source, uLong *sourceLen,

int flush_mode);

// Initialization method to be called if we hit an error while

// compressing. On hitting an error, call this method before

// returning the error.

void CompressErrorInit();

int compression_level_; // compression level

int window_bits_; // log base 2 of the window size used in compression

int mem_level_; // specifies the amount of memory to be used by

// compressor (1-9)

z_stream comp_stream_; // Zlib stream data structure

bool comp_init_; // True if we have initialized comp_stream_

z_stream uncomp_stream_; // Zlib stream data structure

bool uncomp_init_; // True if we have initialized uncomp_stream_

// These are used only with chunked compression.

bool first_chunk_; // true if we need to emit headers with this chunk