BmnCompressionGlobalFunctions.cxx

Go to the documentation of this file.

// headers from this target
#include "BmnCompressionGlobalFunctions.h"
 
#include "BmnDefinitions.h"
#include "BmnFileReaderRaw.h"
#include "BmnFileReaderXzLzma.h"
#include "BmnFileReaderZLib.h"
#include "BmnFileReaderZLibNG.h"
#include "BmnFileReaderZStd.h"
// std:: headers
#include <algorithm>
#include <array>
#include <cctype>
#include <iterator>
#include <string>
#ifdef BMNCOMPRESSION_WITH_ZSTD
#include <zstd.h>
#endif   // BMNCOMPRESSION_WITH_ZSTD
 
// 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
// ================== static function declaration ==================
// 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
 
/*
 * A translation-unit function that will be updated as we add new reading libraries. This function
 * opens a stream for the provided path (if one exists) and based on magic bytes, it returns what kind
 * of file reader should be created
 * @param aFilePath A path to an existing actual and accessible file that should be read
 * @param aUserSelectedAlgorithm A preferred algorithm selected by a user and passed into
 * `BmnCompressionIsArchiveLibAvailable`
 * @return A type of the file that should be opened
 */
[[nodiscard]] static BmnFileType DoCommonProcessingOfFileFinding(const std::filesystem::path& aFilePath,
                                                                 const BmnFileType aUserSelectedAlgorithm);
 
// 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
// ================== Global functions ==================
// 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
 
bool BmnCompressionIsArchiveLibAvailable(const BmnFileType aLibraryType) noexcept
{
    switch (aLibraryType) {
        case BmnFileType::ZStd:
#ifdef BMNCOMPRESSION_WITH_ZSTD
            return true;
#else
            return false;
#endif   // BMNCOMPRESSION_WITH_ZSTD
        case BmnFileType::ZLib:
#ifdef BMNCOMPRESSION_WITH_ZLIB
            return true;
#else
            return false;
#endif   // BMNCOMPRESSION_WITH_ZLIB
        case BmnFileType::ZLib_ng:
#ifdef BMNCOMPRESSION_WITH_ZLIB_NG
            return true;
#else
            return false;
#endif   // BMNCOMPRESSION_WITH_ZLIB_NG
        case BmnFileType::XZ_LZMA:
#ifdef BMNCOMPRESSION_WITH_XZ_LZMA
            return true;
#else
            return false;
#endif   // BMNCOMPRESSION_WITH_XZ_LZMA
        case BmnFileType::Raw:
            return true;
        case BmnFileType::Unknown:
        default:
            return false;
    }
}
 
BmnIFileReader* BmnCompressionCreateNewSuitableReaderForAFile(const std::filesystem::path& aFilePath,
                                                              const BmnFileType aPreferredTypeForThisAlgorithm)
{
    BmnFileType aNeededType = DoCommonProcessingOfFileFinding(aFilePath, aPreferredTypeForThisAlgorithm);
    switch (aNeededType) {
#ifdef BMNCOMPRESSION_WITH_ZSTD
        case BmnFileType::ZStd:
            return new BmnFileReaderZStd{aFilePath};
#endif   // BMNCOMPRESSION_WITH_ZSTD
#ifdef BMNCOMPRESSION_WITH_ZLIB
        case BmnFileType::ZLib:
            return new BmnFileReaderZLib{aFilePath};
#endif   // BMNCOMPRESSION_WITH_ZLIB
#ifdef BMNCOMPRESSION_WITH_ZLIB_NG
        case BmnFileType::ZLib_ng:
            return new BmnFileReaderZLibNG{aFilePath};
#endif   // BMNCOMPRESSION_WITH_ZLIB_NG
#ifdef BMNCOMPRESSION_WITH_XZ_LZMA
        case BmnFileType::XZ_LZMA:
            return new BmnFileReaderXzLzma{aFilePath};
#endif   // BMNCOMPRESSION_WITH_XZ_LZMA
        case BmnFileType::Raw:
            return new BmnFileReaderRaw{aFilePath};
        case BmnFileType::Unknown:
        default:
            return nullptr;
    }
}
 
BmnIFileReader* BmnCompressionCreateNewSuitableReaderForAFile(std::filesystem::path&& aFilePath,
                                                              const BmnFileType aPreferredTypeForThisAlgorithm)
{
    BmnFileType aNeededType = DoCommonProcessingOfFileFinding(aFilePath, aPreferredTypeForThisAlgorithm);
    switch (aNeededType) {
        case BmnFileType::ZStd:
#ifdef BMNCOMPRESSION_WITH_ZSTD
            return new BmnFileReaderZStd{std::move(aFilePath)};
#endif   // BMNCOMPRESSION_WITH_ZSTD
#ifdef BMNCOMPRESSION_WITH_ZLIB
        case BmnFileType::ZLib:
            return new BmnFileReaderZLib{std::move(aFilePath)};
#endif   // BMNCOMPRESSION_WITH_ZLIB
#ifdef BMNCOMPRESSION_WITH_ZLIB_NG
        case BmnFileType::ZLib_ng:
            return new BmnFileReaderZLibNG{std::move(aFilePath)};
#endif   // BMNCOMPRESSION_WITH_ZLIB_NG
#ifdef BMNCOMPRESSION_WITH_XZ_LZMA
        case BmnFileType::XZ_LZMA:
            return new BmnFileReaderXzLzma{std::move(aFilePath)};
#endif   // BMNCOMPRESSION_WITH_XZ_LZMA
        case BmnFileType::Raw:
            return new BmnFileReaderRaw{std::move(aFilePath)};
        case BmnFileType::Unknown:
        default:
            return nullptr;
    }
}
 
std::filesystem::path BmnCompressionRemoveArchiveExtension(std::filesystem::path aFilePath)
{
    std::string fileExtension = aFilePath.extension().string();
    // '.ZST' names the very same format as '.zst', so the extensions are compared in the lower case
    std::transform(fileExtension.begin(), fileExtension.end(), fileExtension.begin(),
                   [](unsigned char aSymbol) { return static_cast<char>(std::tolower(aSymbol)); });
 
    // the list of the archive extensions is declared in BmnCompressionGlobalFunctions.h
    if (std::find(std::cbegin(BmnCompressionArchiveExtensions), std::cend(BmnCompressionArchiveExtensions),
                  fileExtension)
        == std::cend(BmnCompressionArchiveExtensions))
        return aFilePath;
 
    return aFilePath.replace_extension();
}
 
// 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
// ================== static function definition ==================
// 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
 
DISABLE_UNUSED_PARAM_WARNING
static BmnFileType DoCommonProcessingOfFileFinding(const std::filesystem::path& aFilePath,
                                                   const BmnFileType aUserSelectedAlgorithm)
{
    if (aFilePath.empty()) {
        LOG(error) << "You did not provide a path for opening a file reader!\n";
        return BmnFileType::Unknown;
    }
    try {
        if (!std::filesystem::exists(aFilePath) || !std::filesystem::is_regular_file(aFilePath)) {
            LOG(error) << "You should provide an existing path to an actual file for opening a file reader!\n";
            return BmnFileType::Unknown;
        }
    } catch (const std::bad_alloc& errorDescription) {
        LOG(error) << "Filesystem failure! Reason: " << errorDescription.what() << '\n';
        return BmnFileType::Unknown;
    } catch (const std::filesystem::filesystem_error& errorDescription) {
        LOG(error) << "Filesystem failure! Reason: " << errorDescription.what() << '\n';
        return BmnFileType::Unknown;
    }
    std::ifstream inStream{};
    inStream.open(aFilePath, std::ios::in | std::ios::binary);
    if (!inStream.is_open()) {
        LOG(error) << "Failed to open a file for checking a magic byte for opening a file reader!\n";
        return BmnFileType::Unknown;
    }
    std::array<char, 15> beginningOfTheStream{};
    inStream.read(beginningOfTheStream.data(), beginningOfTheStream.size());
    // ================================================================================================================
#ifdef BMNCOMPRESSION_WITH_ZSTD
    if (*reinterpret_cast<uint32_t*>(beginningOfTheStream.data()) == ZSTD_MAGICNUMBER)
        return BmnFileType::ZStd;
#endif   // BMNCOMPRESSION_WITH_ZSTD
    // ================================================================================================================
#ifdef BMNCOMPRESSION_WITH_XZ_LZMA
    // I don't see this information in the XZ_LZMA API. Still, I found it on the internet and seems to work
    constexpr char xzMagicByte[7] = {"\xFD\x37\x7A\x58\x5A\x00"};
    for (size_t i = 0ull; i < 6; ++i) {
        if (beginningOfTheStream[i] != xzMagicByte[i])
            break;
        // if we are here in the last pass, it means we have a match
        if (i == 5)
            return BmnFileType::XZ_LZMA;
    }
#endif   // BMNCOMPRESSION_WITH_XZ_LZMA
    // ================================================================================================================
#if defined(BMNCOMPRESSION_WITH_ZLIB) || defined(BMNCOMPRESSION_WITH_ZLIB_NG)
    // for now we expect GZip compression while later we might add additional support for files compressed directly by
    // us. the deflate format itself doesn't have a magic byte, while zlib has various headers, but we will not be
    // writing a direct ZLIB stream anyway
    if (beginningOfTheStream[0] == '\x1F' && beginningOfTheStream[1] == '\x8B') {
#ifdef BMNCOMPRESSION_WITH_ZLIB_NG
#ifdef BMNCOMPRESSION_WITH_ZLIB
        if (aUserSelectedAlgorithm == BmnFileType::ZLib)
            return BmnFileType::ZLib;
#endif   // BMNCOMPRESSION_WITH_ZLIB
        return BmnFileType::ZLib_ng;
#else    // defined(BMNCOMPRESSION_WITH_ZLIB) && !defined(BMNCOMPRESSION_WITH_ZLIB_NG)
        return BmnFileType::ZLib;
#endif   // BMNCOMPRESSION_WITH_ZLIB_NG
    }
#endif   // defined(BMNCOMPRESSION_WITH_ZLIB) || defined(BMNCOMPRESSION_WITH_ZLIB_NG)
    // ================================================================================================================
    return BmnFileType::Raw;
}
RESTORE_UNUSED_PARAM_WARNING