Package.hpp

Go to the documentation of this file.

//
//  CeresEngine - A game development framework
//
//  Created by Rogiel Sulzbach.
//  Copyright (c) 2018-2022 Rogiel Sulzbach. All rights reserved.
//
 
#pragma once
 
#include "Forward.hpp"
 
#include "Resource.hpp"
 
#include "CeresEngine/Macros.hpp"
 
#include "CeresEngine/Foundation/Async.hpp"
#include "CeresEngine/Foundation/SmartPtr.hpp"
#include "CeresEngine/Foundation/URI.hpp"
#include "CeresEngine/Foundation/UUID.hpp"
#include "CeresEngine/Foundation/Threading/ExecutionContext.hpp"
 
namespace CeresEngine {
 
    class PackagedResourceData;
 
    struct PackageMetadata {
        CE_REFLECTABLE_CLASS
        
    public:
        virtual ~PackageMetadata() noexcept = default;
    };
 
    struct PackageID : public UUID {
        using UUID::UUID;
 
        explicit PackageID(const UUID& uuid) : UUID(uuid) {}
 
        static const PackageID null;
    };
    
    class Package final : public RefCounted<Package> {
        friend class PackagedResourceData;
 
        struct Entry {
            ResourceID resourceID;
            
            FilePath path;
            
            WeakResourceHandle<Resource> handle;
        };
 
    private:
        PackageManager& mManager;
 
        PackageURL mPackageURL;
 
    private:
        PackageID mPackageID;
 
        SPtr<PackageMetadata> mMetadata;
 
        struct PrivateData;
        
        UPtr<PrivateData> mData;
 
        struct PackageIndex {
            HashMap<ResourceID, Entry> byUUID;
            
            HashMap<String, Entry> byPath;
        };
 
        LockedObject<PackageIndex, SharedMutex> mIndex;
 
    public:
        explicit Package(PackageManager& manager, const PackageURL& packageURL);
 
        ~Package() noexcept;
 
    public:
        [[nodiscard]] const PackageID& getPackageID() const noexcept { return mPackageID; }
 
        [[nodiscard]] const SPtr<PackageMetadata>& getMetadata() const noexcept { return mMetadata; }
 
        void setMetadata(const SPtr<PackageMetadata>& metadata) noexcept { mMetadata = metadata; }
 
        [[nodiscard]] bool isEmpty() const noexcept;
 
    public: // Resource Management
        Async<> addResource(const FilePath& path, const HResource& resource, bool allowReplacing = false);
        
        Async<> removeResource(const FilePath& path);
        
        Async<> removeResource(const ResourceID& resourceID);
 
        Async<HResource> loadResource(const FilePath& path);
        
        Async<HResource> loadResource(const ResourceID& resourceID);
 
    public: // Package management
        Async<> save();
        Async<> save(const PackageURL& url);
 
    private:
        Optional<FilePath> resolveUUIDToPath(const ResourceID& uuid);
        
        Optional<ResourceID> resolvePathToUUID(const FilePath& path);
    };
 
    using PackagePtr = RC<Package>;
 
    class PackagedResourceData : public ResourceData {
    public:
        explicit PackagedResourceData(Package& package) noexcept;
 
        explicit PackagedResourceData(Package& package, ResourceData&& existingData) noexcept;
    };
 
} // namespace CeresEngine