zstd.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: AGPL-3.0-or-later
// Copyright 2026 Johnson Ogundeji
#pragma once
 
 
#ifdef SIGNET_HAS_ZSTD
 
#include "signet/compression/codec.hpp"
 
#include <zstd.h>
 
#include <cstdint>
#include <string>
#include <vector>
 
namespace signet::forge {
 
class ZstdCodec : public CompressionCodec {
public:
    explicit ZstdCodec(int compression_level = 3)
        : level_(compression_level) {}
 
    [[nodiscard]] expected<std::vector<uint8_t>> compress(
        const uint8_t* data, size_t size) const override {
 
        size_t bound = ZSTD_compressBound(size);
        std::vector<uint8_t> out(bound);
 
        size_t compressed_size = ZSTD_compress(
            out.data(), out.size(),
            data, size,
            level_);
 
        if (ZSTD_isError(compressed_size)) {
            return Error{ErrorCode::INTERNAL_ERROR,
                         std::string("ZSTD compress failed: ") +
                         ZSTD_getErrorName(compressed_size)};
        }
 
        out.resize(compressed_size);
        return out;
    }
 
    [[nodiscard]] expected<std::vector<uint8_t>> decompress(
        const uint8_t* data, size_t size,
        size_t uncompressed_size) const override {
 
        static constexpr size_t MAX_DECOMPRESS_SIZE = 256 * 1024 * 1024; // 256 MB
        if (uncompressed_size > MAX_DECOMPRESS_SIZE)
            return Error{ErrorCode::INVALID_ARGUMENT, "Decompression size exceeds 256 MB limit"};
 
        std::vector<uint8_t> out(uncompressed_size);
 
        size_t decompressed_size = ZSTD_decompress(
            out.data(), out.size(),
            data, size);
 
        if (ZSTD_isError(decompressed_size)) {
            return Error{ErrorCode::CORRUPT_PAGE,
                         std::string("ZSTD decompress failed: ") +
                         ZSTD_getErrorName(decompressed_size)};
        }
 
        if (decompressed_size != uncompressed_size) {
            return Error{ErrorCode::CORRUPT_PAGE,
                         "ZSTD: decompressed " +
                         std::to_string(decompressed_size) +
                         " bytes but expected " +
                         std::to_string(uncompressed_size)};
        }
 
        return out;
    }
 
 
    [[nodiscard]] Compression codec_type() const override {
        return Compression::ZSTD;
    }
 
    [[nodiscard]] const char* name() const override {
        return "zstd";
    }
 
 
private:
    int level_;
};
 
// ===========================================================================
// Auto-registration helper
// ===========================================================================
 
inline void register_zstd_codec(int level = 3) {
    CodecRegistry::instance().register_codec(std::make_unique<ZstdCodec>(level));
}
 
} // namespace signet::forge
 
#endif // SIGNET_HAS_ZSTD