diff --git a/DDCond/include/DDCond/ConditionsTags.h b/DDCond/include/DDCond/ConditionsTags.h
index af15563c687505a49e4211a6da12a81561612801..5a5037b47c4f1fb17d60dd6d0e185f4f480ce1cf 100644
--- a/DDCond/include/DDCond/ConditionsTags.h
+++ b/DDCond/include/DDCond/ConditionsTags.h
@@ -38,14 +38,13 @@ namespace DD4hep {
UNICODE(open_transaction);
UNICODE(close_transaction);
- UNICODE(value);
- UNICODE(mapping);
- UNICODE(sequence);
- UNICODE(alignment);
-
UNICODE(iov);
UNICODE(iov_type);
UNICODE(manager);
+
+ UNICODE(mapping);
+ UNICODE(sequence);
+ UNICODE(alignment);
}
// User must ensure there are no clashes. If yes, then the clashing entry is unnecessary.
using namespace ::DD4hep::XML::Conditions;
diff --git a/DDCond/src/plugins/ConditionsPlugins.cpp b/DDCond/src/plugins/ConditionsPlugins.cpp
index 25a7128e9a84f199e714dc81cb3d66fefc2b637b..4e25dcdd5d15a6f751563cfd0d9ab1d2beead4a7 100644
--- a/DDCond/src/plugins/ConditionsPlugins.cpp
+++ b/DDCond/src/plugins/ConditionsPlugins.cpp
@@ -16,7 +16,9 @@
#include "DD4hep/LCDD.h"
#include "DD4hep/Printout.h"
#include "DD4hep/Conditions.h"
+#include "DD4hep/DetConditions.h"
#include "DD4hep/DetFactoryHelper.h"
+#include "DD4hep/ConditionsPrinter.h"
#include "DDCond/ConditionsManager.h"
#include "DDCond/ConditionsIOVPool.h"
@@ -27,10 +29,18 @@
using namespace std;
using namespace DD4hep;
using namespace DD4hep::Conditions;
+using Geometry::DetElement;
+using Geometry::PlacedVolume;
namespace {
- /// Plugin function:
- /// Install the alignment manager as an extension to the central LCDD object
+ /// Plugin function: Install the alignment manager as an extension to the central LCDD object
+ /**
+ * Factory: DD4hep_ConditionsManagerInstaller
+ *
+ * \author M.Frank
+ * \version 1.0
+ * \date 01/04/2016
+ */
int ddcond_install_cond_mgr (LCDD& lcdd, int argc, char** argv) {
Handle<ConditionsManagerObject> mgr(lcdd.extension<ConditionsManagerObject>(false));
if ( !mgr.isValid() ) {
@@ -54,13 +64,24 @@ DECLARE_APPLY(DD4hep_ConditionsManagerInstaller,ddcond_install_cond_mgr)
namespace {
+
+ /// Plugin function: Dump of all Conditions pool with or without conditions
+ /**
+ * Factory: DD4hep_ConditionsPoolDump: Dump pools only
+ * Factory: DD4hep_ConditionsDump: Dump pools and conditions
+ *
+ * \author M.Frank
+ * \version 1.0
+ * \date 01/04/2016
+ */
int ddcond_dump_conditions_functor(lcdd_t& lcdd, bool print_conditions, int argc, char** argv) {
typedef std::vector<const IOVType*> _T;
typedef ConditionsIOVPool::Elements _E;
typedef RangeConditions _R;
ConditionsManager manager = ConditionsManager::from(lcdd);
- Condition::Processor* printer = 0;
-
+ ConditionsPrinter default_printer("");
+ Condition::Processor* printer = &default_printer;
+
if ( argc > 0 ) {
printer = (Condition::Processor*) argv[0];
}
@@ -82,7 +103,9 @@ namespace {
cp->select_all(rc);
for(_R::const_iterator ic=rc.begin(); ic!=rc.end(); ++ic) {
if ( printer ) { (*printer)(*ic); }
- else { /* print_conditions<void>(rc); */ }
+ else {
+ /* print_conditions<void>(rc); */
+ }
}
}
}
@@ -106,42 +129,69 @@ namespace {
DECLARE_APPLY(DD4hep_ConditionsPoolDump,ddcond_dump_pools)
DECLARE_APPLY(DD4hep_ConditionsDump,ddcond_dump_conditions)
// ======================================================================================
-#if 0
namespace {
-
- int ddcond_assign_keys(LCDD& lcdd, int /* argc */, char** /* argv */) {
- typedef std::vector<const IOVType*> _T;
- typedef ConditionsIOVPool::Elements _E;
- typedef RangeConditions _R;
- ConditionsManager manager = ConditionsManager::from(lcdd);
-
- const _T types = manager.iovTypesUsed();
- for( _T::const_iterator i = types.begin(); i != types.end(); ++i ) {
- const IOVType* type = *i;
- if ( type ) {
- ConditionsIOVPool* pool = manager.iovPool(*type);
- if ( pool ) {
- const _E& e = pool->elements;
- for (_E::const_iterator j=e.begin(); j != e.end(); ++j) {
- _R rc;
- ConditionsPool* cp = (*j).second;
- cp->select_all(rc);
- for(_R::const_iterator ic=rc.begin(); ic!=rc.end(); ++ic) {
- Condition cond(*ic);
-
- }
+ /// Plugin function: Dump of all Conditions associated to the detector elements
+ /**
+ * Factory: DD4hep_DetElementConditionsDump
+ *
+ * \author M.Frank
+ * \version 1.0
+ * \date 01/04/2016
+ */
+ int ddcond_detelement_dump(LCDD& lcdd, int /* argc */, char** /* argv */) {
+ struct Actor {
+ ConditionsManager manager;
+ ConditionsPrinter printer;
+ dd4hep_ptr<UserPool> user_pool;
+ const IOVType* iov_type;
+
+ /// Standard constructor
+ Actor(ConditionsManager m) : manager(m) {
+ iov_type = manager.iovType("run");
+ IOV iov(iov_type);
+ iov.set(1500);
+ long num_updated = manager.prepare(iov, user_pool);
+ printout(INFO,"Conditions",
+ "+++ ConditionsUpdate: Updated %ld conditions of type %s.",
+ num_updated, iov_type ? iov_type->str().c_str() : "???");
+ user_pool->print("User pool");
+ }
+ /// Default destructor
+ ~Actor() {
+ manager.clean(iov_type, 20);
+ user_pool->clear();
+ user_pool.release();
+ }
+ /// Dump method.
+ long dump(DetElement de,int level) {
+ const DetElement::Children& children = de.children();
+ PlacedVolume place = de.placement();
+ char sens = place.volume().isSensitive() ? 'S' : ' ';
+ char fmt[128], tmp[32];
+ ::snprintf(tmp,sizeof(tmp),"%03d/",level+1);
+ ::snprintf(fmt,sizeof(fmt),"%03d %%-%ds %%s #Dau:%%d VolID:%%08X %%c",level+1,2*level+1);
+ printout(INFO,"DetectorDump",fmt,"",de.path().c_str(),int(children.size()),
+ (unsigned long)de.volumeID(), sens);
+ if ( de.hasConditions() ) {
+ DetConditions conds(de);
+ Container cont = conds.conditions();
+ printer.setName(string(tmp)+de.name());
+ for(const auto& k : cont->keys ) {
+ Condition c = cont.get(k.first,*(user_pool.get()));
+ (printer)(c);
}
}
+ for (const auto& c : de.children() )
+ dump(c.second,level+1);
+ return 1;
}
- }
- return 1;
+ };
+ return Actor(ConditionsManager::from(lcdd)).dump(lcdd.world(),0);
}
}
-
-DECLARE_APPLY(DD4hep_AssignConditionsKeys,ddcond_assign_keys)
-#endif
+DECLARE_APPLY(DD4hep_DetElementConditionsDump,ddcond_detelement_dump)
+
// ======================================================================================
-
namespace {
/// Plugin entry point.
static long ddcond_synchronize_conditions(lcdd_t& lcdd, int argc, char** argv) {
diff --git a/DDCond/src/plugins/ConditionsRepositoryParser.cpp b/DDCond/src/plugins/ConditionsRepositoryParser.cpp
index ab2fa8b329814f0a7e3c64b5633b846e5ffe82e1..e07a07e0464f9647c489203c748830d99895b612 100644
--- a/DDCond/src/plugins/ConditionsRepositoryParser.cpp
+++ b/DDCond/src/plugins/ConditionsRepositoryParser.cpp
@@ -125,7 +125,7 @@ namespace {
string typ = elt.hasAttr(_U(type)) ? elt.typeStr() : tag;
string nam = elt.hasAttr(_U(name)) ? elt.nameStr() : tag;
string add = XML::DocumentHandler::system_path(e);
- Condition cond(det.path()+"/"+nam, typ);
+ Condition cond(det.path()+"#"+nam, typ);
printout(INFO,"XMLConditions","++ Processing condition tag:%s name:%s type:%s [%s]",
tag.c_str(), nam.c_str(), typ.c_str(),
@@ -152,12 +152,14 @@ namespace {
string typ = type.empty() ? elt.typeStr() : type;
string val = elt.hasAttr(_U(value)) ? elt.valueStr() : elt.text();
Condition con = create_condition(det, e);
+ con->value = val;
OpaqueDataBinder::bind(bnd, con, typ, val);
return con;
}
}
namespace DD4hep {
+
/** Convert iov_type repository objects
*
* @author M.Frank
@@ -319,10 +321,24 @@ namespace DD4hep {
template <> void Converter<mapping>::operator()(xml_h e) const {
xml_comp_t elt(e);
ConversionArg* arg = _param<ConversionArg>();
- string typ = elt.typeStr();
+ string key_type = e.attr<string>(_U(key));
+ string val_type = e.attr<string>(_U(value));
Condition con = create_condition(arg->detector, e);
- string val = elt.hasAttr(_U(value)) ? elt.valueStr() : elt.text();
- OpaqueDataBinder::bind(VectorBinder(), con, typ, val);
+ OpaqueDataBlock& b = con->data;
+ MapBinder binder;
+
+ OpaqueDataBinder::bind_map(binder, b, key_type, val_type);
+ for(xml_coll_t i(e,_U(item)); i; ++i) {
+ // If explicit key, value data are present in attributes:
+ if ( i.hasAttr(_U(key)) && i.hasAttr(_U(value)) ) {
+ string key = i.attr<string>(_U(key));
+ string val = i.attr<string>(_U(value));
+ OpaqueDataBinder::insert_map(binder, b, key_type, key, val_type, val);
+ continue;
+ }
+ // Otherwise interprete the data directly from the data content
+ OpaqueDataBinder::insert_map(binder, b, key_type, val_type, i.text());
+ }
arg->manager.registerUnlocked(arg->pool, con);
}
@@ -403,7 +419,7 @@ namespace DD4hep {
XML::DocumentHolder doc(XML::DocumentHandler().load(e, e.attr_value(_U(ref))));
(*this)(doc.root());
}
- xml_coll_t(e,_UC(value)).for_each(Converter<value>(lcdd,param,optional));
+ xml_coll_t(e,_U(value)).for_each(Converter<value>(lcdd,param,optional));
xml_coll_t(e,_UC(mapping)).for_each(Converter<mapping>(lcdd,param,optional));
xml_coll_t(e,_UC(sequence)).for_each(Converter<sequence>(lcdd,param,optional));
xml_coll_t(e,_UC(alignment)).for_each(Converter<alignment>(lcdd,param,optional));
diff --git a/DDCore/include/DD4hep/ConditionsPrinter.h b/DDCore/include/DD4hep/ConditionsPrinter.h
new file mode 100644
index 0000000000000000000000000000000000000000..16d03146f0867a759e6afcd13e951f77c7b3e597
--- /dev/null
+++ b/DDCore/include/DD4hep/ConditionsPrinter.h
@@ -0,0 +1,56 @@
+//==========================================================================
+// AIDA Detector description implementation for LCD
+//--------------------------------------------------------------------------
+// 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 DD4HEP_DDCOND_CONDITIONSPRINTER_H
+#define DD4HEP_DDCOND_CONDITIONSPRINTER_H
+
+// Framework includes
+#include "DD4hep/Conditions.h"
+
+/// Namespace for the AIDA detector description toolkit
+namespace DD4hep {
+
+ /// Namespace for the AIDA detector description toolkit supporting XML utilities
+ namespace Conditions {
+
+ /// Generic Conditions data dumper.
+ /**
+ * \author M.Frank
+ * \version 1.0
+ * \date 31/03/2016
+ * \ingroup DD4HEP_DDDB
+ */
+ class ConditionsPrinter : public Condition::Processor {
+ public:
+ std::string name;
+ std::string prefix;
+ protected:
+ int m_flag;
+
+ public:
+ typedef Conditions::Condition Cond;
+
+ /// Initializing constructor
+ ConditionsPrinter(const std::string& prefix="",
+ int flag=Cond::NO_NAME|Cond::WITH_IOV|Cond::WITH_ADDRESS);
+ /// Set name for printouts
+ void setName(const std::string& value) { name = value; }
+ /// Set prefix for printouts
+ void setPrefix(const std::string& value) { prefix = value; }
+ /// Callback to output conditions information
+ virtual int operator()(Condition cond);
+ };
+
+ } /* End namespace Conditions */
+} /* End namespace DD4hep */
+
+#endif /* DD4HEP_DDCOND_CONDITIONSPRINTER_H */
diff --git a/DDCore/include/DD4hep/OpaqueData.h b/DDCore/include/DD4hep/OpaqueData.h
index 741f8c318bfd6e19583040f8016a6ed11bebfbe6..3944589818b76797a91e6a132330dbb61ef731d0 100644
--- a/DDCore/include/DD4hep/OpaqueData.h
+++ b/DDCore/include/DD4hep/OpaqueData.h
@@ -114,6 +114,9 @@ namespace DD4hep {
template <typename T> T& bind();
/// Bind data value [Equivalent to set(value)]
template <typename T> T& bind(const std::string& value);
+ /// Bind data value. Ugly, but some compilers otherwise do not recognize the function in templates
+ template <typename T> void bind(const T*);
+
/// Set data value
void assign(const void* ptr,const std::type_info& typ);
/// Bind grammar and assign value
diff --git a/DDCore/include/DD4hep/OpaqueDataBinder.h b/DDCore/include/DD4hep/OpaqueDataBinder.h
index dc5b02b77da0e1860eff852924072600b4ae7809..ea4779c2fa051d58282f7b737e969a954b6c2949 100644
--- a/DDCore/include/DD4hep/OpaqueDataBinder.h
+++ b/DDCore/include/DD4hep/OpaqueDataBinder.h
@@ -105,23 +105,27 @@ namespace DD4hep {
~OpaqueDataBinder() = default;
/// Binding function for scalar items. See the implementation function for the concrete instantiations
- template <typename BINDER, typename T> static
- bool bind(const BINDER& b, T& object, const std::string& typ, const std::string& val);
+ template <typename BINDER, typename OBJECT> static
+ bool bind(const BINDER& b, OBJECT& object, const std::string& typ, const std::string& val);
/// Binding function for sequences (unmapped STL containers)
- template <typename T> static
- bool bind_sequence(T& object, const std::string& typ, const std::string& val);
+ template <typename OBJECT> static
+ bool bind_sequence(OBJECT& object, const std::string& typ, const std::string& val);
/// Binding function for STL maps. Does not fill data!
- template <typename T> static
- bool bind_map(T& object, const std::string& key_type, const std::string& val_type);
+ template <typename BINDER, typename OBJECT> static
+ bool bind_map(const BINDER& b, OBJECT& o, const std::string& key_type, const std::string& val_type);
/// Filling function for STL maps.
- template <typename T> static
- bool insert_map(T& object,
+ template <typename BINDER, typename OBJECT> static
+ bool insert_map(const BINDER& b, OBJECT& o,
const std::string& key_type, const std::string& key,
const std::string& val_type, const std::string& val);
-
+ /// Filling function for STL maps.
+ template <typename BINDER, typename OBJECT> static
+ bool insert_map(const BINDER& b, OBJECT& o,
+ const std::string& key_type, const std::string& val_type,
+ const std::string& pair_data);
};
} /* End namespace DD4hep */
#endif /* DD4HEP_OPAQUEDATABINDER_H */
diff --git a/DDCore/include/DD4hep/objects/OpaqueData_inl.h b/DDCore/include/DD4hep/objects/OpaqueData_inl.h
index 376d37cb0dddef96b357a7011cbc936095a6bbca..236454dc8b4e9ad4ba801bbe58e8485d1aad8e21 100644
--- a/DDCore/include/DD4hep/objects/OpaqueData_inl.h
+++ b/DDCore/include/DD4hep/objects/OpaqueData_inl.h
@@ -53,6 +53,11 @@ namespace DD4hep {
this->bind(&BasicGrammar::instance<T>(),opaqueCopyObject<T>,opaqueDestructObject<T>);
return *(new(this->pointer) T());
}
+ /// Bind data value. Ugly, but some compilers otherwise do not recognize the function in templates
+ template <typename T> void OpaqueDataBlock::bind(const T*) {
+ this->bind(&BasicGrammar::instance<T>(),opaqueCopyObject<T>,opaqueDestructObject<T>);
+ new(this->pointer) T();
+ }
/// Bind grammar and assign value
template <typename T> T& OpaqueDataBlock::bind(const std::string& value) {
T& ret = this->bind<T>();
diff --git a/DDCore/include/XML/UnicodeValues.h b/DDCore/include/XML/UnicodeValues.h
index 0d20489c964b4b9e97474fbc474fc3e968adb501..073ee29668670b93fca74b68d197ae128a30b422 100644
--- a/DDCore/include/XML/UnicodeValues.h
+++ b/DDCore/include/XML/UnicodeValues.h
@@ -203,6 +203,7 @@ namespace DD4hep {
UNICODE (InvisibleNoDaughters);
UNICODE (InvisibleWithDaughters);
UNICODE (isotope);
+ UNICODE (item);
UNICODE (j);
UNICODE (J);
diff --git a/DDCore/src/ConditionsPrinter.cpp b/DDCore/src/ConditionsPrinter.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..9b52b3762da0fcc545025e46b3fd7feec75ff709
--- /dev/null
+++ b/DDCore/src/ConditionsPrinter.cpp
@@ -0,0 +1,45 @@
+//==========================================================================
+// AIDA Detector description implementation for LCD
+//--------------------------------------------------------------------------
+// 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 includes
+#include "DD4hep/Printout.h"
+#include "DD4hep/ConditionsPrinter.h"
+
+using namespace DD4hep;
+using namespace DD4hep::Conditions;
+
+/// Initializing constructor
+ConditionsPrinter::ConditionsPrinter(const std::string& pref, int flg)
+ : name("Condition"), prefix(pref), m_flag(flg)
+{
+}
+
+/// Callback to output conditions information
+int ConditionsPrinter::operator()(Condition cond) {
+ if ( cond.isValid() ) {
+ printout(INFO,name,"++ %s%s",prefix.c_str(),cond.str(m_flag).c_str());
+ const OpaqueData& data = cond.data();
+ std::string values = data.str();
+ if ( values.length() > 132 ) values = values.substr(0,130)+"...";
+ std::string new_prefix = prefix;
+ new_prefix.assign(prefix.length(),' ');
+ printout(INFO,name,"++ %s \tPath:%s",
+ new_prefix.c_str(),
+ cond.name().c_str(),
+ data.dataType().c_str());
+ printout(INFO,name,"++ %s \tData:%s",
+ new_prefix.c_str(),
+ values.c_str());
+ }
+ return 1;
+}
diff --git a/DDCore/src/OpaqueDataBinder.cpp b/DDCore/src/OpaqueDataBinder.cpp
index cc76f201e4316c6ea7c7af0c06fa1dd4f34fa79f..2c55e5c7fec04b21b70dbee8bf4270c637e491d7 100644
--- a/DDCore/src/OpaqueDataBinder.cpp
+++ b/DDCore/src/OpaqueDataBinder.cpp
@@ -30,23 +30,23 @@ namespace DD4hep {
/// Helper class to bind string values to C++ data objects (primitive or complex)
template <typename T, typename Q> bool ValueBinder::bind(T& object, const string& val, const Q*) const
- { object.bind<Q>(val); return true; }
+ { object.bind<Q>(val); return true; }
/// Helper class to bind string values to a STL vector of data objects (primitive or complex)
template <typename T, typename Q> bool VectorBinder::bind(T& object, const string& val, const Q*) const
- { object.bind<vector<Q> >(val); return true; }
+ { object.bind<vector<Q> >(val); return true; }
/// Helper class to bind string values to a STL list of data objects (primitive or complex)
template <typename T, typename Q> bool ListBinder::bind(T& object, const string& val, const Q*) const
- { object.bind<list<Q> >(val); return true; }
+ { object.bind<list<Q> >(val); return true; }
/// Helper class to bind string values to a STL set of data objects (primitive or complex)
template <typename T, typename Q> bool SetBinder::bind(T& object, const string& val, const Q*) const
- { object.bind<set<Q> >(val); return true; }
+ { object.bind<set<Q> >(val); return true; }
/// Helper class to bind STL map objects
template <typename T, typename Q> bool MapBinder::bind(T& object, const Q*) const
- { object.bind<Q>(); return true; }
+ { object.bind((const Q*)0); return true; }
/// Binding function for scalar items. See the implementation function for the concrete instantiations
template <typename BINDER, typename T>
@@ -109,22 +109,16 @@ namespace DD4hep {
return bind(ValueBinder(), object, value_type, val);
return false;
}
-
-
- template<typename KEY, typename VAL>
- static void insert_map_item(const KEY& k, const string& val, OpaqueDataBlock& block) {
- typedef map<KEY,VAL> map_t;
- map_t& m = block.get<map_t>();
- VAL v;
- if ( !BasicGrammar::instance<VAL>().fromString(&v, val) ) {
- except("OpaqueDataBinder","++ Failed to convert conditions map entry.");
- }
- m.insert(make_pair(k,v));
- }
- template<typename KEY, typename VAL>
- static void insert_map_item(const KEY& k, const string& val, Conditions::Condition& block) {
+
+ template<typename BINDER, typename OBJECT, typename KEY, typename VAL>
+ static void insert_map_item(const BINDER&,
+ OBJECT& object,
+ const KEY& k,
+ const string& val,
+ const VAL*)
+ {
typedef map<KEY,VAL> map_t;
- map_t& m = block.get<map_t>();
+ map_t& m = object.get<map_t>();
VAL v;
if ( !BasicGrammar::instance<VAL>().fromString(&v, val) ) {
except("OpaqueDataBinder","++ Failed to convert conditions map entry.");
@@ -132,152 +126,246 @@ namespace DD4hep {
m.insert(make_pair(k,v));
}
- template<typename KEY, typename OBJECT>
- static void insert_map_key(const string& key_val,
+ template<typename BINDER, typename OBJECT, typename KEY>
+ static void insert_map_key(const BINDER& b,
+ OBJECT& object,
+ const string& key_val,
const string& val_type,
const string& val,
- OBJECT& block)
+ const KEY*)
{
KEY key;
BasicGrammar::instance<KEY>().fromString(&key, key_val);
// Short and char is not part of the standard dictionaries. Fall back to 'int'.
if ( val_type.substr(0,4) == "char" )
- insert_map_item<KEY,int>(key,val,block);
+ insert_map_item(b, object, key, val, (int*)0);
else if ( val_type.substr(0,5) == "short" )
- insert_map_item<KEY,int>(key,val,block);
+ insert_map_item(b, object, key, val, (int*)0);
else if ( val_type.substr(0,3) == "int" )
- insert_map_item<KEY,int>(key,val,block);
+ insert_map_item(b, object, key, val, (int*)0);
else if ( val_type.substr(0,4) == "long" )
- insert_map_item<KEY,long>(key,val,block);
+ insert_map_item(b, object, key, val, (long*)0);
else if ( val_type.substr(0,5) == "float" )
- insert_map_item<KEY,float>(key,val,block);
+ insert_map_item(b, object, key, val, (float*)0);
else if ( val_type.substr(0,6) == "double" )
- insert_map_item<KEY,double>(key,val,block);
+ insert_map_item(b, object, key, val, (double*)0);
else if ( val_type.substr(0,6) == "string" )
- insert_map_item<KEY,string>(key,val,block);
+ insert_map_item(b, object, key, val, (string*)0);
else if ( val_type == "std::string" )
- insert_map_item<KEY,string>(key,val,block);
+ insert_map_item(b, object, key, val, (string*)0);
else {
printout(INFO,"Param","++ Unknown conditions parameter type:%s data:%s",
val_type.c_str(),val.c_str());
- insert_map_item<KEY,string>(key,val,block);
+ insert_map_item(b, object, key, val, (string*)0);
+ }
+ }
+
+ template<typename BINDER, typename OBJECT, typename KEY, typename VAL>
+ static void insert_map_pair(const BINDER&,
+ OBJECT& object,
+ const string& data,
+ const KEY*,
+ const VAL*)
+ {
+ typedef map<KEY,VAL> map_t;
+ pair<KEY,VAL> entry;
+ map_t& m = object.get<map_t>();
+ if ( !BasicGrammar::instance<pair<KEY,VAL> >().fromString(&entry,data) ) {
+ except("OpaqueDataBinder","++ Failed to convert conditions map entry.");
}
+ m.insert(entry);
}
- template<typename OBJECT, typename KEY>
- static void bind_mapping(const string& val_type, OBJECT& object, const KEY*) {
+ template<typename BINDER, typename OBJECT, typename KEY>
+ static void insert_map_data(const BINDER& b,
+ OBJECT& object,
+ const string& val_type,
+ const string& pair_data,
+ const KEY*)
+ {
+ // Short and char is not part of the standard dictionaries. Fall back to 'int'.
+ if ( val_type.substr(0,4) == "char" )
+ insert_map_pair(b, object, pair_data, (KEY*)0, (int*)0);
+ else if ( val_type.substr(0,5) == "short" )
+ insert_map_pair(b, object, pair_data, (KEY*)0, (int*)0);
+ else if ( val_type.substr(0,3) == "int" )
+ insert_map_pair(b, object, pair_data, (KEY*)0, (int*)0);
+ else if ( val_type.substr(0,4) == "long" )
+ insert_map_pair(b, object, pair_data, (KEY*)0, (long*)0);
+ else if ( val_type.substr(0,5) == "float" )
+ insert_map_pair(b, object, pair_data, (KEY*)0, (float*)0);
+ else if ( val_type.substr(0,6) == "double" )
+ insert_map_pair(b, object, pair_data, (KEY*)0, (double*)0);
+ else if ( val_type.substr(0,6) == "string" )
+ insert_map_pair(b, object, pair_data, (KEY*)0, (string*)0);
+ else if ( val_type == "std::string" )
+ insert_map_pair(b, object, pair_data, (KEY*)0, (string*)0);
+ else {
+ printout(INFO,"Param","++ Unknown conditions parameter type:%s data:%s",
+ val_type.c_str(),pair_data.c_str());
+ insert_map_pair(b, object, pair_data, (KEY*)0, (string*)0);
+ }
+ }
+
+ template<typename BINDER, typename OBJECT, typename KEY>
+ static void bind_mapping(const BINDER& b, const string& val_type, OBJECT& object, const KEY*) {
if ( val_type.substr(0,3) == "int" )
- MapBinder().bind(object, (map<KEY,int>*)0);
+ b.bind(object, (map<KEY,int>*)0);
#if defined(DD4HEP_HAVE_ALL_PARSERS)
else if ( val_type.substr(0,12) == "unsigned int" )
- MapBinder().bind(object, (map<KEY,unsigned int>*)0);
+ b.bind(object, (map<KEY,unsigned int>*)0);
else if ( val_type.substr(0,4) == "char" )
- MapBinder().bind(object, (map<KEY,char>*)0);
+ b.bind(object, (map<KEY,char>*)0);
else if ( val_type.substr(0,13) == "unsigned char" )
- MapBinder().bind(object, (map<KEY,unsigned char>*)0);
+ b.bind(object, (map<KEY,unsigned char>*)0);
else if ( val_type.substr(0,5) == "short" )
- MapBinder().bind(object, (map<KEY,short>*)0);
+ b.bind(object, (map<KEY,short>*)0);
else if ( val_type.substr(0,14) == "unsigned short" )
- MapBinder().bind(object, (map<KEY,unsigned short>*)0);
+ b.bind(object, (map<KEY,unsigned short>*)0);
else if ( val_type.substr(0,13) == "unsigned long" )
- MapBinder().bind(object, (map<KEY,unsigned long>*)0);
+ b.bind(object, (map<KEY,unsigned long>*)0);
#else
// Short and char is not part of the standard dictionaries. Fall back to 'int'.
else if ( val_type.substr(0,4) == "char" )
- MapBinder().bind(object, (map<KEY,int>*)0);
+ b.bind(object, (map<KEY,int>*)0);
else if ( val_type.substr(0,5) == "short" )
- MapBinder().bind(object, (map<KEY,int>*)0);
+ b.bind(object, (map<KEY,int>*)0);
#endif
else if ( val_type.substr(0,4) == "long" )
- MapBinder().bind(object, (map<KEY,long>*)0);
+ b.bind(object, (map<KEY,long>*)0);
else if ( val_type.substr(0,5) == "float" )
- MapBinder().bind(object, (map<KEY,float>*)0);
+ b.bind(object, (map<KEY,float>*)0);
else if ( val_type.substr(0,6) == "double" )
- MapBinder().bind(object, (map<KEY,double>*)0);
+ b.bind(object, (map<KEY,double>*)0);
else if ( val_type.substr(0,6) == "string" )
- MapBinder().bind(object, (map<KEY,string>*)0);
+ b.bind(object, (map<KEY,string>*)0);
else if ( val_type == "std::string" )
- MapBinder().bind(object, (map<KEY,string>*)0);
+ b.bind(object, (map<KEY,string>*)0);
else {
- MapBinder().bind(object, (map<KEY,string>*)0);
+ b.bind(object, (map<KEY,string>*)0);
}
}
/// Binding function for STL maps
- template <typename T>
- bool OpaqueDataBinder::bind_map(T& object, const string& key_type, const string& val_type) {
+ template <typename BINDER, typename OBJECT>
+ bool OpaqueDataBinder::bind_map(const BINDER& b, OBJECT& object,
+ const string& key_type, const string& val_type) {
// Short and char is not part of the standard dictionaries. Fall back to 'int'.
if ( key_type.substr(0,3) == "int" )
- bind_mapping(val_type,object,_int());
+ bind_mapping(b, val_type, object, _int());
#if defined(DD4HEP_HAVE_ALL_PARSERS)
else if ( key_type.substr(0,4) == "char" )
- bind_mapping(val_type,object,_int());
+ bind_mapping(b, val_type, object, _int());
else if ( key_type.substr(0,5) == "short" )
- bind_mapping(val_type,object,_int());
+ bind_mapping(b, val_type, object, _int());
else if ( key_type.substr(0,4) == "long" )
- bind_mapping(val_type,object,_long());
+ bind_mapping(b, val_type, object, _long());
else if ( key_type.substr(0,5) == "float" )
- bind_mapping(val_type,object,_float());
+ bind_mapping(b, val_type, object, _float());
else if ( key_type.substr(0,6) == "double" )
- bind_mapping(val_type,object,_double());
+ bind_mapping(b, val_type, object, _double());
#endif
else if ( key_type.substr(0,6) == "string" )
- bind_mapping(val_type,object,_string());
+ bind_mapping(b, val_type, object, _string());
else if ( key_type == "std::string" )
- bind_mapping(val_type,object,_string());
+ bind_mapping(b, val_type, object, _string());
else {
printout(INFO,"OpaqueDataBinder","++ Unknown MAP-conditions key-type:%s",key_type.c_str());
- bind_mapping(val_type,object,_string());
+ bind_mapping(b, val_type, object, _string());
}
return true;
}
/// Filling function for STL maps.
- template <typename T>
- bool OpaqueDataBinder::insert_map(T& object, const string& key_type, const string& key, const string& val_type, const string& val) {
+ template <typename BINDER, typename OBJECT>
+ bool OpaqueDataBinder::insert_map(const BINDER& b, OBJECT& object,
+ const string& key_type, const string& key,
+ const string& val_type, const string& val)
+ {
if ( key_type.substr(0,3) == "int" )
- insert_map_key<int>(key,val_type,val,object);
+ insert_map_key(b, object, key, val_type, val, _int());
#if defined(DD4HEP_HAVE_ALL_PARSERS)
// Short and char is not part of the standard dictionaries. Fall back to 'int'.
else if ( key_type.substr(0,4) == "char" )
- insert_map_key<int>(key,val_type,val,object);
+ insert_map_key(b, object, key, val_type, val, _int());
else if ( key_type.substr(0,5) == "short" )
- insert_map_key<int>(key,val_type,val,object);
+ insert_map_key(b, object, key, val_type, val, _int());
else if ( key_type.substr(0,4) == "long" )
- insert_map_key<long>(key,val_type,val,object);
+ insert_map_key(b, object, key, val_type, val, _long());
else if ( key_type.substr(0,5) == "float" )
- insert_map_key<float>(key,val_type,val,object);
+ insert_map_key(b, object, key, val_type, val, _float());
else if ( key_type.substr(0,6) == "double" )
- insert_map_key<double>(key,val_type,val,object);
+ insert_map_key(b, object, key, val_type, val, _double());
#endif
else if ( key_type.substr(0,6) == "string" )
- insert_map_key<string>(key,val_type,val,object);
+ insert_map_key(b, object, key, val_type, val, _string());
else if ( key_type == "std::string" )
- insert_map_key<string>(key,val_type,val,object);
+ insert_map_key(b, object, key, val_type, val, _string());
else {
printout(INFO,"OpaqueDataBinder","++ Unknown MAP-conditions key-type:%s",key_type.c_str());
- insert_map_key<string>(key,val_type,val,object);
+ insert_map_key(b, object, key, val_type, val, _string());
}
return true;
}
- /// Instantiate the data binder for OpaqueData
+ /// Filling function for STL maps.
+ template <typename BINDER, typename OBJECT>
+ bool OpaqueDataBinder::insert_map(const BINDER& b, OBJECT& object,
+ const std::string& key_type, const std::string& val_type,
+ const std::string& pair_data)
+ {
+ if ( key_type.substr(0,3) == "int" )
+ insert_map_data(b, object, val_type, pair_data, _int());
+#if defined(DD4HEP_HAVE_ALL_PARSERS)
+ // Short and char is not part of the standard dictionaries. Fall back to 'int'.
+ else if ( key_type.substr(0,4) == "char" )
+ insert_map_data(b, object, val_type, pair_data, _int());
+ else if ( key_type.substr(0,5) == "short" )
+ insert_map_data(b, object, val_type, pair_data, _int());
+ else if ( key_type.substr(0,4) == "long" )
+ insert_map_data(b, object, val_type, pair_data, _long());
+ else if ( key_type.substr(0,5) == "float" )
+ insert_map_data(b, object, val_type, pair_data, _float());
+ else if ( key_type.substr(0,6) == "double" )
+ insert_map_data(b, object, val_type, pair_data, _double());
+#endif
+ else if ( key_type.substr(0,6) == "string" )
+ insert_map_data(b, object, val_type, pair_data, _string());
+ else if ( key_type == "std::string" )
+ insert_map_data(b, object, val_type, pair_data, _string());
+ else {
+ printout(INFO,"OpaqueDataBinder","++ Unknown MAP-conditions key-type:%s",key_type.c_str());
+ insert_map_data(b, object, val_type, pair_data, _string());
+ }
+ return true;
+ }
+
+ /// Instantiate the data binder for OpaqueData
template bool OpaqueDataBinder::bind_sequence<OpaqueDataBlock>(OpaqueDataBlock& object,const string& typ,const string& val);
- template bool OpaqueDataBinder::bind_map<OpaqueDataBlock>(OpaqueDataBlock& object,const string& typ,const string& val);
- template bool OpaqueDataBinder::insert_map<OpaqueDataBlock>(OpaqueDataBlock& object,
- const string& key_type, const string& key,
- const string& val_type, const string& val);
+ template bool OpaqueDataBinder::bind_map<MapBinder,OpaqueDataBlock>( const MapBinder& b, OpaqueDataBlock& object,
+ const string& typ,const string& val);
+ template bool OpaqueDataBinder::insert_map<MapBinder,OpaqueDataBlock>(const MapBinder& b, OpaqueDataBlock& object,
+ const string& key_type, const string& key,
+ const string& val_type, const string& val);
+ template bool OpaqueDataBinder::insert_map<MapBinder,OpaqueDataBlock>(const MapBinder& b, OpaqueDataBlock& object,
+ const string& key_type, const string& val_type,
+ const string& pair_data);
/// Conditions binding function for STL maps
- template <>
- bool OpaqueDataBinder::bind_map(Conditions::Condition& object, const string& key_type, const string& val_type)
- { return bind_map(object->data, key_type, val_type); }
+ template <> bool OpaqueDataBinder::bind_map(const MapBinder& b, Conditions::Condition& object,
+ const string& key_type, const string& val_type)
+ { return bind_map(b, object->data, key_type, val_type); }
/// Conditions: Filling function for STL maps.
- template <> bool OpaqueDataBinder::insert_map(Conditions::Condition& object,
+ template <> bool OpaqueDataBinder::insert_map(const MapBinder& b, Conditions::Condition& object,
const string& key_type, const string& key,
const string& val_type, const string& val)
- { return insert_map(object->data, key_type, key, val_type, val); }
+ { return insert_map(b, object->data, key_type, key, val_type, val); }
+
+ /// Conditions: Filling function for STL maps.
+ template <> bool OpaqueDataBinder::insert_map(const MapBinder& b, Conditions::Condition& object,
+ const string& key_type, const string& val_type, const string& pair_data)
+ { return insert_map(b, object->data, key_type, val_type, pair_data); }
/// Instantiation for Conditions:
template bool
diff --git a/DDCore/src/plugins/StandardPlugins.cpp b/DDCore/src/plugins/StandardPlugins.cpp
index ca4543622601fe4dbfc3e9641b656cfcc8fef82f..28de2bd0714d1c463ac6d5f71e0633645c980cc6 100644
--- a/DDCore/src/plugins/StandardPlugins.cpp
+++ b/DDCore/src/plugins/StandardPlugins.cpp
@@ -59,11 +59,27 @@ static LCDDBuildType build_type(const char* value) {
throw runtime_error(string("Invalid build type value: ")+value);
}
+/// Basic entry point to create a LCDD instance
+/**
+ * Factory: LCDD_constructor
+ *
+ * \author M.Frank
+ * \version 1.0
+ * \date 01/04/2014
+ */
static void* create_lcdd_instance(const char* /* name */) {
return &LCDD::getInstance();
}
DECLARE_CONSTRUCTOR(LCDD_constructor,create_lcdd_instance)
+/// Basic entry point to display the currently loaded geometry using the ROOT OpenGL viewer
+/**
+ * Factory: DD4hepGeometryDisplay
+ *
+ * \author M.Frank
+ * \version 1.0
+ * \date 01/04/2014
+ */
static long display(LCDD& lcdd, int argc, char** argv) {
TGeoManager& mgr = lcdd.manager();
const char* opt = "ogl";
@@ -81,6 +97,39 @@ static long display(LCDD& lcdd, int argc, char** argv) {
}
DECLARE_APPLY(DD4hepGeometryDisplay,display)
+/// Basic entry point to start the ROOT interpreter.
+/**
+ * Factory: DD4hepRint
+ *
+ * \author M.Frank
+ * \version 1.0
+ * \date 01/04/2014
+ */
+static long run_interpreter(LCDD& /* lcdd */, int argc, char** argv) {
+ if ( argc > 0 ) {
+ pair<int, char**> a(argc,argv);
+ }
+ else {
+ pair<int, char**> a(0,0);
+ TRint app("DD4hep", &a.first, a.second);
+ app.Run();
+ }
+ return 1;
+}
+DECLARE_APPLY(DD4hepRint,run_interpreter)
+
+/// Basic entry point to start the ROOT interpreter.
+/**
+ * The UI will show up in the ROOT prompt and is accessible
+ * in the interpreter with the global variable
+ * DD4hep::DD4hepUI* gDD4hepUI;
+ *
+ * Factory: DD4hepInteractiveUI
+ *
+ * \author M.Frank
+ * \version 1.0
+ * \date 01/04/2014
+ */
static long root_ui(LCDD& lcdd, int /* argc */, char** /* argv */) {
char cmd[256];
DD4hepUI* ui = new DD4hepUI(lcdd);
@@ -93,6 +142,19 @@ static long root_ui(LCDD& lcdd, int /* argc */, char** /* argv */) {
}
DECLARE_APPLY(DD4hepInteractiveUI,root_ui)
+/// Basic entry point to interprete an XML document
+/**
+ * - The file URI to be opened
+ * is passed as first argument to the call.
+ * - The processing hint (build type) is passed as optional
+ * second argument.
+ *
+ * Factory: DD4hepCompactLoader
+ *
+ * \author M.Frank
+ * \version 1.0
+ * \date 01/04/2014
+ */
static long load_compact(LCDD& lcdd, int argc, char** argv) {
if ( argc > 0 ) {
LCDDBuildType type = BUILD_DEFAULT;
@@ -112,19 +174,21 @@ static long load_compact(LCDD& lcdd, int argc, char** argv) {
}
DECLARE_APPLY(DD4hepCompactLoader,load_compact)
-static long run_interpreter(LCDD& /* lcdd */, int argc, char** argv) {
- if ( argc > 0 ) {
- pair<int, char**> a(argc,argv);
- }
- else {
- pair<int, char**> a(0,0);
- TRint app("DD4hep", &a.first, a.second);
- app.Run();
- }
- return 1;
-}
-DECLARE_APPLY(DD4hepRint,run_interpreter)
-
+/// Basic entry point to process any XML document.
+/**
+ * - The file URI to be opened
+ * is passed as first argument to the call.
+ * - The processing hint (build type) is passed as optional
+ * second argument.
+ *
+ * The root tag defines the plugin to interprete it.
+ *
+ * Factory: DD4hepXMLLoader
+ *
+ * \author M.Frank
+ * \version 1.0
+ * \date 01/04/2014
+ */
static long load_xml(LCDD& lcdd, int argc, char** argv) {
if ( argc > 0 ) {
LCDDBuildType type = BUILD_DEFAULT;
@@ -144,6 +208,21 @@ static long load_xml(LCDD& lcdd, int argc, char** argv) {
}
DECLARE_APPLY(DD4hepXMLLoader,load_xml)
+/// Basic entry point to process any pre-parsed XML document.
+/**
+ * - The handle to the XML element (XercesC DOMNode)
+ * is passed as first argument to the call.
+ * - The processing hint (build type) is passed as optional
+ * second argument.
+ *
+ * The root tag defines the plugin to interprete it.
+ *
+ * Factory: DD4hepXMLProcessor
+ *
+ * \author M.Frank
+ * \version 1.0
+ * \date 01/04/2014
+ */
static long process_xml_doc(LCDD& lcdd, int argc, char** argv) {
if ( argc > 0 ) {
LCDDBuildType type = BUILD_DEFAULT;
@@ -160,12 +239,22 @@ static long process_xml_doc(LCDD& lcdd, int argc, char** argv) {
imp->processXMLElement(input, type);
return 1;
}
+ except("DD4hepXMLProcessor",
+ "++ The passed reference to the parsed XML document is invalid.");
}
}
return 0;
}
DECLARE_APPLY(DD4hepXMLProcessor,process_xml_doc)
+/// Basic entry point to load the volume manager object
+/**
+ * Factory: DD4hepVolumeManager
+ *
+ * \author M.Frank
+ * \version 1.0
+ * \date 01/04/2014
+ */
static long load_volmgr(LCDD& lcdd, int, char**) {
try {
LCDDImp* imp = dynamic_cast<LCDDImp*>(&lcdd);
@@ -186,6 +275,14 @@ static long load_volmgr(LCDD& lcdd, int, char**) {
}
DECLARE_APPLY(DD4hepVolumeManager,load_volmgr)
+/// Basic entry point to dump a DD4hep geometry to a ROOT file
+/**
+ * Factory: DD4hepGeometry2ROOT
+ *
+ * \author M.Frank
+ * \version 1.0
+ * \date 01/04/2014
+ */
static long dump_geometry2root(LCDD& lcdd, int argc, char** argv) {
if ( argc > 0 ) {
string output = argv[0];
@@ -200,6 +297,14 @@ static long dump_geometry2root(LCDD& lcdd, int argc, char** argv) {
}
DECLARE_APPLY(DD4hepGeometry2ROOT,dump_geometry2root)
+/// Basic entry point to load a DD4hep geometry directly from the ROOT file
+/**
+ * Factory: DD4hepRootLoader
+ *
+ * \author M.Frank
+ * \version 1.0
+ * \date 01/04/2014
+ */
static long load_geometryFromroot(LCDD& lcdd, int argc, char** argv) {
if ( argc > 0 ) {
string input = argv[0];
@@ -213,11 +318,13 @@ static long load_geometryFromroot(LCDD& lcdd, int argc, char** argv) {
}
DECLARE_APPLY(DD4hepRootLoader,load_geometryFromroot)
-/** Basic entry point to print out the volume hierarchy
+/// Basic entry point to print out the volume hierarchy
+/**
+ * Factory: DD4hepVolumeDump
*
- * @author M.Frank
- * @version 1.0
- * @date 01/04/2014
+ * \author M.Frank
+ * \version 1.0
+ * \date 01/04/2014
*/
static long dump_volume_tree(LCDD& lcdd, int argc, char** argv) {
struct Actor {
@@ -309,11 +416,13 @@ static long dump_volume_tree(LCDD& lcdd, int argc, char** argv) {
}
DECLARE_APPLY(DD4hepVolumeDump,dump_volume_tree)
-/** Basic entry point to print out the detector element hierarchy
+/// Basic entry point to print out the detector element hierarchy
+/**
+ * Factory: DD4hepDetectorDump, DD4hepDetectorVolumeDump
*
- * @author M.Frank
- * @version 1.0
- * @date 01/04/2014
+ * \author M.Frank
+ * \version 1.0
+ * \date 01/04/2014
*/
template <int flag> long dump_detelement_tree(LCDD& lcdd, int argc, char** argv) {
struct Actor {
@@ -356,11 +465,13 @@ template <int flag> long dump_detelement_tree(LCDD& lcdd, int argc, char** argv)
DECLARE_APPLY(DD4hepDetectorDump,dump_detelement_tree<0>)
DECLARE_APPLY(DD4hepDetectorVolumeDump,dump_detelement_tree<1>)
-/** Basic entry point to print out the volume hierarchy
+/// Basic entry point to print out the volume hierarchy
+/**
+ * Factory: DD4hepDetElementCache
*
- * @author M.Frank
- * @version 1.0
- * @date 01/04/2014
+ * \author M.Frank
+ * \version 1.0
+ * \date 01/04/2014
*/
static long detelement_cache(LCDD& lcdd, int , char** ) {
struct Actor {
@@ -379,6 +490,14 @@ static long detelement_cache(LCDD& lcdd, int , char** ) {
}
DECLARE_APPLY(DD4hepDetElementCache,detelement_cache)
+/// Basic entry point to dump the geometry tree of the lcdd instance
+/**
+ * Factory: DD4hepGeometryTreeDump
+ *
+ * \author M.Frank
+ * \version 1.0
+ * \date 01/04/2014
+ */
#include "../GeometryTreeDump.h"
static long exec_GeometryTreeDump(LCDD& lcdd, int, char** ) {
GeometryTreeDump dmp;
@@ -387,6 +506,14 @@ static long exec_GeometryTreeDump(LCDD& lcdd, int, char** ) {
}
DECLARE_APPLY(DD4hepGeometryTreeDump,exec_GeometryTreeDump)
+/// Basic entry point to dump the geometry in GDML format
+/**
+ * Factory: DD4hepSimpleGDMLWriter
+ *
+ * \author M.Frank
+ * \version 1.0
+ * \date 01/04/2014
+ */
#include "../SimpleGDMLWriter.h"
static long exec_SimpleGDMLWriter(LCDD& lcdd, int argc, char** argv) {
if ( argc > 1 ) {
@@ -403,11 +530,13 @@ static long exec_SimpleGDMLWriter(LCDD& lcdd, int argc, char** argv) {
}
DECLARE_APPLY(DD4hepSimpleGDMLWriter,exec_SimpleGDMLWriter)
-/** Basic entry point to print out detector type map
+/// Basic entry point to print out detector type map
+/**
+ * Factory: DD4hepDetectorTypes
*
- * @author M.Frank
- * @version 1.0
- * @date 01/04/2014
+ * \author M.Frank
+ * \version 1.0
+ * \date 01/04/2014
*/
static long detectortype_cache(LCDD& lcdd, int , char** ) {
vector<string> v = lcdd.detectorTypes();
diff --git a/DDDB/include/DDDB/DDDBConditionPrinter.h b/DDDB/include/DDDB/DDDBConditionPrinter.h
index 3aad87842ad0e68066a7bf96ddc8e6d977f140ac..08d78d2120c43aee6e6b0f6ec68f6faa119505f4 100644
--- a/DDDB/include/DDDB/DDDBConditionPrinter.h
+++ b/DDDB/include/DDDB/DDDBConditionPrinter.h
@@ -1,4 +1,3 @@
-// $Id$
//==========================================================================
// AIDA Detector description implementation for LCD
//--------------------------------------------------------------------------
@@ -51,21 +50,21 @@ namespace DD4hep {
*/
class ParamPrinter {
protected:
- /// Printout prefix
- std::string& m_prefix;
+ /// Printout prefix
+ std::string& m_prefix;
public:
- /// Initializing constructor
+ /// Initializing constructor
ParamPrinter(std::string& prefix);
- /// Default destructor
- virtual ~ParamPrinter() {}
+ /// Default destructor
+ virtual ~ParamPrinter() {}
- /// Set prefix for prinouts
- void setPrefix(const std::string& value) { m_prefix = value; }
- /// Access prefix value
- const std::string& prefix() const { return m_prefix; }
- /// Callback to output conditions information
- virtual void operator()(const Conditions::AbstractMap::Params::value_type& obj) const;
+ /// Set prefix for prinouts
+ void setPrefix(const std::string& value) { m_prefix = value; }
+ /// Access prefix value
+ const std::string& prefix() const { return m_prefix; }
+ /// Callback to output conditions information
+ virtual void operator()(const Conditions::AbstractMap::Params::value_type& obj) const;
};
protected:
@@ -78,8 +77,8 @@ namespace DD4hep {
/// Initializing constructor
ConditionPrinter(const std::string& prefix="",
- int flag=Cond::NO_NAME|Cond::WITH_IOV|Cond::WITH_ADDRESS,
- ParamPrinter* prt=0);
+ int flag=Cond::NO_NAME|Cond::WITH_IOV|Cond::WITH_ADDRESS,
+ ParamPrinter* prt=0);
/// Set prefix for prinouts
void setPrefix(const std::string& value) { m_prefix = value; }
/// Callback to output conditions information
diff --git a/DDDB/src/CondDB2DDDB.cpp b/DDDB/src/CondDB2DDDB.cpp
index 5a5787c7a81db37fc9fbdb72a311cb18f65d5ab9..a57cb8a03b7d6b7399b6d735ee1a656ff5eb6cd4 100644
--- a/DDDB/src/CondDB2DDDB.cpp
+++ b/DDDB/src/CondDB2DDDB.cpp
@@ -525,13 +525,14 @@ namespace DD4hep {
string key_type = e.attr<string>(_LBU(keytype));
string val_type = e.attr<string>(_LBU(valuetype));
pair<string,OpaqueDataBlock> block;
+ MapBinder binder;
block.first = nam;
- OpaqueDataBinder::bind_map(block.second, key_type, val_type);
+ OpaqueDataBinder::bind_map(binder,block.second, key_type, val_type);
for(xml_coll_t i(e,_LBU(item)); i; ++i) {
string key = i.attr<string>(_LBU(key));
string val = i.attr<string>(_LBU(value));
- OpaqueDataBinder::insert_map(block.second, key_type, key, val_type, val);
+ OpaqueDataBinder::insert_map(binder,block.second, key_type, key, val_type, val);
}
ConditionParams* par = _option<ConditionParams>();
pair<ConditionParams::iterator,bool> res = par->insert(block);