LibraryBase.hpp

 
//
//  Copyright Phoenix Contact GmbH & Co. KG
//
#pragma once
#include "Arp/Base/Core/Arp.hpp"
#include "Arp/Base/Core/CommonTypeName.hxx"
#include "Arp/Base/Acf/Commons/ILibrary.hpp"
#include "Arp/Base/Acf/Commons/IComponentFactory.hpp"
 
namespace Arp::Base::Acf::Commons
{
 
class ARP_EXPORT LibraryBase : public ILibrary
{
public: // Impl forward declaration
    class Impl;
 
public: // usings
    using FactoryMethod = IComponentFactory::FactoryMethod;             
    using FactoryMethodCompat = IComponentFactory::FactoryMethodCompat; 
 
public: // construction/destruction/assignment
    explicit LibraryBase(const ArpVersion& libraryVersion = ArpVersion{});
    LibraryBase(const LibraryBase& arg) = delete;
    LibraryBase(LibraryBase&& arg)noexcept;
    LibraryBase& operator=(const LibraryBase& arg) = delete;
    LibraryBase& operator=(LibraryBase&& arg)noexcept;
    ~LibraryBase(void)override;
 
public: // ILibrary operations
    void                Initialize(void)override;
    void                Dispose(void)override;
    IComponentFactory&  GetComponentFactory(void)override;
    const ArpVersion&   GetBuildVersion(void)const override;
    const ArpVersion&   GetLibraryVersion(void)const override;
    String              GetLibraryInfoItem(LibraryInfoKind kind)const override;
 
public: // factory operations
    template<class T> void AddComponentType(void);
    template<class T> void RegisterComponentType(void);
    template<class T> void RegisterComponentType(const String& typeName);
 
public: // internal operations
    Impl&       GetImpl(void);
    const Impl& GetImpl(void)const;
 
private: // methods
    void    AddComponentTypeImpl(const String& typeName, FactoryMethod factoryMethod);
    void    RegisterComponentTypeImpl(const String& typeName, FactoryMethodCompat factoryMethod);
 
private: // Impl usings
    using Pimpl = PimplPtr<Impl>;
 
private: // Impl fields
    Pimpl   pimpl;
};
 
template<class T>
inline void LibraryBase::AddComponentType()
{
    auto createComponent = [](ILibrary & library, const String& componentName) -> IComponent::Ptr
    {
        return std::make_shared<T>(library, componentName);
    };
    this->AddComponentTypeImpl(TypeName<T>().GetFullName(), createComponent);
    this->AddComponentTypeImpl(CommonTypeName<T>().GetFullName(), createComponent);
}
 
template<class T>
inline void LibraryBase::RegisterComponentType()
{
    this->RegisterComponentTypeImpl(TypeName<T>().GetFullName(), &T::Create);
}
 
template<class T>
inline void LibraryBase::RegisterComponentType(const String& typeName)
{
    this->RegisterComponentTypeImpl(typeName, &T::Create);
}
 
} // end of namespace Arp::Base::Acf::Commons
 
namespace Arp::System::Acf
{
using Arp::Base::Acf::Commons::LibraryBase;
}