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 XmlNode;
class ParamNode;
class ParamsBase;

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

 //
 virtual ParamsBase* deepCopy(ParamNode* newRoot = 0);
 
 //
 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);


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


virtual ParamNode* buildNode(); 


void SetFlagDirty(const string& flag);

const string& GetName() {return _paramsBaseName;}

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 bool IsParamsTag(const string&tag) {return (GetTypeFromTag(tag) > 0);}
#ifndef DOXYGEN_SKIP_THIS
    static ParamsBase* CreateDummyParamsBase(std::string tag);
    
    static void addDummyParamsBaseInstance(ParamsBase*const & pb ) {dummyParamsBaseInstances.push_back(pb);}

    static void clearDummyParamsBaseInstances();
#endif
private:
    //These should be accessed by subclasses through get() and set() methods
    ParamNode *_currentParamNode;
    ParamNode *_rootParamNode;
    

protected:
    static vector<ParamsBase*> dummyParamsBaseInstances;
    static const string _emptyString;
    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 numEmbedClasses;


protected:

 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