Attribute.h

Go to the documentation of this file.

/*
 *  JEMRIS Copyright (C) 2007-2010  Tony Stöcker, Kaveh Vahedipour
 *                                  Forschungszentrum Jülich, Germany
 *
 *  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     "StrX.h"
#include     <ginac/ginac.h>
#include     <xercesc/dom/DOM.hpp>

XERCES_CPP_NAMESPACE_USE

//declaration of the Prototype
class Prototype;

typedef double (*FUNCP_4P) (double, double, double, double);

class Attribute {

 public:

    Attribute (const string& name, Prototype* proto, const bool& pub, const bool& obs, const    double& val) { Initialize(name,proto,pub,obs,val); };
    Attribute (const string& name, Prototype* proto, const bool& pub, const bool& obs, const       int& val) { Initialize(name,proto,pub,obs,val); };
    Attribute (const string& name, Prototype* proto, const bool& pub, const bool& obs, const      long& val) { Initialize(name,proto,pub,obs,val); };
    Attribute (const string& name, Prototype* proto, const bool& pub, const bool& obs, const  unsigned& val) { Initialize(name,proto,pub,obs,val); };
    Attribute (const string& name, Prototype* proto, const bool& pub, const bool& obs, const      bool& val) { Initialize(name,proto,pub,obs,val); };
    Attribute (const string& name, Prototype* proto, const bool& pub, const bool& obs, const    string& val) { Initialize(name,proto,pub,obs,val); };
    Attribute (const string& name, Prototype* proto, const bool& pub, const bool& obs, const PulseAxis& val) { Initialize(name,proto,pub,obs,val); };

    Attribute (const 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, string sym="diff")    { m_diff = val; m_sym_diff = sym; }

    string GetName() const    { return m_name; }

    string GetTypeID() const   { return m_datatype; }

    void* GetAddress() const    { return m_address; }

    Prototype*          GetPrototype() const    { return m_prototype; }

    string      GetSymbol() { return m_symbol_name; };

    bool SetMember (string expr, const vector<Attribute*>& obs_attribs, bool verbose = false);

    void EvalExpression ();

    double EvalCompiledExpression (double const val, 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(  );
                }

                m_observers.at(i)->EvalExpression();
            UpdatePrototype( m_observers.at(i)->GetPrototype() );
            //cout << "DEBUG " << GetName() << " notified " << m_observers.at(i)->GetName() << endl;
        }

        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 (Prototype* prot);


    /* 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 (isnan(d)) return 0;
        return d;
    };

        template <typename T> void Initialize(const 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;              
        string                  m_name;                 
        void*                   m_address;              
        string                  m_datatype;             
        void*                   m_backup;               
    Prototype*          m_prototype;    
    string                      m_symbol_name;  
    string                      m_sym_diff;             
        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;               
        vector<bool>    m_compiled;             
        vector<GiNaC::FUNCP_1P> m_fp;   
        vector<GiNaC::FUNCP_1P> m_fpi;  
        FUNCP_4P                m_nlgfp;                
        int                             m_diff;                 
        bool            m_complex;      
    double          m_imaginary;    
    vector<Attribute*> m_subjects;  
    vector<Attribute*> m_observers; 
};

#endif /* ATTRIBUTE_H_ */