DD4hep  1.32.0
Detector Description Toolkit for High Energy Physics
All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Modules Pages
OpaqueData.h
Go to the documentation of this file.
1 //==========================================================================
2 // AIDA Detector description implementation
3 //--------------------------------------------------------------------------
4 // Copyright (C) Organisation europeenne pour la Recherche nucleaire (CERN)
5 // All rights reserved.
6 //
7 // For the licensing terms see $DD4hepINSTALL/LICENSE.
8 // For the list of contributors see $DD4hepINSTALL/doc/CREDITS.
9 //
10 // Author : M.Frank
11 //
12 //==========================================================================
13 #ifndef DD4HEP_OPAQUEDATA_H
14 #define DD4HEP_OPAQUEDATA_H
15 
16 // Framework include files
17 #include <DD4hep/Grammar.h>
18 
19 // C/C++ include files
20 #include <typeinfo>
21 #include <string>
22 
24 namespace dd4hep {
25 
26  // Forward declarations
27  class BasicGrammar;
28 
30 
38  class OpaqueData {
39  private:
40  protected:
42  OpaqueData() = default;
44  virtual ~OpaqueData() = default;
46  OpaqueData(const OpaqueData& copy) = default;
48  OpaqueData& operator=(const OpaqueData& copy) = default;
49 
50  public:
52  const BasicGrammar* grammar = 0;
53 
54  protected:
56  void* pointer = 0;
57 
58  public:
60  bool fromString(const std::string& rep);
62  std::string str() const;
64  const std::type_info& typeInfo() const;
66  const std::string& dataType() const;
68  const void* ptr() const { return pointer; }
70  bool is_bound() const { return 0 != pointer; }
72  template <typename T> T& get();
74  template <typename T> const T& get() const;
76  template <typename T> T& as();
78  template <typename T> const T& as() const;
79  };
80 
81 
83 
91  class OpaqueDataBlock : public OpaqueData {
92 
93  public:
95  constexpr static const size_t BUFFER_SIZE = 40;
96 
97  protected:
99 
107  unsigned char data[BUFFER_SIZE];
108 
109  public:
110  enum _DataTypes {
111  PLAIN_DATA = 1<<0,
112  ALLOC_DATA = 1<<1,
113  STACK_DATA = 1<<2,
114  BOUND_DATA = 1<<3,
115  EXTERN_DATA = 1<<4
116  };
118  unsigned int type;
119 
120  public:
122  OpaqueDataBlock();
124  template <typename OBJECT> OpaqueDataBlock(OBJECT&& data);
132  void* ptr() const { return pointer; }
134  void* bind(const BasicGrammar* grammar);
136  void* bind(void* ptr, size_t len, const BasicGrammar* grammar);
138  void bindExtern(void* ptr, const BasicGrammar* grammar);
140  template <typename T, typename... Args> T& construct(Args... args);
142  template <typename T> T& bind();
144  template <typename T> T& bind(void* ptr, size_t len);
146  template <typename T> T& bind(const std::string& value);
148  template <typename T> T& bind(void* ptr, size_t len, const std::string& value);
150  template <typename T> T& bind(T&& data);
152  template <typename T> void bindExtern(T* ptr);
153  };
154 
156  template <typename T> inline T& OpaqueData::get() {
157  if (!grammar || !grammar->equals(typeid(T))) { throw std::bad_cast(); }
158  return *(T*)pointer;
159  }
160 
162  template <typename T> inline const T& OpaqueData::get() const {
163  if (!grammar || !grammar->equals(typeid(T))) { throw std::bad_cast(); }
164  return *(T*)pointer;
165  }
166 
168  template <typename T> inline T& OpaqueData::as() {
169  if ( grammar ) {
170  T* obj = (T*)(grammar->cast().apply_dynCast(Cast::instance<T>(), this->pointer));
171  if ( obj ) return *obj;
172  }
173  throw std::bad_cast();
174  }
175 
177  template <typename T> inline const T& OpaqueData::as() const {
178  if ( grammar ) {
179  const T* obj = (const T*)(grammar->cast().apply_dynCast(Cast::instance<T>(), this->pointer));
180  if ( obj ) return *obj;
181  }
182  throw std::bad_cast();
183  }
184 
186  template <typename OBJECT> OpaqueDataBlock::OpaqueDataBlock(OBJECT&& obj) {
187  this->bind(&BasicGrammar::instance<OBJECT>());
188  new(this->pointer) OBJECT(std::move(obj));
189  }
190 
192  template <typename T, typename... Args> inline T& OpaqueDataBlock::construct(Args... args) {
193  this->bind(&BasicGrammar::instance<T>());
194  return *(new(this->pointer) T(std::forward<Args>(args)...));
195  }
196 
198  template <typename T> inline T& OpaqueDataBlock::bind() {
199  this->bind(&BasicGrammar::instance<T>());
200  return *(new(this->pointer) T());
201  }
202 
204  template <typename T> inline T& OpaqueDataBlock::bind(T&& obj) {
205  this->bind(&BasicGrammar::instance<T>());
206  new(this->pointer) T(std::move(obj));
207  }
208 
210  template <typename T> inline T& OpaqueDataBlock::bind(void* ptr, size_t len) {
211  this->bind(ptr,len,&BasicGrammar::instance<T>());
212  return *(new(this->pointer) T());
213  }
214 
216  template <typename T> inline T& OpaqueDataBlock::bind(const std::string& value) {
217  T& ret = this->bind<T>();
218  if ( !value.empty() && !this->fromString(value) ) {
219  throw std::runtime_error("OpaqueDataBlock::set> Failed to bind type "+
220  typeName(typeid(T))+" to condition data block.");
221  }
222  return ret;
223  }
224 
226  template <typename T> inline T& OpaqueDataBlock::bind(void* ptr, size_t len, const std::string& value) {
227  T& ret = this->bind<T>(ptr, len);
228  if ( !value.empty() && !this->fromString(value) ) {
229  throw std::runtime_error("OpaqueDataBlock::set> Failed to bind type "+
230  typeName(typeid(T))+" to condition data block.");
231  }
232  return ret;
233  }
235  template <typename T> inline void OpaqueDataBlock::bindExtern(T* ptr) {
236  bindExtern(ptr, &BasicGrammar::instance<T>());
237  }
238 
239 } /* End namespace dd4hep */
240 #endif // DD4HEP_OPAQUEDATA_H
dd4hep::OpaqueData::~OpaqueData
virtual ~OpaqueData()=default
Standard Destructor.
dd4hep::BasicGrammar::equals
virtual bool equals(const std::type_info &other_type) const =0
Access to the type information.
dd4hep::OpaqueData::OpaqueData
OpaqueData()=default
Standard initializing constructor.
dd4hep::OpaqueDataBlock::BOUND_DATA
@ BOUND_DATA
Definition: OpaqueData.h:114
dd4hep::OpaqueDataBlock::BUFFER_SIZE
constexpr static const size_t BUFFER_SIZE
Buffer size of the in-place data buffer.
Definition: OpaqueData.h:95
dd4hep::OpaqueDataBlock::construct
T & construct(Args... args)
Construct conditions object and bind the data.
Definition: OpaqueData.h:192
dd4hep::OpaqueDataBlock::type
unsigned int type
Data buffer type: Must be a bitmap of enum _DataTypes!
Definition: OpaqueData.h:118
dd4hep::OpaqueData::OpaqueData
OpaqueData(const OpaqueData &copy)=default
Copy constructor.
dd4hep::OpaqueDataBlock::data
unsigned char data[BUFFER_SIZE]
Data buffer: plain data are allocated directly on this buffer.
Definition: OpaqueData.h:107
dd4hep::OpaqueDataBlock::_DataTypes
_DataTypes
Definition: OpaqueData.h:110
dd4hep::OpaqueDataBlock
Class describing an opaque conditions data block.
Definition: OpaqueData.h:91
dd4hep::OpaqueData::fromString
bool fromString(const std::string &rep)
No ROOT persistency.
Definition: OpaqueData.cpp:26
dd4hep::OpaqueData::is_bound
bool is_bound() const
Check if object is already bound....
Definition: OpaqueData.h:70
dd4hep::OpaqueDataBlock::EXTERN_DATA
@ EXTERN_DATA
Definition: OpaqueData.h:115
dd4hep::OpaqueDataBlock::OpaqueDataBlock
OpaqueDataBlock()
Standard initializing constructor.
Definition: OpaqueData.cpp:58
dd4hep::OpaqueData::as
T & as()
Generic getter. Resolves polymorph types. It is mandatory that the datatype is polymorph!
Definition: OpaqueData.h:168
dd4hep::BasicGrammar
Base class describing string evaluation to C++ objects using boost::spirit.
Definition: Grammar.h:55
dd4hep::OpaqueDataBlock::STACK_DATA
@ STACK_DATA
Definition: OpaqueData.h:113
dd4hep::OpaqueData::operator=
OpaqueData & operator=(const OpaqueData &copy)=default
Assignment operator.
dd4hep::OpaqueData
Class describing an opaque data block.
Definition: OpaqueData.h:38
dd4hep::OpaqueData::get
T & get()
Generic getter. Specify the exact type, not a polymorph type.
Definition: OpaqueData.h:156
dd4hep::OpaqueDataBlock::ptr
void * ptr() const
Write access to the data buffer. Is only valid after call to bind<T>()
Definition: OpaqueData.h:132
dd4hep::OpaqueDataBlock::bind
T & bind()
Bind data value.
Definition: OpaqueData.h:198
dd4hep::OpaqueDataBlock::ALLOC_DATA
@ ALLOC_DATA
Definition: OpaqueData.h:112
dd4hep::OpaqueData::ptr
const void * ptr() const
Access to the data buffer (read only!). Is only valid after call to bind<T>()
Definition: OpaqueData.h:68
dd4hep::OpaqueData::typeInfo
const std::type_info & typeInfo() const
Access type id of the condition.
Definition: OpaqueData.cpp:42
dd4hep::OpaqueDataBlock::operator=
OpaqueDataBlock & operator=(const OpaqueDataBlock &copy)
Assignment operator (Required by ROOT dictionaries)
Definition: OpaqueData.cpp:90
dd4hep
Namespace for the AIDA detector description toolkit.
Definition: AlignmentsCalib.h:28
dd4hep::BasicGrammar::cast
virtual const Cast & cast() const
Access ABI object cast.
Definition: Grammar.cpp:252
dd4hep::OpaqueDataBlock::PLAIN_DATA
@ PLAIN_DATA
Definition: OpaqueData.h:111
dd4hep::OpaqueDataBlock::bindExtern
void bindExtern(void *ptr, const BasicGrammar *grammar)
Bind external data value to the pointer.
Definition: OpaqueData.cpp:146
dd4hep::OpaqueData::grammar
const BasicGrammar * grammar
Data type.
Definition: OpaqueData.h:52
dd4hep::OpaqueData::dataType
const std::string & dataType() const
Access type name of the condition data block.
Definition: OpaqueData.cpp:50
dd4hep::detail::tools::copy
void copy(Alignment from, Alignment to)
Copy alignment object from source object.
Definition: AlignmentTools.cpp:43
dd4hep::OpaqueData::str
std::string str() const
Create string representation of the data block.
Definition: OpaqueData.cpp:34
dd4hep::OpaqueData::pointer
void * pointer
No ROOT persistency.
Definition: OpaqueData.h:56
dd4hep::OpaqueDataBlock::~OpaqueDataBlock
~OpaqueDataBlock()
Standard Destructor.
Definition: OpaqueData.cpp:79
Grammar.h