dl_tool_archiver.h

浏览该文件的文档.

#pragma once
 
#include <memory/dl_buffer.h>
#include <memory/dl_stream_output.h>
#include <memory/dl_stream_input.h>
#include <io/dl_file.h>
#include <memory/dl_crypto.h>
#include <base/dl_string.h>
 
 
namespace dl::Tool
{
    constexpr uint16_t ARCHIVER_TYPE = 0x4002;
    constexpr uint8_t ARCHIVER_VERSION = 1;

class Archiver
{
public:
    struct Head
    {
        uint16_t _type;
        uint8_t _version;
        uint8_t _modeCompress;
        uint32_t _sizeFileList;        // 文件列表（压缩前大小）
        uint32_t _sizeFileListCompress;    // 文件列表（压缩后大小）
        uint64_t _sizeFileBlock;  // 文件块大小（压缩前）
    };
    struct FileInfo
    {
        uint64_t _offset;    // 内存偏移
        uint32_t _size;        // 大小
        uint32_t _crc;      // crc
    };
    using FileList = std::unordered_map<std::string, FileInfo>;
 
    struct Param
    {
        std::string _src;
        std::string _out;
        Memory::CompressMode _compressMode;
        bool _bCrc;
    };
 
    static void Compress(const Param& p)
    {
        std::vector<std::string> vec_file;
        File::GetPathFileAll(p._src, vec_file);
        if (vec_file.empty())
        {
            log_warn("文件数量为0！");
        }
        FileList all_file;
        // 文件块
        StreamOutput s;
        for (auto& iter : vec_file)
        {
            Buffer buf = File::GetBuffer(iter);
            uint32_t crc = 0;
            if (p._bCrc)
                crc = Crypto::HashCrc32(buf);
 
            FileInfo& f = all_file[File::GetRelative(iter, p._src)];
            f._offset = s.GetPos();
            f._size = (uint32_t)buf.size();
            f._crc = crc;
 
            uint64_t size_file = (uint64_t)buf.size();
            s.Write(&size_file);
            s.Write(&buf);
        }
        // 文件列表
        StreamOutput s1;
        s1.Write(&all_file);
 
        // 头
        Head head;
        head._type = ARCHIVER_TYPE;
        head._version = ARCHIVER_VERSION;
        head._modeCompress = p._compressMode;
        head._sizeFileList = (uint32_t)s1.GetPos();
        s1.Compress(p._compressMode);
        head._sizeFileListCompress = (uint32_t)s1.GetPos();
        head._sizeFileBlock = s.GetPos();
 
        s.Compress(p._compressMode);
 
        StreamOutput s_all;
        s_all.Write(&head);
        s_all.Write(s1.GetData(), s1.GetPos());
        s_all.Write(s.GetData(), s.GetPos());
 
        s_all.Save(p._out);
    }
    static bool Decompress(BufferView buf, std::string_view out)
    {
        StreamInput s_all;
        s_all.LoadFromMemory(buf);
 
        Head head;
        s_all.Read(&head);
 
        if (head._type != ARCHIVER_TYPE)
        {
            log_err("文件类型错误！");
            return false;
        }
        if (head._version != ARCHIVER_VERSION)
        {
            log_err("存档版本错误！");
            return false;
        }
        // 文件列表
        FileList all_file;
        {
            Buffer buf_temp;
            BufferView buf;
            if (head._modeCompress == Memory::E_LZ4)
            {
                buf_temp = Memory::DecompressLz4(
                    { s_all.GetCurrent(), head._sizeFileListCompress }, (size_t)head._sizeFileList);
                buf = buf_temp;
            }
#ifndef DL_DISABLE_ZLIB
            else if (head._modeCompress == Memory::E_ZIP)
            {
                buf_temp = Memory::DecompressZip(
                    { s_all.GetCurrent(), head._sizeFileListCompress }, (size_t)head._sizeFileList);
                buf = buf_temp;
            }
#endif
            else
                buf = { s_all.GetCurrent(), head._sizeFileListCompress };
            StreamInput s1;
            s1.LoadFromMemory(buf);
            s1.Read(&all_file);
 
            // 偏移
            s_all.SetPos(s_all.GetPos() + head._sizeFileListCompress);
        }
        // 文件块
        {
            Buffer buf_temp;
            BufferView buf;
            if (head._modeCompress == Memory::E_LZ4)
            {
                buf_temp = Memory::DecompressLz4(
                    { s_all.GetCurrent(), s_all.GetRemain() }, (size_t)head._sizeFileBlock);
                buf = buf_temp;
            }
#ifndef DL_DISABLE_ZLIB
            else if (head._modeCompress == Memory::E_ZIP)
            {
                buf_temp = Memory::DecompressZip(
                    { s_all.GetCurrent(), s_all.GetRemain() }, (size_t)head._sizeFileBlock);
                buf = buf_temp;
            }
#endif
            else
                buf = { s_all.GetCurrent(), s_all.GetRemain() };
 
            size_t count = 0;
            for (auto& [name, info] : all_file)
            {
                std::byte* p = buf.data() + info._offset;
                std::size_t size_file = (std::size_t)*(uint64_t*)p;
                if (info._size != size_file)
                {
                    log_err("文件大小不匹配：{}", size_file);
                    continue;
                }
                p += sizeof(uint64_t);
 
                std::string path_name = out + name;
                if (!File::CreateFolder(File::GetFilePath(path_name)))
                {
                    log_err("路径创建失败：{}", File::GetFilePath(path_name));
                    continue;
                }
                if (!File::SaveBuffer(
                    { p, size_file }, path_name))
                {
                    log_err("文件保存失败：{}", path_name);
                    continue;
                }
                ++count;
            }
            return count == all_file.size();
        }
    }
    static bool Decompress(std::string_view src, std::string_view out)
    {
        Buffer buf = File::GetBuffer(src);
        if (buf.empty())
        {
            log_err("加载文件失败：{}", src);
            return false;
        }
        return Decompress(buf, out);
    }
    static bool GetFileList(BufferView buf, FileList& all_file)
    {
        StreamInput s_all;
        s_all.LoadFromMemory(buf);
 
        Head head;
        s_all.Read(&head);
 
        if (head._type != ARCHIVER_TYPE)
        {
            log_err("文件类型错误！");
            return false;
        }
        if (head._version != ARCHIVER_VERSION)
        {
            log_err("存档版本错误！");
            return false;
        }
        {
            Buffer buf_temp;
            BufferView buf;
            if (head._modeCompress == Memory::E_LZ4)
            {
                buf_temp = Memory::DecompressLz4(
                    { s_all.GetCurrent(), head._sizeFileListCompress }, (size_t)head._sizeFileList);
                buf = buf_temp;
            }
#ifndef DL_DISABLE_ZLIB
            else if (head._modeCompress == Memory::E_ZIP)
            {
                buf_temp = Memory::DecompressZip(
                    { s_all.GetCurrent(), head._sizeFileListCompress }, (size_t)head._sizeFileList);
                buf = buf_temp;
            }
#endif
            else
                buf = { s_all.GetCurrent(), head._sizeFileListCompress };
            StreamInput s1;
            s1.LoadFromMemory(buf);
            s1.Read(&all_file);
        }
        return true;
    }
private:
    // 头
 
    // 文件列表（压缩）
    // name、FileInfo
    
    // 文件数据（压缩）
    // buffer
};
 
}