ComponentBase.hpp

 
//
//  Copyright Phoenix Contact GmbH & Co. KG
//
#pragma once
#ifndef ARP_USE_ARP_SYSTEM_ACF_COMMONS
#include "Arp/Base/Acf/Commons/ComponentBase.hpp"
namespace Arp::System::Acf
{
using Arp::Base::Acf::Commons::ComponentBase;
}
#else
#include "Arp/System/Core/Arp.h"
#include "Arp/System/Acf/ILibrary.hpp"
#include "Arp/System/Acf/IComponent.hpp"
#include "Arp/Base/Rsc/Commons/Services/IRscServiceFactory.hpp"
 
namespace Arp { namespace System { namespace Acf
{
 
using namespace Arp::Base::Rsc::Commons;
 
class ComponentBase : public IComponent
{
public: // construction/destruction
    ComponentBase(
        IApplication& application,
        ILibrary& library,
        const String& fullName,
        ComponentCategory category,
        uint32 startOrder = GetDefaultStartOrder(),
        bool isSingleton = false);
 
    ~ComponentBase(void)override = default;
 
public: // properties
    IApplication&       GetApplication(void)const final;
    ILibrary&           GetLibrary(void)const final;
    String              GetFullName(void)const final;
    ArpVersion          GetVersion(void)const final;
    ComponentCategory   GetComponentCategory(void)const final;
    uint32              GetStartOrder(void)const final;
    bool                IsSingleton(void)const final;
    bool                IsRequired(void)const final;
 
public: // static
    static uint32   GetDefaultStartOrder(void);
 
public: // IComponent operations
    void    Initialize(void)override;
    void    LoadSettings(const String& settingsPath)override;
    void    SetupSettings(void)override;
    void    SubscribeServices(void)override;
    void    PublishServices(void)override;
    void    LoadConfig(void)override;
    void    SetupConfig(void)override;
    void    ResetConfig(void)override;
    void    Dispose(void)override;
    void    PowerDown(void)override;
 
protected: // service operations used by derived items
    template<class TService, class TServiceFactory>
    void    PublishComponentService(void);
 
private: // methods
    void    PublishComponentService(const char* serviceName, IRscServiceFactory* pServiceFactory);
 
private: // deleted methods
    ComponentBase(const ComponentBase& arg) = delete;
    ComponentBase& operator=(const ComponentBase& arg) = delete;
 
private: // fields
    IApplication&       application;
    ILibrary&           library;
    String              fullName;
    ComponentCategory   componentCategory = ComponentCategory::None;
    uint32              startOrder = 0;
    bool                isSingleton = false;
    bool                isRequired = false;
 
private: // static fields
    static const uint32 maxComponentStartOrder;
    static const uint32 customComponentStartOrderShift;
};
 
// inline methods of class ComponentBase
 
inline IApplication& ComponentBase::GetApplication()const
{
    return this->application;
}
 
inline ILibrary& ComponentBase::GetLibrary()const
{
    return this->library;
}
 
inline String ComponentBase::GetFullName()const
{
    return this->fullName;
}
 
inline ArpVersion ComponentBase::GetVersion(void)const
{
    return this->library.GetBuildVersion();
}
 
inline ComponentCategory ComponentBase::GetComponentCategory(void)const
{
    return this->componentCategory;
}
 
inline uint32 ComponentBase::GetStartOrder(void)const
{
    return this->startOrder;
}
 
inline bool ComponentBase::IsSingleton()const
{
    return this->isSingleton;
}
 
inline bool ComponentBase::IsRequired()const
{
    return this->isRequired;
}
 
template<class TService, class TServiceFactory>
inline void ComponentBase::PublishComponentService()
{
    this->PublishComponentService(TService::GetProxyFactory().GetServiceName(), TServiceFactory::Create(*this));
}
 
}}} // end of namesapce Arp::System::Acf
#endif // ndef ARP_USE_ARP_SYSTEM_ACF_COMMONS