Compression.h

#pragma once
 
#include <xrpl/basics/CompressionAlgorithms.h>
#include <xrpl/basics/Log.h>
 
namespace xrpl::compression {
 
constexpr std::size_t kHeaderBytes = 6;
constexpr std::size_t kHeaderBytesCompressed = 10;
 
// All values other than 'none' must have the high bit. The low order four bits
// must be 0.
enum class Algorithm : std::uint8_t { None = 0x00, LZ4 = 0x90 };
 
enum class Compressed : std::uint8_t { On, Off };

template <typename InputStream>
std::size_t
decompress(
    InputStream& in,
    std::size_t inSize,
    std::uint8_t* decompressed,
    std::size_t decompressedSize,
    Algorithm algorithm = Algorithm::LZ4)
{
    try
    {
        if (algorithm == Algorithm::LZ4)
        {
            return xrpl::compression_algorithms::lz4Decompress(
                in, inSize, decompressed, decompressedSize);
        }
 
        // LCOV_EXCL_START
        JLOG(debugLog().warn()) << "decompress: invalid compression algorithm "
                                << static_cast<int>(algorithm);
        UNREACHABLE(
            "xrpl::compression::decompress : invalid compression "
            "algorithm");
        // LCOV_EXCL_STOP
    }
    catch (...)  // NOLINT(bugprone-empty-catch)
    {
    }
    return 0;
}

template <class BufferFactory>
std::size_t
compress(
    void const* in,
    std::size_t inSize,
    BufferFactory&& bf,
    Algorithm algorithm = Algorithm::LZ4)
{
    try
    {
        if (algorithm == Algorithm::LZ4)
        {
            return xrpl::compression_algorithms::lz4Compress(
                in, inSize, std::forward<BufferFactory>(bf));
        }
 
        // LCOV_EXCL_START
        JLOG(debugLog().warn()) << "compress: invalid compression algorithm"
                                << static_cast<int>(algorithm);
        UNREACHABLE(
            "xrpl::compression::compress : invalid compression "
            "algorithm");
        // LCOV_EXCL_STOP
    }
    catch (...)  // NOLINT(bugprone-empty-catch)
    {
    }
    return 0;
}
}  // namespace xrpl::compression