NmBuildingAutomation.h

Go to the documentation of this file.

#ifndef __NMBUILDINGAUTOMATION_H__
#define __NMBUILDINGAUTOMATION_H__

#include "nodemanagerbase.h"
#include "variablehandle.h"
#include "opcua_baseobjecttype.h"
#include "iomanager.h"
#include "CANOpenServerConfig.h"
#include "ControlInterface.h"


namespace AddressSpace
{
        class UaControlVariable;

        typedef  std::vector<UaControlVariable *> UaControlVariableSet ;
        typedef  std::map<string, UaControlVariable *> UaControlVariableMap;

//      class UaCanBusObject;
//      class UaCanNodeObject;
        class UaCalcCompiler;
        
        class NmBuildingAutomation : public NodeManagerBase
        {
                UA_DISABLE_COPY(NmBuildingAutomation);
        public:

                NmBuildingAutomation(shared_ptr<UserDevice::ControlInterface> conInterf, const UaString nameOfSerevr);

                virtual ~NmBuildingAutomation();

                virtual UaStatus   afterStartUp();   
                virtual UaStatus   beforeShutDown();  

                virtual UaStatus readValues(const UaVariableArray &arrUaVariables, UaDataValueArray &arrDataValues);

                virtual UaStatus writeValues(const UaVariableArray &arrUaVariables, const PDataValueArray &arrpDataValues, UaStatusCodeArray &arrStatusCodes);

                virtual IOManager* getIOManager(UaNode* pUaNode,  OpcUa_Int32 attributeId) const;

                virtual VariableHandle* getVariableHandler(Session* session, VariableHandle::ServiceType serviceType, OpcUa_NodeId *nodeId, OpcUa_Int32 attributeId);

                UaNodeId getNewNodeId(const UaNode *,const UaString );                  
                UaNodeId getTopNodeId(const UaNode *pNode) const;                               
//              UaNodeId getCanNodeNodeId(const UaNode *pNode) const;                   //! get node id of can node 
                UaNode*  getUpNode(const UaNode *pNode) const; 
                UaString getDefaultLocale() const { return m_defaultLocaleId; }


                OpcUa_Int32 findUaVariables(const OpcUa::BaseObjectType *pParObj,string& pattern, UaControlVariableSet& storage);  

                OpcUa_Int32 findUaNodeVariables(UaNode *pNode,string& pattern,UaControlVariableSet &storage);

                shared_ptr<UserDevice::ControlInterface> m_pControlInterface;                   
//              UaStatusCode createNodeManagerAliasNode(const UaNodeId &sourceNodeId);
                UaObject* getInstanceDeclarationObject(OpcUa_UInt32 numericIdentifier,NodeManagerUaNode *nm)            
                {
                        return getInstanceDeclaration<UaObject>(numericIdentifier,nm);
                }
                //              UaObject* getInstanceDeclarationObjectType(OpcUa_UInt32 numericIdentifier); //! get an object type based on numerical id ( if not return null)
                //              UaMethod* getInstanceDeclarationMethod(OpcUa_UInt32 numericIdentifier);         //! get a method based on numerical id ( if not return null)
                UaVariable* getInstanceDeclarationVariable(const UaNodeId &n)           
                {
                        return getInstanceDeclaration<UaVariable>(n);
                }
                //              UaVariable* getInstanceDeclarationVariable(const UaString );            //! get a variable based on string ( if not return null)

                UaObjectType* getInstanceDeclarationObjectType(OpcUa_UInt32 numericIdentifier) 
                {
                        
                        return getInstanceDeclaration<UaObjectType>(numericIdentifier, m_pControlInterface->getNodeTypeManager());
                        // Try to find the instance declaration node with the numeric identifier 
                        // and the namespace index of this node manager
                        //UaNode* pNode = m_pTypeNodeManager->getNode(UaNodeId(numericIdentifier, m_pTypeNodeManager->getNameSpaceIndex()));

                        //if (pNode != NULL) {
                        //      int t = pNode->nodeClass();
                        //      if (t == OpcUa_NodeClass_ObjectType)
                        //      {
                        //              // Return the node if valid and a variable
                        //              return (UaObject*)pNode;
                        //      }
                        //}
                        return NULL;
                }

                UaVariableType* getInstanceDeclarationVariableType(OpcUa_UInt32 numericIdentifier) 
                {
                        return getInstanceDeclaration<UaVariableType>(numericIdentifier, m_pControlInterface->getNodeTypeManager());
                        
                        // Try to find the instance declaration node with the numeric identifier 
                        // and the namespace index of this node manager
                        //UaNode* pNode = m_pTypeNodeManager->getNode(UaNodeId(numericIdentifier, m_pTypeNodeManager->getNameSpaceIndex()));

                        //if (pNode != NULL) {
                        //      int t = pNode->nodeClass();
                        //      if (t == OpcUa_NodeClass_VariableType)
                        //      {
                        //              // Return the node if valid and a variable
                        //              return (UaVariableType*)pNode;
                        //      }
                        //}
                        //return NULL;
                }

                UaNode*  findNode(const UaNodeId &NodeId) const { return NodeManagerBase::findNode(NodeId); } 

        private:
                template<typename X>
                X* getInstanceDeclaration(OpcUa_UInt32 numericIdentifier, NodeManagerUaNode *nm)
                {
                        X* pNode = dynamic_cast<X *>(nm->getNode(UaNodeId(numericIdentifier, nm->getNameSpaceIndex())));
                        //X* pNode = dynamic_cast<X *>(findNode(UaNodeId(numericIdentifier, nm->getNameSpaceIndex())));
                        return pNode;
                };

                template<typename X>
                X* getInstanceDeclaration(const UaNodeId &n)
                {
                        X* pNode = dynamic_cast<X *>(getNode(n));
                        //                      X* pNode = dynamic_cast<X *>(findNode(n));
                        return pNode;
                };



                UaStatus createTypeNodes();  
                UaStatus createNodeTypes();  
                UaStatus createCanbuses();   
//              UaStatus createItems();      //! create calculated items

                UaString        m_sNameNodeId;
                OpcUa_Int32 m_iNumNameNodeId;

                CanOpenOpcServerConfig::NODETYPE_sequence       m_nodetypes;    
                CanOpenOpcServerConfig::CANBUS_sequence         m_canbuses;             
                CanOpenOpcServerConfig::ITEM_sequence           m_items;                
                CanOpenOpcServerConfig::REGEXPR_sequence        m_regexprisson; 

        };
}
#endif // __NMBUILDINGAUTOMATION_H__