ZlibBufferWriter.hpp

Go to the documentation of this file.

#ifndef BYTEME_ZLIB_BUFFER_WRITER_HPP
#define BYTEME_ZLIB_BUFFER_WRITER_HPP
 
#include <stdexcept>
#include <vector>
#include <cstddef>
 
#include "zlib.h"
 
#include "Writer.hpp"
#include "check_buffer_size.hpp"
 
namespace byteme {
 
struct ZlibBufferWriterOptions {
    int mode = 2;
 
    int compression_level = 6;
 
    std::size_t buffer_size = 65536;
};
struct ZlibBufferWriterOptions {…};
 
class ZlibBufferWriter final : public Writer {
private:
    struct ZStream {
        ZStream(int mode, int level) {
            strm.zalloc = Z_NULL;
            strm.zfree = Z_NULL;
            strm.opaque = Z_NULL;
            strm.avail_in = 0;
            strm.next_in = Z_NULL;
 
            // Check out https://zlib.net/manual.html for the constants.
            int windowBits;
            if (mode == 0) { // deflate
                windowBits = -15;
            } else if (mode == 1) { // Zlib
                windowBits = 15;
            } else if (mode == 2) { // Gzip
                windowBits = 16 + 15;
            } else {
                throw std::runtime_error("unknown Zlib compression mode supplied");
            } 
 
            int ret = deflateInit2(&strm, level, Z_DEFLATED, windowBits, 8, Z_DEFAULT_STRATEGY);
            if (ret != Z_OK) {
                throw std::runtime_error("failed to initialize Zlib buffer compression");
            }
        }
 
        ~ZStream() {
            deflateEnd(&strm);
            return;
        }
 
    public:
        // Delete the remaining constructors.
        ZStream(const ZStream&) = delete;
        ZStream(ZStream&&) = delete;
        ZStream& operator=(const ZStream&) = delete;
        ZStream& operator=(ZStream&&) = delete;
 
    public:
        z_stream strm;
    };
public:
    ZlibBufferWriter(const ZlibBufferWriterOptions& options) : 
        my_zstr(options.mode, options.compression_level),
        my_holding(
            check_buffer_size<decltype(decltype(ZStream::strm)::avail_out)>( // constrained for the z_stream interface.
                check_buffer_size(options.buffer_size)
            )
        )
    {}
    ZlibBufferWriter(const ZlibBufferWriterOptions& options) :  {…}
 
public:
    using Writer::write;
 
    void write(const unsigned char* buffer, std::size_t n) {
        typedef decltype(decltype(ZStream::strm)::avail_in) Size; // constrained for the z_stream interface.
        safe_write<Size, false>(
            buffer,
            n,
            [&](const unsigned char* buffer0, Size n0) -> void {
                my_zstr.strm.next_in = const_cast<unsigned char*>(buffer0); // for C compatibility.
                my_zstr.strm.avail_in = n0;
                dump(Z_NO_FLUSH);
            }
        );
    }
    void write(const unsigned char* buffer, std::size_t n) {…}
 
    void finish() {
        my_zstr.strm.next_in = nullptr;
        my_zstr.strm.avail_in = 0;
        dump(Z_FINISH);
    }
    void finish() {…}
 
private:
    ZStream my_zstr;
    std::vector<unsigned char> my_holding;
 
    void dump(int flag) {
        do {
            my_zstr.strm.avail_out = my_holding.size();
            my_zstr.strm.next_out = my_holding.data();
            deflate(&(my_zstr.strm), flag); // no need to check, see https://zlib.net/zlib_how.html.
            std::size_t compressed = my_holding.size() - my_zstr.strm.avail_out;
            output.insert(output.end(), my_holding.begin(), my_holding.begin() + compressed);
        } while (my_zstr.strm.avail_out == 0);
    }
 
public:
    // Exposed for back-compatibility only.
    std::vector<unsigned char> output;
    std::vector<unsigned char>& get_output() {
        return output;
    }
    std::vector<unsigned char>& get_output() {…}
};
class ZlibBufferWriter final : public Writer {…};
 
}
 
#endif