PlcDomainProxy.hpp

//
//  Copyright PHOENIX CONTACT Electronics GmbH
//
#pragma once
#include "Arp/System/Core/Arp.h"
#include "Arp/System/Core/event.hxx"
#include "Arp/System/Core/AppDomainSingleton.hxx"
#include "Arp/System/Commons/Logging.h"
#include "Arp/System/Acf/IComponent.hpp"
#include "Arp/System/Rsc/Services/IRscServiceFactory.hpp"
#include "Arp/Plc/Commons/Domain/PlcStartKind.hpp"
 
// forwards
namespace Arp { namespace Plc { namespace Domain
{
class PlcDomainComponent;
class PlcDomainProxyComponent;
}}}
 
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 Watchdog { namespace Services { namespace Internal
{
class IWatchdogInfoService;
}}}}} // end of namespace Arp::Plc::Commons::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::System::Rsc::Services;
using namespace Arp::Plc::Domain;
using namespace Arp::Plc::Commons::Services::Internal;
using namespace Arp::System::Watchdog::Services::Internal;
using namespace Arp::Hardware::DeviceHmi::Services::Internal;
 
class PlcDomainProxy : public AppDomainSingleton<PlcDomainProxy>, private Loggable<PlcDomainProxy>
{
    friend class Arp::Plc::Domain::PlcDomainComponent;
    friend class Arp::Plc::Domain::PlcDomainProxyComponent;
 
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;
    ~PlcDomainProxy(void) = default;
 
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("Obsolete")
    bool    IsPlcSuspendedBySystemWatchdog(bool& warmStartNotPossible, bool& autoRestart); // obsolete
    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: // deleted methods
    PlcDomainProxy(const PlcDomainProxy& arg) = default;
    PlcDomainProxy& operator=(const PlcDomainProxy& arg) = default;
 
private: // fields
    IPlcDomainServicePtr    plcDomainSerivcePtr;
    IWatchdogInfoServicePtr watchdogInfoServicePtr;
    ISwitchesServicePtr     switchesServicePtr;
 
private: // static fields
    boolean                 hasStartStopSwitch = false;     /* here for binary compatibility */
 
};
 
// inline methods of class PlcDomainProxy
 
}}}} // end of namespace Arp::Plc::Commons::Domain