Attribute.h

Go to the documentation of this file.

 
/*
 *  JEMRIS Copyright (C) 
 *                        2006-2025  Tony Stoecker
 *                        2007-2018  Kaveh Vahedipour
 *                        2009-2019  Daniel Pflugfelder
 *                                  
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 */
 
 
#ifndef ATTRIBUTE_H_
#define ATTRIBUTE_H_
 
#include "Declarations.h"
 
#include     <stdexcept>
#include     <map>
#include     <vector>
#include     <typeinfo>
#include     <cmath>
 
#include     <iostream>
#include     <iomanip>
 
#include     "StrX.h"
#include     <ginac/ginac.h>
#include     <xercesc/dom/DOM.hpp>
 
using namespace std;
 
XERCES_CPP_NAMESPACE_USE
 
//declaration of the Prototype
class Prototype;
 
typedef double (*FUNCP_4P) (double, double, double, double);
 
class Attribute {
 
 public:
 
    Attribute (const std::string& name, Prototype* proto, const bool& pub, const bool& obs, const    double& val) { Initialize(name,proto,pub,obs,val); };
    Attribute (const std::string& name, Prototype* proto, const bool& pub, const bool& obs, const       int& val) { Initialize(name,proto,pub,obs,val); };
    Attribute (const std::string& name, Prototype* proto, const bool& pub, const bool& obs, const      long& val) { Initialize(name,proto,pub,obs,val); };
    Attribute (const std::string& name, Prototype* proto, const bool& pub, const bool& obs, const  unsigned& val) { Initialize(name,proto,pub,obs,val); };
    Attribute (const std::string& name, Prototype* proto, const bool& pub, const bool& obs, const      bool& val) { Initialize(name,proto,pub,obs,val); };
    Attribute (const std::string& name, Prototype* proto, const bool& pub, const bool& obs, const    std::string& val) { Initialize(name,proto,pub,obs,val); };
    Attribute (const std::string& name, Prototype* proto, const bool& pub, const bool& obs, const PulseAxis& val) { Initialize(name,proto,pub,obs,val); };
 
    Attribute (const std::string& name, Prototype* proto, const bool& pub, const bool& obs) {
        m_public        = true;
        m_observable    = false;
        m_dynamic       = false;
        m_name                  = name;
        m_prototype     = proto;
        m_symbol_name   = "NA";
        m_formula           = "NA";
        m_ginac_excomp  = false;
        m_num_fp                = -1;
        m_cur_fp                = -1;
        m_nlgfp                 = NULL;
        m_diff                  = -1;
        m_sym_diff      = "NA";
        m_complex       = false;
        m_imaginary             = 0.0;
        m_address       = NULL;
        m_datatype      = "";
        m_backup        = NULL;
 
    }
 
    virtual ~Attribute ();
 
    bool IsPublic() const { return m_public;  }
 
    void SetPublic(bool val)    { m_public = val; }
 
    bool IsObservable() const    { return m_observable; }
 
    void SetObservable(bool val)    { m_observable = val; }
 
    bool IsDynamic() const    { return m_dynamic; }
 
    void SetDynamic(bool val)    { m_dynamic = val; }
 
    int GetDiff()    { return m_diff; }
 
    double GetImaginary()    { return m_imaginary; }
 
    bool IsComplex() const    { return m_complex; }
 
    void SetDiff(int val=0, std::string sym="diff")    { m_diff = val; m_sym_diff = sym; }
 
    std::string GetName() const    { return m_name; }
 
    std::string GetTypeID() const   { return m_datatype; }
 
    void* GetAddress() const    { return m_address; }
 
    Prototype*          GetPrototype() const    { return m_prototype; }
 
    std::string GetSymbol() { return m_symbol_name; };
 
    std::string GetFormula() { return m_formula; };
 
    bool SetMember (std::string expr, const std::vector<Attribute*>& obs_attribs, const std::vector<std::string>& obs_attrib_keyword, bool verbose = false);
 
    void EvalExpression ();
 
    std::vector<Attribute*>             GetObservers  (){       return m_observers; };
 
    std::vector<Attribute*>             GetSubjects  (){        return m_subjects; };
 
    double EvalCompiledExpression (double const val, std::string const attrib );
 
    double EvalCompiledNLGExpression (double const x, double const y, double const z, double const g );
 
    bool        HasGinacExCompiler(){return     m_ginac_excomp;};
 
    int         GetNumberFunctionPointers(){return m_num_fp;};
 
    int         GetCurrentFunctionPointer  (){  return m_cur_fp; };
 
    void        ResetCurrentFunctionPointer(){  m_cur_fp=0; };
 
    void        StepCurrentFunctionPointer (){  m_cur_fp = (m_cur_fp+1>m_num_fp)?m_num_fp:m_cur_fp+1; };
 
 
    /* pure template Functions need header implementation! */
 
    template <typename T> bool Notify (const T& val) {
 
        if ( !NewState(val) ) return false;
 
        //initiate re-evaluation and preparation of the observers
        for (unsigned int i=0; i<m_observers.size(); i++) {
 
                //increase the counter for the observer's function pointer
                if (m_observers.at(i)->GetNumberFunctionPointers()>0) {
                        m_observers.at(i)->StepCurrentFunctionPointer(  );
                }
            //cout << "DEBUG " << GetName() << " notified " << m_observers.at(i)->GetName() << endl;
                m_observers.at(i)->EvalExpression();
                m_observers.at(i)->UpdatePrototype();
        }
 
        return true;
    }
    
    template <typename T> bool NewState(const T& val) {
        if ( *((T*) m_backup) == val ) return false;
        *((T*) m_backup) = val;
        return true;
    };
 
    void AttachObserver (Attribute* attrib);
 
    void AttachSubject (Attribute* attrib);
 
 
 private:
 
    void UpdatePrototype ();
 
 
    /* pure template Functions need header implementation */
 
    template <typename T> void WriteMember (const T& val) {
        *((T*) m_address) = val;
        //Notify(val);
    }
 
    template <typename T> T GetMember (){
        T d = *((T*) m_address);
        if (std::isnan(d)) return 0;
        return d;
    }
 
        template <typename T> void Initialize(const std::string& name, Prototype* proto, const bool& pub, const bool& obs, const T& val){
        m_public        = pub;
        m_observable    = obs;
        m_dynamic       = false;
        m_name                  = name;
        m_prototype     = proto;
        m_symbol_name   = "x";
        m_formula           = "";
        m_ginac_excomp  = true;
        m_compiled.push_back(false);
        m_num_fp                = 0;
        m_cur_fp                = 0;
        m_nlgfp                 = NULL;
        m_diff                  = 0;
        m_sym_diff      = "diff";
        m_complex       = false;
        m_imaginary             = 0.0;
        m_address       = ((void*) &val);
        m_datatype      = typeid(T*).name();
        T* p            = new T(val);
        m_backup        = (void*) p;
        }
        
        bool                    m_public;               
        bool                    m_observable;   
        bool                    m_dynamic;              
        std::string     m_name;                 
        void*                   m_address;              
        std::string     m_datatype;             
        void*                   m_backup;               
    Prototype*          m_prototype;    
    std::string         m_symbol_name;  
    std::string         m_sym_diff;             
        std::string     m_formula;              
        GiNaC::ex       m_expression;   
        GiNaC::lst              m_symlist;              
        bool                    m_ginac_excomp; 
        unsigned int    m_num_fp;               
        unsigned int    m_cur_fp;               
        std::vector<bool>       m_compiled;             
        std::vector<GiNaC::FUNCP_1P> m_fp;      
        std::vector<GiNaC::FUNCP_1P> m_fpi;     
        FUNCP_4P                m_nlgfp;                
        int                             m_diff;                 
        bool            m_complex;      
    double          m_imaginary;    
    std::vector<Attribute*> m_subjects;  
    std::vector<Attribute*> m_observers; 
};
 
#endif /* ATTRIBUTE_H_ */