src/dom/minidom.h

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