xmlsomreader.h

/**************************************************************************
*   Copyright (C) 2004 by root                                            *
*   root@aquiles                                                          *
*                                                                         *
*   This program is free software; you can redistribute it and/or modify  *
*   it under the terms of the GNU General Public License as published by  *
*   the Free Software Foundation; either version 2 of the License, or     *
*   (at your option) any later version.                                   *
*                                                                         *
*   This program is distributed in the hope that it will be useful,       *
*   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
*   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
*   GNU General Public License for more details.                          *
*                                                                         *
*   You should have received a copy of the GNU General Public License     *
*   along with this program; if not, write to the                         *
*   Free Software Foundation, Inc.,                                       *
*   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
***************************************************************************/

#ifndef XMLSOMReader_H
#define XMLSOMReader_H

#include <libxml/xmlreader.h>

#include <stdlib.h>
#include <string>
#include <stdexcept>
#include <map>

using std::exception;

namespace xmlsom {


  class XMLSOMReader {
  
    public:
  
      XMLSOMReader(std::string filename) throw(std::exception);
    
      ~XMLSOMReader() {};
          
    protected:    
    
      void doParse() throw(std::exception);    
    
      virtual void processElement( const std::string& name,
                                   const std::string& value,
                                   const std::map<std::string,std::string>& attrs )
        throw(exception) = 0;
                                
      virtual void processEndElement(const std::string& name) {};
    
    private:
  
      void prepareNode();
    
      void prepareAttrs();
  
      xmlTextReaderPtr reader;
      
      std::string filename;  

      std::map<std::string,std::string> atribs;

      const xmlChar* name;

      const xmlChar* value;

      std::string sname;

      std::string svalue;

      bool handleEmptyElement;
  };



  //default constructor
  XMLSOMReader::XMLSOMReader(std::string fileName) throw(std::exception)
    : filename(fileName) { 
  
    reader = xmlNewTextReaderFilename(filename.data());
 
    if (reader == NULL)
      throw std::invalid_argument("Invalid filename path");

    handleEmptyElement = false;
  
  };



  //start point of parsing
  //must be called by subclasses
  void XMLSOMReader::doParse() throw (std::exception) {

    int ret = xmlTextReaderRead(reader);  

    //traverses the xml node tree
    while (ret == 1) {    
      //formats the node
      prepareNode();
    
      //read next node
      ret = xmlTextReaderRead(reader);
    }

    xmlFreeTextReader(reader);  

    if (ret != 0)
      throw std::invalid_argument("failed to parse " + filename);  
  };



  //formats the node for a aplication-specific processing class
  void XMLSOMReader::prepareNode() {
  
    //element type
    int nodeType = xmlTextReaderNodeType(reader);  

    switch(nodeType) {

      case XML_READER_TYPE_ELEMENT: {

        if (handleEmptyElement) {
          processElement(sname, "", atribs);
          handleEmptyElement = false;
        }

        name = xmlTextReaderConstName(reader);
        
        sname = std::string( (char*) name);
        
        //extracts the attributes into a map<string,string>
        prepareAttrs();
        
        handleEmptyElement = true;

        break;
      }

      
      case XML_READER_TYPE_TEXT: {

        value = xmlTextReaderConstValue(reader);

        if (value != NULL) {
          svalue = std::string( (char*) value );
        } else {
          svalue = "";
        }

        //delegates the processing for a subclass
        processElement(sname, svalue, atribs);      
        handleEmptyElement = false;

        break;
      }


      case XML_READER_TYPE_END_ELEMENT: {      
        processEndElement( sname );
        break;
      }
    }
  
  }



  // reads the attributes of a node generating a map
  // of name<->value pairs
  void XMLSOMReader::prepareAttrs() {  
  
    const xmlChar* name;
    const xmlChar* value;
  
    atribs.clear();

    int count = xmlTextReaderAttributeCount(reader);

    for(register int i = 0 ; i < count ; i++) {
  
      if (xmlTextReaderMoveToAttributeNo(reader, i) == 1) {
        name = xmlTextReaderConstName(reader);
        value = xmlTextReaderConstValue(reader);

        std::string sname( (char *) name );
        std::string svalue( (char *) value );
      
        //adds attribute pair
        atribs[sname] = svalue;
      
      }
    }
  };


};

#endif

---