XmlWriter.hpp

// This file is part of the imaging2 class library.
//
// University of Innsbruck, Infmath Imaging, 2009.
// http://infmath.uibk.ac.at
//
// All rights reserved.


#ifndef XMLWRITER_H
#define XMLWRITER_H

#include <core/cio.hpp>

#include <boost/shared_ptr.hpp>


typedef struct _xmlDoc xmlDoc;
typedef xmlDoc * xmlDocPtr;

typedef struct _xmlTextWriter xmlTextWriter;
typedef xmlTextWriter * xmlTextWriterPtr;

namespace imaging
{
  template<class data_t>
  class xml_handler;
  
  class XmlWriter
  {
    class stream_command
    {
      friend class XmlWriter;
      size_t _cmd_id;

    protected:
      enum commands { ELEMENT = 0, END_ELEMENT, ATTRIBUTE, COMMENT };

      std::string _identifier;

    public:
      stream_command() {}
      stream_command(size_t cmd_id, const std::string & identifier) : _cmd_id(cmd_id), _identifier(identifier) {}
    };

    template<size_t N, class data_t>
    void fixed_vector_2_string(const ublas::fixed_vector<data_t, N> & v, std::string & str)
    {
      std::ostringstream out;
      
      out << "(";
      for(std::size_t i = 0; i < N - 1; ++i)
        out << v(i) << ",";
        
      out << v(N - 1) << ")";
        
      str = out.str();
    }
    
    template <class data_t>
    XmlWriter &  write_integral_type_value(const data_t & value);
    
    template <class data_t>
    XmlWriter &  write_integral_type_vector(const std::vector<data_t> & vector);
    
  public:
    class element : public stream_command
    {
    public:
      element(const std::string & identifier) : stream_command(ELEMENT, identifier) {}
    };
    class attribute : public stream_command
    {
    public:
      attribute(const std::string & identifier) : stream_command(ATTRIBUTE, identifier) {}
    };
    
    class comment : public stream_command
    {
    public:
      comment(const std::string & identifier) : stream_command(COMMENT, identifier) {}
    };

  private:
    xmlDocPtr _doc;
    xmlTextWriterPtr _writer;

    bool _attribute_active;
    std::string _current_attribute;
    std::string _current_attribute_content;
    
    bool _element_active;
    std::string _current_element;

    void flush_element();

    static const char ISO_8859_1 [];


  public:

    static const stream_command end_element;

    XmlWriter(const std::string & root_element, const std::string & style_file_name = "");

    ~XmlWriter();

    XmlWriter & operator<<(const stream_command & command);
    
    XmlWriter & operator<<(const element & command);
    
    XmlWriter & operator<<(const attribute & command);
    
    XmlWriter & operator<<(const comment & command);
    
    XmlWriter & operator<<(const std::string & string);
    
    XmlWriter & operator<<(const char* str);
    
    XmlWriter & operator<<(float_t value);
    
    XmlWriter & operator<<(size_t value);

    template<size_t N, class data_t>
    XmlWriter & operator<<(const ublas::fixed_vector<data_t, N> & value)
    {
      std::string temp;
      fixed_vector_2_string(value, temp);
      
      *this << temp;
    
      return *this;
    }
    
    template<class data_t>
    XmlWriter & operator<<(const data_t & object)
    {
      xml_handler<data_t> handler;
    
      *this << element(handler.element_name);
      handler.write_object(object, *this);
      *this << end_element;

      return *this;
    }
    
    template<class data_t>
    XmlWriter & operator<<(const std::vector<data_t> & vector)
    {
      for(size_t i = 0; i < vector.size(); ++i)
        *this << vector[i];

      return *this;
    }
    
    XmlWriter & operator<<(const std::vector<float_t> & vector);
    
    template<class data_t>
    XmlWriter & operator<<(const std::vector< boost::shared_ptr<data_t> > & vector)
    {
      for(size_t i = 0; i < vector.size(); ++i)
        *this << *vector[i];

      return *this;
    }

    void write_file(const std::string & file_name);
  };
}

#endif

---