The Gaudi Framework  v30r3 (a5ef0a68)
RootCnvDict.cpp
Go to the documentation of this file.
1 // Do NOT change. Changes will be lost next time file is generated
2 
3 #define R__DICTIONARY_FILENAME RootCnvDict
4 
5 /*******************************************************************/
6 #include <stddef.h>
7 #include <stdio.h>
8 #include <stdlib.h>
9 #include <string.h>
10 #include <assert.h>
11 #define G__DICTIONARY
12 #include "RConfig.h"
13 #include "TClass.h"
14 #include "TDictAttributeMap.h"
15 #include "TInterpreter.h"
16 #include "TROOT.h"
17 #include "TBuffer.h"
18 #include "TMemberInspector.h"
19 #include "TInterpreter.h"
20 #include "TVirtualMutex.h"
21 #include "TError.h"
22 
23 #ifndef G__ROOT
24 #define G__ROOT
25 #endif
26 
27 #include "RtypesImp.h"
28 #include "TIsAProxy.h"
29 #include "TFileMergeInfo.h"
30 #include <algorithm>
31 #include "TCollectionProxyInfo.h"
32 /*******************************************************************/
33 
34 #include "TDataMember.h"
35 
36 // Since CINT ignores the std namespace, we need to do so in this file.
37 namespace std {} using namespace std;
38 
39 // Header files passed as explicit arguments
40 #include "/builds/gaudi/Gaudi/RootCnv/dict/RootCnv_dict.h"
41 
42 // Header files passed via #pragma extra_include
43 
44 namespace ROOT {
45  static TClass *GaudicLcLRootRef_Dictionary();
46  static void GaudicLcLRootRef_TClassManip(TClass*);
47  static void *new_GaudicLcLRootRef(void *p = 0);
48  static void *newArray_GaudicLcLRootRef(Long_t size, void *p);
49  static void delete_GaudicLcLRootRef(void *p);
50  static void deleteArray_GaudicLcLRootRef(void *p);
51  static void destruct_GaudicLcLRootRef(void *p);
52 
53  // Function generating the singleton type initializer
54  static TGenericClassInfo *GenerateInitInstanceLocal(const ::Gaudi::RootRef*)
55  {
56  ::Gaudi::RootRef *ptr = 0;
57  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Gaudi::RootRef));
58  static ::ROOT::TGenericClassInfo
59  instance("Gaudi::RootRef", "RootCnv/RootRefs.h", 31,
60  typeid(::Gaudi::RootRef), ::ROOT::Internal::DefineBehavior(ptr, ptr),
61  &GaudicLcLRootRef_Dictionary, isa_proxy, 4,
62  sizeof(::Gaudi::RootRef) );
63  instance.SetNew(&new_GaudicLcLRootRef);
64  instance.SetNewArray(&newArray_GaudicLcLRootRef);
65  instance.SetDelete(&delete_GaudicLcLRootRef);
66  instance.SetDeleteArray(&deleteArray_GaudicLcLRootRef);
67  instance.SetDestructor(&destruct_GaudicLcLRootRef);
68  return &instance;
69  }
70  TGenericClassInfo *GenerateInitInstance(const ::Gaudi::RootRef*)
71  {
72  return GenerateInitInstanceLocal((::Gaudi::RootRef*)0);
73  }
74  // Static variable to force the class initialization
75  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Gaudi::RootRef*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
76 
77  // Dictionary for non-ClassDef classes
78  static TClass *GaudicLcLRootRef_Dictionary() {
79  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Gaudi::RootRef*)0x0)->GetClass();
80  GaudicLcLRootRef_TClassManip(theClass);
81  return theClass;
82  }
83 
84  static void GaudicLcLRootRef_TClassManip(TClass* ){
85  }
86 
87 } // end of namespace ROOT
88 
89 namespace ROOT {
90  static TClass *GaudicLcLRootObjectRefs_Dictionary();
91  static void GaudicLcLRootObjectRefs_TClassManip(TClass*);
92  static void *new_GaudicLcLRootObjectRefs(void *p = 0);
93  static void *newArray_GaudicLcLRootObjectRefs(Long_t size, void *p);
94  static void delete_GaudicLcLRootObjectRefs(void *p);
95  static void deleteArray_GaudicLcLRootObjectRefs(void *p);
96  static void destruct_GaudicLcLRootObjectRefs(void *p);
97 
98  // Function generating the singleton type initializer
99  static TGenericClassInfo *GenerateInitInstanceLocal(const ::Gaudi::RootObjectRefs*)
100  {
101  ::Gaudi::RootObjectRefs *ptr = 0;
102  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Gaudi::RootObjectRefs));
103  static ::ROOT::TGenericClassInfo
104  instance("Gaudi::RootObjectRefs", "RootCnv/RootRefs.h", 60,
105  typeid(::Gaudi::RootObjectRefs), ::ROOT::Internal::DefineBehavior(ptr, ptr),
106  &GaudicLcLRootObjectRefs_Dictionary, isa_proxy, 4,
107  sizeof(::Gaudi::RootObjectRefs) );
108  instance.SetNew(&new_GaudicLcLRootObjectRefs);
109  instance.SetNewArray(&newArray_GaudicLcLRootObjectRefs);
110  instance.SetDelete(&delete_GaudicLcLRootObjectRefs);
111  instance.SetDeleteArray(&deleteArray_GaudicLcLRootObjectRefs);
112  instance.SetDestructor(&destruct_GaudicLcLRootObjectRefs);
113  return &instance;
114  }
115  TGenericClassInfo *GenerateInitInstance(const ::Gaudi::RootObjectRefs*)
116  {
117  return GenerateInitInstanceLocal((::Gaudi::RootObjectRefs*)0);
118  }
119  // Static variable to force the class initialization
120  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Gaudi::RootObjectRefs*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
121 
122  // Dictionary for non-ClassDef classes
123  static TClass *GaudicLcLRootObjectRefs_Dictionary() {
124  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Gaudi::RootObjectRefs*)0x0)->GetClass();
125  GaudicLcLRootObjectRefs_TClassManip(theClass);
126  return theClass;
127  }
128 
129  static void GaudicLcLRootObjectRefs_TClassManip(TClass* ){
130  }
131 
132 } // end of namespace ROOT
133 
134 namespace ROOT {
135  static TClass *GaudicLcLRootNTupleDescriptor_Dictionary();
136  static void GaudicLcLRootNTupleDescriptor_TClassManip(TClass*);
137  static void *new_GaudicLcLRootNTupleDescriptor(void *p = 0);
138  static void *newArray_GaudicLcLRootNTupleDescriptor(Long_t size, void *p);
139  static void delete_GaudicLcLRootNTupleDescriptor(void *p);
140  static void deleteArray_GaudicLcLRootNTupleDescriptor(void *p);
141  static void destruct_GaudicLcLRootNTupleDescriptor(void *p);
142 
143  // Function generating the singleton type initializer
144  static TGenericClassInfo *GenerateInitInstanceLocal(const ::Gaudi::RootNTupleDescriptor*)
145  {
146  ::Gaudi::RootNTupleDescriptor *ptr = 0;
147  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Gaudi::RootNTupleDescriptor));
148  static ::ROOT::TGenericClassInfo
149  instance("Gaudi::RootNTupleDescriptor", "RootCnv/RootRefs.h", 79,
150  typeid(::Gaudi::RootNTupleDescriptor), ::ROOT::Internal::DefineBehavior(ptr, ptr),
151  &GaudicLcLRootNTupleDescriptor_Dictionary, isa_proxy, 4,
152  sizeof(::Gaudi::RootNTupleDescriptor) );
153  instance.SetNew(&new_GaudicLcLRootNTupleDescriptor);
154  instance.SetNewArray(&newArray_GaudicLcLRootNTupleDescriptor);
155  instance.SetDelete(&delete_GaudicLcLRootNTupleDescriptor);
156  instance.SetDeleteArray(&deleteArray_GaudicLcLRootNTupleDescriptor);
157  instance.SetDestructor(&destruct_GaudicLcLRootNTupleDescriptor);
158  return &instance;
159  }
160  TGenericClassInfo *GenerateInitInstance(const ::Gaudi::RootNTupleDescriptor*)
161  {
162  return GenerateInitInstanceLocal((::Gaudi::RootNTupleDescriptor*)0);
163  }
164  // Static variable to force the class initialization
165  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Gaudi::RootNTupleDescriptor*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
166 
167  // Dictionary for non-ClassDef classes
168  static TClass *GaudicLcLRootNTupleDescriptor_Dictionary() {
169  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Gaudi::RootNTupleDescriptor*)0x0)->GetClass();
170  GaudicLcLRootNTupleDescriptor_TClassManip(theClass);
171  return theClass;
172  }
173 
174  static void GaudicLcLRootNTupleDescriptor_TClassManip(TClass* ){
175  }
176 
177 } // end of namespace ROOT
178 
179 namespace ROOT {
180  static TClass *poolcLcLGuid_Dictionary();
181  static void poolcLcLGuid_TClassManip(TClass*);
182  static void *new_poolcLcLGuid(void *p = 0);
183  static void *newArray_poolcLcLGuid(Long_t size, void *p);
184  static void delete_poolcLcLGuid(void *p);
185  static void deleteArray_poolcLcLGuid(void *p);
186  static void destruct_poolcLcLGuid(void *p);
187 
188  // Function generating the singleton type initializer
189  static TGenericClassInfo *GenerateInitInstanceLocal(const ::pool::Guid*)
190  {
191  ::pool::Guid *ptr = 0;
192  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::pool::Guid));
193  static ::ROOT::TGenericClassInfo
194  instance("pool::Guid", "RootCnv/PoolClasses.h", 13,
195  typeid(::pool::Guid), ::ROOT::Internal::DefineBehavior(ptr, ptr),
196  &poolcLcLGuid_Dictionary, isa_proxy, 4,
197  sizeof(::pool::Guid) );
198  instance.SetNew(&new_poolcLcLGuid);
199  instance.SetNewArray(&newArray_poolcLcLGuid);
200  instance.SetDelete(&delete_poolcLcLGuid);
201  instance.SetDeleteArray(&deleteArray_poolcLcLGuid);
202  instance.SetDestructor(&destruct_poolcLcLGuid);
203  return &instance;
204  }
205  TGenericClassInfo *GenerateInitInstance(const ::pool::Guid*)
206  {
207  return GenerateInitInstanceLocal((::pool::Guid*)0);
208  }
209  // Static variable to force the class initialization
210  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::pool::Guid*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
211 
212  // Dictionary for non-ClassDef classes
213  static TClass *poolcLcLGuid_Dictionary() {
214  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::pool::Guid*)0x0)->GetClass();
215  poolcLcLGuid_TClassManip(theClass);
216  return theClass;
217  }
218 
219  static void poolcLcLGuid_TClassManip(TClass* ){
220  }
221 
222 } // end of namespace ROOT
223 
224 namespace ROOT {
225  static TClass *poolcLcLToken_Dictionary();
226  static void poolcLcLToken_TClassManip(TClass*);
227  static void *new_poolcLcLToken(void *p = 0);
228  static void *newArray_poolcLcLToken(Long_t size, void *p);
229  static void delete_poolcLcLToken(void *p);
230  static void deleteArray_poolcLcLToken(void *p);
231  static void destruct_poolcLcLToken(void *p);
232 
233  // Function generating the singleton type initializer
234  static TGenericClassInfo *GenerateInitInstanceLocal(const ::pool::Token*)
235  {
236  ::pool::Token *ptr = 0;
237  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::pool::Token));
238  static ::ROOT::TGenericClassInfo
239  instance("pool::Token", "RootCnv/PoolClasses.h", 26,
240  typeid(::pool::Token), ::ROOT::Internal::DefineBehavior(ptr, ptr),
241  &poolcLcLToken_Dictionary, isa_proxy, 4,
242  sizeof(::pool::Token) );
243  instance.SetNew(&new_poolcLcLToken);
244  instance.SetNewArray(&newArray_poolcLcLToken);
245  instance.SetDelete(&delete_poolcLcLToken);
246  instance.SetDeleteArray(&deleteArray_poolcLcLToken);
247  instance.SetDestructor(&destruct_poolcLcLToken);
248  return &instance;
249  }
250  TGenericClassInfo *GenerateInitInstance(const ::pool::Token*)
251  {
252  return GenerateInitInstanceLocal((::pool::Token*)0);
253  }
254  // Static variable to force the class initialization
255  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::pool::Token*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
256 
257  // Dictionary for non-ClassDef classes
258  static TClass *poolcLcLToken_Dictionary() {
259  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::pool::Token*)0x0)->GetClass();
260  poolcLcLToken_TClassManip(theClass);
261  return theClass;
262  }
263 
264  static void poolcLcLToken_TClassManip(TClass* ){
265  }
266 
267 } // end of namespace ROOT
268 
269 namespace ROOT {
270  static TClass *UCharDbArray_Dictionary();
271  static void UCharDbArray_TClassManip(TClass*);
272  static void *new_UCharDbArray(void *p = 0);
273  static void *newArray_UCharDbArray(Long_t size, void *p);
274  static void delete_UCharDbArray(void *p);
275  static void deleteArray_UCharDbArray(void *p);
276  static void destruct_UCharDbArray(void *p);
277 
278  // Function generating the singleton type initializer
279  static TGenericClassInfo *GenerateInitInstanceLocal(const ::UCharDbArray*)
280  {
281  ::UCharDbArray *ptr = 0;
282  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::UCharDbArray));
283  static ::ROOT::TGenericClassInfo
284  instance("UCharDbArray", "RootCnv/PoolClasses.h", 48,
285  typeid(::UCharDbArray), ::ROOT::Internal::DefineBehavior(ptr, ptr),
286  &UCharDbArray_Dictionary, isa_proxy, 4,
287  sizeof(::UCharDbArray) );
288  instance.SetNew(&new_UCharDbArray);
289  instance.SetNewArray(&newArray_UCharDbArray);
290  instance.SetDelete(&delete_UCharDbArray);
291  instance.SetDeleteArray(&deleteArray_UCharDbArray);
292  instance.SetDestructor(&destruct_UCharDbArray);
293  return &instance;
294  }
295  TGenericClassInfo *GenerateInitInstance(const ::UCharDbArray*)
296  {
297  return GenerateInitInstanceLocal((::UCharDbArray*)0);
298  }
299  // Static variable to force the class initialization
300  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::UCharDbArray*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
301 
302  // Dictionary for non-ClassDef classes
303  static TClass *UCharDbArray_Dictionary() {
304  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::UCharDbArray*)0x0)->GetClass();
305  UCharDbArray_TClassManip(theClass);
306  return theClass;
307  }
308 
309  static void UCharDbArray_TClassManip(TClass* ){
310  }
311 
312 } // end of namespace ROOT
313 
314 namespace ROOT {
315  static TClass *PoolDbTokenWrap_Dictionary();
316  static void PoolDbTokenWrap_TClassManip(TClass*);
317  static void *new_PoolDbTokenWrap(void *p = 0);
318  static void *newArray_PoolDbTokenWrap(Long_t size, void *p);
319  static void delete_PoolDbTokenWrap(void *p);
320  static void deleteArray_PoolDbTokenWrap(void *p);
321  static void destruct_PoolDbTokenWrap(void *p);
322 
323  // Function generating the singleton type initializer
324  static TGenericClassInfo *GenerateInitInstanceLocal(const ::PoolDbTokenWrap*)
325  {
326  ::PoolDbTokenWrap *ptr = 0;
327  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::PoolDbTokenWrap));
328  static ::ROOT::TGenericClassInfo
329  instance("PoolDbTokenWrap", "RootCnv/PoolClasses.h", 71,
330  typeid(::PoolDbTokenWrap), ::ROOT::Internal::DefineBehavior(ptr, ptr),
331  &PoolDbTokenWrap_Dictionary, isa_proxy, 4,
332  sizeof(::PoolDbTokenWrap) );
333  instance.SetNew(&new_PoolDbTokenWrap);
334  instance.SetNewArray(&newArray_PoolDbTokenWrap);
335  instance.SetDelete(&delete_PoolDbTokenWrap);
336  instance.SetDeleteArray(&deleteArray_PoolDbTokenWrap);
337  instance.SetDestructor(&destruct_PoolDbTokenWrap);
338  return &instance;
339  }
340  TGenericClassInfo *GenerateInitInstance(const ::PoolDbTokenWrap*)
341  {
342  return GenerateInitInstanceLocal((::PoolDbTokenWrap*)0);
343  }
344  // Static variable to force the class initialization
345  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::PoolDbTokenWrap*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
346 
347  // Dictionary for non-ClassDef classes
348  static TClass *PoolDbTokenWrap_Dictionary() {
349  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::PoolDbTokenWrap*)0x0)->GetClass();
350  PoolDbTokenWrap_TClassManip(theClass);
351  return theClass;
352  }
353 
354  static void PoolDbTokenWrap_TClassManip(TClass* ){
355  }
356 
357 } // end of namespace ROOT
358 
359 namespace ROOT {
360  static TClass *PoolDbLinkManager_Dictionary();
361  static void PoolDbLinkManager_TClassManip(TClass*);
362  static void *new_PoolDbLinkManager(void *p = 0);
363  static void *newArray_PoolDbLinkManager(Long_t size, void *p);
364  static void delete_PoolDbLinkManager(void *p);
365  static void deleteArray_PoolDbLinkManager(void *p);
366  static void destruct_PoolDbLinkManager(void *p);
367 
368  // Function generating the singleton type initializer
369  static TGenericClassInfo *GenerateInitInstanceLocal(const ::PoolDbLinkManager*)
370  {
371  ::PoolDbLinkManager *ptr = 0;
372  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::PoolDbLinkManager));
373  static ::ROOT::TGenericClassInfo
374  instance("PoolDbLinkManager", "RootCnv/PoolClasses.h", 100,
375  typeid(::PoolDbLinkManager), ::ROOT::Internal::DefineBehavior(ptr, ptr),
376  &PoolDbLinkManager_Dictionary, isa_proxy, 4,
377  sizeof(::PoolDbLinkManager) );
378  instance.SetNew(&new_PoolDbLinkManager);
379  instance.SetNewArray(&newArray_PoolDbLinkManager);
380  instance.SetDelete(&delete_PoolDbLinkManager);
381  instance.SetDeleteArray(&deleteArray_PoolDbLinkManager);
382  instance.SetDestructor(&destruct_PoolDbLinkManager);
383  return &instance;
384  }
385  TGenericClassInfo *GenerateInitInstance(const ::PoolDbLinkManager*)
386  {
387  return GenerateInitInstanceLocal((::PoolDbLinkManager*)0);
388  }
389  // Static variable to force the class initialization
390  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::PoolDbLinkManager*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
391 
392  // Dictionary for non-ClassDef classes
393  static TClass *PoolDbLinkManager_Dictionary() {
394  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::PoolDbLinkManager*)0x0)->GetClass();
395  PoolDbLinkManager_TClassManip(theClass);
396  return theClass;
397  }
398 
399  static void PoolDbLinkManager_TClassManip(TClass* ){
400  }
401 
402 } // end of namespace ROOT
403 
404 namespace ROOT {
405  // Wrappers around operator new
406  static void *new_GaudicLcLRootRef(void *p) {
407  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::Gaudi::RootRef : new ::Gaudi::RootRef;
408  }
409  static void *newArray_GaudicLcLRootRef(Long_t nElements, void *p) {
410  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::Gaudi::RootRef[nElements] : new ::Gaudi::RootRef[nElements];
411  }
412  // Wrapper around operator delete
413  static void delete_GaudicLcLRootRef(void *p) {
414  delete ((::Gaudi::RootRef*)p);
415  }
416  static void deleteArray_GaudicLcLRootRef(void *p) {
417  delete [] ((::Gaudi::RootRef*)p);
418  }
419  static void destruct_GaudicLcLRootRef(void *p) {
420  typedef ::Gaudi::RootRef current_t;
421  ((current_t*)p)->~current_t();
422  }
423 } // end of namespace ROOT for class ::Gaudi::RootRef
424 
425 namespace ROOT {
426  // Wrappers around operator new
427  static void *new_GaudicLcLRootObjectRefs(void *p) {
428  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::Gaudi::RootObjectRefs : new ::Gaudi::RootObjectRefs;
429  }
430  static void *newArray_GaudicLcLRootObjectRefs(Long_t nElements, void *p) {
431  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::Gaudi::RootObjectRefs[nElements] : new ::Gaudi::RootObjectRefs[nElements];
432  }
433  // Wrapper around operator delete
434  static void delete_GaudicLcLRootObjectRefs(void *p) {
435  delete ((::Gaudi::RootObjectRefs*)p);
436  }
437  static void deleteArray_GaudicLcLRootObjectRefs(void *p) {
438  delete [] ((::Gaudi::RootObjectRefs*)p);
439  }
440  static void destruct_GaudicLcLRootObjectRefs(void *p) {
441  typedef ::Gaudi::RootObjectRefs current_t;
442  ((current_t*)p)->~current_t();
443  }
444 } // end of namespace ROOT for class ::Gaudi::RootObjectRefs
445 
446 namespace ROOT {
447  // Wrappers around operator new
448  static void *new_GaudicLcLRootNTupleDescriptor(void *p) {
449  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::Gaudi::RootNTupleDescriptor : new ::Gaudi::RootNTupleDescriptor;
450  }
451  static void *newArray_GaudicLcLRootNTupleDescriptor(Long_t nElements, void *p) {
452  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::Gaudi::RootNTupleDescriptor[nElements] : new ::Gaudi::RootNTupleDescriptor[nElements];
453  }
454  // Wrapper around operator delete
455  static void delete_GaudicLcLRootNTupleDescriptor(void *p) {
456  delete ((::Gaudi::RootNTupleDescriptor*)p);
457  }
458  static void deleteArray_GaudicLcLRootNTupleDescriptor(void *p) {
459  delete [] ((::Gaudi::RootNTupleDescriptor*)p);
460  }
461  static void destruct_GaudicLcLRootNTupleDescriptor(void *p) {
462  typedef ::Gaudi::RootNTupleDescriptor current_t;
463  ((current_t*)p)->~current_t();
464  }
465 } // end of namespace ROOT for class ::Gaudi::RootNTupleDescriptor
466 
467 namespace ROOT {
468  // Wrappers around operator new
469  static void *new_poolcLcLGuid(void *p) {
470  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::pool::Guid : new ::pool::Guid;
471  }
472  static void *newArray_poolcLcLGuid(Long_t nElements, void *p) {
473  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::pool::Guid[nElements] : new ::pool::Guid[nElements];
474  }
475  // Wrapper around operator delete
476  static void delete_poolcLcLGuid(void *p) {
477  delete ((::pool::Guid*)p);
478  }
479  static void deleteArray_poolcLcLGuid(void *p) {
480  delete [] ((::pool::Guid*)p);
481  }
482  static void destruct_poolcLcLGuid(void *p) {
483  typedef ::pool::Guid current_t;
484  ((current_t*)p)->~current_t();
485  }
486 } // end of namespace ROOT for class ::pool::Guid
487 
488 namespace ROOT {
489  // Wrappers around operator new
490  static void *new_poolcLcLToken(void *p) {
491  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::pool::Token : new ::pool::Token;
492  }
493  static void *newArray_poolcLcLToken(Long_t nElements, void *p) {
494  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::pool::Token[nElements] : new ::pool::Token[nElements];
495  }
496  // Wrapper around operator delete
497  static void delete_poolcLcLToken(void *p) {
498  delete ((::pool::Token*)p);
499  }
500  static void deleteArray_poolcLcLToken(void *p) {
501  delete [] ((::pool::Token*)p);
502  }
503  static void destruct_poolcLcLToken(void *p) {
504  typedef ::pool::Token current_t;
505  ((current_t*)p)->~current_t();
506  }
507 } // end of namespace ROOT for class ::pool::Token
508 
509 namespace ROOT {
510  // Wrappers around operator new
511  static void *new_UCharDbArray(void *p) {
512  return p ? new(p) ::UCharDbArray : new ::UCharDbArray;
513  }
514  static void *newArray_UCharDbArray(Long_t nElements, void *p) {
515  return p ? new(p) ::UCharDbArray[nElements] : new ::UCharDbArray[nElements];
516  }
517  // Wrapper around operator delete
518  static void delete_UCharDbArray(void *p) {
519  delete ((::UCharDbArray*)p);
520  }
521  static void deleteArray_UCharDbArray(void *p) {
522  delete [] ((::UCharDbArray*)p);
523  }
524  static void destruct_UCharDbArray(void *p) {
525  typedef ::UCharDbArray current_t;
526  ((current_t*)p)->~current_t();
527  }
528 } // end of namespace ROOT for class ::UCharDbArray
529 
530 namespace ROOT {
531  // Wrappers around operator new
532  static void *new_PoolDbTokenWrap(void *p) {
533  return p ? new(p) ::PoolDbTokenWrap : new ::PoolDbTokenWrap;
534  }
535  static void *newArray_PoolDbTokenWrap(Long_t nElements, void *p) {
536  return p ? new(p) ::PoolDbTokenWrap[nElements] : new ::PoolDbTokenWrap[nElements];
537  }
538  // Wrapper around operator delete
539  static void delete_PoolDbTokenWrap(void *p) {
540  delete ((::PoolDbTokenWrap*)p);
541  }
542  static void deleteArray_PoolDbTokenWrap(void *p) {
543  delete [] ((::PoolDbTokenWrap*)p);
544  }
545  static void destruct_PoolDbTokenWrap(void *p) {
546  typedef ::PoolDbTokenWrap current_t;
547  ((current_t*)p)->~current_t();
548  }
549 } // end of namespace ROOT for class ::PoolDbTokenWrap
550 
551 namespace ROOT {
552  // Wrappers around operator new
553  static void *new_PoolDbLinkManager(void *p) {
554  return p ? new(p) ::PoolDbLinkManager : new ::PoolDbLinkManager;
555  }
556  static void *newArray_PoolDbLinkManager(Long_t nElements, void *p) {
557  return p ? new(p) ::PoolDbLinkManager[nElements] : new ::PoolDbLinkManager[nElements];
558  }
559  // Wrapper around operator delete
560  static void delete_PoolDbLinkManager(void *p) {
561  delete ((::PoolDbLinkManager*)p);
562  }
563  static void deleteArray_PoolDbLinkManager(void *p) {
564  delete [] ((::PoolDbLinkManager*)p);
565  }
566  static void destruct_PoolDbLinkManager(void *p) {
567  typedef ::PoolDbLinkManager current_t;
568  ((current_t*)p)->~current_t();
569  }
570 } // end of namespace ROOT for class ::PoolDbLinkManager
571 
572 namespace ROOT {
573  static TClass *vectorlEpoolcLcLTokenmUgR_Dictionary();
574  static void vectorlEpoolcLcLTokenmUgR_TClassManip(TClass*);
575  static void *new_vectorlEpoolcLcLTokenmUgR(void *p = 0);
576  static void *newArray_vectorlEpoolcLcLTokenmUgR(Long_t size, void *p);
577  static void delete_vectorlEpoolcLcLTokenmUgR(void *p);
578  static void deleteArray_vectorlEpoolcLcLTokenmUgR(void *p);
579  static void destruct_vectorlEpoolcLcLTokenmUgR(void *p);
580 
581  // Function generating the singleton type initializer
582  static TGenericClassInfo *GenerateInitInstanceLocal(const vector<pool::Token*>*)
583  {
584  vector<pool::Token*> *ptr = 0;
585  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<pool::Token*>));
586  static ::ROOT::TGenericClassInfo
587  instance("vector<pool::Token*>", -2, "vector", 214,
588  typeid(vector<pool::Token*>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
589  &vectorlEpoolcLcLTokenmUgR_Dictionary, isa_proxy, 4,
590  sizeof(vector<pool::Token*>) );
591  instance.SetNew(&new_vectorlEpoolcLcLTokenmUgR);
592  instance.SetNewArray(&newArray_vectorlEpoolcLcLTokenmUgR);
593  instance.SetDelete(&delete_vectorlEpoolcLcLTokenmUgR);
594  instance.SetDeleteArray(&deleteArray_vectorlEpoolcLcLTokenmUgR);
595  instance.SetDestructor(&destruct_vectorlEpoolcLcLTokenmUgR);
596  instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<pool::Token*> >()));
597  return &instance;
598  }
599  // Static variable to force the class initialization
600  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const vector<pool::Token*>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
601 
602  // Dictionary for non-ClassDef classes
603  static TClass *vectorlEpoolcLcLTokenmUgR_Dictionary() {
604  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector<pool::Token*>*)0x0)->GetClass();
605  vectorlEpoolcLcLTokenmUgR_TClassManip(theClass);
606  return theClass;
607  }
608 
609  static void vectorlEpoolcLcLTokenmUgR_TClassManip(TClass* ){
610  }
611 
612 } // end of namespace ROOT
613 
614 namespace ROOT {
615  // Wrappers around operator new
616  static void *new_vectorlEpoolcLcLTokenmUgR(void *p) {
617  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<pool::Token*> : new vector<pool::Token*>;
618  }
619  static void *newArray_vectorlEpoolcLcLTokenmUgR(Long_t nElements, void *p) {
620  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<pool::Token*>[nElements] : new vector<pool::Token*>[nElements];
621  }
622  // Wrapper around operator delete
623  static void delete_vectorlEpoolcLcLTokenmUgR(void *p) {
624  delete ((vector<pool::Token*>*)p);
625  }
626  static void deleteArray_vectorlEpoolcLcLTokenmUgR(void *p) {
627  delete [] ((vector<pool::Token*>*)p);
628  }
629  static void destruct_vectorlEpoolcLcLTokenmUgR(void *p) {
630  typedef vector<pool::Token*> current_t;
631  ((current_t*)p)->~current_t();
632  }
633 } // end of namespace ROOT for class vector<pool::Token*>
634 
635 namespace ROOT {
636  static TClass *vectorlEGaudicLcLRootRefgR_Dictionary();
637  static void vectorlEGaudicLcLRootRefgR_TClassManip(TClass*);
638  static void *new_vectorlEGaudicLcLRootRefgR(void *p = 0);
639  static void *newArray_vectorlEGaudicLcLRootRefgR(Long_t size, void *p);
640  static void delete_vectorlEGaudicLcLRootRefgR(void *p);
641  static void deleteArray_vectorlEGaudicLcLRootRefgR(void *p);
642  static void destruct_vectorlEGaudicLcLRootRefgR(void *p);
643 
644  // Function generating the singleton type initializer
645  static TGenericClassInfo *GenerateInitInstanceLocal(const vector<Gaudi::RootRef>*)
646  {
647  vector<Gaudi::RootRef> *ptr = 0;
648  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<Gaudi::RootRef>));
649  static ::ROOT::TGenericClassInfo
650  instance("vector<Gaudi::RootRef>", -2, "vector", 214,
651  typeid(vector<Gaudi::RootRef>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
652  &vectorlEGaudicLcLRootRefgR_Dictionary, isa_proxy, 4,
653  sizeof(vector<Gaudi::RootRef>) );
654  instance.SetNew(&new_vectorlEGaudicLcLRootRefgR);
655  instance.SetNewArray(&newArray_vectorlEGaudicLcLRootRefgR);
656  instance.SetDelete(&delete_vectorlEGaudicLcLRootRefgR);
657  instance.SetDeleteArray(&deleteArray_vectorlEGaudicLcLRootRefgR);
658  instance.SetDestructor(&destruct_vectorlEGaudicLcLRootRefgR);
659  instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<Gaudi::RootRef> >()));
660  return &instance;
661  }
662  // Static variable to force the class initialization
663  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const vector<Gaudi::RootRef>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
664 
665  // Dictionary for non-ClassDef classes
666  static TClass *vectorlEGaudicLcLRootRefgR_Dictionary() {
667  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector<Gaudi::RootRef>*)0x0)->GetClass();
668  vectorlEGaudicLcLRootRefgR_TClassManip(theClass);
669  return theClass;
670  }
671 
672  static void vectorlEGaudicLcLRootRefgR_TClassManip(TClass* ){
673  }
674 
675 } // end of namespace ROOT
676 
677 namespace ROOT {
678  // Wrappers around operator new
679  static void *new_vectorlEGaudicLcLRootRefgR(void *p) {
680  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<Gaudi::RootRef> : new vector<Gaudi::RootRef>;
681  }
682  static void *newArray_vectorlEGaudicLcLRootRefgR(Long_t nElements, void *p) {
683  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<Gaudi::RootRef>[nElements] : new vector<Gaudi::RootRef>[nElements];
684  }
685  // Wrapper around operator delete
686  static void delete_vectorlEGaudicLcLRootRefgR(void *p) {
687  delete ((vector<Gaudi::RootRef>*)p);
688  }
689  static void deleteArray_vectorlEGaudicLcLRootRefgR(void *p) {
690  delete [] ((vector<Gaudi::RootRef>*)p);
691  }
692  static void destruct_vectorlEGaudicLcLRootRefgR(void *p) {
693  typedef vector<Gaudi::RootRef> current_t;
694  ((current_t*)p)->~current_t();
695  }
696 } // end of namespace ROOT for class vector<Gaudi::RootRef>
697 
698 namespace {
699  void TriggerDictionaryInitialization_RootCnvDict_Impl() {
700  static const char* headers[] = {
701 0 };
702  static const char* includePaths[] = {
703 "/builds/gaudi/Gaudi/RootCnv",
704 "/builds/gaudi/Gaudi/GaudiUtils",
705 "/builds/gaudi/Gaudi/GaudiPluginService",
706 "/builds/gaudi/Gaudi/GaudiKernel",
707 "/cvmfs/sft.cern.ch/lcg/releases/LCG_93/AIDA/3.2.1/x86_64-centos7-gcc62-opt/src/cpp",
708 "/cvmfs/sft.cern.ch/lcg/releases/LCG_93/tbb/2018_U1/x86_64-centos7-gcc62-opt/include",
709 "/cvmfs/sft.cern.ch/lcg/releases/LCG_93/ROOT/6.12.06/x86_64-centos7-gcc62-opt/include",
710 "/cvmfs/sft.cern.ch/lcg/releases/LCG_93/Boost/1.66.0/x86_64-centos7-gcc62-opt/include",
711 "/builds/gaudi/Gaudi/build-gcc62/include",
712 "/cvmfs/sft.cern.ch/lcg/releases/LCG_93/rangev3/0.3.0/x86_64-centos7-gcc62-opt/include",
713 "/cvmfs/sft.cern.ch/lcg/releases/ROOT/6.12.06-51921/x86_64-centos7-gcc62-opt/include",
714 "/builds/gaudi/Gaudi/build-gcc62/RootCnv/",
715 0
716  };
717  static const char* fwdDeclCode = R"DICTFWDDCLS(
718 #line 1 "RootCnvDict dictionary forward declarations' payload"
719 #pragma clang diagnostic ignored "-Wkeyword-compat"
720 #pragma clang diagnostic ignored "-Wignored-attributes"
721 #pragma clang diagnostic ignored "-Wreturn-type-c-linkage"
722 extern int __Cling_Autoloading_Map;
723 namespace Gaudi{struct __attribute__((annotate("$clingAutoload$RootCnv/RootRefs.h"))) RootRef;}
724 namespace std{template <typename _Tp> class __attribute__((annotate("$clingAutoload$bits/allocator.h"))) __attribute__((annotate("$clingAutoload$string"))) allocator;
725 }
726 namespace pool{class __attribute__((annotate("$clingAutoload$RootCnv/PoolClasses.h"))) Token;}
727 namespace Gaudi{struct __attribute__((annotate("$clingAutoload$RootCnv/RootRefs.h"))) RootObjectRefs;}
728 namespace Gaudi{struct __attribute__((annotate("$clingAutoload$RootCnv/RootRefs.h"))) RootNTupleDescriptor;}
729 namespace pool{class __attribute__((annotate("$clingAutoload$RootCnv/PoolClasses.h"))) Guid;}
730 struct __attribute__((annotate("$clingAutoload$RootCnv/PoolClasses.h"))) UCharDbArray;
731 class __attribute__((annotate("$clingAutoload$RootCnv/PoolClasses.h"))) PoolDbTokenWrap;
732 class __attribute__((annotate("$clingAutoload$RootCnv/PoolClasses.h"))) PoolDbLinkManager;
733 )DICTFWDDCLS";
734  static const char* payloadCode = R"DICTPAYLOAD(
735 #line 1 "RootCnvDict dictionary payload"
736 #ifdef _Instantiations
737  #undef _Instantiations
738 #endif
739 
740 #ifndef G__VECTOR_HAS_CLASS_ITERATOR
741  #define G__VECTOR_HAS_CLASS_ITERATOR 1
742 #endif
743 #ifndef _Instantiations
744  #define _Instantiations RootCnv_Instantiations
745 #endif
746 #ifndef _GNU_SOURCE
747  #define _GNU_SOURCE 1
748 #endif
749 #ifndef unix
750  #define unix 1
751 #endif
752 #ifndef f2cFortran
753  #define f2cFortran 1
754 #endif
755 #ifndef linux
756  #define linux 1
757 #endif
758 #ifndef GAUDI_V20_COMPAT
759  #define GAUDI_V20_COMPAT 1
760 #endif
761 #ifndef BOOST_FILESYSTEM_VERSION
762  #define BOOST_FILESYSTEM_VERSION 3
763 #endif
764 #ifndef BOOST_SPIRIT_USE_PHOENIX_V3
765  #define BOOST_SPIRIT_USE_PHOENIX_V3 1
766 #endif
767 #ifndef PACKAGE_NAME
768  #define PACKAGE_NAME "RootCnv"
769 #endif
770 #ifndef PACKAGE_VERSION
771  #define PACKAGE_VERSION "v30r3"
772 #endif
773 #ifndef __POOL_COMPATIBILITY
774  #define __POOL_COMPATIBILITY 1
775 #endif
776 #ifndef NDEBUG
777  #define NDEBUG 1
778 #endif
779 
780 #define _BACKWARD_BACKWARD_WARNING_H
781 #include "RootCnv/RootRefs.h"
782 
783 #ifdef __POOL_COMPATIBILITY
784 #include "RootCnv/PoolClasses.h"
785 #if 0
786 //typedef Gaudi::RootNTupleDescriptor PoolDbNTupleDescriptor;
787 class PoolDbNTupleDescriptor {
788  public:
790  std::string description;
792  std::string optional;
794  std::string container;
796  unsigned long clid;
798  PoolDbNTupleDescriptor() {}
800  virtual ~PoolDbNTupleDescriptor() {}
801 };
802 #endif
803 #endif
804 
805 // Add here addition include files for the dictionary generation
806 namespace RootCnv
807 {
808  struct __Instantiations {
809  };
810 }
811 
812 #undef _BACKWARD_BACKWARD_WARNING_H
813 )DICTPAYLOAD";
814  static const char* classesHeaders[]={
815 "Gaudi::RootNTupleDescriptor", payloadCode, "@",
816 "Gaudi::RootObjectRefs", payloadCode, "@",
817 "Gaudi::RootRef", payloadCode, "@",
818 "PoolDbLinkManager", payloadCode, "@",
819 "PoolDbTokenWrap", payloadCode, "@",
820 "UCharDbArray", payloadCode, "@",
821 "pool::Guid", payloadCode, "@",
822 "pool::Token", payloadCode, "@",
823 nullptr};
824 
825  static bool isInitialized = false;
826  if (!isInitialized) {
827  TROOT::RegisterModule("RootCnvDict",
828  headers, includePaths, payloadCode, fwdDeclCode,
829  TriggerDictionaryInitialization_RootCnvDict_Impl, {}, classesHeaders);
830  isInitialized = true;
831  }
832  }
833  static struct DictInit {
834  DictInit() {
835  TriggerDictionaryInitialization_RootCnvDict_Impl();
836  }
837  } __TheDictionaryInitializer;
838 }
839 void TriggerDictionaryInitialization_RootCnvDict() {
840  TriggerDictionaryInitialization_RootCnvDict_Impl();
841 }
TriggerDictionaryInitialization_RootCnvDict
void TriggerDictionaryInitialization_RootCnvDict()
Definition: RootCnvDict.cpp:839
std
STL namespace.
Gaudi::RootObjectRefs
Persistent reference object containing all leafs and links corresponding to a Gaudi DataObject...
Definition: RootRefs.h:60
details::size
constexpr auto size(const C &c) noexcept(noexcept(c.size())) -> decltype(c.size())
Definition: AnyDataWrapper.h:14
UCharDbArray
Shadow class to mimik POOL blobs.
Definition: PoolClasses.h:48
ROOT::GenerateInitInstance
TGenericClassInfo * GenerateInitInstance(const ::PoolDbLinkManager *)
Definition: RootCnvDict.cpp:385
Gaudi::RootRef
Persistent reference object.
Definition: RootRefs.h:31
pool::Token
Shadow class to mimik POOL tokens.
Definition: PoolClasses.h:26
PoolDbTokenWrap
Description:
Definition: PoolClasses.h:71
Genfun::GaudiMathImplementation::ROOT::R__UseDummy
R__UseDummy(_R__UNIQUE_DICT_(Init))