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
    bool    IsPlcSuspendedBySwitch(void);
    bool    IsPlcSuspendedBySystemWatchdog(bool& warmStartNotPossible, bool& autoRestart); // obsolete
    bool    IsPlcSuspendedBySystemWatchdog(PlcStartKind& startKind);

public: // operations
    void    RegisterComponent(IComponent& component, bool isSystemComponent = false);
    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