dom_xml.cpp00001
00024 #include "dom/dom_xml.h"
00025 #include "dom/dom_exception.h"
00026 #include "xml/dom_textimpl.h"
00027 #include "xml/dom_xmlimpl.h"
00028
00029 using namespace DOM;
00030
00031 CDATASection::CDATASection()
00032 {
00033 }
00034
00035 CDATASection::CDATASection(const CDATASection &) : Text()
00036 {
00037 }
00038
00039 CDATASection &CDATASection::operator = (const Node &other)
00040 {
00041 NodeImpl* ohandle = other.handle();
00042 if ( impl != ohandle ) {
00043 if (!ohandle || ohandle->nodeType() != CDATA_SECTION_NODE) {
00044 if ( impl ) impl->deref();
00045 impl = 0;
00046 } else {
00047 Node::operator =(other);
00048 }
00049 }
00050 return *this;
00051 }
00052
00053 CDATASection &CDATASection::operator = (const CDATASection &other)
00054 {
00055 Node::operator =(other);
00056 return *this;
00057 }
00058
00059 CDATASection::~CDATASection()
00060 {
00061 }
00062
00063 CDATASection::CDATASection(CDATASectionImpl *i) : Text(i)
00064 {
00065 }
00066
00067
00068 Entity::Entity()
00069 {
00070 }
00071
00072 Entity::Entity(const Entity &) : Node()
00073 {
00074 }
00075
00076 Entity &Entity::operator = (const Node &other)
00077 {
00078 NodeImpl* ohandle = other.handle();
00079 if ( impl != ohandle ) {
00080 if (!ohandle || ohandle->nodeType() != ENTITY_NODE) {
00081 if ( impl ) impl->deref();
00082 impl = 0;
00083 } else {
00084 Node::operator =(other);
00085 }
00086 }
00087 return *this;
00088 }
00089
00090 Entity &Entity::operator = (const Entity &other)
00091 {
00092 Node::operator =(other);
00093 return *this;
00094 }
00095
00096 Entity::~Entity()
00097 {
00098 }
00099
00100 DOMString Entity::publicId() const
00101 {
00102 if (!impl)
00103 return DOMString();
00104
00105 return ((EntityImpl*)impl)->publicId();
00106 }
00107
00108 DOMString Entity::systemId() const
00109 {
00110 if (!impl)
00111 return DOMString();
00112
00113 return ((EntityImpl*)impl)->systemId();
00114 }
00115
00116 DOMString Entity::notationName() const
00117 {
00118 if (!impl)
00119 return DOMString();
00120
00121 return ((EntityImpl*)impl)->notationName();
00122 }
00123
00124 Entity::Entity(EntityImpl *i) : Node(i)
00125 {
00126 }
00127
00128
00129
00130 EntityReference::EntityReference()
00131 {
00132 }
00133
00134 EntityReference::EntityReference(const EntityReference &) : Node()
00135 {
00136 }
00137
00138 EntityReference &EntityReference::operator = (const Node &other)
00139 {
00140 NodeImpl* ohandle = other.handle();
00141 if ( impl != ohandle ) {
00142 if (!ohandle || ohandle->nodeType() != ENTITY_REFERENCE_NODE) {
00143 if ( impl ) impl->deref();
00144 impl = 0;
00145 } else {
00146 Node::operator =(other);
00147 }
00148 }
00149 return *this;
00150 }
00151
00152 EntityReference &EntityReference::operator = (const EntityReference &other)
00153 {
00154 Node::operator =(other);
00155 return *this;
00156 }
00157
00158 EntityReference::~EntityReference()
00159 {
00160 }
00161
00162 EntityReference::EntityReference(EntityReferenceImpl *i) : Node(i)
00163 {
00164 }
00165
00166
00167
00168 Notation::Notation()
00169 {
00170 }
00171
00172 Notation::Notation(const Notation &) : Node()
00173 {
00174 }
00175
00176 Notation &Notation::operator = (const Node &other)
00177 {
00178 NodeImpl* ohandle = other.handle();
00179 if ( impl != ohandle ) {
00180 if (!ohandle || ohandle->nodeType() != NOTATION_NODE) {
00181 if ( impl ) impl->deref();
00182 impl = 0;
00183 } else {
00184 Node::operator =(other);
00185 }
00186 }
00187 return *this;
00188 }
00189
00190 Notation &Notation::operator = (const Notation &other)
00191 {
00192 Node::operator =(other);
00193 return *this;
00194 }
00195
00196 Notation::~Notation()
00197 {
00198 }
00199
00200 DOMString Notation::publicId() const
00201 {
00202 if (!impl)
00203 return DOMString();
00204
00205 return ((NotationImpl*)impl)->publicId();
00206 }
00207
00208 DOMString Notation::systemId() const
00209 {
00210 if (!impl)
00211 return DOMString();
00212
00213 return ((NotationImpl*)impl)->systemId();
00214 }
00215
00216 Notation::Notation(NotationImpl *i) : Node(i)
00217 {
00218 }
00219
00220
00221
00222
00223 ProcessingInstruction::ProcessingInstruction()
00224 {
00225 }
00226
00227 ProcessingInstruction::ProcessingInstruction(const ProcessingInstruction &)
00228 : Node()
00229 {
00230 }
00231
00232 ProcessingInstruction &ProcessingInstruction::operator = (const Node &other)
00233 {
00234 NodeImpl* ohandle = other.handle();
00235 if ( impl != ohandle ) {
00236 if (!ohandle || ohandle->nodeType() != PROCESSING_INSTRUCTION_NODE) {
00237 if ( impl ) impl->deref();
00238 impl = 0;
00239 } else {
00240 Node::operator =(other);
00241 }
00242 }
00243 return *this;
00244 }
00245
00246 ProcessingInstruction &ProcessingInstruction::operator = (const ProcessingInstruction &other)
00247 {
00248 Node::operator =(other);
00249 return *this;
00250 }
00251
00252 ProcessingInstruction::~ProcessingInstruction()
00253 {
00254 }
00255
00256 DOMString ProcessingInstruction::target() const
00257 {
00258 if (!impl)
00259 return DOMString();
00260
00261 return ((ProcessingInstructionImpl*)impl)->target();
00262 }
00263
00264 DOMString ProcessingInstruction::data() const
00265 {
00266 if (!impl)
00267 return DOMString();
00268
00269 return ((ProcessingInstructionImpl*)impl)->data();
00270 }
00271
00272 void ProcessingInstruction::setData( const DOMString &_data )
00273 {
00274 if (!impl)
00275 return;
00276
00277 int exceptioncode = 0;
00278 ((ProcessingInstructionImpl*)impl)->setData(_data, exceptioncode);
00279 if (exceptioncode)
00280 throw DOMException(exceptioncode);
00281 }
00282
00283 ProcessingInstruction::ProcessingInstruction(ProcessingInstructionImpl *i) : Node(i)
00284 {
00285 }
00286
00287 StyleSheet ProcessingInstruction::sheet() const
00288 {
00289 if (impl) return ((ProcessingInstructionImpl*)impl)->sheet();
00290 return 0;
00291 }
00292
00293
|