ModuleFactory.hxx

 
//
//  Copyright PHOENIX CONTACT Electronics GmbH
//
#pragma once
#include "Arp/System/Core/Arp.h"
#include "Arp/System/Commons/Exceptions/ArgumentException.hpp"
#include <memory>
#include <vector>
 
namespace Arp { namespace System { namespace Commons { namespace Extensibility
{
 
template<typename TModuleInterface>
class ModuleFactory
{
public:
    // typedefs
    using ModuleInterfacePtr = std::unique_ptr<TModuleInterface>;
    using FactoryFunction = std::function<ModuleInterfacePtr()>;
    using FactoryFunctions = std::vector<std::pair<String, FactoryFunction>>;
 
    // construction/destruction
    ModuleFactory(void) = default;
    ModuleFactory(const ModuleFactory& arg) = default;
    ModuleFactory(ModuleFactory&& arg) noexcept = default;
    ModuleFactory& operator=(const ModuleFactory& arg) = default;
    ModuleFactory& operator=(ModuleFactory&& arg) noexcept = default;
    virtual ~ModuleFactory(void) noexcept = default;
 
    ModuleInterfacePtr Create(const String& moduleName) const;
 
    std::vector<String> GetModuleNames() const;
 
    void AddFactoryFunction(const String& moduleName, FactoryFunction function);
 
 
private:
    typename FactoryFunctions::const_iterator FindByName(const String& moduleName) const;
 
private:
    FactoryFunctions factoryFunctions;
};
 
 
template<typename TModuleInterface>
typename ModuleFactory<TModuleInterface>::ModuleInterfacePtr ModuleFactory<TModuleInterface>::Create(const String& moduleName) const
{
    auto it = this->FindByName(moduleName);
    if (it == this->factoryFunctions.end())
    {
        return ModuleInterfacePtr{};
    }
    else
    {
        return it->second();
    }
}
 
template<typename TModuleInterface>
std::vector<String> ModuleFactory<TModuleInterface>::GetModuleNames() const
{
    std::vector<String> result;
    result.reserve(this->factoryFunctions.size());
    std::transform(this->factoryFunctions.begin(), this->factoryFunctions.end(),
                   std::back_inserter(result), [](const typename FactoryFunctions::value_type & each)
    {
        return each.first;
    });
    return result;
}
 
template<typename TModuleInterface>
void ModuleFactory<TModuleInterface>::AddFactoryFunction(
    const String& moduleName, FactoryFunction function)
{
    if (moduleName.IsEmpty())
    {
        throw ArgumentException::Create("moduleName", moduleName, "Invalid module name");
    }
 
    if (function == nullptr)
    {
        throw ArgumentException::Create("function", static_cast<void*>(nullptr), "Invalid factory function.");
    }
 
    auto it = this->FindByName(moduleName);
    if (it == this->factoryFunctions.end())
    {
        this->factoryFunctions.emplace_back(moduleName, function);
    }
    else
    {
        throw ArgumentException::Create("moduleName", moduleName, "Duplicate module name");
    }
}
 
template<typename TModuleInterface>
typename ModuleFactory<TModuleInterface>::FactoryFunctions::const_iterator ModuleFactory<TModuleInterface>::FindByName(
    const String& moduleName) const
{
    return std::find_if(this->factoryFunctions.begin(), this->factoryFunctions.end(),
                        [&moduleName](const typename FactoryFunctions::value_type & each)
    {
        return each.first == moduleName;
    });
}
 
 
 
}}}} // namespace Arp::System::Commons::Extensibility