XMLElements.h

Go to the documentation of this file.

//==========================================================================
//  AIDA Detector description implementation 
//--------------------------------------------------------------------------
// Copyright (C) Organisation europeenne pour la Recherche nucleaire (CERN)
// All rights reserved.
//
// For the licensing terms see $DD4hepINSTALL/LICENSE.
// For the list of contributors see $DD4hepINSTALL/doc/CREDITS.
//
// Author     : M.Frank
//
//==========================================================================
#ifndef XML_XMLELEMENTS_H
#define XML_XMLELEMENTS_H
 
// C/C++ include files
#include <cmath>
#include <string>
#include <vector>
#include <stdexcept>
 
// Framework include files
#include <XML/config.h>
 
#ifndef RAD_2_DEGREE
#define RAD_2_DEGREE 57.295779513082320876798154814105
#endif
#ifndef M_PI
#define M_PI 3.14159265358979323846
#endif
 
namespace dd4hep {
 
  namespace xml {
 
    typedef const XmlAttr* Attribute;
 
 
    class XmlString {
    public:
      static XmlChar* replicate(const XmlChar* c);
      static XmlChar* transcode(const char* c);
      static void release(char** p);
      static size_t length(const char* s);
#ifndef __TIXML__
      static size_t length(const XmlChar* s);
      static char* transcode(const XmlChar* c);
      static void release(XmlChar** p);
#endif
    };
 
#ifdef __TIXML__
 
    class XmlException {
    public:
      std::string msg;
      XmlException() : msg() {}
      XmlException(const std::string& m) : msg(m) {}
      XmlException(const XmlException& e) : msg(e.msg) {}
      virtual ~XmlException() {}
      XmlException& operator=(const XmlException& c) {
        if ( &c != this ) msg = c.msg;
        return *this;
      }
    };
#endif
 
    typedef const std::string& CSTR;
 
    void dumpTree(XmlDocument* doc);
 
    int set_float_precision(int precision);
    int get_float_precision();
 
    std::string _toString(const Attribute attr);
    std::string _toString(const XmlChar *toTranscode);
    std::string _toString(const char* s);
    std::string _toString(const std::string& s);
    std::string _toString(unsigned long i, const char* fmt = "%lu");
    std::string _toString(unsigned int i, const char* fmt = "%u");
    std::string _toString(int i, const char* fmt = "%d");
    std::string _toString(long i, const char* fmt = "%ld");
    std::string _toString(float d, const char* fmt = "%.17e");
    std::string _toString(double d, const char* fmt = "%.17e");
    std::string _ptrToString(const void* p, const char* fmt = "%p");
    template <typename T> std::string _toString(const T* p, const char* fmt = "%p")
    {      return _ptrToString((void*)p,fmt);       }
 
    void _toDictionary(const XmlChar* name, const XmlChar* value);
    template <typename T> void _toDictionary(const XmlChar* name, T value);
 
    void _toDictionary(const XmlChar* name, float  value);
    void _toDictionary(const XmlChar* name, double value);
 
    bool _toBool(const XmlChar* value);
    int _toInt(const XmlChar* value);
    unsigned int _toUInt(const XmlChar* value);
    long _toLong(const XmlChar* value);
    unsigned long _toULong(const XmlChar* value);
    float _toFloat(const XmlChar* value);
    double _toDouble(const XmlChar* value);
 
    std::string getEnviron(const std::string& env);
    bool enableEnvironResolution(bool new_value);
    
 
    class Strng_t {
    public:
      XmlChar* m_xml;
#ifndef __TIXML__
      Strng_t(const XmlChar* c) {
        m_xml = XmlString::replicate(c);
      }
      Strng_t& operator=(const XmlChar* s);
#endif
      Strng_t(const char* c) {
        m_xml = XmlString::transcode(c);
      }
      Strng_t(const std::string& c) {
        m_xml = XmlString::transcode(c.c_str());
      }
      Strng_t(const Strng_t& c) {
        m_xml = XmlString::replicate(c.m_xml);
      }
      ~Strng_t() {
        if (m_xml)
          XmlString::release(&m_xml);
      }
      operator const XmlChar*() const {
        return m_xml;
      }
      const XmlChar* ptr() const {
        return m_xml;
      }
      size_t length()  const  {
        return XmlString::length(m_xml);
      }
      Strng_t& operator=(const char* s);
      Strng_t& operator=(const Strng_t& s);
      Strng_t& operator=(const std::string& s);
    };
 
    Strng_t operator+(const Strng_t& a, const char* b);
    Strng_t operator+(const Strng_t& a, const std::string& b);
    Strng_t operator+(const Strng_t& a, const Strng_t& b);
    Strng_t operator+(const char* a, const Strng_t& b);
    Strng_t operator+(const std::string& a, const Strng_t& b);
 
#ifndef __TIXML__
    Strng_t operator+(const Strng_t& a, const XmlChar* b);
    Strng_t operator+(const XmlChar* a, const Strng_t& b);
    Strng_t operator+(const XmlChar* a, const std::string& b);
    Strng_t operator+(const std::string& a, const XmlChar* b);
 
#endif
 
 
    class Tag_t : public Strng_t {
    public:
      std::string m_str;
#ifndef __TIXML__
      Tag_t(const char* s)
        : Strng_t(s), m_str(s) {
      }
#endif
      Tag_t(const XmlChar* s)
        : Strng_t(s), m_str(_toString(s)) {
      }
      Tag_t(const Strng_t& s)
        : Strng_t(s), m_str(_toString(s)) {
      }
      Tag_t(const std::string& s)
        : Strng_t(s), m_str(s) {
      }
      Tag_t(const std::string& v, const std::string& s, void (*register_func)(const std::string&, Tag_t*))
        : Strng_t(s), m_str(s) {
        register_func(v, this);
      }
      Tag_t(const Tag_t& c)
        : Strng_t(c), m_str(c.m_str) {
      }
      ~Tag_t() {
      }
 
      Tag_t& operator=(const char* s);
      Tag_t& operator=(const Tag_t& s);
      Tag_t& operator=(const Strng_t& s);
      Tag_t& operator=(const std::string& s);
 
      operator const std::string&() const {
        return m_str;
      }
      const std::string& str() const {
        return m_str;
      }
      const char* c_str() const {
        return m_str.c_str();
      }
    };
 
    Tag_t operator+(const Tag_t& a, const char* b);
    Tag_t operator+(const char* a, const Tag_t& b);
    Tag_t operator+(const Tag_t& a, const XmlChar* b);
    Tag_t operator+(const Tag_t& a, const Strng_t& b);
    Tag_t operator+(const Tag_t& a, const std::string& b);
    inline bool operator==(const std::string& c, const Tag_t& b) {
      return c == b.m_str;
    }
 
    std::string _toString(const Strng_t& s);
    std::string _toString(const Tag_t& s);
    void _toDictionary(const XmlChar* name, const Strng_t& s);
    void _toDictionary(const XmlChar* name, const Tag_t& t);
 
 
    class NodeList {
    public:
      Tag_t m_tag;
      XmlElement* m_node;
      mutable XmlElement* m_ptr;
 
      NodeList(const NodeList& l);
      NodeList(XmlElement* frst, const XmlChar* t);
      ~NodeList();
      XmlElement* reset();
      XmlElement* next() const;
      XmlElement* previous() const;
      NodeList& operator=(const NodeList& l);
    };
 
 
    class Handle_t {
    public:
      // Abbreviation for internal use
      typedef XmlElement* Elt_t;
 
      mutable Elt_t m_node;
 
      Handle_t(Elt_t e = 0)
        : m_node(e) {
      }
      Elt_t operator->() const {
        return m_node;
      }
      operator Elt_t() const {
        return m_node;
      }
      Elt_t ptr() const {
        return m_node;
      }
      Handle_t clone(XmlDocument* new_doc) const;
 
      const XmlChar* rawTag() const;
      const XmlChar* rawText() const;
      const XmlChar* rawValue() const;
      std::string tag() const {
        return _toString(rawTag());
      }
      std::string text() const {
        return _toString(rawText());
      }
      std::string value() const {
        return _toString(rawValue());
      }
      void setValue(const XmlChar* text) const;
      void setValue(const std::string& text) const;
      void setText(const XmlChar* text) const;
      void setText(const std::string& text) const;
 
      /*** DOM Attribute handling
       */
      const XmlChar* attr_name(const Attribute attr) const;
      const XmlChar* attr_value(const Attribute attr) const;
      const XmlChar* attr_value(const XmlChar* attr) const;
      const XmlChar* attr_value_nothrow(const XmlChar* attr) const;
 
      Attribute attr_ptr(const XmlChar* attr) const;
      Attribute attr_nothrow(const XmlChar* tag) const;
      bool hasAttr(const XmlChar* t) const;
      std::vector<Attribute> attributes() const;
      template <class T> T attr(const Attribute a) const {
        return this->attr<T>(this->attr_name(a));
      }
      void removeAttrs() const;
      void setAttrs(Handle_t e) const;
      template <class T> T attr(const XmlChar* name) const;
      template <class T> T attr(const XmlChar* name, T default_value) const;
 
      Attribute setAttr(const XmlChar* t, const XmlChar* v) const;
      Attribute setAttr(const XmlChar* t, const Attribute v) const;
      Attribute setAttr(const XmlChar* t, int val) const;
      Attribute setAttr(const XmlChar* t, bool val) const;
      Attribute setAttr(const XmlChar* t, float val) const;
      Attribute setAttr(const XmlChar* t, double val) const;
      Attribute setAttr(const XmlChar* t, const std::string& val) const;
#ifndef __TIXML__
      bool hasAttr(const char* t) const {
        return hasAttr(Strng_t(t));
      }
      template <class T> T attr(const char* name) const {
        return this->attr<T>(Strng_t(name));
      }
      template <class T> T attr(const char* name, const T& default_value) const {
        Strng_t tag(name);
        return this->hasAttr(tag) ? this->attr<T>(tag) : default_value;
      }
      Attribute setAttr(const XmlChar* t, const char* v) const;
#endif
 
      Handle_t setRef(const XmlChar* tag, const XmlChar* ref);
      Handle_t setRef(const XmlChar* tag, const std::string& ref);
 
      /*** DOM Element child handling
       */
      bool hasChild(const XmlChar* tag) const;
      Handle_t child(const XmlChar* tag, bool throw_exception = true) const;
      NodeList children(const XmlChar* tag) const;
      size_t numChildren(const XmlChar* tag, bool throw_exception) const;
      Handle_t remove(Handle_t e) const;
      void removeChildren(const XmlChar* tag) const;
      void append(Handle_t e) const;
      Handle_t parent() const;
      unsigned int checksum(unsigned int param, unsigned int (fcn)(unsigned int param, const XmlChar*, size_t)=0) const;
    };
 
#define INLINE inline
    typedef const XmlChar* cpXmlChar;
 
    template <> INLINE Attribute Handle_t::attr<Attribute>(const XmlChar* tag_value) const {
      return attr_ptr(tag_value);
    }
 
    template <> INLINE cpXmlChar Handle_t::attr<cpXmlChar>(const XmlChar* tag_value) const {
      return attr_value(tag_value);
    }
 
    template <> INLINE bool Handle_t::attr<bool>(const XmlChar* tag_value) const {
      return _toBool(attr_value(tag_value));
    }
 
    template <> INLINE int Handle_t::attr<int>(const XmlChar* tag_value) const {
      return _toInt(attr_value(tag_value));
    }
    
    template <> INLINE unsigned int Handle_t::attr<unsigned int>(const XmlChar* tag_value) const {
      return _toUInt(attr_value(tag_value));
    }
    
    template <> INLINE long Handle_t::attr<long>(const XmlChar* tag_value) const {
      return _toLong(attr_value(tag_value));
    }
 
    template <> INLINE unsigned long Handle_t::attr<unsigned long>(const XmlChar* tag_value) const {
      return _toULong(attr_value(tag_value));
    }
 
    template <> INLINE float Handle_t::attr<float>(const XmlChar* tag_value) const {
      return _toFloat(attr_value(tag_value));
    }
 
    template <> INLINE double Handle_t::attr<double>(const XmlChar* tag_value) const {
      return _toDouble(attr_value(tag_value));
    }
 
    template <> INLINE std::string Handle_t::attr<std::string>(const XmlChar* tag_value) const {
      return _toString(attr_value(tag_value));
    }
 
    template <> INLINE Attribute Handle_t::attr<Attribute>(const XmlChar* tag_value, Attribute default_value) const {
      Attribute a = attr_nothrow(tag_value);
      return a ? a : std::move(default_value);
    }
 
    template <> INLINE bool Handle_t::attr<bool>(const XmlChar* tag_value, bool default_value) const {
      Attribute a = attr_nothrow(tag_value);
      return a ? _toBool(attr_value(a)) : default_value;
    }
 
    template <> INLINE int Handle_t::attr<int>(const XmlChar* tag_value, int default_value) const {
      Attribute a = attr_nothrow(tag_value);
      return a ? _toInt(attr_value(a)) : default_value;
    }
    
    template <> INLINE unsigned int Handle_t::attr<unsigned int>(const XmlChar* tag_value, unsigned int default_value) const {
      Attribute a = attr_nothrow(tag_value);
      return a ? _toUInt(attr_value(a)) : default_value;
    }
    
    template <> INLINE long Handle_t::attr<long>(const XmlChar* tag_value, long default_value) const {
      Attribute a = attr_nothrow(tag_value);
      return a ? _toLong(attr_value(a)) : default_value;
    }
 
    template <> INLINE unsigned long Handle_t::attr<unsigned long>(const XmlChar* tag_value, unsigned long default_value) const {
      Attribute a = attr_nothrow(tag_value);
      return a ? _toULong(attr_value(a)) : default_value;
    }
 
    template <> INLINE float Handle_t::attr<float>(const XmlChar* tag_value, float default_value) const {
      Attribute a = attr_nothrow(tag_value);
      return a ? _toFloat(attr_value(a)) : default_value;
    }
 
    template <> INLINE double Handle_t::attr<double>(const XmlChar* tag_value, double default_value) const {
      Attribute a = attr_nothrow(tag_value);
      return a ? _toDouble(attr_value(a)) : default_value;
    }
 
    template <> INLINE std::string Handle_t::attr<std::string>(const XmlChar* tag_value, std::string default_value) const {
      Attribute a = attr_nothrow(tag_value);
      return a ? _toString(attr_value(a)) : std::move(default_value);
    }
 
#if 0
    template<> INLINE bool Handle_t::attr<bool>(const Attribute tag_value) const
    { return _toBool(attr_value(tag_value));}
 
    template<> INLINE int Handle_t::attr<int>(const Attribute tag_value) const
    { return _toInt(attr_value(tag_value));}
 
    template<> INLINE float Handle_t::attr<float>(const Attribute tag_value) const
    { return _toFloat(attr_value(tag_value));}
 
    template<> INLINE double Handle_t::attr<double>(const Attribute tag_value) const
    { return _toDouble(attr_value(tag_value));}
 
    template<> INLINE std::string Handle_t::attr<std::string>(const Attribute tag_value) const
    { return _toString(attr_value(tag_value));}
#endif
 
 
    class Collection_t : public Handle_t {
    public:
      NodeList m_children;
#ifndef __TIXML__
      Collection_t(Handle_t node, const XmlChar* tag);
#endif
      Collection_t(Handle_t node, const char* tag);
      Collection_t(NodeList children);
      Collection_t& reset();
      size_t size() const;
      void operator++() const;
      void operator++(int) const;
      void operator--() const;
      void operator--(int) const;
      Elt_t current() const {
        return m_node;
      }
      void throw_loop_exception(const std::exception& e) const;
      template <class T> void for_each(T oper) const {
        try {
          for (const Collection_t& c = *this; c; ++c)
            oper(*this);
        }
        catch (const std::exception& e) {
          throw_loop_exception(e);
        }
      }
      template <class T> void for_each(const XmlChar* tag_name, T oper) const {
        try {
          for (const Collection_t& c = *this; c; ++c)
            Collection_t(c.m_node, tag_name).for_each(oper);
        }
        catch (const std::exception& e) {
          throw_loop_exception(e);
        }
      }
    };
 
 
    class Document {
    public:
      typedef XmlDocument* DOC;
      DOC m_doc;
 
      Document() : m_doc(0) {}
      Document(DOC d) : m_doc(d) {}
      Document(const Document& d) = default;
      Document& operator=(const Document& d) = default;
      ~Document() = default;
      operator DOC() const       {        return m_doc;      }
      DOC operator->() const     {        return m_doc;      }
      DOC ptr() const            {        return m_doc;      }
 
      Handle_t root() const;
      Handle_t createElt(const XmlChar* tag) const;
      Handle_t clone(Handle_t source) const;
      std::string uri() const;
    };
 
 
    class DocumentHolder : public Document {
    public:
      DocumentHolder() = default;
      DocumentHolder(const DocumentHolder& copy) = delete;
      DocumentHolder(DOC d) : Document(d) { }
      DocumentHolder& operator=(const DocumentHolder& copy) = delete;
      DocumentHolder& assign(DOC d);
      virtual ~DocumentHolder();
    };
 
 
    class Element {
    public:
      typedef Handle_t::Elt_t Elt_t;
 
      Handle_t m_element;
 
      Element(const Handle_t& e) : m_element(e)          {      }
      Element(const Element& e) : m_element(e.m_element) {      }
      Element(const Document& document, const XmlChar* type);
      Document document() const;
 
      operator bool() const {
        return 0 != m_element.ptr();
      }
      bool operator!() const {
        return 0 == m_element.ptr();
      }
      Element& operator=(const Element& c)  {
        m_element = c.m_element;
        return *this;
      }
      Element& operator=(Handle_t handle)  {
        m_element = handle;
        return *this;
      }
      operator Handle_t() const {
        return m_element;
      }
      operator Elt_t() const {
        return m_element;
      }
      Elt_t ptr() const {
        return m_element;
      }
      Handle_t parent()  const   {
        return m_element.parent();
      }
      Elt_t parentElement()  const;
      std::string tag() const {
        return m_element.tag();
      }
      const XmlChar* tagName() const {
        return m_element.rawTag();
      }
      std::string text() const {
        return m_element.text();
      }
      void text(const std::string value) const {
        return m_element.setText(value);
      }
      void append(Handle_t handle) const {
        m_element.append(handle);
      }
      Handle_t clone(const Document& new_doc) const {
        return new_doc.clone(m_element);
      }
      bool hasAttr(const XmlChar* name) const {
        return m_element.hasAttr(name);
      }
      template <class T> T attr(const XmlAttr* att) const {
        return m_element.attr<T>(att);
      }
      template <class T> T attr(const XmlChar* tag_value) const {
        return m_element.attr<T>(tag_value);
      }
      template <class T> T attr(const XmlChar* tag_value, T default_value) const {
        return m_element.attr<T>(tag_value, default_value);
      }
#ifndef __TIXML__
      template <class T> T attr(const char* name) const {
        return this->attr<T>(Strng_t(name));
      }
      template <class T> T attr(const char* name, T default_value) const {
        return this->attr<T>(Strng_t(name), default_value);
      }
#endif
      const XmlChar* attr_name(const Attribute a) const {
        return m_element.attr_name(a);
      }
      const XmlChar* attr_value(const Attribute a) const {
        return m_element.attr_value(a);
      }
      size_t numChildren(const XmlChar* tag_value, bool exc = true) const {
        return m_element.numChildren(tag_value, exc);
      }
      void setAttrs(Handle_t e) const {
        return m_element.setAttrs(e);
      }
      void removeAttrs() const {
        m_element.removeAttrs();
      }
      std::vector<Attribute> attributes() const {
        return m_element.attributes();
      }
      Attribute getAttr(const XmlChar* name) const;
      template <class T>
      Attribute setAttr(const XmlChar* nam, const T& val) const {
        return m_element.setAttr(nam, val);
      }
      template <class T> void setValue(const T& val) const {
        m_element.setValue(val);
      }
      Handle_t clone(Handle_t h) const;
      Handle_t addChild(const XmlChar* tag) const;
      Handle_t setChild(const XmlChar* tag) const;
      Handle_t child(const Strng_t& tag_value, bool except = true) const {
        return m_element.child(tag_value, except);
      }
      Handle_t remove(Handle_t node) const {
        return m_element.remove(node);
      }
      bool hasChild(const XmlChar* tag_value) const {
        return m_element.hasChild(tag_value);
      }
      Attribute setRef(const XmlChar* tag, const XmlChar* refname) const;
      Attribute setRef(const XmlChar* tag, const std::string& refname) const;
      const XmlChar* getRef(const XmlChar* tag) const;
#ifndef __TIXML__
      void addComment(const XmlChar* text) const;
#endif
      void addComment(const char* text) const;
      void addComment(const std::string& text_value) const;
    };
 
 
    class RefElement : public Element {
    public:
      Attribute m_name;
      RefElement(const Handle_t& e);
      RefElement(const RefElement& e);
      RefElement(const Document& d, const XmlChar* type, const XmlChar* name);
      RefElement& operator=(const RefElement& e);
      const XmlChar* name() const;
      const XmlChar* refName() const;
      void setName(const XmlChar* new_name);
    };
 
#undef INLINE
 
    class DocumentHandler;
 
    void dump_tree(Handle_t elt);
    void dump_tree(Handle_t elt, std::ostream& os);
    void dump_tree(Document doc);
    void dump_tree(Document doc, std::ostream& os);
 
  }
} /* End namespace dd4hep   */
#endif // XML_XMLELEMENTS_H