Autor: Krzysztof Mioduszewski 2008/04/14 23:59

Xerces-C++ DOM jest częścią Xerces-C++ API zaprojektowanego do współpracy z plikami w formacie XML. API umożliwia parsowania, manipulowanie, walidowanie oraz generowanie poprawnych dokumentów.

Biblioteka DOM jest implementacją następujących rekomendacji W3C:

• Document Object Model (DOM) Level 1 Specification
• Document Object Model (DOM) Level 2 Core Specification
• Document Object Model (DOM) Level 2 Traversal and Range Specification

Oraz zawiera częściową implementację (opartą o W3C Working Draft 09 April 2002) :

• Document Object Model (DOM) Level 3 Core Specification
• Document Object Model (DOM) Level 3 Abstract Schemas and Load and Save Specification

Więcej informacji na stronie projektu http://xerces.apache.org/xerces-c/. Na stronie znajdują się źródła, oraz skompilowane wersje biblioteki na różne platformy. Kompletna instrukcja instalacji na różnych platformach znajduje się tutaj.

Nagłówki, które powinniśmy dołączyć w przypadku pisania typowych aplikacji korzystających z Xerces DOM znajdują się poniżej:

#include <xercesc/util/PlatformUtils.hpp>
#include <xercesc/util/XMLString.hpp>
#include <xercesc/dom/DOM.hpp> 
#include <xercesc/parsers/XercesDOMParser.hpp>

Xerces posiada własny typ znakowy XMLCh, który jest używany zamiast char i std::string. Do konwersji pomiędzy typami char* a XMLCh* (w obie strony) używana jest funkcja XMLString::transcode(). Pamięć zaalokowaną na łańcuchy należy zwalniać za pomocą funkcji XMLString::release().

Przed użyciem jakichkolwiek klas Xerces konieczne jest wywołanie metody XMLPlatformUtils::Initialize(). Po zakończeniu korzystania z Xerces powinno się wywołać XMLPlatformUtils::Terminate(). Poniżej znajduje się uproszczona struktura programu (warto zwrócić uwagę na uzycie transcode()).

#include <xercesc/util/PlatformUtils.hpp>
#include <xercesc/util/XMLString.hpp>
#include <xercesc/dom/DOM.hpp> 
#include <xercesc/parsers/XercesDOMParser.hpp>
// ...
#include <iostream>  
 
int main()
{
	try { 
		//incjalizacja Xerces-C++
		xercesc::XMLPlatformUtils::Initialize();
	}
	catch (const xercesc::XMLException& e) {
		//konwersja  z XMLCh* na char*
		char* msg = xercesc::XMLString::transcode(e.getMessage()) ;
 
		std::cerr << "Init Error: " << msg << std::endl;
		//zwolnienie pamieci
		xercesc::XMLString::release(&msg) ;
		return 1;
	}
 
	// Tutaj korzystamy z mozliwosci Xerces-C++ 
 
	xercesc::XMLPlatformUtils::Terminate();
 
	return 0;
}

Jest to parser umożliwiający wczytanie do pamięci struktury pliku XML za pomocą metody parse(). Po czym uzyskujemy dostęp do obiektu DOMDocument, po którym możemy poruszać się wykorzystując zaimplementowane w zgodzie z rekomendacjami W3C metody.

Poniżej przykładowe fragmenty kodu dotyczącego inicjalizacji i korzystania z XercesDOMParser.

xercesc::XercesDOMParser* parser = new xercesc::XercesDOMParser();
parser->setValidationScheme(xercesc::XercesDOMParser::Val_Auto);  //uruchamia walidację, jeżeli dostępne jest DTD (wewnętrzne/zewnętrzne)   
parser->setDoNamespaces(true);  
 
char* xmlFile = "file.xml";
 
try {
    parser->parse(xmlFile);
}
catch( const xercesc::XMLException& e ){
    //...			
}
catch( const xercesc::DOMException& e ){
    //...	
}
catch (...) {
    //...
}
 
//sprawdzamy czy nie wystąpiły błędy podczas parsowania
if(parser->getErrorCount()==0) {
    xercesc::DOMDocument* XMLdoc = parser->getDocument();
    //...
}

Dobrym pomysłem jest zastosowanie własnego ErrorHandler do wykrywania błędów składniowych w trakcie parsowania i wyświetlania o nich informacji (typ, miejsce wystąpienia). Najprostszy sposób to zaimplementowanie metod z interfejsu HandlerBase:

#include <xercesc/sax/HandlerBase.hpp>
 
class myErrorHandler : xercesc::HandlerBase {
	void warning( const xercesc::SAXParseException& e ) { 
		char *msg = xercesc::XMLString::transcode(e.getMessage()); 
		std::cout << "warning: " << msg 
		          << " | line: " << e.getLineNumber() << std::endl;
		xercesc::XMLString::release(&msg);
	}
	void error( const xercesc::SAXParseException& e ) {
               // analogicznie jak wyżej
	}
	void fatalError( const xercesc::SAXParseException& e ) {
	       // j.w.
	}
	void resetErrors() {}
};
 
//...
 
xercesc::XercesDOMParser* parser = new xercesc::XercesDOMParser();
parser->setValidationScheme(xercesc::XercesDOMParser::Val_Auto);    
parser->setDoNamespaces(true);  
 
xercesc::ErrorHandler* errHandler = (xercesc::ErrorHandler*) new myErrorHandler();
parser->setErrorHandler(errHandler);

Gdy dokument zostanie sparsowany bez żadnych błędów możemy swobodnie zacząć na nim pracować wykorzystując zawarte w rekomendacjach metody. Poniżje znajduje się kod przykładowej aplikacji, która wczytuje plik XML, wpisuje jego zawartość na ekran, modyfikuje go, a następnie zapisuje zmiany do pliku.

Plik XML - notes.xml, który zostanie wczytany:

<?xml version="1.0"?>
<!DOCTYPE notes SYSTEM "note.dtd">
<notes owner="John Doe">
 
   <note date="21/02/2008">
      <from>Jani</from>
      <heading>Reminder</heading>
      <body>Don't forget me this weekend</body>
   </note>
   <note date="12/04/2008">
      <from>Jeff</from>
      <heading>Money</heading>
      <body>Gimme my money back!</body>
   </note>
</notes>

DTD - notes.dtd

 <!ELEMENT notes (note+) > 
 <!ATTLIST notes owner CDATA #REQUIRED>
  <!ELEMENT note (from,heading,body)>
  <!ATTLIST note date CDATA #REQUIRED>
  <!ELEMENT from    (#PCDATA)>
  <!ELEMENT heading (#PCDATA)>
  <!ELEMENT body    (#PCDATA)>

Klasy pomocnicze:

 
//klasa pomocnicza przechowujaca nazwy tagów oraz atrybutów w formacie XMLCh*
class TagNames {
	public:
	XMLCh* TAG_NOTES;
	XMLCh* TAG_NOTE;
	XMLCh* TAG_FROM;
	XMLCh* TAG_HEADING;
	XMLCh* TAG_BODY;
 
	XMLCh* ATTR_OWNER;
	XMLCh* ATTR_DATE;
 
	TagNames()
		:
		TAG_NOTES(xercesc::XMLString::transcode("notes")),
		TAG_NOTE(xercesc::XMLString::transcode("note")),
		TAG_FROM(xercesc::XMLString::transcode("from")),
		TAG_HEADING(xercesc::XMLString::transcode("heading")),
		TAG_BODY(xercesc::XMLString::transcode("body")),
 
		ATTR_OWNER(xercesc::XMLString::transcode("owner")),
		ATTR_DATE(xercesc::XMLString::transcode("date"))
	{}
 
	~TagNames() throw(){
 
		try{
			xercesc::XMLString::release(&TAG_NOTES);
			xercesc::XMLString::release(&TAG_NOTE);
			xercesc::XMLString::release(&TAG_FROM);
			xercesc::XMLString::release(&TAG_HEADING);
			xercesc::XMLString::release(&TAG_BODY);
 
			xercesc::XMLString::release(&ATTR_OWNER);
			xercesc::XMLString::release(&ATTR_DATE);
		}catch( ... ){
			std::cerr << "TagNames destructor error" << std::endl ;
		}	
	} 
}

//...
 
xercesc::DOMDocument* XMLdoc = parser->getDocument();
xercesc::DOMElement* root = XMLdoc->getDocumentElement();
 
//pobieramy nazwę elementu głównego
char* rootName = XMLString::transcode(root->getLocalName());
 
if(root->hasAttributes()) {
	xercesc::DOMNamedNodeMap* attrMap = root->getAttributes();
	//iterujemy sobie po atrybutach
        for( XMLSize_t i = 0 ; i < attrMap->getLength() ; ++i ) {
		DOMAttr* attr = dynamic_cast<DOMAttr*>(attrMap->item(ix));
                //wykorzystujemy sobie atrybut
                attr->getName();  //tutaj mamy nazwe
                attr->getValue(); //wartosc
                //...
	}
}