BOSS 7.1.0
BESIII Offline Software System
Loading...
Searching...
No Matches
BesVisLib/BesVisLib_rootcint.cxx
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 dOdOdIBesVisLibdIBesVisLib_rootcint
4#define R__NO_DEPRECATION
5
6/*******************************************************************/
7#include <stddef.h>
8#include <stdio.h>
9#include <stdlib.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// The generated code does not explicitly qualifies STL entities
38namespace std {} using namespace std;
39
40// Header files passed as explicit arguments
41#include "../BesVisLib/Bes2DView.h"
42#include "../BesVisLib/BesCircle2D.h"
43#include "../BesVisLib/BesCursor.h"
44#include "../BesVisLib/BesEvent.h"
45#include "../BesVisLib/BesEventHeader.h"
46#include "../BesVisLib/BesGeometry.h"
47#include "../BesVisLib/BesGeoTrack.h"
48#include "../BesVisLib/BesGMenuBar.h"
49#include "../BesVisLib/BesGMenuTitle.h"
50#include "../BesVisLib/BesGPictureButton.h"
51#include "../BesVisLib/BesHeader.h"
52#include "../BesVisLib/BesMarker2D.h"
53#include "../BesVisLib/BesPaveText.h"
54#include "../BesVisLib/BesPolygon2D.h"
55#include "../BesVisLib/BesStatus.h"
56#include "../BesVisLib/BesView.h"
57#include "../BesVisLib/BesVisDisplay.h"
58#include "../BesVisLib/Emc2DCrystal.h"
59#include "../BesVisLib/EmcROOTGeo.h"
60#include "../BesVisLib/Mdc2DWire.h"
61#include "../BesVisLib/BesTView.h"
62#include "../BesVisLib/MdcROOTGeo.h"
63#include "../BesVisLib/Muc2DStrip.h"
64#include "../BesVisLib/MucROOTGeo.h"
65#include "../BesVisLib/SubDetectorROOTGeo.h"
66#include "../BesVisLib/Tof2DScin.h"
67#include "../BesVisLib/TofROOTGeo.h"
68#include "../BesVisLib/ZHelix.h"
69#include "../BesVisLib/vector3.h"
70#include "../BesVisLib/DstConvert.h"
71
72// Header files passed via #pragma extra_include
73
74namespace ROOT {
75 static void *new_BesStatus(void *p = 0);
76 static void *newArray_BesStatus(Long_t size, void *p);
77 static void delete_BesStatus(void *p);
78 static void deleteArray_BesStatus(void *p);
79 static void destruct_BesStatus(void *p);
80
81 // Function generating the singleton type initializer
82 static TGenericClassInfo *GenerateInitInstanceLocal(const ::BesStatus*)
83 {
84 ::BesStatus *ptr = 0;
85 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::BesStatus >(0);
86 static ::ROOT::TGenericClassInfo
87 instance("BesStatus", ::BesStatus::Class_Version(), "BesStatus.h", 27,
88 typeid(::BesStatus), ::ROOT::Internal::DefineBehavior(ptr, ptr),
89 &::BesStatus::Dictionary, isa_proxy, 4,
90 sizeof(::BesStatus) );
91 instance.SetNew(&new_BesStatus);
92 instance.SetNewArray(&newArray_BesStatus);
93 instance.SetDelete(&delete_BesStatus);
94 instance.SetDeleteArray(&deleteArray_BesStatus);
95 instance.SetDestructor(&destruct_BesStatus);
96 return &instance;
97 }
98 TGenericClassInfo *GenerateInitInstance(const ::BesStatus*)
99 {
100 return GenerateInitInstanceLocal((::BesStatus*)0);
101 }
102 // Static variable to force the class initialization
103 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::BesStatus*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
104} // end of namespace ROOT
105
106namespace ROOT {
107 static void *new_BesTView(void *p = 0);
108 static void *newArray_BesTView(Long_t size, void *p);
109 static void delete_BesTView(void *p);
110 static void deleteArray_BesTView(void *p);
111 static void destruct_BesTView(void *p);
112 static void streamer_BesTView(TBuffer &buf, void *obj);
113
114 // Function generating the singleton type initializer
115 static TGenericClassInfo *GenerateInitInstanceLocal(const ::BesTView*)
116 {
117 ::BesTView *ptr = 0;
118 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::BesTView >(0);
119 static ::ROOT::TGenericClassInfo
120 instance("BesTView", ::BesTView::Class_Version(), "BesTView.h", 31,
121 typeid(::BesTView), ::ROOT::Internal::DefineBehavior(ptr, ptr),
122 &::BesTView::Dictionary, isa_proxy, 17,
123 sizeof(::BesTView) );
124 instance.SetNew(&new_BesTView);
125 instance.SetNewArray(&newArray_BesTView);
126 instance.SetDelete(&delete_BesTView);
127 instance.SetDeleteArray(&deleteArray_BesTView);
128 instance.SetDestructor(&destruct_BesTView);
129 instance.SetStreamerFunc(&streamer_BesTView);
130 return &instance;
131 }
132 TGenericClassInfo *GenerateInitInstance(const ::BesTView*)
133 {
134 return GenerateInitInstanceLocal((::BesTView*)0);
135 }
136 // Static variable to force the class initialization
137 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::BesTView*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
138} // end of namespace ROOT
139
140namespace ROOT {
141 static void *new_Bes2DView(void *p = 0);
142 static void *newArray_Bes2DView(Long_t size, void *p);
143 static void delete_Bes2DView(void *p);
144 static void deleteArray_Bes2DView(void *p);
145 static void destruct_Bes2DView(void *p);
146
147 // Function generating the singleton type initializer
148 static TGenericClassInfo *GenerateInitInstanceLocal(const ::Bes2DView*)
149 {
150 ::Bes2DView *ptr = 0;
151 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::Bes2DView >(0);
152 static ::ROOT::TGenericClassInfo
153 instance("Bes2DView", ::Bes2DView::Class_Version(), "Bes2DView.h", 25,
154 typeid(::Bes2DView), ::ROOT::Internal::DefineBehavior(ptr, ptr),
155 &::Bes2DView::Dictionary, isa_proxy, 4,
156 sizeof(::Bes2DView) );
157 instance.SetNew(&new_Bes2DView);
158 instance.SetNewArray(&newArray_Bes2DView);
159 instance.SetDelete(&delete_Bes2DView);
160 instance.SetDeleteArray(&deleteArray_Bes2DView);
161 instance.SetDestructor(&destruct_Bes2DView);
162 return &instance;
163 }
164 TGenericClassInfo *GenerateInitInstance(const ::Bes2DView*)
165 {
166 return GenerateInitInstanceLocal((::Bes2DView*)0);
167 }
168 // Static variable to force the class initialization
169 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Bes2DView*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
170} // end of namespace ROOT
171
172namespace ROOT {
173 static void *new_BesCircle2D(void *p = 0);
174 static void *newArray_BesCircle2D(Long_t size, void *p);
175 static void delete_BesCircle2D(void *p);
176 static void deleteArray_BesCircle2D(void *p);
177 static void destruct_BesCircle2D(void *p);
178
179 // Function generating the singleton type initializer
180 static TGenericClassInfo *GenerateInitInstanceLocal(const ::BesCircle2D*)
181 {
182 ::BesCircle2D *ptr = 0;
183 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::BesCircle2D >(0);
184 static ::ROOT::TGenericClassInfo
185 instance("BesCircle2D", ::BesCircle2D::Class_Version(), "BesCircle2D.h", 25,
186 typeid(::BesCircle2D), ::ROOT::Internal::DefineBehavior(ptr, ptr),
187 &::BesCircle2D::Dictionary, isa_proxy, 4,
188 sizeof(::BesCircle2D) );
189 instance.SetNew(&new_BesCircle2D);
190 instance.SetNewArray(&newArray_BesCircle2D);
191 instance.SetDelete(&delete_BesCircle2D);
192 instance.SetDeleteArray(&deleteArray_BesCircle2D);
193 instance.SetDestructor(&destruct_BesCircle2D);
194 return &instance;
195 }
196 TGenericClassInfo *GenerateInitInstance(const ::BesCircle2D*)
197 {
198 return GenerateInitInstanceLocal((::BesCircle2D*)0);
199 }
200 // Static variable to force the class initialization
201 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::BesCircle2D*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
202} // end of namespace ROOT
203
204namespace ROOT {
205 static void *new_BesCursor(void *p = 0);
206 static void *newArray_BesCursor(Long_t size, void *p);
207 static void delete_BesCursor(void *p);
208 static void deleteArray_BesCursor(void *p);
209 static void destruct_BesCursor(void *p);
210
211 // Function generating the singleton type initializer
212 static TGenericClassInfo *GenerateInitInstanceLocal(const ::BesCursor*)
213 {
214 ::BesCursor *ptr = 0;
215 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::BesCursor >(0);
216 static ::ROOT::TGenericClassInfo
217 instance("BesCursor", ::BesCursor::Class_Version(), "BesCursor.h", 19,
218 typeid(::BesCursor), ::ROOT::Internal::DefineBehavior(ptr, ptr),
219 &::BesCursor::Dictionary, isa_proxy, 4,
220 sizeof(::BesCursor) );
221 instance.SetNew(&new_BesCursor);
222 instance.SetNewArray(&newArray_BesCursor);
223 instance.SetDelete(&delete_BesCursor);
224 instance.SetDeleteArray(&deleteArray_BesCursor);
225 instance.SetDestructor(&destruct_BesCursor);
226 return &instance;
227 }
228 TGenericClassInfo *GenerateInitInstance(const ::BesCursor*)
229 {
230 return GenerateInitInstanceLocal((::BesCursor*)0);
231 }
232 // Static variable to force the class initialization
233 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::BesCursor*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
234} // end of namespace ROOT
235
236namespace ROOT {
237 static void *new_BesEventHeader(void *p = 0);
238 static void *newArray_BesEventHeader(Long_t size, void *p);
239 static void delete_BesEventHeader(void *p);
240 static void deleteArray_BesEventHeader(void *p);
241 static void destruct_BesEventHeader(void *p);
242
243 // Function generating the singleton type initializer
244 static TGenericClassInfo *GenerateInitInstanceLocal(const ::BesEventHeader*)
245 {
246 ::BesEventHeader *ptr = 0;
247 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::BesEventHeader >(0);
248 static ::ROOT::TGenericClassInfo
249 instance("BesEventHeader", ::BesEventHeader::Class_Version(), "BesEventHeader.h", 14,
250 typeid(::BesEventHeader), ::ROOT::Internal::DefineBehavior(ptr, ptr),
251 &::BesEventHeader::Dictionary, isa_proxy, 4,
252 sizeof(::BesEventHeader) );
253 instance.SetNew(&new_BesEventHeader);
254 instance.SetNewArray(&newArray_BesEventHeader);
255 instance.SetDelete(&delete_BesEventHeader);
256 instance.SetDeleteArray(&deleteArray_BesEventHeader);
257 instance.SetDestructor(&destruct_BesEventHeader);
258 return &instance;
259 }
260 TGenericClassInfo *GenerateInitInstance(const ::BesEventHeader*)
261 {
262 return GenerateInitInstanceLocal((::BesEventHeader*)0);
263 }
264 // Static variable to force the class initialization
265 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::BesEventHeader*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
266} // end of namespace ROOT
267
268namespace ROOT {
269 static void *new_BesMarker2D(void *p = 0);
270 static void *newArray_BesMarker2D(Long_t size, void *p);
271 static void delete_BesMarker2D(void *p);
272 static void deleteArray_BesMarker2D(void *p);
273 static void destruct_BesMarker2D(void *p);
274
275 // Function generating the singleton type initializer
276 static TGenericClassInfo *GenerateInitInstanceLocal(const ::BesMarker2D*)
277 {
278 ::BesMarker2D *ptr = 0;
279 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::BesMarker2D >(0);
280 static ::ROOT::TGenericClassInfo
281 instance("BesMarker2D", ::BesMarker2D::Class_Version(), "BesMarker2D.h", 13,
282 typeid(::BesMarker2D), ::ROOT::Internal::DefineBehavior(ptr, ptr),
283 &::BesMarker2D::Dictionary, isa_proxy, 4,
284 sizeof(::BesMarker2D) );
285 instance.SetNew(&new_BesMarker2D);
286 instance.SetNewArray(&newArray_BesMarker2D);
287 instance.SetDelete(&delete_BesMarker2D);
288 instance.SetDeleteArray(&deleteArray_BesMarker2D);
289 instance.SetDestructor(&destruct_BesMarker2D);
290 return &instance;
291 }
292 TGenericClassInfo *GenerateInitInstance(const ::BesMarker2D*)
293 {
294 return GenerateInitInstanceLocal((::BesMarker2D*)0);
295 }
296 // Static variable to force the class initialization
297 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::BesMarker2D*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
298} // end of namespace ROOT
299
300namespace ROOT {
301 static void *new_BesPaveText(void *p = 0);
302 static void *newArray_BesPaveText(Long_t size, void *p);
303 static void delete_BesPaveText(void *p);
304 static void deleteArray_BesPaveText(void *p);
305 static void destruct_BesPaveText(void *p);
306
307 // Function generating the singleton type initializer
308 static TGenericClassInfo *GenerateInitInstanceLocal(const ::BesPaveText*)
309 {
310 ::BesPaveText *ptr = 0;
311 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::BesPaveText >(0);
312 static ::ROOT::TGenericClassInfo
313 instance("BesPaveText", ::BesPaveText::Class_Version(), "BesPaveText.h", 11,
314 typeid(::BesPaveText), ::ROOT::Internal::DefineBehavior(ptr, ptr),
315 &::BesPaveText::Dictionary, isa_proxy, 4,
316 sizeof(::BesPaveText) );
317 instance.SetNew(&new_BesPaveText);
318 instance.SetNewArray(&newArray_BesPaveText);
319 instance.SetDelete(&delete_BesPaveText);
320 instance.SetDeleteArray(&deleteArray_BesPaveText);
321 instance.SetDestructor(&destruct_BesPaveText);
322 return &instance;
323 }
324 TGenericClassInfo *GenerateInitInstance(const ::BesPaveText*)
325 {
326 return GenerateInitInstanceLocal((::BesPaveText*)0);
327 }
328 // Static variable to force the class initialization
329 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::BesPaveText*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
330} // end of namespace ROOT
331
332namespace ROOT {
333 static void *new_BesGeoTrack(void *p = 0);
334 static void *newArray_BesGeoTrack(Long_t size, void *p);
335 static void delete_BesGeoTrack(void *p);
336 static void deleteArray_BesGeoTrack(void *p);
337 static void destruct_BesGeoTrack(void *p);
338
339 // Function generating the singleton type initializer
340 static TGenericClassInfo *GenerateInitInstanceLocal(const ::BesGeoTrack*)
341 {
342 ::BesGeoTrack *ptr = 0;
343 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::BesGeoTrack >(0);
344 static ::ROOT::TGenericClassInfo
345 instance("BesGeoTrack", ::BesGeoTrack::Class_Version(), "BesGeoTrack.h", 12,
346 typeid(::BesGeoTrack), ::ROOT::Internal::DefineBehavior(ptr, ptr),
347 &::BesGeoTrack::Dictionary, isa_proxy, 4,
348 sizeof(::BesGeoTrack) );
349 instance.SetNew(&new_BesGeoTrack);
350 instance.SetNewArray(&newArray_BesGeoTrack);
351 instance.SetDelete(&delete_BesGeoTrack);
352 instance.SetDeleteArray(&deleteArray_BesGeoTrack);
353 instance.SetDestructor(&destruct_BesGeoTrack);
354 return &instance;
355 }
356 TGenericClassInfo *GenerateInitInstance(const ::BesGeoTrack*)
357 {
358 return GenerateInitInstanceLocal((::BesGeoTrack*)0);
359 }
360 // Static variable to force the class initialization
361 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::BesGeoTrack*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
362} // end of namespace ROOT
363
364namespace ROOT {
365 static void *new_BesEvent(void *p = 0);
366 static void *newArray_BesEvent(Long_t size, void *p);
367 static void delete_BesEvent(void *p);
368 static void deleteArray_BesEvent(void *p);
369 static void destruct_BesEvent(void *p);
370
371 // Function generating the singleton type initializer
372 static TGenericClassInfo *GenerateInitInstanceLocal(const ::BesEvent*)
373 {
374 ::BesEvent *ptr = 0;
375 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::BesEvent >(0);
376 static ::ROOT::TGenericClassInfo
377 instance("BesEvent", ::BesEvent::Class_Version(), "BesEvent.h", 23,
378 typeid(::BesEvent), ::ROOT::Internal::DefineBehavior(ptr, ptr),
379 &::BesEvent::Dictionary, isa_proxy, 4,
380 sizeof(::BesEvent) );
381 instance.SetNew(&new_BesEvent);
382 instance.SetNewArray(&newArray_BesEvent);
383 instance.SetDelete(&delete_BesEvent);
384 instance.SetDeleteArray(&deleteArray_BesEvent);
385 instance.SetDestructor(&destruct_BesEvent);
386 return &instance;
387 }
388 TGenericClassInfo *GenerateInitInstance(const ::BesEvent*)
389 {
390 return GenerateInitInstanceLocal((::BesEvent*)0);
391 }
392 // Static variable to force the class initialization
393 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::BesEvent*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
394} // end of namespace ROOT
395
396namespace ROOT {
397 static void *new_BesView(void *p = 0);
398 static void *newArray_BesView(Long_t size, void *p);
399 static void delete_BesView(void *p);
400 static void deleteArray_BesView(void *p);
401 static void destruct_BesView(void *p);
402
403 // Function generating the singleton type initializer
404 static TGenericClassInfo *GenerateInitInstanceLocal(const ::BesView*)
405 {
406 ::BesView *ptr = 0;
407 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::BesView >(0);
408 static ::ROOT::TGenericClassInfo
409 instance("BesView", ::BesView::Class_Version(), "BesView.h", 30,
410 typeid(::BesView), ::ROOT::Internal::DefineBehavior(ptr, ptr),
411 &::BesView::Dictionary, isa_proxy, 4,
412 sizeof(::BesView) );
413 instance.SetNew(&new_BesView);
414 instance.SetNewArray(&newArray_BesView);
415 instance.SetDelete(&delete_BesView);
416 instance.SetDeleteArray(&deleteArray_BesView);
417 instance.SetDestructor(&destruct_BesView);
418 return &instance;
419 }
420 TGenericClassInfo *GenerateInitInstance(const ::BesView*)
421 {
422 return GenerateInitInstanceLocal((::BesView*)0);
423 }
424 // Static variable to force the class initialization
425 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::BesView*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
426} // end of namespace ROOT
427
428namespace ROOT {
429 static TClass *SubDetectorROOTGeo_Dictionary();
430 static void SubDetectorROOTGeo_TClassManip(TClass*);
431 static void *new_SubDetectorROOTGeo(void *p = 0);
432 static void *newArray_SubDetectorROOTGeo(Long_t size, void *p);
433 static void delete_SubDetectorROOTGeo(void *p);
434 static void deleteArray_SubDetectorROOTGeo(void *p);
435 static void destruct_SubDetectorROOTGeo(void *p);
436
437 // Function generating the singleton type initializer
438 static TGenericClassInfo *GenerateInitInstanceLocal(const ::SubDetectorROOTGeo*)
439 {
440 ::SubDetectorROOTGeo *ptr = 0;
441 static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::SubDetectorROOTGeo));
442 static ::ROOT::TGenericClassInfo
443 instance("SubDetectorROOTGeo", "SubDetectorROOTGeo.h", 29,
444 typeid(::SubDetectorROOTGeo), ::ROOT::Internal::DefineBehavior(ptr, ptr),
445 &SubDetectorROOTGeo_Dictionary, isa_proxy, 4,
446 sizeof(::SubDetectorROOTGeo) );
447 instance.SetNew(&new_SubDetectorROOTGeo);
448 instance.SetNewArray(&newArray_SubDetectorROOTGeo);
449 instance.SetDelete(&delete_SubDetectorROOTGeo);
450 instance.SetDeleteArray(&deleteArray_SubDetectorROOTGeo);
451 instance.SetDestructor(&destruct_SubDetectorROOTGeo);
452 return &instance;
453 }
454 TGenericClassInfo *GenerateInitInstance(const ::SubDetectorROOTGeo*)
455 {
456 return GenerateInitInstanceLocal((::SubDetectorROOTGeo*)0);
457 }
458 // Static variable to force the class initialization
459 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::SubDetectorROOTGeo*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
460
461 // Dictionary for non-ClassDef classes
462 static TClass *SubDetectorROOTGeo_Dictionary() {
463 TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::SubDetectorROOTGeo*)0x0)->GetClass();
464 SubDetectorROOTGeo_TClassManip(theClass);
465 return theClass;
466 }
467
468 static void SubDetectorROOTGeo_TClassManip(TClass* ){
469 }
470
471} // end of namespace ROOT
472
473namespace ROOT {
474 static void *new_BesPolygon2D(void *p = 0);
475 static void *newArray_BesPolygon2D(Long_t size, void *p);
476 static void delete_BesPolygon2D(void *p);
477 static void deleteArray_BesPolygon2D(void *p);
478 static void destruct_BesPolygon2D(void *p);
479
480 // Function generating the singleton type initializer
481 static TGenericClassInfo *GenerateInitInstanceLocal(const ::BesPolygon2D*)
482 {
483 ::BesPolygon2D *ptr = 0;
484 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::BesPolygon2D >(0);
485 static ::ROOT::TGenericClassInfo
486 instance("BesPolygon2D", ::BesPolygon2D::Class_Version(), "BesPolygon2D.h", 27,
487 typeid(::BesPolygon2D), ::ROOT::Internal::DefineBehavior(ptr, ptr),
488 &::BesPolygon2D::Dictionary, isa_proxy, 4,
489 sizeof(::BesPolygon2D) );
490 instance.SetNew(&new_BesPolygon2D);
491 instance.SetNewArray(&newArray_BesPolygon2D);
492 instance.SetDelete(&delete_BesPolygon2D);
493 instance.SetDeleteArray(&deleteArray_BesPolygon2D);
494 instance.SetDestructor(&destruct_BesPolygon2D);
495 return &instance;
496 }
497 TGenericClassInfo *GenerateInitInstance(const ::BesPolygon2D*)
498 {
499 return GenerateInitInstanceLocal((::BesPolygon2D*)0);
500 }
501 // Static variable to force the class initialization
502 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::BesPolygon2D*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
503} // end of namespace ROOT
504
505namespace ROOT {
506 static void *new_Mdc2DWire(void *p = 0);
507 static void *newArray_Mdc2DWire(Long_t size, void *p);
508 static void delete_Mdc2DWire(void *p);
509 static void deleteArray_Mdc2DWire(void *p);
510 static void destruct_Mdc2DWire(void *p);
511
512 // Function generating the singleton type initializer
513 static TGenericClassInfo *GenerateInitInstanceLocal(const ::Mdc2DWire*)
514 {
515 ::Mdc2DWire *ptr = 0;
516 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::Mdc2DWire >(0);
517 static ::ROOT::TGenericClassInfo
518 instance("Mdc2DWire", ::Mdc2DWire::Class_Version(), "Mdc2DWire.h", 17,
519 typeid(::Mdc2DWire), ::ROOT::Internal::DefineBehavior(ptr, ptr),
520 &::Mdc2DWire::Dictionary, isa_proxy, 4,
521 sizeof(::Mdc2DWire) );
522 instance.SetNew(&new_Mdc2DWire);
523 instance.SetNewArray(&newArray_Mdc2DWire);
524 instance.SetDelete(&delete_Mdc2DWire);
525 instance.SetDeleteArray(&deleteArray_Mdc2DWire);
526 instance.SetDestructor(&destruct_Mdc2DWire);
527 return &instance;
528 }
529 TGenericClassInfo *GenerateInitInstance(const ::Mdc2DWire*)
530 {
531 return GenerateInitInstanceLocal((::Mdc2DWire*)0);
532 }
533 // Static variable to force the class initialization
534 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Mdc2DWire*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
535} // end of namespace ROOT
536
537namespace ROOT {
538 static TClass *MdcROOTGeo_Dictionary();
539 static void MdcROOTGeo_TClassManip(TClass*);
540 static void *new_MdcROOTGeo(void *p = 0);
541 static void *newArray_MdcROOTGeo(Long_t size, void *p);
542 static void delete_MdcROOTGeo(void *p);
543 static void deleteArray_MdcROOTGeo(void *p);
544 static void destruct_MdcROOTGeo(void *p);
545
546 // Function generating the singleton type initializer
547 static TGenericClassInfo *GenerateInitInstanceLocal(const ::MdcROOTGeo*)
548 {
549 ::MdcROOTGeo *ptr = 0;
550 static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::MdcROOTGeo));
551 static ::ROOT::TGenericClassInfo
552 instance("MdcROOTGeo", "MdcROOTGeo.h", 31,
553 typeid(::MdcROOTGeo), ::ROOT::Internal::DefineBehavior(ptr, ptr),
554 &MdcROOTGeo_Dictionary, isa_proxy, 4,
555 sizeof(::MdcROOTGeo) );
556 instance.SetNew(&new_MdcROOTGeo);
557 instance.SetNewArray(&newArray_MdcROOTGeo);
558 instance.SetDelete(&delete_MdcROOTGeo);
559 instance.SetDeleteArray(&deleteArray_MdcROOTGeo);
560 instance.SetDestructor(&destruct_MdcROOTGeo);
561 return &instance;
562 }
563 TGenericClassInfo *GenerateInitInstance(const ::MdcROOTGeo*)
564 {
565 return GenerateInitInstanceLocal((::MdcROOTGeo*)0);
566 }
567 // Static variable to force the class initialization
568 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::MdcROOTGeo*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
569
570 // Dictionary for non-ClassDef classes
571 static TClass *MdcROOTGeo_Dictionary() {
572 TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::MdcROOTGeo*)0x0)->GetClass();
573 MdcROOTGeo_TClassManip(theClass);
574 return theClass;
575 }
576
577 static void MdcROOTGeo_TClassManip(TClass* ){
578 }
579
580} // end of namespace ROOT
581
582namespace ROOT {
583 static void *new_Tof2DScin(void *p = 0);
584 static void *newArray_Tof2DScin(Long_t size, void *p);
585 static void delete_Tof2DScin(void *p);
586 static void deleteArray_Tof2DScin(void *p);
587 static void destruct_Tof2DScin(void *p);
588
589 // Function generating the singleton type initializer
590 static TGenericClassInfo *GenerateInitInstanceLocal(const ::Tof2DScin*)
591 {
592 ::Tof2DScin *ptr = 0;
593 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::Tof2DScin >(0);
594 static ::ROOT::TGenericClassInfo
595 instance("Tof2DScin", ::Tof2DScin::Class_Version(), "Tof2DScin.h", 18,
596 typeid(::Tof2DScin), ::ROOT::Internal::DefineBehavior(ptr, ptr),
597 &::Tof2DScin::Dictionary, isa_proxy, 4,
598 sizeof(::Tof2DScin) );
599 instance.SetNew(&new_Tof2DScin);
600 instance.SetNewArray(&newArray_Tof2DScin);
601 instance.SetDelete(&delete_Tof2DScin);
602 instance.SetDeleteArray(&deleteArray_Tof2DScin);
603 instance.SetDestructor(&destruct_Tof2DScin);
604 return &instance;
605 }
606 TGenericClassInfo *GenerateInitInstance(const ::Tof2DScin*)
607 {
608 return GenerateInitInstanceLocal((::Tof2DScin*)0);
609 }
610 // Static variable to force the class initialization
611 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Tof2DScin*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
612} // end of namespace ROOT
613
614namespace ROOT {
615 static TClass *TofROOTGeo_Dictionary();
616 static void TofROOTGeo_TClassManip(TClass*);
617 static void *new_TofROOTGeo(void *p = 0);
618 static void *newArray_TofROOTGeo(Long_t size, void *p);
619 static void delete_TofROOTGeo(void *p);
620 static void deleteArray_TofROOTGeo(void *p);
621 static void destruct_TofROOTGeo(void *p);
622
623 // Function generating the singleton type initializer
624 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TofROOTGeo*)
625 {
626 ::TofROOTGeo *ptr = 0;
627 static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::TofROOTGeo));
628 static ::ROOT::TGenericClassInfo
629 instance("TofROOTGeo", "TofROOTGeo.h", 29,
630 typeid(::TofROOTGeo), ::ROOT::Internal::DefineBehavior(ptr, ptr),
631 &TofROOTGeo_Dictionary, isa_proxy, 4,
632 sizeof(::TofROOTGeo) );
633 instance.SetNew(&new_TofROOTGeo);
634 instance.SetNewArray(&newArray_TofROOTGeo);
635 instance.SetDelete(&delete_TofROOTGeo);
636 instance.SetDeleteArray(&deleteArray_TofROOTGeo);
637 instance.SetDestructor(&destruct_TofROOTGeo);
638 return &instance;
639 }
640 TGenericClassInfo *GenerateInitInstance(const ::TofROOTGeo*)
641 {
642 return GenerateInitInstanceLocal((::TofROOTGeo*)0);
643 }
644 // Static variable to force the class initialization
645 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::TofROOTGeo*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
646
647 // Dictionary for non-ClassDef classes
648 static TClass *TofROOTGeo_Dictionary() {
649 TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::TofROOTGeo*)0x0)->GetClass();
650 TofROOTGeo_TClassManip(theClass);
651 return theClass;
652 }
653
654 static void TofROOTGeo_TClassManip(TClass* ){
655 }
656
657} // end of namespace ROOT
658
659namespace ROOT {
660 static void *new_Emc2DCrystal(void *p = 0);
661 static void *newArray_Emc2DCrystal(Long_t size, void *p);
662 static void delete_Emc2DCrystal(void *p);
663 static void deleteArray_Emc2DCrystal(void *p);
664 static void destruct_Emc2DCrystal(void *p);
665
666 // Function generating the singleton type initializer
667 static TGenericClassInfo *GenerateInitInstanceLocal(const ::Emc2DCrystal*)
668 {
669 ::Emc2DCrystal *ptr = 0;
670 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::Emc2DCrystal >(0);
671 static ::ROOT::TGenericClassInfo
672 instance("Emc2DCrystal", ::Emc2DCrystal::Class_Version(), "Emc2DCrystal.h", 18,
673 typeid(::Emc2DCrystal), ::ROOT::Internal::DefineBehavior(ptr, ptr),
674 &::Emc2DCrystal::Dictionary, isa_proxy, 4,
675 sizeof(::Emc2DCrystal) );
676 instance.SetNew(&new_Emc2DCrystal);
677 instance.SetNewArray(&newArray_Emc2DCrystal);
678 instance.SetDelete(&delete_Emc2DCrystal);
679 instance.SetDeleteArray(&deleteArray_Emc2DCrystal);
680 instance.SetDestructor(&destruct_Emc2DCrystal);
681 return &instance;
682 }
683 TGenericClassInfo *GenerateInitInstance(const ::Emc2DCrystal*)
684 {
685 return GenerateInitInstanceLocal((::Emc2DCrystal*)0);
686 }
687 // Static variable to force the class initialization
688 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Emc2DCrystal*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
689} // end of namespace ROOT
690
691namespace ROOT {
692 static TClass *EmcROOTGeo_Dictionary();
693 static void EmcROOTGeo_TClassManip(TClass*);
694 static void *new_EmcROOTGeo(void *p = 0);
695 static void *newArray_EmcROOTGeo(Long_t size, void *p);
696 static void delete_EmcROOTGeo(void *p);
697 static void deleteArray_EmcROOTGeo(void *p);
698 static void destruct_EmcROOTGeo(void *p);
699
700 // Function generating the singleton type initializer
701 static TGenericClassInfo *GenerateInitInstanceLocal(const ::EmcROOTGeo*)
702 {
703 ::EmcROOTGeo *ptr = 0;
704 static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::EmcROOTGeo));
705 static ::ROOT::TGenericClassInfo
706 instance("EmcROOTGeo", "EmcROOTGeo.h", 32,
707 typeid(::EmcROOTGeo), ::ROOT::Internal::DefineBehavior(ptr, ptr),
708 &EmcROOTGeo_Dictionary, isa_proxy, 4,
709 sizeof(::EmcROOTGeo) );
710 instance.SetNew(&new_EmcROOTGeo);
711 instance.SetNewArray(&newArray_EmcROOTGeo);
712 instance.SetDelete(&delete_EmcROOTGeo);
713 instance.SetDeleteArray(&deleteArray_EmcROOTGeo);
714 instance.SetDestructor(&destruct_EmcROOTGeo);
715 return &instance;
716 }
717 TGenericClassInfo *GenerateInitInstance(const ::EmcROOTGeo*)
718 {
719 return GenerateInitInstanceLocal((::EmcROOTGeo*)0);
720 }
721 // Static variable to force the class initialization
722 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::EmcROOTGeo*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
723
724 // Dictionary for non-ClassDef classes
725 static TClass *EmcROOTGeo_Dictionary() {
726 TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::EmcROOTGeo*)0x0)->GetClass();
727 EmcROOTGeo_TClassManip(theClass);
728 return theClass;
729 }
730
731 static void EmcROOTGeo_TClassManip(TClass* ){
732 }
733
734} // end of namespace ROOT
735
736namespace ROOT {
737 static void *new_Muc2DStrip(void *p = 0);
738 static void *newArray_Muc2DStrip(Long_t size, void *p);
739 static void delete_Muc2DStrip(void *p);
740 static void deleteArray_Muc2DStrip(void *p);
741 static void destruct_Muc2DStrip(void *p);
742
743 // Function generating the singleton type initializer
744 static TGenericClassInfo *GenerateInitInstanceLocal(const ::Muc2DStrip*)
745 {
746 ::Muc2DStrip *ptr = 0;
747 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::Muc2DStrip >(0);
748 static ::ROOT::TGenericClassInfo
749 instance("Muc2DStrip", ::Muc2DStrip::Class_Version(), "Muc2DStrip.h", 18,
750 typeid(::Muc2DStrip), ::ROOT::Internal::DefineBehavior(ptr, ptr),
751 &::Muc2DStrip::Dictionary, isa_proxy, 4,
752 sizeof(::Muc2DStrip) );
753 instance.SetNew(&new_Muc2DStrip);
754 instance.SetNewArray(&newArray_Muc2DStrip);
755 instance.SetDelete(&delete_Muc2DStrip);
756 instance.SetDeleteArray(&deleteArray_Muc2DStrip);
757 instance.SetDestructor(&destruct_Muc2DStrip);
758 return &instance;
759 }
760 TGenericClassInfo *GenerateInitInstance(const ::Muc2DStrip*)
761 {
762 return GenerateInitInstanceLocal((::Muc2DStrip*)0);
763 }
764 // Static variable to force the class initialization
765 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Muc2DStrip*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
766} // end of namespace ROOT
767
768namespace ROOT {
769 static TClass *MucROOTGeo_Dictionary();
770 static void MucROOTGeo_TClassManip(TClass*);
771 static void *new_MucROOTGeo(void *p = 0);
772 static void *newArray_MucROOTGeo(Long_t size, void *p);
773 static void delete_MucROOTGeo(void *p);
774 static void deleteArray_MucROOTGeo(void *p);
775 static void destruct_MucROOTGeo(void *p);
776
777 // Function generating the singleton type initializer
778 static TGenericClassInfo *GenerateInitInstanceLocal(const ::MucROOTGeo*)
779 {
780 ::MucROOTGeo *ptr = 0;
781 static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::MucROOTGeo));
782 static ::ROOT::TGenericClassInfo
783 instance("MucROOTGeo", "MucROOTGeo.h", 30,
784 typeid(::MucROOTGeo), ::ROOT::Internal::DefineBehavior(ptr, ptr),
785 &MucROOTGeo_Dictionary, isa_proxy, 4,
786 sizeof(::MucROOTGeo) );
787 instance.SetNew(&new_MucROOTGeo);
788 instance.SetNewArray(&newArray_MucROOTGeo);
789 instance.SetDelete(&delete_MucROOTGeo);
790 instance.SetDeleteArray(&deleteArray_MucROOTGeo);
791 instance.SetDestructor(&destruct_MucROOTGeo);
792 return &instance;
793 }
794 TGenericClassInfo *GenerateInitInstance(const ::MucROOTGeo*)
795 {
796 return GenerateInitInstanceLocal((::MucROOTGeo*)0);
797 }
798 // Static variable to force the class initialization
799 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::MucROOTGeo*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
800
801 // Dictionary for non-ClassDef classes
802 static TClass *MucROOTGeo_Dictionary() {
803 TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::MucROOTGeo*)0x0)->GetClass();
804 MucROOTGeo_TClassManip(theClass);
805 return theClass;
806 }
807
808 static void MucROOTGeo_TClassManip(TClass* ){
809 }
810
811} // end of namespace ROOT
812
813namespace ROOT {
814 static void *new_BesGeometry(void *p = 0);
815 static void *newArray_BesGeometry(Long_t size, void *p);
816 static void delete_BesGeometry(void *p);
817 static void deleteArray_BesGeometry(void *p);
818 static void destruct_BesGeometry(void *p);
819
820 // Function generating the singleton type initializer
821 static TGenericClassInfo *GenerateInitInstanceLocal(const ::BesGeometry*)
822 {
823 ::BesGeometry *ptr = 0;
824 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::BesGeometry >(0);
825 static ::ROOT::TGenericClassInfo
826 instance("BesGeometry", ::BesGeometry::Class_Version(), "BesGeometry.h", 18,
827 typeid(::BesGeometry), ::ROOT::Internal::DefineBehavior(ptr, ptr),
828 &::BesGeometry::Dictionary, isa_proxy, 4,
829 sizeof(::BesGeometry) );
830 instance.SetNew(&new_BesGeometry);
831 instance.SetNewArray(&newArray_BesGeometry);
832 instance.SetDelete(&delete_BesGeometry);
833 instance.SetDeleteArray(&deleteArray_BesGeometry);
834 instance.SetDestructor(&destruct_BesGeometry);
835 return &instance;
836 }
837 TGenericClassInfo *GenerateInitInstance(const ::BesGeometry*)
838 {
839 return GenerateInitInstanceLocal((::BesGeometry*)0);
840 }
841 // Static variable to force the class initialization
842 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::BesGeometry*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
843} // end of namespace ROOT
844
845namespace ROOT {
846 static void *new_BesGMenuTitle(void *p = 0);
847 static void *newArray_BesGMenuTitle(Long_t size, void *p);
848 static void delete_BesGMenuTitle(void *p);
849 static void deleteArray_BesGMenuTitle(void *p);
850 static void destruct_BesGMenuTitle(void *p);
851
852 // Function generating the singleton type initializer
853 static TGenericClassInfo *GenerateInitInstanceLocal(const ::BesGMenuTitle*)
854 {
855 ::BesGMenuTitle *ptr = 0;
856 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::BesGMenuTitle >(0);
857 static ::ROOT::TGenericClassInfo
858 instance("BesGMenuTitle", ::BesGMenuTitle::Class_Version(), "BesGMenuTitle.h", 12,
859 typeid(::BesGMenuTitle), ::ROOT::Internal::DefineBehavior(ptr, ptr),
860 &::BesGMenuTitle::Dictionary, isa_proxy, 4,
861 sizeof(::BesGMenuTitle) );
862 instance.SetNew(&new_BesGMenuTitle);
863 instance.SetNewArray(&newArray_BesGMenuTitle);
864 instance.SetDelete(&delete_BesGMenuTitle);
865 instance.SetDeleteArray(&deleteArray_BesGMenuTitle);
866 instance.SetDestructor(&destruct_BesGMenuTitle);
867 return &instance;
868 }
869 TGenericClassInfo *GenerateInitInstance(const ::BesGMenuTitle*)
870 {
871 return GenerateInitInstanceLocal((::BesGMenuTitle*)0);
872 }
873 // Static variable to force the class initialization
874 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::BesGMenuTitle*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
875} // end of namespace ROOT
876
877namespace ROOT {
878 static void *new_BesGMenuBar(void *p = 0);
879 static void *newArray_BesGMenuBar(Long_t size, void *p);
880 static void delete_BesGMenuBar(void *p);
881 static void deleteArray_BesGMenuBar(void *p);
882 static void destruct_BesGMenuBar(void *p);
883
884 // Function generating the singleton type initializer
885 static TGenericClassInfo *GenerateInitInstanceLocal(const ::BesGMenuBar*)
886 {
887 ::BesGMenuBar *ptr = 0;
888 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::BesGMenuBar >(0);
889 static ::ROOT::TGenericClassInfo
890 instance("BesGMenuBar", ::BesGMenuBar::Class_Version(), "BesGMenuBar.h", 8,
891 typeid(::BesGMenuBar), ::ROOT::Internal::DefineBehavior(ptr, ptr),
892 &::BesGMenuBar::Dictionary, isa_proxy, 4,
893 sizeof(::BesGMenuBar) );
894 instance.SetNew(&new_BesGMenuBar);
895 instance.SetNewArray(&newArray_BesGMenuBar);
896 instance.SetDelete(&delete_BesGMenuBar);
897 instance.SetDeleteArray(&deleteArray_BesGMenuBar);
898 instance.SetDestructor(&destruct_BesGMenuBar);
899 return &instance;
900 }
901 TGenericClassInfo *GenerateInitInstance(const ::BesGMenuBar*)
902 {
903 return GenerateInitInstanceLocal((::BesGMenuBar*)0);
904 }
905 // Static variable to force the class initialization
906 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::BesGMenuBar*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
907} // end of namespace ROOT
908
909namespace ROOT {
910 static void *new_BesGPictureButton(void *p = 0);
911 static void *newArray_BesGPictureButton(Long_t size, void *p);
912 static void delete_BesGPictureButton(void *p);
913 static void deleteArray_BesGPictureButton(void *p);
914 static void destruct_BesGPictureButton(void *p);
915
916 // Function generating the singleton type initializer
917 static TGenericClassInfo *GenerateInitInstanceLocal(const ::BesGPictureButton*)
918 {
919 ::BesGPictureButton *ptr = 0;
920 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::BesGPictureButton >(0);
921 static ::ROOT::TGenericClassInfo
922 instance("BesGPictureButton", ::BesGPictureButton::Class_Version(), "BesGPictureButton.h", 7,
923 typeid(::BesGPictureButton), ::ROOT::Internal::DefineBehavior(ptr, ptr),
924 &::BesGPictureButton::Dictionary, isa_proxy, 4,
925 sizeof(::BesGPictureButton) );
926 instance.SetNew(&new_BesGPictureButton);
927 instance.SetNewArray(&newArray_BesGPictureButton);
928 instance.SetDelete(&delete_BesGPictureButton);
929 instance.SetDeleteArray(&deleteArray_BesGPictureButton);
930 instance.SetDestructor(&destruct_BesGPictureButton);
931 return &instance;
932 }
933 TGenericClassInfo *GenerateInitInstance(const ::BesGPictureButton*)
934 {
935 return GenerateInitInstanceLocal((::BesGPictureButton*)0);
936 }
937 // Static variable to force the class initialization
938 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::BesGPictureButton*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
939} // end of namespace ROOT
940
941namespace ROOT {
942 static void *new_BesHeader(void *p = 0);
943 static void *newArray_BesHeader(Long_t size, void *p);
944 static void delete_BesHeader(void *p);
945 static void deleteArray_BesHeader(void *p);
946 static void destruct_BesHeader(void *p);
947
948 // Function generating the singleton type initializer
949 static TGenericClassInfo *GenerateInitInstanceLocal(const ::BesHeader*)
950 {
951 ::BesHeader *ptr = 0;
952 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::BesHeader >(0);
953 static ::ROOT::TGenericClassInfo
954 instance("BesHeader", ::BesHeader::Class_Version(), "BesHeader.h", 12,
955 typeid(::BesHeader), ::ROOT::Internal::DefineBehavior(ptr, ptr),
956 &::BesHeader::Dictionary, isa_proxy, 4,
957 sizeof(::BesHeader) );
958 instance.SetNew(&new_BesHeader);
959 instance.SetNewArray(&newArray_BesHeader);
960 instance.SetDelete(&delete_BesHeader);
961 instance.SetDeleteArray(&deleteArray_BesHeader);
962 instance.SetDestructor(&destruct_BesHeader);
963 return &instance;
964 }
965 TGenericClassInfo *GenerateInitInstance(const ::BesHeader*)
966 {
967 return GenerateInitInstanceLocal((::BesHeader*)0);
968 }
969 // Static variable to force the class initialization
970 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::BesHeader*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
971} // end of namespace ROOT
972
973namespace ROOT {
974 static void *new_BesVisDisplay(void *p = 0);
975 static void *newArray_BesVisDisplay(Long_t size, void *p);
976 static void delete_BesVisDisplay(void *p);
977 static void deleteArray_BesVisDisplay(void *p);
978 static void destruct_BesVisDisplay(void *p);
979
980 // Function generating the singleton type initializer
981 static TGenericClassInfo *GenerateInitInstanceLocal(const ::BesVisDisplay*)
982 {
983 ::BesVisDisplay *ptr = 0;
984 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::BesVisDisplay >(0);
985 static ::ROOT::TGenericClassInfo
986 instance("BesVisDisplay", ::BesVisDisplay::Class_Version(), "BesVisDisplay.h", 37,
987 typeid(::BesVisDisplay), ::ROOT::Internal::DefineBehavior(ptr, ptr),
988 &::BesVisDisplay::Dictionary, isa_proxy, 4,
989 sizeof(::BesVisDisplay) );
990 instance.SetNew(&new_BesVisDisplay);
991 instance.SetNewArray(&newArray_BesVisDisplay);
992 instance.SetDelete(&delete_BesVisDisplay);
993 instance.SetDeleteArray(&deleteArray_BesVisDisplay);
994 instance.SetDestructor(&destruct_BesVisDisplay);
995 return &instance;
996 }
997 TGenericClassInfo *GenerateInitInstance(const ::BesVisDisplay*)
998 {
999 return GenerateInitInstanceLocal((::BesVisDisplay*)0);
1000 }
1001 // Static variable to force the class initialization
1002 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::BesVisDisplay*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1003} // end of namespace ROOT
1004
1005namespace ROOT {
1006 static void *new_ZHelix(void *p = 0);
1007 static void *newArray_ZHelix(Long_t size, void *p);
1008 static void delete_ZHelix(void *p);
1009 static void deleteArray_ZHelix(void *p);
1010 static void destruct_ZHelix(void *p);
1011 static Long64_t merge_ZHelix(void *obj, TCollection *coll,TFileMergeInfo *info);
1012
1013 // Function generating the singleton type initializer
1014 static TGenericClassInfo *GenerateInitInstanceLocal(const ::ZHelix*)
1015 {
1016 ::ZHelix *ptr = 0;
1017 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::ZHelix >(0);
1018 static ::ROOT::TGenericClassInfo
1019 instance("ZHelix", ::ZHelix::Class_Version(), "ZHelix.h", 42,
1020 typeid(::ZHelix), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1021 &::ZHelix::Dictionary, isa_proxy, 4,
1022 sizeof(::ZHelix) );
1023 instance.SetNew(&new_ZHelix);
1024 instance.SetNewArray(&newArray_ZHelix);
1025 instance.SetDelete(&delete_ZHelix);
1026 instance.SetDeleteArray(&deleteArray_ZHelix);
1027 instance.SetDestructor(&destruct_ZHelix);
1028 instance.SetMerge(&merge_ZHelix);
1029 return &instance;
1030 }
1031 TGenericClassInfo *GenerateInitInstance(const ::ZHelix*)
1032 {
1033 return GenerateInitInstanceLocal((::ZHelix*)0);
1034 }
1035 // Static variable to force the class initialization
1036 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::ZHelix*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1037} // end of namespace ROOT
1038
1039//______________________________________________________________________________
1040atomic_TClass_ptr BesStatus::fgIsA(0); // static to hold class pointer
1041
1042//______________________________________________________________________________
1043const char *BesStatus::Class_Name()
1044{
1045 return "BesStatus";
1046}
1047
1048//______________________________________________________________________________
1049const char *BesStatus::ImplFileName()
1050{
1051 return ::ROOT::GenerateInitInstanceLocal((const ::BesStatus*)0x0)->GetImplFileName();
1052}
1053
1054//______________________________________________________________________________
1055int BesStatus::ImplFileLine()
1056{
1057 return ::ROOT::GenerateInitInstanceLocal((const ::BesStatus*)0x0)->GetImplFileLine();
1058}
1059
1060//______________________________________________________________________________
1061TClass *BesStatus::Dictionary()
1062{
1063 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesStatus*)0x0)->GetClass();
1064 return fgIsA;
1065}
1066
1067//______________________________________________________________________________
1068TClass *BesStatus::Class()
1069{
1070 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesStatus*)0x0)->GetClass(); }
1071 return fgIsA;
1072}
1073
1074//______________________________________________________________________________
1075atomic_TClass_ptr BesTView::fgIsA(0); // static to hold class pointer
1076
1077//______________________________________________________________________________
1078const char *BesTView::Class_Name()
1079{
1080 return "BesTView";
1081}
1082
1083//______________________________________________________________________________
1084const char *BesTView::ImplFileName()
1085{
1086 return ::ROOT::GenerateInitInstanceLocal((const ::BesTView*)0x0)->GetImplFileName();
1087}
1088
1089//______________________________________________________________________________
1090int BesTView::ImplFileLine()
1091{
1092 return ::ROOT::GenerateInitInstanceLocal((const ::BesTView*)0x0)->GetImplFileLine();
1093}
1094
1095//______________________________________________________________________________
1096TClass *BesTView::Dictionary()
1097{
1098 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesTView*)0x0)->GetClass();
1099 return fgIsA;
1100}
1101
1102//______________________________________________________________________________
1103TClass *BesTView::Class()
1104{
1105 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesTView*)0x0)->GetClass(); }
1106 return fgIsA;
1107}
1108
1109//______________________________________________________________________________
1110atomic_TClass_ptr Bes2DView::fgIsA(0); // static to hold class pointer
1111
1112//______________________________________________________________________________
1113const char *Bes2DView::Class_Name()
1114{
1115 return "Bes2DView";
1116}
1117
1118//______________________________________________________________________________
1119const char *Bes2DView::ImplFileName()
1120{
1121 return ::ROOT::GenerateInitInstanceLocal((const ::Bes2DView*)0x0)->GetImplFileName();
1122}
1123
1124//______________________________________________________________________________
1125int Bes2DView::ImplFileLine()
1126{
1127 return ::ROOT::GenerateInitInstanceLocal((const ::Bes2DView*)0x0)->GetImplFileLine();
1128}
1129
1130//______________________________________________________________________________
1131TClass *Bes2DView::Dictionary()
1132{
1133 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::Bes2DView*)0x0)->GetClass();
1134 return fgIsA;
1135}
1136
1137//______________________________________________________________________________
1138TClass *Bes2DView::Class()
1139{
1140 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::Bes2DView*)0x0)->GetClass(); }
1141 return fgIsA;
1142}
1143
1144//______________________________________________________________________________
1145atomic_TClass_ptr BesCircle2D::fgIsA(0); // static to hold class pointer
1146
1147//______________________________________________________________________________
1148const char *BesCircle2D::Class_Name()
1149{
1150 return "BesCircle2D";
1151}
1152
1153//______________________________________________________________________________
1154const char *BesCircle2D::ImplFileName()
1155{
1156 return ::ROOT::GenerateInitInstanceLocal((const ::BesCircle2D*)0x0)->GetImplFileName();
1157}
1158
1159//______________________________________________________________________________
1160int BesCircle2D::ImplFileLine()
1161{
1162 return ::ROOT::GenerateInitInstanceLocal((const ::BesCircle2D*)0x0)->GetImplFileLine();
1163}
1164
1165//______________________________________________________________________________
1166TClass *BesCircle2D::Dictionary()
1167{
1168 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesCircle2D*)0x0)->GetClass();
1169 return fgIsA;
1170}
1171
1172//______________________________________________________________________________
1173TClass *BesCircle2D::Class()
1174{
1175 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesCircle2D*)0x0)->GetClass(); }
1176 return fgIsA;
1177}
1178
1179//______________________________________________________________________________
1180atomic_TClass_ptr BesCursor::fgIsA(0); // static to hold class pointer
1181
1182//______________________________________________________________________________
1183const char *BesCursor::Class_Name()
1184{
1185 return "BesCursor";
1186}
1187
1188//______________________________________________________________________________
1189const char *BesCursor::ImplFileName()
1190{
1191 return ::ROOT::GenerateInitInstanceLocal((const ::BesCursor*)0x0)->GetImplFileName();
1192}
1193
1194//______________________________________________________________________________
1195int BesCursor::ImplFileLine()
1196{
1197 return ::ROOT::GenerateInitInstanceLocal((const ::BesCursor*)0x0)->GetImplFileLine();
1198}
1199
1200//______________________________________________________________________________
1201TClass *BesCursor::Dictionary()
1202{
1203 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesCursor*)0x0)->GetClass();
1204 return fgIsA;
1205}
1206
1207//______________________________________________________________________________
1208TClass *BesCursor::Class()
1209{
1210 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesCursor*)0x0)->GetClass(); }
1211 return fgIsA;
1212}
1213
1214//______________________________________________________________________________
1215atomic_TClass_ptr BesEventHeader::fgIsA(0); // static to hold class pointer
1216
1217//______________________________________________________________________________
1218const char *BesEventHeader::Class_Name()
1219{
1220 return "BesEventHeader";
1221}
1222
1223//______________________________________________________________________________
1224const char *BesEventHeader::ImplFileName()
1225{
1226 return ::ROOT::GenerateInitInstanceLocal((const ::BesEventHeader*)0x0)->GetImplFileName();
1227}
1228
1229//______________________________________________________________________________
1230int BesEventHeader::ImplFileLine()
1231{
1232 return ::ROOT::GenerateInitInstanceLocal((const ::BesEventHeader*)0x0)->GetImplFileLine();
1233}
1234
1235//______________________________________________________________________________
1236TClass *BesEventHeader::Dictionary()
1237{
1238 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesEventHeader*)0x0)->GetClass();
1239 return fgIsA;
1240}
1241
1242//______________________________________________________________________________
1243TClass *BesEventHeader::Class()
1244{
1245 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesEventHeader*)0x0)->GetClass(); }
1246 return fgIsA;
1247}
1248
1249//______________________________________________________________________________
1250atomic_TClass_ptr BesMarker2D::fgIsA(0); // static to hold class pointer
1251
1252//______________________________________________________________________________
1253const char *BesMarker2D::Class_Name()
1254{
1255 return "BesMarker2D";
1256}
1257
1258//______________________________________________________________________________
1259const char *BesMarker2D::ImplFileName()
1260{
1261 return ::ROOT::GenerateInitInstanceLocal((const ::BesMarker2D*)0x0)->GetImplFileName();
1262}
1263
1264//______________________________________________________________________________
1265int BesMarker2D::ImplFileLine()
1266{
1267 return ::ROOT::GenerateInitInstanceLocal((const ::BesMarker2D*)0x0)->GetImplFileLine();
1268}
1269
1270//______________________________________________________________________________
1271TClass *BesMarker2D::Dictionary()
1272{
1273 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesMarker2D*)0x0)->GetClass();
1274 return fgIsA;
1275}
1276
1277//______________________________________________________________________________
1278TClass *BesMarker2D::Class()
1279{
1280 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesMarker2D*)0x0)->GetClass(); }
1281 return fgIsA;
1282}
1283
1284//______________________________________________________________________________
1285atomic_TClass_ptr BesPaveText::fgIsA(0); // static to hold class pointer
1286
1287//______________________________________________________________________________
1288const char *BesPaveText::Class_Name()
1289{
1290 return "BesPaveText";
1291}
1292
1293//______________________________________________________________________________
1294const char *BesPaveText::ImplFileName()
1295{
1296 return ::ROOT::GenerateInitInstanceLocal((const ::BesPaveText*)0x0)->GetImplFileName();
1297}
1298
1299//______________________________________________________________________________
1300int BesPaveText::ImplFileLine()
1301{
1302 return ::ROOT::GenerateInitInstanceLocal((const ::BesPaveText*)0x0)->GetImplFileLine();
1303}
1304
1305//______________________________________________________________________________
1306TClass *BesPaveText::Dictionary()
1307{
1308 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesPaveText*)0x0)->GetClass();
1309 return fgIsA;
1310}
1311
1312//______________________________________________________________________________
1313TClass *BesPaveText::Class()
1314{
1315 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesPaveText*)0x0)->GetClass(); }
1316 return fgIsA;
1317}
1318
1319//______________________________________________________________________________
1320atomic_TClass_ptr BesGeoTrack::fgIsA(0); // static to hold class pointer
1321
1322//______________________________________________________________________________
1323const char *BesGeoTrack::Class_Name()
1324{
1325 return "BesGeoTrack";
1326}
1327
1328//______________________________________________________________________________
1329const char *BesGeoTrack::ImplFileName()
1330{
1331 return ::ROOT::GenerateInitInstanceLocal((const ::BesGeoTrack*)0x0)->GetImplFileName();
1332}
1333
1334//______________________________________________________________________________
1335int BesGeoTrack::ImplFileLine()
1336{
1337 return ::ROOT::GenerateInitInstanceLocal((const ::BesGeoTrack*)0x0)->GetImplFileLine();
1338}
1339
1340//______________________________________________________________________________
1341TClass *BesGeoTrack::Dictionary()
1342{
1343 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesGeoTrack*)0x0)->GetClass();
1344 return fgIsA;
1345}
1346
1347//______________________________________________________________________________
1348TClass *BesGeoTrack::Class()
1349{
1350 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesGeoTrack*)0x0)->GetClass(); }
1351 return fgIsA;
1352}
1353
1354//______________________________________________________________________________
1355atomic_TClass_ptr BesEvent::fgIsA(0); // static to hold class pointer
1356
1357//______________________________________________________________________________
1358const char *BesEvent::Class_Name()
1359{
1360 return "BesEvent";
1361}
1362
1363//______________________________________________________________________________
1364const char *BesEvent::ImplFileName()
1365{
1366 return ::ROOT::GenerateInitInstanceLocal((const ::BesEvent*)0x0)->GetImplFileName();
1367}
1368
1369//______________________________________________________________________________
1370int BesEvent::ImplFileLine()
1371{
1372 return ::ROOT::GenerateInitInstanceLocal((const ::BesEvent*)0x0)->GetImplFileLine();
1373}
1374
1375//______________________________________________________________________________
1376TClass *BesEvent::Dictionary()
1377{
1378 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesEvent*)0x0)->GetClass();
1379 return fgIsA;
1380}
1381
1382//______________________________________________________________________________
1383TClass *BesEvent::Class()
1384{
1385 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesEvent*)0x0)->GetClass(); }
1386 return fgIsA;
1387}
1388
1389//______________________________________________________________________________
1390atomic_TClass_ptr BesView::fgIsA(0); // static to hold class pointer
1391
1392//______________________________________________________________________________
1393const char *BesView::Class_Name()
1394{
1395 return "BesView";
1396}
1397
1398//______________________________________________________________________________
1399const char *BesView::ImplFileName()
1400{
1401 return ::ROOT::GenerateInitInstanceLocal((const ::BesView*)0x0)->GetImplFileName();
1402}
1403
1404//______________________________________________________________________________
1405int BesView::ImplFileLine()
1406{
1407 return ::ROOT::GenerateInitInstanceLocal((const ::BesView*)0x0)->GetImplFileLine();
1408}
1409
1410//______________________________________________________________________________
1411TClass *BesView::Dictionary()
1412{
1413 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesView*)0x0)->GetClass();
1414 return fgIsA;
1415}
1416
1417//______________________________________________________________________________
1418TClass *BesView::Class()
1419{
1420 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesView*)0x0)->GetClass(); }
1421 return fgIsA;
1422}
1423
1424//______________________________________________________________________________
1425atomic_TClass_ptr BesPolygon2D::fgIsA(0); // static to hold class pointer
1426
1427//______________________________________________________________________________
1428const char *BesPolygon2D::Class_Name()
1429{
1430 return "BesPolygon2D";
1431}
1432
1433//______________________________________________________________________________
1434const char *BesPolygon2D::ImplFileName()
1435{
1436 return ::ROOT::GenerateInitInstanceLocal((const ::BesPolygon2D*)0x0)->GetImplFileName();
1437}
1438
1439//______________________________________________________________________________
1440int BesPolygon2D::ImplFileLine()
1441{
1442 return ::ROOT::GenerateInitInstanceLocal((const ::BesPolygon2D*)0x0)->GetImplFileLine();
1443}
1444
1445//______________________________________________________________________________
1446TClass *BesPolygon2D::Dictionary()
1447{
1448 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesPolygon2D*)0x0)->GetClass();
1449 return fgIsA;
1450}
1451
1452//______________________________________________________________________________
1453TClass *BesPolygon2D::Class()
1454{
1455 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesPolygon2D*)0x0)->GetClass(); }
1456 return fgIsA;
1457}
1458
1459//______________________________________________________________________________
1460atomic_TClass_ptr Mdc2DWire::fgIsA(0); // static to hold class pointer
1461
1462//______________________________________________________________________________
1463const char *Mdc2DWire::Class_Name()
1464{
1465 return "Mdc2DWire";
1466}
1467
1468//______________________________________________________________________________
1469const char *Mdc2DWire::ImplFileName()
1470{
1471 return ::ROOT::GenerateInitInstanceLocal((const ::Mdc2DWire*)0x0)->GetImplFileName();
1472}
1473
1474//______________________________________________________________________________
1475int Mdc2DWire::ImplFileLine()
1476{
1477 return ::ROOT::GenerateInitInstanceLocal((const ::Mdc2DWire*)0x0)->GetImplFileLine();
1478}
1479
1480//______________________________________________________________________________
1481TClass *Mdc2DWire::Dictionary()
1482{
1483 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::Mdc2DWire*)0x0)->GetClass();
1484 return fgIsA;
1485}
1486
1487//______________________________________________________________________________
1488TClass *Mdc2DWire::Class()
1489{
1490 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::Mdc2DWire*)0x0)->GetClass(); }
1491 return fgIsA;
1492}
1493
1494//______________________________________________________________________________
1495atomic_TClass_ptr Tof2DScin::fgIsA(0); // static to hold class pointer
1496
1497//______________________________________________________________________________
1498const char *Tof2DScin::Class_Name()
1499{
1500 return "Tof2DScin";
1501}
1502
1503//______________________________________________________________________________
1504const char *Tof2DScin::ImplFileName()
1505{
1506 return ::ROOT::GenerateInitInstanceLocal((const ::Tof2DScin*)0x0)->GetImplFileName();
1507}
1508
1509//______________________________________________________________________________
1510int Tof2DScin::ImplFileLine()
1511{
1512 return ::ROOT::GenerateInitInstanceLocal((const ::Tof2DScin*)0x0)->GetImplFileLine();
1513}
1514
1515//______________________________________________________________________________
1516TClass *Tof2DScin::Dictionary()
1517{
1518 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::Tof2DScin*)0x0)->GetClass();
1519 return fgIsA;
1520}
1521
1522//______________________________________________________________________________
1523TClass *Tof2DScin::Class()
1524{
1525 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::Tof2DScin*)0x0)->GetClass(); }
1526 return fgIsA;
1527}
1528
1529//______________________________________________________________________________
1530atomic_TClass_ptr Emc2DCrystal::fgIsA(0); // static to hold class pointer
1531
1532//______________________________________________________________________________
1533const char *Emc2DCrystal::Class_Name()
1534{
1535 return "Emc2DCrystal";
1536}
1537
1538//______________________________________________________________________________
1539const char *Emc2DCrystal::ImplFileName()
1540{
1541 return ::ROOT::GenerateInitInstanceLocal((const ::Emc2DCrystal*)0x0)->GetImplFileName();
1542}
1543
1544//______________________________________________________________________________
1545int Emc2DCrystal::ImplFileLine()
1546{
1547 return ::ROOT::GenerateInitInstanceLocal((const ::Emc2DCrystal*)0x0)->GetImplFileLine();
1548}
1549
1550//______________________________________________________________________________
1551TClass *Emc2DCrystal::Dictionary()
1552{
1553 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::Emc2DCrystal*)0x0)->GetClass();
1554 return fgIsA;
1555}
1556
1557//______________________________________________________________________________
1558TClass *Emc2DCrystal::Class()
1559{
1560 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::Emc2DCrystal*)0x0)->GetClass(); }
1561 return fgIsA;
1562}
1563
1564//______________________________________________________________________________
1565atomic_TClass_ptr Muc2DStrip::fgIsA(0); // static to hold class pointer
1566
1567//______________________________________________________________________________
1568const char *Muc2DStrip::Class_Name()
1569{
1570 return "Muc2DStrip";
1571}
1572
1573//______________________________________________________________________________
1574const char *Muc2DStrip::ImplFileName()
1575{
1576 return ::ROOT::GenerateInitInstanceLocal((const ::Muc2DStrip*)0x0)->GetImplFileName();
1577}
1578
1579//______________________________________________________________________________
1580int Muc2DStrip::ImplFileLine()
1581{
1582 return ::ROOT::GenerateInitInstanceLocal((const ::Muc2DStrip*)0x0)->GetImplFileLine();
1583}
1584
1585//______________________________________________________________________________
1586TClass *Muc2DStrip::Dictionary()
1587{
1588 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::Muc2DStrip*)0x0)->GetClass();
1589 return fgIsA;
1590}
1591
1592//______________________________________________________________________________
1593TClass *Muc2DStrip::Class()
1594{
1595 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::Muc2DStrip*)0x0)->GetClass(); }
1596 return fgIsA;
1597}
1598
1599//______________________________________________________________________________
1600atomic_TClass_ptr BesGeometry::fgIsA(0); // static to hold class pointer
1601
1602//______________________________________________________________________________
1603const char *BesGeometry::Class_Name()
1604{
1605 return "BesGeometry";
1606}
1607
1608//______________________________________________________________________________
1609const char *BesGeometry::ImplFileName()
1610{
1611 return ::ROOT::GenerateInitInstanceLocal((const ::BesGeometry*)0x0)->GetImplFileName();
1612}
1613
1614//______________________________________________________________________________
1615int BesGeometry::ImplFileLine()
1616{
1617 return ::ROOT::GenerateInitInstanceLocal((const ::BesGeometry*)0x0)->GetImplFileLine();
1618}
1619
1620//______________________________________________________________________________
1621TClass *BesGeometry::Dictionary()
1622{
1623 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesGeometry*)0x0)->GetClass();
1624 return fgIsA;
1625}
1626
1627//______________________________________________________________________________
1628TClass *BesGeometry::Class()
1629{
1630 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesGeometry*)0x0)->GetClass(); }
1631 return fgIsA;
1632}
1633
1634//______________________________________________________________________________
1635atomic_TClass_ptr BesGMenuTitle::fgIsA(0); // static to hold class pointer
1636
1637//______________________________________________________________________________
1638const char *BesGMenuTitle::Class_Name()
1639{
1640 return "BesGMenuTitle";
1641}
1642
1643//______________________________________________________________________________
1644const char *BesGMenuTitle::ImplFileName()
1645{
1646 return ::ROOT::GenerateInitInstanceLocal((const ::BesGMenuTitle*)0x0)->GetImplFileName();
1647}
1648
1649//______________________________________________________________________________
1650int BesGMenuTitle::ImplFileLine()
1651{
1652 return ::ROOT::GenerateInitInstanceLocal((const ::BesGMenuTitle*)0x0)->GetImplFileLine();
1653}
1654
1655//______________________________________________________________________________
1656TClass *BesGMenuTitle::Dictionary()
1657{
1658 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesGMenuTitle*)0x0)->GetClass();
1659 return fgIsA;
1660}
1661
1662//______________________________________________________________________________
1663TClass *BesGMenuTitle::Class()
1664{
1665 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesGMenuTitle*)0x0)->GetClass(); }
1666 return fgIsA;
1667}
1668
1669//______________________________________________________________________________
1670atomic_TClass_ptr BesGMenuBar::fgIsA(0); // static to hold class pointer
1671
1672//______________________________________________________________________________
1673const char *BesGMenuBar::Class_Name()
1674{
1675 return "BesGMenuBar";
1676}
1677
1678//______________________________________________________________________________
1679const char *BesGMenuBar::ImplFileName()
1680{
1681 return ::ROOT::GenerateInitInstanceLocal((const ::BesGMenuBar*)0x0)->GetImplFileName();
1682}
1683
1684//______________________________________________________________________________
1685int BesGMenuBar::ImplFileLine()
1686{
1687 return ::ROOT::GenerateInitInstanceLocal((const ::BesGMenuBar*)0x0)->GetImplFileLine();
1688}
1689
1690//______________________________________________________________________________
1691TClass *BesGMenuBar::Dictionary()
1692{
1693 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesGMenuBar*)0x0)->GetClass();
1694 return fgIsA;
1695}
1696
1697//______________________________________________________________________________
1698TClass *BesGMenuBar::Class()
1699{
1700 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesGMenuBar*)0x0)->GetClass(); }
1701 return fgIsA;
1702}
1703
1704//______________________________________________________________________________
1705atomic_TClass_ptr BesGPictureButton::fgIsA(0); // static to hold class pointer
1706
1707//______________________________________________________________________________
1708const char *BesGPictureButton::Class_Name()
1709{
1710 return "BesGPictureButton";
1711}
1712
1713//______________________________________________________________________________
1714const char *BesGPictureButton::ImplFileName()
1715{
1716 return ::ROOT::GenerateInitInstanceLocal((const ::BesGPictureButton*)0x0)->GetImplFileName();
1717}
1718
1719//______________________________________________________________________________
1720int BesGPictureButton::ImplFileLine()
1721{
1722 return ::ROOT::GenerateInitInstanceLocal((const ::BesGPictureButton*)0x0)->GetImplFileLine();
1723}
1724
1725//______________________________________________________________________________
1726TClass *BesGPictureButton::Dictionary()
1727{
1728 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesGPictureButton*)0x0)->GetClass();
1729 return fgIsA;
1730}
1731
1732//______________________________________________________________________________
1733TClass *BesGPictureButton::Class()
1734{
1735 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesGPictureButton*)0x0)->GetClass(); }
1736 return fgIsA;
1737}
1738
1739//______________________________________________________________________________
1740atomic_TClass_ptr BesHeader::fgIsA(0); // static to hold class pointer
1741
1742//______________________________________________________________________________
1743const char *BesHeader::Class_Name()
1744{
1745 return "BesHeader";
1746}
1747
1748//______________________________________________________________________________
1749const char *BesHeader::ImplFileName()
1750{
1751 return ::ROOT::GenerateInitInstanceLocal((const ::BesHeader*)0x0)->GetImplFileName();
1752}
1753
1754//______________________________________________________________________________
1755int BesHeader::ImplFileLine()
1756{
1757 return ::ROOT::GenerateInitInstanceLocal((const ::BesHeader*)0x0)->GetImplFileLine();
1758}
1759
1760//______________________________________________________________________________
1761TClass *BesHeader::Dictionary()
1762{
1763 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesHeader*)0x0)->GetClass();
1764 return fgIsA;
1765}
1766
1767//______________________________________________________________________________
1768TClass *BesHeader::Class()
1769{
1770 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesHeader*)0x0)->GetClass(); }
1771 return fgIsA;
1772}
1773
1774//______________________________________________________________________________
1775atomic_TClass_ptr BesVisDisplay::fgIsA(0); // static to hold class pointer
1776
1777//______________________________________________________________________________
1778const char *BesVisDisplay::Class_Name()
1779{
1780 return "BesVisDisplay";
1781}
1782
1783//______________________________________________________________________________
1784const char *BesVisDisplay::ImplFileName()
1785{
1786 return ::ROOT::GenerateInitInstanceLocal((const ::BesVisDisplay*)0x0)->GetImplFileName();
1787}
1788
1789//______________________________________________________________________________
1790int BesVisDisplay::ImplFileLine()
1791{
1792 return ::ROOT::GenerateInitInstanceLocal((const ::BesVisDisplay*)0x0)->GetImplFileLine();
1793}
1794
1795//______________________________________________________________________________
1796TClass *BesVisDisplay::Dictionary()
1797{
1798 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesVisDisplay*)0x0)->GetClass();
1799 return fgIsA;
1800}
1801
1802//______________________________________________________________________________
1803TClass *BesVisDisplay::Class()
1804{
1805 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesVisDisplay*)0x0)->GetClass(); }
1806 return fgIsA;
1807}
1808
1809//______________________________________________________________________________
1810atomic_TClass_ptr ZHelix::fgIsA(0); // static to hold class pointer
1811
1812//______________________________________________________________________________
1813const char *ZHelix::Class_Name()
1814{
1815 return "ZHelix";
1816}
1817
1818//______________________________________________________________________________
1819const char *ZHelix::ImplFileName()
1820{
1821 return ::ROOT::GenerateInitInstanceLocal((const ::ZHelix*)0x0)->GetImplFileName();
1822}
1823
1824//______________________________________________________________________________
1825int ZHelix::ImplFileLine()
1826{
1827 return ::ROOT::GenerateInitInstanceLocal((const ::ZHelix*)0x0)->GetImplFileLine();
1828}
1829
1830//______________________________________________________________________________
1831TClass *ZHelix::Dictionary()
1832{
1833 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::ZHelix*)0x0)->GetClass();
1834 return fgIsA;
1835}
1836
1837//______________________________________________________________________________
1838TClass *ZHelix::Class()
1839{
1840 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::ZHelix*)0x0)->GetClass(); }
1841 return fgIsA;
1842}
1843
1844//______________________________________________________________________________
1845void BesStatus::Streamer(TBuffer &R__b)
1846{
1847 // Stream an object of class BesStatus.
1848
1849 if (R__b.IsReading()) {
1850 R__b.ReadClassBuffer(BesStatus::Class(),this);
1851 } else {
1852 R__b.WriteClassBuffer(BesStatus::Class(),this);
1853 }
1854}
1855
1856namespace ROOT {
1857 // Wrappers around operator new
1858 static void *new_BesStatus(void *p) {
1859 return p ? new(p) ::BesStatus : new ::BesStatus;
1860 }
1861 static void *newArray_BesStatus(Long_t nElements, void *p) {
1862 return p ? new(p) ::BesStatus[nElements] : new ::BesStatus[nElements];
1863 }
1864 // Wrapper around operator delete
1865 static void delete_BesStatus(void *p) {
1866 delete ((::BesStatus*)p);
1867 }
1868 static void deleteArray_BesStatus(void *p) {
1869 delete [] ((::BesStatus*)p);
1870 }
1871 static void destruct_BesStatus(void *p) {
1872 typedef ::BesStatus current_t;
1873 ((current_t*)p)->~current_t();
1874 }
1875} // end of namespace ROOT for class ::BesStatus
1876
1877namespace ROOT {
1878 // Wrappers around operator new
1879 static void *new_BesTView(void *p) {
1880 return p ? new(p) ::BesTView : new ::BesTView;
1881 }
1882 static void *newArray_BesTView(Long_t nElements, void *p) {
1883 return p ? new(p) ::BesTView[nElements] : new ::BesTView[nElements];
1884 }
1885 // Wrapper around operator delete
1886 static void delete_BesTView(void *p) {
1887 delete ((::BesTView*)p);
1888 }
1889 static void deleteArray_BesTView(void *p) {
1890 delete [] ((::BesTView*)p);
1891 }
1892 static void destruct_BesTView(void *p) {
1893 typedef ::BesTView current_t;
1894 ((current_t*)p)->~current_t();
1895 }
1896 // Wrapper around a custom streamer member function.
1897 static void streamer_BesTView(TBuffer &buf, void *obj) {
1898 ((::BesTView*)obj)->::BesTView::Streamer(buf);
1899 }
1900} // end of namespace ROOT for class ::BesTView
1901
1902//______________________________________________________________________________
1903void Bes2DView::Streamer(TBuffer &R__b)
1904{
1905 // Stream an object of class Bes2DView.
1906
1907 if (R__b.IsReading()) {
1908 R__b.ReadClassBuffer(Bes2DView::Class(),this);
1909 } else {
1910 R__b.WriteClassBuffer(Bes2DView::Class(),this);
1911 }
1912}
1913
1914namespace ROOT {
1915 // Wrappers around operator new
1916 static void *new_Bes2DView(void *p) {
1917 return p ? new(p) ::Bes2DView : new ::Bes2DView;
1918 }
1919 static void *newArray_Bes2DView(Long_t nElements, void *p) {
1920 return p ? new(p) ::Bes2DView[nElements] : new ::Bes2DView[nElements];
1921 }
1922 // Wrapper around operator delete
1923 static void delete_Bes2DView(void *p) {
1924 delete ((::Bes2DView*)p);
1925 }
1926 static void deleteArray_Bes2DView(void *p) {
1927 delete [] ((::Bes2DView*)p);
1928 }
1929 static void destruct_Bes2DView(void *p) {
1930 typedef ::Bes2DView current_t;
1931 ((current_t*)p)->~current_t();
1932 }
1933} // end of namespace ROOT for class ::Bes2DView
1934
1935//______________________________________________________________________________
1936void BesCircle2D::Streamer(TBuffer &R__b)
1937{
1938 // Stream an object of class BesCircle2D.
1939
1940 if (R__b.IsReading()) {
1941 R__b.ReadClassBuffer(BesCircle2D::Class(),this);
1942 } else {
1943 R__b.WriteClassBuffer(BesCircle2D::Class(),this);
1944 }
1945}
1946
1947namespace ROOT {
1948 // Wrappers around operator new
1949 static void *new_BesCircle2D(void *p) {
1950 return p ? new(p) ::BesCircle2D : new ::BesCircle2D;
1951 }
1952 static void *newArray_BesCircle2D(Long_t nElements, void *p) {
1953 return p ? new(p) ::BesCircle2D[nElements] : new ::BesCircle2D[nElements];
1954 }
1955 // Wrapper around operator delete
1956 static void delete_BesCircle2D(void *p) {
1957 delete ((::BesCircle2D*)p);
1958 }
1959 static void deleteArray_BesCircle2D(void *p) {
1960 delete [] ((::BesCircle2D*)p);
1961 }
1962 static void destruct_BesCircle2D(void *p) {
1963 typedef ::BesCircle2D current_t;
1964 ((current_t*)p)->~current_t();
1965 }
1966} // end of namespace ROOT for class ::BesCircle2D
1967
1968//______________________________________________________________________________
1969void BesCursor::Streamer(TBuffer &R__b)
1970{
1971 // Stream an object of class BesCursor.
1972
1973 if (R__b.IsReading()) {
1974 R__b.ReadClassBuffer(BesCursor::Class(),this);
1975 } else {
1976 R__b.WriteClassBuffer(BesCursor::Class(),this);
1977 }
1978}
1979
1980namespace ROOT {
1981 // Wrappers around operator new
1982 static void *new_BesCursor(void *p) {
1983 return p ? new(p) ::BesCursor : new ::BesCursor;
1984 }
1985 static void *newArray_BesCursor(Long_t nElements, void *p) {
1986 return p ? new(p) ::BesCursor[nElements] : new ::BesCursor[nElements];
1987 }
1988 // Wrapper around operator delete
1989 static void delete_BesCursor(void *p) {
1990 delete ((::BesCursor*)p);
1991 }
1992 static void deleteArray_BesCursor(void *p) {
1993 delete [] ((::BesCursor*)p);
1994 }
1995 static void destruct_BesCursor(void *p) {
1996 typedef ::BesCursor current_t;
1997 ((current_t*)p)->~current_t();
1998 }
1999} // end of namespace ROOT for class ::BesCursor
2000
2001//______________________________________________________________________________
2002void BesEventHeader::Streamer(TBuffer &R__b)
2003{
2004 // Stream an object of class BesEventHeader.
2005
2006 if (R__b.IsReading()) {
2007 R__b.ReadClassBuffer(BesEventHeader::Class(),this);
2008 } else {
2009 R__b.WriteClassBuffer(BesEventHeader::Class(),this);
2010 }
2011}
2012
2013namespace ROOT {
2014 // Wrappers around operator new
2015 static void *new_BesEventHeader(void *p) {
2016 return p ? new(p) ::BesEventHeader : new ::BesEventHeader;
2017 }
2018 static void *newArray_BesEventHeader(Long_t nElements, void *p) {
2019 return p ? new(p) ::BesEventHeader[nElements] : new ::BesEventHeader[nElements];
2020 }
2021 // Wrapper around operator delete
2022 static void delete_BesEventHeader(void *p) {
2023 delete ((::BesEventHeader*)p);
2024 }
2025 static void deleteArray_BesEventHeader(void *p) {
2026 delete [] ((::BesEventHeader*)p);
2027 }
2028 static void destruct_BesEventHeader(void *p) {
2029 typedef ::BesEventHeader current_t;
2030 ((current_t*)p)->~current_t();
2031 }
2032} // end of namespace ROOT for class ::BesEventHeader
2033
2034//______________________________________________________________________________
2035void BesMarker2D::Streamer(TBuffer &R__b)
2036{
2037 // Stream an object of class BesMarker2D.
2038
2039 if (R__b.IsReading()) {
2040 R__b.ReadClassBuffer(BesMarker2D::Class(),this);
2041 } else {
2042 R__b.WriteClassBuffer(BesMarker2D::Class(),this);
2043 }
2044}
2045
2046namespace ROOT {
2047 // Wrappers around operator new
2048 static void *new_BesMarker2D(void *p) {
2049 return p ? new(p) ::BesMarker2D : new ::BesMarker2D;
2050 }
2051 static void *newArray_BesMarker2D(Long_t nElements, void *p) {
2052 return p ? new(p) ::BesMarker2D[nElements] : new ::BesMarker2D[nElements];
2053 }
2054 // Wrapper around operator delete
2055 static void delete_BesMarker2D(void *p) {
2056 delete ((::BesMarker2D*)p);
2057 }
2058 static void deleteArray_BesMarker2D(void *p) {
2059 delete [] ((::BesMarker2D*)p);
2060 }
2061 static void destruct_BesMarker2D(void *p) {
2062 typedef ::BesMarker2D current_t;
2063 ((current_t*)p)->~current_t();
2064 }
2065} // end of namespace ROOT for class ::BesMarker2D
2066
2067//______________________________________________________________________________
2068void BesPaveText::Streamer(TBuffer &R__b)
2069{
2070 // Stream an object of class BesPaveText.
2071
2072 if (R__b.IsReading()) {
2073 R__b.ReadClassBuffer(BesPaveText::Class(),this);
2074 } else {
2075 R__b.WriteClassBuffer(BesPaveText::Class(),this);
2076 }
2077}
2078
2079namespace ROOT {
2080 // Wrappers around operator new
2081 static void *new_BesPaveText(void *p) {
2082 return p ? new(p) ::BesPaveText : new ::BesPaveText;
2083 }
2084 static void *newArray_BesPaveText(Long_t nElements, void *p) {
2085 return p ? new(p) ::BesPaveText[nElements] : new ::BesPaveText[nElements];
2086 }
2087 // Wrapper around operator delete
2088 static void delete_BesPaveText(void *p) {
2089 delete ((::BesPaveText*)p);
2090 }
2091 static void deleteArray_BesPaveText(void *p) {
2092 delete [] ((::BesPaveText*)p);
2093 }
2094 static void destruct_BesPaveText(void *p) {
2095 typedef ::BesPaveText current_t;
2096 ((current_t*)p)->~current_t();
2097 }
2098} // end of namespace ROOT for class ::BesPaveText
2099
2100//______________________________________________________________________________
2101void BesGeoTrack::Streamer(TBuffer &R__b)
2102{
2103 // Stream an object of class BesGeoTrack.
2104
2105 if (R__b.IsReading()) {
2106 R__b.ReadClassBuffer(BesGeoTrack::Class(),this);
2107 } else {
2108 R__b.WriteClassBuffer(BesGeoTrack::Class(),this);
2109 }
2110}
2111
2112namespace ROOT {
2113 // Wrappers around operator new
2114 static void *new_BesGeoTrack(void *p) {
2115 return p ? new(p) ::BesGeoTrack : new ::BesGeoTrack;
2116 }
2117 static void *newArray_BesGeoTrack(Long_t nElements, void *p) {
2118 return p ? new(p) ::BesGeoTrack[nElements] : new ::BesGeoTrack[nElements];
2119 }
2120 // Wrapper around operator delete
2121 static void delete_BesGeoTrack(void *p) {
2122 delete ((::BesGeoTrack*)p);
2123 }
2124 static void deleteArray_BesGeoTrack(void *p) {
2125 delete [] ((::BesGeoTrack*)p);
2126 }
2127 static void destruct_BesGeoTrack(void *p) {
2128 typedef ::BesGeoTrack current_t;
2129 ((current_t*)p)->~current_t();
2130 }
2131} // end of namespace ROOT for class ::BesGeoTrack
2132
2133//______________________________________________________________________________
2134void BesEvent::Streamer(TBuffer &R__b)
2135{
2136 // Stream an object of class BesEvent.
2137
2138 if (R__b.IsReading()) {
2139 R__b.ReadClassBuffer(BesEvent::Class(),this);
2140 } else {
2141 R__b.WriteClassBuffer(BesEvent::Class(),this);
2142 }
2143}
2144
2145namespace ROOT {
2146 // Wrappers around operator new
2147 static void *new_BesEvent(void *p) {
2148 return p ? new(p) ::BesEvent : new ::BesEvent;
2149 }
2150 static void *newArray_BesEvent(Long_t nElements, void *p) {
2151 return p ? new(p) ::BesEvent[nElements] : new ::BesEvent[nElements];
2152 }
2153 // Wrapper around operator delete
2154 static void delete_BesEvent(void *p) {
2155 delete ((::BesEvent*)p);
2156 }
2157 static void deleteArray_BesEvent(void *p) {
2158 delete [] ((::BesEvent*)p);
2159 }
2160 static void destruct_BesEvent(void *p) {
2161 typedef ::BesEvent current_t;
2162 ((current_t*)p)->~current_t();
2163 }
2164} // end of namespace ROOT for class ::BesEvent
2165
2166//______________________________________________________________________________
2167void BesView::Streamer(TBuffer &R__b)
2168{
2169 // Stream an object of class BesView.
2170
2171 if (R__b.IsReading()) {
2172 R__b.ReadClassBuffer(BesView::Class(),this);
2173 } else {
2174 R__b.WriteClassBuffer(BesView::Class(),this);
2175 }
2176}
2177
2178namespace ROOT {
2179 // Wrappers around operator new
2180 static void *new_BesView(void *p) {
2181 return p ? new(p) ::BesView : new ::BesView;
2182 }
2183 static void *newArray_BesView(Long_t nElements, void *p) {
2184 return p ? new(p) ::BesView[nElements] : new ::BesView[nElements];
2185 }
2186 // Wrapper around operator delete
2187 static void delete_BesView(void *p) {
2188 delete ((::BesView*)p);
2189 }
2190 static void deleteArray_BesView(void *p) {
2191 delete [] ((::BesView*)p);
2192 }
2193 static void destruct_BesView(void *p) {
2194 typedef ::BesView current_t;
2195 ((current_t*)p)->~current_t();
2196 }
2197} // end of namespace ROOT for class ::BesView
2198
2199namespace ROOT {
2200 // Wrappers around operator new
2201 static void *new_SubDetectorROOTGeo(void *p) {
2202 return p ? new(p) ::SubDetectorROOTGeo : new ::SubDetectorROOTGeo;
2203 }
2204 static void *newArray_SubDetectorROOTGeo(Long_t nElements, void *p) {
2205 return p ? new(p) ::SubDetectorROOTGeo[nElements] : new ::SubDetectorROOTGeo[nElements];
2206 }
2207 // Wrapper around operator delete
2208 static void delete_SubDetectorROOTGeo(void *p) {
2209 delete ((::SubDetectorROOTGeo*)p);
2210 }
2211 static void deleteArray_SubDetectorROOTGeo(void *p) {
2212 delete [] ((::SubDetectorROOTGeo*)p);
2213 }
2214 static void destruct_SubDetectorROOTGeo(void *p) {
2215 typedef ::SubDetectorROOTGeo current_t;
2216 ((current_t*)p)->~current_t();
2217 }
2218} // end of namespace ROOT for class ::SubDetectorROOTGeo
2219
2220//______________________________________________________________________________
2221void BesPolygon2D::Streamer(TBuffer &R__b)
2222{
2223 // Stream an object of class BesPolygon2D.
2224
2225 if (R__b.IsReading()) {
2226 R__b.ReadClassBuffer(BesPolygon2D::Class(),this);
2227 } else {
2228 R__b.WriteClassBuffer(BesPolygon2D::Class(),this);
2229 }
2230}
2231
2232namespace ROOT {
2233 // Wrappers around operator new
2234 static void *new_BesPolygon2D(void *p) {
2235 return p ? new(p) ::BesPolygon2D : new ::BesPolygon2D;
2236 }
2237 static void *newArray_BesPolygon2D(Long_t nElements, void *p) {
2238 return p ? new(p) ::BesPolygon2D[nElements] : new ::BesPolygon2D[nElements];
2239 }
2240 // Wrapper around operator delete
2241 static void delete_BesPolygon2D(void *p) {
2242 delete ((::BesPolygon2D*)p);
2243 }
2244 static void deleteArray_BesPolygon2D(void *p) {
2245 delete [] ((::BesPolygon2D*)p);
2246 }
2247 static void destruct_BesPolygon2D(void *p) {
2248 typedef ::BesPolygon2D current_t;
2249 ((current_t*)p)->~current_t();
2250 }
2251} // end of namespace ROOT for class ::BesPolygon2D
2252
2253//______________________________________________________________________________
2254void Mdc2DWire::Streamer(TBuffer &R__b)
2255{
2256 // Stream an object of class Mdc2DWire.
2257
2258 if (R__b.IsReading()) {
2259 R__b.ReadClassBuffer(Mdc2DWire::Class(),this);
2260 } else {
2261 R__b.WriteClassBuffer(Mdc2DWire::Class(),this);
2262 }
2263}
2264
2265namespace ROOT {
2266 // Wrappers around operator new
2267 static void *new_Mdc2DWire(void *p) {
2268 return p ? new(p) ::Mdc2DWire : new ::Mdc2DWire;
2269 }
2270 static void *newArray_Mdc2DWire(Long_t nElements, void *p) {
2271 return p ? new(p) ::Mdc2DWire[nElements] : new ::Mdc2DWire[nElements];
2272 }
2273 // Wrapper around operator delete
2274 static void delete_Mdc2DWire(void *p) {
2275 delete ((::Mdc2DWire*)p);
2276 }
2277 static void deleteArray_Mdc2DWire(void *p) {
2278 delete [] ((::Mdc2DWire*)p);
2279 }
2280 static void destruct_Mdc2DWire(void *p) {
2281 typedef ::Mdc2DWire current_t;
2282 ((current_t*)p)->~current_t();
2283 }
2284} // end of namespace ROOT for class ::Mdc2DWire
2285
2286namespace ROOT {
2287 // Wrappers around operator new
2288 static void *new_MdcROOTGeo(void *p) {
2289 return p ? new(p) ::MdcROOTGeo : new ::MdcROOTGeo;
2290 }
2291 static void *newArray_MdcROOTGeo(Long_t nElements, void *p) {
2292 return p ? new(p) ::MdcROOTGeo[nElements] : new ::MdcROOTGeo[nElements];
2293 }
2294 // Wrapper around operator delete
2295 static void delete_MdcROOTGeo(void *p) {
2296 delete ((::MdcROOTGeo*)p);
2297 }
2298 static void deleteArray_MdcROOTGeo(void *p) {
2299 delete [] ((::MdcROOTGeo*)p);
2300 }
2301 static void destruct_MdcROOTGeo(void *p) {
2302 typedef ::MdcROOTGeo current_t;
2303 ((current_t*)p)->~current_t();
2304 }
2305} // end of namespace ROOT for class ::MdcROOTGeo
2306
2307//______________________________________________________________________________
2308void Tof2DScin::Streamer(TBuffer &R__b)
2309{
2310 // Stream an object of class Tof2DScin.
2311
2312 if (R__b.IsReading()) {
2313 R__b.ReadClassBuffer(Tof2DScin::Class(),this);
2314 } else {
2315 R__b.WriteClassBuffer(Tof2DScin::Class(),this);
2316 }
2317}
2318
2319namespace ROOT {
2320 // Wrappers around operator new
2321 static void *new_Tof2DScin(void *p) {
2322 return p ? new(p) ::Tof2DScin : new ::Tof2DScin;
2323 }
2324 static void *newArray_Tof2DScin(Long_t nElements, void *p) {
2325 return p ? new(p) ::Tof2DScin[nElements] : new ::Tof2DScin[nElements];
2326 }
2327 // Wrapper around operator delete
2328 static void delete_Tof2DScin(void *p) {
2329 delete ((::Tof2DScin*)p);
2330 }
2331 static void deleteArray_Tof2DScin(void *p) {
2332 delete [] ((::Tof2DScin*)p);
2333 }
2334 static void destruct_Tof2DScin(void *p) {
2335 typedef ::Tof2DScin current_t;
2336 ((current_t*)p)->~current_t();
2337 }
2338} // end of namespace ROOT for class ::Tof2DScin
2339
2340namespace ROOT {
2341 // Wrappers around operator new
2342 static void *new_TofROOTGeo(void *p) {
2343 return p ? new(p) ::TofROOTGeo : new ::TofROOTGeo;
2344 }
2345 static void *newArray_TofROOTGeo(Long_t nElements, void *p) {
2346 return p ? new(p) ::TofROOTGeo[nElements] : new ::TofROOTGeo[nElements];
2347 }
2348 // Wrapper around operator delete
2349 static void delete_TofROOTGeo(void *p) {
2350 delete ((::TofROOTGeo*)p);
2351 }
2352 static void deleteArray_TofROOTGeo(void *p) {
2353 delete [] ((::TofROOTGeo*)p);
2354 }
2355 static void destruct_TofROOTGeo(void *p) {
2356 typedef ::TofROOTGeo current_t;
2357 ((current_t*)p)->~current_t();
2358 }
2359} // end of namespace ROOT for class ::TofROOTGeo
2360
2361//______________________________________________________________________________
2362void Emc2DCrystal::Streamer(TBuffer &R__b)
2363{
2364 // Stream an object of class Emc2DCrystal.
2365
2366 if (R__b.IsReading()) {
2367 R__b.ReadClassBuffer(Emc2DCrystal::Class(),this);
2368 } else {
2369 R__b.WriteClassBuffer(Emc2DCrystal::Class(),this);
2370 }
2371}
2372
2373namespace ROOT {
2374 // Wrappers around operator new
2375 static void *new_Emc2DCrystal(void *p) {
2376 return p ? new(p) ::Emc2DCrystal : new ::Emc2DCrystal;
2377 }
2378 static void *newArray_Emc2DCrystal(Long_t nElements, void *p) {
2379 return p ? new(p) ::Emc2DCrystal[nElements] : new ::Emc2DCrystal[nElements];
2380 }
2381 // Wrapper around operator delete
2382 static void delete_Emc2DCrystal(void *p) {
2383 delete ((::Emc2DCrystal*)p);
2384 }
2385 static void deleteArray_Emc2DCrystal(void *p) {
2386 delete [] ((::Emc2DCrystal*)p);
2387 }
2388 static void destruct_Emc2DCrystal(void *p) {
2389 typedef ::Emc2DCrystal current_t;
2390 ((current_t*)p)->~current_t();
2391 }
2392} // end of namespace ROOT for class ::Emc2DCrystal
2393
2394namespace ROOT {
2395 // Wrappers around operator new
2396 static void *new_EmcROOTGeo(void *p) {
2397 return p ? new(p) ::EmcROOTGeo : new ::EmcROOTGeo;
2398 }
2399 static void *newArray_EmcROOTGeo(Long_t nElements, void *p) {
2400 return p ? new(p) ::EmcROOTGeo[nElements] : new ::EmcROOTGeo[nElements];
2401 }
2402 // Wrapper around operator delete
2403 static void delete_EmcROOTGeo(void *p) {
2404 delete ((::EmcROOTGeo*)p);
2405 }
2406 static void deleteArray_EmcROOTGeo(void *p) {
2407 delete [] ((::EmcROOTGeo*)p);
2408 }
2409 static void destruct_EmcROOTGeo(void *p) {
2410 typedef ::EmcROOTGeo current_t;
2411 ((current_t*)p)->~current_t();
2412 }
2413} // end of namespace ROOT for class ::EmcROOTGeo
2414
2415//______________________________________________________________________________
2416void Muc2DStrip::Streamer(TBuffer &R__b)
2417{
2418 // Stream an object of class Muc2DStrip.
2419
2420 if (R__b.IsReading()) {
2421 R__b.ReadClassBuffer(Muc2DStrip::Class(),this);
2422 } else {
2423 R__b.WriteClassBuffer(Muc2DStrip::Class(),this);
2424 }
2425}
2426
2427namespace ROOT {
2428 // Wrappers around operator new
2429 static void *new_Muc2DStrip(void *p) {
2430 return p ? new(p) ::Muc2DStrip : new ::Muc2DStrip;
2431 }
2432 static void *newArray_Muc2DStrip(Long_t nElements, void *p) {
2433 return p ? new(p) ::Muc2DStrip[nElements] : new ::Muc2DStrip[nElements];
2434 }
2435 // Wrapper around operator delete
2436 static void delete_Muc2DStrip(void *p) {
2437 delete ((::Muc2DStrip*)p);
2438 }
2439 static void deleteArray_Muc2DStrip(void *p) {
2440 delete [] ((::Muc2DStrip*)p);
2441 }
2442 static void destruct_Muc2DStrip(void *p) {
2443 typedef ::Muc2DStrip current_t;
2444 ((current_t*)p)->~current_t();
2445 }
2446} // end of namespace ROOT for class ::Muc2DStrip
2447
2448namespace ROOT {
2449 // Wrappers around operator new
2450 static void *new_MucROOTGeo(void *p) {
2451 return p ? new(p) ::MucROOTGeo : new ::MucROOTGeo;
2452 }
2453 static void *newArray_MucROOTGeo(Long_t nElements, void *p) {
2454 return p ? new(p) ::MucROOTGeo[nElements] : new ::MucROOTGeo[nElements];
2455 }
2456 // Wrapper around operator delete
2457 static void delete_MucROOTGeo(void *p) {
2458 delete ((::MucROOTGeo*)p);
2459 }
2460 static void deleteArray_MucROOTGeo(void *p) {
2461 delete [] ((::MucROOTGeo*)p);
2462 }
2463 static void destruct_MucROOTGeo(void *p) {
2464 typedef ::MucROOTGeo current_t;
2465 ((current_t*)p)->~current_t();
2466 }
2467} // end of namespace ROOT for class ::MucROOTGeo
2468
2469//______________________________________________________________________________
2470void BesGeometry::Streamer(TBuffer &R__b)
2471{
2472 // Stream an object of class BesGeometry.
2473
2474 if (R__b.IsReading()) {
2475 R__b.ReadClassBuffer(BesGeometry::Class(),this);
2476 } else {
2477 R__b.WriteClassBuffer(BesGeometry::Class(),this);
2478 }
2479}
2480
2481namespace ROOT {
2482 // Wrappers around operator new
2483 static void *new_BesGeometry(void *p) {
2484 return p ? new(p) ::BesGeometry : new ::BesGeometry;
2485 }
2486 static void *newArray_BesGeometry(Long_t nElements, void *p) {
2487 return p ? new(p) ::BesGeometry[nElements] : new ::BesGeometry[nElements];
2488 }
2489 // Wrapper around operator delete
2490 static void delete_BesGeometry(void *p) {
2491 delete ((::BesGeometry*)p);
2492 }
2493 static void deleteArray_BesGeometry(void *p) {
2494 delete [] ((::BesGeometry*)p);
2495 }
2496 static void destruct_BesGeometry(void *p) {
2497 typedef ::BesGeometry current_t;
2498 ((current_t*)p)->~current_t();
2499 }
2500} // end of namespace ROOT for class ::BesGeometry
2501
2502//______________________________________________________________________________
2503void BesGMenuTitle::Streamer(TBuffer &R__b)
2504{
2505 // Stream an object of class BesGMenuTitle.
2506
2507 if (R__b.IsReading()) {
2508 R__b.ReadClassBuffer(BesGMenuTitle::Class(),this);
2509 } else {
2510 R__b.WriteClassBuffer(BesGMenuTitle::Class(),this);
2511 }
2512}
2513
2514namespace ROOT {
2515 // Wrappers around operator new
2516 static void *new_BesGMenuTitle(void *p) {
2517 return p ? new(p) ::BesGMenuTitle : new ::BesGMenuTitle;
2518 }
2519 static void *newArray_BesGMenuTitle(Long_t nElements, void *p) {
2520 return p ? new(p) ::BesGMenuTitle[nElements] : new ::BesGMenuTitle[nElements];
2521 }
2522 // Wrapper around operator delete
2523 static void delete_BesGMenuTitle(void *p) {
2524 delete ((::BesGMenuTitle*)p);
2525 }
2526 static void deleteArray_BesGMenuTitle(void *p) {
2527 delete [] ((::BesGMenuTitle*)p);
2528 }
2529 static void destruct_BesGMenuTitle(void *p) {
2530 typedef ::BesGMenuTitle current_t;
2531 ((current_t*)p)->~current_t();
2532 }
2533} // end of namespace ROOT for class ::BesGMenuTitle
2534
2535//______________________________________________________________________________
2536void BesGMenuBar::Streamer(TBuffer &R__b)
2537{
2538 // Stream an object of class BesGMenuBar.
2539
2540 if (R__b.IsReading()) {
2541 R__b.ReadClassBuffer(BesGMenuBar::Class(),this);
2542 } else {
2543 R__b.WriteClassBuffer(BesGMenuBar::Class(),this);
2544 }
2545}
2546
2547namespace ROOT {
2548 // Wrappers around operator new
2549 static void *new_BesGMenuBar(void *p) {
2550 return p ? new(p) ::BesGMenuBar : new ::BesGMenuBar;
2551 }
2552 static void *newArray_BesGMenuBar(Long_t nElements, void *p) {
2553 return p ? new(p) ::BesGMenuBar[nElements] : new ::BesGMenuBar[nElements];
2554 }
2555 // Wrapper around operator delete
2556 static void delete_BesGMenuBar(void *p) {
2557 delete ((::BesGMenuBar*)p);
2558 }
2559 static void deleteArray_BesGMenuBar(void *p) {
2560 delete [] ((::BesGMenuBar*)p);
2561 }
2562 static void destruct_BesGMenuBar(void *p) {
2563 typedef ::BesGMenuBar current_t;
2564 ((current_t*)p)->~current_t();
2565 }
2566} // end of namespace ROOT for class ::BesGMenuBar
2567
2568//______________________________________________________________________________
2569void BesGPictureButton::Streamer(TBuffer &R__b)
2570{
2571 // Stream an object of class BesGPictureButton.
2572
2573 if (R__b.IsReading()) {
2574 R__b.ReadClassBuffer(BesGPictureButton::Class(),this);
2575 } else {
2576 R__b.WriteClassBuffer(BesGPictureButton::Class(),this);
2577 }
2578}
2579
2580namespace ROOT {
2581 // Wrappers around operator new
2582 static void *new_BesGPictureButton(void *p) {
2583 return p ? new(p) ::BesGPictureButton : new ::BesGPictureButton;
2584 }
2585 static void *newArray_BesGPictureButton(Long_t nElements, void *p) {
2586 return p ? new(p) ::BesGPictureButton[nElements] : new ::BesGPictureButton[nElements];
2587 }
2588 // Wrapper around operator delete
2589 static void delete_BesGPictureButton(void *p) {
2590 delete ((::BesGPictureButton*)p);
2591 }
2592 static void deleteArray_BesGPictureButton(void *p) {
2593 delete [] ((::BesGPictureButton*)p);
2594 }
2595 static void destruct_BesGPictureButton(void *p) {
2596 typedef ::BesGPictureButton current_t;
2597 ((current_t*)p)->~current_t();
2598 }
2599} // end of namespace ROOT for class ::BesGPictureButton
2600
2601//______________________________________________________________________________
2602void BesHeader::Streamer(TBuffer &R__b)
2603{
2604 // Stream an object of class BesHeader.
2605
2606 if (R__b.IsReading()) {
2607 R__b.ReadClassBuffer(BesHeader::Class(),this);
2608 } else {
2609 R__b.WriteClassBuffer(BesHeader::Class(),this);
2610 }
2611}
2612
2613namespace ROOT {
2614 // Wrappers around operator new
2615 static void *new_BesHeader(void *p) {
2616 return p ? new(p) ::BesHeader : new ::BesHeader;
2617 }
2618 static void *newArray_BesHeader(Long_t nElements, void *p) {
2619 return p ? new(p) ::BesHeader[nElements] : new ::BesHeader[nElements];
2620 }
2621 // Wrapper around operator delete
2622 static void delete_BesHeader(void *p) {
2623 delete ((::BesHeader*)p);
2624 }
2625 static void deleteArray_BesHeader(void *p) {
2626 delete [] ((::BesHeader*)p);
2627 }
2628 static void destruct_BesHeader(void *p) {
2629 typedef ::BesHeader current_t;
2630 ((current_t*)p)->~current_t();
2631 }
2632} // end of namespace ROOT for class ::BesHeader
2633
2634//______________________________________________________________________________
2635void BesVisDisplay::Streamer(TBuffer &R__b)
2636{
2637 // Stream an object of class BesVisDisplay.
2638
2639 if (R__b.IsReading()) {
2640 R__b.ReadClassBuffer(BesVisDisplay::Class(),this);
2641 } else {
2642 R__b.WriteClassBuffer(BesVisDisplay::Class(),this);
2643 }
2644}
2645
2646namespace ROOT {
2647 // Wrappers around operator new
2648 static void *new_BesVisDisplay(void *p) {
2649 return p ? new(p) ::BesVisDisplay : new ::BesVisDisplay;
2650 }
2651 static void *newArray_BesVisDisplay(Long_t nElements, void *p) {
2652 return p ? new(p) ::BesVisDisplay[nElements] : new ::BesVisDisplay[nElements];
2653 }
2654 // Wrapper around operator delete
2655 static void delete_BesVisDisplay(void *p) {
2656 delete ((::BesVisDisplay*)p);
2657 }
2658 static void deleteArray_BesVisDisplay(void *p) {
2659 delete [] ((::BesVisDisplay*)p);
2660 }
2661 static void destruct_BesVisDisplay(void *p) {
2662 typedef ::BesVisDisplay current_t;
2663 ((current_t*)p)->~current_t();
2664 }
2665} // end of namespace ROOT for class ::BesVisDisplay
2666
2667//______________________________________________________________________________
2668void ZHelix::Streamer(TBuffer &R__b)
2669{
2670 // Stream an object of class ZHelix.
2671
2672 if (R__b.IsReading()) {
2673 R__b.ReadClassBuffer(ZHelix::Class(),this);
2674 } else {
2675 R__b.WriteClassBuffer(ZHelix::Class(),this);
2676 }
2677}
2678
2679namespace ROOT {
2680 // Wrappers around operator new
2681 static void *new_ZHelix(void *p) {
2682 return p ? new(p) ::ZHelix : new ::ZHelix;
2683 }
2684 static void *newArray_ZHelix(Long_t nElements, void *p) {
2685 return p ? new(p) ::ZHelix[nElements] : new ::ZHelix[nElements];
2686 }
2687 // Wrapper around operator delete
2688 static void delete_ZHelix(void *p) {
2689 delete ((::ZHelix*)p);
2690 }
2691 static void deleteArray_ZHelix(void *p) {
2692 delete [] ((::ZHelix*)p);
2693 }
2694 static void destruct_ZHelix(void *p) {
2695 typedef ::ZHelix current_t;
2696 ((current_t*)p)->~current_t();
2697 }
2698 // Wrapper around the merge function.
2699 static Long64_t merge_ZHelix(void *obj,TCollection *coll,TFileMergeInfo *) {
2700 return ((::ZHelix*)obj)->Merge(coll);
2701 }
2702} // end of namespace ROOT for class ::ZHelix
2703
2704namespace ROOT {
2705 static TClass *vectorlETStringgR_Dictionary();
2706 static void vectorlETStringgR_TClassManip(TClass*);
2707 static void *new_vectorlETStringgR(void *p = 0);
2708 static void *newArray_vectorlETStringgR(Long_t size, void *p);
2709 static void delete_vectorlETStringgR(void *p);
2710 static void deleteArray_vectorlETStringgR(void *p);
2711 static void destruct_vectorlETStringgR(void *p);
2712
2713 // Function generating the singleton type initializer
2714 static TGenericClassInfo *GenerateInitInstanceLocal(const vector<TString>*)
2715 {
2716 vector<TString> *ptr = 0;
2717 static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<TString>));
2718 static ::ROOT::TGenericClassInfo
2719 instance("vector<TString>", -2, "vector", 214,
2720 typeid(vector<TString>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
2721 &vectorlETStringgR_Dictionary, isa_proxy, 0,
2722 sizeof(vector<TString>) );
2723 instance.SetNew(&new_vectorlETStringgR);
2724 instance.SetNewArray(&newArray_vectorlETStringgR);
2725 instance.SetDelete(&delete_vectorlETStringgR);
2726 instance.SetDeleteArray(&deleteArray_vectorlETStringgR);
2727 instance.SetDestructor(&destruct_vectorlETStringgR);
2728 instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<TString> >()));
2729 return &instance;
2730 }
2731 // Static variable to force the class initialization
2732 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const vector<TString>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
2733
2734 // Dictionary for non-ClassDef classes
2735 static TClass *vectorlETStringgR_Dictionary() {
2736 TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector<TString>*)0x0)->GetClass();
2737 vectorlETStringgR_TClassManip(theClass);
2738 return theClass;
2739 }
2740
2741 static void vectorlETStringgR_TClassManip(TClass* ){
2742 }
2743
2744} // end of namespace ROOT
2745
2746namespace ROOT {
2747 // Wrappers around operator new
2748 static void *new_vectorlETStringgR(void *p) {
2749 return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<TString> : new vector<TString>;
2750 }
2751 static void *newArray_vectorlETStringgR(Long_t nElements, void *p) {
2752 return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<TString>[nElements] : new vector<TString>[nElements];
2753 }
2754 // Wrapper around operator delete
2755 static void delete_vectorlETStringgR(void *p) {
2756 delete ((vector<TString>*)p);
2757 }
2758 static void deleteArray_vectorlETStringgR(void *p) {
2759 delete [] ((vector<TString>*)p);
2760 }
2761 static void destruct_vectorlETStringgR(void *p) {
2762 typedef vector<TString> current_t;
2763 ((current_t*)p)->~current_t();
2764 }
2765} // end of namespace ROOT for class vector<TString>
2766
2767namespace ROOT {
2768 static TClass *maplEintcOintgR_Dictionary();
2769 static void maplEintcOintgR_TClassManip(TClass*);
2770 static void *new_maplEintcOintgR(void *p = 0);
2771 static void *newArray_maplEintcOintgR(Long_t size, void *p);
2772 static void delete_maplEintcOintgR(void *p);
2773 static void deleteArray_maplEintcOintgR(void *p);
2774 static void destruct_maplEintcOintgR(void *p);
2775
2776 // Function generating the singleton type initializer
2777 static TGenericClassInfo *GenerateInitInstanceLocal(const map<int,int>*)
2778 {
2779 map<int,int> *ptr = 0;
2780 static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(map<int,int>));
2781 static ::ROOT::TGenericClassInfo
2782 instance("map<int,int>", -2, "map", 96,
2783 typeid(map<int,int>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
2784 &maplEintcOintgR_Dictionary, isa_proxy, 0,
2785 sizeof(map<int,int>) );
2786 instance.SetNew(&new_maplEintcOintgR);
2787 instance.SetNewArray(&newArray_maplEintcOintgR);
2788 instance.SetDelete(&delete_maplEintcOintgR);
2789 instance.SetDeleteArray(&deleteArray_maplEintcOintgR);
2790 instance.SetDestructor(&destruct_maplEintcOintgR);
2791 instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::MapInsert< map<int,int> >()));
2792 return &instance;
2793 }
2794 // Static variable to force the class initialization
2795 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const map<int,int>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
2796
2797 // Dictionary for non-ClassDef classes
2798 static TClass *maplEintcOintgR_Dictionary() {
2799 TClass* theClass =::ROOT::GenerateInitInstanceLocal((const map<int,int>*)0x0)->GetClass();
2800 maplEintcOintgR_TClassManip(theClass);
2801 return theClass;
2802 }
2803
2804 static void maplEintcOintgR_TClassManip(TClass* ){
2805 }
2806
2807} // end of namespace ROOT
2808
2809namespace ROOT {
2810 // Wrappers around operator new
2811 static void *new_maplEintcOintgR(void *p) {
2812 return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) map<int,int> : new map<int,int>;
2813 }
2814 static void *newArray_maplEintcOintgR(Long_t nElements, void *p) {
2815 return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) map<int,int>[nElements] : new map<int,int>[nElements];
2816 }
2817 // Wrapper around operator delete
2818 static void delete_maplEintcOintgR(void *p) {
2819 delete ((map<int,int>*)p);
2820 }
2821 static void deleteArray_maplEintcOintgR(void *p) {
2822 delete [] ((map<int,int>*)p);
2823 }
2824 static void destruct_maplEintcOintgR(void *p) {
2825 typedef map<int,int> current_t;
2826 ((current_t*)p)->~current_t();
2827 }
2828} // end of namespace ROOT for class map<int,int>
2829
2830namespace {
2831 void TriggerDictionaryInitialization_BesVisLib_rootcint_Impl() {
2832 static const char* headers[] = {
2833"../BesVisLib/Bes2DView.h",
2834"../BesVisLib/BesCircle2D.h",
2835"../BesVisLib/BesCursor.h",
2836"../BesVisLib/BesEvent.h",
2837"../BesVisLib/BesEventHeader.h",
2838"../BesVisLib/BesGeometry.h",
2839"../BesVisLib/BesGeoTrack.h",
2840"../BesVisLib/BesGMenuBar.h",
2841"../BesVisLib/BesGMenuTitle.h",
2842"../BesVisLib/BesGPictureButton.h",
2843"../BesVisLib/BesHeader.h",
2844"../BesVisLib/BesMarker2D.h",
2845"../BesVisLib/BesPaveText.h",
2846"../BesVisLib/BesPolygon2D.h",
2847"../BesVisLib/BesStatus.h",
2848"../BesVisLib/BesView.h",
2849"../BesVisLib/BesVisDisplay.h",
2850"../BesVisLib/Emc2DCrystal.h",
2851"../BesVisLib/EmcROOTGeo.h",
2852"../BesVisLib/Mdc2DWire.h",
2853"../BesVisLib/BesTView.h",
2854"../BesVisLib/MdcROOTGeo.h",
2855"../BesVisLib/Muc2DStrip.h",
2856"../BesVisLib/MucROOTGeo.h",
2857"../BesVisLib/SubDetectorROOTGeo.h",
2858"../BesVisLib/Tof2DScin.h",
2859"../BesVisLib/TofROOTGeo.h",
2860"../BesVisLib/ZHelix.h",
2861"../BesVisLib/vector3.h",
2862"../BesVisLib/DstConvert.h",
28630
2864 };
2865 static const char* includePaths[] = {
2866"/cvmfs/bes3.ihep.ac.cn/bes3sw/Boss/7.1.0.a/Event/RootEventData/RootEventData-00-04-00",
2867"/cvmfs/bes3.ihep.ac.cn/bes3sw/ExternalLib/lcg/LCG_84/BesGDML/2.8.1/x86_64-centos7-gcc49-geant41007-geom-opt/include/Common/Saxana",
2868"/cvmfs/bes3.ihep.ac.cn/bes3sw/ExternalLib/lcg/LCG_84/BesGDML/2.8.1/x86_64-centos7-gcc49-geant41007-geom-opt/include/Common/Saxana/Saxana",
2869"/cvmfs/bes3.ihep.ac.cn/bes3sw/ExternalLib/lcg/LCG_84/BesGDML/2.8.1/x86_64-centos7-gcc49-geant41007-geom-opt/include/Common/Processes",
2870"/cvmfs/bes3.ihep.ac.cn/bes3sw/ExternalLib/lcg/LCG_84/BesGDML/2.8.1/x86_64-centos7-gcc49-geant41007-geom-opt/include/Common/Processes/Processes",
2871"/cvmfs/bes3.ihep.ac.cn/bes3sw/ExternalLib/lcg/LCG_84/BesGDML/2.8.1/x86_64-centos7-gcc49-geant41007-geom-opt/include/Common/Schema",
2872"/cvmfs/bes3.ihep.ac.cn/bes3sw/ExternalLib/lcg/LCG_84/BesGDML/2.8.1/x86_64-centos7-gcc49-geant41007-geom-opt/include/Common/Schema/Schema",
2873"/cvmfs/bes3.ihep.ac.cn/bes3sw/ExternalLib/lcg/LCG_84/BesGDML/2.8.1/x86_64-centos7-gcc49-geant41007-geom-opt/include/Common/Writer",
2874"/cvmfs/bes3.ihep.ac.cn/bes3sw/ExternalLib/lcg/LCG_84/BesGDML/2.8.1/x86_64-centos7-gcc49-geant41007-geom-opt/include/Common/Writer/Writer",
2875"/cvmfs/bes3.ihep.ac.cn/bes3sw/ExternalLib/lcg/LCG_84/BesGDML/2.8.1/x86_64-centos7-gcc49-geant41007-geom-opt/include/ROOTBinding/Processor",
2876"/cvmfs/bes3.ihep.ac.cn/bes3sw/ExternalLib/lcg/LCG_84/BesGDML/2.8.1/x86_64-centos7-gcc49-geant41007-geom-opt/include/ROOTBinding/Processor/Processor",
2877"/cvmfs/bes3.ihep.ac.cn/bes3sw/ExternalLib/lcg/LCG_84/BesGDML/2.8.1/x86_64-centos7-gcc49-geant41007-geom-opt/include/ROOTBinding/Subscribers",
2878"/cvmfs/bes3.ihep.ac.cn/bes3sw/ExternalLib/lcg/LCG_84/BesGDML/2.8.1/x86_64-centos7-gcc49-geant41007-geom-opt/include/ROOTBinding/Subscribers/Subscribers",
2879"/cvmfs/bes3.ihep.ac.cn/bes3sw/ExternalLib/lcg/LCG_84/BesGDML/2.8.1/x86_64-centos7-gcc49-geant41007-geom-opt/include/ROOTBinding/Evaluator",
2880"/cvmfs/bes3.ihep.ac.cn/bes3sw/ExternalLib/lcg/LCG_84/BesGDML/2.8.1/x86_64-centos7-gcc49-geant41007-geom-opt/include/ROOTBinding/Evaluator/Evaluator",
2881"/cvmfs/bes3.ihep.ac.cn/bes3sw/ExternalLib/lcg/LCG_84/clhep/2.4.4.0/x86_64-centos7-gcc49-opt/include",
2882"/cvmfs/bes3.ihep.ac.cn/bes3sw/ExternalLib/lcg/LCG_84/ROOT/6.20.02/x86_64-centos7-gcc49-opt/include/",
2883"/cvmfs/bes3.ihep.ac.cn/bes3sw/Boss/7.1.0.a/EventDisplay/BesVisLib/BesVisLib-00-06-01/BesVisLib/",
28840
2885 };
2886 static const char* fwdDeclCode = R"DICTFWDDCLS(
2887#line 1 "BesVisLib_rootcint dictionary forward declarations' payload"
2888#pragma clang diagnostic ignored "-Wkeyword-compat"
2889#pragma clang diagnostic ignored "-Wignored-attributes"
2890#pragma clang diagnostic ignored "-Wreturn-type-c-linkage"
2891extern int __Cling_Autoloading_Map;
2892class __attribute__((annotate(R"ATTRDUMP(Bes View Status)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$BesStatus.h"))) __attribute__((annotate("$clingAutoload$../BesVisLib/Bes2DView.h"))) BesStatus;
2893class __attribute__((annotate(R"ATTRDUMP(3-D View)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(3-D View)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(3-D View)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(3-D View)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$BesTView.h"))) __attribute__((annotate("$clingAutoload$../BesVisLib/Bes2DView.h"))) BesTView;
2894class __attribute__((annotate(R"ATTRDUMP(Bes View)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$../BesVisLib/Bes2DView.h"))) Bes2DView;
2895class __attribute__((annotate(R"ATTRDUMP(Circle in 2D)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$../BesVisLib/BesCircle2D.h"))) BesCircle2D;
2896class __attribute__((annotate(R"ATTRDUMP(BesCursor)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$../BesVisLib/BesCursor.h"))) BesCursor;
2897class __attribute__((annotate(R"ATTRDUMP(Bes Event Header)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$BesEventHeader.h"))) __attribute__((annotate("$clingAutoload$../BesVisLib/BesEvent.h"))) BesEventHeader;
2898class __attribute__((annotate(R"ATTRDUMP(Bes 2D marker)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$BesMarker2D.h"))) __attribute__((annotate("$clingAutoload$../BesVisLib/BesEvent.h"))) BesMarker2D;
2899class __attribute__((annotate(R"ATTRDUMP(BesPaveText)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$BesPaveText.h"))) __attribute__((annotate("$clingAutoload$../BesVisLib/BesEvent.h"))) BesPaveText;
2900class __attribute__((annotate(R"ATTRDUMP(BesGeoTrack)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$BesGeoTrack.h"))) __attribute__((annotate("$clingAutoload$../BesVisLib/BesEvent.h"))) BesGeoTrack;
2901class __attribute__((annotate(R"ATTRDUMP(BesVis Event)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$../BesVisLib/BesEvent.h"))) BesEvent;
2902class __attribute__((annotate(R"ATTRDUMP(BesVis View)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$BesView.h"))) __attribute__((annotate("$clingAutoload$../BesVisLib/BesGeometry.h"))) BesView;
2903class __attribute__((annotate("$clingAutoload$SubDetectorROOTGeo.h"))) __attribute__((annotate("$clingAutoload$../BesVisLib/BesGeometry.h"))) SubDetectorROOTGeo;
2904class __attribute__((annotate(R"ATTRDUMP(Polygon in 2D)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$BesPolygon2D.h"))) __attribute__((annotate("$clingAutoload$../BesVisLib/BesGeometry.h"))) BesPolygon2D;
2905class __attribute__((annotate(R"ATTRDUMP(Mdc 2D Wire)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$Mdc2DWire.h"))) __attribute__((annotate("$clingAutoload$../BesVisLib/BesGeometry.h"))) Mdc2DWire;
2906class __attribute__((annotate("$clingAutoload$MdcROOTGeo.h"))) __attribute__((annotate("$clingAutoload$../BesVisLib/BesGeometry.h"))) MdcROOTGeo;
2907class __attribute__((annotate(R"ATTRDUMP(Tof 2D Scin)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$Tof2DScin.h"))) __attribute__((annotate("$clingAutoload$../BesVisLib/BesGeometry.h"))) Tof2DScin;
2908class __attribute__((annotate("$clingAutoload$TofROOTGeo.h"))) __attribute__((annotate("$clingAutoload$../BesVisLib/BesGeometry.h"))) TofROOTGeo;
2909class __attribute__((annotate(R"ATTRDUMP(Emc 2D Crystal)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$Emc2DCrystal.h"))) __attribute__((annotate("$clingAutoload$../BesVisLib/BesGeometry.h"))) Emc2DCrystal;
2910class __attribute__((annotate("$clingAutoload$EmcROOTGeo.h"))) __attribute__((annotate("$clingAutoload$../BesVisLib/BesGeometry.h"))) EmcROOTGeo;
2911class __attribute__((annotate(R"ATTRDUMP(Muc 2D Strip)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$Muc2DStrip.h"))) __attribute__((annotate("$clingAutoload$../BesVisLib/BesGeometry.h"))) Muc2DStrip;
2912class __attribute__((annotate("$clingAutoload$MucROOTGeo.h"))) __attribute__((annotate("$clingAutoload$../BesVisLib/BesGeometry.h"))) MucROOTGeo;
2913class __attribute__((annotate(R"ATTRDUMP(Bes Geometry)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$../BesVisLib/BesGeometry.h"))) BesGeometry;
2914class __attribute__((annotate(R"ATTRDUMP(Menu title class)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$BesGMenuTitle.h"))) __attribute__((annotate("$clingAutoload$../BesVisLib/BesGMenuBar.h"))) BesGMenuTitle;
2915class __attribute__((annotate(R"ATTRDUMP(Menu bar class)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$../BesVisLib/BesGMenuBar.h"))) BesGMenuBar;
2916class __attribute__((annotate(R"ATTRDUMP(BesGPictureButton)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$../BesVisLib/BesGPictureButton.h"))) BesGPictureButton;
2917class __attribute__((annotate(R"ATTRDUMP(BesVis Header)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$../BesVisLib/BesHeader.h"))) BesHeader;
2918class __attribute__((annotate(R"ATTRDUMP(Utility class to display ATLAS outline, tracks, clusters, jets,..)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$../BesVisLib/BesVisDisplay.h"))) BesVisDisplay;
2919class __attribute__((annotate(R"ATTRDUMP(ZeVis Helix)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$../BesVisLib/ZHelix.h"))) ZHelix;
2920)DICTFWDDCLS";
2921 static const char* payloadCode = R"DICTPAYLOAD(
2922#line 1 "BesVisLib_rootcint dictionary payload"
2923
2924
2925#define _BACKWARD_BACKWARD_WARNING_H
2926// Inline headers
2927#include "../BesVisLib/Bes2DView.h"
2928#include "../BesVisLib/BesCircle2D.h"
2929#include "../BesVisLib/BesCursor.h"
2930#include "../BesVisLib/BesEvent.h"
2931#include "../BesVisLib/BesEventHeader.h"
2932#include "../BesVisLib/BesGeometry.h"
2933#include "../BesVisLib/BesGeoTrack.h"
2934#include "../BesVisLib/BesGMenuBar.h"
2935#include "../BesVisLib/BesGMenuTitle.h"
2936#include "../BesVisLib/BesGPictureButton.h"
2937#include "../BesVisLib/BesHeader.h"
2938#include "../BesVisLib/BesMarker2D.h"
2939#include "../BesVisLib/BesPaveText.h"
2940#include "../BesVisLib/BesPolygon2D.h"
2941#include "../BesVisLib/BesStatus.h"
2942#include "../BesVisLib/BesView.h"
2943#include "../BesVisLib/BesVisDisplay.h"
2944#include "../BesVisLib/Emc2DCrystal.h"
2945#include "../BesVisLib/EmcROOTGeo.h"
2946#include "../BesVisLib/Mdc2DWire.h"
2947#include "../BesVisLib/BesTView.h"
2948#include "../BesVisLib/MdcROOTGeo.h"
2949#include "../BesVisLib/Muc2DStrip.h"
2950#include "../BesVisLib/MucROOTGeo.h"
2951#include "../BesVisLib/SubDetectorROOTGeo.h"
2952#include "../BesVisLib/Tof2DScin.h"
2953#include "../BesVisLib/TofROOTGeo.h"
2954#include "../BesVisLib/ZHelix.h"
2955#include "../BesVisLib/vector3.h"
2956#include "../BesVisLib/DstConvert.h"
2957
2958#undef _BACKWARD_BACKWARD_WARNING_H
2959)DICTPAYLOAD";
2960 static const char* classesHeaders[] = {
2961"Bes2DView", payloadCode, "@",
2962"BesCircle2D", payloadCode, "@",
2963"BesCursor", payloadCode, "@",
2964"BesEvent", payloadCode, "@",
2965"BesEventHeader", payloadCode, "@",
2966"BesGMenuBar", payloadCode, "@",
2967"BesGMenuTitle", payloadCode, "@",
2968"BesGPictureButton", payloadCode, "@",
2969"BesGeoTrack", payloadCode, "@",
2970"BesGeometry", payloadCode, "@",
2971"BesHeader", payloadCode, "@",
2972"BesMarker2D", payloadCode, "@",
2973"BesPaveText", payloadCode, "@",
2974"BesPolygon2D", payloadCode, "@",
2975"BesStatus", payloadCode, "@",
2976"BesTView", payloadCode, "@",
2977"BesView", payloadCode, "@",
2978"BesVisDisplay", payloadCode, "@",
2979"Emc2DCrystal", payloadCode, "@",
2980"EmcROOTGeo", payloadCode, "@",
2981"Mdc2DWire", payloadCode, "@",
2982"MdcROOTGeo", payloadCode, "@",
2983"Muc2DStrip", payloadCode, "@",
2984"MucROOTGeo", payloadCode, "@",
2985"SubDetectorROOTGeo", payloadCode, "@",
2986"Tof2DScin", payloadCode, "@",
2987"TofROOTGeo", payloadCode, "@",
2988"ZHelix", payloadCode, "@",
2989nullptr
2990};
2991 static bool isInitialized = false;
2992 if (!isInitialized) {
2993 TROOT::RegisterModule("BesVisLib_rootcint",
2994 headers, includePaths, payloadCode, fwdDeclCode,
2995 TriggerDictionaryInitialization_BesVisLib_rootcint_Impl, {}, classesHeaders, /*hasCxxModule*/false);
2996 isInitialized = true;
2997 }
2998 }
2999 static struct DictInit {
3000 DictInit() {
3001 TriggerDictionaryInitialization_BesVisLib_rootcint_Impl();
3002 }
3003 } __TheDictionaryInitializer;
3004}
3005void TriggerDictionaryInitialization_BesVisLib_rootcint() {
3006 TriggerDictionaryInitialization_BesVisLib_rootcint_Impl();
3007}
TriggerDictionaryInitialization_BesVisLib_rootcint
void TriggerDictionaryInitialization_BesVisLib_rootcint()
Definition: BesVisLib/BesVisLib_rootcint.cxx:3005
ZHelix
Definition: ZHelix.h:42
ROOT::R__UseDummy
R__UseDummy(_R__UNIQUE_DICT_(Init))
ROOT::GenerateInitInstance
TGenericClassInfo * GenerateInitInstance(const ::TJobInfo *)
Definition: RootEventData/RootEventData_rootcint.cxx:125