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 <vapor/MyBase.h>
#ifdef WIN32
#pragma warning(disable : 4251)
#endif

namespace VAPoR {


//
class VDF_API XmlNode : public VetsUtil::MyBase {
public:
    enum ErrCode_T {
        ERR_DEF = 1,    // default error
        ERR_TNP         // Tag not present
    };


 XmlNode(
    const string &tag, const map<string, string> &attrs, 
    size_t numChildrenHint = 0
 );
XmlNode(
    const string &tag, 
    size_t numChildrenHint = 0
 );
 XmlNode() {_objInitialized = false;}
 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); }

 //
 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. 
 //
 // Get methods return a negative result if the named tag does not exist.
 // If the named tag does not exist, 'Get' methods will return a 
 // reference to a vector (or string) of zero length, *and* will
 // register an error with the SetErrMsg() method.
 //

 //
 virtual int SetElementLong(
    const vector<string> &tags, const vector<long> &values
 );
 //
 virtual int SetElementLong(
    const string &tag, const vector<long> &values
 );
 virtual const vector<long> &GetElementLong(const string &tag) const;

 

 virtual int HasElementLong(const string &tag) const;

 //
 virtual int SetElementDouble(
    const string &tag, const vector<double> &values
 );

 //
 virtual int SetElementDouble(
    const vector<string> &tags, const vector<double> &values
 );
 virtual const vector<double> &GetElementDouble(const string &tag) const;
 

 virtual int HasElementDouble(const string &tag) const;

 //
 virtual int SetElementString(const string &tag, const string &values);

 virtual const string &GetElementString(const string &tag) const;

 //
 virtual int SetElementStringVec(
    const string &tag,const vector <string> &values
 );
 //
virtual int SetElementStringVec(
    const vector<string> &tagpath, const vector <string> &values
);
 
 virtual void GetElementStringVec(const string &tag, vector <string> &vec) const;


 virtual int HasElementString(const string &tag) const;

 //

 //
 virtual void AddChild(
    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 int    DeleteChild(size_t index);
 virtual int    DeleteChild(const string &tag);
 //
 virtual void DeleteAll();
 //
 virtual void ClearChildren() {_children.clear();}


 virtual int    ReplaceChild(XmlNode* childNode, XmlNode* newChild);


 //
 virtual XmlNode *GetChild(size_t index) const;

 //
 virtual XmlNode *GetParent() {return(_parent);}

 virtual int HasChild(size_t index);

 //
 virtual XmlNode *GetChild(const string &tag) const;

 //
 virtual bool &ErrOnMissing() {return (_errOnMissing); };

 virtual int HasChild(const string &tag);

 //
 friend ostream& operator<<(ostream &s, const XmlNode& node);

 //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);
    
 //help with strings that xml can't parse:
 // replace all occurrences of 'input' with 'output'
 //output should not occur in input.
    
 static string replaceAll(const string& sourceString, const char* input, const char* output);
 static vector <long> _emptyLongVec;                // empty elements 
 static vector <double> _emptyDoubleVec;
 static vector <string> _emptyStringVec;
 static string _emptyString;
    

protected:
  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
 bool _errOnMissing;
private:
 static string replacement; 
 int    _objInitialized;    // has the obj successfully been initialized?

 
 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
 

 // Recursively delete all chidren of the specified node. The node itself
 // is not deleted.
 //
 void _deleteChildren(XmlNode *node);

};
//ostream& VAPoR::operator<< (ostream& os, const XmlNode& node);
};

#endif  //  _XmlNode_h_