Prototype.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 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_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 () {};

    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 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);

    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);

    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; 
};

#endif /*_PROTOTYPE_H_*/