cta_ua_controllerobject.h

Aller à la documentation de ce fichier.

#ifndef __CONTROLLEROBJECT_H__
#define __CONTROLLEROBJECT_H__

#include "uaobjecttypes.h"
#include "methodmanager.h"
#include "opcua_offnormalalarmtype.h"

#include <string>
#include "hardwarecommunicationinterface.h"

class UaMethodGeneric;
class HardWareCommunicationInterface;

namespace CTA_UA {
class ClientManager;
}

namespace CTA_Slc_Dict {
//class DeviceCollector;
class InterfaceManager;
}

namespace CTA_UA {

class ControllerObject: public UaObjectBase, public MethodManager {
    UA_DISABLE_COPY(ControllerObject);
public:
    struct Tab {
        int taille;
        std::string* element;
    };

    ControllerObject(const UaString& name, const UaString& nameParent,
            const UaNodeId& newNodeId, const UaString& defaultLocaleId,
            int alarmFlag, CTA_Hardware::HardWareInterface *hardwareComm);

    virtual ~ControllerObject(void);
    //void set();
    void init();
    void setAlarm(int onOff, std::string message, int severity);
    // Implement UaObject interface
    OpcUa_Byte eventNotifier() const;
    // Override UaObject method implementation
    MethodManager* getMethodManager(UaMethod* pMethod) const;
    void addMethod(UaMethodGeneric* m_pMethod);

    // Implement MethodManager interface
    virtual UaStatus beginCall(MethodManagerCallback* pCallback,
            const ServiceContext& serviceContext, OpcUa_UInt32 callbackHandle,
            MethodHandle* pMethodHandle, const UaVariantArray& inputArguments);
    OpcUa_Int16 getTypeNamespace();

    // Own synchronous call implementation the can be overridden in subclasses
    UaStatus call(UaMethod* /*pMethod*/,
            const UaVariantArray& /*inputArguments*/,
            UaVariantArray& /*outputArguments*/,
            UaStatusCodeArray& /*inputArgumentResults*/,
            UaDiagnosticInfos& /*inputArgumentDiag*/);

    std::map<std::string, Tab> mymap;
    std::map<std::string, std::string> elementmap;
    UaString m_fichierMain;
    static OpcUa_Int16 s_namespaceIndex;
    CTA_UA::NodeManagerCTA* m_pNodeManager;

    virtual UaNodeId typeDefinitionId() const;
    void setEvent(std::map<std::string, std::string> m_eventList);

protected:
    UaMutexRefCounted* m_pSharedMutex;
    OpcUa_UInt32 m_deviceAddress;

private:
    void caseSet(std::string &commandString,std::string chemin, std::string element);
    int caseGet(std::string commandString,std::string chemin, std::string element,UaVariantArray& outputArguments);
    void buildResult(std::string resultString,UaVariantArray& outputArguments);
    void buildCommand(std::string &commandString,const UaVariantArray& inputArguments ,int terminal,vector<int> index);

    ClientManager *m_pClientManager;
    CTA_Hardware::HardWareInterface *m_hardwareComm;
    UaMethodGeneric* m_pMethod;
    UaMethodGeneric* m_pMethodStop;
    UaString m_name;
    CTA_Slc_Dict::InterfaceManager *m_interfaceManager;

    std::string m_pname;
    std::string m_parent;
    std::string m_full;
    std::string m_address;
    int m_port;
    int m_eventFlag;
    int m_alarmFlag;
    OpcUa::OffNormalAlarmType* m_pStateOffNormalAlarm;
    std::map<std::string, std::string> m_eventList;
};
} // end namespace
#endif