BmnFileReaderZLib.cxx

Go to the documentation of this file.

// headers from this target
#include "BmnFileReaderZLib.h"
 
#include "BmnDefinitions.h"
// std:: headers
#include <cassert>
#include <filesystem>
// the main ZLib header
#ifdef BMNCOMPRESSION_WITH_ZLIB
#include <zlib.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
 
// 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
// ================== BmnFileReaderZLib 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
 
// ========== BmnIFileReaderInterface ==========
 
BmnFileReaderZLib::BmnFileReaderZLib(const std::string& fileName)
    : BmnIFileReader(BmnFileType::ZLib, fileName)
    , fZlibStream(nullptr)
    , fArchiveReadManager(*this)
    , fNumberOfReadBytes(0ull)
    , fLastReturnStatus(0)
{}
 
BmnFileReaderZLib::BmnFileReaderZLib(std::string&& fileName)
    : BmnIFileReader(BmnFileType::ZLib, std::move(fileName))
    , fZlibStream(nullptr)
    , fArchiveReadManager(*this)
    , fNumberOfReadBytes(0ull)
    , fLastReturnStatus(0)
{}
 
BmnFileReaderZLib::BmnFileReaderZLib(const std::filesystem::path& filePath)
    : BmnIFileReader(BmnFileType::ZLib, filePath)
    , fZlibStream(nullptr)
    , fArchiveReadManager(*this)
    , fNumberOfReadBytes(0ull)
    , fLastReturnStatus(0)
{}
 
BmnFileReaderZLib::BmnFileReaderZLib(std::filesystem::path&& filePath)
    : BmnIFileReader(BmnFileType::ZLib, std::move(filePath))
    , fZlibStream(nullptr)
    , fArchiveReadManager(*this)
    , fNumberOfReadBytes(0ull)
    , fLastReturnStatus(0)
{}
 
BmnFileReaderZLib::~BmnFileReaderZLib()
{
    BmnFileReaderZLib::Close();
    // another delete here as Close might go bad and still not break the code (in Release builds)
#ifdef BMNCOMPRESSION_WITH_ZLIB
    delete fZlibStream;
#endif   // BMNCOMPRESSION_WITH_ZLIB
}
 
void BmnFileReaderZLib::Open(const BmnBinaryFileProcessingOptions processingFlags)
{
#ifdef BMNCOMPRESSION_WITH_ZLIB
    /*
    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 (fZlibStream) {
        LOG(error) << "ZLib stream is already valid!";
        return;
    }
    if (!PerformStandardChecksBeforeOpening(processingFlags))
        return;
    fArchiveReadManager.Open(fFilePath, std::ios::in | std::ios::binary);
    fZlibStream =
        new z_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 (inflateInit2(fZlibStream, 15 + 32) != Z_OK) {
        LOG(error) << "Failed to initialize ZLib stream! Reason: " << fZlibStream->msg << '\n';
        inflateEnd(fZlibStream);
        delete fZlibStream;
        fZlibStream = nullptr;
        fArchiveReadManager.Close();
    }
 
#else
    throw std::runtime_error{"Trying to use ZLIB while BMN is not compiled with it!"};
#endif   // BMNCOMPRESSION_WITH_ZLIB
}
 
void BmnFileReaderZLib::Close() noexcept
{
#ifdef BMNCOMPRESSION_WITH_ZLIB
    if (!fZlibStream)
        return;
    if (inflateEnd(fZlibStream) != Z_OK) {
        LOG(fatal) << "Failed to free ZLib stream - possible huge memory leak! Failure reason: " << fZlibStream->msg
                   << '\n';
        std::terminate();
    }
    delete fZlibStream;
    fZlibStream = nullptr;
    fArchiveReadManager.Close();
    fNumberOfReadBytes = 0ull;
    fLastReturnStatus = 0;
#endif   // BMNCOMPRESSION_WITH_ZLIB
}
 
int64_t BmnFileReaderZLib::Read(void* dataToFill, const int64_t sizeToFill)
{
#ifdef BMNCOMPRESSION_WITH_ZLIB
    if (!IsStreamInGoodState())
        return 0ll;
    return fArchiveReadManager.Read(dataToFill, sizeToFill);
#else
    throw std::runtime_error{"Trying to use ZLIB while BMN is not compiled with it!"};
#endif   // BMNCOMPRESSION_WITH_ZLIB
}
 
int64_t BmnFileReaderZLib::Tell() const noexcept
{
    return fNumberOfReadBytes + fArchiveReadManager.GetCurrentOutputBufferPosition()
           - fArchiveReadManager.GetTotalOutputBufferFilledSize();
}
 
void BmnFileReaderZLib::Seek(int64_t value)
{
#ifdef BMNCOMPRESSION_WITH_ZLIB
    if (value < 0ll || (size_t)value == fNumberOfReadBytes)
        return;
    if (!IsStreamInGoodState()) {
        LOG(error) << "Before calling `BmnFileReaderZLib::Seek` ensure to clear bad flags!\n";
        return;
    }
    if (!fZlibStream) {
        LOG(error) << "Before calling `BmnFileReaderZLib::Seek` ensure to open the stream!\n";
        return;
    }
    if (!fArchiveReadManager.IsOpen()) {
        LOG(error) << "Reading file missing while calling `BmnFileReaderZLib::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 while BMN is not compiled with it!"};
#endif   // BMNCOMPRESSION_WITH_ZLIB
}
 
bool BmnFileReaderZLib::IsGood() const noexcept
{
#ifdef BMNCOMPRESSION_WITH_ZLIB
    return fZlibStream && IsStreamInGoodState() && fArchiveReadManager.IsGood();
#else
    return false;
#endif   // BMNCOMPRESSION_WITH_ZLIB
}
 
bool BmnFileReaderZLib::IsEOF() const noexcept
{
    return fArchiveReadManager.IsEOF();
}
 
void BmnFileReaderZLib::ClearStateFlags()
{
    // I don't like this method much
    fLastReturnStatus = 0;
    fArchiveReadManager.Clear();
}
 
bool BmnFileReaderZLib::IsOpen() const noexcept
{
    return fArchiveReadManager.IsOpen() && fZlibStream;
}
 
// ========== BmnIArchiveLib Interface ==========
 
BmnFileStreamResults BmnFileReaderZLib::Uncompress(const void* source,
                                                   const size_t sourceTotalSize,
                                                   size_t& numberOfReadBytes,
                                                   void* output,
                                                   const size_t outputTotalSize,
                                                   size_t& numberOfSetOutputBytes)
{
    if (!fZlibStream)
        return BmnFileStreamResults::FileNotOpen;
#ifdef BMNCOMPRESSION_WITH_ZLIB
    if (!IsStreamInGoodState())
        return BmnFileStreamResults::TryingToReadBadStream;
    fZlibStream->next_out = (Bytef*)output;
    fZlibStream->avail_out = (uInt)outputTotalSize;
    fZlibStream->total_out = 0u;
    fZlibStream->next_in = (Bytef*)source;
    fZlibStream->avail_in = (uInt)sourceTotalSize;
    fZlibStream->total_in = 0u;
    fLastReturnStatus = inflate(fZlibStream, Z_NO_FLUSH);
    if (!IsStreamInGoodState())
        return BmnFileStreamResults::UnexpectedFail;
    numberOfReadBytes = (size_t)fZlibStream->total_in;
    numberOfSetOutputBytes = (size_t)fZlibStream->total_out;
    fNumberOfReadBytes += numberOfSetOutputBytes;
    if (fLastReturnStatus == Z_STREAM_END)
        return BmnFileStreamResults::ReachedEOF;
    return BmnFileStreamResults::Success;
#else
    throw std::runtime_error{"Trying to use ZLIB while BMN is not compiled with it!"};
#endif   // BMNCOMPRESSION_WITH_ZLIB
}
 
std::string BmnFileReaderZLib::GetLastUncompressErrorDescription() const noexcept
{
#ifdef BMNCOMPRESSION_WITH_ZLIB
    std::string strToReturn{};
    if (fZlibStream && fZlibStream->msg)
        strToReturn = std::string{fZlibStream->msg};
    return strToReturn;
#else
    return std::string{"BMN NOT BUILT WITH ZLIB"};
#endif   // BMNCOMPRESSION_WITH_ZLIB
}
 
bool BmnFileReaderZLib::JumpsAllowed() const noexcept
{
    return false;
}
 
void BmnFileReaderZLib::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 `BmnFileReaderZLib::JumpTo` while the type doesn't allow jumping!\n";
}
 
size_t BmnFileReaderZLib::GetNumberOfDecompressedBytes() const noexcept
{
    return fNumberOfReadBytes;
}
 
bool BmnFileReaderZLib::HasReachedTheEndOfStream() const noexcept
{
#ifdef BMNCOMPRESSION_WITH_ZLIB
    if (!IsStreamInGoodState())
        return true;
    return fLastReturnStatus == Z_STREAM_END;
#else
    return true;
#endif   // BMNCOMPRESSION_WITH_ZLIB
}
 
bool BmnFileReaderZLib::IsStreamInGoodState() const noexcept
{
#ifdef BMNCOMPRESSION_WITH_ZLIB
    return fLastReturnStatus >= 0;
#else
    return false;
#endif   // BMNCOMPRESSION_WITH_ZLIB
}
 
#ifndef BMNCOMPRESSION_WITH_ZLIB
RESTORE_UNUSED_PARAM_WARNING
#endif   // BMNCOMPRESSION_WITH_ZLIB