HSAdmin Backend Domains, E-Mail, Datenbanken
Purodha
2013-02-20 4a7e12928010374d76e677c8ec3ea4f5e63e9487
commit | author | age
c64ab5 1 /***************************************************************************
CD 2  *   Copyright (C) 2005 by Christof Donat   *
3  *   cdonat@gmx.de   *
4  *                                                                         *
5  *   This program is free software; you can redistribute it and/or modify  *
6  *   it under the terms of the GNU General Public License as published by  *
7  *   the Free Software Foundation; either version 2 of the License, or     *
8  *   (at your option) any later version.                                   *
9  *                                                                         *
10  *   This program is distributed in the hope that it will be useful,       *
11  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
13  *   GNU General Public License for more details.                          *
14  *                                                                         *
15  *   You should have received a copy of the GNU General Public License     *
16  *   along with this program; if not, write to the                         *
17  *   Free Software Foundation, Inc.,                                       *
18  *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
19  ***************************************************************************/
20
21 #include <string>
22 #include <map>
23 #include <vector>
24
25 #ifndef HSADMIN_XMLPARSER
26 #define HSADMIN_XMLPARSER
27
28 /** \brief a general XML Parser
29  * 
30  * well, it works for me. The API is inspired a bit by SAX, but I didn't
31  * whant to create the full SAX API.
32  */
33 namespace xmlParser {
34
35 using std::string;
36 using std::map;
37 using std::vector;
38
39 //! Node Types
40 typedef enum {
41     UNKNOWN                = 0,
42     ELEMENT                = 1,
43     ATTRIBUTE              = 2,
44     TEXT                   = 3,
45     CDATA                  = 4,
46     PROCESSING_INSTRUCTION = 7,
47     COMMENT                = 8,
48     DOCUMENT               = 9,
49
50 } nodeType;
51
52 //! base class for all Nodes
53 class Node {
54     public:
55     Node(nodeType type): m_type(type) {};
56     Node(): m_type(UNKNOWN) {};
57     nodeType m_type;
58 };
59
60 //! Text node
61 class Text: public Node {
62     public:
63     Text(): m_content(""), Node::Node(TEXT) {};
64     //! create a Text node from a C++ String
65     Text(string content): m_content(content), Node::Node(TEXT) {};
66     //! copy-construct a Text node
67     Text(const Text &text): m_content(text.m_content), Node::Node(TEXT) {};
68
69     //! the actual text
70     string m_content;
71 };
72
73 //! Element node
74 class Element: public Node {
75     public:
76     Element():
77             m_nodes(vector<Node*>(0)), 
78             m_attributes(map<string,string>()), 
79             m_name(""), 
80             Node::Node(ELEMENT) {};
81     //! create a Element from its tag-name , a List of Attributes and a List of Child-Nodes
82     Element(string name, map<string,string> attributes, vector<Node*> content):
83             m_nodes(content), 
84             m_attributes(attributes), 
85             m_name(name), 
86             Node::Node(ELEMENT) {};
87     //! copy-construct a Element Node
88     Element(const Element &elm):
89             m_nodes(elm.m_nodes), 
90             m_attributes(elm.m_attributes), 
91             m_name(elm.m_name), 
92             Node::Node(ELEMENT) {};
93
94     //! The tag name
95     string m_name;
96     //! the attributes
97     map<string,string> m_attributes;
98     //! che child nodes
99     vector<Node*> m_nodes;
100 };
101
102 //! the XML parser calls the operator() for everything it finds
103 class responseParserHook {
104     public:
105     enum {
106         ELEMENT                = 1,
107         ATTRIBUTE              = 2,
108         TEXT                   = 3,
109         CDATA                  = 4,
110         PROCESSING_INSTRUCTION = 7,
111         COMMENT                = 8,
112         DOCUMENT               = 9,
113         START_ELEMENT          = 16,
114         END_ELEMENT            = 17,
115         EMPTY_ELEMENT          = 18,
116         ATTRIBUTE_VALUE        = 32,
117     };
118
119     virtual bool operator()(int type, string content) = 0;
120 };
121
122 //! a dummy Parser; the general parser base class
123 class parser {
124     public:
125     bool operator()(const string& content, int &pos, responseParserHook *hook);
126 };
127
128 /** \brief Template to construct a Parser from two parsers.
129  * 
130  * combines the results of the two parsers with 'or'.
131  */
132 template <class first, class second> class orRule : public parser {
133     public:
134     inline bool operator()(const string& content, int &pos, responseParserHook *hook) {
135         int oldpos = pos;
136         if( !car(content,pos,hook) ) return cdr(content,pos,hook);
137         return true;
138     };
139     private:
140     first car;
141     second cdr;
142 };
143
144 //! parse everything that is a space
145 class spaceParser: public parser {
146     public:
147     bool operator()(const string& content, int &pos, responseParserHook *hook);
148 };
149
150 //! parse XML comments
151 class commentParser {
152     public:
153     bool operator()(const string& content, int &pos, responseParserHook *hook);
154 };
155
156 //! parse either spaces or comments
157 typedef orRule<spaceParser, commentParser> comspaceParser;
158
159 //! parse XML names
160 class nameParser: public parser {
161     public:
162     bool operator()(const string& content, int &pos, responseParserHook *hook);
163 };
164
165 //! parse XML attribute values
166 class attributeValueParser: public parser {
167     public:
168     bool operator()(const string& content, int &pos, responseParserHook *hook);
169 };
170
171 //! parse XML attributes with name and value
172 class attributeParser: public parser {
173     public:
174     bool operator()(const string& content, int &pos, responseParserHook *hook);
175
176     private:
177     nameParser name;
178     spaceParser space;
179     attributeValueParser value;
180 };
181
182 //! parse an empty element
183 class emptyelemParser: public parser {
184     public:
185     bool operator()(const string& content, int &pos, responseParserHook *hook);
186     
187     private:
188     nameParser name;
189     attributeParser attrib;
190     spaceParser space;
191 };
192
193 //! parse the start of an element
194 class startelemParser: public parser {
195     public:
196     bool operator()(const string& content, int &pos, responseParserHook *hook);
197     
198     private:
199     nameParser name;
200     attributeParser attrib;
201     spaceParser space;
202 };
203
204 //! parse the end of an element
205 class endelemParser: public parser {
206     public:
207     bool operator()(const string& content, int &pos, responseParserHook *hook);
208     
209     private:
210     nameParser name;
211     spaceParser space;
212 };
213
214 //! parse Text
215 class textParser: public parser {
216     public:
217     bool operator()(const string& content, int &pos, responseParserHook *hook);
218 };
219
220 //! parse CDATA-sections
221 class cdataParser: public parser {
222     public:
223     bool operator()(const string& content, int &pos, responseParserHook *hook);
224 };
225
226 //! parse general Elements
227 class elemParser: public parser {
228     public:
229     bool operator()(const string& content, int &pos, responseParserHook *hook);
230
231     private:
232     emptyelemParser emptyelem;
233     startelemParser elemstart;
234     comspaceParser comspace;
235     endelemParser endelem;
236     textParser text;
237     cdataParser cdata;
238 };
239
240 //! parse the xml Processing instruction at the beginning of each XML-File
241 class xmlpcParser: public parser {
242     public:
243     bool operator()(const string& content, int &pos, responseParserHook *hook);
244     
245     private:
246     nameParser name;
247     attributeParser attrib;
248     spaceParser space;
249 };
250
251 //! parse an XML-File
252 class XMLParser: public parser {
253     public:
254     bool operator()(const string& content, int &pos, responseParserHook *hook);
255     private:
256     spaceParser space;
257     xmlpcParser xmlpc;
258     comspaceParser comspace;
259     elemParser elem;
260 };
261
262 //! just a convenient wraper around the XMLParser
263 class ResponseParser {
264     public:
265     bool operator()(const string& content, responseParserHook *hook);
266     private:
267     XMLParser xml;
268 };
269
270 }
271
272 #else /* HSADMIN_XMLPARSER */
273
274 namespace xmlParser {
275
276 class responseParserHook;
277 class parser;
278 template <class first, class second> class orRule;
279 class spaceParser;
280 class commentParser;
281 class nameParser;
282 class attributeValueParser;
283 class attributeParser;
284 class emptyelemParser;
285 class startelemParser;
286 class endelemParser;
287 class textParser;
288 class cdataParser;
289 class elemParser;
290 class xmlpcParser;
291 class XMLParser;
292 class ResponseParser;
293
294 }
295
296 #endif /* HSADMIN_XMLPARSER */