← Back to branch summary

~ubuntu-branches/debian/experimental/kopete/experimental

« back to all changes in this revision

Viewing changes to protocols/jabber/libjingle/talk/xmllite/xmlelement.h

  • Committer: Package Import Robot
  • Author(s): Maximiliano Curia
  • Date: 2015-02-24 11:32:57 UTC
  • mfrom: (1.1.41 vivid)
  • Revision ID: package-import@ubuntu.com-20150224113257-gnupg4v7lzz18ij0
Tags: 4:14.12.2-1
* New upstream release (14.12.2).
* Bump Standards-Version to 3.9.6, no changes needed.

Show diffs side-by-side

added added

removed removed

Lines of Context:
protocols/jabber/libjingle/talk/xmllite/xmlelement.h
 
1
/*
 
2
 * libjingle
 
3
 * Copyright 2004--2005, Google Inc.
 
4
 *
 
5
 * Redistribution and use in source and binary forms, with or without
 
6
 * modification, are permitted provided that the following conditions are met:
 
7
 *
 
8
 *  1. Redistributions of source code must retain the above copyright notice,
 
9
 *     this list of conditions and the following disclaimer.
 
10
 *  2. Redistributions in binary form must reproduce the above copyright notice,
 
11
 *     this list of conditions and the following disclaimer in the documentation
 
12
 *     and/or other materials provided with the distribution.
 
13
 *  3. The name of the author may not be used to endorse or promote products
 
14
 *     derived from this software without specific prior written permission.
 
15
 *
 
16
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
 
17
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 
18
 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
 
19
 * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 
20
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 
21
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
 
22
 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 
23
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
 
24
 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
 
25
 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
26
 */
 
27
 
 
28
#ifndef TALK_XMLLITE_XMLELEMENT_H_
 
29
#define TALK_XMLLITE_XMLELEMENT_H_
 
30
 
 
31
#include <iosfwd>
 
32
#include <string>
 
33
 
 
34
#include "talk/base/scoped_ptr.h"
 
35
#include "talk/xmllite/qname.h"
 
36
 
 
37
namespace buzz {
 
38
 
 
39
class XmlChild;
 
40
class XmlText;
 
41
class XmlElement;
 
42
class XmlAttr;
 
43
 
 
44
class XmlChild {
 
45
 public:
 
46
  XmlChild* NextChild() { return next_child_; }
 
47
  const XmlChild* NextChild() const { return next_child_; }
 
48
 
 
49
  bool IsText() const { return IsTextImpl(); }
 
50
 
 
51
  XmlElement* AsElement() { return AsElementImpl(); }
 
52
  const XmlElement* AsElement() const { return AsElementImpl(); }
 
53
 
 
54
  XmlText* AsText() { return AsTextImpl(); }
 
55
  const XmlText* AsText() const { return AsTextImpl(); }
 
56
 
 
57
 
 
58
 protected:
 
59
  XmlChild() :
 
60
    next_child_(NULL) {
 
61
  }
 
62
 
 
63
  virtual bool IsTextImpl() const = 0;
 
64
  virtual XmlElement* AsElementImpl() const = 0;
 
65
  virtual XmlText* AsTextImpl() const = 0;
 
66
 
 
67
 
 
68
  virtual ~XmlChild();
 
69
 
 
70
 private:
 
71
  friend class XmlElement;
 
72
 
 
73
  XmlChild(const XmlChild& noimpl);
 
74
 
 
75
  XmlChild* next_child_;
 
76
};
 
77
 
 
78
class XmlText : public XmlChild {
 
79
 public:
 
80
  explicit XmlText(const std::string& text) :
 
81
    XmlChild(),
 
82
    text_(text) {
 
83
  }
 
84
  explicit XmlText(const XmlText& t) :
 
85
    XmlChild(),
 
86
    text_(t.text_) {
 
87
  }
 
88
  explicit XmlText(const char* cstr, size_t len) :
 
89
    XmlChild(),
 
90
    text_(cstr, len) {
 
91
  }
 
92
  virtual ~XmlText();
 
93
 
 
94
  const std::string& Text() const { return text_; }
 
95
  void SetText(const std::string& text);
 
96
  void AddParsedText(const char* buf, int len);
 
97
  void AddText(const std::string& text);
 
98
 
 
99
 protected:
 
100
  virtual bool IsTextImpl() const;
 
101
  virtual XmlElement* AsElementImpl() const;
 
102
  virtual XmlText* AsTextImpl() const;
 
103
 
 
104
 private:
 
105
  std::string text_;
 
106
};
 
107
 
 
108
class XmlAttr {
 
109
 public:
 
110
  XmlAttr* NextAttr() const { return next_attr_; }
 
111
  const QName& Name() const { return name_; }
 
112
  const std::string& Value() const { return value_; }
 
113
 
 
114
 private:
 
115
  friend class XmlElement;
 
116
 
 
117
  explicit XmlAttr(const QName& name, const std::string& value) :
 
118
    next_attr_(NULL),
 
119
    name_(name),
 
120
    value_(value) {
 
121
  }
 
122
  explicit XmlAttr(const XmlAttr& att) :
 
123
    next_attr_(NULL),
 
124
    name_(att.name_),
 
125
    value_(att.value_) {
 
126
  }
 
127
 
 
128
  XmlAttr* next_attr_;
 
129
  QName name_;
 
130
  std::string value_;
 
131
};
 
132
 
 
133
class XmlElement : public XmlChild {
 
134
 public:
 
135
  explicit XmlElement(const QName& name);
 
136
  explicit XmlElement(const QName& name, bool useDefaultNs);
 
137
  explicit XmlElement(const XmlElement& elt);
 
138
 
 
139
  virtual ~XmlElement();
 
140
 
 
141
  const QName& Name() const { return name_; }
 
142
  void SetName(const QName& name) { name_ = name; }
 
143
 
 
144
  const std::string BodyText() const;
 
145
  void SetBodyText(const std::string& text);
 
146
 
 
147
  const QName FirstElementName() const;
 
148
 
 
149
  XmlAttr* FirstAttr();
 
150
  const XmlAttr* FirstAttr() const
 
151
    { return const_cast<XmlElement *>(this)->FirstAttr(); }
 
152
 
 
153
  // Attr will return an empty string if the attribute isn't there:
 
154
  // use HasAttr to test presence of an attribute.
 
155
  const std::string Attr(const StaticQName& name) const;
 
156
  const std::string Attr(const QName& name) const;
 
157
  bool HasAttr(const StaticQName& name) const;
 
158
  bool HasAttr(const QName& name) const;
 
159
  void SetAttr(const QName& name, const std::string& value);
 
160
  void ClearAttr(const QName& name);
 
161
 
 
162
  XmlChild* FirstChild();
 
163
  const XmlChild* FirstChild() const {
 
164
    return const_cast<XmlElement *>(this)->FirstChild();
 
165
  }
 
166
 
 
167
  XmlElement* FirstElement();
 
168
  const XmlElement* FirstElement() const {
 
169
    return const_cast<XmlElement *>(this)->FirstElement();
 
170
  }
 
171
 
 
172
  XmlElement* NextElement();
 
173
  const XmlElement* NextElement() const {
 
174
    return const_cast<XmlElement *>(this)->NextElement();
 
175
  }
 
176
 
 
177
  XmlElement* FirstWithNamespace(const std::string& ns);
 
178
  const XmlElement* FirstWithNamespace(const std::string& ns) const {
 
179
    return const_cast<XmlElement *>(this)->FirstWithNamespace(ns);
 
180
  }
 
181
 
 
182
  XmlElement* NextWithNamespace(const std::string& ns);
 
183
  const XmlElement* NextWithNamespace(const std::string& ns) const {
 
184
    return const_cast<XmlElement *>(this)->NextWithNamespace(ns);
 
185
  }
 
186
 
 
187
  XmlElement* FirstNamed(const StaticQName& name);
 
188
  const XmlElement* FirstNamed(const StaticQName& name) const {
 
189
    return const_cast<XmlElement *>(this)->FirstNamed(name);
 
190
  }
 
191
 
 
192
  XmlElement* FirstNamed(const QName& name);
 
193
  const XmlElement* FirstNamed(const QName& name) const {
 
194
    return const_cast<XmlElement *>(this)->FirstNamed(name);
 
195
  }
 
196
 
 
197
  XmlElement* NextNamed(const StaticQName& name);
 
198
  const XmlElement* NextNamed(const StaticQName& name) const {
 
199
    return const_cast<XmlElement *>(this)->NextNamed(name);
 
200
  }
 
201
 
 
202
  XmlElement* NextNamed(const QName& name);
 
203
  const XmlElement* NextNamed(const QName& name) const {
 
204
    return const_cast<XmlElement *>(this)->NextNamed(name);
 
205
  }
 
206
 
 
207
  // Finds the first element named 'name'.  If that element can't be found then
 
208
  // adds one and returns it.
 
209
  XmlElement* FindOrAddNamedChild(const QName& name);
 
210
 
 
211
  const std::string TextNamed(const QName& name) const;
 
212
 
 
213
  void InsertChildAfter(XmlChild* predecessor, XmlChild* new_child);
 
214
  void RemoveChildAfter(XmlChild* predecessor);
 
215
 
 
216
  void AddParsedText(const char* buf, int len);
 
217
  // Note: CDATA is not supported by XMPP, therefore using this function will
 
218
  // generate non-XMPP compatible XML.
 
219
  void AddCDATAText(const char* buf, int len);
 
220
  void AddText(const std::string& text);
 
221
  void AddText(const std::string& text, int depth);
 
222
  void AddElement(XmlElement* child);
 
223
  void AddElement(XmlElement* child, int depth);
 
224
  void AddAttr(const QName& name, const std::string& value);
 
225
  void AddAttr(const QName& name, const std::string& value, int depth);
 
226
  void ClearNamedChildren(const QName& name);
 
227
  void ClearAttributes();
 
228
  void ClearChildren();
 
229
 
 
230
  static XmlElement* ForStr(const std::string& str);
 
231
  std::string Str() const;
 
232
 
 
233
  bool IsCDATA() const { return cdata_; }
 
234
 
 
235
 protected:
 
236
  virtual bool IsTextImpl() const;
 
237
  virtual XmlElement* AsElementImpl() const;
 
238
  virtual XmlText* AsTextImpl() const;
 
239
 
 
240
 private:
 
241
  QName name_;
 
242
  XmlAttr* first_attr_;
 
243
  XmlAttr* last_attr_;
 
244
  XmlChild* first_child_;
 
245
  XmlChild* last_child_;
 
246
  bool cdata_;
 
247
};
 
248
 
 
249
}  // namespace buzz
 
250
 
 
251
#endif  // TALK_XMLLITE_XMLELEMENT_H_