PackFile.h

Go to the documentation of this file.

#pragma once
 
#include <functional>
#include <memory>
#include <optional>
#include <span>
#include <string>
#include <string_view>
#include <unordered_map>
#include <vector>
 
#include <sourcepp/Macros.h>
#include <tsl/htrie_map.h>
 
#include "Attribute.h"
#include "Entry.h"
#include "Options.h"
 
namespace vpkpp {
 
// Executable extensions - mostly just for Godot exports
constexpr std::string_view EXECUTABLE_EXTENSION0 = ".exe";    // - Windows
constexpr std::string_view EXECUTABLE_EXTENSION1 = ".bin";    // - Linux + Godot 3 and below (and Generic)
constexpr std::string_view EXECUTABLE_EXTENSION2 = ".x86_64"; //         | Godot 4 (64-bit)
 
class PackFile {
public:
    enum class OpenProperty {
        DECRYPTION_KEY, // The pack file is encrypted
    };
 
    // Accepts the pack file GUID and request property, returns the requested value
    using OpenPropertyRequest = std::function<std::vector<std::byte>(PackFile* packFile, OpenProperty property)>;
 
    template<typename R>
    using EntryCallbackBase = std::function<R(const std::string& path, const Entry& entry)>;
    using EntryCallback     = EntryCallbackBase<void>;
    using EntryPredicate    = EntryCallbackBase<bool>;
 
    // Accepts the entry's path
    using EntryCreation     = std::function<EntryOptions(const std::string& path)>;
 
    using EntryTrie = tsl::htrie_map<char, Entry>;
 
    PackFile(const PackFile& other) = delete;
    PackFile& operator=(const PackFile& other) = delete;
 
    PackFile(PackFile&& other) noexcept = default;
    PackFile& operator=(PackFile&& other) noexcept = default;
 
    virtual ~PackFile() = default;
 
    [[nodiscard]] static std::unique_ptr<PackFile> open(const std::string& path, const EntryCallback& callback = nullptr, const OpenPropertyRequest& requestProperty = nullptr);
 
    [[nodiscard]] static std::vector<std::string> getOpenableExtensions();
 
    [[nodiscard]] virtual constexpr std::string_view getGUID() const = 0;
 
    template<typename T>
    requires requires (const T&) {{T::GUID} -> std::convertible_to<std::string_view>;}
    [[nodiscard]] bool isInstanceOf() const {
        return this->getGUID() == T::GUID;
    }
 
    [[nodiscard]] virtual constexpr bool hasEntryChecksums() const {
        return false;
    }
 
    [[nodiscard]] virtual std::vector<std::string> verifyEntryChecksums() const;
 
    [[nodiscard]] virtual bool hasPackFileChecksum() const;
 
    [[nodiscard]] virtual bool verifyPackFileChecksum() const;
 
    [[nodiscard]] virtual bool hasPackFileSignature() const;
 
    [[nodiscard]] virtual bool verifyPackFileSignature() const;
 
    [[nodiscard]] virtual constexpr bool isCaseSensitive() const {
        return false;
    }
 
    [[nodiscard]] bool hasEntry(const std::string& path, bool includeUnbaked = true) const;
 
    [[nodiscard]] std::optional<Entry> findEntry(const std::string& path_, bool includeUnbaked = true) const;
 
    [[nodiscard]] virtual std::optional<std::vector<std::byte>> readEntry(const std::string& path_) const = 0;
 
    [[nodiscard]] std::optional<std::vector<std::byte>> operator[](const std::string& path_) const;
 
    [[nodiscard]] std::optional<std::string> readEntryText(const std::string& path) const;
 
    [[nodiscard]] virtual constexpr bool isReadOnly() const noexcept {
        return false;
    }
 
    void addEntry(const std::string& entryPath, const std::string& filepath, EntryOptions options = {});
 
    void addEntry(const std::string& path, std::vector<std::byte>&& buffer, EntryOptions options = {});
 
    void addEntry(const std::string& path, std::span<const std::byte> buffer, EntryOptions options = {});
 
    void addDirectory(const std::string& entryBaseDir, const std::string& dir, EntryOptions options = {});
 
    void addDirectory(const std::string& entryBaseDir_, const std::string& dir, const EntryCreation& creation);
 
    virtual bool renameEntry(const std::string& oldPath_, const std::string& newPath_); // NOLINT(*-use-nodiscard)
 
    virtual bool renameDirectory(const std::string& oldDir_, const std::string& newDir_); // NOLINT(*-use-nodiscard)
 
    virtual bool removeEntry(const std::string& path_);
 
    virtual std::size_t removeDirectory(const std::string& dirName_);
 
    virtual bool bake(const std::string& outputDir_ /*= ""*/, BakeOptions options /*= {}*/, const EntryCallback& callback /*= nullptr*/) = 0;
 
    bool extractEntry(const std::string& entryPath, const std::string& filepath) const; // NOLINT(*-use-nodiscard)
 
    bool extractDirectory(const std::string& dir_, const std::string& outputDir) const; // NOLINT(*-use-nodiscard)
 
    bool extractAll(const std::string& outputDir, bool createUnderPackFileDir = true) const; // NOLINT(*-use-nodiscard)
 
    bool extractAll(const std::string& outputDir, const EntryPredicate& predicate, bool stripSharedDirs = true) const; // NOLINT(*-use-nodiscard)
 
    [[nodiscard]] const EntryTrie& getBakedEntries() const;
 
    [[nodiscard]] const EntryTrie& getUnbakedEntries() const;
 
    [[nodiscard]] std::size_t getEntryCount(bool includeUnbaked = true) const;
 
    void runForAllEntries(const EntryCallback& operation, bool includeUnbaked = true) const;
 
    void runForAllEntries(const std::string& parentDir, const EntryCallback& operation, bool recursive = true, bool includeUnbaked = true) const;
 
    [[nodiscard]] std::string_view getFilepath() const;
 
    [[nodiscard]] std::string getTruncatedFilepath() const;
 
    [[nodiscard]] std::string getFilename() const;
 
    [[nodiscard]] std::string getTruncatedFilename() const;
 
    [[nodiscard]] std::string getFilestem() const;
 
    [[nodiscard]] virtual std::string getTruncatedFilestem() const;
 
    [[nodiscard]] virtual Attribute getSupportedEntryAttributes() const;
 
    [[nodiscard]] virtual explicit operator std::string() const;
 
    [[nodiscard]] static std::string escapeEntryPathForWrite(const std::string& path);
 
protected:
    explicit PackFile(std::string fullFilePath_);
 
    void runForAllEntriesInternal(const std::function<void(const std::string&, Entry&)>& operation, bool includeUnbaked = true);
 
    void runForAllEntriesInternal(const std::string& parentDir, const std::function<void(const std::string&, Entry&)>& operation, bool recursive = true, bool includeUnbaked = true);
 
    [[nodiscard]] std::vector<std::string> verifyEntryChecksumsUsingCRC32() const;
 
    virtual void addEntryInternal(Entry& entry, const std::string& path, std::vector<std::byte>& buffer, EntryOptions options) = 0;
 
    [[nodiscard]] std::string getBakeOutputDir(const std::string& outputDir) const;
 
    void mergeUnbakedEntries();
 
    void setFullFilePath(const std::string& outputDir);
 
    [[nodiscard]] std::string cleanEntryPath(const std::string& path) const;
 
    [[nodiscard]] static Entry createNewEntry();
 
    [[nodiscard]] static std::optional<std::vector<std::byte>> readUnbakedEntry(const Entry& entry);
 
    using OpenFactoryFunctionBasic = std::function<std::unique_ptr<PackFile>(const std::string& path, const EntryCallback& callback)>;
    using OpenFactoryFunction      = std::function<std::unique_ptr<PackFile>(const std::string& path, const EntryCallback& callback, const OpenPropertyRequest& requestProperty)>;
 
    static std::unordered_map<std::string, std::vector<OpenFactoryFunction>>& getOpenExtensionRegistry();
 
    static const OpenFactoryFunction& registerOpenExtensionForTypeFactory(std::string_view extension, const OpenFactoryFunctionBasic& factory);
 
    static const OpenFactoryFunction& registerOpenExtensionForTypeFactory(std::string_view extension, const OpenFactoryFunction& factory);
 
    std::string fullFilePath;
    EntryTrie entries;
    EntryTrie unbakedEntries;
};
 
class PackFileReadOnly : public PackFile {
public:
    [[nodiscard]] constexpr bool isReadOnly() const noexcept final {
        return true;
    }
 
    [[nodiscard]] explicit operator std::string() const override;
 
protected:
    explicit PackFileReadOnly(const std::string& fullFilePath_);
 
    void addEntryInternal(Entry& entry, const std::string& path, std::vector<std::byte>& buffer, EntryOptions options) final;
 
    bool bake(const std::string& outputDir_, BakeOptions options, const EntryCallback& callback) final;
};
 
} // namespace vpkpp
 
#define VPKPP_REGISTER_PACKFILE_OPEN(extension, function) \
    static inline const OpenFactoryFunction& SOURCEPP_UNIQUE_NAME(packFileOpenTypeFactoryFunction) = PackFile::registerOpenExtensionForTypeFactory(extension, function)
 
#define VPKPP_REGISTER_PACKFILE_OPEN_EXECUTABLE(function) \
    static inline const OpenFactoryFunction& SOURCEPP_UNIQUE_NAME(packFileOpenExecutable0TypeFactoryFunction) = PackFile::registerOpenExtensionForTypeFactory(vpkpp::EXECUTABLE_EXTENSION0, function); \
    static inline const OpenFactoryFunction& SOURCEPP_UNIQUE_NAME(packFileOpenExecutable1TypeFactoryFunction) = PackFile::registerOpenExtensionForTypeFactory(vpkpp::EXECUTABLE_EXTENSION1, function); \
    static inline const OpenFactoryFunction& SOURCEPP_UNIQUE_NAME(packFileOpenExecutable2TypeFactoryFunction) = PackFile::registerOpenExtensionForTypeFactory(vpkpp::EXECUTABLE_EXTENSION2, function)