Arcane  v3.15.3.0
Documentation utilisateur
Chargement...
Recherche...
Aucune correspondance
DomLibXml2V2.cc
1// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
2//-----------------------------------------------------------------------------
3// Copyright 2000-2025 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
4// See the top-level COPYRIGHT file for details.
5// SPDX-License-Identifier: Apache-2.0
6//-----------------------------------------------------------------------------
7/*---------------------------------------------------------------------------*/
8/* DomLibXml2.cc (C) 2000-2025 */
9/* */
10/* Encapsulation du DOM de libxml2. */
11/*---------------------------------------------------------------------------*/
12/*---------------------------------------------------------------------------*/
13
14#include "arcane/utils/NotImplementedException.h"
15#include "arcane/utils/Array.h"
16#include "arcane/utils/Iostream.h"
17#include "arcane/utils/ScopedPtr.h"
18#include "arcane/utils/StdHeader.h"
19#include "arcane/utils/ITraceMng.h"
20#include "arcane/utils/OStringStream.h"
21#include "arcane/utils/TraceInfo.h"
22#include "arcane/utils/StringBuilder.h"
23#include "arcane/utils/CheckedConvert.h"
24
25#include "arcane/core/Dom.h"
26#include "arcane/core/DomUtils.h"
27#include "arcane/core/ISharedReference.h"
28#include "arcane/core/XmlNode.h"
29#include "arcane/core/IXmlDocumentHolder.h"
30#include "arcane/core/XmlException.h"
31
32#include <libxml/tree.h>
33#include <libxml/parser.h>
34#include <libxml/xmlsave.h>
35#include <libxml/parserInternals.h>
36#include <libxml/xinclude.h>
37#include <libxml/xmlschemas.h>
38
39/*---------------------------------------------------------------------------*/
40/*---------------------------------------------------------------------------*/
41
42namespace Arcane::dom
43{
44
45/*---------------------------------------------------------------------------*/
46/*---------------------------------------------------------------------------*/
47// TODO: POUR NamedNodeMap, il n'y a pas de type correspondant dans libxml2
48// et comme cela peut représenter des types différents il faut faire un
49// type spécifique qui gère cela.
50class LibXml2_DOMImplementation;
51
52struct _wxmlText : _xmlNode {};
53struct _wxmlComment : _xmlNode {};
54struct _wxmlDocType : _xmlNode {};
55struct _wxmlDocumentFragment : _xmlNode {};
56struct _wxmlCDATA : _xmlNode {};
57struct _wxmlNodeList : _xmlNode {};
58struct _wxmlEntityReference : _xmlNode {};
59struct _wxmlCharacterData : _xmlNode {};
60struct _wxmlProcessingInstruction : _xmlNode {};
61struct _wxmlNamedNodeMapPtr : _xmlNode {};
62
70typedef _wxmlCDATA* xmlCDATAPtr;
71typedef _wxmlText* xmlTextPtr;
73
74static xmlNodePtr impl(NodePrv* p) { return (xmlNodePtr)p; }
75static xmlAttrPtr impl(AttrPrv* p) { return (xmlAttrPtr)p; }
76static xmlElementPtr impl(ElementPrv* p) { return (xmlElementPtr)p; }
77static xmlNamedNodeMapPtr impl(NamedNodeMapPrv* p) { return (xmlNamedNodeMapPtr)p; }
78static xmlDocPtr impl(DocumentPrv* p) { return (xmlDocPtr)p; }
79static xmlDocTypePtr impl(DocumentTypePrv* p) { return (xmlDocTypePtr)p; }
80[[maybe_unused]] static LibXml2_DOMImplementation* impl(ImplementationPrv* p) { return (LibXml2_DOMImplementation*)p; }
81static xmlCharacterDataPtr impl(CharacterDataPrv* p) { return (xmlCharacterDataPtr)p; }
82static xmlTextPtr impl(TextPrv* p) { return (xmlTextPtr)p; }
83[[maybe_unused]] static xmlNodeListPtr impl(NodeListPrv* p) { return (xmlNodeListPtr)p; }
84static xmlDocumentFragmentPtr impl(DocumentFragmentPrv* p) { return (xmlDocumentFragmentPtr)p; }
85static xmlCDATAPtr impl(CDATASectionPrv* p) { return (xmlCDATAPtr)p; }
86static xmlProcessingInstructionPtr impl(ProcessingInstructionPrv* p) { return (xmlProcessingInstructionPtr)p; }
87static xmlEntityReferencePtr impl(EntityReferencePrv* p) { return (xmlEntityReferencePtr)p; }
88[[maybe_unused]] static xmlEntityPtr impl(EntityPrv* p) { return (xmlEntityPtr)p; }
89[[maybe_unused]] static xmlNotationPtr impl(NotationPrv* p) { return (xmlNotationPtr)p; }
90//static ::DOMError* impl(DOMErrorPrv* p) { return (::DOMError*)p; }
91//static ::DOMLocator* impl(DOMLocatorPrv* p) { return (::DOMLocator*)p; }
92
93static NodePrv* cvt(xmlNodePtr p) { return (NodePrv*)p; }
94static AttrPrv* cvt(xmlAttrPtr p) { return (AttrPrv*)p; }
95static ElementPrv* cvt(xmlElementPtr p) { return (ElementPrv*)p; }
96static NamedNodeMapPrv* cvt(xmlNamedNodeMapPtr p) { return (NamedNodeMapPrv*)p; }
97static DocumentPrv* cvt(xmlDocPtr p) { return (DocumentPrv*)p; }
98static DocumentTypePrv* cvt(xmlDocTypePtr p) { return (DocumentTypePrv*)p; }
99static ImplementationPrv* cvt(LibXml2_DOMImplementation* p) { return (ImplementationPrv*)p; }
100static CharacterDataPrv* cvt(xmlCharacterDataPtr p) { return (CharacterDataPrv*)p; }
101static TextPrv* cvt(xmlTextPtr p) { return (TextPrv*)p; }
102[[maybe_unused]] static NodeListPrv* cvt(xmlNodeListPtr p) { return (NodeListPrv*)p; }
103[[maybe_unused]] static DocumentFragmentPrv* cvt(xmlDocumentFragmentPtr p) { return (DocumentFragmentPrv*)p; }
104[[maybe_unused]] static CommentPrv* cvt(xmlCommentPtr p) { return (CommentPrv*)p; }
105[[maybe_unused]] static CDATASectionPrv* cvt(xmlCDATAPtr p) { return (CDATASectionPrv*)p; }
106static ProcessingInstructionPrv* cvt(xmlProcessingInstructionPtr p) { return (ProcessingInstructionPrv*)p; }
107[[maybe_unused]] static EntityReferencePrv* cvt(xmlEntityReferencePtr p) { return (EntityReferencePrv*)p; }
108static EntityPrv* cvt(xmlEntityPtr p) { return (EntityPrv*)p; }
109static NotationPrv* cvt(xmlNotationPtr p) { return (NotationPrv*)p; }
110//static DOMLocatorPrv* cvt(::DOMLocator* p) { return (DOMLocatorPrv*)p; }
111
112/*---------------------------------------------------------------------------*/
113/*---------------------------------------------------------------------------*/
114typedef char XMLCh;
115
116const xmlChar*
117domStringToXmlChar(const String& str)
118{
119 const xmlChar* ch = reinterpret_cast<const xmlChar*>(str.utf8().data());
120 return ch;
121}
122
123const xmlChar*
124toChar(const String& value)
125{
126 return domStringToXmlChar(value);
127}
128
129String fromChar(const xmlChar* value)
130{
131 if (!value)
132 return DOMString();
133 Integer len = ::xmlStrlen(value);
134 // Ne pas oublier le '\0' terminal
135 ByteConstArrayView bytes(len+1,value);
136 return DOMString(bytes);
137}
138
139String fromCharAndFree(xmlChar* value)
140{
141 if (!value)
142 return DOMString();
143 String s(fromChar(value));
144 ::xmlFree(value);
145 return s;
146}
147
148/*---------------------------------------------------------------------------*/
149/*---------------------------------------------------------------------------*/
150
151NodePrv* toNodePrv(const Node& node)
152{
153 return node._impl();
154}
155
156/*---------------------------------------------------------------------------*/
157/*---------------------------------------------------------------------------*/
158
159/*---------------------------------------------------------------------------*/
160/*---------------------------------------------------------------------------*/
161
162#define TNIE throw NotImplementedException(A_FUNCINFO)
163
164/*---------------------------------------------------------------------------*/
165/*---------------------------------------------------------------------------*/
166
168{
169 public:
170 static LibXml2_DOMImplementation sDOMImplementation;
171 static LibXml2_DOMImplementation* getImplementation()
172 {
173 return &sDOMImplementation;
174 }
175};
176
177LibXml2_DOMImplementation LibXml2_DOMImplementation::sDOMImplementation;
178
179/*---------------------------------------------------------------------------*/
180/*---------------------------------------------------------------------------*/
181/*!
182 * \brief Gestion des erreurs du lecteur Xml.
183 *
184 * \note le handler d'erreur est géré par libxml2 par thread.
185 * Il n'est donc pas nécessaire de le protéger en multi-threading.
186 */
188{
189 public:
190
192 {
193 ::xmlSetStructuredErrorFunc(this,&LibXml2_ErrorHandler::handler);
194 }
196 {
197 ::xmlSetStructuredErrorFunc(nullptr,nullptr);
198 }
199
200 public:
201 //! Handler à connecter à la libxml2.
202 template <class T>
203 static void XMLCDECL handler(void* user_data,T* e)
204 {
205 if (!e)
206 return;
207 auto x = reinterpret_cast<LibXml2_ErrorHandler*>(user_data);
208 if (!x)
209 return;
210 x->addError(e);
211 }
212 public:
213 const String& errorMessage() const { return m_error_message; }
214 private:
215 String m_error_message;
216 public:
217 void addError(const xmlError* e)
218 {
220 if (e->level==XML_ERR_WARNING)
221 sb += "(warning):";
222 else if (e->level==XML_ERR_ERROR)
223 sb += "(error):";
224 else if (e->level==XML_ERR_FATAL)
225 sb += "(fatal):";
226
227 sb += " domain ";
228 sb += e->domain;
229 sb += " errcode ";
230 sb += e->code;
231
232 if (e->line > 0) {
233 sb += " line ";
234 sb += e->line;
235 if (e->int2 > 0) {
236 sb += " column ";
237 sb += e->int2;
238 }
239 }
240 sb += " : ";
241 if (e->message)
242 sb += e->message;
243 else
244 sb += "(unknown)";
245 m_error_message = m_error_message + sb.toString();
246 }
247};
248
249/*---------------------------------------------------------------------------*/
250/*---------------------------------------------------------------------------*/
251
252class ILibXml2_Reader;
253
254/*---------------------------------------------------------------------------*/
255/*---------------------------------------------------------------------------*/
256/*!
257 * \brief Classe encapsulant l'analyser d'un document XML.
258 */
260{
261 public:
263 : m_file_name(file_name), m_trace(trace), m_options(0)
264 {
265 }
266 public:
267 /*!
268 * \brief Analyse le contenu Xml via le reader \a reader.
269 *
270 * Retourne un document Xml qui doit ensuite être détruit par
271 * appel à l'opérateur delete. Ce document ne peut pas être nul.
272 *
273 * \a reader Lecteur associé.
274 * \a schema_name Nom du fichier contenant le XML Schema à valider. Peut être nul.
275 * \a schema_data Contenu mémoire du XML Schema. Peut être nul.
276 */
279 public:
280 const String& fileName() const { return m_file_name; }
281 int options() const { return m_options; }
282 private:
283 String m_file_name;
284 ITraceMng* m_trace;
285 int m_options;
286 private:
287 void _applySchema(::xmlDocPtr doc,LibXml2_ErrorHandler& err_handler,
289};
290
291/*---------------------------------------------------------------------------*/
292/*---------------------------------------------------------------------------*/
293/*!
294 * \brief Classe encapsulant la validation XML Schema d'un document XML.
295 */
297{
298 public:
300 : m_schema_file_name(schema_file_name),m_schema_parser_context(nullptr),
301 m_schema_ptr(nullptr), m_schema_valid_context(nullptr)
302 {
303 }
305 {
306 _clearMemory();
307 }
308 public:
309 /*!
310 * \brief Valide un document XML.
311 *
312 * Valide le document \a doc. Le nom de fichier du schéma est donné
313 * par le constructeur. Si \a schema_data est non nul on considère qu'il
314 * s'agit du contenu du fichier XML Schema.
315 *
316 * \a doc Document XML.
317 * \a schema_data Contenu mémoire du XML Schema. Peut être nul.
318 */
319 void validate(::xmlDocPtr doc,ByteConstArrayView schema_data);
320 private:
321 String m_schema_file_name;
322 ::xmlSchemaParserCtxtPtr m_schema_parser_context;
323 ::xmlSchemaPtr m_schema_ptr;
324 ::xmlSchemaValidCtxtPtr m_schema_valid_context;
325 private:
326 void _clearMemory()
327 {
328 if (m_schema_parser_context){
329 ::xmlSchemaFreeParserCtxt(m_schema_parser_context);
330 m_schema_parser_context = nullptr;
331 }
332 if (m_schema_ptr){
333 ::xmlSchemaFree(m_schema_ptr);
334 m_schema_ptr = nullptr;
335 }
336 if (m_schema_valid_context){
337 ::xmlSchemaFreeValidCtxt(m_schema_valid_context);
338 m_schema_valid_context = nullptr;
339 }
340 }
341};
342
343/*---------------------------------------------------------------------------*/
344/*---------------------------------------------------------------------------*/
345
347{
348 public:
349 virtual ~ILibXml2_Reader(){}
350 public:
351 virtual ::xmlDocPtr read(LibXml2_Parser& context) =0;
352};
353
354/*---------------------------------------------------------------------------*/
355/*---------------------------------------------------------------------------*/
356
358: public ILibXml2_Reader
359{
360 public:
362 : m_buffer(buffer) {}
363 public:
364 ::xmlDocPtr read(LibXml2_Parser& parser) override
365 {
366 const char* encoding = nullptr;
367 int options = parser.options();
368 const char* buf_base = reinterpret_cast<const char*>(m_buffer.data());
369 // TODO: regarder s'il n'y a pas une version 64 bits de lecture
370 // qui fonctionne aussi sur les anciennes versions de LibXml2
371 // (pour le support RHEL6)
372 int buf_size = CheckedConvert::toInt32(m_buffer.size());
373 while (buf_size > 0 && static_cast<char>(m_buffer[buf_size - 1]) == '\0') {
374 buf_size--;
375 }
376 const String& name = parser.fileName();
377 ::xmlParserCtxtPtr ctxt = ::xmlNewParserCtxt();
378 ::xmlDocPtr doc = ::xmlCtxtReadMemory(ctxt,buf_base,buf_size,
379 name.localstr(),encoding,options);
380 ::xmlFreeParserCtxt(ctxt);
381 return doc;
382 }
383 private:
384 ByteConstSpan m_buffer;
385};
386
387/*---------------------------------------------------------------------------*/
388/*---------------------------------------------------------------------------*/
389
391: public ILibXml2_Reader
392{
393 public:
395 : m_file_name(file_name) {}
396 public:
397 ::xmlDocPtr read(LibXml2_Parser& parser) override
398 {
399 const char* encoding = nullptr;
400 int options = parser.options();
401 const char* file_name = m_file_name.localstr();
402 ::xmlParserCtxtPtr ctxt = ::xmlNewParserCtxt();
403 ::xmlDocPtr doc = ::xmlCtxtReadFile(ctxt,file_name,encoding,options);
404 ::xmlFreeParserCtxt(ctxt);
405 return doc;
406 }
407 private:
408 String m_file_name;
409};
410
411/*---------------------------------------------------------------------------*/
412/*---------------------------------------------------------------------------*/
413
415: public IXmlDocumentHolder
416{
417 public:
419 : m_document(nullptr), m_document_node(nullptr)
420 {}
422 {
423 if (m_document){
424 ::xmlDocPtr doc = impl(m_document);
425 ::xmlFreeDoc(doc);
426 }
427 }
428 XmlNode documentNode() override { return XmlNode(nullptr, m_document_node); }
429 IXmlDocumentHolder* clone() override { TNIE; }
430 void save(ByteArray& bytes) override
431 {
433 domimp._save(bytes,m_document,(-1));
434 }
435 String save() override
436 {
437 //TODO verifier qu'on sauve toujours en UTF8.
438 ByteUniqueArray bytes;
439 save(bytes);
440 String new_s = String::fromUtf8(bytes);
441 return new_s;
442 }
443
444 public:
445
446 void assignDocument(DocumentPrv* doc)
447 {
448 m_document = doc;
449 m_document_node = (NodePrv*)doc;
450 }
451 DocumentPrv* _document() const { return m_document; }
452 private:
453 DocumentPrv* m_document;
454 NodePrv* m_document_node;
455};
456
457/*---------------------------------------------------------------------------*/
458/*---------------------------------------------------------------------------*/
459
460DOMImplementation::
461DOMImplementation()
462: m_p(nullptr)
463{
464 m_p = cvt(LibXml2_DOMImplementation::getImplementation());
465}
466
467DOMImplementation::
468DOMImplementation(ImplementationPrv* prv)
469: m_p(prv)
470{
471}
472
473DOMImplementation::
474~DOMImplementation()
475{
476}
477
478void DOMImplementation::
479_checkValid() const
480{
481 if (!m_p)
483}
484
485ImplementationPrv* DOMImplementation::
486_impl() const
487{
488 return m_p;
489}
490
491bool DOMImplementation::
492hasFeature(const DOMString& feature,const DOMString& version) const
493{
494 ARCANE_UNUSED(feature);
495 ARCANE_UNUSED(version);
496 _checkValid();
497 TNIE;
498 //return impl(m_p)->hasFeature(toChar(feature),toChar(version));
499}
500
501DocumentType DOMImplementation::
502createDocumentType(const DOMString& qualified_name,const DOMString& public_id,
503 const DOMString& system_id) const
504{
505 ARCANE_UNUSED(qualified_name);
506 ARCANE_UNUSED(public_id);
507 ARCANE_UNUSED(system_id);
508 _checkValid();
509 TNIE;
510 //return cvt(impl(m_p)->createDocumentType(toChar(qualified_name),toChar(public_id),
511 // toChar(system_id)));
512}
513
514DOMImplementation DOMImplementation::
515getInterface(const DOMString& feature) const
516{
517 _checkValid();
518 ARCANE_UNUSED(feature);
519 throw NotImplementedException(A_FUNCINFO);
520}
521
522DOMWriter DOMImplementation::
523createDOMWriter() const
524{
525 _checkValid();
526 throw NotImplementedException(A_FUNCINFO);
527}
528
529/*---------------------------------------------------------------------------*/
530/*---------------------------------------------------------------------------*/
531/*!
532 * \todo traiter les arguments...
533 */
534Document DOMImplementation::
535createDocument(const DOMString& namespace_uri,const DOMString& qualified_name,
536 const DocumentType& doctype) const
537{
538 if (!namespace_uri.null())
539 ARCANE_THROW(NotImplementedException,"non nul namespace-uri");
540 if (!qualified_name.null())
541 ARCANE_THROW(NotImplementedException,"non nul qualified-name");
542 if (!doctype._null())
543 ARCANE_THROW(NotImplementedException,"non nul doctype");
544 const xmlChar* xml_version = nullptr;
545 xmlDocPtr doc = ::xmlNewDoc(xml_version);
546 return cvt(doc);
547}
548
549/*---------------------------------------------------------------------------*/
550/*---------------------------------------------------------------------------*/
551
552String DOMImplementation::
553_implementationName() const
554{
555 return "libxml2";
556}
557
558/*---------------------------------------------------------------------------*/
559/*---------------------------------------------------------------------------*/
560
561IXmlDocumentHolder* DOMImplementation::
563{
564 Document _doc = createDocument(DOMString(),DOMString(),DocumentType());
565 auto xml_doc = new XmlDocumentHolderLibXml2();
566 xml_doc->assignDocument(_doc._impl());
567 return xml_doc;
568}
569
570/*---------------------------------------------------------------------------*/
571/*---------------------------------------------------------------------------*/
572
573IXmlDocumentHolder* DOMImplementation::
574_load(const String& fname,ITraceMng* msg,const String& schemaname)
575{
576 return _load(fname,msg,schemaname,ByteConstArrayView());
577}
578
579/*---------------------------------------------------------------------------*/
580/*---------------------------------------------------------------------------*/
581
582IXmlDocumentHolder* DOMImplementation::
583_load(const String& fname,ITraceMng* trace,const String& schema_name,
584 ByteConstArrayView schema_data)
585{
586 _checkValid();
587 LibXml2_FileReader reader(fname);
588 LibXml2_Parser parser(fname,trace);
589 auto doc_holder = parser.parse(&reader,schema_name,schema_data);
590 return doc_holder;
591}
592
593/*---------------------------------------------------------------------------*/
594/*---------------------------------------------------------------------------*/
595
596IXmlDocumentHolder* DOMImplementation::
597_load(ByteConstSpan buffer,const String& name,ITraceMng* trace)
598{
599 _checkValid();
600 if (buffer.empty())
601 return new XmlDocumentHolderLibXml2();
602
603 LibXml2_MemoryReader reader(buffer);
604 LibXml2_Parser parser(name,trace);
605 auto doc_holder = parser.parse(&reader,String(),ByteConstArrayView());
606 return doc_holder;
607}
608
609/*---------------------------------------------------------------------------*/
610/*---------------------------------------------------------------------------*/
611
612void DOMImplementation::
613_save(ByteArray& bytes,const Document& document,int indent_level)
614{
615 ARCANE_UNUSED(indent_level);
616 // NOTE: Les versions récentes de libxml2 (2.9.0) utilisent une nouvelle
617 // API pour les buffers via les méthodes xmlBufContent() (pour récupérer
618 // le contenu) et xmlBufUse() (pour récupérer la taille utilisée).
619 // Ces deux méthodes permettent de gérer des buffers d'une taille supérieure
620 // à 2Go.
621 // Cependant, sous RHEL6, la version par défaut de libxml2 est trop
622 // ancienne et donc il faut supporter les anciennes méthodes.
623 // La macro 'LIBXML2_NEW_BUFFER' est définie si on peut utiliser le
624 // nouveau mécanisme.
625 xmlDocPtr doc = impl(document._impl());
626 xmlBufferPtr buf = ::xmlBufferCreate();
627
628 int options = 0;
629 if (indent_level > 0)
630 options = XML_SAVE_FORMAT;
631 xmlSaveCtxtPtr ctx = ::xmlSaveToBuffer(buf,nullptr,options);
632 (void)::xmlSaveDoc(ctx,doc);
633 (void)::xmlSaveClose(ctx);
634
635 const xmlChar* content = ::xmlBufferContent(buf);
636 size_t content_len = ::xmlBufferLength(buf);
637
638 Integer buf_view_size = arcaneCheckArraySize(content_len);
639 ByteConstArrayView buf_view(buf_view_size,(const Byte*)content);
640 bytes.copy(buf_view);
641 // TODO: protéger le buffer des exceptions possibles de bytes.copy().
642 ::xmlBufferFree(buf);
643}
644
645/*---------------------------------------------------------------------------*/
646/*---------------------------------------------------------------------------*/
647
651{
652 std::unique_ptr<XmlDocumentHolderLibXml2> xml_parser(new XmlDocumentHolderLibXml2());
653
655 m_options |= XML_PARSE_XINCLUDE;
656
657 ::xmlDocPtr doc_ptr = nullptr;
658
659 {
660 // Note: le handler d'erreur est géré par libxml2 par thread.
661 // Il n'est donc pas nécessaire de le protéger en multi-threading.
663
664 doc_ptr = reader->read(*this);
665
666 if (!doc_ptr)
667 ARCANE_THROW(XmlException,"Could not parse document '{0}'\n{1}", fileName(),
668 err_handler.errorMessage());
669
670 // Assigne le document pour garantir sa libération en cas d'exception.
671 xml_parser->assignDocument(cvt(doc_ptr));
672
673 // Effectue le remplacement des XInclude. La méthode ::xmlXIncludeProcess()
674 // retourne le nombre de substitutions ou (-1) en cas d'erreur.
675 int nb_xinclude = ::xmlXIncludeProcess(doc_ptr);
676 if (nb_xinclude==(-1))
677 ARCANE_THROW(XmlException,"Could not parse xinclude for document '{0}'\n{1}", fileName(),
678 err_handler.errorMessage());
679
680 // Même si la lecture est correcte, il est possible qu'il y ait des
681 // messages d'avertissement à afficher.
682 String err_message = err_handler.errorMessage();
683 if (m_trace && !err_message.null())
684 m_trace->info() << "Info parsing document " << fileName() << " : " << err_message;
685 }
686
687 // Décommenter pour débug si on souhaite afficher le document lu.
688 //::xmlDocDump(stdout,doc_ptr);
689
690 {
692 validator.validate(doc_ptr,schema_data);
693 }
694
695 return xml_parser.release();
696}
697
698/*---------------------------------------------------------------------------*/
699/*---------------------------------------------------------------------------*/
700
703{
704 // Il faut positionner schema_name ou schema_data ou les deux.
705 // Si 'schema_data' est positionné, alors on l'utilise et on considère que
706 // 'schema_name' est le nom du fichier correspondant.
707 if (m_schema_file_name.null() && schema_data.empty())
708 return;
709 _clearMemory();
711 if (!schema_data.empty()){
712 auto base_ptr = reinterpret_cast<const char*>(schema_data.data());
713 m_schema_parser_context = ::xmlSchemaNewMemParserCtxt(base_ptr,schema_data.size());
714 }
715 else
716 m_schema_parser_context = ::xmlSchemaNewParserCtxt(m_schema_file_name.localstr());
717 if (!m_schema_parser_context)
718 ARCANE_THROW(XmlException,"Can not create schema parser");
719 m_schema_ptr = xmlSchemaParse(m_schema_parser_context);
720 if (!m_schema_ptr)
721 ARCANE_THROW(XmlException,"Can not read schema file '{0}'\n{1}",m_schema_file_name,
722 err_handler.errorMessage());
723 m_schema_valid_context = xmlSchemaNewValidCtxt(m_schema_ptr);
724 if (!m_schema_valid_context)
725 ARCANE_THROW(XmlException,"Can not create valid context for file '{0}'\n{1}",
726 m_schema_file_name,err_handler.errorMessage());
728 int result = xmlSchemaValidateDoc(m_schema_valid_context, doc_ptr);
729 if (result!=0)
730 ARCANE_THROW(XmlException,"Can not validate file '{0}'\n{1}",
731 m_schema_file_name,err_handler.errorMessage());
732}
733
734/*---------------------------------------------------------------------------*/
735/*---------------------------------------------------------------------------*/
736
737/*---------------------------------------------------------------------------*/
738/*---------------------------------------------------------------------------*/
739
740Node::
741Node()
742: m_p(0)
743{}
744Node::
745Node(NodePrv* p)
746: m_p(p)
747{
748}
749Node::
750Node(const Node& from)
751: m_p(from.m_p)
752{
753}
754const Node& Node::
755operator=(const Node& from)
756{
757 _assign(from);
758 return (*this);
759}
760Node::
761~Node()
762{}
763bool Node::
764_null() const
765{
766 return !m_p;
767}
768void Node::
769_checkValid() const
770{
771 if (_null())
773}
774NodePrv* Node::
775_impl() const
776{
777 return m_p;
778}
779
780UShort Node::
781nodeType() const
782{
783 _checkValid();
784 // Le type retourné par libxml2 (de type xmlElementType) correspond à celui du DOM
785 // avec les mêmes valeurs. Il faut donc simplement caster la valeur.
786 return (UShort)(impl(m_p)->type);
787}
788Node Node::
789firstChild() const
790{
791 _checkValid();
792 ::xmlNodePtr first_children = impl(m_p)->children;
793 return cvt(first_children);
794}
795Node Node::
796lastChild() const
797{
798 _checkValid();
799 TNIE;
800 //return cvt(impl(m_p)->getLastChild());
801}
802Node Node::
803previousSibling() const
804{
805 _checkValid();
806 TNIE;
807 //return cvt(impl(m_p)->getPreviousSibling());
808}
809Node Node::
810nextSibling() const
811{
812 _checkValid();
813 xmlNodePtr next_node = impl(m_p)->next;
814 return cvt(next_node);
815}
816Node Node::
817parentNode() const
818{
819 _checkValid();
820 return cvt(impl(m_p)->parent);
821}
822NodeList Node::
823childNodes() const
824{
825 _checkValid();
826 TNIE;
827 //return cvt(impl(m_p)->getChildNodes());
828}
829DOMString Node::
830nodeName() const
831{
832 _checkValid();
833 //if (impl(m_p)->type==XML_ELEMENT_NODE)
834 //std::cerr << "NODE_NAME =" << impl(m_p)->name << " content=" << impl(m_p)->content << "\n";
835 return fromChar(impl(m_p)->name);
836}
837NamedNodeMap Node::
838attributes() const
839{
840 _checkValid();
841 ::xmlNodePtr xelement = impl(m_p);
842 xmlAttrPtr p = xelement->properties;
843 return cvt((xmlNamedNodeMapPtr)(p));
844}
845Document Node::
846ownerDocument() const
847{
848 _checkValid();
849 ::xmlNodePtr node = impl(m_p);
850 return cvt(node->doc);
851}
852DOMString Node::
853nodeValue() const
854{
855 _checkValid();
856 xmlChar* content = ::xmlNodeGetContent(impl(m_p));
857 return fromCharAndFree(content);
858}
859void Node::
860nodeValue(const DOMString& str) const
861{
862 ARCANE_UNUSED(str);
863 _checkValid();
864 TNIE;
865 //impl(m_p)->setNodeValue(toChar(str));
866}
867void Node::
868_assign(const Node& node)
869{
870 m_p = node.m_p;
871}
872Node Node::
873insertBefore(const Node& new_child,const Node& ref_child) const
874{
875 ARCANE_UNUSED(new_child);
876 ARCANE_UNUSED(ref_child);
877 _checkValid();
878 TNIE;
879 //return cvt(impl(m_p)->insertBefore(impl(new_child._impl()),impl(ref_child._impl())));
880}
881Node Node::
882replaceChild(const Node& new_child,const Node& old_child) const
883{
884 ARCANE_UNUSED(new_child);
885 ARCANE_UNUSED(old_child);
886 _checkValid();
887 TNIE;
888 //return cvt(impl(m_p)->replaceChild(impl(new_child._impl()),impl(old_child._impl())));
889}
890Node Node::
891removeChild(const Node& old_child) const
892{
893 _checkValid();
894 ::xmlNodePtr xchild = impl(old_child._impl());
895 // Attention, il faut ensuite détruire le noeud via Node::releaseNode())
896 // pour libérer la mémoire.
897 ::xmlUnlinkNode(xchild);
898 return cvt(xchild);
899}
900Node Node::
901appendChild(const Node& new_child) const
902{
903 _checkValid();
904 return cvt(::xmlAddChild(impl(m_p),impl(new_child._impl())));
905}
906bool Node::
907hasChildNodes() const
908{
909 _checkValid();
910 TNIE;
911 //return impl(m_p)->hasChildNodes();
912}
913Node Node::
914cloneNode(bool deep) const
915{
916 _checkValid();
917 ARCANE_UNUSED(deep);
918 TNIE;
919 //return cvt(impl(m_p)->cloneNode(deep));
920}
921DOMString Node::
922prefix() const
923{
924 _checkValid();
925 TNIE;
926 //return fromChar(impl(m_p)->getPrefix());
927}
928void Node::
929prefix(const DOMString& new_prefix) const
930{
931 _checkValid();
932 ARCANE_UNUSED(new_prefix);
933 TNIE;
934 //impl(m_p)->setPrefix(toChar(new_prefix));
935}
936void Node::
937normalize() const
938{
939 _checkValid();
940 TNIE;
941 //impl(m_p)->normalize();
942}
943bool Node::
944isSupported(const DOMString& feature,const DOMString& version) const
945{
946 ARCANE_UNUSED(feature);
947 ARCANE_UNUSED(version);
948 _checkValid();
949 TNIE;
950 //return impl(m_p)->isSupported(toChar(feature),toChar(version));
951}
952DOMString Node::
953namespaceURI() const
954{
955 _checkValid();
956 TNIE;
957 //return fromChar(impl(m_p)->getNamespaceURI());
958}
959DOMString Node::
960localName() const
961{
962 _checkValid();
963 return fromChar(impl(m_p)->name);
964}
965DOMString Node::
966baseURI() const
967{
968 _checkValid();
969 TNIE;
970 //return fromChar(impl(m_p)->getBaseURI());
971}
972DOMString Node::
973textContent() const
974{
975 _checkValid();
976 TNIE;
977 //return fromChar(impl(m_p)->getTextContent());
978}
979void Node::
980textContent(const DOMString& value) const
981{
982 _checkValid();
983 ARCANE_UNUSED(value);
984 TNIE;
985 //impl(m_p)->setTextContent(toChar(value));
986}
987bool Node::
988isSameNode(const Node& node) const
989{
990 _checkValid();
991 ARCANE_UNUSED(node);
992 TNIE;
993 //return impl(m_p)->isSameNode(impl(node.m_p));
994}
995bool Node::
996isEqualNode(const Node& other) const
997{
998 _checkValid();
999 ARCANE_UNUSED(other);
1000 TNIE;
1001 //return impl(m_p)->isEqualNode(impl(other._impl()));
1002}
1003bool Node::
1004isDefaultNamespace(const DOMString& namespace_uri) const
1005{
1006 _checkValid();
1007 ARCANE_UNUSED(namespace_uri);
1008 TNIE;
1009 //return impl(m_p)->isDefaultNamespace(toChar(namespace_uri));
1010}
1011DOMString Node::
1012lookupNamespaceURI(const DOMString& prefix) const
1013{
1014 _checkValid();
1015 ARCANE_UNUSED(prefix);
1016 TNIE;
1017 //return fromChar(impl(m_p)->lookupNamespaceURI(toChar(prefix)));
1018}
1019DOMObject Node::
1020setUserData(const DOMString& key,const DOMObject& data,
1021 const UserDataHandler& handler) const
1022{
1023 _checkValid();
1024 ARCANE_UNUSED(key);
1025 ARCANE_UNUSED(data);
1026 ARCANE_UNUSED(handler);
1027 throw NotImplementedException(A_FUNCINFO);
1028}
1029DOMObject Node::
1030getUserData(const DOMString& key) const
1031{
1032 _checkValid();
1033 ARCANE_UNUSED(key);
1034 TNIE;
1035 //return impl(m_p)->getUserData(toChar(key));
1036}
1039{
1040 ::xmlNodePtr xnode = impl(m_p);
1041 if (xnode)
1042 ::xmlFreeNode(xnode);
1043}
1044bool
1045operator==(const Node& n1,const Node& n2)
1046{
1047 return impl(n1.m_p) == impl(n2.m_p);
1048}
1049bool
1050operator!=(const Node& n1,const Node& n2)
1051{
1052 return ! operator==(n1,n2);
1053}
1054
1055/*---------------------------------------------------------------------------*/
1056/*---------------------------------------------------------------------------*/
1057
1058CharacterData::
1059CharacterData(CharacterDataPrv* v)
1060: Node(cvt((xmlNodePtr)impl(v)))
1061{}
1062
1063CharacterData::
1064CharacterData()
1065: Node()
1066{}
1067
1068CharacterData::
1069CharacterData(const CharacterData& node)
1070: Node(node)
1071{
1072}
1073
1074CharacterData::
1075CharacterData(const Node& node)
1076: Node()
1077{
1078 TNIE;
1079 ARCANE_UNUSED(node);
1080 //NodePrv* ni= node._impl();
1081 //if (ni && impl(ni)->getNodeType()==CDATA_SECTION_NODE)
1082 //_assign(node);
1083}
1084
1085CharacterDataPrv* CharacterData::
1086_impl() const
1087{
1088 TNIE;
1089 //return cvt((xmlCharacterDataPtr)impl(m_p));
1090}
1091
1092/*---------------------------------------------------------------------------*/
1093/*---------------------------------------------------------------------------*/
1094
1095Text::
1096Text(TextPrv* v)
1097: CharacterData(cvt((xmlCharacterDataPtr)impl(v)))
1098{}
1099Text::
1100Text()
1101: CharacterData()
1102{}
1103Text::
1104Text(const Text& node)
1105: CharacterData(node)
1106{
1107}
1108Text::
1109Text(const Node& node)
1110: CharacterData()
1111{
1112 TNIE;
1113 ARCANE_UNUSED(node);
1114 //NodePrv* ni= node._impl();
1115 //if (ni && impl(ni)->getNodeType()==TEXT_NODE)
1116 //_assign(node);
1117}
1118TextPrv* Text::
1119_impl() const
1120{
1121 return cvt((xmlTextPtr)impl(m_p));
1122}
1123
1124/*---------------------------------------------------------------------------*/
1125/*---------------------------------------------------------------------------*/
1126
1127/*---------------------------------------------------------------------------*/
1128/*---------------------------------------------------------------------------*/
1129
1130/*---------------------------------------------------------------------------*/
1131/*---------------------------------------------------------------------------*/
1132
1133/*---------------------------------------------------------------------------*/
1134/*---------------------------------------------------------------------------*/
1135
1136Document::
1137Document()
1138{}
1139Document::
1140Document(DocumentPrv* p)
1141: Node(cvt((xmlNodePtr)impl(p)))
1142{}
1143Document::
1144Document(const Node& node)
1145: Node()
1146{
1147 NodePrv* ni= node._impl();
1148 if (ni && impl(ni)->type==XML_DOCUMENT_NODE)
1149 _assign(node);
1150}
1151DocumentPrv* Document::
1152_impl() const
1153{
1154 return cvt((xmlDocPtr)impl(m_p));
1155}
1156DocumentType Document::
1157doctype() const
1158{
1159 _checkValid();
1160 TNIE;
1161 //return cvt(impl(_impl())->getDoctype());
1162}
1163DOMImplementation Document::
1164implementation() const
1165{
1166 _checkValid();
1167 TNIE;
1168 //return cvt(impl(_impl())->getImplementation());
1169}
1170Element Document::
1171documentElement() const
1172{
1173 _checkValid();
1174 xmlDocPtr xdoc = impl(_impl());
1175 xmlNodePtr xnode = ::xmlDocGetRootElement(xdoc);
1176 return cvt((xmlElementPtr)xnode);
1177}
1178Element Document::
1179createElement(const DOMString& name) const
1180{
1181 _checkValid();
1182 xmlDocPtr xdoc = impl(_impl());
1183 xmlNsPtr nspace = nullptr;
1184 xmlChar* content = nullptr;
1185 xmlNodePtr xnode = ::xmlNewDocNode(xdoc,nspace,toChar(name),content);
1186 return cvt((xmlElementPtr)xnode);
1187}
1188DocumentFragment Document::
1189createDocumentFragment() const
1190{
1191 _checkValid();
1192 TNIE;
1193 //return cvt(impl(_impl())->createDocumentFragment());
1194}
1195Text Document::
1196createTextNode(const DOMString& data) const
1197{
1198 _checkValid();
1199 xmlDocPtr xdoc = impl(_impl());
1200 return cvt((xmlTextPtr)::xmlNewDocText(xdoc,toChar(data)));
1201}
1202Comment Document::
1203createComment(const DOMString& data) const
1204{
1205 _checkValid();
1206 TNIE;
1207 ARCANE_UNUSED(data);
1208 //return cvt(impl(_impl())->createComment(toChar(data)));
1209}
1210CDATASection Document::
1211createCDATASection(const DOMString& data) const
1212{
1213 _checkValid();
1214 TNIE;
1215 ARCANE_UNUSED(data);
1216 //return cvt(impl(_impl())->createCDATASection(toChar(data)));
1217}
1218ProcessingInstruction Document::
1219createProcessingInstruction(const DOMString& target,
1220 const DOMString& data) const
1221{
1222 _checkValid();
1223 ARCANE_UNUSED(target);
1224 ARCANE_UNUSED(data);
1225 TNIE;
1226 // return cvt(impl(_impl())->createProcessingInstruction(toChar(target),toChar(data)));
1227}
1228
1229Attr Document::
1230createAttribute(const DOMString& name) const
1231{
1232 _checkValid();
1233 ARCANE_UNUSED(name);
1234 TNIE;
1235 //return cvt(impl(_impl())->createAttribute(toChar(name)));
1236}
1237
1238EntityReference Document::
1239createEntityReference(const DOMString& name) const
1240{
1241 _checkValid();
1242 ARCANE_UNUSED(name);
1243 TNIE;
1244 //return cvt(impl(_impl())->createEntityReference(toChar(name)));
1245}
1246NodeList Document::
1247getElementsByTagName(const DOMString& tagname) const
1248{
1249 _checkValid();
1250 ARCANE_UNUSED(tagname);
1251 TNIE;
1252 //return cvt(impl(_impl())->getElementsByTagName(toChar(tagname)));
1253}
1254Node Document::
1255importNode(const Node& imported_node,bool deep) const
1256{
1257 _checkValid();
1258 ARCANE_UNUSED(imported_node);
1259 ARCANE_UNUSED(deep);
1260 TNIE;
1261 //return cvt(impl(_impl())->importNode(impl(toNodePrv(imported_node)),deep));
1262}
1263Element Document::
1264createElementNS(const DOMString& namespace_uri,const DOMString& qualified_name) const
1265{
1266 _checkValid();
1267 ARCANE_UNUSED(namespace_uri);
1268 ARCANE_UNUSED(qualified_name);
1269 TNIE;
1270 //return cvt(impl(_impl())->createElementNS(toChar(namespace_uri),toChar(qualified_name)));
1271}
1272Attr Document::
1273createAttributeNS(const DOMString& namespace_uri,const DOMString& qualified_name) const
1274{
1275 _checkValid();
1276 ARCANE_UNUSED(namespace_uri);
1277 ARCANE_UNUSED(qualified_name);
1278 TNIE;
1279 //return cvt(impl(_impl())->createAttributeNS(toChar(namespace_uri),toChar(qualified_name)));
1280}
1281NodeList Document::
1282getElementsByTagNameNS(const DOMString& namespace_uri,const DOMString& local_name) const
1283{
1284 _checkValid();
1285 ARCANE_UNUSED(namespace_uri);
1286 ARCANE_UNUSED(local_name);
1287 TNIE;
1288 //return cvt(impl(_impl())->getElementsByTagNameNS(toChar(namespace_uri),toChar(local_name)));
1289}
1290Element Document::
1291getElementById(const DOMString& element_id) const
1292{
1293 _checkValid();
1294 TNIE;
1295 ARCANE_UNUSED(element_id);
1296 //return cvt(impl(_impl())->getElementById(toChar(element_id)));
1297}
1298DOMString Document::
1299actualEncoding() const
1300{
1301 _checkValid();
1302 TNIE;
1303 //throw NotImplementedException(A_FUNCINFO);
1304}
1305void Document::
1306actualEncoding(const DOMString& value) const
1307{
1308 _checkValid();
1309 ARCANE_UNUSED(value);
1310 throw NotImplementedException(A_FUNCINFO);
1311}
1312
1313DOMString Document::
1314encoding() const
1315{
1316 _checkValid();
1317 throw NotImplementedException(A_FUNCINFO);
1318}
1319
1320void Document::
1321encoding(const DOMString& value) const
1322{
1323 _checkValid();
1324 ARCANE_UNUSED(value);
1325 throw NotImplementedException(A_FUNCINFO);
1326}
1327
1328bool Document::
1329standalone() const
1330{
1331 _checkValid();
1332 throw NotImplementedException(A_FUNCINFO);
1333}
1334
1335void Document::
1336standalone(bool value) const
1337{
1338 _checkValid();
1339 ARCANE_UNUSED(value);
1340 throw NotImplementedException(A_FUNCINFO);
1341}
1342
1343bool Document::
1344strictErrorChecking() const
1345{
1346 _checkValid();
1347 TNIE;
1348 //return impl(_impl())->getStrictErrorChecking();
1349}
1350void Document::
1351strictErrorChecking(bool value) const
1352{
1353 _checkValid();
1354 ARCANE_UNUSED(value);
1355 TNIE;
1356 //impl(_impl())->setStrictErrorChecking(value);
1357}
1358void Document::
1359documentURI(const DOMString& document_uri) const
1360{
1361 _checkValid();
1362 ARCANE_UNUSED(document_uri);
1363 TNIE;
1364 //impl(_impl())->setDocumentURI(toChar(document_uri));
1365}
1366DOMString Document::
1367documentURI() const
1368{
1369 _checkValid();
1370 TNIE;
1371 //return fromChar(impl(_impl())->getDocumentURI());
1372}
1373
1374Node Document::
1375adoptNode(const Node& source) const
1376{
1377 _checkValid();
1378 TNIE;
1379 ARCANE_UNUSED(source);
1380 //return Node(cvt(impl(_impl())->adoptNode(impl(source._impl()))));
1381}
1382void Document::
1383normalizeDocument()
1384{
1385 _checkValid();
1386 TNIE;
1387 //impl(_impl())->normalizeDocument();
1388}
1389Node Document::
1390renameNode(const Node& node,const DOMString& namespace_uri,
1391 const DOMString& name)
1392{
1393 _checkValid();
1394 node._checkValid();
1395 ARCANE_UNUSED(node);
1396 ARCANE_UNUSED(namespace_uri);
1397 ARCANE_UNUSED(name);
1398 TNIE;
1399 //return Node(cvt(impl(_impl())->renameNode(impl(node._impl()),toChar(namespace_uri),toChar(name))));
1400}
1401
1402/*---------------------------------------------------------------------------*/
1403/*---------------------------------------------------------------------------*/
1404
1405DocumentFragment::
1406DocumentFragment()
1407: Node()
1408{}
1409DocumentFragment::
1410DocumentFragment(DocumentFragmentPrv* prv)
1411: Node(cvt((xmlNodePtr)impl(prv)))
1412{}
1413
1414/*---------------------------------------------------------------------------*/
1415/*---------------------------------------------------------------------------*/
1416
1417Comment::
1418Comment()
1419: CharacterData()
1420{}
1421Comment::
1422Comment(CommentPrv* prv)
1423: CharacterData((CharacterDataPrv*)prv)
1424{}
1425
1426/*---------------------------------------------------------------------------*/
1427/*---------------------------------------------------------------------------*/
1428
1429CDATASection::
1430CDATASection()
1431: Text()
1432{}
1433CDATASection::
1434CDATASection(CDATASectionPrv* prv)
1435: Text(cvt((xmlTextPtr)impl(prv)))
1436{}
1437
1438/*---------------------------------------------------------------------------*/
1439/*---------------------------------------------------------------------------*/
1440
1441EntityReference::
1442EntityReference()
1443: Node()
1444{}
1445EntityReference::
1446EntityReference(EntityReferencePrv* prv)
1447: Node(cvt((xmlNodePtr)impl(prv)))
1448{}
1449
1450/*---------------------------------------------------------------------------*/
1451/*---------------------------------------------------------------------------*/
1452
1453NodeList::
1454NodeList()
1455: m_p(0)
1456{}
1457NodeList::
1458NodeList(NodeListPrv* prv)
1459: m_p(prv)
1460{}
1461
1462void NodeList::
1463_checkValid() const
1464{
1465 if (!m_p)
1467}
1468Node NodeList::
1469item(ULong index) const
1470{
1471 _checkValid();
1472 ARCANE_UNUSED(index);
1473 TNIE;
1474 //return cvt(impl(m_p)->item(index));
1475}
1476ULong NodeList::
1477length() const
1478{
1479 _checkValid();
1480 TNIE;
1481 //return impl(m_p)->getLength();
1482}
1483
1484/*---------------------------------------------------------------------------*/
1485/*---------------------------------------------------------------------------*/
1486
1487DOMString CharacterData::
1488data() const
1489{
1490 _checkValid();
1491 TNIE;
1492 //return fromChar(impl(_impl())->getData());
1493}
1494void CharacterData::
1495data(const DOMString& value) const
1496{
1497 _checkValid();
1498 ARCANE_UNUSED(value);
1499 TNIE;
1500 //impl(_impl())->setData(toChar(value));
1501}
1502ULong CharacterData::
1503length() const
1504{
1505 _checkValid();
1506 TNIE;
1507 //return impl(_impl())->getLength();
1508}
1509DOMString CharacterData::
1510substringData(ULong offset,ULong count) const
1511{
1512 _checkValid();
1513 ARCANE_UNUSED(offset);
1514 ARCANE_UNUSED(count);
1515 TNIE;
1516 //return fromChar(impl(_impl())->substringData(offset,count));
1517}
1518void CharacterData::
1519appendData(const DOMString& arg) const
1520{
1521 _checkValid();
1522 ARCANE_UNUSED(arg);
1523 TNIE;
1524 //impl(_impl())->appendData(toChar(arg));
1525}
1526void CharacterData::
1527insertData(ULong offset,const DOMString& arg) const
1528{
1529 _checkValid();
1530 ARCANE_UNUSED(offset);
1531 ARCANE_UNUSED(arg);
1532 TNIE;
1533 //impl(_impl())->insertData(offset,toChar(arg));
1534}
1535void CharacterData::
1536deleteData(ULong offset,ULong count) const
1537{
1538 _checkValid();
1539 ARCANE_UNUSED(offset);
1540 ARCANE_UNUSED(count);
1541 TNIE;
1542 //impl(_impl())->deleteData(offset,count);
1543}
1544void CharacterData::
1545replaceData(ULong offset,ULong count,const DOMString& arg) const
1546{
1547 _checkValid();
1548 TNIE;
1549 ARCANE_UNUSED(offset);
1550 ARCANE_UNUSED(count);
1551 ARCANE_UNUSED(arg);
1552 //impl(_impl())->replaceData(offset,count,toChar(arg));
1553}
1554
1555/*---------------------------------------------------------------------------*/
1556/*---------------------------------------------------------------------------*/
1557
1558Attr::
1559Attr(AttrPrv* p)
1560: Node(cvt((xmlNodePtr)impl(p)))
1561{
1562}
1563
1564Attr::
1565Attr(const Node& node)
1566: Node()
1567{
1568 ARCANE_UNUSED(node);
1569 TNIE;
1570 // NodePrv* ni= node._impl();
1571 //if (ni && impl(ni)->getNodeType()==ATTRIBUTE_NODE)
1572 //_assign(node);
1573}
1574
1575AttrPrv* Attr::
1576_impl() const
1577{
1578 return cvt((xmlAttrPtr)impl(m_p));
1579}
1580DOMString Attr::
1581name() const
1582{
1583 _checkValid();
1584 TNIE;
1585 //return fromChar(impl(_impl())->getName());
1586}
1587bool Attr::
1588specified() const
1589{
1590 _checkValid();
1591 TNIE;
1592 //return impl(_impl())->getSpecified();
1593}
1594DOMString Attr::
1595value() const
1596{
1597 _checkValid();
1598 TNIE;
1599 //return fromChar(impl(_impl())->getValue());
1600}
1601void Attr::
1602value(const DOMString& str) const
1603{
1604 _checkValid();
1605 ARCANE_UNUSED(str);
1606 TNIE;
1607 //impl(_impl())->setValue(toChar(str));
1608}
1609Element Attr::
1610ownerElement() const
1611{
1612 _checkValid();
1613 TNIE;
1614 //return cvt(impl(_impl())->getOwnerElement());
1615}
1616
1617/*---------------------------------------------------------------------------*/
1618/*---------------------------------------------------------------------------*/
1619
1620Element::
1621Element()
1622: Node()
1623{}
1624Element::
1625Element(ElementPrv* p)
1626: Node(cvt((xmlNodePtr)impl(p)))
1627{}
1628Element::
1629Element(const Node& node)
1630: Node()
1631{
1632 NodePrv* ni= node._impl();
1633 if (ni && impl(ni)->type==XML_ELEMENT_NODE)
1634 _assign(node);
1635}
1636Element::
1637Element(const Element& node)
1638: Node(node)
1639{}
1640ElementPrv* Element::
1641_impl() const
1642{
1643 return cvt((xmlElementPtr)impl(m_p));
1644}
1645
1646DOMString Element::
1647tagName() const
1648{
1649 _checkValid();
1650 TNIE;
1651 // return fromChar(impl(_impl())->getTagName());
1652}
1653String Element::
1654getAttribute(const DOMString& name) const
1655{
1656 _checkValid();
1657 Attr a = getAttributeNode(name);
1658 if (a._null())
1659 return String();
1660 ::xmlChar* prop = ::xmlGetProp(impl(m_p),toChar(name));
1661 String s = fromChar(prop);
1662 ::xmlFree(prop);
1663 return s;
1664}
1665void Element::
1666setAttribute(const DOMString& name,const DOMString& value) const
1667{
1668 _checkValid();
1669 ::xmlSetProp(impl(m_p),toChar(name),toChar(value));
1670}
1671void Element::
1672removeAttribute(const DOMString& name) const
1673{
1674 _checkValid();
1675 ARCANE_UNUSED(name);
1676 TNIE;
1677 //impl(_impl())->removeAttribute(toChar(name));
1678}
1679Attr Element::
1680getAttributeNode(const DOMString& name) const
1681{
1682 _checkValid();
1683 xmlElementPtr elem_ptr = (xmlElementPtr)(impl(_impl()));
1684 return cvt(::xmlHasProp((xmlNodePtr)elem_ptr,toChar(name)));
1685}
1686Attr Element::
1687setAttributeNode(const Attr& new_attr) const
1688{
1689 _checkValid();
1690 ARCANE_UNUSED(new_attr);
1691 TNIE;
1692 //return cvt(impl(_impl())->setAttributeNode(impl(new_attr._impl())));
1693}
1694Attr Element::
1695removeAttributeNode(const Attr& old_attr) const
1696{
1697 _checkValid();
1698 ARCANE_UNUSED(old_attr);
1699 TNIE;
1700 //return cvt(impl(_impl())->removeAttributeNode(impl(old_attr._impl())));
1701}
1702NodeList Element::
1703getElementsByTagName(const DOMString& name) const
1704{
1705 _checkValid();
1706 ARCANE_UNUSED(name);
1707 TNIE;
1708 //return NodeList(cvt(impl(_impl())->getElementsByTagName(toChar(name))));
1709}
1710DOMString Element::
1711getAttributeNS(const DOMString& namespace_uri,const DOMString& local_name) const
1712{
1713 _checkValid();
1714 ARCANE_UNUSED(namespace_uri);
1715 ARCANE_UNUSED(local_name);
1716 TNIE;
1717 //return fromChar(impl(_impl())->getAttributeNS(toChar(namespace_uri),toChar(local_name)));
1718}
1719void Element::
1720setAttributeNS(const DOMString& namespace_uri,const DOMString& local_name,
1721 const DOMString& value) const
1722{
1723 _checkValid();
1724 ARCANE_UNUSED(namespace_uri);
1725 ARCANE_UNUSED(local_name);
1726 ARCANE_UNUSED(value);
1727 TNIE;
1728 //impl(_impl())->setAttributeNS(toChar(namespace_uri),toChar(local_name),toChar(value));
1729}
1730void Element::
1731removeAttributeNS(const DOMString& namespace_uri,const DOMString& local_name) const
1732{
1733 _checkValid();
1734 ARCANE_UNUSED(namespace_uri);
1735 ARCANE_UNUSED(local_name);
1736 TNIE;
1737 //impl(_impl())->removeAttributeNS(toChar(namespace_uri),toChar(local_name));
1738}
1739Attr Element::
1740getAttributeNodeNS(const DOMString& namespace_uri,const DOMString& local_name) const
1741{
1742 _checkValid();
1743 ARCANE_UNUSED(namespace_uri);
1744 ARCANE_UNUSED(local_name);
1745 TNIE;
1746 //return Attr(cvt(impl(_impl())->getAttributeNodeNS(toChar(namespace_uri),toChar(local_name))));
1747}
1748Attr Element::
1749setAttributeNodeNS(const Attr& new_attr) const
1750{
1751 _checkValid();
1752 new_attr._checkValid();
1753 TNIE;
1754 //return Attr(cvt(impl(_impl())->setAttributeNodeNS(impl(new_attr._impl()))));
1755}
1756NodeList Element::
1757getElementsByTagNameNS(const DOMString& namespace_uri,const DOMString& local_name) const
1758{
1759 _checkValid();
1760 ARCANE_UNUSED(namespace_uri);
1761 ARCANE_UNUSED(local_name);
1762 TNIE;
1763 //return NodeList(cvt(impl(_impl())->getElementsByTagNameNS(toChar(namespace_uri),toChar(local_name))));
1764}
1765bool Element::
1766hasAttribute(const DOMString& name) const
1767{
1768 _checkValid();
1769 ARCANE_UNUSED(name);
1770 TNIE;
1771 //return impl(_impl())->hasAttribute(toChar(name));
1772}
1773bool Element::
1774hasAttributeNS(const DOMString& namespace_uri,const DOMString& local_name) const
1775{
1776 _checkValid();
1777 ARCANE_UNUSED(namespace_uri);
1778 ARCANE_UNUSED(local_name);
1779 TNIE;
1780 //return impl(_impl())->hasAttributeNS(toChar(namespace_uri),toChar(local_name));
1781}
1782
1783/*---------------------------------------------------------------------------*/
1784/*---------------------------------------------------------------------------*/
1785
1786Text Text::
1787splitText(ULong offset) const
1788{
1789 _checkValid();
1790 ARCANE_UNUSED(offset);
1791 TNIE;
1792 //return Text(cvt(impl(_impl())->splitText(offset)));
1793}
1794DOMString Text::
1795wholeText() const
1796{
1797 _checkValid();
1798 TNIE;
1799 //return fromChar(impl(_impl())->getWholeText());
1800}
1801Text Text::
1802replaceWholeText(const DOMString& content) const
1803{
1804 _checkValid();
1805 ARCANE_UNUSED(content);
1806 TNIE;
1807 //return Text(cvt(impl(_impl())->replaceWholeText(toChar(content))));
1808}
1809
1810/*---------------------------------------------------------------------------*/
1811/*---------------------------------------------------------------------------*/
1812
1813DocumentType::
1814DocumentType()
1815: Node()
1816{}
1817DocumentType::
1818DocumentType(DocumentTypePrv* prv)
1819: Node(cvt((xmlNodePtr)impl(prv)))
1820{}
1821DocumentTypePrv* DocumentType::
1822_impl() const
1823{
1824 return cvt((xmlDocTypePtr)impl(m_p));
1825}
1826DOMString DocumentType::
1827name() const
1828{
1829 _checkValid();
1830 TNIE;
1831 //return fromChar(impl(_impl())->getName());
1832}
1833NamedNodeMap DocumentType::
1834entities() const
1835{
1836 _checkValid();
1837 TNIE;
1838 //return NamedNodeMap(cvt(impl(_impl())->getEntities()));
1839}
1840NamedNodeMap DocumentType::
1841notations() const
1842{
1843 _checkValid();
1844 TNIE;
1845 //return NamedNodeMap(cvt(impl(_impl())->getNotations()));
1846}
1847DOMString DocumentType::
1848publicId() const
1849{
1850 _checkValid();
1851 TNIE;
1852 //return fromChar(impl(_impl())->getPublicId());
1853}
1854DOMString DocumentType::
1855systemId() const
1856{
1857 _checkValid();
1858 TNIE;
1859 //return fromChar(impl(_impl())->getSystemId());
1860}
1861DOMString DocumentType::
1862internalSubset() const
1863{
1864 _checkValid();
1865 TNIE;
1866 //return fromChar(impl(_impl())->getInternalSubset());
1867}
1868
1869/*---------------------------------------------------------------------------*/
1870/*---------------------------------------------------------------------------*/
1871
1872NotationPrv* Notation::
1873_impl() const
1874{
1875 return cvt((xmlNotationPtr)impl(m_p));
1876}
1877
1878DOMString Notation::
1879publicId() const
1880{
1881 _checkValid();
1882 TNIE;
1883 //return fromChar(impl(_impl())->getPublicId());
1884}
1885
1886DOMString Notation::
1887systemId() const
1888{
1889 _checkValid();
1890 TNIE;
1891 //return fromChar(impl(_impl())->getSystemId());
1892}
1893
1894/*---------------------------------------------------------------------------*/
1895/*---------------------------------------------------------------------------*/
1896
1897EntityPrv* Entity::
1898_impl() const
1899{
1900 return cvt((xmlEntityPtr)impl(m_p));
1901}
1902
1903DOMString Entity::
1904publicId() const
1905{
1906 _checkValid();
1907 TNIE;
1908 //return fromChar(impl(_impl())->getPublicId());
1909}
1910DOMString Entity::
1911systemId() const
1912{
1913 _checkValid();
1914 TNIE;
1915 //return fromChar(impl(_impl())->getSystemId());
1916}
1917DOMString Entity::
1918notationName() const
1919{
1920 _checkValid();
1921 TNIE;
1922 //return fromChar(impl(_impl())->getNotationName());
1923}
1924
1925/*---------------------------------------------------------------------------*/
1926/*---------------------------------------------------------------------------*/
1927
1928ProcessingInstruction::
1929ProcessingInstruction()
1930: Node()
1931{}
1932ProcessingInstruction::
1933ProcessingInstruction(ProcessingInstructionPrv* prv)
1934: Node(cvt((xmlNodePtr)impl(prv)))
1935{}
1936ProcessingInstructionPrv* ProcessingInstruction::
1937_impl() const
1938{
1939 return cvt((xmlProcessingInstructionPtr)impl(m_p));
1940}
1941
1942DOMString ProcessingInstruction::
1943target() const
1944{
1945 _checkValid();
1946 TNIE;
1947 //return fromChar(impl(_impl())->getTarget());
1948}
1949DOMString ProcessingInstruction::
1950data() const
1951{
1952 _checkValid();
1953 TNIE;
1954 //return fromChar(impl(_impl())->getData());
1955}
1956void ProcessingInstruction::
1957data(const DOMString& value) const
1958{
1959 _checkValid();
1960 ARCANE_UNUSED(value);
1961 TNIE;
1962 //impl(_impl())->setData(toChar(value));
1963}
1964
1965/*---------------------------------------------------------------------------*/
1966/*---------------------------------------------------------------------------*/
1967
1968NamedNodeMap::
1969NamedNodeMap()
1970: m_p(nullptr)
1971{}
1972NamedNodeMap::
1973NamedNodeMap(NamedNodeMapPrv* p)
1974: m_p(p)
1975{}
1976NamedNodeMap::
1977NamedNodeMap(const NamedNodeMap& from)
1978: m_p(from.m_p)
1979{}
1980const NamedNodeMap& NamedNodeMap::
1981operator=(const NamedNodeMap& from)
1982{
1983 m_p = from.m_p;
1984 return (*this);
1985}
1986NamedNodeMap::
1987~NamedNodeMap()
1988{}
1989NamedNodeMapPrv* NamedNodeMap::
1990_impl() const
1991{
1992 return m_p;
1993}
1994bool NamedNodeMap::
1995_null() const
1996{
1997 return !m_p;
1998}
1999ULong NamedNodeMap::
2000length() const
2001{
2002 if (_null())
2003 return 0;
2004 ULong n = 0;
2005 ::xmlNodePtr xnode = (::xmlNodePtr)impl(m_p);
2006 while(xnode){
2007 ++n;
2008 xnode = xnode->next;
2009 }
2010 return n;
2011}
2012Node NamedNodeMap::
2013getNamedItem(const DOMString& name) const
2014{
2015 // NOTE: Ne marche que pour les attributs. Pour les autres types (entities, ...)
2016 // il faudrait faire une autre version. A priori, si on caste 'xmlAttr' en
2017 // 'xmlNode' et qu'on utilise que les champs de base (name, next), ca devrait
2018 // pouvoir aller pour tout.
2019 // NOTE: Pour les attributs, \a name peut contenir un préfix de namespace (par
2020 // exemple xml:lang). Il faut donc rechercher via le préfix + le nom local
2021 // et pas seulement le nom local.
2022 if (_null())
2023 return Node();
2024 ::xmlAttrPtr xattrlist = (::xmlAttrPtr)impl(m_p);
2025 const ::xmlChar* aname = toChar(name);
2026 ::xmlAttrPtr current = xattrlist;
2027 while (current){
2028 if (current->type==XML_ATTRIBUTE_NODE && current->ns){
2029 std::string full_name = (const char*)(current->ns->prefix);
2030 full_name += ":";
2031 full_name += (const char*)(current->name);
2032 if (xmlStrEqual(aname, (const xmlChar*)full_name.c_str())==1){
2033 return cvt((::xmlNodePtr)current);
2034 }
2035 }
2036 if (xmlStrEqual(aname,current->name)==1){
2037 return cvt((::xmlNodePtr)current);
2038 }
2039 current = current->next;
2040 }
2041 return Node();
2042}
2043Node NamedNodeMap::
2044setNamedItem(const Node& arg) const
2045{
2046 if (_null() || arg._null())
2047 return Node();
2048 TNIE;
2049 //return Node(cvt(impl(_impl())->setNamedItem(impl(arg._impl()))));
2050}
2051Node NamedNodeMap::
2052removeNamedItem(const DOMString& name) const
2053{
2054 if (_null())
2055 return Node();
2056 ARCANE_UNUSED(name);
2057 TNIE;
2058 //return Node(cvt(impl(_impl())->removeNamedItem(toChar(name))));
2059}
2060Node NamedNodeMap::
2061item(ULong index) const
2062{
2063 if (_null())
2064 return Node();
2065 ULong n = 0;
2066 ::xmlNodePtr xnode = (::xmlNodePtr)impl(m_p);
2067 while(xnode){
2068 if (n==index)
2069 return Node(cvt(xnode));
2070 ++n;
2071 xnode = xnode->next;
2072 }
2073 return Node();
2074}
2075Node NamedNodeMap::
2076getNamedItemNS(const DOMString& namespace_uri,const DOMString& local_name) const
2077{
2078 if (_null())
2079 return Node();
2080 ARCANE_UNUSED(namespace_uri);
2081 ARCANE_UNUSED(local_name);
2082 TNIE;
2083 //return Node(cvt(impl(_impl())->getNamedItemNS(toChar(namespace_uri),toChar(local_name))));
2084}
2085Node NamedNodeMap::
2086setNamedItemNS(const Node& arg) const
2087{
2088 if (_null())
2089 return Node();
2090 if (arg._null())
2091 return Node();
2092 TNIE;
2093 //return Node(cvt(impl(_impl())->setNamedItemNS(impl(arg._impl()))));
2094}
2095Node NamedNodeMap::
2096removeNamedItemNS(const DOMString& namespace_uri,const DOMString& local_name) const
2097{
2098 if (_null())
2099 return Node();
2100 ARCANE_UNUSED(namespace_uri);
2101 ARCANE_UNUSED(local_name);
2102 TNIE;
2103 //return Node(cvt(impl(_impl())->removeNamedItemNS(toChar(namespace_uri),toChar(local_name))));
2104}
2105
2106/*---------------------------------------------------------------------------*/
2107/*---------------------------------------------------------------------------*/
2108
2109DOMImplementation DOMImplementationSource::
2110getDOMImplementation(const DOMString& features) const
2111{
2112 ARCANE_UNUSED(features);
2113 throw NotImplementedException(A_FUNCINFO);
2114}
2115
2116/*---------------------------------------------------------------------------*/
2117/*---------------------------------------------------------------------------*/
2118
2119void UserDataHandler::
2120handle(UShort operation,const DOMString& key,const DOMObject& data,
2121 const Node& src,const Node& dest) const
2122{
2123 ARCANE_UNUSED(operation);
2124 ARCANE_UNUSED(key);
2125 ARCANE_UNUSED(data);
2126 ARCANE_UNUSED(src);
2127 ARCANE_UNUSED(dest);
2128 throw NotImplementedException(A_FUNCINFO);
2129}
2130
2131/*---------------------------------------------------------------------------*/
2132/*---------------------------------------------------------------------------*/
2133
2134DOMWriter::
2135DOMWriter()
2136: m_p(0)
2137{}
2138DOMWriter::
2139DOMWriter(DOMWriterPrv* p)
2140: m_p(p)
2141{
2142}
2143DOMWriter::
2144DOMWriter(const DOMWriter& from)
2145: m_p(from.m_p)
2146{
2147}
2148const DOMWriter& DOMWriter::
2149operator=(const DOMWriter& from)
2150{
2151 m_p = from.m_p;
2152 return (*this);
2153}
2154DOMWriter::
2155~DOMWriter()
2156{}
2157bool DOMWriter::
2158_null() const
2159{
2160 return !m_p;
2161}
2162void DOMWriter::
2163_checkValid() const
2164{
2165 if (_null())
2167}
2168DOMWriterPrv* DOMWriter::
2169_impl() const
2170{
2171 return m_p;
2172}
2173
2174ByteUniqueArray DOMWriter::
2175writeNode(const Node& node) const
2176{
2177 ARCANE_UNUSED(node);
2178 throw NotImplementedException(A_FUNCINFO);
2179}
2180
2181void DOMWriter::
2182encoding(const String& encoding)
2183{
2184 _checkValid();
2185 ARCANE_UNUSED(encoding);
2186 throw NotImplementedException(A_FUNCINFO);
2187}
2188
2189String DOMWriter::
2190encoding() const
2191{
2192 _checkValid();
2193 throw NotImplementedException(A_FUNCINFO);
2194}
2195
2196/*---------------------------------------------------------------------------*/
2197/*---------------------------------------------------------------------------*/
2198
2199DOMError::
2200DOMError()
2201: m_p(0)
2202{}
2203DOMError::
2204DOMError(DOMErrorPrv* p)
2205: m_p(p)
2206{
2207}
2208DOMError::
2209DOMError(const DOMError& from)
2210: m_p(from.m_p)
2211{
2212}
2213const DOMError& DOMError::
2214operator=(const DOMError& from)
2215{
2216 m_p = from.m_p;
2217 return (*this);
2218}
2219DOMError::
2220~DOMError()
2221{}
2222bool DOMError::
2223_null() const
2224{
2225 return !m_p;
2226}
2227void DOMError::
2228_checkValid() const
2229{
2230 if (_null())
2232}
2233DOMErrorPrv* DOMError::
2234_impl() const
2235{
2236 return m_p;
2237}
2238
2239UShort DOMError::
2240severity() const
2241{
2242 _checkValid();
2243 TNIE;
2244 //return impl(_impl())->getSeverity();
2245}
2246DOMString DOMError::
2247message() const
2248{
2249 _checkValid();
2250 TNIE;
2251 //return fromChar(impl(_impl())->getMessage());
2252}
2253DOMObject DOMError::
2254relatedException() const
2255{
2256 _checkValid();
2257 TNIE;
2258 //return DOMObject(impl(_impl())->getRelatedException());
2259}
2260DOMLocator DOMError::
2261location() const
2262{
2263 _checkValid();
2264 TNIE;
2265 //return DOMLocator(cvt(impl(_impl())->getLocation()));
2266}
2267
2268/*---------------------------------------------------------------------------*/
2269/*---------------------------------------------------------------------------*/
2270
2271bool DOMErrorHandler::
2272handleError(const DOMError& error) const
2273{
2274 ARCANE_UNUSED(error);
2275 throw NotImplementedException(A_FUNCINFO);
2276}
2277
2278/*---------------------------------------------------------------------------*/
2279/*---------------------------------------------------------------------------*/
2280
2281DOMLocator::
2282DOMLocator()
2283: m_p(0)
2284{}
2285DOMLocator::
2286DOMLocator(DOMLocatorPrv* p)
2287: m_p(p)
2288{
2289}
2290DOMLocator::
2291DOMLocator(const DOMLocator& from)
2292: m_p(from.m_p)
2293{
2294}
2295const DOMLocator& DOMLocator::
2296operator=(const DOMLocator& from)
2297{
2298 m_p = from.m_p;
2299 return (*this);
2300}
2301DOMLocator::
2302~DOMLocator()
2303{}
2304bool DOMLocator::
2305_null() const
2306{
2307 return !m_p;
2308}
2309void DOMLocator::
2310_checkValid() const
2311{
2312 if (_null())
2314}
2315DOMLocatorPrv* DOMLocator::
2316_impl() const
2317{
2318 return m_p;
2319}
2320
2321long DOMLocator::
2322lineNumber() const
2323{
2324 _checkValid();
2325 TNIE;
2326 //return impl(_impl())->getLineNumber();
2327}
2328
2329long DOMLocator::
2330columnNumber() const
2331{
2332 _checkValid();
2333 TNIE;
2334 //return impl(_impl())->getColumnNumber();
2335}
2336
2337DOMString DOMLocator::
2338uri() const
2339{
2340 _checkValid();
2341 TNIE;
2342 //return fromChar(impl(_impl())->getURI());
2343}
2344
2345/*---------------------------------------------------------------------------*/
2346/*---------------------------------------------------------------------------*/
2347
2348/*---------------------------------------------------------------------------*/
2349/*---------------------------------------------------------------------------*/
2350
2351XPathExpression XPathEvaluator::
2352createExpression(const DOMString& expression,
2353 const XPathNSResolver& resolver) const
2354{
2355 ARCANE_UNUSED(expression);
2356 ARCANE_UNUSED(resolver);
2357 throw NotImplementedException(A_FUNCINFO);
2358}
2359XPathResult XPathEvaluator::
2360createResult() const
2361{
2362 throw NotImplementedException(A_FUNCINFO);
2363}
2364XPathNSResolver XPathEvaluator::
2365createNSResolver(const Node& node_resolver) const
2366{
2367 ARCANE_UNUSED(node_resolver);
2368 throw NotImplementedException(A_FUNCINFO);
2369}
2370XPathResult XPathEvaluator::
2371evaluate(const DOMString& expression,const Node& context_node,
2372 const XPathNSResolver& resolver,UShort type,
2373 const XPathResult& result) const
2374{
2375 ARCANE_UNUSED(expression);
2376 ARCANE_UNUSED(context_node);
2377 ARCANE_UNUSED(resolver);
2378 ARCANE_UNUSED(type);
2379 ARCANE_UNUSED(result);
2380 throw NotImplementedException(A_FUNCINFO);
2381}
2382XPathResult XPathEvaluator::
2383evaluateExpression(const XPathExpression& expression,
2384 const Node& context_node,UShort type,
2385 const XPathResult& result) const
2386{
2387 ARCANE_UNUSED(expression);
2388 ARCANE_UNUSED(context_node);
2389 ARCANE_UNUSED(type);
2390 ARCANE_UNUSED(result);
2391 throw NotImplementedException(A_FUNCINFO);
2392}
2393
2394/*---------------------------------------------------------------------------*/
2395/*---------------------------------------------------------------------------*/
2396
2397DOMString XPathNSResolver::
2398lookupNamespaceURI(const DOMString& prefix) const
2399{
2400 ARCANE_UNUSED(prefix);
2401 throw NotImplementedException(A_FUNCINFO);
2402}
2403
2404/*---------------------------------------------------------------------------*/
2405/*---------------------------------------------------------------------------*/
2406
2407UShort XPathResult::
2408resultType() const
2409{
2410 throw NotImplementedException(A_FUNCINFO);
2411}
2412double XPathResult::
2413numberValue() const
2414{
2415 throw NotImplementedException(A_FUNCINFO);
2416}
2417DOMString XPathResult::
2418stringValue() const
2419{
2420 throw NotImplementedException(A_FUNCINFO);
2421}
2422bool XPathResult::
2423booleanValue() const
2424{
2425 throw NotImplementedException(A_FUNCINFO);
2426}
2427Node XPathResult::
2428singleNodeValue() const
2429{
2430 throw NotImplementedException(A_FUNCINFO);
2431}
2432XPathSetIterator XPathResult::
2433getSetIterator(bool ordered) const
2434{
2435 ARCANE_UNUSED(ordered);
2436 throw NotImplementedException(A_FUNCINFO);
2437}
2438XPathSetSnapshot XPathResult::
2439getSetSnapshot(bool ordered) const
2440{
2441 ARCANE_UNUSED(ordered);
2442 throw NotImplementedException(A_FUNCINFO);
2443}
2444
2445/*---------------------------------------------------------------------------*/
2446/*---------------------------------------------------------------------------*/
2447
2448Node XPathSetIterator::
2449nextNode() const
2450{
2451 throw NotImplementedException(A_FUNCINFO);
2452}
2453
2454/*---------------------------------------------------------------------------*/
2455/*---------------------------------------------------------------------------*/
2456
2457ULong XPathSetSnapshot::
2458length() const
2459{
2460 throw NotImplementedException(A_FUNCINFO);
2461}
2462Node XPathSetSnapshot::
2463item(ULong index) const
2464{
2465 ARCANE_UNUSED(index);
2466 throw NotImplementedException(A_FUNCINFO);
2467}
2468
2469/*---------------------------------------------------------------------------*/
2470/*---------------------------------------------------------------------------*/
2471
2472Element XPathNamespace::
2473ownerElement() const
2474{
2475 throw NotImplementedException(A_FUNCINFO);
2476}
2477
2478/*---------------------------------------------------------------------------*/
2479/*---------------------------------------------------------------------------*/
2480
2481void DOMImplementation::
2482initialize()
2483{
2484 // Appelle explicitement xmlInitParser(). Cela n'est en théorie pas
2485 // indispensable mais cette méthode peut générer des exceptions flottante
2486 // car à un momement il y a un appel explicite à une division par zéro pour
2487 // générer un Nan (dans xmlXPathInit()). Comme DOMImplementation::initialize()
2488 // est appelé avant d'activer les exception flottantes il faut faire
2489 // explicitement l'appel à l'initialisation du parseur ici.
2490 ::xmlInitParser();
2491}
2492
2493/*---------------------------------------------------------------------------*/
2494/*---------------------------------------------------------------------------*/
2495
2496void DOMImplementation::
2497terminate()
2498{
2499 // Là encore ce n'est pas indispensable mais cela permet de libérer les
2500 // ressources globales et ainsi éviter des fuites mémoire potentielles
2501 // (ce qui gène les outils comme valgrind).
2502 ::xmlCleanupParser();
2503}
2504
2505/*---------------------------------------------------------------------------*/
2506/*---------------------------------------------------------------------------*/
2507
2508}
2509
2510/*---------------------------------------------------------------------------*/
2511/*---------------------------------------------------------------------------*/
2512
#define ARCANE_THROW(exception_class,...)
Macro pour envoyer une exception avec formattage.
Gestionnaire d'un document DOM.
Noeud d'un maillage.
Definition Item.h:573
Exception liées aux fichiers XML.
Noeud d'un arbre DOM.
Definition XmlNode.h:51
IXmlDocumentHolder * _load(const String &fname, ITraceMng *msg, const String &schemaname)
IXmlDocumentHolder * _newDocument()
Les méthodes suivantes sont internes à Arcane.
Gestion des erreurs du lecteur Xml.
static void XMLCDECL handler(void *user_data, T *e)
Handler à connecter à la libxml2.
Classe encapsulant l'analyser d'un document XML.
IXmlDocumentHolder * parse(ILibXml2_Reader *reader, const String &schema_name, ByteConstArrayView schema_data)
Analyse le contenu Xml via le reader reader.
Classe encapsulant la validation XML Schema d'un document XML.
void validate(::xmlDocPtr doc, ByteConstArrayView schema_data)
Valide un document XML.
NodePrv * m_p
Implémentation de la classe.
Definition Dom.h:413
void releaseNode()
Détruit le noeud.
IXmlDocumentHolder * clone() override
Clone ce document.
XmlNode documentNode() override
Noeud document. Ce noeud est nul si le document n'existe pas.
String save() override
Sauvegarde ce document et retourne la chaîne de caractères.
void save(ByteArray &bytes) override
Sauvegarde ce document dans le tableau bytes.
Classe de base des vecteurs 1D de données.
Vue constante d'un tableau de type T.
Interface du gestionnaire de traces.
virtual TraceMessage info()=0
Flot pour un message d'information.
Référence à une instance.
Constructeur de chaîne de caractère unicode.
String toString() const
Retourne la chaîne de caractères construite.
Chaîne de caractères unicode.
const char * localstr() const
Retourne la conversion de l'instance dans l'encodage UTF-8.
Definition String.cc:227
bool null() const
Retourne true si la chaîne est nulle.
Definition String.cc:304
Vecteur 1D de données avec sémantique par valeur (style STL).
Integer len(const char *s)
Retourne la longueur de la chaîne s.
Int32 toInt32(Int64 v)
Converti un Int64 en un Int32.
Integer arcaneCheckArraySize(unsigned long long size)
Vérifie que size peut être converti dans un 'Integer' pour servir de taille à un tableau....
void arcaneNullPointerError()
Signalue l'utilisation d'un pointeur nul.
Array< Byte > ByteArray
Tableau dynamique à une dimension de caractères.
Definition UtilsTypes.h:211
Span< const std::byte > ByteConstSpan
Vue en lecture seule d'un tableau à une dimension de caractères.
Definition UtilsTypes.h:638
UniqueArray< Byte > ByteUniqueArray
Tableau dynamique à une dimension de caractères.
Definition UtilsTypes.h:425
ConstArrayView< Byte > ByteConstArrayView
Equivalent C d'un tableau à une dimension de caractères.
Definition UtilsTypes.h:566
Int32 Integer
Type représentant un entier.