ZLib.cpp

Go to the documentation of this file.

 
 
#include "galaxy/logging/Log.hpp"
 
#include "ZLib.hpp"
 
#ifdef GALAXY_WIN_PLATFORM
GALAXY_DISABLE_WARNING_PUSH
GALAXY_DISABLE_WARNING(26403)
GALAXY_DISABLE_WARNING(26407)
GALAXY_DISABLE_WARNING(26409)
GALAXY_DISABLE_WARNING(26414)
GALAXY_DISABLE_WARNING(26477)
#endif
 
namespace galaxy
{
    ZLib::ZLib(const Mode mode)
        : m_mode {mode}
        , m_finished {false}
        , m_in {0}
        , m_out {0}
    {
        try
        {
            if (m_mode == ZLib::Mode::COMPRESS)
            {
                m_stream.zalloc = Z_NULL;
                m_stream.zfree  = Z_NULL;
                m_stream.opaque = Z_NULL;
 
                if (deflateInit2(&m_stream, 9, Z_DEFLATED, 15, 9, Z_DEFAULT_STRATEGY) != Z_OK)
                {
                    GALAXY_LOG(GALAXY_ERROR, "Failed to initialize ZLib compressor.");
                }
            }
            else
            {
                m_stream.zalloc   = Z_NULL;
                m_stream.zfree    = Z_NULL;
                m_stream.opaque   = Z_NULL;
                m_stream.next_in  = Z_NULL;
                m_stream.avail_in = 0;
 
                if (inflateInit2(&m_stream, 15) != Z_OK)
                {
                    GALAXY_LOG(GALAXY_ERROR, "Failed to initialize ZLib decompressor.");
                }
            }
        }
        catch (const std::exception& e)
        {
            GALAXY_LOG(GALAXY_ERROR, "{0}.", e.what());
        }
    }
 
    ZLib::~ZLib()
    {
        try
        {
            if (m_mode == ZLib::Mode::COMPRESS)
            {
                deflateEnd(&m_stream);
            }
            else
            {
                inflateEnd(&m_stream);
            }
        }
        catch (const std::exception& e)
        {
            GALAXY_LOG(GALAXY_ERROR, "{0}.", e.what());
        }
    }
 
    std::string ZLib::encode(const std::string& input)
    {
        auto in   = new char[GALAXY_ZLIB_COMPLETE_CHUNK];
        auto zlib = new ZLib(ZLib::Mode::COMPRESS);
 
        std::string result;
 
        try
        {
            std::memset(in, 0, sizeof(char) * GALAXY_ZLIB_COMPLETE_CHUNK);
 
            unsigned int total_read = 0;
 
            std::stringstream sstream;
            sstream.str(input);
 
            while (true)
            {
                sstream.read(in, GALAXY_ZLIB_COMPLETE_CHUNK);
                total_read = static_cast<unsigned int>(sstream.gcount());
 
                if (total_read != 0)
                {
                    result += zlib->compressor({in, total_read});
                }
                else
                {
                    break;
                }
            }
 
            result += zlib->finish();
        }
        catch (const std::exception& e)
        {
            GALAXY_LOG(GALAXY_ERROR, "{0}.", e.what());
        }
 
        delete[] in;
        delete zlib;
        return result;
    }
 
    std::string ZLib::decode(const std::string& input)
    {
        auto in   = new char[GALAXY_ZLIB_COMPLETE_CHUNK];
        auto zlib = new ZLib(ZLib::Mode::DECOMPRESS);
 
        std::string result;
 
        try
        {
            std::memset(in, 0, sizeof(char) * GALAXY_ZLIB_COMPLETE_CHUNK);
 
            unsigned int total_read = 0;
 
            std::stringstream sstream;
            sstream.str(input);
 
            while (true)
            {
                sstream.read(in, GALAXY_ZLIB_COMPLETE_CHUNK);
                total_read = static_cast<unsigned int>(sstream.gcount());
 
                if (total_read != 0)
                {
                    result += zlib->decompressor({in, total_read});
                }
                else
                {
                    break;
                }
            }
        }
        catch (const std::exception& e)
        {
            GALAXY_LOG(GALAXY_ERROR, "{0}.", e.what());
        }
 
        delete[] in;
        delete zlib;
        return result;
    }
 
    std::string ZLib::compressor(const std::string& input)
    {
        std::string result;
 
        try
        {
            if (m_mode == ZLib::Mode::COMPRESS)
            {
                if (!m_finished)
                {
                    for (auto i = 0u; i < input.length(); i += GALAXY_ZLIB_COMPLETE_CHUNK)
                    {
                        const auto left    = static_cast<unsigned int>(input.length() - i);
                        const auto end     = left <= GALAXY_ZLIB_COMPLETE_CHUNK;
                        const auto current = (left > GALAXY_ZLIB_COMPLETE_CHUNK) ? GALAXY_ZLIB_COMPLETE_CHUNK : left;
 
                        std::memcpy(m_in, input.data() + i, current);
 
                        m_stream.avail_in = current;
                        m_stream.next_in  = (Bytef*)m_in;
 
                        do
                        {
                            m_stream.avail_out = GALAXY_ZLIB_COMPLETE_CHUNK;
                            m_stream.next_out  = (Bytef*)m_out;
 
                            if (deflate(&m_stream, end ? Z_SYNC_FLUSH : Z_NO_FLUSH) == Z_STREAM_ERROR)
                            {
                                GALAXY_LOG(GALAXY_ERROR, "Failed to compress ZLib data stream.");
                                return {};
                            }
 
                            result += std::string(m_out, GALAXY_ZLIB_COMPLETE_CHUNK - m_stream.avail_out);
                        } while (m_stream.avail_out == 0);
                    }
                }
                else
                {
                    GALAXY_LOG(GALAXY_WARNING, "Dont call ZLib compress after calling zlib finish.");
                }
            }
            else
            {
                GALAXY_LOG(GALAXY_WARNING, "Dont call ZLib compress in decompression mode.");
            }
        }
        catch (const std::exception& e)
        {
            GALAXY_LOG(GALAXY_ERROR, "{0}.", e.what());
        }
 
        return result;
    }
 
    std::string ZLib::finish()
    {
        std::string result;
 
        try
        {
            if (m_mode == ZLib::Mode::COMPRESS)
            {
                if (!m_finished)
                {
                    m_finished        = true;
                    m_stream.avail_in = 0;
                    m_stream.next_in  = (Bytef*)m_in;
 
                    do
                    {
                        m_stream.avail_out = GALAXY_ZLIB_COMPLETE_CHUNK;
                        m_stream.next_out  = (Bytef*)m_out;
 
                        if (deflate(&m_stream, Z_FINISH) == Z_STREAM_ERROR)
                        {
                            GALAXY_LOG(GALAXY_ERROR, "Failed to complete ZLib compression.");
                            return {};
                        }
 
                        result += std::string(m_out, GALAXY_ZLIB_COMPLETE_CHUNK - m_stream.avail_out);
                    } while (m_stream.avail_out == 0);
                }
                else
                {
                    GALAXY_LOG(GALAXY_WARNING, "ZLib finish already called.");
                }
            }
            else
            {
                GALAXY_LOG(GALAXY_WARNING, "Dont call ZLib finish in decompress mode.");
            }
        }
        catch (const std::exception& e)
        {
            GALAXY_LOG(GALAXY_ERROR, "{0}.", e.what());
        }
 
        return result;
    }
 
    std::string ZLib::decompressor(const std::string& input)
    {
        std::string result;
 
        try
        {
            if (m_mode == ZLib::Mode::DECOMPRESS)
            {
                for (auto i = 0u; i < input.length(); i += GALAXY_ZLIB_COMPLETE_CHUNK)
                {
                    const auto left    = static_cast<unsigned int>(input.length() - i);
                    const auto current = (left > GALAXY_ZLIB_COMPLETE_CHUNK) ? GALAXY_ZLIB_COMPLETE_CHUNK : left;
 
                    std::memcpy(m_in, input.data() + i, current);
 
                    m_stream.avail_in = current;
                    m_stream.next_in  = (Bytef*)m_in;
 
                    if (m_stream.avail_in == 0)
                    {
                        break;
                    }
                    do
                    {
                        m_stream.avail_out = GALAXY_ZLIB_COMPLETE_CHUNK;
                        m_stream.next_out  = (Bytef*)m_out;
 
                        if (inflate(&m_stream, Z_NO_FLUSH) == Z_STREAM_ERROR)
                        {
                            GALAXY_LOG(GALAXY_ERROR, "Failed to complete ZLib decompression.");
                            return {};
                        }
 
                        result += std::string(m_out, GALAXY_ZLIB_COMPLETE_CHUNK - m_stream.avail_out);
                    } while (m_stream.avail_out == 0);
                }
            }
            else
            {
                GALAXY_LOG(GALAXY_WARNING, "Dont call ZLib finish in compress mode.");
            }
        }
        catch (const std::exception& e)
        {
            GALAXY_LOG(GALAXY_ERROR, "{0}.", e.what());
        }
 
        return result;
    }
} // namespace galaxy
 
#ifdef GALAXY_WIN_PLATFORM
GALAXY_DISABLE_WARNING_POP
#endif