modulemanager.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 <utility/errorstate.h>
#include <rtti/typeinfo.h>
#include <string>
#include <vector>
#include <assert.h>
 
namespace nap
{
    // Forward Declares
    class Core;
    class ModuleManager;
 
    class NAPAPI Module final
    {
        friend class ModuleManager;
    public:
        Module() = default;
 
        // Copy is not allowed
        Module(Module&) = delete;
 
        // Copy assignment is not allowed
        Module& operator=(const Module&) = delete;
 
        // Move is not allowed
        Module(Module&&) = delete;
 
        // Move assignment is not allowed
        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; }
 
    private:
        std::string                     mName;                                  
        ModuleDescriptor*               mDescriptor = nullptr;                  
        std::unique_ptr<ModuleInfo>     mInfo = nullptr;                        
        void*                           mHandle = nullptr;                      
        rtti::TypeInfo                  mService = rtti::TypeInfo::empty();     
    };
 
 
    class NAPAPI ModuleManager final
    {
        friend class Core;
    public:
        // Constructor
        ModuleManager(Core& core);
 
        // Destructor
        ~ModuleManager();
 
        // Copy is not allowed
        ModuleManager(ModuleManager&) = delete;
 
        // Copy assignment is not allowed
        ModuleManager& operator=(const ModuleManager&) = delete;
 
        // Move is not allowed
        ModuleManager(ModuleManager&&) = delete;
        
        // Move assignment is not allowed
        ModuleManager& operator=(ModuleManager&&) = delete;
 
        bool loadModules(const ProjectInfo& projectInfo, utility::ErrorState& error);
 
        std::vector<nap::Module*> getModules() const;
 
        const Module* findModule(const std::string& moduleName) const;
 
        const Module* findModule(const nap::rtti::TypeInfo& serviceType) const;
 
        template<typename T>
        const Module* findModule() const    { return findModule(RTTI_OF(T)); }
 
    private:
        bool sourceModule(const ProjectInfo& projectinfo, const std::string& moduleName, utility::ErrorState& err);
 
        std::vector<std::unique_ptr<Module>>            mModules;   // The loaded modules
        Core&                                           mCore;      // Core
    };
}