PlcDomainProxy.hpp

 
//
//  Copyright Phoenix Contact GmbH & Co. KG
//
#pragma once
#include "Arp/System/Core/Arp.h"
#include "Arp/System/Core/event.hxx"
#include "Arp/System/Commons/Logging.h"
#include "Arp/System/Acf/IComponent.hpp"
#include "Arp/Plc/Domain/Commons/PlcStartKind.hpp"
 
// forwards
namespace Arp { namespace Plc { namespace Domain
{
class PlcDomainComponent;
class PlcDomainProxyComponent;
}}}
 
// forwards
namespace Arp::Base::Rsc::Commons::Services
{
class IRscServiceFactory;
}
 
namespace Arp { namespace Plc { namespace Commons { namespace Services { namespace Internal
{
class IPlcDomainService;
}}}}} // end of namespace Arp::Plc::Commons::Services::Internal
 
namespace Arp { namespace System { namespace Monitoring { namespace Services { namespace Internal
{
class IWatchdogInfoService;
}}}}} // end of namespace Arp::System::Monitoring::Services::Internal
 
namespace Arp { namespace Hardware { namespace DeviceHmi { namespace Services { namespace Internal
{
class ISwitchesService;
}}}}} // end of namespace Arp::Hardware::DeviceHmi::Services::Internal
 
namespace Arp { namespace Plc { namespace Commons { namespace Domain
{
 
using namespace Arp::System::Acf;
using namespace Arp::Plc::Domain;
using namespace Arp::Base::Rsc::Commons::Services;
using namespace Arp::Plc::Commons::Services::Internal;
using namespace Arp::System::Monitoring::Services::Internal;
using namespace Arp::Hardware::DeviceHmi::Services::Internal;
 
class PlcDomainProxy : private Loggable<PlcDomainProxy>
{
    friend class Arp::Plc::Domain::PlcDomainComponent;
    friend class Arp::Plc::Domain::PlcDomainProxyComponent;
 
public: // usings
    using Instance = PlcDomainProxy;
    using InstancePtr = std::unique_ptr<Instance>;
    using PlcStartKind = Arp::Plc::Domain::Commons::PlcStartKind;
 
private: // using/typedefs
    using IPlcDomainServicePtr = std::shared_ptr<IPlcDomainService>;
    using IWatchdogInfoServicePtr = std::shared_ptr<IWatchdogInfoService>;
    using ISwitchesServicePtr = std::shared_ptr<ISwitchesService>;
 
public: // construction/destruction
    PlcDomainProxy(void) = default;
 
public: // static singleton operations
    static Instance&    CreateInstance(void);
    static bool         IsCreated(void);
    static void         DisposeInstance(void);
    static Instance&    GetInstance(void);
 
public: // events
    event<void>         PlcLoading;
    event<void>         PlcLoaded;
    event<PlcStartKind> PlcStarting;
    event<void>         PlcStarted;
    event<void>         PlcStopping;
    event<void>         PlcStopped;
    event<bool>         PlcUnloading;   // bool parameter = 'onError'
    event<bool>         PlcUnloaded;    // bool parameter = 'onError'
    event<void>         PlcChanging;
    event<bool>         PlcChanged;     // bool parameter = 'success'
 
public: // properties setter/getter
    ARP_DEPRECATED("Not required anymore. Moved to PLC manager")
    bool    IsPlcSuspendedBySwitch(void);
    ARP_DEPRECATED("Not required anymore. Moved to PLC manager")
    bool    IsPlcSuspendedBySystemWatchdog(bool& warmStartNotPossible, bool& autoRestart);
    ARP_DEPRECATED("Not required anymore. Moved to PLC manager")
    bool    IsPlcSuspendedBySystemWatchdog(PlcStartKind& startKind);
 
public: // operations
    void    RegisterComponent(IComponent& component, bool isSystemComponent = false);
    void    RegisterProxyComponent(IComponent& component);
    void    UnregisterComponent(IComponent& component);
 
private: // methods
    void    PublishComponentService(IComponent& component, const char* serviceName, IRscServiceFactory* pServiceFactory);
 
private: // methods
    void    SubscribeServices(bool isPlcProcess = false);
 
private: // fields
    IPlcDomainServicePtr    plcDomainSerivcePtr;
    IWatchdogInfoServicePtr watchdogInfoServicePtr;
    ISwitchesServicePtr     switchesServicePtr;
 
private: // static fields
    static InstancePtr      instancePtr;
    boolean                 hasStartStopSwitch = false;     /* here for binary compatibility */
};
 
// inline methods of class PlcDomainProxy
 
}}}} // end of namespace Arp::Plc::Commons::Domain