XmlNode.h

Go to the documentation of this file.

//
//      $Id$
//
 
#ifndef _XmlNode_h_
#define _XmlNode_h_
 
#include <iostream>
#include <map>
#include <vector>
#include <string>
#include <stack>
#include <vapor/MyBase.h>
#ifdef WIN32
    #pragma warning(disable : 4251)
#endif
 
namespace VAPoR {
 
//
class PARAMS_API XmlNode : public Wasp::MyBase {
public:
    XmlNode(const string &tag, const map<string, string> &attrs, size_t numChildrenHint = 0);
    XmlNode(const string &tag, size_t numChildrenHint = 0);
    XmlNode();
 
    virtual XmlNode *Construct(const string &tag, const map<string, string> &attrs, size_t numChildrenHint = 0) { return (new XmlNode(tag, attrs, numChildrenHint)); }
 
    XmlNode(const XmlNode &node);
 
    virtual XmlNode *Clone() { return new XmlNode(*this); };
 
    //
    virtual ~XmlNode();
 
    //
    string &Tag() { return (_tag); }
 
    string GetTag() const { return (_tag); }
 
    void SetTag(string tag) { _tag = tag; }
 
    //
    map<string, string> &Attrs() { return (_attrmap); }
 
    // These methods set or get XML character data, possibly formatting
    // the data in the process. The paramter 'tag' identifies the XML
    // element tag associated with the character data. The
    // parameter, 'values', contains the character data itself. The Long and
    // Double versions of these methods convert a between character streams
    // and vectors of longs or doubles as appropriate.
    //
 
    //
    virtual void SetElementLong(const vector<string> &tags, const vector<long> &values);
    virtual void SetElementLong(const vector<string> &tags, long value)
    {
        vector<long> values(1, value);
        XmlNode::SetElementLong(tags, values);
    }
 
    //
    virtual void SetElementLong(const string &tag, const vector<long> &values);
    virtual void SetElementLong(const string &tag, long value)
    {
        vector<long> values(1, value);
        XmlNode::SetElementLong(tag, values);
    }
 
    virtual const vector<long> &GetElementLong(const string &tag) const;
 
    virtual bool HasElementLong(const string &tag) const;
 
    //
    virtual void SetElementDouble(const string &tag, const vector<double> &values);
    virtual void SetElementDouble(const string &tag, double value)
    {
        vector<double> values(1, value);
        XmlNode::SetElementDouble(tag, values);
    }
 
    //
    virtual void SetElementDouble(const vector<string> &tags, const vector<double> &values);
    virtual void SetElementDouble(const vector<string> &tags, double value)
    {
        vector<double> values(1, value);
        XmlNode::SetElementDouble(tags, values);
    }
 
    virtual const vector<double> &GetElementDouble(const string &tag) const;
 
    virtual bool HasElementDouble(const string &tag) const;
 
    //
    virtual void SetElementString(const string &tag, const string &values);
 
    virtual const string &GetElementString(const string &tag) const;
 
    //
    virtual void SetElementStringVec(const string &tag, const vector<string> &values);
    //
    virtual void SetElementStringVec(const vector<string> &tagpath, const vector<string> &values);
 
    virtual void GetElementStringVec(const string &tag, vector<string> &vec) const;
 
    virtual bool HasElementString(const string &tag) const;
 
    //
 
    //
    XmlNode *AddChild(const XmlNode *child);
    XmlNode *AddChild(const XmlNode &child);
 
    virtual int GetNumChildren() const { return (int)(_children.size()); };
 
    //
    virtual XmlNode *NewChild(const string &tag, const map<string, string> &attrs, size_t numChildrenHint = 0);
 
    virtual XmlNode *NewChild(const string &tag, size_t numChildrenHint = 0)
    {
        map<string, string> attrs;
        return (NewChild(tag, attrs, numChildrenHint));
    }
 
    virtual int DeleteChild(size_t index);
    virtual int DeleteChild(const string &tag);
 
    //
    virtual void DeleteAll();
 
#ifdef VAPOR3_0_0_ALPHA
 
    virtual int ReplaceChild(XmlNode *childNode, XmlNode *newChild);
#endif
 
    //
    virtual XmlNode *GetChild(size_t index) const;
 
    virtual bool HasChild(size_t index) const;
 
    //
    virtual XmlNode *GetChild(const string &tag) const;
 
    virtual bool HasChild(const string &tag) const;
 
    virtual XmlNode *GetNode(std::vector<string> path, bool absolute) const;
 
    //
    virtual XmlNode *GetNode(string path) const;
 
    //
    virtual XmlNode *GetParent() const { return (_parent); }
 
    //
    void SetParent(XmlNode *parent);
 
    //
    friend ostream &operator<<(ostream &s, const XmlNode &node);
 
    //
    XmlNode &operator=(const XmlNode &rhs);
 
    //
    bool operator==(const XmlNode &rhs) const;
    bool operator!=(const XmlNode &rhs) const { return (!(*this == rhs)); };
 
    //
    virtual bool IsRoot() const { return (GetParent() == NULL); }
 
    //
    virtual std::vector<string> GetPathVec() const;
 
    //
    virtual string GetPath() const;
 
    virtual XmlNode *GetRoot() const;
 
    static const std::vector<XmlNode *> &GetAllocatedNodes() { return (_allocatedNodes); }
 
    // Following is a substitute for exporting the "<<" operator in windows.
    // I don't know how to export an operator<< !
    static ostream &streamOut(ostream &os, const XmlNode &node);
 
    static bool IsValidXMLElement(const string &s, int *badIdx=nullptr);
    static string SanitizeXMLTag(string s);
 
private:
    static vector<long>   _emptyLongVec;    // empty elements
    static vector<double> _emptyDoubleVec;
    static vector<string> _emptyStringVec;
    static string         _emptyString;
 
    static std::vector<XmlNode *> _allocatedNodes;
 
    map<string, vector<long>>   _longmap;      // node's long data
    map<string, vector<double>> _doublemap;    // node's double data
    map<string, string>         _stringmap;    // node's string data
    map<string, string>         _attrmap;      // node's attributes
 
    vector<XmlNode *> _children;    // node's children
    string            _tag;         // node's tag name
 
    size_t   _asciiLimit;    // length limit beyond which element data are encoded
    XmlNode *_parent;        // Node's parent
};
// ostream& VAPoR::operator<< (ostream& os, const XmlNode& node);
 
class PARAMS_API XmlParser : public Wasp::MyBase {
public:
    XmlParser();
    ~XmlParser() {}
 
    int LoadFromFile(XmlNode *root, string path);
    int LoadFromFile(XmlNode *root, istream &in);
 
private:
    enum type { UNKNOWN, PARENT, LONG_DATA, DOUBLE_DATA, STRING_DATA };
 
    XmlNode *             _root;
    type                  _nodeType;
    std::stack<XmlNode *> _nodeStack;
    string                _stringData;
 
    void _startElementHandler(string tag, map<string, string> &myattrs);
    void _endElementHandler(string tag);
    void _charDataHandler(string s);
 
    bool _isParentElement(string tag, map<string, string> myattrs) const;
    bool _isDataElement(string tag, map<string, string> myattrs, type &dtype) const;
 
    friend void _StartElementHandler(void *userData, const char *tag, const char **attrs);
 
    friend void _EndElementHandler(void *userData, const char *tag);
 
    friend void _CharDataHandler(void *userData, const char *s, int len);
};
 
};    // namespace VAPoR
 
#endif    //    _XmlNode_h_