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