resourcemanager.h

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
#pragma once
 
// Local Includes
#include "numeric.h"
#include "signalslot.h"
#include "corefactory.h"
#include "directorywatcher.h"
 
// External Includes
#include <rtti/rtti.h>
#include <rtti/objectptr.h>
#include <utility/dllexport.h>
#include <rtti/unresolvedpointer.h>
#include <rtti/factory.h>
#include <rtti/deserializeresult.h>
#include <map>
 
namespace nap
{   
    class Core;
    class Scene;
    class Device;
 
    class RTTIObjectGraphItem;
    template<typename ITEM> class ObjectGraph;
    using RTTIObjectGraph = ObjectGraph<RTTIObjectGraphItem>;
 
    class NAPAPI ResourceManager final
    {
        friend class Core;
        RTTI_ENABLE()
    public:
        ResourceManager(nap::Core& core);
 
        ~ResourceManager();
 
        bool loadFile(const std::string& filename, utility::ErrorState& errorState);
 
        /*
        * Loads a json file containing objects. When the objects are loaded, a comparison is performed against the objects that are already loaded. Only
        * the new objects and the objects that are different from the existing objects are loaded into the manager. The set of objects that is new
        * or changed then receives an init() call in the correct dependency order: if an object has a pointer to another object, the pointee is initted
        * first. In case an already existing object that wasn't in the file points to something that is changed, that object is recreated by 
        * cloning it and then calling init() on it. That also happens in the correct dependency order.
        *
        * Because there may be other objects pointing to objects that were read from json (which is only allowed through the ObjectPtr class), the updating
        * mechanism patches all those pointers before calling init(). 
        *
        * In case one of the init() calls fail, the previous state is completely restored by patching the pointers back and destroying objects that were read.
        * The client does not need to worry about handling such cases.
        * In case all init() calls succeed, any old objects are destructed (the cloned and the previously existing objects).
        *
        * Before objects are destructed, onDestroy is called. onDestroy is called in the reverse initialization order. This way, it is still safe to use any 
        * pointers to perform cleanup of internal data. 
        *
        * The file should be located in the 'data' folder (current working directory) of your application.
        *
        * @param filename json file containing all objects.
        * @param externalChangedFile externally changed file that caused load of this file (like texture, shader etc)
        * @param errorState if the function returns false, contains error information.
        * @return if the file loaded successfully.
        */
        bool loadFile(const std::string& filename, const std::string& externalChangedFile, utility::ErrorState& errorState);
 
        rtti::ObjectPtr<rtti::Object> findObject(const std::string& id) const;
 
        template<class T>
        rtti::ObjectPtr<T> findObject(const std::string& id) const { return rtti::ObjectPtr<T>(findObject(id)); }
 
        template<class T>
        std::vector<rtti::ObjectPtr<T>> getObjects() const;
 
        rtti::ObjectPtr<rtti::Object> createObject(const rtti::TypeInfo& type);
 
        template<typename T>
        rtti::ObjectPtr<T> createObject() { return rtti::ObjectPtr<T>(createObject(RTTI_OF(T))); }
 
        void checkForFileChanges();
 
        rtti::Factory& getFactory();
 
        void watchDirectory(const std::string& directory);
 
        nap::Signal<> mPreResourcesLoadedSignal;
 
        nap::Signal<> mPostResourcesLoadedSignal;
 
    private:
        using InstanceByIDMap   = std::unordered_map<std::string, rtti::Object*>;                   // Map from object ID to object (non-owned)
        using ObjectByIDMap     = std::unordered_map<std::string, std::unique_ptr<rtti::Object>>;   // Map from object ID to object (owned)
        using FileLinkMap       = std::unordered_map<std::string, std::vector<std::string>>;        // Map from target file to multiple source files
 
        class OverlayLinkResolver;
 
        enum class EFileModified : uint8_t
        {
            Yes,
            No,
            Error
        };
 
        void addObject(const std::string& id, std::unique_ptr<rtti::Object> object);
        void removeObject(const std::string& id);
        void addFileLink(const std::string& sourceFile, const std::string& targetFile);
 
        bool loadFileAndDeserialize(const std::string& filename, rtti::DeserializeResult& readResult, utility::ErrorState& errorState);
 
        void determineObjectsToInit(const RTTIObjectGraph& objectGraph, const ObjectByIDMap& objectsToUpdate, const std::string& externalChangedFile, std::vector<std::string>& objectsToInit);
        void buildObjectGraph(const ObjectByIDMap& objectsToUpdate, RTTIObjectGraph& objectGraph);
        EFileModified isFileModified(const std::string& modifiedFile);
        void stopAndDestroyAllObjects();
        void destroyObjects(const std::unordered_set<std::string>& objectIDsToDelete, const RTTIObjectGraph& object_graph);
 
    private:
        struct RollbackHelper final
        {
        public:
            RollbackHelper(ResourceManager& service);
            ~RollbackHelper();
 
            void clear();
            void addExistingDevice(Device& device);
            void addNewDevice(Device& device);
            void addInitializedObject(rtti::Object& object);
 
            ObjectByIDMap& getObjectsToUpdate() { return mObjectsToUpdate; }
 
        private:
            void destroyObjects();
 
        private:
            ResourceManager&            mService;
            ObjectByIDMap               mObjectsToUpdate;           
            std::vector<Device*>        mExistingDevices;           
            std::vector<Device*>        mNewDevices;                
            std::vector<rtti::Object*>  mInitializedObjects;        
            bool                        mRollbackObjects = true;
        };
 
        using ModifiedTimeMap = std::unordered_map<std::string, uint64>;
 
        ObjectByIDMap                       mObjects;                       // Holds all objects
        std::set<std::string>               mFilesToWatch;                  // Files currently loaded, used for watching changes on the files
        FileLinkMap                         mFileLinkMap;                   // Map containing links from target to source file, for updating source files if the file monitor sees changes
        std::unique_ptr<DirectoryWatcher>   mDirectoryWatcher = nullptr;    // File monitor, detects changes on files
        ModifiedTimeMap                     mFileModTimes;                  // Cache for file modification times to avoid responding to too many file events
        std::unique_ptr<CoreFactory>        mFactory = nullptr;             // Responsible for creating objects when de-serializing
        Core&                               mCore;                          // Core
    };
 
 
    template<class T>
    std::vector<rtti::ObjectPtr<T>> ResourceManager::getObjects() const
    {
        std::vector<rtti::ObjectPtr<T>> result;
        for (auto& kvp : mObjects)
        {
            T* object = rtti_cast<T>(kvp.second.get());
            if (object != nullptr)
                result.push_back(object);
        }
 
        return result;
    }
}