Prototype.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 PROTOTYPE_H_
#define PROTOTYPE_H_
 
#include     "StrX.h"
#include     "Attribute.h"
#include     "TPOI.h"
#include     "Debug.h"
#include     "World.h"
 
#include     <stdexcept>
#include     <map>
#include     <vector>
#include     <typeinfo>
#include     <cmath>
#include     <sstream>
#include     <fstream>
 
#include     <ginac/ginac.h>
#include     <xercesc/dom/DOM.hpp>
XERCES_CPP_NAMESPACE_USE
 
 
enum PrepareMode{ PREP_INIT,    PREP_VERBOSE,   PREP_UPDATE };
enum Type       { MOD_PULSE,    MOD_ATOM,       MOD_CONCAT, MOD_CONTAINER, MOD_VOID, COIL};
 
//parameter class declaration
class Parameters;
 
//Macros for attribute creation in Prototype::Prepare()
#define ATTRIBUTE(KEY,VAL)              if (mode!=PREP_UPDATE && m_attributes.find(KEY)==m_attributes.end() ) \
                                                                                m_attributes.insert(pair<string,Attribute*>(KEY,new Attribute(KEY,this, true, true,VAL)));
#define HIDDEN_ATTRIBUTE(KEY,VAL)   if (mode!=PREP_UPDATE && m_attributes.find(KEY)==m_attributes.end() ) \
                                                                                m_attributes.insert(pair<string,Attribute*>(KEY,new Attribute(KEY,this,false, true,VAL)));
#define UNOBSERVABLE_ATTRIBUTE(KEY) if (mode!=PREP_UPDATE && m_attributes.find(KEY)==m_attributes.end() ) \
                                                                                m_attributes.insert(pair<string,Attribute*>(KEY,new Attribute(KEY,this,false,false)));
 
 
using std::ofstream;
using std::string;
using std::map;
 
class Prototype {
 
 public:
 
    Prototype () { m_prepared=false; };
 
    virtual ~Prototype () {
       map<string,Attribute*>::iterator iter;
        for (iter = m_attributes.begin(); iter != m_attributes.end(); iter++ )
                delete iter->second;
 
    };
 
    Prototype (const Prototype&) {};
 
    virtual Prototype* GetParent   () {return NULL;};
 
    virtual Prototype* Clone      () const           = 0;
 
    virtual bool       Prepare    (PrepareMode mode) = 0;
 
    inline bool IsPrepared () {return m_prepared;};
 
 
    virtual void       Initialize (DOMNode* conf)    = 0;
 
    void               SetName    (string name);
 
    inline DOMNode* GetNode () {return m_node;};
 
    void SetNode (DOMNode* node) {m_node=node;};
 
    static bool ReplaceString (string& str, const string& s1, const string& s2);
 
 
    static bool ReplaceSymbolString (string& str, const string& s1, const string& s2);
 
    static vector<string>  Tokenize (const string& str, const string& delimiters = ",");
 
    inline string GetClassType () {return XMLString::transcode(GetNode()->getNodeName());};
 
    inline Type GetType () {return m_type;};
 
 
    string GetDOMattribute    (const string attribute){ return StrX(((DOMElement*) m_node)->getAttribute (StrX(attribute).XMLchar())).std_str() ;  }
 
    bool HasDOMattribute    (const string attribute) {  if (GetDOMattribute(attribute).empty()) return false; else return true;  }
 
 
    Attribute*  GetAttribute(string name);
 
    void        CopyObservers(Attribute* a1, Attribute* a2);
 
    inline bool HasAttribute (string name) {if (GetAttribute(name)==NULL) return false; else return true;};
 
      void  HideAttribute (string attrib, bool observable = true);
 
        inline virtual Prototype* GetPrototypeByAttributeValue (string name, string attrib) {return this;};
 
    inline string GetName () { return m_name; };
 
    bool Observe (Attribute* attrib, string prot_name, string attrib_name, bool verbose);
    bool Observe (Attribute* attrib, string prot_name, string attrib_name, string attrib_keyword, bool verbose);
 
    template <typename T> bool Notify (const T& val) {
 
        map<string,Attribute*>::iterator iter;
        for(iter = m_attributes.begin(); iter != m_attributes.end(); iter++)
            if (iter->second->GetAddress() == ((void*) &val) ) return iter->second->Notify(val);
 
        return false;
    }
 
    template <typename T> bool NewState (const T& val) {
 
        map<string,Attribute*>::iterator iter;
        for(iter = m_attributes.begin(); iter != m_attributes.end(); iter++)
            if (iter->second->GetAddress() == ((void*) &val) ) return iter->second->NewState(val);
 
        return false;
    };
    
    vector<double>*             GetVector()              {return &m_vector;  };
 
 
 protected:
 
    bool                        m_aux;         
    bool                        m_prepared;    
    string                      m_name;        
    DOMNode*                    m_node;        
    Type                        m_type;        
    vector<double>              m_vector;      
    map<string,Attribute*>              m_attributes;  
    vector<Attribute*>                  m_obs_attribs; 
    vector<string>                              m_obs_attrib_keyword; 
};
 
#endif /*_PROTOTYPE_H_*/