ParamNode.h

Go to the documentation of this file.

//
//      $Id$
//

#ifndef _ParamNode_h_
#define _ParamNode_h_

#include <iostream>
#include <map>
#include <vector>
#include <string>
#include <vapor/MyBase.h>
#include <vapor/XmlNode.h>

namespace VAPoR {

class ParamsBase;
//
class PARAMS_API ParamNode : public XmlNode {
public:

 class DirtyFlag {
 public:
    DirtyFlag() {_status = true;}
    bool Test() const {return(_status);}
    void Set() {_status = true;}
    void Clear() {_status = false;}
 private:
    bool _status;
 };


 ParamNode(
    const string &tag, const map<string, string> &attrs, 
    size_t numChildrenHint = 0
 );

  ParamNode(
    const string &tag, 
    size_t numChildrenHint = 0
    );

 virtual ParamNode *Construct(
    const string &tag, const map<string, string> &attrs,
    size_t numChildrenHint = 0
 ) { return(new ParamNode(tag, attrs, numChildrenHint)); }

 ParamNode(const ParamNode &pn);

 ParamNode* NodeCopy();

 ParamNode* ShallowCopy();
 
 virtual ParamNode* deepCopy() ;

 virtual ~ParamNode();

 
 //
 void SetAllFlags(bool dirty);
    
 //
 int SetElementDouble(
    const string &tag, double value
 );
 //
 int SetElementDouble(
    const string &tag, const vector<double> &values
 );
 //
 int SetElementDouble(
    const vector<string> &tagpath, const vector<double> &values
 );

 virtual const vector<double> &GetElementDouble(const vector<string> &tagpath, const vector<double>& defaultVal = XmlNode::_emptyDoubleVec );

 virtual const vector<double> &GetElementDouble(const string &tag, const vector<double>& defaultVal = XmlNode::_emptyDoubleVec); 
 
 int SetElementLong(
    const string &tag, const vector<long> &values
 );
 //
 int SetElementLong(
    const string &tag, long value
 );
 //
 int SetElementLong(
    const vector<string> &tagpath, const vector<long> &values
 );
 virtual const vector<long> &GetElementLong(const vector<string> &tagpath, const vector<long>& defaultVal = XmlNode::_emptyLongVec);
 virtual const vector<long> &GetElementLong(const string &tag, const vector<long>& defaultVal= XmlNode::_emptyLongVec);


 //
 int SetElementString(
    const string &tag, const string &value
 );
 //
 int SetElementString(
    const vector<string> &tagpath, const string &value
 );
 //
 int SetElementStringVec(const string &tag, const vector<string> &values);
 //
 int SetElementStringVec(const string &tag, const vector<string> &values, const string blankSub);
 //
 int SetElementStringVec(const vector<string> &tagpath, const vector<string> &values);
 //
 virtual const string &GetElementString(const string &tag, const string& defaultVal = XmlNode::_emptyString); 
 
 virtual const string &GetElementString(const vector<string> &tagpath, const string& defaultVal = XmlNode::_emptyString );
 
 virtual void GetElementStringVec(const vector<string> &tagpath, vector <string> &vec, const vector<string>& defaultVal = _emptyStringVec) ;
 virtual void GetElementStringVec(const string &tag, vector <string> &vec, const vector<string>& defaultVal = _emptyStringVec);
 virtual void GetElementStringVec(const string &tag, vector <string> &vec, const string blankSub);
 //
 int SetFlagDirty(const vector<string> &tagpath);

 //
 
 int SetFlagDirty(const string &tag);
 //
 int AddNode(const string& tag, ParamNode* child);

 //
 int AddNode(const vector<string>& tagpath, ParamNode* child);

 //
 int AddRegisteredNode(const string& tag, ParamNode* child, ParamsBase* associate);

 //
 int AddRegisteredNode(const vector<string>& tagPath, ParamNode* child, ParamsBase* associate);

 //
 ParamNode *GetChild(size_t index) const {return((ParamNode *) XmlNode::GetChild(index));}

 //
 ParamNode *GetNode(const vector<string> &tagpath);

 //
 ParamNode *GetNode(const string &tag) const {return((ParamNode *) XmlNode::GetChild(tag));}
 //
 int ReplaceNode(const vector<string> &tagpath, ParamNode* newNode);

 //
 int ReplaceNode(const string &tag, ParamNode* newNode);

 //
 int DeleteNode(const string &tag);
        
 //
 int DeleteNode(const vector<string> &tagpath); 
 //
 int RegisterDirtyFlag(const string &tag, ParamNode::DirtyFlag *df);

 //
 int RegisterDirtyFlag(const vector<string> &tagpath, ParamNode::DirtyFlag *df);

 //
 int UnRegisterDirtyFlag(
    const vector<string> &tagpath, const ParamNode::DirtyFlag *df
 );

 //
 int UnRegisterDirtyFlag(
    const string &tag, const ParamNode::DirtyFlag *df
 );

 //
 void SetParamsBase(ParamsBase* pBase) {_paramsBase = pBase;}

 //
ParamsBase* GetParamsBase() {return _paramsBase;}

static const string _paramsBaseAttr;
static const string _paramNodeAttr;

protected:
 map <string, vector <DirtyFlag *> > _dirtyFlags;
 static const string _typeAttr;
 
 
 vector<long> longvec;
 vector<double>doublevec;

 ParamsBase* _paramsBase;
};

};

#endif  //  _ParamNode_h_