zlib_compress.hpp

浏览该文件的文档.

#ifndef NEFORCE_COMPRESS_ZLIB_COMPRESS_HPP__
#define NEFORCE_COMPRESS_ZLIB_COMPRESS_HPP__

 
#ifdef NEFORCE_SUPPORT_ZLIB
#    include <zlib.h>
#    include "NeForce/core/string/string.hpp"
#    include "NeForce/core/memory/unique_ptr.hpp"
NEFORCE_BEGIN_NAMESPACE__


struct zlib_exception final : thirdparty_exception {
    explicit zlib_exception(const char* info = "Zlib Operation Failed.", int code = 0) noexcept :
    thirdparty_exception(info),
    code_(code) {}
 
    explicit zlib_exception(const exception& e) :
    thirdparty_exception(e) {}
 
    ~zlib_exception() override = default;
 
    NEFORCE_NODISCARD const char* type() const noexcept override { return "zlib_exception"; }
 
private:
    int code_{0};
};
 // Exceptions


enum class compress_level : int8_t {
    none = Z_NO_COMPRESSION,               
    best_speed = Z_BEST_SPEED,             
    default_level = Z_DEFAULT_COMPRESSION, 
    best_compression = Z_BEST_COMPRESSION  
};

enum class compress_strategy : int8_t {
    default_strategy = Z_DEFAULT_STRATEGY, 
    filtered = Z_FILTERED,                 
    huffman_only = Z_HUFFMAN_ONLY,         
    rle = Z_RLE,                           
    fixed = Z_FIXED                        
};

enum class compress_format : int8_t {
    zlib,   
    gzip,   
    deflate 
};
 

class NEFORCE_API zlib_compressor {
private:
    struct compressor_stream_deleter {
        void operator()(::z_stream* s) const noexcept {
            if (s != nullptr) {
                if (s->state != nullptr) {
                    ::deflateEnd(s);
                }
                delete s;
            }
        }
    };
 
    struct decompressor_stream_deleter {
        void operator()(::z_stream* s) const noexcept {
            if (s != nullptr) {
                if (s->state != nullptr) {
                    ::inflateEnd(s);
                }
                delete s;
            }
        }
    };

    NEFORCE_NODISCARD static byte_vector compress_data(const byte_t* data, size_t size, compress_level level,
                                                       compress_strategy strategy, compress_format format);

    NEFORCE_NODISCARD static byte_vector decompress_data(byte_t* data, size_t size, size_t estimated_original_size,
                                                         compress_format format);
 
public:
    template <typename Iterator>
    NEFORCE_NODISCARD static byte_vector
    compress(Iterator begin, Iterator end, const compress_level level = compress_level::default_level,
             const compress_strategy strategy = compress_strategy::default_strategy,
             const compress_format format = compress_format::zlib) {
        static_assert(is_ranges_cot_iter_v<Iterator>, "Iterator must be contiguous_iterator");
        static_assert(sizeof(iter_value_t<Iterator>) == 1, "Iterator must point to byte-sized elements");
 
        const auto* data = reinterpret_cast<const byte_t*>(&*begin);
        const size_t data_size = _NEFORCE distance(begin, end);
        return compress_data(data, data_size, level, strategy, format);
    }

    NEFORCE_NODISCARD static byte_vector
    compress(const string_view data, const compress_level level = compress_level::default_level,
             const compress_strategy strategy = compress_strategy::default_strategy,
             const compress_format format = compress_format::zlib) {
 
        return compress_data(reinterpret_cast<const byte_t*>(data.data()), data.size(), level, strategy, format);
    }

    template <typename T>
    NEFORCE_NODISCARD static byte_vector
    compress(const vector<T>& data, const compress_level level = compress_level::default_level,
             const compress_strategy strategy = compress_strategy::default_strategy,
             const compress_format format = compress_format::zlib) {
        static_assert(sizeof(T) == 1, "Vector must contain byte-sized elements");
 
        return zlib_compressor::compress_data(reinterpret_cast<const byte_t*>(data.data()), data.size() * sizeof(T),
                                              level, strategy, format);
    }

    template <typename Iterator>
    NEFORCE_NODISCARD static byte_vector decompress(Iterator begin, Iterator end,
                                                    const size_t estimated_original_size = 0,
                                                    const compress_format format = compress_format::zlib) {
 
        static_assert(is_ranges_cot_iter_v<Iterator>, "Iterator must be contiguous_iterator");
        static_assert(sizeof(iter_value_t<Iterator>) == 1, "Iterator must point to byte-sized elements");
 
        auto* data = reinterpret_cast<byte_t*>(&*begin);
        const size_t data_size = _NEFORCE distance(begin, end);
 
        return decompress_data(data, data_size, estimated_original_size, format);
    }

    NEFORCE_NODISCARD static byte_vector decompress(const byte_view& data, const size_t estimated_original_size = 0,
                                                    const compress_format format = compress_format::zlib) {
        return decompress_data(data.data(), data.size(), estimated_original_size, format);
    }

    class NEFORCE_API stream_compressor {
    private:
        unique_ptr<::z_stream, compressor_stream_deleter> stream_; 
 
        bool initialized_ = false; 
        size_t bytes_input_ = 0;   
        size_t bytes_output_ = 0;  
 
    public:
        explicit stream_compressor(compress_level level = compress_level::default_level,
                                   compress_strategy strategy = compress_strategy::default_strategy,
                                   compress_format format = compress_format::zlib);

        ~stream_compressor() = default;
 
        stream_compressor(const stream_compressor&) = delete;
        stream_compressor& operator=(const stream_compressor&) = delete;

        stream_compressor(stream_compressor&& other) noexcept;

        stream_compressor& operator=(stream_compressor&& other) noexcept;

        byte_vector compress(const cbyte_view& data, bool finish = false);

        byte_vector compress(string_view data, bool finish = false);

        byte_vector finish();

        void reset(compress_level level = compress_level::default_level,
                   compress_strategy strategy = compress_strategy::default_strategy,
                   compress_format format = compress_format::zlib);

        void soft_reset();

        NEFORCE_NODISCARD size_t bytes_input() const noexcept { return bytes_input_; }

        NEFORCE_NODISCARD size_t bytes_output() const noexcept { return bytes_output_; }

        NEFORCE_NODISCARD double compression_ratio() const noexcept {
            return bytes_input_ > 0 ? static_cast<double>(bytes_output_) / static_cast<double>(bytes_input_) : 0.0;
        }
    };

    class NEFORCE_API stream_decompressor {
    private:
        unique_ptr<::z_stream, decompressor_stream_deleter> stream_; 
 
        bool initialized_ = false; 
        size_t bytes_input_ = 0;   
        size_t bytes_output_ = 0;  
 
    public:
        explicit stream_decompressor(compress_format format = compress_format::zlib);

        ~stream_decompressor() = default;
 
        stream_decompressor(const stream_decompressor&) = delete;
        stream_decompressor& operator=(const stream_decompressor&) = delete;

        stream_decompressor(stream_decompressor&& other) noexcept;

        stream_decompressor& operator=(stream_decompressor&& other) noexcept;

        byte_vector decompress(const byte_view& data, bool finish = false);

        byte_vector finish();

        void reset(compress_format format = compress_format::zlib);

        void soft_reset();

        NEFORCE_NODISCARD size_t bytes_input() const noexcept { return bytes_input_; }

        NEFORCE_NODISCARD size_t bytes_output() const noexcept { return bytes_output_; }

        NEFORCE_NODISCARD double expansion_ratio() const noexcept {
            return bytes_input_ > 0 ? static_cast<double>(bytes_output_) / static_cast<double>(bytes_input_) : 0.0;
        }
    };
};
 // Compression
 
NEFORCE_END_NAMESPACE__
#endif
#endif // NEFORCE_COMPRESS_ZLIB_COMPRESS_HPP__