Elements.cpp

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
//
//==========================================================================
 
// Framework include files
#include <JSON/Printout.h>
#include <JSON/Elements.h>
 
// C/C++ include files
#include <iostream>
#include <stdexcept>
#include <cstdio>
#include <map>
 
using namespace dd4hep::json;
static const size_t INVALID_NODE = ~0U;
 
// Forward declarations
namespace dd4hep {
  std::pair<int, double> _toInteger(const std::string& value);
  std::pair<int, double> _toFloatingPoint(const std::string& value);
  void   _toDictionary(const std::string& name, const std::string& value, const std::string& typ);
  std::string _getEnviron(const std::string& env);
}
// Static storage
namespace {
  std::string _checkEnviron(const std::string& env)  {
    std::string r = dd4hep::_getEnviron(env);
    return r.empty() ? env : r;
  }
}
 
namespace {
 
  // This should ensure we are not passing temporaries of std::string and then
  // returning the "const char*" content calling .c_str()
  const ptree::data_type& value_data(const ptree& entry)  {
    return entry.data();
  }
 
  JsonElement* node_first(JsonElement* e, const char* tag) {
    if ( e )  {
      std::string t(tag);
      if ( t == "*" )  {
        ptree::iterator i = e->second.begin();
        return i != e->second.end() ? &(*i) : 0;
      }
      ptree::assoc_iterator i = e->second.find(t);
      return i != e->second.not_found() ? &(*i) : 0;
    }
    return 0;
  }
 
  size_t node_count(JsonElement* e, const std::string& t) {
    return e ? (t=="*" ? e->second.size() : e->second.count(t)) : 0;
  }
 
  Attribute attribute_node(JsonElement* n, const char* t)  {
    if ( n )  {
      auto i = n->second.find(t);
      return i != n->second.not_found() ? &(*i) : 0;
    }
    return 0;
  }
 
  const char* attribute_value(Attribute a) {
    return value_data(a->second).c_str();
  }
}
 
std::string dd4hep::json::_toString(Attribute attr) {
  if (attr)
    return _toString(attribute_value(attr));
  return "";
}
 
template <typename T> static inline std::string __to_string(T value, const char* fmt) {
  char text[128];
  ::snprintf(text, sizeof(text), fmt, value);
  return text;
}
 
std::string dd4hep::json::_toString(const char* s) {
  if ( !s || *s == 0 ) return "";
  else if ( !(*s == '$' && *(s+1) == '{') ) return s;
  return _checkEnviron(s);
}
 
std::string dd4hep::json::_toString(const std::string& s) {
  if ( s.length() < 3 || s[0] != '$' ) return s;
  else if ( !(s[0] == '$' && s[1] == '{') ) return s;
  return _checkEnviron(s);
}
 
std::string dd4hep::json::_toString(unsigned long v, const char* fmt) {
  return __to_string(v, fmt);
}
 
std::string dd4hep::json::_toString(unsigned int v, const char* fmt) {
  return __to_string(v, fmt);
}
 
std::string dd4hep::json::_toString(int v, const char* fmt) {
  return __to_string(v, fmt);
}
 
std::string dd4hep::json::_toString(long v, const char* fmt)   {
  return __to_string(v, fmt);
}
 
std::string dd4hep::json::_toString(float v, const char* fmt) {
  return __to_string(v, fmt);
}
 
std::string dd4hep::json::_toString(double v, const char* fmt) {
  return __to_string(v, fmt);
}
 
std::string dd4hep::json::_ptrToString(const void* v, const char* fmt) {
  return __to_string(v, fmt);
}
 
long dd4hep::json::_toLong(const char* value) {
  return value ? (long)dd4hep::_toInteger(_toString(value)).second : -1L;
}
 
int dd4hep::json::_toInt(const char* value) {
  return value ? (int)dd4hep::_toInteger(_toString(value)).second : -1;
}
 
bool dd4hep::json::_toBool(const char* value) {
  if (value) {
    std::string s = _toString(value);
    return s == "true";
  }
  return false;
}
 
float dd4hep::json::_toFloat(const char* value) {
  return (float)(value ? dd4hep::_toFloatingPoint(_toString(value)).second : 0.0);
}
 
double dd4hep::json::_toDouble(const char* value) {
  return value ? dd4hep::_toFloatingPoint(_toString(value)).second : 0.0;
}
 
void dd4hep::json::_toDictionary(const char* name, const char* value) {
  dd4hep::_toDictionary(name, value, "number");
}
 
template <typename T> void dd4hep::json::_toDictionary(const char* name, T value)   {
  dd4hep::_toDictionary(name, _toString(value), "number");
}
 
template void dd4hep::json::_toDictionary(const char* name, const std::string& value);
template void dd4hep::json::_toDictionary(const char* name, unsigned long value);
template void dd4hep::json::_toDictionary(const char* name, unsigned int value);
template void dd4hep::json::_toDictionary(const char* name, unsigned short value);
template void dd4hep::json::_toDictionary(const char* name, int value);
template void dd4hep::json::_toDictionary(const char* name, long value);
template void dd4hep::json::_toDictionary(const char* name, short value);
template void dd4hep::json::_toDictionary(const char* name, float value);
template void dd4hep::json::_toDictionary(const char* name, double value);
 
std::string dd4hep::json::getEnviron(const std::string& env)   {
  return dd4hep::_getEnviron(env);
}
 
NodeList::NodeList(const NodeList& copy)
  : m_tag(copy.m_tag), m_node(copy.m_node)
{
  reset();
}
 
NodeList::NodeList(JsonElement* node, const std::string& tag_value)
  : m_tag(tag_value), m_node(node)
{
  reset();
}
 
NodeList::~NodeList() {
}
 
JsonElement* NodeList::reset() {
  if ( m_tag == "*" )
    m_ptr = std::make_pair(m_node->second.ordered_begin(), m_node->second.not_found());
  else
    m_ptr = m_node->second.equal_range(m_tag);
  if ( m_ptr.first != m_ptr.second )
    return &(*m_ptr.first);
  return 0;
}
 
JsonElement* NodeList::next() const {
  if ( m_ptr.first != m_ptr.second )  {
    m_ptr.first = ++m_ptr.first;
    if ( m_ptr.first != m_ptr.second ) return &(*m_ptr.first);
  }
  return 0;
}
 
JsonElement* NodeList::previous() const {
  if ( m_ptr.first != m_ptr.second )  {
    m_ptr.first = --m_ptr.first;
    if ( m_ptr.first != m_ptr.second ) return &(*m_ptr.first);
  }
  return 0;
}
 
NodeList& NodeList::operator=(const NodeList& l) {
  if ( this != &l ) {
    m_tag  = l.m_tag;
    m_node = l.m_node;
    reset();
  }
  return *this;
}
 
const char* Handle_t::rawTag() const {
  return m_node->first.c_str();
}
 
const char* Handle_t::rawText() const {
  return value_data(m_node->second).c_str();
}
 
const char* Handle_t::rawValue() const {
  return value_data(m_node->second).c_str();
}
 
Attribute Handle_t::attr_nothrow(const char* tag_value) const {
  return attribute_node(m_node, tag_value);
}
 
bool Handle_t::hasAttr(const char* tag_value) const {
  return m_node && 0 != node_first(m_node, tag_value);
}
 
std::vector<Attribute> Handle_t::attributes() const {
  std::vector < Attribute > attrs;
  if (m_node) {
    for(ptree::iterator i=m_node->second.begin(); i!=m_node->second.end(); ++i)  {
      Attribute a = &(*i);
      attrs.emplace_back(a);
    }
  }
  return attrs;
}
 
size_t Handle_t::numChildren(const char* t, bool throw_exception) const {
  size_t n = node_count(m_node, t);
  if (n == INVALID_NODE && !throw_exception)
    return 0;
  else if (n != INVALID_NODE)
    return n;
  std::string msg = "Handle_t::numChildren: ";
  if (m_node)
    msg += "Element [" + tag() + "] has no children of type '" + _toString(t) + "'";
  else
    msg += "Element [INVALID] has no children of type '" + _toString(t) + "'";
  throw std::runtime_error(msg);
}
 
Handle_t Handle_t::child(const char* t, bool throw_exception) const {
  Elt_t e = node_first(m_node, t);
  if (e || !throw_exception)
    return e;
  std::string msg = "Handle_t::child: ";
  if (m_node)
    msg += "Element [" + tag() + "] has no child of type '" + _toString(t) + "'";
  else
    msg += "Element [INVALID]. Cannot remove child of type: '" + _toString(t) + "'";
  throw std::runtime_error(msg);
}
 
NodeList Handle_t::children(const char* tag_value) const {
  return NodeList(m_node, tag_value);
}
 
bool Handle_t::hasChild(const char* tag_value) const {
  return node_first(m_node, tag_value) != 0;
}
 
Attribute Handle_t::attr_ptr(const char* t) const {
  Attribute a = attribute_node(m_node, t);
  if (0 != a)
    return a;
  std::string msg = "Handle_t::attr_ptr: ";
  if (m_node)
    msg += "Element [" + tag() + "] has no attribute of type '" + _toString(t) + "'";
  else
    msg += "Element [INVALID] has no attribute of type '" + _toString(t) + "'";
  throw std::runtime_error(msg);
}
 
const char* Handle_t::attr_name(const Attribute a) const {
  if (a) {
    return a->first.c_str();
  }
  throw std::runtime_error("Attempt to access invalid XML attribute object!");
}
 
const char* Handle_t::attr_value(const char* attr_tag) const {
  return attribute_value(attr_ptr(attr_tag));
}
 
const char* Handle_t::attr_value(const Attribute attr_val) const {
  return attribute_value(attr_val);
}
 
const char* Handle_t::attr_value_nothrow(const char* attr_tag) const {
  Attribute a = attr_nothrow(attr_tag);
  return a ? attribute_value(a) : 0;
}
 
 
Handle_t Document::root() const   {
  if ( m_doc )   {
    return m_doc;
  }
  throw std::runtime_error("Document::root: Invalid handle!");
}
 
DocumentHolder& DocumentHolder::assign(DOC d)   {
  if ( m_doc )   {
    printout(DEBUG,"DocumentHolder","+++ Release JSON document....");
    delete m_doc;
  }
  m_doc = d;
  return *this;
}
 
DocumentHolder::~DocumentHolder()   {
  assign(0);
}
 
Attribute Element::getAttr(const char* name) const {
  return m_element ? attribute_node(m_element, name) : 0;
}
 
Collection_t::Collection_t(Handle_t element, const char* tag_value)
  : m_children(element, tag_value) {
  m_node = m_children.reset();
}
 
Collection_t::Collection_t(NodeList node_list)
  : m_children(node_list) {
  m_node = m_children.reset();
}
 
Collection_t& Collection_t::reset() {
  m_node = m_children.reset();
  return *this;
}
 
size_t Collection_t::size() const {
  return Handle_t(m_children.m_node).numChildren(m_children.m_tag.c_str(), false);
}
 
void Collection_t::throw_loop_exception(const std::exception& e) const {
  if (m_node) {
    throw std::runtime_error(std::string(e.what()) + "\n" + "dd4hep: Error interpreting XML nodes of type <" + tag() + "/>");
  }
  throw std::runtime_error(std::string(e.what()) + "\n" + "dd4hep: Error interpreting collections XML nodes.");
}
 
void Collection_t::operator++() const {
  while (m_node) {
    m_node = m_children.next();
    if (m_node && m_node->second.size() > 0 )
      return;
  }
}
 
void Collection_t::operator--() const {
  while (m_node) {
    m_node = m_children.previous();
    if (m_node && m_node->second.size() > 0 )
      return;
  }
}
 
void Collection_t::operator++(int) const {
  ++(*this);
}
 
void Collection_t::operator--(int) const {
  --(*this);
}
 
void dd4hep::json::dumpTree(Handle_t elt)   {
  dumpTree(elt.ptr());
}
 
void dd4hep::json::dumpTree(Element elt)   {
  dumpTree(elt.ptr());
}
 
void dd4hep::json::dumpTree(const JsonElement* elt)   {
  struct Dump {
    void operator()(const JsonElement* e, const std::string& tag)   const  {
      std::string t = tag+"   ";
      printout(INFO,"DumpTree","+++ %s %s: %s",tag.c_str(), e->first.c_str(), e->second.data().c_str());
      for(auto i=e->second.begin(); i!=e->second.end(); ++i)
        (*this)(&(*i), t);
    }
  } _dmp;
  _dmp(elt," ");
}