ParamsBase.h

Go to the documentation of this file.

//************************************************************************
//                                  *
//           Copyright (C)  2008                *
//     University Corporation for Atmospheric Research          *
//           All Rights Reserved                *
//                                  *
//************************************************************************/
//
//  File:       ParamsBase.h
//
//  Author:     John Clyne, modified by Alan Norton
//          National Center for Atmospheric Research
//          PO 3000, Boulder, Colorado
//
//  Date:       March 2008
//
//  Description:    
//      Defines the ParamsBase class
//      This is an abstract class for classes that rely on 
//      accessing an XML node for get/set
//

#ifndef ParamsBase_H
#define ParamsBase_H

#include <vapor/XmlNode.h>
#include <vapor/ParamNode.h>
#include <vapor/ExpatParseMgr.h>
#include "assert.h"
#include <vapor/common.h>


using namespace VetsUtil;
namespace VAPoR{

class Params;


//

class XmlNode;
class ParamNode;
class ParamsBase;
class DataMgrV3_0;

class PARAMS_API ParamsBase : public ParsedXml {
    

typedef ParamsBase* (*BaseCreateFcn)();

public: 
ParamsBase(
    XmlNode *parent, const string &name
 );
typedef int ParamsBaseType;
ParamsBase(const string& name) {
    _currentParamNode = _rootParamNode = 0;
    _parseDepth = 0;
    _paramsBaseName = name;
}
ParamsBase(const ParamsBase &pbase);
virtual ~ParamsBase();

 


 //
 void SetParent(XmlNode *parent);


 //
 virtual bool elementStartHandler(
    ExpatParseMgr* pm, int depth, string& tag, const char ** attribs
 );

 //
 virtual bool elementEndHandler(ExpatParseMgr* pm, int depth, string& tag);


virtual ParamNode* buildNode(); 



ParamNode *GetRootNode() const { return(_rootParamNode); }



const string GetName() const {return _paramsBaseName;}
virtual long GetValueLong(const string& tag, const vector<long>& defaultVal = _emptyLongVec)
    {
        return GetRootNode()->GetElementLong(tag, defaultVal)[0];
    }
virtual double GetValueDouble(const string& tag,const vector<double>& defaultVal = _emptyDoubleVec)
    {return GetRootNode()->GetElementDouble(tag,defaultVal)[0];}
virtual const string GetValueString(const string& tag, const string& defaultVal = _emptyString)
    {return GetRootNode()->GetElementString(tag, defaultVal);}
virtual const vector<long> GetValueLongVec(const string& tag,const vector<long>& defaultVal = _emptyLongVec)
    {return GetRootNode()->GetElementLong(tag, defaultVal);}
virtual const vector<double> GetValueDoubleVec(const string& tag, const vector<double>& defaultVal = _emptyDoubleVec)
    {return GetRootNode()->GetElementDouble(tag, defaultVal);}
virtual void GetValueStringVec(const string& tag, vector<string>& vec, const vector<string>& defaultVal = _emptyStringVec)
    {GetRootNode()->GetElementStringVec(tag, vec, defaultVal);}


    virtual int SetValueLong(string tag, const char* description, long value, Params* p);

    virtual int SetValueLong(string tag, const char* description, const vector<long>& value, Params* p);

    virtual int SetValueDouble(string tag, const char* description, double value, Params* p);

    virtual int SetValueDouble(string tag, const char* description, const vector<double>& value, Params* p);

    virtual int SetValueString(string tag, const char* description, const string& value, Params* p);

    virtual int SetValueStringVec(string tag, const char* description, const vector<string>& value, Params* p);


ParamsBaseType GetParamsBaseTypeId() {return GetTypeFromTag(_paramsBaseName);}

static ParamsBaseType GetTypeFromTag(const string&tag);

static const string GetTagFromType(ParamsBaseType t);

static ParamsBase* CreateDefaultParamsBase(int pType){
    ParamsBase *p = (createDefaultFcnMap[pType])();
    return p;
}
static ParamsBase* CreateDefaultParamsBase(const string&tag);

//Methods for registration and tabulation of existing Params instances


    static int RegisterParamsBaseClass(const string& tag, BaseCreateFcn fcn, bool isParams);
    static int ReregisterParamsBaseClass(const string& tag, const string& newtag, bool isParams);
    virtual void SetRootParamNode(ParamNode* pn){_rootParamNode = pn;}
    static int GetNumParamsClasses() {return _numParamsClasses;}
    static int GetNumBasicParamsClasses() {return _numBasicParamsClasses;}
    static bool IsParamsTag(const string&tag) {return (GetTypeFromTag(tag) > 0);}

    ParamsBase* GetParamsBase(const vector<string>& path) const;

    int SetParamsBase(const vector<string>& path, ParamsBase* pbase);

    int RemoveParamsBase(const vector<string>& path, ParamsBase* pbase);

#ifndef DOXYGEN_SKIP_THIS

    static ParamsBase* CreateDummyParamsBase(std::string tag);
    
    static void addDummyParamsBaseInstance(ParamsBase*const & pb ) {dummyParamsBaseInstances.push_back(pb);}

    static void clearDummyParamsBaseInstances();
    ParamsBase* deepCopy(ParamNode* newRoot = 0);

    static void setDataMgr(DataMgrV3_0* dataMgr){ _dataMgr = dataMgr;}

private:
    static DataMgrV3_0* _dataMgr;
    //These should be accessed by subclasses through get() and set() methods
    ParamNode *_currentParamNode;
    ParamNode *_rootParamNode;
    

protected:
    static DataMgrV3_0* GetDataMgr() {return _dataMgr;}
    static vector<ParamsBase*> dummyParamsBaseInstances;
    static const string _emptyString;
    static const vector<string> _emptyStringVec;
    static const vector<double> _emptyDoubleVec;
    static const vector<long> _emptyLongVec;
    virtual ParamNode *getCurrentParamNode() {return _currentParamNode;}
    
    virtual void setCurrentParamNode(ParamNode* pn){ _currentParamNode=pn;}
    
    
    
    static map<string,int> classIdFromTagMap;
    static map<int,string> tagFromClassIdMap;
    static map<int,BaseCreateFcn> createDefaultFcnMap;

    string _paramsBaseName;
    int _parseDepth;
    static int _numParamsClasses;
    static int _numBasicParamsClasses;
    static int _numEmbedClasses;

#endif //DOXYGEN_SKIP_THIS


 ParamNode *GetCurrentNode() { return(_currentParamNode); }

 //
 ParamNode *Push(
     string& tag,
     ParamsBase* pBase = 0
    );


 //
 ParamNode *Pop();

 //
 void Remove(const string &name);

 //
 const map <string, string> &GetAttributes();


 //
 void Clear();

};

#ifndef DOXYGEN_SKIP_THIS

//The DummyParamsBase is simply holding the parse information for
//A paramsBase extension class that is not present. This can only occur
//as a ParamsBase node inside a DummyParams node
class DummyParamsBase : public ParamsBase {
    public:
        DummyParamsBase(XmlNode *parent, const string &name) :
          ParamsBase(parent, name) {}
        
    virtual ~DummyParamsBase(){}
};
#endif //DOXYGEN_SKIP_THIS
}; //End namespace VAPoR
#endif //ParamsBase_H