src/pedro/pedrodom.h

   1 #ifndef __PEDRODOM_H__
   2 #define __PEDRODOM_H__
   3 /*
   4  * API for the Pedro mini-DOM parser and tree
   5  *
   6  * Authors:
   7  *   Bob Jamison
   8  *
   9  * Copyright (C) 2005-2008 Bob Jamison
  10  *
  11  *  This library is free software; you can redistribute it and/or
  12  *  modify it under the terms of the GNU Lesser General Public
  13  *  License as published by the Free Software Foundation; either
  14  *  version 2.1 of the License, or (at your option) any later version.
  15  *
  16  *  This library is distributed in the hope that it will be useful,
  17  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  19  *  Lesser General Public License for more details.
  20  *
  21  *  You should have received a copy of the GNU Lesser General Public
  22  *  License along with this library; if not, write to the Free Software
  23  *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  24  */
  25
  26 #include <glib.h>
  27
  28 #include <string>
  29 #include <vector>
  30
  31
  32 namespace Pedro
  33 {
  34
  35 typedef std::string DOMString;
  36 typedef unsigned int XMLCh;
  37
  38
  39 class Namespace
  40 {
  41 public:
  42     Namespace()
  43         {}
  44
  45     Namespace(const DOMString &prefixArg, const DOMString &namespaceURIArg)
  46         {
  47         prefix       = prefixArg;
  48         namespaceURI = namespaceURIArg;
  49         }
  50
  51     Namespace(const Namespace &other)
  52         {
  53         assign(other);
  54         }
  55
  56     Namespace &operator=(const Namespace &other)
  57         {
  58         assign(other);
  59         return *this;
  60         }
  61
  62     virtual ~Namespace()
  63         {}
  64
  65     virtual DOMString getPrefix()
  66         { return prefix; }
  67
  68     virtual DOMString getNamespaceURI()
  69         { return namespaceURI; }
  70
  71 protected:
  72
  73     void assign(const Namespace &other)
  74         {
  75         prefix       = other.prefix;
  76         namespaceURI = other.namespaceURI;
  77         }
  78
  79     DOMString prefix;
  80     DOMString namespaceURI;
  81
  82 };
  83
  84 class Attribute
  85 {
  86 public:
  87     Attribute()
  88         {}
  89
  90     Attribute(const DOMString &nameArg, const DOMString &valueArg)
  91         {
  92         name  = nameArg;
  93         value = valueArg;
  94         }
  95
  96     Attribute(const Attribute &other)
  97         {
  98         assign(other);
  99         }
 100
 101     Attribute &operator=(const Attribute &other)
 102         {
 103         assign(other);
 104         return *this;
 105         }
 106
 107     virtual ~Attribute()
 108         {}
 109
 110     virtual DOMString getName()
 111         { return name; }
 112
 113     virtual DOMString getValue()
 114         { return value; }
 115
 116 protected:
 117
 118     void assign(const Attribute &other)
 119         {
 120         name  = other.name;
 121         value = other.value;
 122         }
 123
 124     DOMString name;
 125     DOMString value;
 126
 127 };
 128
 129
 130 //#Define a list of elements. (Children, search results, etc)
 131 class Element;
 132 typedef std::vector<Element *> ElementList;
 133
 134
 135
 136 class Element
 137 {
 138 friend class Parser;
 139
 140 public:
 141     Element()
 142         {
 143         parent = NULL;
 144         }
 145
 146     Element(const DOMString &nameArg)
 147         {
 148         parent = NULL;
 149         name   = nameArg;
 150         }
 151
 152     Element(const DOMString &nameArg, const DOMString &valueArg)
 153         {
 154         parent = NULL;
 155         name   = nameArg;
 156         value  = valueArg;
 157         }
 158
 159     Element(const Element &other)
 160         {
 161         assign(other);
 162         }
 163
 164     Element &operator=(const Element &other)
 165         {
 166         assign(other);
 167         return *this;
 168         }
 169
 170     virtual Element *clone();
 171
 172     virtual ~Element()
 173         {
 174         for (unsigned int i=0 ; i<children.size() ; i++)
 175             delete children[i];
 176         }
 177
 178     virtual DOMString getName()
 179         { return name; }
 180
 181     virtual DOMString getValue()
 182         { return value; }
 183
 184     Element *getParent()
 185         { return parent; }
 186
 187     Element *getFirstChild()
 188         { return (children.size() == 0) ? NULL : children[0]; }
 189
 190     ElementList getChildren()
 191         { return children; }
 192
 193     ElementList findElements(const DOMString &name);
 194
 195     DOMString getAttribute(const DOMString &name);
 196
 197     std::vector<Attribute> &getAttributes()
 198         { return attributes; }
 199
 200     DOMString getTagAttribute(const DOMString &tagName, const DOMString &attrName);
 201
 202     DOMString getTagValue(const DOMString &tagName);
 203
 204     void addChild(Element *child);
 205
 206     void addAttribute(const DOMString &name, const DOMString &value);
 207
 208     void addNamespace(const DOMString &prefix, const DOMString &namespaceURI);
 209
 210     bool exists(const DOMString &name)
 211         { return (findElements(name).size() > 0); }
 212
 213     /**
 214      * Prettyprint an XML tree to an output stream.  Elements are indented
 215      * according to element hierarchy.
 216      * @param f a stream to receive the output
 217      * @param elem the element to output
 218      */
 219     void writeIndented(FILE *f);
 220
 221     /**
 222      * Prettyprint an XML tree to standard output.  This is the equivalent of
 223      * writeIndented(stdout).
 224      * @param elem the element to output
 225      */
 226     void print();
 227
 228 protected:
 229
 230     void assign(const Element &other)
 231         {
 232         parent     = other.parent;
 233         children   = other.children;
 234         attributes = other.attributes;
 235         namespaces = other.namespaces;
 236         name       = other.name;
 237         value      = other.value;
 238         }
 239
 240     void findElementsRecursive(std::vector<Element *>&res, const DOMString &name);
 241
 242     void writeIndentedRecursive(FILE *f, int indent);
 243
 244     Element *parent;
 245
 246     ElementList children;
 247
 248     std::vector<Attribute> attributes;
 249     std::vector<Namespace> namespaces;
 250
 251     DOMString name;
 252     DOMString value;
 253
 254 };
 255
 256
 257
 258
 259
 260 class Parser
 261 {
 262 public:
 263     /**
 264      * Constructor
 265      */
 266     Parser()
 267         { init(); }
 268
 269     virtual ~Parser()
 270         {}
 271
 272     /**
 273      * Parse XML in a char buffer.
 274      * @param buf a character buffer to parse
 275      * @param pos position to start parsing
 276      * @param len number of chars, from pos, to parse.
 277      * @return a pointer to the root of the XML document;
 278      */
 279     Element *parse(const char *buf,int pos,int len);
 280
 281     /**
 282      * Parse XML in a char buffer.
 283      * @param buf a character buffer to parse
 284      * @param pos position to start parsing
 285      * @param len number of chars, from pos, to parse.
 286      * @return a pointer to the root of the XML document;
 287      */
 288     Element *parse(const DOMString &buf);
 289
 290     /**
 291      * Parse a named XML file.  The file is loaded like a data file;
 292      * the original format is not preserved.
 293      * @param fileName the name of the file to read
 294      * @return a pointer to the root of the XML document;
 295      */
 296     Element *parseFile(const DOMString &fileName);
 297
 298     /**
 299      * Utility method to preprocess a string for XML
 300      * output, escaping its entities.
 301      * @param str the string to encode
 302      */
 303     static DOMString encode(const DOMString &str);
 304
 305     /**
 306      *  Removes whitespace from beginning and end of a string
 307      */
 308     DOMString trim(const DOMString &s);
 309
 310 private:
 311
 312     void init()
 313         {
 314         keepGoing       = true;
 315         currentNode     = NULL;
 316         parselen        = 0;
 317         parsebuf        = NULL;
 318         currentPosition = 0;
 319         }
 320
 321     void getLineAndColumn(long pos, long *lineNr, long *colNr);
 322
 323     void error(char *fmt, ...) G_GNUC_PRINTF(2,3);
 324
 325     int peek(long pos);
 326
 327     int match(long pos, const char *text);
 328
 329     int skipwhite(long p);
 330
 331     int getWord(int p0, DOMString &buf);
 332
 333     int getQuoted(int p0, DOMString &buf, int do_i_parse);
 334
 335     int parseVersion(int p0);
 336
 337     int parseDoctype(int p0);
 338
 339     int parseElement(int p0, Element *par,int depth);
 340
 341     Element *parse(XMLCh *buf,int pos,int len);
 342
 343     bool       keepGoing;
 344     Element    *currentNode;
 345     long       parselen;
 346     XMLCh      *parsebuf;
 347     DOMString  cdatabuf;
 348     long       currentPosition;
 349     int        colNr;
 350
 351 };
 352
 353
 354
 355 }//namespace Pedro
 356
 357
 358 #endif /* __PEDRODOM_H__ */
 359
 360 //########################################################################
 361 //#  E N D    O F    F I L E
 362 //########################################################################
 363