CompressionAlgorithms.h

#ifndef XRPL_COMPRESSIONALGORITHMS_H_INCLUDED
#define XRPL_COMPRESSIONALGORITHMS_H_INCLUDED
 
#include <xrpl/basics/contract.h>
 
#include <lz4.h>
 
#include <algorithm>
#include <cstdint>
#include <stdexcept>
#include <vector>
 
namespace ripple {
 
namespace compression_algorithms {
 
template <typename BufferFactory>
std::size_t
lz4Compress(void const* in, std::size_t inSize, BufferFactory&& bf)
{
    if (inSize > UINT32_MAX)
        Throw<std::runtime_error>("lz4 compress: invalid size");
 
    auto const outCapacity = LZ4_compressBound(inSize);
 
    // Request the caller to allocate and return the buffer to hold compressed
    // data
    auto compressed = bf(outCapacity);
 
    auto compressedSize = LZ4_compress_default(
        reinterpret_cast<char const*>(in),
        reinterpret_cast<char*>(compressed),
        inSize,
        outCapacity);
    if (compressedSize == 0)
        Throw<std::runtime_error>("lz4 compress: failed");
 
    return compressedSize;
}
 
inline std::size_t
lz4Decompress(
    std::uint8_t const* in,
    std::size_t inSizeUnchecked,
    std::uint8_t* decompressed,
    std::size_t decompressedSizeUnchecked)
{
    int const inSize = static_cast<int>(inSizeUnchecked);
    int const decompressedSize = static_cast<int>(decompressedSizeUnchecked);
 
    if (inSize <= 0)
        Throw<std::runtime_error>("lz4Decompress: integer overflow (input)");
 
    if (decompressedSize <= 0)
        Throw<std::runtime_error>("lz4Decompress: integer overflow (output)");
 
    if (LZ4_decompress_safe(
            reinterpret_cast<char const*>(in),
            reinterpret_cast<char*>(decompressed),
            inSize,
            decompressedSize) != decompressedSize)
        Throw<std::runtime_error>("lz4Decompress: failed");
 
    return decompressedSize;
}
 
template <typename InputStream>
std::size_t
lz4Decompress(
    InputStream& in,
    std::size_t inSize,
    std::uint8_t* decompressed,
    std::size_t decompressedSize)
{
    std::vector<std::uint8_t> compressed;
    std::uint8_t const* chunk = nullptr;
    int chunkSize = 0;
    int copiedInSize = 0;
    auto const currentBytes = in.ByteCount();
 
    // Use the first chunk if it is >= inSize bytes of the compressed message.
    // Otherwise copy inSize bytes of chunks into compressed buffer and
    // use the buffer to decompress.
    while (in.Next(reinterpret_cast<void const**>(&chunk), &chunkSize))
    {
        if (copiedInSize == 0)
        {
            if (chunkSize >= inSize)
            {
                copiedInSize = inSize;
                break;
            }
            compressed.resize(inSize);
        }
 
        chunkSize = chunkSize < (inSize - copiedInSize)
            ? chunkSize
            : (inSize - copiedInSize);
 
        std::copy(chunk, chunk + chunkSize, compressed.data() + copiedInSize);
 
        copiedInSize += chunkSize;
 
        if (copiedInSize == inSize)
        {
            chunk = compressed.data();
            break;
        }
    }
 
    // Put back unused bytes
    if (in.ByteCount() > (currentBytes + copiedInSize))
        in.BackUp(in.ByteCount() - currentBytes - copiedInSize);
 
    if ((copiedInSize == 0 && chunkSize < inSize) ||
        (copiedInSize > 0 && copiedInSize != inSize))
        Throw<std::runtime_error>("lz4 decompress: insufficient input size");
 
    return lz4Decompress(chunk, inSize, decompressed, decompressedSize);
}
 
}  // namespace compression_algorithms
 
}  // namespace ripple
 
#endif  // XRPL_COMPRESSIONALGORITHMS_H_INCLUDED