xmlsomwriter.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 XMLSOMWRITER_H
#define XMLSOMWRITER_H

#include <string>
#include <stdexcept>
#include <map>
#include <libxml/encoding.h>
#include <libxml/xmlwriter.h>

#define DEFAULT_ENCODING "ISO-8859-1"


typedef enum {

  AT_BEGINNING = 0,

  AT_DOCUMENT,

  AT_ELEMENT,

  AT_END    

} XMLWriterState;


namespace xmlsom {


  class XMLSOMWriter {
  
    public:
    
      XMLSOMWriter(std::string fileName) throw(std::exception);
    
      virtual void startDocument() throw(std::exception);
    
      virtual void startElement( const std::string& name,                                
                                 const std::map<std::string,std::string>& attrs ) throw(std::exception);
    
      virtual void startElement( const std::string& name ) throw(std::exception);

      virtual void writeElement( const std::string& name,
                                 const std::string& value,
                                 const std::map<std::string,std::string>& attrs ) throw(std::exception);

      virtual void writeElement( const std::string& name, const std::string& value ) throw(std::exception);

    
      virtual void endElement() throw(std::exception);
    
      virtual void endDocument() throw(std::exception);

      ~XMLSOMWriter();
  
    protected:
  
      void writeAttributes( const std::map<std::string,std::string>* attrs ) throw(std::exception);
    
      std::string filename;
    
      XMLWriterState status;
    
      xmlTextWriterPtr writer;

  };

  //default constructor
  XMLSOMWriter::XMLSOMWriter(std::string fileName) 
    throw(std::exception) : filename(fileName) {

    //creates a writer for the given filename without compression
    writer = xmlNewTextWriterFilename(filename.data(), 0);

    xmlTextWriterSetIndent(writer, 3);
  
    if (writer == NULL)
      throw std::invalid_argument("Error creating the xml writer");
      
    status = AT_BEGINNING;
  };



  //default destructor
  XMLSOMWriter::~XMLSOMWriter() {};



  //signals for a document starting
  void XMLSOMWriter::startDocument() throw(std::exception) {
  
    if (status != AT_BEGINNING)
      throw std::invalid_argument("Invalid XMLWriter state to start a document");

    status = AT_DOCUMENT; //set the appropriate status
  
    //formerly starts the documents
    int rc = xmlTextWriterStartDocument(writer, 0, DEFAULT_ENCODING, 0);
  
    if (rc < 0)
      throw std::invalid_argument("Error starting document");
  };



  //signals for an element starting
  void XMLSOMWriter::startElement( const std::string& name ) 
       throw(std::exception) {

    if (status != AT_DOCUMENT)
      throw std::invalid_argument("Invalid XMLWriter state to start an element");

        status = AT_ELEMENT; //proper status
  
    //formerly starts an element
    int rc = xmlTextWriterStartElement(writer, BAD_CAST name.data());
  
    if (rc < 0)
      throw std::invalid_argument("Error starting element");
  
  };



  //signals for an element starting
  void xmlsom::XMLSOMWriter::startElement( const std::string& name, 
                                           const std::map<std::string,std::string>& attrs ) 
        throw(std::exception) {

    this->startElement(name);
    
    //writes the attributes
    writeAttributes(&attrs);
  };



  //Writes a subelement its value and its attributes    
  void XMLSOMWriter::writeElement( const std::string& name,
                                   const std::string& value ) 
        throw(std::exception) {

    if (status != AT_DOCUMENT && status != AT_ELEMENT)
      throw std::invalid_argument("Invalid XMLWriter state to write an element");

    int rc = xmlTextWriterWriteElement(writer, BAD_CAST name.data(),
                                       BAD_CAST value.data()); 
   
    if (rc < 0)
      throw std::invalid_argument("Error writing element");
  };




  //Writes a subelement its value and its attributes    
  void XMLSOMWriter::writeElement( const std::string& name,
                                   const std::string& value,
                                   const std::map<std::string,std::string>& attrs ) 
       throw(std::exception) {

    if (status != AT_DOCUMENT && status != AT_ELEMENT)
      throw std::invalid_argument("Invalid XMLWriter state to write an element");
  
    int rc = xmlTextWriterStartElement(writer, BAD_CAST name.data());  

    //writes the attributes
    writeAttributes(&attrs);
    
    rc = xmlTextWriterWriteString(writer, BAD_CAST value.data());

    rc = xmlTextWriterEndElement(writer);

    if (rc < 0)
      throw std::invalid_argument("Error writing element");
  };



  //marks the end of an element
  void XMLSOMWriter::endElement() throw(std::exception) {
  
      if (status != AT_ELEMENT)
      throw std::invalid_argument("Invalid XMLWriter state to finnish an element");
  
    status = AT_DOCUMENT;
    
    int rc = xmlTextWriterEndElement(writer);

    if (rc < 0)
      throw std::invalid_argument("Error finnishing element");  
  };



  //signals the end of a document    
  void XMLSOMWriter::endDocument() throw(std::exception) {
  
    if (status != AT_DOCUMENT)
      throw std::invalid_argument("Invalid XMLWriter state to finnish a document");
  
    status = AT_END;
  
    int rc = xmlTextWriterEndDocument(writer);
  
    xmlFreeTextWriter(writer);

    if (rc < 0)
      throw std::invalid_argument("Error finnishing document");
  };




  //Takes a map of attribute-value pairs and writes down
  void XMLSOMWriter::writeAttributes( const std::map<std::string,std::string>* attrs ) 
    throw(std::exception) {

    if (attrs != 0) {

      int rc = 0;
      std::map<std::string,std::string>::const_iterator it;

      for(it = attrs->begin() ; it != attrs->end() ; it++ ) {      

        rc = xmlTextWriterWriteAttribute(writer, BAD_CAST it->first.data(),
                                         BAD_CAST it->second.data());
        if (rc < 0)
          throw std::invalid_argument("Error writing attribute");
      }
    }
  };


};


#endif

---