src/dom/minidom.h

   1 #include <string>
   2 #include <vector>
   3
   4
   5 namespace MiniDom
   6 {
   7 typedef std::string DOMString;
   8 typedef unsigned int XMLCh;
   9
  10
  11 class Namespace
  12 {
  13 public:
  14     Namespace()
  15         {}
  16
  17     Namespace(const DOMString &prefixArg, const DOMString &namespaceURIArg)
  18         {
  19         prefix       = prefixArg;
  20         namespaceURI = namespaceURIArg;
  21         }
  22
  23     Namespace(const Namespace &other)
  24         {
  25         prefix       = other.prefix;
  26         namespaceURI = other.namespaceURI;
  27         }
  28
  29     virtual ~Namespace()
  30         {}
  31
  32     virtual DOMString getPrefix()
  33         { return prefix; }
  34
  35     virtual DOMString getNamespaceURI()
  36         { return namespaceURI; }
  37
  38 protected:
  39
  40     DOMString prefix;
  41     DOMString namespaceURI;
  42
  43 };
  44
  45 class Attribute
  46 {
  47 public:
  48     Attribute()
  49         {}
  50
  51     Attribute(const DOMString &nameArg, const DOMString &valueArg)
  52         {
  53         name  = nameArg;
  54         value = valueArg;
  55         }
  56
  57     Attribute(const Attribute &other)
  58         {
  59         name  = other.name;
  60         value = other.value;
  61         }
  62
  63     virtual ~Attribute()
  64         {}
  65
  66     virtual DOMString getName()
  67         { return name; }
  68
  69     virtual DOMString getValue()
  70         { return value; }
  71
  72 protected:
  73
  74     DOMString name;
  75     DOMString value;
  76
  77 };
  78
  79
  80 class Element
  81 {
  82 friend class Parser;
  83
  84 public:
  85     Element()
  86         {
  87         parent = NULL;
  88         }
  89
  90     Element(const DOMString &nameArg)
  91         {
  92         parent = NULL;
  93         name   = nameArg;
  94         }
  95
  96     Element(const DOMString &nameArg, const DOMString &valueArg)
  97         {
  98         parent = NULL;
  99         name  = nameArg;
 100         value = valueArg;
 101         }
 102
 103     Element(const Element &other)
 104         {
 105         parent     = other.parent;
 106         children   = other.children;
 107         attributes = other.attributes;
 108         namespaces = other.namespaces;
 109         name       = other.name;
 110         value      = other.value;
 111         }
 112
 113     virtual ~Element()
 114         {
 115         for (unsigned int i=0 ; i<children.size() ; i++)
 116             delete children[i];
 117         }
 118
 119     virtual DOMString getName()
 120         { return name; }
 121
 122     virtual DOMString getValue()
 123         { return value; }
 124
 125     Element *getParent()
 126         { return parent; }
 127
 128     std::vector<Element *> getChildren()
 129         { return children; }
 130
 131     std::vector<Element *> findElements(const DOMString &name);
 132
 133     DOMString getAttribute(const DOMString &name);
 134
 135     void addChild(Element *child);
 136
 137     void addAttribute(const DOMString &name, const DOMString &value);
 138
 139     void addNamespace(const DOMString &prefix, const DOMString &namespaceURI);
 140
 141
 142     /**
 143      * Prettyprint an XML tree to an output stream.  Elements are indented
 144      * according to element hierarchy.
 145      * @param f a stream to receive the output
 146      * @param elem the element to output
 147      */
 148     void writeIndented(FILE *f);
 149
 150     /**
 151      * Prettyprint an XML tree to standard output.  This is the equivalent of
 152      * writeIndented(stdout).
 153      * @param elem the element to output
 154      */
 155     void print();
 156
 157 protected:
 158
 159
 160     void findElementsRecursive(std::vector<Element *>&res, const DOMString &name);
 161
 162     void writeIndentedRecursive(FILE *f, int indent);
 163
 164     Element *parent;
 165
 166     std::vector<Element *>children;
 167
 168     std::vector<Attribute> attributes;
 169     std::vector<Namespace> namespaces;
 170
 171     DOMString name;
 172     DOMString value;
 173
 174 };
 175
 176
 177
 178
 179
 180 class Parser
 181 {
 182 public:
 183     Parser()
 184         { init(); }
 185
 186     virtual ~Parser()
 187         {}
 188
 189     /**
 190      * Parse XML in a char buffer.
 191      * @param buf a character buffer to parse
 192      * @param pos position to start parsing
 193      * @param len number of chars, from pos, to parse.
 194      * @return a pointer to the root of the XML document;
 195      */
 196     Element *parse(const char *buf,int pos,int len);
 197
 198     /**
 199      * Parse XML in a char buffer.
 200      * @param buf a character buffer to parse
 201      * @param pos position to start parsing
 202      * @param len number of chars, from pos, to parse.
 203      * @return a pointer to the root of the XML document;
 204      */
 205     Element *parse(const DOMString &buf);
 206
 207     /**
 208      * Parse a named XML file.  The file is loaded like a data file;
 209      * the original format is not preserved.
 210      * @param fileName the name of the file to read
 211      * @return a pointer to the root of the XML document;
 212      */
 213     Element *parseFile(const char *fileName);
 214
 215
 216
 217
 218 private:
 219
 220     void init()
 221         {
 222         keepGoing       = true;
 223         currentNode     = NULL;
 224         parselen        = 0;
 225         parsebuf        = NULL;
 226         currentPosition = 0;
 227         }
 228
 229     void getLineAndColumn(long pos, long *lineNr, long *colNr);
 230
 231     void error(char *fmt, ...);
 232
 233     int peek(long pos);
 234
 235     int match(long pos, const char *text);
 236
 237     int skipwhite(long p);
 238
 239     int getWord(int p0, DOMString &buf);
 240
 241     int getQuoted(int p0, DOMString &buf, int do_i_parse);
 242
 243     int parseVersion(int p0);
 244
 245     int parseDoctype(int p0);
 246
 247     int parseElement(int p0, Element *par,int depth);
 248
 249     Element *parse(XMLCh *buf,int pos,int len);
 250
 251     bool         keepGoing;
 252     Element      *currentNode;
 253     long         parselen;
 254     XMLCh        *parsebuf;
 255     DOMString    cdatabuf;
 256     long         currentPosition;
 257     int          colNr;
 258
 259
 260 };
 261
 262
 263
 264 }//namespace MiniDom
 265
 266
 267 //########################################################################
 268 //#  E N D    O F    F I L E
 269 //########################################################################
 270