XmlReader.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 XML_XMLREADER_H
#define XML_XMLREADER_H

#include <core/cio.hpp>
#include <core/Exception.hpp>

#include <boost/shared_ptr.hpp>
#include <boost/lexical_cast.hpp>

typedef struct _xmlDoc xmlDoc;
typedef xmlDoc * xmlDocPtr;

typedef struct _xmlXPathContext xmlXPathContext;
typedef xmlXPathContext * xmlXPathContextPtr;

typedef struct _xmlNodeSet xmlNodeSet;
typedef xmlNodeSet * xmlNodeSetPtr;
  
namespace imaging
{
  
  template<class data_t>
  class xml_handler;
  
  class XmlReader
  {
    class stream_command
    {
      friend class XmlReader;

    protected:
      enum commands { ELEMENT = 0, INDEX, ELEMENT_WITH_INDEX, END_ELEMENT, ATTRIBUTE, CHILD_ELEMENT };

      size_t _cmd_id;
      std::string _identifier;
      size_t _index;

    public:
      stream_command() {}
      stream_command(size_t cmd_id, const std::string & identifier, size_t index = 0) : 
        _cmd_id(cmd_id), _identifier(identifier), _index(index) {}}
    ;
    
  public:
    class element : public stream_command
    {
    public:
      element(const std::string & identifier) : stream_command(ELEMENT, identifier) {}
      
      element(const std::string & identifier, size_t index) :
        stream_command(ELEMENT_WITH_INDEX, identifier, index) {}
      
      element(size_t index) : stream_command(INDEX, "", index) {}
    };
    
    class child_element : public stream_command
    {
    public:
      child_element(size_t index) : stream_command(CHILD_ELEMENT, "", index) {}
    };

    
    class attribute : public stream_command
    {
    public:
      attribute(const std::string & identifier) : stream_command(ATTRIBUTE, identifier) {}}
    ;

    template <class data_t>
    class default_value
    {
      friend class XmlReader;

      data_t & _object;
      const data_t & _default_object;

    public:
      default_value(data_t & object, const data_t & default_object) : _object(object), _default_object(default_object) {}
    };
    
    template <class data_t>
    class try_read
    {
      friend class XmlReader;

      data_t & _object;

    public:
      try_read(data_t & object) : _object(object){}
    };


  class XmlNoTagException : public Exception
    {
    public:
      XmlNoTagException(std::string msg = std::string("XmlNoTagException!")) : Exception(msg) {}}
    ;

  private:
    xmlDocPtr _doc;
    xmlXPathContextPtr _xpathCtx;

    std::vector<stream_command> _current_path;
    std::string _current_attribute;
    bool _attribute_active;

    void parse_element(const std::string & path_expression, std::string & result) const
      throw (XmlNoTagException);
    
    void parse_attribute(const std::string & attribute, std::string & result) const
      throw (XmlNoTagException);

    size_t evaluate_x_path(const std::string & path_expr, xmlNodeSetPtr & node_set_ptr) const;

    void compute_current_path(std::string & path) const;

    size_t compute_n_elements(const std::string & path_expr) const;

    template<size_t N, class data_t>
    void string_2_fixed_vector(const std::string & str, ublas::fixed_vector<data_t, N> & v)
    {
      std::istringstream in(str);
      char buffer[5];

      in.getline(buffer, 5, '(');

      for(std::size_t i = 0; i < N - 1; ++i)
      {
        v(i) = data_t(float_t(0));
        in >> v(i);
        in.getline(buffer, 5, ',');
      }

      v(N - 1) = data_t(float_t(0));
      in >> v(N - 1);
    }
    
    template <class data_t>
    XmlReader &  read_integral_type_value(data_t & value)
    {
      std::string temp;
  
      *this >> temp;
  
      try
      {
        value = boost::lexical_cast<data_t>(temp);
      }
      catch(boost::bad_lexical_cast & e)
      {
        throw Exception("Exception: lexical cast of '" + temp + "' failed in XmlReader::read_integral_type_value().");
      }
  
      return *this;
    }
    
    template <class data_t>
    XmlReader & read_integral_type_vector(std::vector<data_t> & vector)
    {
      std::string path;
      size_t n_elements;
  
      compute_current_path(path);
      n_elements = compute_n_elements(path);
      vector.resize(n_elements);
  
      for(size_t i = 0; i < n_elements; ++i)
      {
        *this >> element(i);
        *this >> vector[i];
        *this >> end_element;
      }
      
      *this >> end_element;
  
      return *this;
    }

  public:
    static const stream_command end_element;

    XmlReader(const std::string & xml_file_name, const std::string & root_element);

    ~XmlReader();

    XmlReader & operator>>(const stream_command & command);

    template<size_t N, class data_t>
    XmlReader & operator>>(ublas::fixed_vector<data_t, N> & value)
    {
      std::string temp;

      (*this) >> temp;

      string_2_fixed_vector(temp, value);

      return *this;
    }

    template<size_t N, class data_t>
    XmlReader & operator>>(std::vector< ublas::fixed_vector<data_t, N> > & vector)
    {
      std::string path;
      size_t n_elements;

      compute_current_path(path);
      n_elements = compute_n_elements(path);
      vector.resize(n_elements);

      for(size_t i = 0; i < n_elements; ++i)
      {
        *this >> element(i);
        *this >> vector[i];
        *this >> end_element;
      }
      
      *this >> end_element;

      return *this;
    }
    
    XmlReader & operator>>(std::vector<float_t> & vector);
    
    XmlReader & operator>>(float_t & value);
    
    XmlReader & operator>>(size_t & value);
    
    XmlReader & operator>>(int & value);
    
    XmlReader & operator>>(bool & value);
    
    XmlReader & operator>>(std::string & string);
    
    XmlReader & operator>>(std::vector<std::string> & vector);

    template<class data_t>
    XmlReader & operator>>(const default_value<data_t> & command)
    {
      try { *this >> command._object; }
      catch (XmlNoTagException & exception) { command._object = command._default_object; }

      return *this;
    }

    template<class data_t>
    XmlReader & operator>>(const try_read<data_t> & command)
    {
      try { *this >> command._object; }
      catch (XmlNoTagException & exception) { }

      return *this;
    }
    
    template<class data_t>
    XmlReader & operator>>(std::vector<data_t> & vector)
    {
      xml_handler<data_t> handler;
      
      std::string path;
      size_t n_elements;
      
      *this >> element(handler.element_name);

      compute_current_path(path);
      n_elements = compute_n_elements(path);
      vector.resize(n_elements);

      for(size_t i = 0; i < n_elements; ++i)
      {
        *this >> element(i);
        handler.read_object(*this, vector[i]);
        *this >> end_element;
      }

      *this >> end_element;

      return *this;
    }
    
    template<class data_t>
    XmlReader & operator>>(std::vector< boost::shared_ptr<data_t> > & vector)
    {
      xml_handler<data_t> handler;
      
      std::string path;
      size_t n_elements;
      
      *this >> element(handler.element_name);

      compute_current_path(path);
      n_elements = compute_n_elements(path);
      vector.resize(n_elements);
      for(size_t i = 0; i < n_elements; ++i)
      {
        try
        {
          vector[i].reset(new data_t);
        }
        catch(std::bad_alloc & e)
        {
          n_elements = 0;
          vector.resize(n_elements);
        }
      }

      for(size_t i = 0; i < n_elements; ++i)
      {
        *this >> element(i);
        handler.read_object(*this, *vector[i]);
        *this >> end_element;
      }

      *this >> end_element;

      return *this;
    }
    
    template<class data_t>
    XmlReader & operator>>(data_t & object)
    {
      xml_handler<data_t> handler;
      bool xml_exception_thrown = false;
      XmlReader::XmlNoTagException exception;
      
      *this >> element(handler.element_name);
      
      try
      {
        handler.read_object(*this, object);
      }
      catch(XmlReader::XmlNoTagException & e)
      {
        xml_exception_thrown = true;
        exception = e;
      }
      
      *this >> end_element;
      
      if(xml_exception_thrown)
        throw exception;

      return *this;
    }

    size_t n_elements() const;

    size_t n_child_elements() const;

    std::string current_element_name() const;
  };
}

#endif

---