BmnFileReaderZLibNG.cxx

Go to the documentation of this file.

// headers from this target
#include "BmnFileReaderZLibNG.h"
 
#include "BmnDefinitions.h"
// std:: headers
#include <cassert>
#include <filesystem>
// the main ZLib header
#ifdef BMNCOMPRESSION_WITH_ZLIB_NG
#include <zlib-ng.h>
#else
// If we build without the library, it would be find to use #pragma on the entire object, without push
// and pop, but it's nothing too important for us here - just for simplicity I'm going with this def
DISABLE_UNUSED_PARAM_WARNING
#endif   // BMNCOMPRESSION_WITH_ZLIB_NG
 
// o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o
// ================== BmnFileReaderZLibNG public methods ==================
// o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o
 
// ========== BmnIFileReaderInterface ==========
 
BmnFileReaderZLibNG::BmnFileReaderZLibNG(const std::string& fileName)
    : BmnIFileReader(BmnFileType::ZLib_ng, fileName)
    , fZlibNgStream(nullptr)
    , fArchiveReadManager(*this)
    , fNumberOfReadBytes(0ull)
    , fLastReturnStatus(0)
{}
 
BmnFileReaderZLibNG::BmnFileReaderZLibNG(std::string&& fileName)
    : BmnIFileReader(BmnFileType::ZLib_ng, std::move(fileName))
    , fZlibNgStream(nullptr)
    , fArchiveReadManager(*this)
    , fNumberOfReadBytes(0ull)
    , fLastReturnStatus(0)
{}
 
BmnFileReaderZLibNG::BmnFileReaderZLibNG(const std::filesystem::path& filePath)
    : BmnIFileReader(BmnFileType::ZLib_ng, filePath)
    , fZlibNgStream(nullptr)
    , fArchiveReadManager(*this)
    , fNumberOfReadBytes(0ull)
    , fLastReturnStatus(0)
{}
 
BmnFileReaderZLibNG::BmnFileReaderZLibNG(std::filesystem::path&& filePath)
    : BmnIFileReader(BmnFileType::ZLib_ng, std::move(filePath))
    , fZlibNgStream(nullptr)
    , fArchiveReadManager(*this)
    , fNumberOfReadBytes(0ull)
    , fLastReturnStatus(0)
{}
 
BmnFileReaderZLibNG::~BmnFileReaderZLibNG()
{
    BmnFileReaderZLibNG::Close();
    // another delete here as Close might go bad and still not break the code (in Release builds)
#ifdef BMNCOMPRESSION_WITH_ZLIB_NG
    delete fZlibNgStream;
#endif   // BMNCOMPRESSION_WITH_ZLIB_NG
}
 
void BmnFileReaderZLibNG::Open(const BmnBinaryFileProcessingOptions processingFlags)
{
#ifdef BMNCOMPRESSION_WITH_ZLIB_NG
    /*
    While we actually don't need so many comments and checks here, we are still performing them just to ensure
    one doesn't make an accidental mistake - it might be easier to catch it
    */
    if (fZlibNgStream) {
        LOG(error) << "ZLib-ng stream is already valid!";
        return;
    }
    if (!PerformStandardChecksBeforeOpening(processingFlags))
        return;
    fArchiveReadManager.Open(fFilePath, std::ios::in | std::ios::binary);
    fZlibNgStream =
        new zng_stream_s{nullptr, 0u, 0u, nullptr, 0u, 0u, nullptr, nullptr, nullptr, nullptr, nullptr, 0, 0u, 0u};
    // according to documentation, adding +32 enables auto-detection of headers, i.e., the stream will decide whether to
    // use gzip or zlib formats
    if (zng_inflateInit2(fZlibNgStream, 15 + 32) != Z_OK) {
        LOG(error) << "Failed to initialize ZLib-ng stream! Reason: " << fZlibNgStream->msg << '\n';
        zng_inflateEnd(fZlibNgStream);
        delete fZlibNgStream;
        fZlibNgStream = nullptr;
        fArchiveReadManager.Close();
    }
 
#else
    throw std::runtime_error{"Trying to use ZLIB-NG while BMN is not compiled with it!"};
#endif   // BMNCOMPRESSION_WITH_ZLIB_NG
}
 
void BmnFileReaderZLibNG::Close() noexcept
{
#ifdef BMNCOMPRESSION_WITH_ZLIB_NG
    if (!fZlibNgStream)
        return;
    if (zng_inflateEnd(fZlibNgStream) != Z_OK) {
        LOG(fatal) << "Failed to free ZLib-ng stream - possible huge memory leak! Failure reason: "
                   << fZlibNgStream->msg << '\n';
        std::terminate();
    }
    delete fZlibNgStream;
    fZlibNgStream = nullptr;
    fArchiveReadManager.Close();
    fNumberOfReadBytes = 0ull;
    fLastReturnStatus = 0;
#endif   // BMNCOMPRESSION_WITH_ZLIB_NG
}
 
int64_t BmnFileReaderZLibNG::Read(void* dataToFill, const int64_t sizeToFill)
{
#ifdef BMNCOMPRESSION_WITH_ZLIB_NG
    if (!IsStreamInGoodState())
        return 0ll;
    return fArchiveReadManager.Read(dataToFill, sizeToFill);
#else
    throw std::runtime_error{"Trying to use ZLIB-NG while BMN is not compiled with it!"};
#endif   // BMNCOMPRESSION_WITH_ZLIB_NG
}
 
int64_t BmnFileReaderZLibNG::Tell() const noexcept
{
    return fNumberOfReadBytes + fArchiveReadManager.GetCurrentOutputBufferPosition()
           - fArchiveReadManager.GetTotalOutputBufferFilledSize();
}
 
void BmnFileReaderZLibNG::Seek(int64_t value)
{
#ifdef BMNCOMPRESSION_WITH_ZLIB_NG
    if (value < 0ll || (size_t)value == fNumberOfReadBytes)
        return;
    if (!IsStreamInGoodState()) {
        LOG(error) << "Before calling `BmnFileReaderZLibNG::Seek` ensure to clear bad flags!\n";
        return;
    }
    if (!fZlibNgStream) {
        LOG(error) << "Before calling `BmnFileReaderZLibNG::Seek` ensure to open the stream!\n";
        return;
    }
    if (!fArchiveReadManager.IsOpen()) {
        LOG(error) << "Reading file missing while calling `BmnFileReaderZLibNG::Seek`\n";
        return;
    }
    if ((size_t)value < (fNumberOfReadBytes - fArchiveReadManager.GetTotalOutputBufferFilledSize())) {
        Close();
        Open(BmnBinaryFileProcessingOptions::ReadBinary);
    }
    // in theory I could check IsOpen again for unexpected errors, but....
    fArchiveReadManager.MoveToDecompressingLocation(value);
#else
    throw std::runtime_error{"Trying to use ZLIB-NG while BMN is not compiled with it!"};
#endif   // BMNCOMPRESSION_WITH_ZLIB_NG
}
 
bool BmnFileReaderZLibNG::IsGood() const noexcept
{
#ifdef BMNCOMPRESSION_WITH_ZLIB_NG
    return fZlibNgStream && IsStreamInGoodState() && fArchiveReadManager.IsGood();
#else
    return false;
#endif   // BMNCOMPRESSION_WITH_ZLIB_NG
}
 
bool BmnFileReaderZLibNG::IsEOF() const noexcept
{
    return fArchiveReadManager.IsEOF();
}
 
void BmnFileReaderZLibNG::ClearStateFlags()
{
    // I don't like this method much
    fLastReturnStatus = 0;
    fArchiveReadManager.Clear();
}
 
bool BmnFileReaderZLibNG::IsOpen() const noexcept
{
    return fArchiveReadManager.IsOpen() && fZlibNgStream;
}
 
// ========== BmnIArchiveLib Interface ==========
 
BmnFileStreamResults BmnFileReaderZLibNG::Uncompress(const void* source,
                                                     const size_t sourceTotalSize,
                                                     size_t& numberOfReadBytes,
                                                     void* output,
                                                     const size_t outputTotalSize,
                                                     size_t& numberOfSetOutputBytes)
{
    if (!fZlibNgStream)
        return BmnFileStreamResults::FileNotOpen;
#ifdef BMNCOMPRESSION_WITH_ZLIB_NG
    if (!IsStreamInGoodState())
        return BmnFileStreamResults::TryingToReadBadStream;
    fZlibNgStream->next_out = (Bytef*)output;
    fZlibNgStream->avail_out = (uInt)outputTotalSize;
    fZlibNgStream->total_out = 0u;
    fZlibNgStream->next_in = (Bytef*)source;
    fZlibNgStream->avail_in = (uInt)sourceTotalSize;
    fZlibNgStream->total_in = 0u;
    fLastReturnStatus = zng_inflate(fZlibNgStream, Z_NO_FLUSH);
    if (!IsStreamInGoodState())
        return BmnFileStreamResults::UnexpectedFail;
    numberOfReadBytes = (size_t)fZlibNgStream->total_in;
    numberOfSetOutputBytes = (size_t)fZlibNgStream->total_out;
    fNumberOfReadBytes += numberOfSetOutputBytes;
    if (fLastReturnStatus == Z_STREAM_END)
        return BmnFileStreamResults::ReachedEOF;
    return BmnFileStreamResults::Success;
#else
    throw std::runtime_error{"Trying to use ZLIB-NG while BMN is not compiled with it!"};
#endif   // BMNCOMPRESSION_WITH_ZLIB_NG
}
 
std::string BmnFileReaderZLibNG::GetLastUncompressErrorDescription() const noexcept
{
#ifdef BMNCOMPRESSION_WITH_ZLIB_NG
    std::string strToReturn{};
    if (fZlibNgStream && fZlibNgStream->msg)
        strToReturn = std::string{fZlibNgStream->msg};
    return strToReturn;
#else
    return std::string{"BMN NOT BUILT WITH ZLIB"};
#endif   // BMNCOMPRESSION_WITH_ZLIB_NG
}
 
bool BmnFileReaderZLibNG::JumpsAllowed() const noexcept
{
    return false;
}
 
void BmnFileReaderZLibNG::JumpTo(size_t)
{
    /*
    In general with ZLib we could allow jumping while carefully building ZLib blocks. Still,
    that would be allowed only in files written by our own encoder, while GZip would not produce
    the same results. Thus, we don't allow jumps no matter what and if jumps are needed, we can
    think about it and adapt later
    */
    LOG(warning) << "Calling `BmnFileReaderZLibNG::JumpTo` while the type doesn't allow jumping!\n";
}
 
size_t BmnFileReaderZLibNG::GetNumberOfDecompressedBytes() const noexcept
{
    return fNumberOfReadBytes;
}
 
bool BmnFileReaderZLibNG::HasReachedTheEndOfStream() const noexcept
{
#ifdef BMNCOMPRESSION_WITH_ZLIB_NG
    if (!IsStreamInGoodState())
        return true;
    return fLastReturnStatus == Z_STREAM_END;
#else
    return true;
#endif   // BMNCOMPRESSION_WITH_ZLIB_NG
}
 
bool BmnFileReaderZLibNG::IsStreamInGoodState() const noexcept
{
#ifdef BMNCOMPRESSION_WITH_ZLIB_NG
    return fLastReturnStatus >= 0;
#else
    return false;
#endif   // BMNCOMPRESSION_WITH_ZLIB_NG
}
 
#ifndef BMNCOMPRESSION_WITH_ZLIB_NG
RESTORE_UNUSED_PARAM_WARNING
#endif   // BMNCOMPRESSION_WITH_ZLIB_NG