ZIP.hpp

Go to the documentation of this file.

//
//  CeresEngine - A game development framework
//
//  Created by Rogiel Sulzbach.
//  Copyright (c) 2018-2023 Rogiel Sulzbach. All rights reserved.
//
 
#pragma once
 
#include "FilePath.hpp"
 
#include "CeresEngine/DataTypes.hpp"
 
#include "CeresEngine/Foundation/Exception.hpp"
#include "CeresEngine/Foundation/Flags.hpp"
#include "CeresEngine/Foundation/Function.hpp"
#include "CeresEngine/Foundation/Generator.hpp"
#include "CeresEngine/Foundation/String.hpp"
#include "CeresEngine/Foundation/StructEnum.hpp"
#include "CeresEngine/Foundation/IO/Stream.hpp"
 
#include <chrono>
 
#if defined(libzip_FOUND)
 
using zip_t = struct zip;
 
namespace CeresEngine {
 
    CE_EXCEPTION_DECL2(ZIPException, IOException);
 
    class ZIPArchive {
    public:
        struct Compression final : public StructEnum<Compression> {
            enum : UnderlyingType {
                Default = 0,
 
                Store,
 
                BZIP2,
 
                Deflate,
 
                XZ,
 
                ZSTD,
            } raw;
 
            UInt32 level = 0;
 
            CE_STRUCT_ENUM_DECL(Compression);
            explicit Compression(const decltype(raw) raw, const UInt32 level) : raw(raw), level(level) {}
 
            [[nodiscard]] bool isCompressionSupported() const noexcept;
 
            [[nodiscard]] bool isDecompressionSupported() const noexcept;
        };
 
        struct Encryption final : public StructEnum<Encryption> {
            enum : UnderlyingType {
                None = 0,
 
                AES128,
 
                AES192,
 
                AES256,
            } raw;
 
            CE_STRUCT_ENUM_DECL(Encryption);
            explicit Encryption(const decltype(raw) raw, UInt32 level) : raw(raw) {}
 
            [[nodiscard]] bool isEncryptionSupported() const noexcept;
 
            [[nodiscard]] bool isDecryptionSupported() const noexcept;
        };
 
        enum class OpenFlag {
            Create = (1u << 0u),
 
            Truncate = (1u << 1u),
 
            ReadOnly = (1u << 2u),
 
            Strict = (1u << 3u),
 
            FailIfExists = (1u << 4u),
 
            Default = 0,
        };
 
        using OpenFlags = Flags<OpenFlag>;
 
        enum class LocateFlag {
            IgnoreCase = (1u << 0u),
 
            IgnoreDirectories = (1u << 1u),
 
            Default = 0,
        };
 
        using LocateFlags = Flags<LocateFlag>;
 
        enum class CreateFlag {
            Overwrite = (1u << 0u),
 
            Default = 0,
        };
 
        using CreateFlags = Flags<CreateFlag>;
 
        enum class OpenStreamFlag {
            Compressed = (1u << 0u),
 
            OriginalData = (1u << 1u),
 
            Default = 0,
        };
 
        using OpenStreamFlags = Flags<OpenStreamFlag>;
 
        using ExtraFieldID = UInt16;
 
        enum class ExtraFieldLocation {
            Local,
 
            Central,
        };
 
    private:
        struct Pimpl;
        UPtr<Pimpl> m;
 
    public:
        class Entry {
            friend class ZIPArchive;
 
        private:
            ZIPArchive* mArchive = nullptr;
            Int64 mIndex = -1;
 
        public:
            Entry() = default;
 
            Entry(const Entry&) = default;
            Entry& operator=(const Entry&) = default;
            Entry(Entry&&) noexcept = default;
            Entry& operator=(Entry&&) noexcept = default;
 
        private:
            explicit Entry(ZIPArchive* archive, const UInt32 index) : mArchive(archive), mIndex(index) {}
 
        public:
            void remove();
 
            void setContent(InputStream stream);
 
            [[nodiscard]] Compression getCompression() const;
 
            void setCompression(const Compression& compression);
 
            [[nodiscard]] bool isCompressed() const;
 
            [[nodiscard]] Encryption getEncryption() const;
 
            void setEncryption(const Encryption& encryption, const String& password);
 
            [[nodiscard]] bool isEncrypted();
 
            [[nodiscard]] UInt64 getCompressedSize() const;
 
            [[nodiscard]] UInt64 getSize() const;
 
            [[nodiscard]] FilePath getPath() const;
 
            void setPath(const FilePath& path);
 
            [[nodiscard]] StringView getName() const;
 
            [[nodiscard]] StringView getComment() const;
 
            void setComment(StringView comment);
 
            // Gets the last modification time (mtime) for the file in the zip.
            [[nodiscard]] Date getModificationDate() const;
 
            void setModificationDate(const Date& modificationDate);
 
        public: // Entra fields
            [[nodiscard]] bool hasExtraField(ExtraFieldID id, UInt16 index = 0, ExtraFieldLocation location = ExtraFieldLocation::Local) const;
 
            [[nodiscard]] MemoryView<const Byte> getExtraField(ExtraFieldID id, UInt16 index = 0, ExtraFieldLocation location = ExtraFieldLocation::Local) const;
 
            template<typename T> [[nodiscard]] Optional<T> getExtraField(const ExtraFieldID id, const UInt16 index = 0, const ExtraFieldLocation location = ExtraFieldLocation::Local) const {
                static_assert(std::is_trivially_copyable_v<T>);
                const MemoryView<const T> memoryView = getExtraField(id, index, location).as<const T>();
                if(memoryView.empty()) {
                    return {};
                }
                return memoryView[0];
            }
 
            template<> [[nodiscard]] Optional<String> getExtraField(const ExtraFieldID id, const UInt16 index, const ExtraFieldLocation location) const {
                const MemoryView<const char> memoryView = getExtraField(id, index, location).as<const char>();
                if(memoryView.empty()) {
                    return {};
                }
                return String(memoryView.data(), memoryView.size());
            }
 
            void setExtraField(MemoryView<const Byte> data, ExtraFieldID id, UInt16 index = 0, ExtraFieldLocation location = ExtraFieldLocation::Local);
 
            template<typename T> void setExtraField(const T& data, const ExtraFieldID id, const UInt16 index = 0, const ExtraFieldLocation location = ExtraFieldLocation::Local) {
                static_assert(std::is_trivially_copyable_v<T>);
                setExtraField(make_memory_view(&data, 1).template as<const Byte>(), id, index, location);
            }
 
            template<> void setExtraField(const String& data, const ExtraFieldID id, const UInt16 index, const ExtraFieldLocation location) {
                setExtraField(make_memory_view(data.data(), data.size()).template as<const Byte>(), id, index, location);
            }
 
            [[nodiscard]] UInt16 getExtraFieldCount(ExtraFieldID id, ExtraFieldLocation location = ExtraFieldLocation::Local) const;
 
            void removeExtraField(ExtraFieldID id, UInt16 index = 0, ExtraFieldLocation location = ExtraFieldLocation::Local);
 
        public:
            [[nodiscard]] InputStream openInputStream(const OpenStreamFlags& flags = OpenStreamFlag::Default) const;
 
            [[nodiscard]] InputStream openInputStream(const String& password, const OpenStreamFlags& flags = OpenStreamFlag::Default) const;
 
        public:
            explicit operator bool() const { return mArchive != nullptr && mIndex != -1; }
        };
 
    public:
        explicit ZIPArchive(const FilePath& path, const OpenFlags& flags = OpenFlag::Default);
 
        explicit ZIPArchive(DataStream dataStream, const OpenFlags& flags = OpenFlag::Create);
 
        explicit ZIPArchive(InputStream inputStream, const OpenFlags& flags = OpenFlag::ReadOnly);
 
        ~ZIPArchive() noexcept;
 
    public:
        [[nodiscard]] Entry locate(const FilePath& path, const LocateFlags& flags = LocateFlag::Default);
 
        [[nodiscard]] Generator<Entry> entries();
 
        Entry createDirectory(const FilePath& path, const CreateFlags& flags = CreateFlag::Default);
 
        Entry createFile(const FilePath& path, InputStream stream, const Compression& compression = Compression::Default,
            const CreateFlags& flags = CreateFlag::Default);
 
        [[nodiscard]] StringView getComment() const;
 
        void setComment(StringView comment);
 
    public:
        using ProgressCallbackFunctionView = FunctionView<void(double) const>;
 
        void commit(ProgressCallbackFunctionView progressCallback = nullptr, double precision = 0.01);
 
        void rollback();
 
        void rollback(const Entry& entry);
 
    public:
        [[nodiscard]] Pimpl* pimpl() const noexcept { return m.get(); };
    };
 
    CE_FLAGS_OPERATORS(ZIPArchive::OpenFlag)
    CE_FLAGS_OPERATORS(ZIPArchive::LocateFlag)
    CE_FLAGS_OPERATORS(ZIPArchive::CreateFlag)
    CE_FLAGS_OPERATORS(ZIPArchive::OpenStreamFlag)
 
} // namespace CeresEngine
#endif