source: XMLIO_V2/dev/dev_rv/xmlio_xml_parser.hpp @ 88

#ifndef __XMLIO_XML_PARSER__
#define __XMLIO_XML_PARSER__ 

// Entêtes Poco DOM
#include <Poco/DOM/DOMParser.h>
#include <Poco/DOM/Document.h>
#include <Poco/DOM/Element.h>

#include <Poco/DOM/NamedNodeMap.h>

//#include <Poco/DOM/AutoPtr.h>

// Entêtes Poco SAX
#include <Poco/SAX/InputSource.h>

// Utilisation de la STL
using std::string;

using std::pair;
using std::vector;
using std::deque;

using std::istream;
using std::ostream;
using std::ostringstream;
using std::ifstream;

// Utilisation de la biliothÚque POCO
using Poco::XML::DOMParser;
using Poco::XML::InputSource;

using Poco::XML::Document;
using Poco::XML::Node;
using Poco::XML::Element;

using Poco::XML::NamedNodeMap;

using Poco::HashMap;

namespace XMLIOSERVER
{
   namespace XML
   {
      
      typedef HashMap<string, string> THashAttributes;
         
      // TODO Mettre des auto_ptr ici car gestion de la mémoire lamentable sans.
      typedef Document* PDocument;
      typedef Node*     PNode;
         
      class XMLNode
      {
         protected :
            
            XMLNode(const string& _rootName) : rootName(_rootName) { this->cNode = NULL ; }
            
         public :
            
            static XMLNode CreateNode(istream& _istr, const string& _rootName = string("simulation"))
            {
               XMLNode node(_rootName);
                  
               if ((_istr.good()))
               { // S'il est possible de lire le flux en entrée ...
                  InputSource src(_istr);
                  DOMParser parser;
                     
                  // On parse la source XML et on vérifie que le premier noeud (racine) est du type "Element"
                  // ... et à pour valeur la chaîne rootName.
                  PDocument pDoc = parser.parse(&src);
                  if (!(pDoc->documentElement()->nodeName().compare(_rootName)))
                  {
                     node.cNode = pDoc->documentElement();
                     node.goToChildElement();
                  }
                  else
                  {
                     ostringstream oss;
                     oss << "L'élément racine doit avoir pour valeur <" << _rootName << "> (\"" <<  (pDoc->documentElement()->nodeName()) <<"\" lue)";
                     throw XMLParsingException(oss.str());
                  }    
               }
               else
                  throw XMLIOStreamException("Impossible de lire le flux en entrée pour le parsing XML !");
                  
               return (node);
            }
               
            string getElementName(void) const {return (this->cNode->nodeName());}
                
            bool goToNextElement(Node* nextElement = 0) 
            {
               nextElement = (!nextElement)? this->cNode->nextSibling() : nextElement;
              
               // On parcourt la liste des "siblings" jusqu'à trouver un élément quelconque.
               for(; ; nextElement = nextElement->nextSibling())
               if (nextElement == NULL) break;
               else if (nextElement->nodeType() == 1)
               {// Si l'un des noeuds est un élément...
                this->cNode = nextElement ;
                return (true);
               } 
              return (false);
             }
             
             bool goToChildElement(void)
             {
              // On parcourt la liste des enfants jusqu'à trouver un élément quelconque.
              if (this->cNode->firstChild())
               if (this->goToNextElement(this->cNode->firstChild()))
                return (true);
                
              return (false);
             }
             
             bool goToParentElement(void)
             { 
              // Pas de retour au parent si on est à la racine.
              if (!(this->getElementName().compare(rootName))) return (false);
              this->cNode = this->cNode->parentNode();
              return (true);
             }
             
             bool getAttributes(THashAttributes& attributes) const
             {
              if(!this->cNode->hasAttributes()) return (false);
              NamedNodeMap* map = this->cNode->attributes();
              
              for(unsigned int i = 0; i< map->length(); i++)
               attributes[map->item(i)->nodeName()] = map->item(i)->nodeValue();

              return (true);
             }
            
            ~XMLNode() 
            { /* Ne rien faire de plus */ }

         private :
                  
            PNode  cNode;
            string rootName;      
         
      };// class XMLNode
      
      #include "field.hpp"
      
      #include "xmlio_group_template.hpp"      
      #include "field_group.hpp"
      
      #include "context.hpp"
            
      using XMLIOSERVER::Context;
      
      class XMLParser
      {
         public : 
            static void Parse(XMLNode& _node)
            {
               THashAttributes attributes;
               
              do {                
                 // Traitement de l'identifiant
                  _node.getAttributes(attributes);            
                  if (attributes.end() == attributes.find("id"))
                  { WARNING("L'un des contexts ne sera pas traité car il n'est pas identifié !"); continue; }
                  Context& context = Context::CreateObject(attributes["id"]);
                  context.parse(_node);
                  attributes.clear();
                  
               } while (_node.goToNextElement());               
            }    
            
            static bool CLASS_TEST(ostream& log = std::clog)
            {
               ifstream istr( "/local/testsuite/iodef_test.xml" , ifstream::in ); // Modifier le répertoire de test ici
               XMLNode node = XMLNode::CreateNode(istr);
               XMLParser::Parse(node);
               log << "Nombre de contexts listés : " << Context::GetCurrentListObject().getSize() << " contre 2 attendus."<< std::endl;
               log << "Test  XMLParser ... ok !" << std::endl;
               return (true);
            }
                 
      }; // class XMLParser     
   }; // namespace XML

};// namespace XMLIOSERVER


#endif // __XMLIO_XML_PARSER__