Elements.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 JSON_ELEMENTS_H
#define JSON_ELEMENTS_H
 
// C/C++ include files
#include <cmath>
#include <string>
#include <vector>
#include <stdexcept>
 
// Framework include files
#include <JSON/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 json {
 
    typedef const JsonAttr* Attribute;
 
    std::string _toString(const Attribute attr);
    std::string _toString(const char *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);       }
 
    template <typename T> void _toDictionary(const char* name, T value);
    void _toDictionary(const char* name, const char* value);
    inline void _toDictionary(const std::string& name, const char* value)
    {  _toDictionary(name.c_str(), value);          }
    void _toDictionary(const char* name, float  value);
    void _toDictionary(const char* name, double value);
    std::string getEnviron(const std::string& env);
 
    bool   _toBool(const char* value);
    int    _toInt(const char* value);
    long   _toLong(const char* value);
    float  _toFloat(const char* value);
    double _toDouble(const char* value);
 
 
    class NodeList {
    public:
      typedef std::pair<JsonElement::second_type::assoc_iterator,JsonElement::second_type::assoc_iterator> iter_t;
      std::string    m_tag;
      JsonElement*   m_node;
      mutable iter_t m_ptr;
 
      NodeList(const NodeList& l);
      NodeList(JsonElement* frst, const std::string& tag);
      ~NodeList();
      JsonElement* reset();
      JsonElement* next() const;
      JsonElement* previous() const;
      NodeList& operator=(const NodeList& l);
    };
 
 
    class Handle_t {
    public:
      // Abbreviation for internal use
      typedef JsonElement* 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;                     }
      const char* rawTag() const;
      const char* rawText() const;
      const char* rawValue() const;
      std::string tag() const   {          return _toString(rawTag());      }
      std::string text() const  {          return _toString(rawText());     }
      std::string value() const {          return _toString(rawValue());    }
 
      /*** Attribute handling                                              */
      const char* attr_name(const Attribute attr) const;
      const char* attr_value(const Attribute attr) const;
      const char* attr_value(const char* attr) const;
      const char* attr_value_nothrow(const char* attr) const;
 
      Attribute attr_ptr(const char* attr) const;
      Attribute attr_nothrow(const char* tag) const;
      bool hasAttr(const char* t) const;
      std::vector<Attribute> attributes() const;
      template <class T> T attr(const Attribute a) const {
        return this->attr<T>(this->attr_name(a));
      }
      template <class T> T attr(const char* name) const;
 
      /*** DOM Element child handling                                     */
      bool hasChild(const char* tag) const;
      Handle_t child(const char* tag, bool throw_exception = true) const;
      NodeList children(const char* tag) const;
      size_t numChildren(const char* tag, bool throw_exception) const;
    };
 
#define INLINE inline
    template <> INLINE Attribute Handle_t::attr<Attribute>(const char* tag_value) const {
      return attr_ptr(tag_value);
    }
 
    template <> INLINE const char* Handle_t::attr<const char*>(const char* tag_value) const {
      return attr_value(tag_value);
    }
 
    template <> INLINE bool Handle_t::attr<bool>(const char* tag_value) const {
      return _toBool(attr_value(tag_value));
    }
 
    template <> INLINE int Handle_t::attr<int>(const char* tag_value) const {
      return _toInt(attr_value(tag_value));
    }
    
    template <> INLINE long Handle_t::attr<long>(const char* tag_value) const {
      return _toLong(attr_value(tag_value));
    }
 
    template <> INLINE float Handle_t::attr<float>(const char* tag_value) const {
      return _toFloat(attr_value(tag_value));
    }
 
    template <> INLINE double Handle_t::attr<double>(const char* tag_value) const {
      return _toDouble(attr_value(tag_value));
    }
 
    template <> INLINE std::string Handle_t::attr<std::string>(const char* tag_value) const {
      return _toString(attr_value(tag_value));
    }
 
 
    class Collection_t : public Handle_t {
    public:
      NodeList m_children;
      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 char* 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 JsonElement* DOC;
      DOC m_doc;
 
      Document(DOC d=0) : m_doc(d) {
      }
      operator DOC() const {
        return m_doc;
      }
      DOC operator->() const {
        return m_doc;
      }
      DOC ptr() const {
        return m_doc;
      }
      Handle_t root() const;
    };
 
 
    class DocumentHolder : public Document {
    public:
      DocumentHolder() : Document() {
      }
      DocumentHolder(DOC d) : Document(d) {
      }
      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& operator=(const Element& c)  {
        m_element = c.m_element;
        return *this;
      }
      Element& operator=(Handle_t handle)  {
        m_element = handle;
        return *this;
      }
      operator bool() const        {        return 0 != m_element.ptr();      }
      bool operator!() const       {        return 0 == m_element.ptr();      }
      operator Handle_t() const    {        return m_element;                 }
      operator Elt_t() const       {        return m_element;                 }
      Elt_t ptr() const            {        return m_element;                 }
      std::string tag() const      {        return m_element.tag();           }
      const char* tagName() const  {        return m_element.rawTag();        }
      std::string text() const     {        return m_element.text();          }
      bool hasAttr(const char* name) const {return m_element.hasAttr(name);   }
      template <class T> T attr(const char* tag_value) const
      {  return m_element.attr<T>(tag_value);                                 }
      const char* attr_name(const Attribute a) const
      {  return m_element.attr_name(a);                                       }
      const char* attr_value(const Attribute a) const
      {  return m_element.attr_value(a);                                      }
      size_t numChildren(const char* tag_value, bool exc = true) const
      {  return m_element.numChildren(tag_value, exc);                        }
      std::vector<Attribute> attributes() const
      {  return m_element.attributes();                                       }
      Attribute getAttr(const char* name) const;
      Handle_t child(const char* tag_value, bool except = true) const
      {  return m_element.child(tag_value, except);                           }
      bool hasChild(const char* tag_value) const
      {  return m_element.hasChild(tag_value);                                }
    };
 
    class DocumentHandler;    
#undef INLINE
    
    void dumpTree(Handle_t elt);
    void dumpTree(Element elt);
    void dumpTree(const JsonElement* elt);
 
  }       /* End namespace json              */
}         /* End namespace dd4hep            */
#endif // JSON_ELEMENTS_H