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/VAssert.h"
#include <functional>
#include <vapor/MyBase.h>
#include <vapor/XmlNode.h>
 
#define PARAMS_IMPL_TAG(class, tag) const std::string class::tag = #tag;
 
namespace VAPoR {
 
//
class PARAMS_API ParamsBase : public Wasp::MyBase {
public:
    //
    class StateSave {
    public:
        virtual void Reinit(const XmlNode *rootNode) {}
        virtual void Save(const XmlNode *node, string description) {}
        virtual void BeginGroup(string description) {}
        virtual void EndGroup() {}
        virtual void IntermediateChange() {}
        virtual void SetEnabled(bool onOff) {}
        virtual bool GetEnabled() const { return (false); }
    };
 
    // NO DEFAULT CONSTRUCTOR
    //
    // ParamsBase();
 
    ParamsBase(StateSave *ssave, const string &classname);
 
    //
    ParamsBase(StateSave *ssave, XmlNode *node);
 
    ParamsBase(const ParamsBase &rhs);
 
    ParamsBase &operator=(const ParamsBase &rhs);
 
    ParamsBase(ParamsBase &&) = delete;
    ParamsBase &operator=(ParamsBase &) = delete;
 
    //
    bool operator==(const ParamsBase &rhs) const { return (_ssave == rhs._ssave && *_node == *(rhs._node)); }
 
    bool operator!=(const ParamsBase &rhs) const { return (!(*this == rhs)); };
 
    virtual ~ParamsBase();
 
    //
    void SetParent(ParamsBase *parent);
 
    XmlNode *GetNode() const { return _node; }
 
    void BeginGroup(const string &description) { _ssave->BeginGroup(description); }
    void EndGroup() { _ssave->EndGroup(); }
    void IntermediateChange() { _ssave->IntermediateChange(); }
 
    virtual vector<long> GetValueLongVec(const string tag) const;
 
    virtual vector<long> GetValueLongVec(const string tag, const vector<long> &defaultVal) const;
 
    virtual long GetValueLong(const string tag, long defaultVal) const;
 
    virtual vector<double> GetValueDoubleVec(const string tag) const;
 
    virtual vector<double> GetValueDoubleVec(const string tag, const vector<double> &defaultVal) const;
 
    virtual double GetValueDouble(const string tag, double defaultVal) const;
 
    virtual vector<string> GetValueStringVec(const string tag) const;
 
    virtual vector<string> GetValueStringVec(const string tag, const vector<string> &defaultVal) const;
 
    virtual string GetValueString(const string tag, string defaultVal) const;
 
    virtual void SetValueLongVec(const string &tag, string description, const vector<long> &values);
 
    virtual void SetValueLong(const string &tag, string description, long value);
 
    virtual void SetValueDoubleVec(const string &tag, string description, const vector<double> &values);
 
    virtual void SetValueDouble(const string &tag, string description, double value);
 
    virtual void SetValueStringVec(const string &tag, string description, const vector<string> &values);
 
    virtual void SetValueString(const string &tag, string description, const string &value);
 
    string GetName() const
    {
        VAssert(_node);
        return (_node->Tag());
    }
 
protected:
    ParamsBase(StateSave *ssave);
 
    //
    void Remove(const string &name);
 
    //
    const map<string, string> &GetAttributes();
 
    //
    void Clear();
 
protected:
    StateSave *_ssave;
    XmlNode *  _node;
};
 
//
// ParamsSeparator Class
//
 
class PARAMS_API ParamsSeparator : public ParamsBase {
public:
    ParamsSeparator(StateSave *ssave, const string &name);
 
    ParamsSeparator(StateSave *ssave, XmlNode *node);
 
    ParamsSeparator(ParamsSeparator *parent, const string &name);
 
    virtual ~ParamsSeparator() {}
 
    bool HasChild(const string &name) { return (GetNode()->HasChild(name)); }
};
 
//
// ParamsFactory Class
//
 
class PARAMS_API ParamsFactory {
public:
    static ParamsFactory *Instance()
    {
        static ParamsFactory instance;
        return &instance;
    }
 
    void RegisterFactoryFunction(string name, function<ParamsBase *(ParamsBase::StateSave *, XmlNode *)> classFactoryFunction)
    {
        // register the class factory function
        m_factoryFunctionRegistry[name] = classFactoryFunction;
    }
 
    ParamsBase *(CreateInstance(string classType, ParamsBase::StateSave *, XmlNode *));
 
    vector<string> GetFactoryNames() const;
 
private:
    map<string, function<ParamsBase *(ParamsBase::StateSave *, XmlNode *)>> m_factoryFunctionRegistry;
 
    ParamsFactory() {}
    ParamsFactory(const ParamsFactory &) {}
    ParamsFactory &operator=(const ParamsFactory &) { return *this; }
};
 
//
// ParamsRegistrar Class
//
// Register ParamsBase derived class with:
//
//  static ParamsRegistrar<ParamsClass> registrar("myclassname");
//
// where 'ParamsClass' is a class derived from 'ParamsBase', and
// "myclassname" is the name of the class
//
 
template<class T> class ParamsRegistrar {
public:
    ParamsRegistrar(string classType)
    {
        // register the class factory function
        //
        ParamsFactory::Instance()->RegisterFactoryFunction(classType, [](ParamsBase::StateSave *ssave, XmlNode *node) -> ParamsBase * {
            if (node)
                return new T(ssave, node);
            else
                return new T(ssave);
        });
    }
};
 
//
// ParamsContainer Class
//
 
//
// The ParamsContainer class constructs an XML tree as depicted below,
// where 'Container Name' is the root of XML tree, and is the name
// passed into the constructor as 'myname'; 'Class Name' is the name of
// the derived ParamsBase class used to construct new instances of
// the derived class; and 'ele name x' is the unique name of the element
// contained in the container.
//
/*
            |----------------|
            | Container Name |
            |----------------|
                    |
                   \|/
            |----------------|
            |   Class Name   |
            |----------------|
                    |         \
                   \|/         \
            |----------------|  \ |----------------|
            |   ele name 1   |....|   ele name n   |
            |----------------|    |----------------|
*/
class PARAMS_API ParamsContainer : public Wasp::MyBase {
public:
    ParamsContainer(ParamsBase::StateSave *ssave, const string &myname);
 
    ParamsContainer(ParamsBase::StateSave *ssave, XmlNode *node);
 
    ParamsContainer(const ParamsContainer &rhs);
 
    ParamsContainer &operator=(const ParamsContainer &rhs);
 
    virtual ~ParamsContainer();
 
    //
    void SetParent(ParamsBase *parent) { GetNode()->SetParent(parent->GetNode()); }
 
    ParamsBase *Insert(ParamsBase *pb, string name);
 
    ParamsBase *Create(string classType, string name);
 
    void Remove(string name);
 
    void Remove(const ParamsBase *pb) { Remove(GetParamsName(pb)); }
 
    ParamsBase *GetParams(string name) const;
 
    string GetParamsName(const ParamsBase *pb) const;
 
    vector<string> GetNames() const;
 
    size_t Size() const { return (_elements.size()); }
 
    XmlNode *GetNode() const { return _separator->GetNode(); }
 
private:
    ParamsBase::StateSave *_ssave;
    // XmlNode *_node;
    ParamsSeparator *         _separator;
    map<string, ParamsBase *> _elements;
};
 
};    // End namespace VAPoR
 
#endif    // ParamsBase_H