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