UaCalcItem.hpp

Go to the documentation of this file.

#ifndef __UACALCITEM_H__
#define __UACALCITEM_H__

#include <opcua_basedatavariabletype.h>
#include "NmBuildingAutomation.h"
#include "UaControlDeviceItem.h"
#include "UaControlDeviceGeneric.h"
#include "uadatetime.h"
#include "uadatavalue.h"
#include <cmath>
#include <string>
#include "srvtrace.h"

#include "muParser.h"
//#include "muParserDef.h"

#ifndef isnan
#define isnan(x) std::isnan(x)
#endif

#ifndef isinf
#define isinf(x) std::isinf(x)
#endif

namespace AddressSpace
{
        typedef  std::map<string,vector<UaControlVariable *> > mapDataVariable ;  
        
        typedef ::ITEM ITEM_type;
        typedef ::xsd::cxx::tree::sequence< ITEM_type > ITEM_sequence;
        typedef ITEM_sequence::iterator ITEM_iterator;
        typedef ITEM_sequence::const_iterator ITEM_const_iterator;
                
        typedef ::REGEXPR REGEXPR_type;
        typedef ::xsd::cxx::tree::sequence< REGEXPR_type > REGEXPR_sequence;
        typedef REGEXPR_sequence::iterator REGEXPR_iterator;
        typedef REGEXPR_sequence::const_iterator REGEXPR_const_iterator;

        class UaCalcItem: public UaControlVariable
        {
                UA_DISABLE_COPY(UaCalcItem);
        public:
/*
                struct UaControlVariableValue {
                        double value;
                        UaControlVariable *ucv;
                        bool active;
                        UaControlVariableValue(UaControlVariable *o, double d)
                        {
                                ucv = o; active = false; value = d;
                        };
                };
*/
//              typedef map<UaNodeId, UaControlVariableValue *> variableSet;
                typedef map<std::string, UaControlVariable*> variableSet; 

                virtual void calculateOnChange(Session *pSession, const UaDataValue& dataValue, OpcUa_Boolean checkAccessLevel);

                virtual void initCalculation();
                
//              UaCalcItem( const UaString& name,UaNodeId& uaId, 
//                      NmBuildingAutomation * pNodeConfig, UaVariant &dv,string &formul, string &whenCondition, string &statusCondition,UaMutexRefCounted* pSharedMutex );

                UaCalcItem(const UaString& name, UaNodeId& uaId, const UaNode *parent,
                        NmBuildingAutomation * pNodeConfig, UaVariant &dv, ITEM &citem, UaControlVariableMap &cvs, UaMutexRefCounted* pSharedMutex);

//              bool compile();

                virtual ~UaCalcItem(void) {}

                void pushDataVariable(std::string& name,UaControlVariable *obd)
                        { 
                                boost::arg<1> _1;
                                boost::arg<2> _2;
                                boost::arg<3> _3;

//                              UaDataValue ud = obd->value(0);
//                              UaControlVariableValue * u = new UaControlVariableValue(obd, convertToDouble(ud));
//                              cout << "ADD " << name << obd->browseName().toString().toUtf8() << endl << flush;

                                m_formul.DefineVar(name, &(obd->curValue));
                                m_var.insert(pair<string, UaControlVariable *>(name, obd));

                                if ( m_sWhenCondition.length() == 0)
                                        obd->valueChange.connect(boost::bind(&UaCalcItem::calculateOnChange,this,_1,_2,_3));
                        }

                void pushConditionVariable(std::string& name, UaControlVariable *obd)
                        { 
                                boost::arg<1> _1;
                                boost::arg<2> _2;
                                boost::arg<3> _3;
//                              UaDataValue ud = obd->value(0);
//                              UaControlVariableValue * u = new UaControlVariableValue(obd, convertToDouble(ud));

                                m_formul.DefineVar(name, &(obd->curValue));
                                m_whenVar.insert(pair<string, UaControlVariable *>(name, obd));
                                obd->valueChange.connect(boost::bind(&UaCalcItem::calculateOnChange,this,_1,_2,_3));
                        }
                void pushStatusVariable(std::string& name, UaControlVariable *obd)
                        { 
//                              boost::arg<1> _1;
//                              UaDataValue ud = obd->value(0);
//                              UaControlVariableValue * u = new UaControlVariableValue(obd, convertToDouble(ud));

                                m_statusFormula.DefineVar(name, &(obd->curValue));
                                m_statusVar.insert(pair<string ,UaControlVariable *>(name,obd));
                }

                OpcUa_StatusCode checkStatus(variableSet& vs)
                {
                        OpcUa_StatusCode ret = OpcUa_Good;
                        for (UaControlVariableMap::const_iterator vit = vs.begin(); vit != vs.end(); vit++)
                        {
                                UaControlVariable *uac = (*vit).second;
                                ret = uac->value(0).statusCode();
//                              cout << "Status Code " << uac->browseName().toString().toUtf8() << " "<< hex << ret << " value "<< uac->curValue << endl << flush;
                                if (ret != OpcUa_Good)
                                        break;
                        }
                        return ret;
                }

                static mu::value_type* getValueFromItem(const mu::char_type* ind, void * pNode);
                static mu::value_type* getValueFromWhenItem(const mu::char_type* ind, void* pNode);
                static mu::value_type* getValueFromStatusItem(const mu::char_type* ind, void* pNode);

                string &getFormula() { return m_sFormul; }
                string &getWhenCondition() { return m_sWhenCondition; }
                string &getStatusCondition() { return m_sStatusCondition; }

                //UaDateTime UaGetSourceTimeStamp(); //! define the timestamps of latest control variable

                static double PowFunc(double a_fVal, double b_fVal)
                {
                        double d = std::pow(a_fVal, b_fVal);
                        return d;
                }

        private:
//              double convertToDouble(variableSet::iterator &vit);
                
                mu::Parser m_whenCondition;             
                mu::Parser m_formul;                            
                mu::Parser m_statusFormula;             

                bool m_fExists;
                bool m_cExists;
                bool m_sExists;

                variableSet m_whenVar;                          
                variableSet m_var;                                      
                variableSet m_statusVar;                                

                string m_sFormul;                                       
                string m_sWhenCondition;                        
                string m_sStatusCondition;                      
                NmBuildingAutomation *m_pNodeManager;
                const UaNode *m_pParent;
        };

        /*
        class UaCalcCompilerItem
        {
        public:
                typedef void(UaCalcItem::*pushUaVariable)(std::string& , UaControlVariable *);
                
                UaCalcCompilerItem(string name, REGEXPR_sequence &regex)
                {
                        m_regex = regex;
                        m_pParentCalc = 0;
                        m_sName =  name;
                        m_whenCondition = 0;
                        m_formul = 0;
                        m_statusFormula = 0;
                        m_pSharedMutex = 0;

                };

                UaCalcCompilerItem(string name, OpcUa::BaseObjectType *pcn, REGEXPR_sequence &regex)
                {
                        m_regex = regex;
                        m_pParentCalc = pcn;
                        m_sName =  name;
                        m_whenCondition = 0;
                        m_formul = 0;
                        m_statusFormula = 0;

                        m_pSharedMutex = ((UaControlDeviceGeneric *)pcn)->getSharedMutex();

                };

                ~UaCalcCompilerItem()
                {
                        m_vCalcItem.clear();
                }

                void setFormula(string *formul) { m_formul = formul; }
                void setWhenCondition(string *wformul) { m_whenCondition = wformul; }
                void setStatusCondition(string *sformul) { m_statusFormula = sformul; }

                string &getName() { return m_sName; }
                
                string * getFormula() { return m_formul; }
                string * getWhenCondition() { return m_whenCondition; }
                string * getStatusCondition() { return m_statusFormula; }

                REGEXPR_sequence &getRegExp() { return m_regex ; }
                OpcUa::BaseObjectType *getParentCalc() { return m_pParentCalc;  }
                UaMutexRefCounted *getItemSharedMutex() { return m_pSharedMutex; }
        
                void addTempItem(UaCalcItem * uci) { m_vCalcItem.push_back(uci); }
                UaStatus CreateLinks(NmBuildingAutomation *pNodeManager);
                UaStatus findLinkToUaVariable(UaCalcItem *,NmBuildingAutomation *,string& ,OpcUa_Int,pushUaVariable);

                virtual void initCalculation();
                mapDataVariable &getMapDataVariable()
                { 
                        return pVariables;
                }
                bool isVariableMap(string name)
                {
                        return (pVariables.find(name) != pVariables.end());
                }

                private:
                        string m_sName;
                        REGEXPR_sequence m_regex;

                        string m_whenCondition;         //! logical formula if it s true the calculation will be executed
                        string m_formul;                                //! analytic formula to calculate
                        string m_statusFormula;         //! logical formula to calculate the status of variable
        
                        UaMutexRefCounted *m_pSharedMutex;
                        OpcUa::BaseObjectType *m_pParentCalc;
                        vector<UaCalcItem *> m_vCalcItem;       //! the temporary list of items
                        mapDataVariable pVariables; //! temporary set of pointer to variables created 
        };
        */

        /*
        class UaCalcCompiler
        {
        public:
                class isName { //! predicate class to select the pattern
                public:
                        isName(std::string sn): n(sn) {}
                        inline bool operator()(REGEXPR &reg) { return reg.name() == n; }
                private:
                        std::string n;
                };
                
                class existRegName { //! predicate class to select the pattern
                public:
                        existRegName(std::string sn) : n(sn) {}
                        bool operator()(UaCalcCompilerItem *o)
                        {
                                REGEXPR_sequence &regex = o->getRegExp();
                                REGEXPR_sequence::iterator it = find_if(regex.begin(), regex.end(), isName(n));
                                return (it != regex.end());
                        }
                private:
                        std::string n;
                };

                //~UaCalcCompiler()
                //{
                //      for (OpcUa_UInt i = 0; i < m_vCCI.size(); i++) {

                //              delete m_vCCI[i];
                //      }
                //      m_vCCI.clear();

                //}

                //UaCalcCompiler(NmBuildingAutomation *pManager) 
                //{
                //      m_vCCI.clear();
                //      m_pNodeManager = pManager;
                //}

                //UaStatus CompileItems(OpcUa::BaseObjectType *pParent,
                //      ITEM_sequence &itnd,
                //      REGEXPR_sequence &regex);

//              UaStatus CompileItems(  ITEM_sequence &itnd,REGEXPR_sequence &regex);

                //UaStatus CreateItems();

//              void initCalculation();
                
        //      UaStatus addCalcCompilerItem(UaCalcCompilerItem *);

        //private:
        //      UaStatus CompileOneItem(string &name, REGEXPR_sequence &regex,ITEM_iterator &sit);
        //      UaStatus createRegVariable(mapDataVariable&, OpcUa::BaseObjectType *, /*CanOpenOpcServerConfig::*/REGEXPR_sequence &, OpcUa_Int32 &);

        //      vector< UaCalcCompilerItem *> m_vCCI;  //! set of formulas
        //      NmBuildingAutomation *m_pNodeManager;
        //};
        
}
#endif