modulecache.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 "projectinfo.h"
 
// External Includes
#include <utility/module.h>
#include <assert.h>
#include <vector>
#include <string>
#include <mutex>
 
namespace nap
{
    // Forward declare
    class ModuleCache;
 
    class NAPAPI Module final
    {
        friend class ModuleCache;
    public:
        Module() = default;
 
        // Copy and move is not allowed
        Module(Module&) = delete;
        Module& operator=(const Module&) = delete;
        Module(Module&&) = delete;
        Module& operator=(Module&&) = delete;
 
        const std::string& getName() const { return mName; }
 
        const ModuleDescriptor& getDescriptor() const { assert(mDescriptor != nullptr); return *mDescriptor; }
 
        const ModuleInfo& getInformation() const { assert(mInfo != nullptr); return *mInfo; }
 
        std::string findAsset(const std::string& name) const;
 
        const rtti::TypeInfo getServiceType() const { return mService; }
 
        const std::vector<const nap::Module*> getDependencies() const { return mDependencies; }
 
    private:
        std::string                     mName;                                  
        ModuleDescriptor*               mDescriptor = nullptr;                  
        std::unique_ptr<ModuleInfo>     mInfo = nullptr;                        
        void*                           mHandle = nullptr;                      
        rtti::TypeInfo                  mService = rtti::TypeInfo::empty();     
        std::vector<const nap::Module*> mDependencies;                          
    };
 
 
    // Module Cache
 
    class NAPAPI ModuleCache final
    {
    public:
        class  Handle;
        static Handle getHandle();
 
        // Copy and move is not allowed
        ModuleCache(ModuleCache&) = delete;
        ModuleCache& operator=(const ModuleCache&) = delete;
        ModuleCache(ModuleCache&&) = delete;
        ModuleCache& operator=(ModuleCache&&) = delete;
 
        class Handle final
        {
            friend class ModuleCache;
        public:
            const nap::Module* sourceModule(const ProjectInfo& projectinfo, const std::string& moduleName, utility::ErrorState& err);
 
            // Copy is not allowed
            Handle(Handle&) = delete;
            Handle& operator=(const Handle&) = delete;
 
            // Move is allowed
            Handle(Handle&& other) noexcept;
            Handle& operator=(Handle&& other) noexcept;
 
        private:
            Handle(nap::ModuleCache& cache, std::mutex& mutex);     
            std::unique_lock<std::mutex> mLock;                     
            nap::ModuleCache* mCache = nullptr;                     
        };
 
    private:
        // Hide constructor
        ModuleCache() = default;
 
        // Attempts to load a NAP module into the current NAP process.
        const nap::Module* sourceModule(const ProjectInfo& projectinfo, const std::string& moduleName, utility::ErrorState& err);
 
        // Find a loaded module by its name as defined in its descriptor file
        const Module* findModule(const std::string& moduleName) const;
 
        // List of unique modules loaded in current host process
        std::vector<std::unique_ptr<Module>> mModules;
    };
}