BAT  0.9.4
The Bayesian analysis toolkit
 All Classes Namespaces Functions Variables Enumerations
libBATmvc_rdict.cxx
1 // Do NOT change. Changes will be lost next time file is generated
2 
3 #define R__DICTIONARY_FILENAME libBATmvc_rdictdOcxx
4 
5 /*******************************************************************/
6 #include <stddef.h>
7 #include <stdio.h>
8 #include <stdlib.h>
9 #include <math.h>
10 #include <string.h>
11 #include <assert.h>
12 #define G__DICTIONARY
13 #include "RConfig.h"
14 #include "TClass.h"
15 #include "TDictAttributeMap.h"
16 #include "TInterpreter.h"
17 #include "TROOT.h"
18 #include "TBuffer.h"
19 #include "TMemberInspector.h"
20 #include "TInterpreter.h"
21 #include "TVirtualMutex.h"
22 #include "TError.h"
23 
24 #ifndef G__ROOT
25 #define G__ROOT
26 #endif
27 
28 #include "RtypesImp.h"
29 #include "TIsAProxy.h"
30 #include "TFileMergeInfo.h"
31 #include <algorithm>
32 #include "TCollectionProxyInfo.h"
33 /*******************************************************************/
34 
35 #include "TDataMember.h"
36 
37 // Since CINT ignores the std namespace, we need to do so in this file.
38 namespace std {} using namespace std;
39 
40 // Header files passed as explicit arguments
41 #include "BCMVCombination.h"
42 #include "BCMVCUncertainty.h"
43 #include "BCMVCMeasurement.h"
44 #include "BCMVCObservable.h"
45 #include "BCMVCDataModel.h"
46 #include "BCMVCPhysicsModel.h"
47 
48 // Header files passed via #pragma extra_include
49 
50 namespace ROOT {
51  static TClass *BCMVCDataModel_Dictionary();
52  static void BCMVCDataModel_TClassManip(TClass*);
53  static void delete_BCMVCDataModel(void *p);
54  static void deleteArray_BCMVCDataModel(void *p);
55  static void destruct_BCMVCDataModel(void *p);
56 
57  // Function generating the singleton type initializer
58  static TGenericClassInfo *GenerateInitInstanceLocal(const ::BCMVCDataModel*)
59  {
60  ::BCMVCDataModel *ptr = 0;
61  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::BCMVCDataModel),0);
62  static ::ROOT::TGenericClassInfo
63  instance("BCMVCDataModel", "BAT/BCMVCDataModel.h", 24,
64  typeid(::BCMVCDataModel), DefineBehavior(ptr, ptr),
65  &BCMVCDataModel_Dictionary, isa_proxy, 0,
66  sizeof(::BCMVCDataModel) );
67  instance.SetDelete(&delete_BCMVCDataModel);
68  instance.SetDeleteArray(&deleteArray_BCMVCDataModel);
69  instance.SetDestructor(&destruct_BCMVCDataModel);
70  return &instance;
71  }
72  TGenericClassInfo *GenerateInitInstance(const ::BCMVCDataModel*)
73  {
74  return GenerateInitInstanceLocal((::BCMVCDataModel*)0);
75  }
76  // Static variable to force the class initialization
77  static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::BCMVCDataModel*)0x0); R__UseDummy(_R__UNIQUE_(Init));
78 
79  // Dictionary for non-ClassDef classes
80  static TClass *BCMVCDataModel_Dictionary() {
81  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::BCMVCDataModel*)0x0)->GetClass();
82  BCMVCDataModel_TClassManip(theClass);
83  return theClass;
84  }
85 
86  static void BCMVCDataModel_TClassManip(TClass* ){
87  }
88 
89 } // end of namespace ROOT
90 
91 namespace ROOT {
92  static TClass *BCMVCMeasurement_Dictionary();
93  static void BCMVCMeasurement_TClassManip(TClass*);
94  static void delete_BCMVCMeasurement(void *p);
95  static void deleteArray_BCMVCMeasurement(void *p);
96  static void destruct_BCMVCMeasurement(void *p);
97 
98  // Function generating the singleton type initializer
99  static TGenericClassInfo *GenerateInitInstanceLocal(const ::BCMVCMeasurement*)
100  {
101  ::BCMVCMeasurement *ptr = 0;
102  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::BCMVCMeasurement),0);
103  static ::ROOT::TGenericClassInfo
104  instance("BCMVCMeasurement", "BAT/BCMVCMeasurement.h", 18,
105  typeid(::BCMVCMeasurement), DefineBehavior(ptr, ptr),
106  &BCMVCMeasurement_Dictionary, isa_proxy, 0,
107  sizeof(::BCMVCMeasurement) );
108  instance.SetDelete(&delete_BCMVCMeasurement);
109  instance.SetDeleteArray(&deleteArray_BCMVCMeasurement);
110  instance.SetDestructor(&destruct_BCMVCMeasurement);
111  return &instance;
112  }
113  TGenericClassInfo *GenerateInitInstance(const ::BCMVCMeasurement*)
114  {
115  return GenerateInitInstanceLocal((::BCMVCMeasurement*)0);
116  }
117  // Static variable to force the class initialization
118  static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::BCMVCMeasurement*)0x0); R__UseDummy(_R__UNIQUE_(Init));
119 
120  // Dictionary for non-ClassDef classes
121  static TClass *BCMVCMeasurement_Dictionary() {
122  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::BCMVCMeasurement*)0x0)->GetClass();
123  BCMVCMeasurement_TClassManip(theClass);
124  return theClass;
125  }
126 
127  static void BCMVCMeasurement_TClassManip(TClass* ){
128  }
129 
130 } // end of namespace ROOT
131 
132 namespace ROOT {
133  static TClass *BCMVCObservable_Dictionary();
134  static void BCMVCObservable_TClassManip(TClass*);
135  static void *new_BCMVCObservable(void *p = 0);
136  static void *newArray_BCMVCObservable(Long_t size, void *p);
137  static void delete_BCMVCObservable(void *p);
138  static void deleteArray_BCMVCObservable(void *p);
139  static void destruct_BCMVCObservable(void *p);
140 
141  // Function generating the singleton type initializer
142  static TGenericClassInfo *GenerateInitInstanceLocal(const ::BCMVCObservable*)
143  {
144  ::BCMVCObservable *ptr = 0;
145  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::BCMVCObservable),0);
146  static ::ROOT::TGenericClassInfo
147  instance("BCMVCObservable", "BAT/BCMVCObservable.h", 17,
148  typeid(::BCMVCObservable), DefineBehavior(ptr, ptr),
149  &BCMVCObservable_Dictionary, isa_proxy, 0,
150  sizeof(::BCMVCObservable) );
151  instance.SetNew(&new_BCMVCObservable);
152  instance.SetNewArray(&newArray_BCMVCObservable);
153  instance.SetDelete(&delete_BCMVCObservable);
154  instance.SetDeleteArray(&deleteArray_BCMVCObservable);
155  instance.SetDestructor(&destruct_BCMVCObservable);
156  return &instance;
157  }
158  TGenericClassInfo *GenerateInitInstance(const ::BCMVCObservable*)
159  {
160  return GenerateInitInstanceLocal((::BCMVCObservable*)0);
161  }
162  // Static variable to force the class initialization
163  static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::BCMVCObservable*)0x0); R__UseDummy(_R__UNIQUE_(Init));
164 
165  // Dictionary for non-ClassDef classes
166  static TClass *BCMVCObservable_Dictionary() {
167  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::BCMVCObservable*)0x0)->GetClass();
168  BCMVCObservable_TClassManip(theClass);
169  return theClass;
170  }
171 
172  static void BCMVCObservable_TClassManip(TClass* ){
173  }
174 
175 } // end of namespace ROOT
176 
177 namespace ROOT {
178  static TClass *BCMVCombination_Dictionary();
179  static void BCMVCombination_TClassManip(TClass*);
180  static void *new_BCMVCombination(void *p = 0);
181  static void *newArray_BCMVCombination(Long_t size, void *p);
182  static void delete_BCMVCombination(void *p);
183  static void deleteArray_BCMVCombination(void *p);
184  static void destruct_BCMVCombination(void *p);
185 
186  // Function generating the singleton type initializer
187  static TGenericClassInfo *GenerateInitInstanceLocal(const ::BCMVCombination*)
188  {
189  ::BCMVCombination *ptr = 0;
190  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::BCMVCombination),0);
191  static ::ROOT::TGenericClassInfo
192  instance("BCMVCombination", "BAT/BCMVCombination.h", 26,
193  typeid(::BCMVCombination), DefineBehavior(ptr, ptr),
194  &BCMVCombination_Dictionary, isa_proxy, 0,
195  sizeof(::BCMVCombination) );
196  instance.SetNew(&new_BCMVCombination);
197  instance.SetNewArray(&newArray_BCMVCombination);
198  instance.SetDelete(&delete_BCMVCombination);
199  instance.SetDeleteArray(&deleteArray_BCMVCombination);
200  instance.SetDestructor(&destruct_BCMVCombination);
201  return &instance;
202  }
203  TGenericClassInfo *GenerateInitInstance(const ::BCMVCombination*)
204  {
205  return GenerateInitInstanceLocal((::BCMVCombination*)0);
206  }
207  // Static variable to force the class initialization
208  static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::BCMVCombination*)0x0); R__UseDummy(_R__UNIQUE_(Init));
209 
210  // Dictionary for non-ClassDef classes
211  static TClass *BCMVCombination_Dictionary() {
212  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::BCMVCombination*)0x0)->GetClass();
213  BCMVCombination_TClassManip(theClass);
214  return theClass;
215  }
216 
217  static void BCMVCombination_TClassManip(TClass* ){
218  }
219 
220 } // end of namespace ROOT
221 
222 namespace ROOT {
223  static TClass *BCMVCPhysicsModel_Dictionary();
224  static void BCMVCPhysicsModel_TClassManip(TClass*);
225  static void *new_BCMVCPhysicsModel(void *p = 0);
226  static void *newArray_BCMVCPhysicsModel(Long_t size, void *p);
227  static void delete_BCMVCPhysicsModel(void *p);
228  static void deleteArray_BCMVCPhysicsModel(void *p);
229  static void destruct_BCMVCPhysicsModel(void *p);
230 
231  // Function generating the singleton type initializer
232  static TGenericClassInfo *GenerateInitInstanceLocal(const ::BCMVCPhysicsModel*)
233  {
234  ::BCMVCPhysicsModel *ptr = 0;
235  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::BCMVCPhysicsModel),0);
236  static ::ROOT::TGenericClassInfo
237  instance("BCMVCPhysicsModel", "BAT/BCMVCPhysicsModel.h", 17,
238  typeid(::BCMVCPhysicsModel), DefineBehavior(ptr, ptr),
239  &BCMVCPhysicsModel_Dictionary, isa_proxy, 0,
240  sizeof(::BCMVCPhysicsModel) );
241  instance.SetNew(&new_BCMVCPhysicsModel);
242  instance.SetNewArray(&newArray_BCMVCPhysicsModel);
243  instance.SetDelete(&delete_BCMVCPhysicsModel);
244  instance.SetDeleteArray(&deleteArray_BCMVCPhysicsModel);
245  instance.SetDestructor(&destruct_BCMVCPhysicsModel);
246  return &instance;
247  }
248  TGenericClassInfo *GenerateInitInstance(const ::BCMVCPhysicsModel*)
249  {
250  return GenerateInitInstanceLocal((::BCMVCPhysicsModel*)0);
251  }
252  // Static variable to force the class initialization
253  static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::BCMVCPhysicsModel*)0x0); R__UseDummy(_R__UNIQUE_(Init));
254 
255  // Dictionary for non-ClassDef classes
256  static TClass *BCMVCPhysicsModel_Dictionary() {
257  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::BCMVCPhysicsModel*)0x0)->GetClass();
258  BCMVCPhysicsModel_TClassManip(theClass);
259  return theClass;
260  }
261 
262  static void BCMVCPhysicsModel_TClassManip(TClass* ){
263  }
264 
265 } // end of namespace ROOT
266 
267 namespace ROOT {
268  static TClass *BCMVCUncertainty_Dictionary();
269  static void BCMVCUncertainty_TClassManip(TClass*);
270  static void delete_BCMVCUncertainty(void *p);
271  static void deleteArray_BCMVCUncertainty(void *p);
272  static void destruct_BCMVCUncertainty(void *p);
273 
274  // Function generating the singleton type initializer
275  static TGenericClassInfo *GenerateInitInstanceLocal(const ::BCMVCUncertainty*)
276  {
277  ::BCMVCUncertainty *ptr = 0;
278  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::BCMVCUncertainty),0);
279  static ::ROOT::TGenericClassInfo
280  instance("BCMVCUncertainty", "BAT/BCMVCUncertainty.h", 22,
281  typeid(::BCMVCUncertainty), DefineBehavior(ptr, ptr),
282  &BCMVCUncertainty_Dictionary, isa_proxy, 0,
283  sizeof(::BCMVCUncertainty) );
284  instance.SetDelete(&delete_BCMVCUncertainty);
285  instance.SetDeleteArray(&deleteArray_BCMVCUncertainty);
286  instance.SetDestructor(&destruct_BCMVCUncertainty);
287  return &instance;
288  }
289  TGenericClassInfo *GenerateInitInstance(const ::BCMVCUncertainty*)
290  {
291  return GenerateInitInstanceLocal((::BCMVCUncertainty*)0);
292  }
293  // Static variable to force the class initialization
294  static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::BCMVCUncertainty*)0x0); R__UseDummy(_R__UNIQUE_(Init));
295 
296  // Dictionary for non-ClassDef classes
297  static TClass *BCMVCUncertainty_Dictionary() {
298  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::BCMVCUncertainty*)0x0)->GetClass();
299  BCMVCUncertainty_TClassManip(theClass);
300  return theClass;
301  }
302 
303  static void BCMVCUncertainty_TClassManip(TClass* ){
304  }
305 
306 } // end of namespace ROOT
307 
308 namespace ROOT {
309  // Wrapper around operator delete
310  static void delete_BCMVCDataModel(void *p) {
311  delete ((::BCMVCDataModel*)p);
312  }
313  static void deleteArray_BCMVCDataModel(void *p) {
314  delete [] ((::BCMVCDataModel*)p);
315  }
316  static void destruct_BCMVCDataModel(void *p) {
317  typedef ::BCMVCDataModel current_t;
318  ((current_t*)p)->~current_t();
319  }
320 } // end of namespace ROOT for class ::BCMVCDataModel
321 
322 namespace ROOT {
323  // Wrapper around operator delete
324  static void delete_BCMVCMeasurement(void *p) {
325  delete ((::BCMVCMeasurement*)p);
326  }
327  static void deleteArray_BCMVCMeasurement(void *p) {
328  delete [] ((::BCMVCMeasurement*)p);
329  }
330  static void destruct_BCMVCMeasurement(void *p) {
331  typedef ::BCMVCMeasurement current_t;
332  ((current_t*)p)->~current_t();
333  }
334 } // end of namespace ROOT for class ::BCMVCMeasurement
335 
336 namespace ROOT {
337  // Wrappers around operator new
338  static void *new_BCMVCObservable(void *p) {
339  return p ? new(p) ::BCMVCObservable : new ::BCMVCObservable;
340  }
341  static void *newArray_BCMVCObservable(Long_t nElements, void *p) {
342  return p ? new(p) ::BCMVCObservable[nElements] : new ::BCMVCObservable[nElements];
343  }
344  // Wrapper around operator delete
345  static void delete_BCMVCObservable(void *p) {
346  delete ((::BCMVCObservable*)p);
347  }
348  static void deleteArray_BCMVCObservable(void *p) {
349  delete [] ((::BCMVCObservable*)p);
350  }
351  static void destruct_BCMVCObservable(void *p) {
352  typedef ::BCMVCObservable current_t;
353  ((current_t*)p)->~current_t();
354  }
355 } // end of namespace ROOT for class ::BCMVCObservable
356 
357 namespace ROOT {
358  // Wrappers around operator new
359  static void *new_BCMVCombination(void *p) {
360  return p ? new(p) ::BCMVCombination : new ::BCMVCombination;
361  }
362  static void *newArray_BCMVCombination(Long_t nElements, void *p) {
363  return p ? new(p) ::BCMVCombination[nElements] : new ::BCMVCombination[nElements];
364  }
365  // Wrapper around operator delete
366  static void delete_BCMVCombination(void *p) {
367  delete ((::BCMVCombination*)p);
368  }
369  static void deleteArray_BCMVCombination(void *p) {
370  delete [] ((::BCMVCombination*)p);
371  }
372  static void destruct_BCMVCombination(void *p) {
373  typedef ::BCMVCombination current_t;
374  ((current_t*)p)->~current_t();
375  }
376 } // end of namespace ROOT for class ::BCMVCombination
377 
378 namespace ROOT {
379  // Wrappers around operator new
380  static void *new_BCMVCPhysicsModel(void *p) {
381  return p ? new(p) ::BCMVCPhysicsModel : new ::BCMVCPhysicsModel;
382  }
383  static void *newArray_BCMVCPhysicsModel(Long_t nElements, void *p) {
384  return p ? new(p) ::BCMVCPhysicsModel[nElements] : new ::BCMVCPhysicsModel[nElements];
385  }
386  // Wrapper around operator delete
387  static void delete_BCMVCPhysicsModel(void *p) {
388  delete ((::BCMVCPhysicsModel*)p);
389  }
390  static void deleteArray_BCMVCPhysicsModel(void *p) {
391  delete [] ((::BCMVCPhysicsModel*)p);
392  }
393  static void destruct_BCMVCPhysicsModel(void *p) {
394  typedef ::BCMVCPhysicsModel current_t;
395  ((current_t*)p)->~current_t();
396  }
397 } // end of namespace ROOT for class ::BCMVCPhysicsModel
398 
399 namespace ROOT {
400  // Wrapper around operator delete
401  static void delete_BCMVCUncertainty(void *p) {
402  delete ((::BCMVCUncertainty*)p);
403  }
404  static void deleteArray_BCMVCUncertainty(void *p) {
405  delete [] ((::BCMVCUncertainty*)p);
406  }
407  static void destruct_BCMVCUncertainty(void *p) {
408  typedef ::BCMVCUncertainty current_t;
409  ((current_t*)p)->~current_t();
410  }
411 } // end of namespace ROOT for class ::BCMVCUncertainty
412 
413 namespace {
414  void TriggerDictionaryInitialization_libBATmvc_Impl() {
415  static const char* headers[] = {
416 "BAT/BCMVCombination.h",
417 "BAT/BCMVCUncertainty.h",
418 "BAT/BCMVCMeasurement.h",
419 "BAT/BCMVCObservable.h",
420 "BAT/BCMVCDataModel.h",
421 "BAT/BCMVCPhysicsModel.h",
422 0
423  };
424  static const char* includePaths[] = {
425 "/home/beaujean/.local/sw/cuba/linux-ubuntu-14.04-x86_64/4.0/include",
426 "/home/beaujean/.local/sw/cuba/linux-ubuntu-14.04-x86_64/4.0/include",
427 "/home/beaujean/.local/sw/bat/linux-ubuntu-14.04-x86_64/0.9.4/include",
428 "/home/beaujean/.local/sw/root/linux-ubuntu-14.04-x86_64/6.02.00/include/root",
429 0
430  };
431  static const char* fwdDeclCode =
432 R"DICTFWDDCLS(
433 #pragma clang diagnostic ignored "-Wkeyword-compat"
434 #pragma clang diagnostic ignored "-Wignored-attributes"
435 #pragma clang diagnostic ignored "-Wreturn-type-c-linkage"
436 extern int __Cling_Autoloading_Map;
437 class __attribute__((annotate("$clingAutoload$BAT/BCMVCDataModel.h"))) BCMVCDataModel;
438 class __attribute__((annotate("$clingAutoload$BAT/BCMVCMeasurement.h"))) BCMVCMeasurement;
439 class __attribute__((annotate("$clingAutoload$BAT/BCMVCObservable.h"))) BCMVCObservable;
440 class __attribute__((annotate("$clingAutoload$BAT/BCMVCombination.h"))) BCMVCombination;
441 class __attribute__((annotate("$clingAutoload$BAT/BCMVCPhysicsModel.h"))) BCMVCPhysicsModel;
442 class __attribute__((annotate("$clingAutoload$BAT/BCMVCUncertainty.h"))) BCMVCUncertainty;
443 )DICTFWDDCLS";
444  static const char* payloadCode = R"DICTPAYLOAD(
445 
446 #ifndef G__VECTOR_HAS_CLASS_ITERATOR
447  #define G__VECTOR_HAS_CLASS_ITERATOR
448 #endif
449 
450 #define _BACKWARD_BACKWARD_WARNING_H
451 #include <BAT/BCMVCombination.h>
452 #include <BAT/BCMVCUncertainty.h>
453 #include <BAT/BCMVCMeasurement.h>
454 #include <BAT/BCMVCObservable.h>
455 #include <BAT/BCMVCDataModel.h>
456 #include <BAT/BCMVCPhysicsModel.h>
457 
458 #undef _BACKWARD_BACKWARD_WARNING_H
459 )DICTPAYLOAD";
460  static const char* classesHeaders[]={
461 "BCMVCDataModel", payloadCode, "@",
462 "BCMVCMeasurement", payloadCode, "@",
463 "BCMVCObservable", payloadCode, "@",
464 "BCMVCPhysicsModel", payloadCode, "@",
465 "BCMVCUncertainty", payloadCode, "@",
466 "BCMVCombination", payloadCode, "@",
467 nullptr};
468 
469  static bool isInitialized = false;
470  if (!isInitialized) {
471  TROOT::RegisterModule("libBATmvc",
472  headers, includePaths, payloadCode, fwdDeclCode,
473  TriggerDictionaryInitialization_libBATmvc_Impl, {}, classesHeaders);
474  isInitialized = true;
475  }
476  }
477  static struct DictInit {
478  DictInit() {
479  TriggerDictionaryInitialization_libBATmvc_Impl();
480  }
481  } __TheDictionaryInitializer;
482 }
483 void TriggerDictionaryInitialization_libBATmvc() {
484  TriggerDictionaryInitialization_libBATmvc_Impl();
485 }