SharedModuleLibrary.hxx

 
//
//  Copyright Phoenix Contact GmbH & Co. KG
//
#pragma once
#include "Arp/System/Core/Arp.h"
#include "Arp/System/Core/CommonTypeName.hxx"
#include "Arp/System/Commons/Runtime/SharedLibrary.hpp"
#include "Arp/System/Commons/Extensibility/SharedModuleLibraryLoader.hpp"
#include "Arp/System/Commons/Extensibility/ModuleLibraryBase.hxx"
#include "Arp/System/Commons/Exceptions/InvalidOperationException.hpp"
 
namespace Arp { namespace System { namespace Commons { namespace Extensibility
{
 
template<typename TModuleInterface>
class SharedModuleLibrary
{
public: // typedefs
    using ModuleInterfacePtr = std::unique_ptr<TModuleInterface>;
 
private: // typedefs
    using ModuleLibrary = ModuleLibraryBase<TModuleInterface>;
    using ModuleLibraryFactoryFunction = const ModuleLibrary & (*)();
 
public: // construction/destruction
    explicit SharedModuleLibrary(const String& path, SharedLibraryMemoryLockOption sharedLibraryMemoryLockOption = SharedLibraryMemoryLockOption::Nothing);
    SharedModuleLibrary(const SharedModuleLibrary& arg) = delete;
    SharedModuleLibrary(SharedModuleLibrary&& arg) = delete;
    SharedModuleLibrary& operator=(const SharedModuleLibrary& arg) = delete;
    SharedModuleLibrary& operator=(SharedModuleLibrary&& arg) = delete;
    virtual ~SharedModuleLibrary(void) = default;
 
public:
 
    template<typename TModule>
    ModuleInterfacePtr CreateModule() const;
 
    ModuleInterfacePtr CreateModule(const String& moduleName) const;
    const String& GetFullPath() const;
    String GetFileName() const;
    bool Exists() const;
    bool IsLoaded() const;
    void Load();
    void Unload();
 
protected:
    virtual String GetModuleLibraryFactoryFunctionName() const = 0;
 
private:
    ModuleLibraryFactoryFunction GetModuleLibraryFactoryFunction(SharedLibrary& sharedLibrary) const;
 
private:
    SharedModuleLibraryLoader loader;
    const ModuleLibrary* libraryBase = nullptr;
 
};
 
template<typename TModuleInterface>
SharedModuleLibrary<TModuleInterface>::SharedModuleLibrary(const String& path, SharedLibraryMemoryLockOption sharedLibraryMemoryLockOption)
    : loader(path, sharedLibraryMemoryLockOption)
{
}
 
template<typename TModuleInterface>
template<typename TModule>
typename SharedModuleLibrary<TModuleInterface>::ModuleInterfacePtr SharedModuleLibrary<TModuleInterface>::CreateModule() const
{
    return this->CreateModule(CommonTypeName<TModule>());
}
 
template<typename TModuleInterface>
typename SharedModuleLibrary<TModuleInterface>::ModuleInterfacePtr
SharedModuleLibrary<TModuleInterface>::CreateModule(const String& moduleName) const
{
    if (this->libraryBase == nullptr)
    {
        return{};
    }
    else
    {
        return this->libraryBase->GetFactory().Create(moduleName);
    }
}
 
template<typename TModuleInterface>
const String& SharedModuleLibrary<TModuleInterface>::GetFullPath() const
{
    return loader.GetFullPath();
}
 
template<typename TModuleInterface>
String SharedModuleLibrary<TModuleInterface>::GetFileName() const
{
    return loader.GetFileName();
}
 
template<typename TModuleInterface>
bool SharedModuleLibrary<TModuleInterface>::Exists() const
{
    return loader.Exists();
}
 
template<typename TModuleInterface>
bool SharedModuleLibrary<TModuleInterface>::IsLoaded() const
{
    return loader.IsLoaded();
}
 
template<typename TModuleInterface>
void SharedModuleLibrary<TModuleInterface>::Load()
{
    this->loader.Load();
    if (this->loader.IsLoaded())
    {
        auto f = GetModuleLibraryFactoryFunction(this->loader.GetSharedLibrary());
        this->libraryBase = &f();
    }
}
 
template<typename TModuleInterface>
void SharedModuleLibrary<TModuleInterface>::Unload()
{
    if (this->loader.IsLoaded())
    {
        this->libraryBase = nullptr;
    }
    this->loader.Unload();
}
 
template<typename TModuleInterface>
typename SharedModuleLibrary<TModuleInterface>::ModuleLibraryFactoryFunction
SharedModuleLibrary<TModuleInterface>::GetModuleLibraryFactoryFunction(SharedLibrary& sharedLibrary) const
{
    auto result = reinterpret_cast<ModuleLibraryFactoryFunction>(
                      sharedLibrary.GetFunctionAddress(GetModuleLibraryFactoryFunctionName()));
    if (result == nullptr)
    {
        throw InvalidOperationException(
            "Could not get module library factory function from '{0}'", this->GetFileName());
    }
    return result;
}
 
}}}} // end of namespace Arp::System::Commons::Extensibility