00001
00002
00003
00004
00005
00006
00007 #define R__DICTIONARY_FILENAME netdInetdIsrcdIG__Net
00008 #include "RConfig.h"
00009 #if !defined(R__ACCESS_IN_SYMBOL)
00010
00011 #define private public
00012 #define protected public
00013 #endif
00014
00015
00016 namespace std {} using namespace std;
00017 #include "G__Net.h"
00018
00019 #include "TClass.h"
00020 #include "TBuffer.h"
00021 #include "TMemberInspector.h"
00022 #include "TError.h"
00023
00024 #ifndef G__ROOT
00025 #define G__ROOT
00026 #endif
00027
00028 #include "RtypesImp.h"
00029 #include "TIsAProxy.h"
00030
00031
00032
00033 namespace ROOT {
00034 namespace Shadow {
00035 }
00036 }
00037
00038
00039 namespace ROOT {
00040 void TMessage_ShowMembers(void *obj, TMemberInspector &R__insp);
00041 static void *new_TMessage(void *p = 0);
00042 static void *newArray_TMessage(Long_t size, void *p);
00043 static void delete_TMessage(void *p);
00044 static void deleteArray_TMessage(void *p);
00045 static void destruct_TMessage(void *p);
00046 static void streamer_TMessage(TBuffer &buf, void *obj);
00047
00048
00049 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMessage*)
00050 {
00051 ::TMessage *ptr = 0;
00052 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMessage >(0);
00053 static ::ROOT::TGenericClassInfo
00054 instance("TMessage", ::TMessage::Class_Version(), "include/TMessage.h", 38,
00055 typeid(::TMessage), DefineBehavior(ptr, ptr),
00056 &::TMessage::Dictionary, isa_proxy, 0,
00057 sizeof(::TMessage) );
00058 instance.SetNew(&new_TMessage);
00059 instance.SetNewArray(&newArray_TMessage);
00060 instance.SetDelete(&delete_TMessage);
00061 instance.SetDeleteArray(&deleteArray_TMessage);
00062 instance.SetDestructor(&destruct_TMessage);
00063 instance.SetStreamerFunc(&streamer_TMessage);
00064 return &instance;
00065 }
00066 TGenericClassInfo *GenerateInitInstance(const ::TMessage*)
00067 {
00068 return GenerateInitInstanceLocal((::TMessage*)0);
00069 }
00070
00071 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMessage*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00072 }
00073
00074 namespace ROOT {
00075 void TSocket_ShowMembers(void *obj, TMemberInspector &R__insp);
00076 static void delete_TSocket(void *p);
00077 static void deleteArray_TSocket(void *p);
00078 static void destruct_TSocket(void *p);
00079 static void streamer_TSocket(TBuffer &buf, void *obj);
00080
00081
00082 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TSocket*)
00083 {
00084 ::TSocket *ptr = 0;
00085 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TSocket >(0);
00086 static ::ROOT::TGenericClassInfo
00087 instance("TSocket", ::TSocket::Class_Version(), "include/TSocket.h", 76,
00088 typeid(::TSocket), DefineBehavior(ptr, ptr),
00089 &::TSocket::Dictionary, isa_proxy, 0,
00090 sizeof(::TSocket) );
00091 instance.SetDelete(&delete_TSocket);
00092 instance.SetDeleteArray(&deleteArray_TSocket);
00093 instance.SetDestructor(&destruct_TSocket);
00094 instance.SetStreamerFunc(&streamer_TSocket);
00095 return &instance;
00096 }
00097 TGenericClassInfo *GenerateInitInstance(const ::TSocket*)
00098 {
00099 return GenerateInitInstanceLocal((::TSocket*)0);
00100 }
00101
00102 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TSocket*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00103 }
00104
00105 namespace ROOT {
00106 void TPSocket_ShowMembers(void *obj, TMemberInspector &R__insp);
00107 static void delete_TPSocket(void *p);
00108 static void deleteArray_TPSocket(void *p);
00109 static void destruct_TPSocket(void *p);
00110 static void streamer_TPSocket(TBuffer &buf, void *obj);
00111
00112
00113 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TPSocket*)
00114 {
00115 ::TPSocket *ptr = 0;
00116 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TPSocket >(0);
00117 static ::ROOT::TGenericClassInfo
00118 instance("TPSocket", ::TPSocket::Class_Version(), "include/TPSocket.h", 35,
00119 typeid(::TPSocket), DefineBehavior(ptr, ptr),
00120 &::TPSocket::Dictionary, isa_proxy, 0,
00121 sizeof(::TPSocket) );
00122 instance.SetDelete(&delete_TPSocket);
00123 instance.SetDeleteArray(&deleteArray_TPSocket);
00124 instance.SetDestructor(&destruct_TPSocket);
00125 instance.SetStreamerFunc(&streamer_TPSocket);
00126 return &instance;
00127 }
00128 TGenericClassInfo *GenerateInitInstance(const ::TPSocket*)
00129 {
00130 return GenerateInitInstanceLocal((::TPSocket*)0);
00131 }
00132
00133 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TPSocket*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00134 }
00135
00136 namespace ROOT {
00137 void TMonitor_ShowMembers(void *obj, TMemberInspector &R__insp);
00138 static void *new_TMonitor(void *p = 0);
00139 static void *newArray_TMonitor(Long_t size, void *p);
00140 static void delete_TMonitor(void *p);
00141 static void deleteArray_TMonitor(void *p);
00142 static void destruct_TMonitor(void *p);
00143 static void streamer_TMonitor(TBuffer &buf, void *obj);
00144
00145
00146 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMonitor*)
00147 {
00148 ::TMonitor *ptr = 0;
00149 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMonitor >(0);
00150 static ::ROOT::TGenericClassInfo
00151 instance("TMonitor", ::TMonitor::Class_Version(), "include/TMonitor.h", 40,
00152 typeid(::TMonitor), DefineBehavior(ptr, ptr),
00153 &::TMonitor::Dictionary, isa_proxy, 0,
00154 sizeof(::TMonitor) );
00155 instance.SetNew(&new_TMonitor);
00156 instance.SetNewArray(&newArray_TMonitor);
00157 instance.SetDelete(&delete_TMonitor);
00158 instance.SetDeleteArray(&deleteArray_TMonitor);
00159 instance.SetDestructor(&destruct_TMonitor);
00160 instance.SetStreamerFunc(&streamer_TMonitor);
00161 return &instance;
00162 }
00163 TGenericClassInfo *GenerateInitInstance(const ::TMonitor*)
00164 {
00165 return GenerateInitInstanceLocal((::TMonitor*)0);
00166 }
00167
00168 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMonitor*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00169 }
00170
00171 namespace ROOT {
00172 void TApplicationRemote_ShowMembers(void *obj, TMemberInspector &R__insp);
00173 static void delete_TApplicationRemote(void *p);
00174 static void deleteArray_TApplicationRemote(void *p);
00175 static void destruct_TApplicationRemote(void *p);
00176 static void streamer_TApplicationRemote(TBuffer &buf, void *obj);
00177
00178
00179 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TApplicationRemote*)
00180 {
00181 ::TApplicationRemote *ptr = 0;
00182 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TApplicationRemote >(0);
00183 static ::ROOT::TGenericClassInfo
00184 instance("TApplicationRemote", ::TApplicationRemote::Class_Version(), "include/TApplicationRemote.h", 56,
00185 typeid(::TApplicationRemote), DefineBehavior(ptr, ptr),
00186 &::TApplicationRemote::Dictionary, isa_proxy, 0,
00187 sizeof(::TApplicationRemote) );
00188 instance.SetDelete(&delete_TApplicationRemote);
00189 instance.SetDeleteArray(&deleteArray_TApplicationRemote);
00190 instance.SetDestructor(&destruct_TApplicationRemote);
00191 instance.SetStreamerFunc(&streamer_TApplicationRemote);
00192 return &instance;
00193 }
00194 TGenericClassInfo *GenerateInitInstance(const ::TApplicationRemote*)
00195 {
00196 return GenerateInitInstanceLocal((::TApplicationRemote*)0);
00197 }
00198
00199 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TApplicationRemote*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00200 }
00201
00202 namespace ROOT {
00203 void TApplicationServer_ShowMembers(void *obj, TMemberInspector &R__insp);
00204 static void delete_TApplicationServer(void *p);
00205 static void deleteArray_TApplicationServer(void *p);
00206 static void destruct_TApplicationServer(void *p);
00207 static void streamer_TApplicationServer(TBuffer &buf, void *obj);
00208
00209
00210 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TApplicationServer*)
00211 {
00212 ::TApplicationServer *ptr = 0;
00213 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TApplicationServer >(0);
00214 static ::ROOT::TGenericClassInfo
00215 instance("TApplicationServer", ::TApplicationServer::Class_Version(), "include/TApplicationServer.h", 42,
00216 typeid(::TApplicationServer), DefineBehavior(ptr, ptr),
00217 &::TApplicationServer::Dictionary, isa_proxy, 0,
00218 sizeof(::TApplicationServer) );
00219 instance.SetDelete(&delete_TApplicationServer);
00220 instance.SetDeleteArray(&deleteArray_TApplicationServer);
00221 instance.SetDestructor(&destruct_TApplicationServer);
00222 instance.SetStreamerFunc(&streamer_TApplicationServer);
00223 return &instance;
00224 }
00225 TGenericClassInfo *GenerateInitInstance(const ::TApplicationServer*)
00226 {
00227 return GenerateInitInstanceLocal((::TApplicationServer*)0);
00228 }
00229
00230 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TApplicationServer*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00231 }
00232
00233 namespace ROOT {
00234 void TFileStager_ShowMembers(void *obj, TMemberInspector &R__insp);
00235 static void delete_TFileStager(void *p);
00236 static void deleteArray_TFileStager(void *p);
00237 static void destruct_TFileStager(void *p);
00238 static void streamer_TFileStager(TBuffer &buf, void *obj);
00239
00240
00241 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TFileStager*)
00242 {
00243 ::TFileStager *ptr = 0;
00244 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TFileStager >(0);
00245 static ::ROOT::TGenericClassInfo
00246 instance("TFileStager", ::TFileStager::Class_Version(), "include/TFileStager.h", 39,
00247 typeid(::TFileStager), DefineBehavior(ptr, ptr),
00248 &::TFileStager::Dictionary, isa_proxy, 0,
00249 sizeof(::TFileStager) );
00250 instance.SetDelete(&delete_TFileStager);
00251 instance.SetDeleteArray(&deleteArray_TFileStager);
00252 instance.SetDestructor(&destruct_TFileStager);
00253 instance.SetStreamerFunc(&streamer_TFileStager);
00254 return &instance;
00255 }
00256 TGenericClassInfo *GenerateInitInstance(const ::TFileStager*)
00257 {
00258 return GenerateInitInstanceLocal((::TFileStager*)0);
00259 }
00260
00261 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TFileStager*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00262 }
00263
00264 namespace ROOT {
00265 void TServerSocket_ShowMembers(void *obj, TMemberInspector &R__insp);
00266 static void delete_TServerSocket(void *p);
00267 static void deleteArray_TServerSocket(void *p);
00268 static void destruct_TServerSocket(void *p);
00269 static void streamer_TServerSocket(TBuffer &buf, void *obj);
00270
00271
00272 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TServerSocket*)
00273 {
00274 ::TServerSocket *ptr = 0;
00275 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TServerSocket >(0);
00276 static ::ROOT::TGenericClassInfo
00277 instance("TServerSocket", ::TServerSocket::Class_Version(), "include/TServerSocket.h", 44,
00278 typeid(::TServerSocket), DefineBehavior(ptr, ptr),
00279 &::TServerSocket::Dictionary, isa_proxy, 0,
00280 sizeof(::TServerSocket) );
00281 instance.SetDelete(&delete_TServerSocket);
00282 instance.SetDeleteArray(&deleteArray_TServerSocket);
00283 instance.SetDestructor(&destruct_TServerSocket);
00284 instance.SetStreamerFunc(&streamer_TServerSocket);
00285 return &instance;
00286 }
00287 TGenericClassInfo *GenerateInitInstance(const ::TServerSocket*)
00288 {
00289 return GenerateInitInstanceLocal((::TServerSocket*)0);
00290 }
00291
00292 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TServerSocket*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00293 }
00294
00295 namespace ROOT {
00296 void TFTP_ShowMembers(void *obj, TMemberInspector &R__insp);
00297 static void delete_TFTP(void *p);
00298 static void deleteArray_TFTP(void *p);
00299 static void destruct_TFTP(void *p);
00300 static void streamer_TFTP(TBuffer &buf, void *obj);
00301
00302
00303 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TFTP*)
00304 {
00305 ::TFTP *ptr = 0;
00306 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TFTP >(0);
00307 static ::ROOT::TGenericClassInfo
00308 instance("TFTP", ::TFTP::Class_Version(), "include/TFTP.h", 42,
00309 typeid(::TFTP), DefineBehavior(ptr, ptr),
00310 &::TFTP::Dictionary, isa_proxy, 0,
00311 sizeof(::TFTP) );
00312 instance.SetDelete(&delete_TFTP);
00313 instance.SetDeleteArray(&deleteArray_TFTP);
00314 instance.SetDestructor(&destruct_TFTP);
00315 instance.SetStreamerFunc(&streamer_TFTP);
00316 return &instance;
00317 }
00318 TGenericClassInfo *GenerateInitInstance(const ::TFTP*)
00319 {
00320 return GenerateInitInstanceLocal((::TFTP*)0);
00321 }
00322
00323 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TFTP*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00324 }
00325
00326 namespace ROOT {
00327 void TGridResult_ShowMembers(void *obj, TMemberInspector &R__insp);
00328 static void *new_TGridResult(void *p = 0);
00329 static void *newArray_TGridResult(Long_t size, void *p);
00330 static void delete_TGridResult(void *p);
00331 static void deleteArray_TGridResult(void *p);
00332 static void destruct_TGridResult(void *p);
00333
00334
00335 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGridResult*)
00336 {
00337 ::TGridResult *ptr = 0;
00338 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGridResult >(0);
00339 static ::ROOT::TGenericClassInfo
00340 instance("TGridResult", ::TGridResult::Class_Version(), "include/TGridResult.h", 33,
00341 typeid(::TGridResult), DefineBehavior(ptr, ptr),
00342 &::TGridResult::Dictionary, isa_proxy, 4,
00343 sizeof(::TGridResult) );
00344 instance.SetNew(&new_TGridResult);
00345 instance.SetNewArray(&newArray_TGridResult);
00346 instance.SetDelete(&delete_TGridResult);
00347 instance.SetDeleteArray(&deleteArray_TGridResult);
00348 instance.SetDestructor(&destruct_TGridResult);
00349 return &instance;
00350 }
00351 TGenericClassInfo *GenerateInitInstance(const ::TGridResult*)
00352 {
00353 return GenerateInitInstanceLocal((::TGridResult*)0);
00354 }
00355
00356 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGridResult*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00357 }
00358
00359 namespace ROOT {
00360 void TGridCollection_ShowMembers(void *obj, TMemberInspector &R__insp);
00361 static void *new_TGridCollection(void *p = 0);
00362 static void *newArray_TGridCollection(Long_t size, void *p);
00363 static void delete_TGridCollection(void *p);
00364 static void deleteArray_TGridCollection(void *p);
00365 static void destruct_TGridCollection(void *p);
00366
00367
00368 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGridCollection*)
00369 {
00370 ::TGridCollection *ptr = 0;
00371 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGridCollection >(0);
00372 static ::ROOT::TGenericClassInfo
00373 instance("TGridCollection", ::TGridCollection::Class_Version(), "include/TGridCollection.h", 36,
00374 typeid(::TGridCollection), DefineBehavior(ptr, ptr),
00375 &::TGridCollection::Dictionary, isa_proxy, 4,
00376 sizeof(::TGridCollection) );
00377 instance.SetNew(&new_TGridCollection);
00378 instance.SetNewArray(&newArray_TGridCollection);
00379 instance.SetDelete(&delete_TGridCollection);
00380 instance.SetDeleteArray(&deleteArray_TGridCollection);
00381 instance.SetDestructor(&destruct_TGridCollection);
00382 return &instance;
00383 }
00384 TGenericClassInfo *GenerateInitInstance(const ::TGridCollection*)
00385 {
00386 return GenerateInitInstanceLocal((::TGridCollection*)0);
00387 }
00388
00389 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGridCollection*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00390 }
00391
00392 namespace ROOT {
00393 void TGridJobStatus_ShowMembers(void *obj, TMemberInspector &R__insp);
00394 static void delete_TGridJobStatus(void *p);
00395 static void deleteArray_TGridJobStatus(void *p);
00396 static void destruct_TGridJobStatus(void *p);
00397
00398
00399 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGridJobStatus*)
00400 {
00401 ::TGridJobStatus *ptr = 0;
00402 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGridJobStatus >(0);
00403 static ::ROOT::TGenericClassInfo
00404 instance("TGridJobStatus", ::TGridJobStatus::Class_Version(), "include/TGridJobStatus.h", 28,
00405 typeid(::TGridJobStatus), DefineBehavior(ptr, ptr),
00406 &::TGridJobStatus::Dictionary, isa_proxy, 4,
00407 sizeof(::TGridJobStatus) );
00408 instance.SetDelete(&delete_TGridJobStatus);
00409 instance.SetDeleteArray(&deleteArray_TGridJobStatus);
00410 instance.SetDestructor(&destruct_TGridJobStatus);
00411 return &instance;
00412 }
00413 TGenericClassInfo *GenerateInitInstance(const ::TGridJobStatus*)
00414 {
00415 return GenerateInitInstanceLocal((::TGridJobStatus*)0);
00416 }
00417
00418 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGridJobStatus*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00419 }
00420
00421 namespace ROOT {
00422 void TGridJob_ShowMembers(void *obj, TMemberInspector &R__insp);
00423 static void delete_TGridJob(void *p);
00424 static void deleteArray_TGridJob(void *p);
00425 static void destruct_TGridJob(void *p);
00426
00427
00428 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGridJob*)
00429 {
00430 ::TGridJob *ptr = 0;
00431 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGridJob >(0);
00432 static ::ROOT::TGenericClassInfo
00433 instance("TGridJob", ::TGridJob::Class_Version(), "include/TGridJob.h", 35,
00434 typeid(::TGridJob), DefineBehavior(ptr, ptr),
00435 &::TGridJob::Dictionary, isa_proxy, 4,
00436 sizeof(::TGridJob) );
00437 instance.SetDelete(&delete_TGridJob);
00438 instance.SetDeleteArray(&deleteArray_TGridJob);
00439 instance.SetDestructor(&destruct_TGridJob);
00440 return &instance;
00441 }
00442 TGenericClassInfo *GenerateInitInstance(const ::TGridJob*)
00443 {
00444 return GenerateInitInstanceLocal((::TGridJob*)0);
00445 }
00446
00447 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGridJob*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00448 }
00449
00450 namespace ROOT {
00451 void TGridJDL_ShowMembers(void *obj, TMemberInspector &R__insp);
00452 static void delete_TGridJDL(void *p);
00453 static void deleteArray_TGridJDL(void *p);
00454 static void destruct_TGridJDL(void *p);
00455
00456
00457 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGridJDL*)
00458 {
00459 ::TGridJDL *ptr = 0;
00460 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGridJDL >(0);
00461 static ::ROOT::TGenericClassInfo
00462 instance("TGridJDL", ::TGridJDL::Class_Version(), "include/TGridJDL.h", 38,
00463 typeid(::TGridJDL), DefineBehavior(ptr, ptr),
00464 &::TGridJDL::Dictionary, isa_proxy, 4,
00465 sizeof(::TGridJDL) );
00466 instance.SetDelete(&delete_TGridJDL);
00467 instance.SetDeleteArray(&deleteArray_TGridJDL);
00468 instance.SetDestructor(&destruct_TGridJDL);
00469 return &instance;
00470 }
00471 TGenericClassInfo *GenerateInitInstance(const ::TGridJDL*)
00472 {
00473 return GenerateInitInstanceLocal((::TGridJDL*)0);
00474 }
00475
00476 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGridJDL*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00477 }
00478
00479 namespace ROOT {
00480 void TGridJobStatusList_ShowMembers(void *obj, TMemberInspector &R__insp);
00481 static void *new_TGridJobStatusList(void *p = 0);
00482 static void *newArray_TGridJobStatusList(Long_t size, void *p);
00483 static void delete_TGridJobStatusList(void *p);
00484 static void deleteArray_TGridJobStatusList(void *p);
00485 static void destruct_TGridJobStatusList(void *p);
00486
00487
00488 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGridJobStatusList*)
00489 {
00490 ::TGridJobStatusList *ptr = 0;
00491 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGridJobStatusList >(0);
00492 static ::ROOT::TGenericClassInfo
00493 instance("TGridJobStatusList", ::TGridJobStatusList::Class_Version(), "include/TGridJobStatusList.h", 34,
00494 typeid(::TGridJobStatusList), DefineBehavior(ptr, ptr),
00495 &::TGridJobStatusList::Dictionary, isa_proxy, 4,
00496 sizeof(::TGridJobStatusList) );
00497 instance.SetNew(&new_TGridJobStatusList);
00498 instance.SetNewArray(&newArray_TGridJobStatusList);
00499 instance.SetDelete(&delete_TGridJobStatusList);
00500 instance.SetDeleteArray(&deleteArray_TGridJobStatusList);
00501 instance.SetDestructor(&destruct_TGridJobStatusList);
00502 return &instance;
00503 }
00504 TGenericClassInfo *GenerateInitInstance(const ::TGridJobStatusList*)
00505 {
00506 return GenerateInitInstanceLocal((::TGridJobStatusList*)0);
00507 }
00508
00509 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGridJobStatusList*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00510 }
00511
00512 namespace ROOT {
00513 void TGrid_ShowMembers(void *obj, TMemberInspector &R__insp);
00514 static void *new_TGrid(void *p = 0);
00515 static void *newArray_TGrid(Long_t size, void *p);
00516 static void delete_TGrid(void *p);
00517 static void deleteArray_TGrid(void *p);
00518 static void destruct_TGrid(void *p);
00519 static void streamer_TGrid(TBuffer &buf, void *obj);
00520
00521
00522 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGrid*)
00523 {
00524 ::TGrid *ptr = 0;
00525 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGrid >(0);
00526 static ::ROOT::TGenericClassInfo
00527 instance("TGrid", ::TGrid::Class_Version(), "include/TGrid.h", 51,
00528 typeid(::TGrid), DefineBehavior(ptr, ptr),
00529 &::TGrid::Dictionary, isa_proxy, 0,
00530 sizeof(::TGrid) );
00531 instance.SetNew(&new_TGrid);
00532 instance.SetNewArray(&newArray_TGrid);
00533 instance.SetDelete(&delete_TGrid);
00534 instance.SetDeleteArray(&deleteArray_TGrid);
00535 instance.SetDestructor(&destruct_TGrid);
00536 instance.SetStreamerFunc(&streamer_TGrid);
00537 return &instance;
00538 }
00539 TGenericClassInfo *GenerateInitInstance(const ::TGrid*)
00540 {
00541 return GenerateInitInstanceLocal((::TGrid*)0);
00542 }
00543
00544 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGrid*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00545 }
00546
00547 namespace ROOT {
00548 void TNetFile_ShowMembers(void *obj, TMemberInspector &R__insp);
00549 static void *new_TNetFile(void *p = 0);
00550 static void *newArray_TNetFile(Long_t size, void *p);
00551 static void delete_TNetFile(void *p);
00552 static void deleteArray_TNetFile(void *p);
00553 static void destruct_TNetFile(void *p);
00554 static void streamer_TNetFile(TBuffer &buf, void *obj);
00555
00556
00557 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TNetFile*)
00558 {
00559 ::TNetFile *ptr = 0;
00560 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TNetFile >(0);
00561 static ::ROOT::TGenericClassInfo
00562 instance("TNetFile", ::TNetFile::Class_Version(), "include/TNetFile.h", 44,
00563 typeid(::TNetFile), DefineBehavior(ptr, ptr),
00564 &::TNetFile::Dictionary, isa_proxy, 0,
00565 sizeof(::TNetFile) );
00566 instance.SetNew(&new_TNetFile);
00567 instance.SetNewArray(&newArray_TNetFile);
00568 instance.SetDelete(&delete_TNetFile);
00569 instance.SetDeleteArray(&deleteArray_TNetFile);
00570 instance.SetDestructor(&destruct_TNetFile);
00571 instance.SetStreamerFunc(&streamer_TNetFile);
00572 return &instance;
00573 }
00574 TGenericClassInfo *GenerateInitInstance(const ::TNetFile*)
00575 {
00576 return GenerateInitInstanceLocal((::TNetFile*)0);
00577 }
00578
00579 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TNetFile*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00580 }
00581
00582 namespace ROOT {
00583 void TNetSystem_ShowMembers(void *obj, TMemberInspector &R__insp);
00584 static void *new_TNetSystem(void *p = 0);
00585 static void *newArray_TNetSystem(Long_t size, void *p);
00586 static void delete_TNetSystem(void *p);
00587 static void deleteArray_TNetSystem(void *p);
00588 static void destruct_TNetSystem(void *p);
00589 static void streamer_TNetSystem(TBuffer &buf, void *obj);
00590
00591
00592 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TNetSystem*)
00593 {
00594 ::TNetSystem *ptr = 0;
00595 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TNetSystem >(0);
00596 static ::ROOT::TGenericClassInfo
00597 instance("TNetSystem", ::TNetSystem::Class_Version(), "include/TNetFile.h", 95,
00598 typeid(::TNetSystem), DefineBehavior(ptr, ptr),
00599 &::TNetSystem::Dictionary, isa_proxy, 0,
00600 sizeof(::TNetSystem) );
00601 instance.SetNew(&new_TNetSystem);
00602 instance.SetNewArray(&newArray_TNetSystem);
00603 instance.SetDelete(&delete_TNetSystem);
00604 instance.SetDeleteArray(&deleteArray_TNetSystem);
00605 instance.SetDestructor(&destruct_TNetSystem);
00606 instance.SetStreamerFunc(&streamer_TNetSystem);
00607 return &instance;
00608 }
00609 TGenericClassInfo *GenerateInitInstance(const ::TNetSystem*)
00610 {
00611 return GenerateInitInstanceLocal((::TNetSystem*)0);
00612 }
00613
00614 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TNetSystem*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00615 }
00616
00617 namespace ROOT {
00618 void TSecContext_ShowMembers(void *obj, TMemberInspector &R__insp);
00619 static void delete_TSecContext(void *p);
00620 static void deleteArray_TSecContext(void *p);
00621 static void destruct_TSecContext(void *p);
00622 static void streamer_TSecContext(TBuffer &buf, void *obj);
00623
00624
00625 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TSecContext*)
00626 {
00627 ::TSecContext *ptr = 0;
00628 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TSecContext >(0);
00629 static ::ROOT::TGenericClassInfo
00630 instance("TSecContext", ::TSecContext::Class_Version(), "include/TSecContext.h", 42,
00631 typeid(::TSecContext), DefineBehavior(ptr, ptr),
00632 &::TSecContext::Dictionary, isa_proxy, 0,
00633 sizeof(::TSecContext) );
00634 instance.SetDelete(&delete_TSecContext);
00635 instance.SetDeleteArray(&deleteArray_TSecContext);
00636 instance.SetDestructor(&destruct_TSecContext);
00637 instance.SetStreamerFunc(&streamer_TSecContext);
00638 return &instance;
00639 }
00640 TGenericClassInfo *GenerateInitInstance(const ::TSecContext*)
00641 {
00642 return GenerateInitInstanceLocal((::TSecContext*)0);
00643 }
00644
00645 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TSecContext*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00646 }
00647
00648 namespace ROOT {
00649 void TSecContextCleanup_ShowMembers(void *obj, TMemberInspector &R__insp);
00650 static void delete_TSecContextCleanup(void *p);
00651 static void deleteArray_TSecContextCleanup(void *p);
00652 static void destruct_TSecContextCleanup(void *p);
00653 static void streamer_TSecContextCleanup(TBuffer &buf, void *obj);
00654
00655
00656 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TSecContextCleanup*)
00657 {
00658 ::TSecContextCleanup *ptr = 0;
00659 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TSecContextCleanup >(0);
00660 static ::ROOT::TGenericClassInfo
00661 instance("TSecContextCleanup", ::TSecContextCleanup::Class_Version(), "include/TSecContext.h", 115,
00662 typeid(::TSecContextCleanup), DefineBehavior(ptr, ptr),
00663 &::TSecContextCleanup::Dictionary, isa_proxy, 0,
00664 sizeof(::TSecContextCleanup) );
00665 instance.SetDelete(&delete_TSecContextCleanup);
00666 instance.SetDeleteArray(&deleteArray_TSecContextCleanup);
00667 instance.SetDestructor(&destruct_TSecContextCleanup);
00668 instance.SetStreamerFunc(&streamer_TSecContextCleanup);
00669 return &instance;
00670 }
00671 TGenericClassInfo *GenerateInitInstance(const ::TSecContextCleanup*)
00672 {
00673 return GenerateInitInstanceLocal((::TSecContextCleanup*)0);
00674 }
00675
00676 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TSecContextCleanup*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00677 }
00678
00679 namespace ROOT {
00680 void TPServerSocket_ShowMembers(void *obj, TMemberInspector &R__insp);
00681 static void delete_TPServerSocket(void *p);
00682 static void deleteArray_TPServerSocket(void *p);
00683 static void destruct_TPServerSocket(void *p);
00684 static void streamer_TPServerSocket(TBuffer &buf, void *obj);
00685
00686
00687 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TPServerSocket*)
00688 {
00689 ::TPServerSocket *ptr = 0;
00690 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TPServerSocket >(0);
00691 static ::ROOT::TGenericClassInfo
00692 instance("TPServerSocket", ::TPServerSocket::Class_Version(), "include/TPServerSocket.h", 35,
00693 typeid(::TPServerSocket), DefineBehavior(ptr, ptr),
00694 &::TPServerSocket::Dictionary, isa_proxy, 0,
00695 sizeof(::TPServerSocket) );
00696 instance.SetDelete(&delete_TPServerSocket);
00697 instance.SetDeleteArray(&deleteArray_TPServerSocket);
00698 instance.SetDestructor(&destruct_TPServerSocket);
00699 instance.SetStreamerFunc(&streamer_TPServerSocket);
00700 return &instance;
00701 }
00702 TGenericClassInfo *GenerateInitInstance(const ::TPServerSocket*)
00703 {
00704 return GenerateInitInstanceLocal((::TPServerSocket*)0);
00705 }
00706
00707 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TPServerSocket*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00708 }
00709
00710 namespace ROOT {
00711 void TSQLColumnInfo_ShowMembers(void *obj, TMemberInspector &R__insp);
00712 static void *new_TSQLColumnInfo(void *p = 0);
00713 static void *newArray_TSQLColumnInfo(Long_t size, void *p);
00714 static void delete_TSQLColumnInfo(void *p);
00715 static void deleteArray_TSQLColumnInfo(void *p);
00716 static void destruct_TSQLColumnInfo(void *p);
00717 static void streamer_TSQLColumnInfo(TBuffer &buf, void *obj);
00718
00719
00720 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TSQLColumnInfo*)
00721 {
00722 ::TSQLColumnInfo *ptr = 0;
00723 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TSQLColumnInfo >(0);
00724 static ::ROOT::TGenericClassInfo
00725 instance("TSQLColumnInfo", ::TSQLColumnInfo::Class_Version(), "include/TSQLColumnInfo.h", 19,
00726 typeid(::TSQLColumnInfo), DefineBehavior(ptr, ptr),
00727 &::TSQLColumnInfo::Dictionary, isa_proxy, 0,
00728 sizeof(::TSQLColumnInfo) );
00729 instance.SetNew(&new_TSQLColumnInfo);
00730 instance.SetNewArray(&newArray_TSQLColumnInfo);
00731 instance.SetDelete(&delete_TSQLColumnInfo);
00732 instance.SetDeleteArray(&deleteArray_TSQLColumnInfo);
00733 instance.SetDestructor(&destruct_TSQLColumnInfo);
00734 instance.SetStreamerFunc(&streamer_TSQLColumnInfo);
00735 return &instance;
00736 }
00737 TGenericClassInfo *GenerateInitInstance(const ::TSQLColumnInfo*)
00738 {
00739 return GenerateInitInstanceLocal((::TSQLColumnInfo*)0);
00740 }
00741
00742 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TSQLColumnInfo*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00743 }
00744
00745 namespace ROOT {
00746 void TSQLServer_ShowMembers(void *obj, TMemberInspector &R__insp);
00747 static void delete_TSQLServer(void *p);
00748 static void deleteArray_TSQLServer(void *p);
00749 static void destruct_TSQLServer(void *p);
00750 static void streamer_TSQLServer(TBuffer &buf, void *obj);
00751
00752
00753 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TSQLServer*)
00754 {
00755 ::TSQLServer *ptr = 0;
00756 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TSQLServer >(0);
00757 static ::ROOT::TGenericClassInfo
00758 instance("TSQLServer", ::TSQLServer::Class_Version(), "include/TSQLServer.h", 45,
00759 typeid(::TSQLServer), DefineBehavior(ptr, ptr),
00760 &::TSQLServer::Dictionary, isa_proxy, 0,
00761 sizeof(::TSQLServer) );
00762 instance.SetDelete(&delete_TSQLServer);
00763 instance.SetDeleteArray(&deleteArray_TSQLServer);
00764 instance.SetDestructor(&destruct_TSQLServer);
00765 instance.SetStreamerFunc(&streamer_TSQLServer);
00766 return &instance;
00767 }
00768 TGenericClassInfo *GenerateInitInstance(const ::TSQLServer*)
00769 {
00770 return GenerateInitInstanceLocal((::TSQLServer*)0);
00771 }
00772
00773 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TSQLServer*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00774 }
00775
00776 namespace ROOT {
00777 void TSQLMonitoringWriter_ShowMembers(void *obj, TMemberInspector &R__insp);
00778 static void delete_TSQLMonitoringWriter(void *p);
00779 static void deleteArray_TSQLMonitoringWriter(void *p);
00780 static void destruct_TSQLMonitoringWriter(void *p);
00781 static void streamer_TSQLMonitoringWriter(TBuffer &buf, void *obj);
00782
00783
00784 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TSQLMonitoringWriter*)
00785 {
00786 ::TSQLMonitoringWriter *ptr = 0;
00787 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TSQLMonitoringWriter >(0);
00788 static ::ROOT::TGenericClassInfo
00789 instance("TSQLMonitoringWriter", ::TSQLMonitoringWriter::Class_Version(), "include/TSQLMonitoring.h", 34,
00790 typeid(::TSQLMonitoringWriter), DefineBehavior(ptr, ptr),
00791 &::TSQLMonitoringWriter::Dictionary, isa_proxy, 0,
00792 sizeof(::TSQLMonitoringWriter) );
00793 instance.SetDelete(&delete_TSQLMonitoringWriter);
00794 instance.SetDeleteArray(&deleteArray_TSQLMonitoringWriter);
00795 instance.SetDestructor(&destruct_TSQLMonitoringWriter);
00796 instance.SetStreamerFunc(&streamer_TSQLMonitoringWriter);
00797 return &instance;
00798 }
00799 TGenericClassInfo *GenerateInitInstance(const ::TSQLMonitoringWriter*)
00800 {
00801 return GenerateInitInstanceLocal((::TSQLMonitoringWriter*)0);
00802 }
00803
00804 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TSQLMonitoringWriter*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00805 }
00806
00807 namespace ROOT {
00808 void TSQLRow_ShowMembers(void *obj, TMemberInspector &R__insp);
00809 static void delete_TSQLRow(void *p);
00810 static void deleteArray_TSQLRow(void *p);
00811 static void destruct_TSQLRow(void *p);
00812 static void streamer_TSQLRow(TBuffer &buf, void *obj);
00813
00814
00815 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TSQLRow*)
00816 {
00817 ::TSQLRow *ptr = 0;
00818 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TSQLRow >(0);
00819 static ::ROOT::TGenericClassInfo
00820 instance("TSQLRow", ::TSQLRow::Class_Version(), "include/TSQLRow.h", 32,
00821 typeid(::TSQLRow), DefineBehavior(ptr, ptr),
00822 &::TSQLRow::Dictionary, isa_proxy, 0,
00823 sizeof(::TSQLRow) );
00824 instance.SetDelete(&delete_TSQLRow);
00825 instance.SetDeleteArray(&deleteArray_TSQLRow);
00826 instance.SetDestructor(&destruct_TSQLRow);
00827 instance.SetStreamerFunc(&streamer_TSQLRow);
00828 return &instance;
00829 }
00830 TGenericClassInfo *GenerateInitInstance(const ::TSQLRow*)
00831 {
00832 return GenerateInitInstanceLocal((::TSQLRow*)0);
00833 }
00834
00835 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TSQLRow*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00836 }
00837
00838 namespace ROOT {
00839 void TSQLResult_ShowMembers(void *obj, TMemberInspector &R__insp);
00840 static void delete_TSQLResult(void *p);
00841 static void deleteArray_TSQLResult(void *p);
00842 static void destruct_TSQLResult(void *p);
00843 static void streamer_TSQLResult(TBuffer &buf, void *obj);
00844
00845
00846 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TSQLResult*)
00847 {
00848 ::TSQLResult *ptr = 0;
00849 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TSQLResult >(0);
00850 static ::ROOT::TGenericClassInfo
00851 instance("TSQLResult", ::TSQLResult::Class_Version(), "include/TSQLResult.h", 34,
00852 typeid(::TSQLResult), DefineBehavior(ptr, ptr),
00853 &::TSQLResult::Dictionary, isa_proxy, 0,
00854 sizeof(::TSQLResult) );
00855 instance.SetDelete(&delete_TSQLResult);
00856 instance.SetDeleteArray(&deleteArray_TSQLResult);
00857 instance.SetDestructor(&destruct_TSQLResult);
00858 instance.SetStreamerFunc(&streamer_TSQLResult);
00859 return &instance;
00860 }
00861 TGenericClassInfo *GenerateInitInstance(const ::TSQLResult*)
00862 {
00863 return GenerateInitInstanceLocal((::TSQLResult*)0);
00864 }
00865
00866 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TSQLResult*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00867 }
00868
00869 namespace ROOT {
00870 void TSQLStatement_ShowMembers(void *obj, TMemberInspector &R__insp);
00871 static void delete_TSQLStatement(void *p);
00872 static void deleteArray_TSQLStatement(void *p);
00873 static void destruct_TSQLStatement(void *p);
00874 static void streamer_TSQLStatement(TBuffer &buf, void *obj);
00875
00876
00877 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TSQLStatement*)
00878 {
00879 ::TSQLStatement *ptr = 0;
00880 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TSQLStatement >(0);
00881 static ::ROOT::TGenericClassInfo
00882 instance("TSQLStatement", ::TSQLStatement::Class_Version(), "include/TSQLStatement.h", 26,
00883 typeid(::TSQLStatement), DefineBehavior(ptr, ptr),
00884 &::TSQLStatement::Dictionary, isa_proxy, 0,
00885 sizeof(::TSQLStatement) );
00886 instance.SetDelete(&delete_TSQLStatement);
00887 instance.SetDeleteArray(&deleteArray_TSQLStatement);
00888 instance.SetDestructor(&destruct_TSQLStatement);
00889 instance.SetStreamerFunc(&streamer_TSQLStatement);
00890 return &instance;
00891 }
00892 TGenericClassInfo *GenerateInitInstance(const ::TSQLStatement*)
00893 {
00894 return GenerateInitInstanceLocal((::TSQLStatement*)0);
00895 }
00896
00897 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TSQLStatement*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00898 }
00899
00900 namespace ROOT {
00901 void TSQLTableInfo_ShowMembers(void *obj, TMemberInspector &R__insp);
00902 static void *new_TSQLTableInfo(void *p = 0);
00903 static void *newArray_TSQLTableInfo(Long_t size, void *p);
00904 static void delete_TSQLTableInfo(void *p);
00905 static void deleteArray_TSQLTableInfo(void *p);
00906 static void destruct_TSQLTableInfo(void *p);
00907 static void streamer_TSQLTableInfo(TBuffer &buf, void *obj);
00908
00909
00910 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TSQLTableInfo*)
00911 {
00912 ::TSQLTableInfo *ptr = 0;
00913 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TSQLTableInfo >(0);
00914 static ::ROOT::TGenericClassInfo
00915 instance("TSQLTableInfo", ::TSQLTableInfo::Class_Version(), "include/TSQLTableInfo.h", 22,
00916 typeid(::TSQLTableInfo), DefineBehavior(ptr, ptr),
00917 &::TSQLTableInfo::Dictionary, isa_proxy, 0,
00918 sizeof(::TSQLTableInfo) );
00919 instance.SetNew(&new_TSQLTableInfo);
00920 instance.SetNewArray(&newArray_TSQLTableInfo);
00921 instance.SetDelete(&delete_TSQLTableInfo);
00922 instance.SetDeleteArray(&deleteArray_TSQLTableInfo);
00923 instance.SetDestructor(&destruct_TSQLTableInfo);
00924 instance.SetStreamerFunc(&streamer_TSQLTableInfo);
00925 return &instance;
00926 }
00927 TGenericClassInfo *GenerateInitInstance(const ::TSQLTableInfo*)
00928 {
00929 return GenerateInitInstanceLocal((::TSQLTableInfo*)0);
00930 }
00931
00932 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TSQLTableInfo*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00933 }
00934
00935 namespace ROOT {
00936 void TWebFile_ShowMembers(void *obj, TMemberInspector &R__insp);
00937 static void delete_TWebFile(void *p);
00938 static void deleteArray_TWebFile(void *p);
00939 static void destruct_TWebFile(void *p);
00940 static void streamer_TWebFile(TBuffer &buf, void *obj);
00941
00942
00943 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TWebFile*)
00944 {
00945 ::TWebFile *ptr = 0;
00946 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TWebFile >(0);
00947 static ::ROOT::TGenericClassInfo
00948 instance("TWebFile", ::TWebFile::Class_Version(), "include/TWebFile.h", 39,
00949 typeid(::TWebFile), DefineBehavior(ptr, ptr),
00950 &::TWebFile::Dictionary, isa_proxy, 0,
00951 sizeof(::TWebFile) );
00952 instance.SetDelete(&delete_TWebFile);
00953 instance.SetDeleteArray(&deleteArray_TWebFile);
00954 instance.SetDestructor(&destruct_TWebFile);
00955 instance.SetStreamerFunc(&streamer_TWebFile);
00956 return &instance;
00957 }
00958 TGenericClassInfo *GenerateInitInstance(const ::TWebFile*)
00959 {
00960 return GenerateInitInstanceLocal((::TWebFile*)0);
00961 }
00962
00963 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TWebFile*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00964 }
00965
00966 namespace ROOT {
00967 void TWebSystem_ShowMembers(void *obj, TMemberInspector &R__insp);
00968 static void *new_TWebSystem(void *p = 0);
00969 static void *newArray_TWebSystem(Long_t size, void *p);
00970 static void delete_TWebSystem(void *p);
00971 static void deleteArray_TWebSystem(void *p);
00972 static void destruct_TWebSystem(void *p);
00973 static void streamer_TWebSystem(TBuffer &buf, void *obj);
00974
00975
00976 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TWebSystem*)
00977 {
00978 ::TWebSystem *ptr = 0;
00979 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TWebSystem >(0);
00980 static ::ROOT::TGenericClassInfo
00981 instance("TWebSystem", ::TWebSystem::Class_Version(), "include/TWebFile.h", 94,
00982 typeid(::TWebSystem), DefineBehavior(ptr, ptr),
00983 &::TWebSystem::Dictionary, isa_proxy, 0,
00984 sizeof(::TWebSystem) );
00985 instance.SetNew(&new_TWebSystem);
00986 instance.SetNewArray(&newArray_TWebSystem);
00987 instance.SetDelete(&delete_TWebSystem);
00988 instance.SetDeleteArray(&deleteArray_TWebSystem);
00989 instance.SetDestructor(&destruct_TWebSystem);
00990 instance.SetStreamerFunc(&streamer_TWebSystem);
00991 return &instance;
00992 }
00993 TGenericClassInfo *GenerateInitInstance(const ::TWebSystem*)
00994 {
00995 return GenerateInitInstanceLocal((::TWebSystem*)0);
00996 }
00997
00998 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TWebSystem*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00999 }
01000
01001
01002 TClass *TMessage::fgIsA = 0;
01003
01004
01005 const char *TMessage::Class_Name()
01006 {
01007 return "TMessage";
01008 }
01009
01010
01011 const char *TMessage::ImplFileName()
01012 {
01013 return ::ROOT::GenerateInitInstanceLocal((const ::TMessage*)0x0)->GetImplFileName();
01014 }
01015
01016
01017 int TMessage::ImplFileLine()
01018 {
01019 return ::ROOT::GenerateInitInstanceLocal((const ::TMessage*)0x0)->GetImplFileLine();
01020 }
01021
01022
01023 void TMessage::Dictionary()
01024 {
01025 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMessage*)0x0)->GetClass();
01026 }
01027
01028
01029 TClass *TMessage::Class()
01030 {
01031 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMessage*)0x0)->GetClass();
01032 return fgIsA;
01033 }
01034
01035
01036 TClass *TSocket::fgIsA = 0;
01037
01038
01039 const char *TSocket::Class_Name()
01040 {
01041 return "TSocket";
01042 }
01043
01044
01045 const char *TSocket::ImplFileName()
01046 {
01047 return ::ROOT::GenerateInitInstanceLocal((const ::TSocket*)0x0)->GetImplFileName();
01048 }
01049
01050
01051 int TSocket::ImplFileLine()
01052 {
01053 return ::ROOT::GenerateInitInstanceLocal((const ::TSocket*)0x0)->GetImplFileLine();
01054 }
01055
01056
01057 void TSocket::Dictionary()
01058 {
01059 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TSocket*)0x0)->GetClass();
01060 }
01061
01062
01063 TClass *TSocket::Class()
01064 {
01065 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TSocket*)0x0)->GetClass();
01066 return fgIsA;
01067 }
01068
01069
01070 TClass *TPSocket::fgIsA = 0;
01071
01072
01073 const char *TPSocket::Class_Name()
01074 {
01075 return "TPSocket";
01076 }
01077
01078
01079 const char *TPSocket::ImplFileName()
01080 {
01081 return ::ROOT::GenerateInitInstanceLocal((const ::TPSocket*)0x0)->GetImplFileName();
01082 }
01083
01084
01085 int TPSocket::ImplFileLine()
01086 {
01087 return ::ROOT::GenerateInitInstanceLocal((const ::TPSocket*)0x0)->GetImplFileLine();
01088 }
01089
01090
01091 void TPSocket::Dictionary()
01092 {
01093 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TPSocket*)0x0)->GetClass();
01094 }
01095
01096
01097 TClass *TPSocket::Class()
01098 {
01099 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TPSocket*)0x0)->GetClass();
01100 return fgIsA;
01101 }
01102
01103
01104 TClass *TMonitor::fgIsA = 0;
01105
01106
01107 const char *TMonitor::Class_Name()
01108 {
01109 return "TMonitor";
01110 }
01111
01112
01113 const char *TMonitor::ImplFileName()
01114 {
01115 return ::ROOT::GenerateInitInstanceLocal((const ::TMonitor*)0x0)->GetImplFileName();
01116 }
01117
01118
01119 int TMonitor::ImplFileLine()
01120 {
01121 return ::ROOT::GenerateInitInstanceLocal((const ::TMonitor*)0x0)->GetImplFileLine();
01122 }
01123
01124
01125 void TMonitor::Dictionary()
01126 {
01127 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMonitor*)0x0)->GetClass();
01128 }
01129
01130
01131 TClass *TMonitor::Class()
01132 {
01133 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMonitor*)0x0)->GetClass();
01134 return fgIsA;
01135 }
01136
01137
01138 TClass *TApplicationRemote::fgIsA = 0;
01139
01140
01141 const char *TApplicationRemote::Class_Name()
01142 {
01143 return "TApplicationRemote";
01144 }
01145
01146
01147 const char *TApplicationRemote::ImplFileName()
01148 {
01149 return ::ROOT::GenerateInitInstanceLocal((const ::TApplicationRemote*)0x0)->GetImplFileName();
01150 }
01151
01152
01153 int TApplicationRemote::ImplFileLine()
01154 {
01155 return ::ROOT::GenerateInitInstanceLocal((const ::TApplicationRemote*)0x0)->GetImplFileLine();
01156 }
01157
01158
01159 void TApplicationRemote::Dictionary()
01160 {
01161 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TApplicationRemote*)0x0)->GetClass();
01162 }
01163
01164
01165 TClass *TApplicationRemote::Class()
01166 {
01167 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TApplicationRemote*)0x0)->GetClass();
01168 return fgIsA;
01169 }
01170
01171
01172 TClass *TApplicationServer::fgIsA = 0;
01173
01174
01175 const char *TApplicationServer::Class_Name()
01176 {
01177 return "TApplicationServer";
01178 }
01179
01180
01181 const char *TApplicationServer::ImplFileName()
01182 {
01183 return ::ROOT::GenerateInitInstanceLocal((const ::TApplicationServer*)0x0)->GetImplFileName();
01184 }
01185
01186
01187 int TApplicationServer::ImplFileLine()
01188 {
01189 return ::ROOT::GenerateInitInstanceLocal((const ::TApplicationServer*)0x0)->GetImplFileLine();
01190 }
01191
01192
01193 void TApplicationServer::Dictionary()
01194 {
01195 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TApplicationServer*)0x0)->GetClass();
01196 }
01197
01198
01199 TClass *TApplicationServer::Class()
01200 {
01201 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TApplicationServer*)0x0)->GetClass();
01202 return fgIsA;
01203 }
01204
01205
01206 TClass *TFileStager::fgIsA = 0;
01207
01208
01209 const char *TFileStager::Class_Name()
01210 {
01211 return "TFileStager";
01212 }
01213
01214
01215 const char *TFileStager::ImplFileName()
01216 {
01217 return ::ROOT::GenerateInitInstanceLocal((const ::TFileStager*)0x0)->GetImplFileName();
01218 }
01219
01220
01221 int TFileStager::ImplFileLine()
01222 {
01223 return ::ROOT::GenerateInitInstanceLocal((const ::TFileStager*)0x0)->GetImplFileLine();
01224 }
01225
01226
01227 void TFileStager::Dictionary()
01228 {
01229 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TFileStager*)0x0)->GetClass();
01230 }
01231
01232
01233 TClass *TFileStager::Class()
01234 {
01235 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TFileStager*)0x0)->GetClass();
01236 return fgIsA;
01237 }
01238
01239
01240 TClass *TServerSocket::fgIsA = 0;
01241
01242
01243 const char *TServerSocket::Class_Name()
01244 {
01245 return "TServerSocket";
01246 }
01247
01248
01249 const char *TServerSocket::ImplFileName()
01250 {
01251 return ::ROOT::GenerateInitInstanceLocal((const ::TServerSocket*)0x0)->GetImplFileName();
01252 }
01253
01254
01255 int TServerSocket::ImplFileLine()
01256 {
01257 return ::ROOT::GenerateInitInstanceLocal((const ::TServerSocket*)0x0)->GetImplFileLine();
01258 }
01259
01260
01261 void TServerSocket::Dictionary()
01262 {
01263 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TServerSocket*)0x0)->GetClass();
01264 }
01265
01266
01267 TClass *TServerSocket::Class()
01268 {
01269 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TServerSocket*)0x0)->GetClass();
01270 return fgIsA;
01271 }
01272
01273
01274 TClass *TFTP::fgIsA = 0;
01275
01276
01277 const char *TFTP::Class_Name()
01278 {
01279 return "TFTP";
01280 }
01281
01282
01283 const char *TFTP::ImplFileName()
01284 {
01285 return ::ROOT::GenerateInitInstanceLocal((const ::TFTP*)0x0)->GetImplFileName();
01286 }
01287
01288
01289 int TFTP::ImplFileLine()
01290 {
01291 return ::ROOT::GenerateInitInstanceLocal((const ::TFTP*)0x0)->GetImplFileLine();
01292 }
01293
01294
01295 void TFTP::Dictionary()
01296 {
01297 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TFTP*)0x0)->GetClass();
01298 }
01299
01300
01301 TClass *TFTP::Class()
01302 {
01303 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TFTP*)0x0)->GetClass();
01304 return fgIsA;
01305 }
01306
01307
01308 TClass *TGridResult::fgIsA = 0;
01309
01310
01311 const char *TGridResult::Class_Name()
01312 {
01313 return "TGridResult";
01314 }
01315
01316
01317 const char *TGridResult::ImplFileName()
01318 {
01319 return ::ROOT::GenerateInitInstanceLocal((const ::TGridResult*)0x0)->GetImplFileName();
01320 }
01321
01322
01323 int TGridResult::ImplFileLine()
01324 {
01325 return ::ROOT::GenerateInitInstanceLocal((const ::TGridResult*)0x0)->GetImplFileLine();
01326 }
01327
01328
01329 void TGridResult::Dictionary()
01330 {
01331 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGridResult*)0x0)->GetClass();
01332 }
01333
01334
01335 TClass *TGridResult::Class()
01336 {
01337 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGridResult*)0x0)->GetClass();
01338 return fgIsA;
01339 }
01340
01341
01342 TClass *TGridCollection::fgIsA = 0;
01343
01344
01345 const char *TGridCollection::Class_Name()
01346 {
01347 return "TGridCollection";
01348 }
01349
01350
01351 const char *TGridCollection::ImplFileName()
01352 {
01353 return ::ROOT::GenerateInitInstanceLocal((const ::TGridCollection*)0x0)->GetImplFileName();
01354 }
01355
01356
01357 int TGridCollection::ImplFileLine()
01358 {
01359 return ::ROOT::GenerateInitInstanceLocal((const ::TGridCollection*)0x0)->GetImplFileLine();
01360 }
01361
01362
01363 void TGridCollection::Dictionary()
01364 {
01365 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGridCollection*)0x0)->GetClass();
01366 }
01367
01368
01369 TClass *TGridCollection::Class()
01370 {
01371 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGridCollection*)0x0)->GetClass();
01372 return fgIsA;
01373 }
01374
01375
01376 TClass *TGridJobStatus::fgIsA = 0;
01377
01378
01379 const char *TGridJobStatus::Class_Name()
01380 {
01381 return "TGridJobStatus";
01382 }
01383
01384
01385 const char *TGridJobStatus::ImplFileName()
01386 {
01387 return ::ROOT::GenerateInitInstanceLocal((const ::TGridJobStatus*)0x0)->GetImplFileName();
01388 }
01389
01390
01391 int TGridJobStatus::ImplFileLine()
01392 {
01393 return ::ROOT::GenerateInitInstanceLocal((const ::TGridJobStatus*)0x0)->GetImplFileLine();
01394 }
01395
01396
01397 void TGridJobStatus::Dictionary()
01398 {
01399 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGridJobStatus*)0x0)->GetClass();
01400 }
01401
01402
01403 TClass *TGridJobStatus::Class()
01404 {
01405 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGridJobStatus*)0x0)->GetClass();
01406 return fgIsA;
01407 }
01408
01409
01410 TClass *TGridJob::fgIsA = 0;
01411
01412
01413 const char *TGridJob::Class_Name()
01414 {
01415 return "TGridJob";
01416 }
01417
01418
01419 const char *TGridJob::ImplFileName()
01420 {
01421 return ::ROOT::GenerateInitInstanceLocal((const ::TGridJob*)0x0)->GetImplFileName();
01422 }
01423
01424
01425 int TGridJob::ImplFileLine()
01426 {
01427 return ::ROOT::GenerateInitInstanceLocal((const ::TGridJob*)0x0)->GetImplFileLine();
01428 }
01429
01430
01431 void TGridJob::Dictionary()
01432 {
01433 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGridJob*)0x0)->GetClass();
01434 }
01435
01436
01437 TClass *TGridJob::Class()
01438 {
01439 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGridJob*)0x0)->GetClass();
01440 return fgIsA;
01441 }
01442
01443
01444 TClass *TGridJDL::fgIsA = 0;
01445
01446
01447 const char *TGridJDL::Class_Name()
01448 {
01449 return "TGridJDL";
01450 }
01451
01452
01453 const char *TGridJDL::ImplFileName()
01454 {
01455 return ::ROOT::GenerateInitInstanceLocal((const ::TGridJDL*)0x0)->GetImplFileName();
01456 }
01457
01458
01459 int TGridJDL::ImplFileLine()
01460 {
01461 return ::ROOT::GenerateInitInstanceLocal((const ::TGridJDL*)0x0)->GetImplFileLine();
01462 }
01463
01464
01465 void TGridJDL::Dictionary()
01466 {
01467 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGridJDL*)0x0)->GetClass();
01468 }
01469
01470
01471 TClass *TGridJDL::Class()
01472 {
01473 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGridJDL*)0x0)->GetClass();
01474 return fgIsA;
01475 }
01476
01477
01478 TClass *TGridJobStatusList::fgIsA = 0;
01479
01480
01481 const char *TGridJobStatusList::Class_Name()
01482 {
01483 return "TGridJobStatusList";
01484 }
01485
01486
01487 const char *TGridJobStatusList::ImplFileName()
01488 {
01489 return ::ROOT::GenerateInitInstanceLocal((const ::TGridJobStatusList*)0x0)->GetImplFileName();
01490 }
01491
01492
01493 int TGridJobStatusList::ImplFileLine()
01494 {
01495 return ::ROOT::GenerateInitInstanceLocal((const ::TGridJobStatusList*)0x0)->GetImplFileLine();
01496 }
01497
01498
01499 void TGridJobStatusList::Dictionary()
01500 {
01501 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGridJobStatusList*)0x0)->GetClass();
01502 }
01503
01504
01505 TClass *TGridJobStatusList::Class()
01506 {
01507 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGridJobStatusList*)0x0)->GetClass();
01508 return fgIsA;
01509 }
01510
01511
01512 TClass *TGrid::fgIsA = 0;
01513
01514
01515 const char *TGrid::Class_Name()
01516 {
01517 return "TGrid";
01518 }
01519
01520
01521 const char *TGrid::ImplFileName()
01522 {
01523 return ::ROOT::GenerateInitInstanceLocal((const ::TGrid*)0x0)->GetImplFileName();
01524 }
01525
01526
01527 int TGrid::ImplFileLine()
01528 {
01529 return ::ROOT::GenerateInitInstanceLocal((const ::TGrid*)0x0)->GetImplFileLine();
01530 }
01531
01532
01533 void TGrid::Dictionary()
01534 {
01535 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGrid*)0x0)->GetClass();
01536 }
01537
01538
01539 TClass *TGrid::Class()
01540 {
01541 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGrid*)0x0)->GetClass();
01542 return fgIsA;
01543 }
01544
01545
01546 TClass *TNetFile::fgIsA = 0;
01547
01548
01549 const char *TNetFile::Class_Name()
01550 {
01551 return "TNetFile";
01552 }
01553
01554
01555 const char *TNetFile::ImplFileName()
01556 {
01557 return ::ROOT::GenerateInitInstanceLocal((const ::TNetFile*)0x0)->GetImplFileName();
01558 }
01559
01560
01561 int TNetFile::ImplFileLine()
01562 {
01563 return ::ROOT::GenerateInitInstanceLocal((const ::TNetFile*)0x0)->GetImplFileLine();
01564 }
01565
01566
01567 void TNetFile::Dictionary()
01568 {
01569 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TNetFile*)0x0)->GetClass();
01570 }
01571
01572
01573 TClass *TNetFile::Class()
01574 {
01575 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TNetFile*)0x0)->GetClass();
01576 return fgIsA;
01577 }
01578
01579
01580 TClass *TNetSystem::fgIsA = 0;
01581
01582
01583 const char *TNetSystem::Class_Name()
01584 {
01585 return "TNetSystem";
01586 }
01587
01588
01589 const char *TNetSystem::ImplFileName()
01590 {
01591 return ::ROOT::GenerateInitInstanceLocal((const ::TNetSystem*)0x0)->GetImplFileName();
01592 }
01593
01594
01595 int TNetSystem::ImplFileLine()
01596 {
01597 return ::ROOT::GenerateInitInstanceLocal((const ::TNetSystem*)0x0)->GetImplFileLine();
01598 }
01599
01600
01601 void TNetSystem::Dictionary()
01602 {
01603 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TNetSystem*)0x0)->GetClass();
01604 }
01605
01606
01607 TClass *TNetSystem::Class()
01608 {
01609 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TNetSystem*)0x0)->GetClass();
01610 return fgIsA;
01611 }
01612
01613
01614 TClass *TSecContext::fgIsA = 0;
01615
01616
01617 const char *TSecContext::Class_Name()
01618 {
01619 return "TSecContext";
01620 }
01621
01622
01623 const char *TSecContext::ImplFileName()
01624 {
01625 return ::ROOT::GenerateInitInstanceLocal((const ::TSecContext*)0x0)->GetImplFileName();
01626 }
01627
01628
01629 int TSecContext::ImplFileLine()
01630 {
01631 return ::ROOT::GenerateInitInstanceLocal((const ::TSecContext*)0x0)->GetImplFileLine();
01632 }
01633
01634
01635 void TSecContext::Dictionary()
01636 {
01637 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TSecContext*)0x0)->GetClass();
01638 }
01639
01640
01641 TClass *TSecContext::Class()
01642 {
01643 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TSecContext*)0x0)->GetClass();
01644 return fgIsA;
01645 }
01646
01647
01648 TClass *TSecContextCleanup::fgIsA = 0;
01649
01650
01651 const char *TSecContextCleanup::Class_Name()
01652 {
01653 return "TSecContextCleanup";
01654 }
01655
01656
01657 const char *TSecContextCleanup::ImplFileName()
01658 {
01659 return ::ROOT::GenerateInitInstanceLocal((const ::TSecContextCleanup*)0x0)->GetImplFileName();
01660 }
01661
01662
01663 int TSecContextCleanup::ImplFileLine()
01664 {
01665 return ::ROOT::GenerateInitInstanceLocal((const ::TSecContextCleanup*)0x0)->GetImplFileLine();
01666 }
01667
01668
01669 void TSecContextCleanup::Dictionary()
01670 {
01671 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TSecContextCleanup*)0x0)->GetClass();
01672 }
01673
01674
01675 TClass *TSecContextCleanup::Class()
01676 {
01677 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TSecContextCleanup*)0x0)->GetClass();
01678 return fgIsA;
01679 }
01680
01681
01682 TClass *TPServerSocket::fgIsA = 0;
01683
01684
01685 const char *TPServerSocket::Class_Name()
01686 {
01687 return "TPServerSocket";
01688 }
01689
01690
01691 const char *TPServerSocket::ImplFileName()
01692 {
01693 return ::ROOT::GenerateInitInstanceLocal((const ::TPServerSocket*)0x0)->GetImplFileName();
01694 }
01695
01696
01697 int TPServerSocket::ImplFileLine()
01698 {
01699 return ::ROOT::GenerateInitInstanceLocal((const ::TPServerSocket*)0x0)->GetImplFileLine();
01700 }
01701
01702
01703 void TPServerSocket::Dictionary()
01704 {
01705 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TPServerSocket*)0x0)->GetClass();
01706 }
01707
01708
01709 TClass *TPServerSocket::Class()
01710 {
01711 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TPServerSocket*)0x0)->GetClass();
01712 return fgIsA;
01713 }
01714
01715
01716 TClass *TSQLColumnInfo::fgIsA = 0;
01717
01718
01719 const char *TSQLColumnInfo::Class_Name()
01720 {
01721 return "TSQLColumnInfo";
01722 }
01723
01724
01725 const char *TSQLColumnInfo::ImplFileName()
01726 {
01727 return ::ROOT::GenerateInitInstanceLocal((const ::TSQLColumnInfo*)0x0)->GetImplFileName();
01728 }
01729
01730
01731 int TSQLColumnInfo::ImplFileLine()
01732 {
01733 return ::ROOT::GenerateInitInstanceLocal((const ::TSQLColumnInfo*)0x0)->GetImplFileLine();
01734 }
01735
01736
01737 void TSQLColumnInfo::Dictionary()
01738 {
01739 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TSQLColumnInfo*)0x0)->GetClass();
01740 }
01741
01742
01743 TClass *TSQLColumnInfo::Class()
01744 {
01745 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TSQLColumnInfo*)0x0)->GetClass();
01746 return fgIsA;
01747 }
01748
01749
01750 TClass *TSQLServer::fgIsA = 0;
01751
01752
01753 const char *TSQLServer::Class_Name()
01754 {
01755 return "TSQLServer";
01756 }
01757
01758
01759 const char *TSQLServer::ImplFileName()
01760 {
01761 return ::ROOT::GenerateInitInstanceLocal((const ::TSQLServer*)0x0)->GetImplFileName();
01762 }
01763
01764
01765 int TSQLServer::ImplFileLine()
01766 {
01767 return ::ROOT::GenerateInitInstanceLocal((const ::TSQLServer*)0x0)->GetImplFileLine();
01768 }
01769
01770
01771 void TSQLServer::Dictionary()
01772 {
01773 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TSQLServer*)0x0)->GetClass();
01774 }
01775
01776
01777 TClass *TSQLServer::Class()
01778 {
01779 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TSQLServer*)0x0)->GetClass();
01780 return fgIsA;
01781 }
01782
01783
01784 TClass *TSQLMonitoringWriter::fgIsA = 0;
01785
01786
01787 const char *TSQLMonitoringWriter::Class_Name()
01788 {
01789 return "TSQLMonitoringWriter";
01790 }
01791
01792
01793 const char *TSQLMonitoringWriter::ImplFileName()
01794 {
01795 return ::ROOT::GenerateInitInstanceLocal((const ::TSQLMonitoringWriter*)0x0)->GetImplFileName();
01796 }
01797
01798
01799 int TSQLMonitoringWriter::ImplFileLine()
01800 {
01801 return ::ROOT::GenerateInitInstanceLocal((const ::TSQLMonitoringWriter*)0x0)->GetImplFileLine();
01802 }
01803
01804
01805 void TSQLMonitoringWriter::Dictionary()
01806 {
01807 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TSQLMonitoringWriter*)0x0)->GetClass();
01808 }
01809
01810
01811 TClass *TSQLMonitoringWriter::Class()
01812 {
01813 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TSQLMonitoringWriter*)0x0)->GetClass();
01814 return fgIsA;
01815 }
01816
01817
01818 TClass *TSQLRow::fgIsA = 0;
01819
01820
01821 const char *TSQLRow::Class_Name()
01822 {
01823 return "TSQLRow";
01824 }
01825
01826
01827 const char *TSQLRow::ImplFileName()
01828 {
01829 return ::ROOT::GenerateInitInstanceLocal((const ::TSQLRow*)0x0)->GetImplFileName();
01830 }
01831
01832
01833 int TSQLRow::ImplFileLine()
01834 {
01835 return ::ROOT::GenerateInitInstanceLocal((const ::TSQLRow*)0x0)->GetImplFileLine();
01836 }
01837
01838
01839 void TSQLRow::Dictionary()
01840 {
01841 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TSQLRow*)0x0)->GetClass();
01842 }
01843
01844
01845 TClass *TSQLRow::Class()
01846 {
01847 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TSQLRow*)0x0)->GetClass();
01848 return fgIsA;
01849 }
01850
01851
01852 TClass *TSQLResult::fgIsA = 0;
01853
01854
01855 const char *TSQLResult::Class_Name()
01856 {
01857 return "TSQLResult";
01858 }
01859
01860
01861 const char *TSQLResult::ImplFileName()
01862 {
01863 return ::ROOT::GenerateInitInstanceLocal((const ::TSQLResult*)0x0)->GetImplFileName();
01864 }
01865
01866
01867 int TSQLResult::ImplFileLine()
01868 {
01869 return ::ROOT::GenerateInitInstanceLocal((const ::TSQLResult*)0x0)->GetImplFileLine();
01870 }
01871
01872
01873 void TSQLResult::Dictionary()
01874 {
01875 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TSQLResult*)0x0)->GetClass();
01876 }
01877
01878
01879 TClass *TSQLResult::Class()
01880 {
01881 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TSQLResult*)0x0)->GetClass();
01882 return fgIsA;
01883 }
01884
01885
01886 TClass *TSQLStatement::fgIsA = 0;
01887
01888
01889 const char *TSQLStatement::Class_Name()
01890 {
01891 return "TSQLStatement";
01892 }
01893
01894
01895 const char *TSQLStatement::ImplFileName()
01896 {
01897 return ::ROOT::GenerateInitInstanceLocal((const ::TSQLStatement*)0x0)->GetImplFileName();
01898 }
01899
01900
01901 int TSQLStatement::ImplFileLine()
01902 {
01903 return ::ROOT::GenerateInitInstanceLocal((const ::TSQLStatement*)0x0)->GetImplFileLine();
01904 }
01905
01906
01907 void TSQLStatement::Dictionary()
01908 {
01909 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TSQLStatement*)0x0)->GetClass();
01910 }
01911
01912
01913 TClass *TSQLStatement::Class()
01914 {
01915 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TSQLStatement*)0x0)->GetClass();
01916 return fgIsA;
01917 }
01918
01919
01920 TClass *TSQLTableInfo::fgIsA = 0;
01921
01922
01923 const char *TSQLTableInfo::Class_Name()
01924 {
01925 return "TSQLTableInfo";
01926 }
01927
01928
01929 const char *TSQLTableInfo::ImplFileName()
01930 {
01931 return ::ROOT::GenerateInitInstanceLocal((const ::TSQLTableInfo*)0x0)->GetImplFileName();
01932 }
01933
01934
01935 int TSQLTableInfo::ImplFileLine()
01936 {
01937 return ::ROOT::GenerateInitInstanceLocal((const ::TSQLTableInfo*)0x0)->GetImplFileLine();
01938 }
01939
01940
01941 void TSQLTableInfo::Dictionary()
01942 {
01943 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TSQLTableInfo*)0x0)->GetClass();
01944 }
01945
01946
01947 TClass *TSQLTableInfo::Class()
01948 {
01949 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TSQLTableInfo*)0x0)->GetClass();
01950 return fgIsA;
01951 }
01952
01953
01954 TClass *TWebFile::fgIsA = 0;
01955
01956
01957 const char *TWebFile::Class_Name()
01958 {
01959 return "TWebFile";
01960 }
01961
01962
01963 const char *TWebFile::ImplFileName()
01964 {
01965 return ::ROOT::GenerateInitInstanceLocal((const ::TWebFile*)0x0)->GetImplFileName();
01966 }
01967
01968
01969 int TWebFile::ImplFileLine()
01970 {
01971 return ::ROOT::GenerateInitInstanceLocal((const ::TWebFile*)0x0)->GetImplFileLine();
01972 }
01973
01974
01975 void TWebFile::Dictionary()
01976 {
01977 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TWebFile*)0x0)->GetClass();
01978 }
01979
01980
01981 TClass *TWebFile::Class()
01982 {
01983 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TWebFile*)0x0)->GetClass();
01984 return fgIsA;
01985 }
01986
01987
01988 TClass *TWebSystem::fgIsA = 0;
01989
01990
01991 const char *TWebSystem::Class_Name()
01992 {
01993 return "TWebSystem";
01994 }
01995
01996
01997 const char *TWebSystem::ImplFileName()
01998 {
01999 return ::ROOT::GenerateInitInstanceLocal((const ::TWebSystem*)0x0)->GetImplFileName();
02000 }
02001
02002
02003 int TWebSystem::ImplFileLine()
02004 {
02005 return ::ROOT::GenerateInitInstanceLocal((const ::TWebSystem*)0x0)->GetImplFileLine();
02006 }
02007
02008
02009 void TWebSystem::Dictionary()
02010 {
02011 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TWebSystem*)0x0)->GetClass();
02012 }
02013
02014
02015 TClass *TWebSystem::Class()
02016 {
02017 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TWebSystem*)0x0)->GetClass();
02018 return fgIsA;
02019 }
02020
02021
02022 void TServerSocket::Streamer(TBuffer &R__b)
02023 {
02024
02025
02026 UInt_t R__s, R__c;
02027 if (R__b.IsReading()) {
02028 Version_t R__v = R__b.ReadVersion(&R__s, &R__c); if (R__v) { }
02029 TSocket::Streamer(R__b);
02030 R__b >> fSecContexts;
02031 R__b.CheckByteCount(R__s, R__c, TServerSocket::IsA());
02032 } else {
02033 R__c = R__b.WriteVersion(TServerSocket::IsA(), kTRUE);
02034 TSocket::Streamer(R__b);
02035 R__b << fSecContexts;
02036 R__b.SetByteCount(R__c, kTRUE);
02037 }
02038 }
02039
02040
02041 void TServerSocket::ShowMembers(TMemberInspector &R__insp)
02042 {
02043
02044 TClass *R__cl = ::TServerSocket::IsA();
02045 if (R__cl || R__insp.IsA()) { }
02046 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSecContexts", &fSecContexts);
02047 TSocket::ShowMembers(R__insp);
02048 }
02049
02050 namespace ROOT {
02051
02052 static void delete_TServerSocket(void *p) {
02053 delete ((::TServerSocket*)p);
02054 }
02055 static void deleteArray_TServerSocket(void *p) {
02056 delete [] ((::TServerSocket*)p);
02057 }
02058 static void destruct_TServerSocket(void *p) {
02059 typedef ::TServerSocket current_t;
02060 ((current_t*)p)->~current_t();
02061 }
02062
02063 static void streamer_TServerSocket(TBuffer &buf, void *obj) {
02064 ((::TServerSocket*)obj)->::TServerSocket::Streamer(buf);
02065 }
02066 }
02067
02068
02069 void TSocket::Streamer(TBuffer &R__b)
02070 {
02071
02072
02073 TNamed::Streamer(R__b);
02074 }
02075
02076
02077 void TSocket::ShowMembers(TMemberInspector &R__insp)
02078 {
02079
02080 TClass *R__cl = ::TSocket::IsA();
02081 if (R__cl || R__insp.IsA()) { }
02082 R__insp.Inspect(R__cl, R__insp.GetParent(), "fAddress", &fAddress);
02083 R__insp.InspectMember(fAddress, "fAddress.");
02084 R__insp.Inspect(R__cl, R__insp.GetParent(), "fBytesRecv", &fBytesRecv);
02085 R__insp.Inspect(R__cl, R__insp.GetParent(), "fBytesSent", &fBytesSent);
02086 R__insp.Inspect(R__cl, R__insp.GetParent(), "fCompress", &fCompress);
02087 R__insp.Inspect(R__cl, R__insp.GetParent(), "fLocalAddress", &fLocalAddress);
02088 R__insp.InspectMember(fLocalAddress, "fLocalAddress.");
02089 R__insp.Inspect(R__cl, R__insp.GetParent(), "fRemoteProtocol", &fRemoteProtocol);
02090 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSecContext", &fSecContext);
02091 R__insp.Inspect(R__cl, R__insp.GetParent(), "fService", &fService);
02092 R__insp.InspectMember(fService, "fService.");
02093 R__insp.Inspect(R__cl, R__insp.GetParent(), "fServType", &fServType);
02094 R__insp.Inspect(R__cl, R__insp.GetParent(), "fSocket", &fSocket);
02095 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTcpWindowSize", &fTcpWindowSize);
02096 R__insp.Inspect(R__cl, R__insp.GetParent(), "fUrl", &fUrl);
02097 R__insp.InspectMember(fUrl, "fUrl.");
02098 R__insp.Inspect(R__cl, R__insp.GetParent(), "fBitsInfo", &fBitsInfo);
02099 R__insp.InspectMember(fBitsInfo, "fBitsInfo.");
02100 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fUUIDs", &fUUIDs);
02101 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLastUsageMtx", &fLastUsageMtx);
02102 R__insp.Inspect(R__cl, R__insp.GetParent(), "fLastUsage", &fLastUsage);
02103 R__insp.InspectMember(fLastUsage, "fLastUsage.");
02104 TNamed::ShowMembers(R__insp);
02105 }
02106
02107 namespace ROOT {
02108
02109 static void delete_TSocket(void *p) {
02110 delete ((::TSocket*)p);
02111 }
02112 static void deleteArray_TSocket(void *p) {
02113 delete [] ((::TSocket*)p);
02114 }
02115 static void destruct_TSocket(void *p) {
02116 typedef ::TSocket current_t;
02117 ((current_t*)p)->~current_t();
02118 }
02119
02120 static void streamer_TSocket(TBuffer &buf, void *obj) {
02121 ((::TSocket*)obj)->::TSocket::Streamer(buf);
02122 }
02123 }
02124
02125
02126 void TPServerSocket::Streamer(TBuffer &R__b)
02127 {
02128
02129
02130 TServerSocket::Streamer(R__b);
02131 }
02132
02133
02134 void TPServerSocket::ShowMembers(TMemberInspector &R__insp)
02135 {
02136
02137 TClass *R__cl = ::TPServerSocket::IsA();
02138 if (R__cl || R__insp.IsA()) { }
02139 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTcpWindowSize", &fTcpWindowSize);
02140 TServerSocket::ShowMembers(R__insp);
02141 }
02142
02143 namespace ROOT {
02144
02145 static void delete_TPServerSocket(void *p) {
02146 delete ((::TPServerSocket*)p);
02147 }
02148 static void deleteArray_TPServerSocket(void *p) {
02149 delete [] ((::TPServerSocket*)p);
02150 }
02151 static void destruct_TPServerSocket(void *p) {
02152 typedef ::TPServerSocket current_t;
02153 ((current_t*)p)->~current_t();
02154 }
02155
02156 static void streamer_TPServerSocket(TBuffer &buf, void *obj) {
02157 ((::TPServerSocket*)obj)->::TPServerSocket::Streamer(buf);
02158 }
02159 }
02160
02161
02162 void TPSocket::Streamer(TBuffer &R__b)
02163 {
02164
02165
02166 TSocket::Streamer(R__b);
02167 }
02168
02169
02170 void TPSocket::ShowMembers(TMemberInspector &R__insp)
02171 {
02172
02173 TClass *R__cl = ::TPSocket::IsA();
02174 if (R__cl || R__insp.IsA()) { }
02175 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSockets", &fSockets);
02176 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fWriteMonitor", &fWriteMonitor);
02177 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fReadMonitor", &fReadMonitor);
02178 R__insp.Inspect(R__cl, R__insp.GetParent(), "fSize", &fSize);
02179 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fWriteBytesLeft", &fWriteBytesLeft);
02180 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fReadBytesLeft", &fReadBytesLeft);
02181 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fWritePtr", &fWritePtr);
02182 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fReadPtr", &fReadPtr);
02183 TSocket::ShowMembers(R__insp);
02184 }
02185
02186 namespace ROOT {
02187
02188 static void delete_TPSocket(void *p) {
02189 delete ((::TPSocket*)p);
02190 }
02191 static void deleteArray_TPSocket(void *p) {
02192 delete [] ((::TPSocket*)p);
02193 }
02194 static void destruct_TPSocket(void *p) {
02195 typedef ::TPSocket current_t;
02196 ((current_t*)p)->~current_t();
02197 }
02198
02199 static void streamer_TPSocket(TBuffer &buf, void *obj) {
02200 ((::TPSocket*)obj)->::TPSocket::Streamer(buf);
02201 }
02202 }
02203
02204
02205 void TMessage::Streamer(TBuffer &R__b)
02206 {
02207
02208
02209 TBufferFile::Streamer(R__b);
02210 }
02211
02212
02213 void TMessage::ShowMembers(TMemberInspector &R__insp)
02214 {
02215
02216 TClass *R__cl = ::TMessage::IsA();
02217 if (R__cl || R__insp.IsA()) { }
02218 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fInfos", &fInfos);
02219 R__insp.Inspect(R__cl, R__insp.GetParent(), "fBitsPIDs", &fBitsPIDs);
02220 R__insp.InspectMember(fBitsPIDs, "fBitsPIDs.");
02221 R__insp.Inspect(R__cl, R__insp.GetParent(), "fWhat", &fWhat);
02222 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fClass", &fClass);
02223 R__insp.Inspect(R__cl, R__insp.GetParent(), "fCompress", &fCompress);
02224 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBufComp", &fBufComp);
02225 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBufCompCur", &fBufCompCur);
02226 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCompPos", &fCompPos);
02227 R__insp.Inspect(R__cl, R__insp.GetParent(), "fEvolution", &fEvolution);
02228 TBufferFile::ShowMembers(R__insp);
02229 }
02230
02231 namespace ROOT {
02232
02233 static void *new_TMessage(void *p) {
02234 return p ? new(p) ::TMessage : new ::TMessage;
02235 }
02236 static void *newArray_TMessage(Long_t nElements, void *p) {
02237 return p ? new(p) ::TMessage[nElements] : new ::TMessage[nElements];
02238 }
02239
02240 static void delete_TMessage(void *p) {
02241 delete ((::TMessage*)p);
02242 }
02243 static void deleteArray_TMessage(void *p) {
02244 delete [] ((::TMessage*)p);
02245 }
02246 static void destruct_TMessage(void *p) {
02247 typedef ::TMessage current_t;
02248 ((current_t*)p)->~current_t();
02249 }
02250
02251 static void streamer_TMessage(TBuffer &buf, void *obj) {
02252 ((::TMessage*)obj)->::TMessage::Streamer(buf);
02253 }
02254 }
02255
02256
02257 void TMonitor::Streamer(TBuffer &R__b)
02258 {
02259
02260
02261 TObject::Streamer(R__b);
02262 TQObject::Streamer(R__b);
02263 }
02264
02265
02266 void TMonitor::ShowMembers(TMemberInspector &R__insp)
02267 {
02268
02269 TClass *R__cl = ::TMonitor::IsA();
02270 if (R__cl || R__insp.IsA()) { }
02271 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fActive", &fActive);
02272 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDeActive", &fDeActive);
02273 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fReady", &fReady);
02274 R__insp.Inspect(R__cl, R__insp.GetParent(), "fMainLoop", &fMainLoop);
02275 R__insp.Inspect(R__cl, R__insp.GetParent(), "fInterrupt", &fInterrupt);
02276 TObject::ShowMembers(R__insp);
02277 TQObject::ShowMembers(R__insp);
02278 }
02279
02280 namespace ROOT {
02281
02282 static void *new_TMonitor(void *p) {
02283 return p ? new(p) ::TMonitor : new ::TMonitor;
02284 }
02285 static void *newArray_TMonitor(Long_t nElements, void *p) {
02286 return p ? new(p) ::TMonitor[nElements] : new ::TMonitor[nElements];
02287 }
02288
02289 static void delete_TMonitor(void *p) {
02290 delete ((::TMonitor*)p);
02291 }
02292 static void deleteArray_TMonitor(void *p) {
02293 delete [] ((::TMonitor*)p);
02294 }
02295 static void destruct_TMonitor(void *p) {
02296 typedef ::TMonitor current_t;
02297 ((current_t*)p)->~current_t();
02298 }
02299
02300 static void streamer_TMonitor(TBuffer &buf, void *obj) {
02301 ((::TMonitor*)obj)->::TMonitor::Streamer(buf);
02302 }
02303 }
02304
02305
02306 void TNetFile::Streamer(TBuffer &R__b)
02307 {
02308
02309
02310 UInt_t R__s, R__c;
02311 if (R__b.IsReading()) {
02312 Version_t R__v = R__b.ReadVersion(&R__s, &R__c); if (R__v) { }
02313 TFile::Streamer(R__b);
02314 fEndpointUrl.Streamer(R__b);
02315 fUser.Streamer(R__b);
02316 R__b >> fSocket;
02317 R__b >> fProtocol;
02318 R__b >> fErrorCode;
02319 R__b >> fNetopt;
02320 R__b.CheckByteCount(R__s, R__c, TNetFile::IsA());
02321 } else {
02322 R__c = R__b.WriteVersion(TNetFile::IsA(), kTRUE);
02323 TFile::Streamer(R__b);
02324 fEndpointUrl.Streamer(R__b);
02325 fUser.Streamer(R__b);
02326 R__b << fSocket;
02327 R__b << fProtocol;
02328 R__b << fErrorCode;
02329 R__b << fNetopt;
02330 R__b.SetByteCount(R__c, kTRUE);
02331 }
02332 }
02333
02334
02335 void TNetFile::ShowMembers(TMemberInspector &R__insp)
02336 {
02337
02338 TClass *R__cl = ::TNetFile::IsA();
02339 if (R__cl || R__insp.IsA()) { }
02340 R__insp.Inspect(R__cl, R__insp.GetParent(), "fEndpointUrl", &fEndpointUrl);
02341 R__insp.InspectMember(fEndpointUrl, "fEndpointUrl.");
02342 R__insp.Inspect(R__cl, R__insp.GetParent(), "fUser", &fUser);
02343 R__insp.InspectMember(fUser, "fUser.");
02344 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSocket", &fSocket);
02345 R__insp.Inspect(R__cl, R__insp.GetParent(), "fProtocol", &fProtocol);
02346 R__insp.Inspect(R__cl, R__insp.GetParent(), "fErrorCode", &fErrorCode);
02347 R__insp.Inspect(R__cl, R__insp.GetParent(), "fNetopt", &fNetopt);
02348 TFile::ShowMembers(R__insp);
02349 }
02350
02351 namespace ROOT {
02352
02353 static void *new_TNetFile(void *p) {
02354 return p ? new(p) ::TNetFile : new ::TNetFile;
02355 }
02356 static void *newArray_TNetFile(Long_t nElements, void *p) {
02357 return p ? new(p) ::TNetFile[nElements] : new ::TNetFile[nElements];
02358 }
02359
02360 static void delete_TNetFile(void *p) {
02361 delete ((::TNetFile*)p);
02362 }
02363 static void deleteArray_TNetFile(void *p) {
02364 delete [] ((::TNetFile*)p);
02365 }
02366 static void destruct_TNetFile(void *p) {
02367 typedef ::TNetFile current_t;
02368 ((current_t*)p)->~current_t();
02369 }
02370
02371 static void streamer_TNetFile(TBuffer &buf, void *obj) {
02372 ((::TNetFile*)obj)->::TNetFile::Streamer(buf);
02373 }
02374 }
02375
02376
02377 void TNetSystem::Streamer(TBuffer &R__b)
02378 {
02379
02380
02381 TSystem::Streamer(R__b);
02382 }
02383
02384
02385 void TNetSystem::ShowMembers(TMemberInspector &R__insp)
02386 {
02387
02388 TClass *R__cl = ::TNetSystem::IsA();
02389 if (R__cl || R__insp.IsA()) { }
02390 R__insp.Inspect(R__cl, R__insp.GetParent(), "fDir", &fDir);
02391 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDirp", &fDirp);
02392 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFTP", &fFTP);
02393 R__insp.Inspect(R__cl, R__insp.GetParent(), "fHost", &fHost);
02394 R__insp.InspectMember(fHost, "fHost.");
02395 R__insp.Inspect(R__cl, R__insp.GetParent(), "fFTPOwner", &fFTPOwner);
02396 R__insp.Inspect(R__cl, R__insp.GetParent(), "fUser", &fUser);
02397 R__insp.InspectMember(fUser, "fUser.");
02398 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPort", &fPort);
02399 R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsLocal", &fIsLocal);
02400 R__insp.Inspect(R__cl, R__insp.GetParent(), "fLocalPrefix", &fLocalPrefix);
02401 R__insp.InspectMember(fLocalPrefix, "fLocalPrefix.");
02402 TSystem::ShowMembers(R__insp);
02403 }
02404
02405 namespace ROOT {
02406
02407 static void *new_TNetSystem(void *p) {
02408 return p ? new(p) ::TNetSystem : new ::TNetSystem;
02409 }
02410 static void *newArray_TNetSystem(Long_t nElements, void *p) {
02411 return p ? new(p) ::TNetSystem[nElements] : new ::TNetSystem[nElements];
02412 }
02413
02414 static void delete_TNetSystem(void *p) {
02415 delete ((::TNetSystem*)p);
02416 }
02417 static void deleteArray_TNetSystem(void *p) {
02418 delete [] ((::TNetSystem*)p);
02419 }
02420 static void destruct_TNetSystem(void *p) {
02421 typedef ::TNetSystem current_t;
02422 ((current_t*)p)->~current_t();
02423 }
02424
02425 static void streamer_TNetSystem(TBuffer &buf, void *obj) {
02426 ((::TNetSystem*)obj)->::TNetSystem::Streamer(buf);
02427 }
02428 }
02429
02430
02431 void TWebFile::Streamer(TBuffer &R__b)
02432 {
02433
02434
02435 UInt_t R__s, R__c;
02436 if (R__b.IsReading()) {
02437 Version_t R__v = R__b.ReadVersion(&R__s, &R__c); if (R__v) { }
02438 TFile::Streamer(R__b);
02439 R__b >> fSize;
02440 R__b >> fSocket;
02441 fProxy.Streamer(R__b);
02442 R__b >> fHasModRoot;
02443 R__b >> fHTTP11;
02444 R__b >> fNoProxy;
02445 fMsgReadBuffer.Streamer(R__b);
02446 fMsgReadBuffer10.Streamer(R__b);
02447 fMsgGetHead.Streamer(R__b);
02448 fBasicUrl.Streamer(R__b);
02449 fUrlOrg.Streamer(R__b);
02450 fBasicUrlOrg.Streamer(R__b);
02451 R__b.CheckByteCount(R__s, R__c, TWebFile::IsA());
02452 } else {
02453 R__c = R__b.WriteVersion(TWebFile::IsA(), kTRUE);
02454 TFile::Streamer(R__b);
02455 R__b << fSize;
02456 R__b << fSocket;
02457 fProxy.Streamer(R__b);
02458 R__b << fHasModRoot;
02459 R__b << fHTTP11;
02460 R__b << fNoProxy;
02461 fMsgReadBuffer.Streamer(R__b);
02462 fMsgReadBuffer10.Streamer(R__b);
02463 fMsgGetHead.Streamer(R__b);
02464 fBasicUrl.Streamer(R__b);
02465 fUrlOrg.Streamer(R__b);
02466 fBasicUrlOrg.Streamer(R__b);
02467 R__b.SetByteCount(R__c, kTRUE);
02468 }
02469 }
02470
02471
02472 void TWebFile::ShowMembers(TMemberInspector &R__insp)
02473 {
02474
02475 TClass *R__cl = ::TWebFile::IsA();
02476 if (R__cl || R__insp.IsA()) { }
02477 R__insp.Inspect(R__cl, R__insp.GetParent(), "fSize", &fSize);
02478 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSocket", &fSocket);
02479 R__insp.Inspect(R__cl, R__insp.GetParent(), "fProxy", &fProxy);
02480 R__insp.InspectMember(fProxy, "fProxy.");
02481 R__insp.Inspect(R__cl, R__insp.GetParent(), "fHasModRoot", &fHasModRoot);
02482 R__insp.Inspect(R__cl, R__insp.GetParent(), "fHTTP11", &fHTTP11);
02483 R__insp.Inspect(R__cl, R__insp.GetParent(), "fNoProxy", &fNoProxy);
02484 R__insp.Inspect(R__cl, R__insp.GetParent(), "fMsgReadBuffer", &fMsgReadBuffer);
02485 R__insp.InspectMember(fMsgReadBuffer, "fMsgReadBuffer.");
02486 R__insp.Inspect(R__cl, R__insp.GetParent(), "fMsgReadBuffer10", &fMsgReadBuffer10);
02487 R__insp.InspectMember(fMsgReadBuffer10, "fMsgReadBuffer10.");
02488 R__insp.Inspect(R__cl, R__insp.GetParent(), "fMsgGetHead", &fMsgGetHead);
02489 R__insp.InspectMember(fMsgGetHead, "fMsgGetHead.");
02490 R__insp.Inspect(R__cl, R__insp.GetParent(), "fBasicUrl", &fBasicUrl);
02491 R__insp.InspectMember(fBasicUrl, "fBasicUrl.");
02492 R__insp.Inspect(R__cl, R__insp.GetParent(), "fUrlOrg", &fUrlOrg);
02493 R__insp.InspectMember(fUrlOrg, "fUrlOrg.");
02494 R__insp.Inspect(R__cl, R__insp.GetParent(), "fBasicUrlOrg", &fBasicUrlOrg);
02495 R__insp.InspectMember(fBasicUrlOrg, "fBasicUrlOrg.");
02496 TFile::ShowMembers(R__insp);
02497 }
02498
02499 namespace ROOT {
02500
02501 static void delete_TWebFile(void *p) {
02502 delete ((::TWebFile*)p);
02503 }
02504 static void deleteArray_TWebFile(void *p) {
02505 delete [] ((::TWebFile*)p);
02506 }
02507 static void destruct_TWebFile(void *p) {
02508 typedef ::TWebFile current_t;
02509 ((current_t*)p)->~current_t();
02510 }
02511
02512 static void streamer_TWebFile(TBuffer &buf, void *obj) {
02513 ((::TWebFile*)obj)->::TWebFile::Streamer(buf);
02514 }
02515 }
02516
02517
02518 void TWebSystem::Streamer(TBuffer &R__b)
02519 {
02520
02521
02522 TSystem::Streamer(R__b);
02523 }
02524
02525
02526 void TWebSystem::ShowMembers(TMemberInspector &R__insp)
02527 {
02528
02529 TClass *R__cl = ::TWebSystem::IsA();
02530 if (R__cl || R__insp.IsA()) { }
02531 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDirp", &fDirp);
02532 TSystem::ShowMembers(R__insp);
02533 }
02534
02535 namespace ROOT {
02536
02537 static void *new_TWebSystem(void *p) {
02538 return p ? new(p) ::TWebSystem : new ::TWebSystem;
02539 }
02540 static void *newArray_TWebSystem(Long_t nElements, void *p) {
02541 return p ? new(p) ::TWebSystem[nElements] : new ::TWebSystem[nElements];
02542 }
02543
02544 static void delete_TWebSystem(void *p) {
02545 delete ((::TWebSystem*)p);
02546 }
02547 static void deleteArray_TWebSystem(void *p) {
02548 delete [] ((::TWebSystem*)p);
02549 }
02550 static void destruct_TWebSystem(void *p) {
02551 typedef ::TWebSystem current_t;
02552 ((current_t*)p)->~current_t();
02553 }
02554
02555 static void streamer_TWebSystem(TBuffer &buf, void *obj) {
02556 ((::TWebSystem*)obj)->::TWebSystem::Streamer(buf);
02557 }
02558 }
02559
02560
02561 void TFTP::Streamer(TBuffer &R__b)
02562 {
02563
02564
02565 UInt_t R__s, R__c;
02566 if (R__b.IsReading()) {
02567 Version_t R__v = R__b.ReadVersion(&R__s, &R__c); if (R__v) { }
02568 TObject::Streamer(R__b);
02569 fHost.Streamer(R__b);
02570 fUser.Streamer(R__b);
02571 R__b >> fPort;
02572 R__b >> fParallel;
02573 R__b >> fWindowSize;
02574 R__b >> fProtocol;
02575 R__b >> fLastBlock;
02576 R__b >> fBlockSize;
02577 R__b >> fMode;
02578 R__b >> fRestartAt;
02579 fCurrentFile.Streamer(R__b);
02580 R__b >> fBytesWrite;
02581 R__b >> fBytesRead;
02582 R__b >> fDir;
02583 R__b.CheckByteCount(R__s, R__c, TFTP::IsA());
02584 } else {
02585 R__c = R__b.WriteVersion(TFTP::IsA(), kTRUE);
02586 TObject::Streamer(R__b);
02587 fHost.Streamer(R__b);
02588 fUser.Streamer(R__b);
02589 R__b << fPort;
02590 R__b << fParallel;
02591 R__b << fWindowSize;
02592 R__b << fProtocol;
02593 R__b << fLastBlock;
02594 R__b << fBlockSize;
02595 R__b << fMode;
02596 R__b << fRestartAt;
02597 fCurrentFile.Streamer(R__b);
02598 R__b << fBytesWrite;
02599 R__b << fBytesRead;
02600 R__b << fDir;
02601 R__b.SetByteCount(R__c, kTRUE);
02602 }
02603 }
02604
02605
02606 void TFTP::ShowMembers(TMemberInspector &R__insp)
02607 {
02608
02609 TClass *R__cl = ::TFTP::IsA();
02610 if (R__cl || R__insp.IsA()) { }
02611 R__insp.Inspect(R__cl, R__insp.GetParent(), "fHost", &fHost);
02612 R__insp.InspectMember(fHost, "fHost.");
02613 R__insp.Inspect(R__cl, R__insp.GetParent(), "fUser", &fUser);
02614 R__insp.InspectMember(fUser, "fUser.");
02615 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPort", &fPort);
02616 R__insp.Inspect(R__cl, R__insp.GetParent(), "fParallel", &fParallel);
02617 R__insp.Inspect(R__cl, R__insp.GetParent(), "fWindowSize", &fWindowSize);
02618 R__insp.Inspect(R__cl, R__insp.GetParent(), "fProtocol", &fProtocol);
02619 R__insp.Inspect(R__cl, R__insp.GetParent(), "fLastBlock", &fLastBlock);
02620 R__insp.Inspect(R__cl, R__insp.GetParent(), "fBlockSize", &fBlockSize);
02621 R__insp.Inspect(R__cl, R__insp.GetParent(), "fMode", &fMode);
02622 R__insp.Inspect(R__cl, R__insp.GetParent(), "fRestartAt", &fRestartAt);
02623 R__insp.Inspect(R__cl, R__insp.GetParent(), "fCurrentFile", &fCurrentFile);
02624 R__insp.InspectMember(fCurrentFile, "fCurrentFile.");
02625 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSocket", &fSocket);
02626 R__insp.Inspect(R__cl, R__insp.GetParent(), "fBytesWrite", &fBytesWrite);
02627 R__insp.Inspect(R__cl, R__insp.GetParent(), "fBytesRead", &fBytesRead);
02628 R__insp.Inspect(R__cl, R__insp.GetParent(), "fDir", &fDir);
02629 TObject::ShowMembers(R__insp);
02630 }
02631
02632 namespace ROOT {
02633
02634 static void delete_TFTP(void *p) {
02635 delete ((::TFTP*)p);
02636 }
02637 static void deleteArray_TFTP(void *p) {
02638 delete [] ((::TFTP*)p);
02639 }
02640 static void destruct_TFTP(void *p) {
02641 typedef ::TFTP current_t;
02642 ((current_t*)p)->~current_t();
02643 }
02644
02645 static void streamer_TFTP(TBuffer &buf, void *obj) {
02646 ((::TFTP*)obj)->::TFTP::Streamer(buf);
02647 }
02648 }
02649
02650
02651 void TSQLServer::Streamer(TBuffer &R__b)
02652 {
02653
02654
02655 TObject::Streamer(R__b);
02656 }
02657
02658
02659 void TSQLServer::ShowMembers(TMemberInspector &R__insp)
02660 {
02661
02662 TClass *R__cl = ::TSQLServer::IsA();
02663 if (R__cl || R__insp.IsA()) { }
02664 R__insp.Inspect(R__cl, R__insp.GetParent(), "fType", &fType);
02665 R__insp.InspectMember(fType, "fType.");
02666 R__insp.Inspect(R__cl, R__insp.GetParent(), "fHost", &fHost);
02667 R__insp.InspectMember(fHost, "fHost.");
02668 R__insp.Inspect(R__cl, R__insp.GetParent(), "fDB", &fDB);
02669 R__insp.InspectMember(fDB, "fDB.");
02670 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPort", &fPort);
02671 R__insp.Inspect(R__cl, R__insp.GetParent(), "fErrorCode", &fErrorCode);
02672 R__insp.Inspect(R__cl, R__insp.GetParent(), "fErrorMsg", &fErrorMsg);
02673 R__insp.InspectMember(fErrorMsg, "fErrorMsg.");
02674 R__insp.Inspect(R__cl, R__insp.GetParent(), "fErrorOut", &fErrorOut);
02675 TObject::ShowMembers(R__insp);
02676 }
02677
02678 namespace ROOT {
02679
02680 static void delete_TSQLServer(void *p) {
02681 delete ((::TSQLServer*)p);
02682 }
02683 static void deleteArray_TSQLServer(void *p) {
02684 delete [] ((::TSQLServer*)p);
02685 }
02686 static void destruct_TSQLServer(void *p) {
02687 typedef ::TSQLServer current_t;
02688 ((current_t*)p)->~current_t();
02689 }
02690
02691 static void streamer_TSQLServer(TBuffer &buf, void *obj) {
02692 ((::TSQLServer*)obj)->::TSQLServer::Streamer(buf);
02693 }
02694 }
02695
02696
02697 void TSQLResult::Streamer(TBuffer &R__b)
02698 {
02699
02700
02701 TObject::Streamer(R__b);
02702 }
02703
02704
02705 void TSQLResult::ShowMembers(TMemberInspector &R__insp)
02706 {
02707
02708 TClass *R__cl = ::TSQLResult::IsA();
02709 if (R__cl || R__insp.IsA()) { }
02710 R__insp.Inspect(R__cl, R__insp.GetParent(), "fRowCount", &fRowCount);
02711 TObject::ShowMembers(R__insp);
02712 }
02713
02714 namespace ROOT {
02715
02716 static void delete_TSQLResult(void *p) {
02717 delete ((::TSQLResult*)p);
02718 }
02719 static void deleteArray_TSQLResult(void *p) {
02720 delete [] ((::TSQLResult*)p);
02721 }
02722 static void destruct_TSQLResult(void *p) {
02723 typedef ::TSQLResult current_t;
02724 ((current_t*)p)->~current_t();
02725 }
02726
02727 static void streamer_TSQLResult(TBuffer &buf, void *obj) {
02728 ((::TSQLResult*)obj)->::TSQLResult::Streamer(buf);
02729 }
02730 }
02731
02732
02733 void TSQLRow::Streamer(TBuffer &R__b)
02734 {
02735
02736
02737 TObject::Streamer(R__b);
02738 }
02739
02740
02741 void TSQLRow::ShowMembers(TMemberInspector &R__insp)
02742 {
02743
02744 TClass *R__cl = ::TSQLRow::IsA();
02745 if (R__cl || R__insp.IsA()) { }
02746 TObject::ShowMembers(R__insp);
02747 }
02748
02749 namespace ROOT {
02750
02751 static void delete_TSQLRow(void *p) {
02752 delete ((::TSQLRow*)p);
02753 }
02754 static void deleteArray_TSQLRow(void *p) {
02755 delete [] ((::TSQLRow*)p);
02756 }
02757 static void destruct_TSQLRow(void *p) {
02758 typedef ::TSQLRow current_t;
02759 ((current_t*)p)->~current_t();
02760 }
02761
02762 static void streamer_TSQLRow(TBuffer &buf, void *obj) {
02763 ((::TSQLRow*)obj)->::TSQLRow::Streamer(buf);
02764 }
02765 }
02766
02767
02768 void TSQLStatement::Streamer(TBuffer &R__b)
02769 {
02770
02771
02772 TObject::Streamer(R__b);
02773 }
02774
02775
02776 void TSQLStatement::ShowMembers(TMemberInspector &R__insp)
02777 {
02778
02779 TClass *R__cl = ::TSQLStatement::IsA();
02780 if (R__cl || R__insp.IsA()) { }
02781 R__insp.Inspect(R__cl, R__insp.GetParent(), "fErrorCode", &fErrorCode);
02782 R__insp.Inspect(R__cl, R__insp.GetParent(), "fErrorMsg", &fErrorMsg);
02783 R__insp.InspectMember(fErrorMsg, "fErrorMsg.");
02784 R__insp.Inspect(R__cl, R__insp.GetParent(), "fErrorOut", &fErrorOut);
02785 TObject::ShowMembers(R__insp);
02786 }
02787
02788 namespace ROOT {
02789
02790 static void delete_TSQLStatement(void *p) {
02791 delete ((::TSQLStatement*)p);
02792 }
02793 static void deleteArray_TSQLStatement(void *p) {
02794 delete [] ((::TSQLStatement*)p);
02795 }
02796 static void destruct_TSQLStatement(void *p) {
02797 typedef ::TSQLStatement current_t;
02798 ((current_t*)p)->~current_t();
02799 }
02800
02801 static void streamer_TSQLStatement(TBuffer &buf, void *obj) {
02802 ((::TSQLStatement*)obj)->::TSQLStatement::Streamer(buf);
02803 }
02804 }
02805
02806
02807 void TSQLTableInfo::Streamer(TBuffer &R__b)
02808 {
02809
02810
02811 TNamed::Streamer(R__b);
02812 }
02813
02814
02815 void TSQLTableInfo::ShowMembers(TMemberInspector &R__insp)
02816 {
02817
02818 TClass *R__cl = ::TSQLTableInfo::IsA();
02819 if (R__cl || R__insp.IsA()) { }
02820 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fColumns", &fColumns);
02821 R__insp.Inspect(R__cl, R__insp.GetParent(), "fEngine", &fEngine);
02822 R__insp.InspectMember(fEngine, "fEngine.");
02823 R__insp.Inspect(R__cl, R__insp.GetParent(), "fCreateTime", &fCreateTime);
02824 R__insp.InspectMember(fCreateTime, "fCreateTime.");
02825 R__insp.Inspect(R__cl, R__insp.GetParent(), "fUpdateTime", &fUpdateTime);
02826 R__insp.InspectMember(fUpdateTime, "fUpdateTime.");
02827 TNamed::ShowMembers(R__insp);
02828 }
02829
02830 namespace ROOT {
02831
02832 static void *new_TSQLTableInfo(void *p) {
02833 return p ? new(p) ::TSQLTableInfo : new ::TSQLTableInfo;
02834 }
02835 static void *newArray_TSQLTableInfo(Long_t nElements, void *p) {
02836 return p ? new(p) ::TSQLTableInfo[nElements] : new ::TSQLTableInfo[nElements];
02837 }
02838
02839 static void delete_TSQLTableInfo(void *p) {
02840 delete ((::TSQLTableInfo*)p);
02841 }
02842 static void deleteArray_TSQLTableInfo(void *p) {
02843 delete [] ((::TSQLTableInfo*)p);
02844 }
02845 static void destruct_TSQLTableInfo(void *p) {
02846 typedef ::TSQLTableInfo current_t;
02847 ((current_t*)p)->~current_t();
02848 }
02849
02850 static void streamer_TSQLTableInfo(TBuffer &buf, void *obj) {
02851 ((::TSQLTableInfo*)obj)->::TSQLTableInfo::Streamer(buf);
02852 }
02853 }
02854
02855
02856 void TSQLColumnInfo::Streamer(TBuffer &R__b)
02857 {
02858
02859
02860 TNamed::Streamer(R__b);
02861 }
02862
02863
02864 void TSQLColumnInfo::ShowMembers(TMemberInspector &R__insp)
02865 {
02866
02867 TClass *R__cl = ::TSQLColumnInfo::IsA();
02868 if (R__cl || R__insp.IsA()) { }
02869 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTypeName", &fTypeName);
02870 R__insp.InspectMember(fTypeName, "fTypeName.");
02871 R__insp.Inspect(R__cl, R__insp.GetParent(), "fSQLType", &fSQLType);
02872 R__insp.Inspect(R__cl, R__insp.GetParent(), "fSize", &fSize);
02873 R__insp.Inspect(R__cl, R__insp.GetParent(), "fLength", &fLength);
02874 R__insp.Inspect(R__cl, R__insp.GetParent(), "fScale", &fScale);
02875 R__insp.Inspect(R__cl, R__insp.GetParent(), "fSigned", &fSigned);
02876 R__insp.Inspect(R__cl, R__insp.GetParent(), "fNullable", &fNullable);
02877 TNamed::ShowMembers(R__insp);
02878 }
02879
02880 namespace ROOT {
02881
02882 static void *new_TSQLColumnInfo(void *p) {
02883 return p ? new(p) ::TSQLColumnInfo : new ::TSQLColumnInfo;
02884 }
02885 static void *newArray_TSQLColumnInfo(Long_t nElements, void *p) {
02886 return p ? new(p) ::TSQLColumnInfo[nElements] : new ::TSQLColumnInfo[nElements];
02887 }
02888
02889 static void delete_TSQLColumnInfo(void *p) {
02890 delete ((::TSQLColumnInfo*)p);
02891 }
02892 static void deleteArray_TSQLColumnInfo(void *p) {
02893 delete [] ((::TSQLColumnInfo*)p);
02894 }
02895 static void destruct_TSQLColumnInfo(void *p) {
02896 typedef ::TSQLColumnInfo current_t;
02897 ((current_t*)p)->~current_t();
02898 }
02899
02900 static void streamer_TSQLColumnInfo(TBuffer &buf, void *obj) {
02901 ((::TSQLColumnInfo*)obj)->::TSQLColumnInfo::Streamer(buf);
02902 }
02903 }
02904
02905
02906 void TSQLMonitoringWriter::Streamer(TBuffer &R__b)
02907 {
02908
02909
02910 TVirtualMonitoringWriter::Streamer(R__b);
02911 }
02912
02913
02914 void TSQLMonitoringWriter::ShowMembers(TMemberInspector &R__insp)
02915 {
02916
02917 TClass *R__cl = ::TSQLMonitoringWriter::IsA();
02918 if (R__cl || R__insp.IsA()) { }
02919 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDB", &fDB);
02920 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTable", &fTable);
02921 R__insp.InspectMember(fTable, "fTable.");
02922 TVirtualMonitoringWriter::ShowMembers(R__insp);
02923 }
02924
02925 namespace ROOT {
02926
02927 static void delete_TSQLMonitoringWriter(void *p) {
02928 delete ((::TSQLMonitoringWriter*)p);
02929 }
02930 static void deleteArray_TSQLMonitoringWriter(void *p) {
02931 delete [] ((::TSQLMonitoringWriter*)p);
02932 }
02933 static void destruct_TSQLMonitoringWriter(void *p) {
02934 typedef ::TSQLMonitoringWriter current_t;
02935 ((current_t*)p)->~current_t();
02936 }
02937
02938 static void streamer_TSQLMonitoringWriter(TBuffer &buf, void *obj) {
02939 ((::TSQLMonitoringWriter*)obj)->::TSQLMonitoringWriter::Streamer(buf);
02940 }
02941 }
02942
02943
02944 void TGrid::Streamer(TBuffer &R__b)
02945 {
02946
02947
02948 TObject::Streamer(R__b);
02949 }
02950
02951
02952 void TGrid::ShowMembers(TMemberInspector &R__insp)
02953 {
02954
02955 TClass *R__cl = ::TGrid::IsA();
02956 if (R__cl || R__insp.IsA()) { }
02957 R__insp.Inspect(R__cl, R__insp.GetParent(), "fGridUrl", &fGridUrl);
02958 R__insp.InspectMember(fGridUrl, "fGridUrl.");
02959 R__insp.Inspect(R__cl, R__insp.GetParent(), "fGrid", &fGrid);
02960 R__insp.InspectMember(fGrid, "fGrid.");
02961 R__insp.Inspect(R__cl, R__insp.GetParent(), "fHost", &fHost);
02962 R__insp.InspectMember(fHost, "fHost.");
02963 R__insp.Inspect(R__cl, R__insp.GetParent(), "fUser", &fUser);
02964 R__insp.InspectMember(fUser, "fUser.");
02965 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPw", &fPw);
02966 R__insp.InspectMember(fPw, "fPw.");
02967 R__insp.Inspect(R__cl, R__insp.GetParent(), "fOptions", &fOptions);
02968 R__insp.InspectMember(fOptions, "fOptions.");
02969 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPort", &fPort);
02970 TObject::ShowMembers(R__insp);
02971 }
02972
02973 namespace ROOT {
02974
02975 static void *new_TGrid(void *p) {
02976 return p ? new(p) ::TGrid : new ::TGrid;
02977 }
02978 static void *newArray_TGrid(Long_t nElements, void *p) {
02979 return p ? new(p) ::TGrid[nElements] : new ::TGrid[nElements];
02980 }
02981
02982 static void delete_TGrid(void *p) {
02983 delete ((::TGrid*)p);
02984 }
02985 static void deleteArray_TGrid(void *p) {
02986 delete [] ((::TGrid*)p);
02987 }
02988 static void destruct_TGrid(void *p) {
02989 typedef ::TGrid current_t;
02990 ((current_t*)p)->~current_t();
02991 }
02992
02993 static void streamer_TGrid(TBuffer &buf, void *obj) {
02994 ((::TGrid*)obj)->::TGrid::Streamer(buf);
02995 }
02996 }
02997
02998
02999 void TGridResult::Streamer(TBuffer &R__b)
03000 {
03001
03002
03003 if (R__b.IsReading()) {
03004 R__b.ReadClassBuffer(TGridResult::Class(),this);
03005 } else {
03006 R__b.WriteClassBuffer(TGridResult::Class(),this);
03007 }
03008 }
03009
03010
03011 void TGridResult::ShowMembers(TMemberInspector &R__insp)
03012 {
03013
03014 TClass *R__cl = ::TGridResult::IsA();
03015 if (R__cl || R__insp.IsA()) { }
03016 TList::ShowMembers(R__insp);
03017 }
03018
03019 namespace ROOT {
03020
03021 static void *new_TGridResult(void *p) {
03022 return p ? new(p) ::TGridResult : new ::TGridResult;
03023 }
03024 static void *newArray_TGridResult(Long_t nElements, void *p) {
03025 return p ? new(p) ::TGridResult[nElements] : new ::TGridResult[nElements];
03026 }
03027
03028 static void delete_TGridResult(void *p) {
03029 delete ((::TGridResult*)p);
03030 }
03031 static void deleteArray_TGridResult(void *p) {
03032 delete [] ((::TGridResult*)p);
03033 }
03034 static void destruct_TGridResult(void *p) {
03035 typedef ::TGridResult current_t;
03036 ((current_t*)p)->~current_t();
03037 }
03038 }
03039
03040
03041 void TGridJDL::Streamer(TBuffer &R__b)
03042 {
03043
03044
03045 if (R__b.IsReading()) {
03046 R__b.ReadClassBuffer(TGridJDL::Class(),this);
03047 } else {
03048 R__b.WriteClassBuffer(TGridJDL::Class(),this);
03049 }
03050 }
03051
03052
03053 void TGridJDL::ShowMembers(TMemberInspector &R__insp)
03054 {
03055
03056 TClass *R__cl = ::TGridJDL::IsA();
03057 if (R__cl || R__insp.IsA()) { }
03058 R__insp.Inspect(R__cl, R__insp.GetParent(), "fMap", &fMap);
03059 R__insp.InspectMember(fMap, "fMap.");
03060 R__insp.Inspect(R__cl, R__insp.GetParent(), "fDescriptionMap", &fDescriptionMap);
03061 R__insp.InspectMember(fDescriptionMap, "fDescriptionMap.");
03062 TObject::ShowMembers(R__insp);
03063 }
03064
03065 namespace ROOT {
03066
03067 static void delete_TGridJDL(void *p) {
03068 delete ((::TGridJDL*)p);
03069 }
03070 static void deleteArray_TGridJDL(void *p) {
03071 delete [] ((::TGridJDL*)p);
03072 }
03073 static void destruct_TGridJDL(void *p) {
03074 typedef ::TGridJDL current_t;
03075 ((current_t*)p)->~current_t();
03076 }
03077 }
03078
03079
03080 void TGridJob::Streamer(TBuffer &R__b)
03081 {
03082
03083
03084 if (R__b.IsReading()) {
03085 R__b.ReadClassBuffer(TGridJob::Class(),this);
03086 } else {
03087 R__b.WriteClassBuffer(TGridJob::Class(),this);
03088 }
03089 }
03090
03091
03092 void TGridJob::ShowMembers(TMemberInspector &R__insp)
03093 {
03094
03095 TClass *R__cl = ::TGridJob::IsA();
03096 if (R__cl || R__insp.IsA()) { }
03097 R__insp.Inspect(R__cl, R__insp.GetParent(), "fJobID", &fJobID);
03098 R__insp.InspectMember(fJobID, "fJobID.");
03099 TObject::ShowMembers(R__insp);
03100 }
03101
03102 namespace ROOT {
03103
03104 static void delete_TGridJob(void *p) {
03105 delete ((::TGridJob*)p);
03106 }
03107 static void deleteArray_TGridJob(void *p) {
03108 delete [] ((::TGridJob*)p);
03109 }
03110 static void destruct_TGridJob(void *p) {
03111 typedef ::TGridJob current_t;
03112 ((current_t*)p)->~current_t();
03113 }
03114 }
03115
03116
03117 void TGridJobStatus::Streamer(TBuffer &R__b)
03118 {
03119
03120
03121 if (R__b.IsReading()) {
03122 R__b.ReadClassBuffer(TGridJobStatus::Class(),this);
03123 } else {
03124 R__b.WriteClassBuffer(TGridJobStatus::Class(),this);
03125 }
03126 }
03127
03128
03129 void TGridJobStatus::ShowMembers(TMemberInspector &R__insp)
03130 {
03131
03132 TClass *R__cl = ::TGridJobStatus::IsA();
03133 if (R__cl || R__insp.IsA()) { }
03134 TNamed::ShowMembers(R__insp);
03135 }
03136
03137 namespace ROOT {
03138
03139 static void delete_TGridJobStatus(void *p) {
03140 delete ((::TGridJobStatus*)p);
03141 }
03142 static void deleteArray_TGridJobStatus(void *p) {
03143 delete [] ((::TGridJobStatus*)p);
03144 }
03145 static void destruct_TGridJobStatus(void *p) {
03146 typedef ::TGridJobStatus current_t;
03147 ((current_t*)p)->~current_t();
03148 }
03149 }
03150
03151
03152 void TGridJobStatusList::Streamer(TBuffer &R__b)
03153 {
03154
03155
03156 if (R__b.IsReading()) {
03157 R__b.ReadClassBuffer(TGridJobStatusList::Class(),this);
03158 } else {
03159 R__b.WriteClassBuffer(TGridJobStatusList::Class(),this);
03160 }
03161 }
03162
03163
03164 void TGridJobStatusList::ShowMembers(TMemberInspector &R__insp)
03165 {
03166
03167 TClass *R__cl = ::TGridJobStatusList::IsA();
03168 if (R__cl || R__insp.IsA()) { }
03169 R__insp.Inspect(R__cl, R__insp.GetParent(), "fJobID", &fJobID);
03170 R__insp.InspectMember(fJobID, "fJobID.");
03171 TList::ShowMembers(R__insp);
03172 }
03173
03174 namespace ROOT {
03175
03176 static void *new_TGridJobStatusList(void *p) {
03177 return p ? new(p) ::TGridJobStatusList : new ::TGridJobStatusList;
03178 }
03179 static void *newArray_TGridJobStatusList(Long_t nElements, void *p) {
03180 return p ? new(p) ::TGridJobStatusList[nElements] : new ::TGridJobStatusList[nElements];
03181 }
03182
03183 static void delete_TGridJobStatusList(void *p) {
03184 delete ((::TGridJobStatusList*)p);
03185 }
03186 static void deleteArray_TGridJobStatusList(void *p) {
03187 delete [] ((::TGridJobStatusList*)p);
03188 }
03189 static void destruct_TGridJobStatusList(void *p) {
03190 typedef ::TGridJobStatusList current_t;
03191 ((current_t*)p)->~current_t();
03192 }
03193 }
03194
03195
03196 void TGridCollection::Streamer(TBuffer &R__b)
03197 {
03198
03199
03200 if (R__b.IsReading()) {
03201 R__b.ReadClassBuffer(TGridCollection::Class(),this);
03202 } else {
03203 R__b.WriteClassBuffer(TGridCollection::Class(),this);
03204 }
03205 }
03206
03207
03208 void TGridCollection::ShowMembers(TMemberInspector &R__insp)
03209 {
03210
03211 TClass *R__cl = ::TGridCollection::IsA();
03212 if (R__cl || R__insp.IsA()) { }
03213 TObject::ShowMembers(R__insp);
03214 }
03215
03216 namespace ROOT {
03217
03218 static void *new_TGridCollection(void *p) {
03219 return p ? new(p) ::TGridCollection : new ::TGridCollection;
03220 }
03221 static void *newArray_TGridCollection(Long_t nElements, void *p) {
03222 return p ? new(p) ::TGridCollection[nElements] : new ::TGridCollection[nElements];
03223 }
03224
03225 static void delete_TGridCollection(void *p) {
03226 delete ((::TGridCollection*)p);
03227 }
03228 static void deleteArray_TGridCollection(void *p) {
03229 delete [] ((::TGridCollection*)p);
03230 }
03231 static void destruct_TGridCollection(void *p) {
03232 typedef ::TGridCollection current_t;
03233 ((current_t*)p)->~current_t();
03234 }
03235 }
03236
03237
03238 void TSecContext::Streamer(TBuffer &R__b)
03239 {
03240
03241
03242 TObject::Streamer(R__b);
03243 }
03244
03245
03246 void TSecContext::ShowMembers(TMemberInspector &R__insp)
03247 {
03248
03249 TClass *R__cl = ::TSecContext::IsA();
03250 if (R__cl || R__insp.IsA()) { }
03251 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fContext", &fContext);
03252 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCleanup", &fCleanup);
03253 R__insp.Inspect(R__cl, R__insp.GetParent(), "fExpDate", &fExpDate);
03254 R__insp.InspectMember(fExpDate, "fExpDate.");
03255 R__insp.Inspect(R__cl, R__insp.GetParent(), "fHost", &fHost);
03256 R__insp.InspectMember(fHost, "fHost.");
03257 R__insp.Inspect(R__cl, R__insp.GetParent(), "fID", &fID);
03258 R__insp.InspectMember(fID, "fID.");
03259 R__insp.Inspect(R__cl, R__insp.GetParent(), "fMethod", &fMethod);
03260 R__insp.Inspect(R__cl, R__insp.GetParent(), "fMethodName", &fMethodName);
03261 R__insp.InspectMember(fMethodName, "fMethodName.");
03262 R__insp.Inspect(R__cl, R__insp.GetParent(), "fOffSet", &fOffSet);
03263 R__insp.Inspect(R__cl, R__insp.GetParent(), "fToken", &fToken);
03264 R__insp.InspectMember(fToken, "fToken.");
03265 R__insp.Inspect(R__cl, R__insp.GetParent(), "fUser", &fUser);
03266 R__insp.InspectMember(fUser, "fUser.");
03267 TObject::ShowMembers(R__insp);
03268 }
03269
03270 namespace ROOT {
03271
03272 static void delete_TSecContext(void *p) {
03273 delete ((::TSecContext*)p);
03274 }
03275 static void deleteArray_TSecContext(void *p) {
03276 delete [] ((::TSecContext*)p);
03277 }
03278 static void destruct_TSecContext(void *p) {
03279 typedef ::TSecContext current_t;
03280 ((current_t*)p)->~current_t();
03281 }
03282
03283 static void streamer_TSecContext(TBuffer &buf, void *obj) {
03284 ((::TSecContext*)obj)->::TSecContext::Streamer(buf);
03285 }
03286 }
03287
03288
03289 void TSecContextCleanup::Streamer(TBuffer &R__b)
03290 {
03291
03292
03293 TObject::Streamer(R__b);
03294 }
03295
03296
03297 void TSecContextCleanup::ShowMembers(TMemberInspector &R__insp)
03298 {
03299
03300 TClass *R__cl = ::TSecContextCleanup::IsA();
03301 if (R__cl || R__insp.IsA()) { }
03302 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPort", &fPort);
03303 R__insp.Inspect(R__cl, R__insp.GetParent(), "fServerProtocol", &fServerProtocol);
03304 R__insp.Inspect(R__cl, R__insp.GetParent(), "fServerType", &fServerType);
03305 TObject::ShowMembers(R__insp);
03306 }
03307
03308 namespace ROOT {
03309
03310 static void delete_TSecContextCleanup(void *p) {
03311 delete ((::TSecContextCleanup*)p);
03312 }
03313 static void deleteArray_TSecContextCleanup(void *p) {
03314 delete [] ((::TSecContextCleanup*)p);
03315 }
03316 static void destruct_TSecContextCleanup(void *p) {
03317 typedef ::TSecContextCleanup current_t;
03318 ((current_t*)p)->~current_t();
03319 }
03320
03321 static void streamer_TSecContextCleanup(TBuffer &buf, void *obj) {
03322 ((::TSecContextCleanup*)obj)->::TSecContextCleanup::Streamer(buf);
03323 }
03324 }
03325
03326
03327 void TFileStager::Streamer(TBuffer &R__b)
03328 {
03329
03330
03331 TNamed::Streamer(R__b);
03332 }
03333
03334
03335 void TFileStager::ShowMembers(TMemberInspector &R__insp)
03336 {
03337
03338 TClass *R__cl = ::TFileStager::IsA();
03339 if (R__cl || R__insp.IsA()) { }
03340 TNamed::ShowMembers(R__insp);
03341 }
03342
03343 namespace ROOT {
03344
03345 static void delete_TFileStager(void *p) {
03346 delete ((::TFileStager*)p);
03347 }
03348 static void deleteArray_TFileStager(void *p) {
03349 delete [] ((::TFileStager*)p);
03350 }
03351 static void destruct_TFileStager(void *p) {
03352 typedef ::TFileStager current_t;
03353 ((current_t*)p)->~current_t();
03354 }
03355
03356 static void streamer_TFileStager(TBuffer &buf, void *obj) {
03357 ((::TFileStager*)obj)->::TFileStager::Streamer(buf);
03358 }
03359 }
03360
03361
03362 void TApplicationRemote::Streamer(TBuffer &R__b)
03363 {
03364
03365
03366 TApplication::Streamer(R__b);
03367 }
03368
03369
03370 void TApplicationRemote::ShowMembers(TMemberInspector &R__insp)
03371 {
03372
03373 TClass *R__cl = ::TApplicationRemote::IsA();
03374 if (R__cl || R__insp.IsA()) { }
03375 R__insp.Inspect(R__cl, R__insp.GetParent(), "fName", &fName);
03376 R__insp.InspectMember(fName, "fName.");
03377 R__insp.Inspect(R__cl, R__insp.GetParent(), "fProtocol", &fProtocol);
03378 R__insp.Inspect(R__cl, R__insp.GetParent(), "fUrl", &fUrl);
03379 R__insp.InspectMember(fUrl, "fUrl.");
03380 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSocket", &fSocket);
03381 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMonitor", &fMonitor);
03382 R__insp.Inspect(R__cl, R__insp.GetParent(), "fInterrupt", &fInterrupt);
03383 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fIntHandler", &fIntHandler);
03384 R__insp.Inspect(R__cl, R__insp.GetParent(), "fLogFilePath", &fLogFilePath);
03385 R__insp.InspectMember(fLogFilePath, "fLogFilePath.");
03386 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFileList", &fFileList);
03387 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fReceivedObject", &fReceivedObject);
03388 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRootFiles", &fRootFiles);
03389 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fWorkingDir", &fWorkingDir);
03390 TApplication::ShowMembers(R__insp);
03391 }
03392
03393 namespace ROOT {
03394
03395 static void delete_TApplicationRemote(void *p) {
03396 delete ((::TApplicationRemote*)p);
03397 }
03398 static void deleteArray_TApplicationRemote(void *p) {
03399 delete [] ((::TApplicationRemote*)p);
03400 }
03401 static void destruct_TApplicationRemote(void *p) {
03402 typedef ::TApplicationRemote current_t;
03403 ((current_t*)p)->~current_t();
03404 }
03405
03406 static void streamer_TApplicationRemote(TBuffer &buf, void *obj) {
03407 ((::TApplicationRemote*)obj)->::TApplicationRemote::Streamer(buf);
03408 }
03409 }
03410
03411
03412 void TApplicationServer::Streamer(TBuffer &R__b)
03413 {
03414
03415
03416 TApplication::Streamer(R__b);
03417 }
03418
03419
03420 void TApplicationServer::ShowMembers(TMemberInspector &R__insp)
03421 {
03422
03423 TClass *R__cl = ::TApplicationServer::IsA();
03424 if (R__cl || R__insp.IsA()) { }
03425 R__insp.Inspect(R__cl, R__insp.GetParent(), "fProtocol", &fProtocol);
03426 R__insp.Inspect(R__cl, R__insp.GetParent(), "fUrl", &fUrl);
03427 R__insp.InspectMember(fUrl, "fUrl.");
03428 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSocket", &fSocket);
03429 R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsValid", &fIsValid);
03430 R__insp.Inspect(R__cl, R__insp.GetParent(), "fInterrupt", &fInterrupt);
03431 R__insp.Inspect(R__cl, R__insp.GetParent(), "fLogFilePath", &fLogFilePath);
03432 R__insp.InspectMember(fLogFilePath, "fLogFilePath.");
03433 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLogFile", &fLogFile);
03434 R__insp.Inspect(R__cl, R__insp.GetParent(), "fLogFileDes", &fLogFileDes);
03435 R__insp.Inspect(R__cl, R__insp.GetParent(), "fRealTimeLog", &fRealTimeLog);
03436 R__insp.Inspect(R__cl, R__insp.GetParent(), "fSessId", &fSessId);
03437 R__insp.InspectMember(fSessId, "fSessId.");
03438 R__insp.Inspect(R__cl, R__insp.GetParent(), "fWorkDir", &fWorkDir);
03439 R__insp.InspectMember(fWorkDir, "fWorkDir.");
03440 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSentCanvases", &fSentCanvases);
03441 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fWorkingDir", &fWorkingDir);
03442 TApplication::ShowMembers(R__insp);
03443 }
03444
03445 namespace ROOT {
03446
03447 static void delete_TApplicationServer(void *p) {
03448 delete ((::TApplicationServer*)p);
03449 }
03450 static void deleteArray_TApplicationServer(void *p) {
03451 delete [] ((::TApplicationServer*)p);
03452 }
03453 static void destruct_TApplicationServer(void *p) {
03454 typedef ::TApplicationServer current_t;
03455 ((current_t*)p)->~current_t();
03456 }
03457
03458 static void streamer_TApplicationServer(TBuffer &buf, void *obj) {
03459 ((::TApplicationServer*)obj)->::TApplicationServer::Streamer(buf);
03460 }
03461 }
03462
03463
03464
03465
03466
03467
03468
03469
03470 #ifdef G__MEMTEST
03471 #undef malloc
03472 #undef free
03473 #endif
03474
03475 #if defined(__GNUC__) && __GNUC__ >= 4 && ((__GNUC_MINOR__ == 2 && __GNUC_PATCHLEVEL__ >= 1) || (__GNUC_MINOR__ >= 3))
03476 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
03477 #endif
03478
03479 extern "C" void G__cpp_reset_tagtableG__Net();
03480
03481 extern "C" void G__set_cpp_environmentG__Net() {
03482 G__add_compiledheader("TObject.h");
03483 G__add_compiledheader("TMemberInspector.h");
03484 G__add_compiledheader("NetErrors.h");
03485 G__add_compiledheader("RRemoteProtocol.h");
03486 G__add_compiledheader("TApplicationRemote.h");
03487 G__add_compiledheader("TApplicationServer.h");
03488 G__add_compiledheader("TFileStager.h");
03489 G__add_compiledheader("TFTP.h");
03490 G__add_compiledheader("TGridCollection.h");
03491 G__add_compiledheader("TGrid.h");
03492 G__add_compiledheader("TGridJDL.h");
03493 G__add_compiledheader("TGridJob.h");
03494 G__add_compiledheader("TGridJobStatus.h");
03495 G__add_compiledheader("TGridJobStatusList.h");
03496 G__add_compiledheader("TGridResult.h");
03497 G__add_compiledheader("TMessage.h");
03498 G__add_compiledheader("TMonitor.h");
03499 G__add_compiledheader("TNetFile.h");
03500 G__add_compiledheader("TPServerSocket.h");
03501 G__add_compiledheader("TPSocket.h");
03502 G__add_compiledheader("TSecContext.h");
03503 G__add_compiledheader("TServerSocket.h");
03504 G__add_compiledheader("TSocket.h");
03505 G__add_compiledheader("TSQLColumnInfo.h");
03506 G__add_compiledheader("TSQLMonitoring.h");
03507 G__add_compiledheader("TSQLResult.h");
03508 G__add_compiledheader("TSQLRow.h");
03509 G__add_compiledheader("TSQLServer.h");
03510 G__add_compiledheader("TSQLStatement.h");
03511 G__add_compiledheader("TSQLTableInfo.h");
03512 G__add_compiledheader("TWebFile.h");
03513 G__cpp_reset_tagtableG__Net();
03514 }
03515 #include <new>
03516 extern "C" int G__cpp_dllrevG__Net() { return(30051515); }
03517
03518
03519
03520
03521
03522
03523 static int G__G__Net_150_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03524 {
03525 TMessage* p = NULL;
03526 char* gvp = (char*) G__getgvp();
03527 switch (libp->paran) {
03528 case 2:
03529
03530 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03531 p = new TMessage((UInt_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
03532 } else {
03533 p = new((void*) gvp) TMessage((UInt_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
03534 }
03535 break;
03536 case 1:
03537
03538 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03539 p = new TMessage((UInt_t) G__int(libp->para[0]));
03540 } else {
03541 p = new((void*) gvp) TMessage((UInt_t) G__int(libp->para[0]));
03542 }
03543 break;
03544 case 0:
03545 int n = G__getaryconstruct();
03546 if (n) {
03547 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03548 p = new TMessage[n];
03549 } else {
03550 p = new((void*) gvp) TMessage[n];
03551 }
03552 } else {
03553 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03554 p = new TMessage;
03555 } else {
03556 p = new((void*) gvp) TMessage;
03557 }
03558 }
03559 break;
03560 }
03561 result7->obj.i = (long) p;
03562 result7->ref = (long) p;
03563 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__NetLN_TMessage));
03564 return(1 || funcname || hash || result7 || libp) ;
03565 }
03566
03567 static int G__G__Net_150_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03568 {
03569 ((TMessage*) G__getstructoffset())->Forward();
03570 G__setnull(result7);
03571 return(1 || funcname || hash || result7 || libp) ;
03572 }
03573
03574 static int G__G__Net_150_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03575 {
03576 G__letint(result7, 85, (long) ((const TMessage*) G__getstructoffset())->GetClass());
03577 return(1 || funcname || hash || result7 || libp) ;
03578 }
03579
03580 static int G__G__Net_150_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03581 {
03582 ((TMessage*) G__getstructoffset())->Reset((UInt_t) G__int(libp->para[0]));
03583 G__setnull(result7);
03584 return(1 || funcname || hash || result7 || libp) ;
03585 }
03586
03587 static int G__G__Net_150_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03588 {
03589 G__letint(result7, 104, (long) ((const TMessage*) G__getstructoffset())->What());
03590 return(1 || funcname || hash || result7 || libp) ;
03591 }
03592
03593 static int G__G__Net_150_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03594 {
03595 ((TMessage*) G__getstructoffset())->SetWhat((UInt_t) G__int(libp->para[0]));
03596 G__setnull(result7);
03597 return(1 || funcname || hash || result7 || libp) ;
03598 }
03599
03600 static int G__G__Net_150_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03601 {
03602 switch (libp->paran) {
03603 case 1:
03604 ((TMessage*) G__getstructoffset())->EnableSchemaEvolution((Bool_t) G__int(libp->para[0]));
03605 G__setnull(result7);
03606 break;
03607 case 0:
03608 ((TMessage*) G__getstructoffset())->EnableSchemaEvolution();
03609 G__setnull(result7);
03610 break;
03611 }
03612 return(1 || funcname || hash || result7 || libp) ;
03613 }
03614
03615 static int G__G__Net_150_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03616 {
03617 G__letint(result7, 103, (long) ((const TMessage*) G__getstructoffset())->UsesSchemaEvolution());
03618 return(1 || funcname || hash || result7 || libp) ;
03619 }
03620
03621 static int G__G__Net_150_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03622 {
03623 switch (libp->paran) {
03624 case 1:
03625 ((TMessage*) G__getstructoffset())->SetCompressionLevel((Int_t) G__int(libp->para[0]));
03626 G__setnull(result7);
03627 break;
03628 case 0:
03629 ((TMessage*) G__getstructoffset())->SetCompressionLevel();
03630 G__setnull(result7);
03631 break;
03632 }
03633 return(1 || funcname || hash || result7 || libp) ;
03634 }
03635
03636 static int G__G__Net_150_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03637 {
03638 G__letint(result7, 105, (long) ((const TMessage*) G__getstructoffset())->GetCompressionLevel());
03639 return(1 || funcname || hash || result7 || libp) ;
03640 }
03641
03642 static int G__G__Net_150_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03643 {
03644 G__letint(result7, 105, (long) ((TMessage*) G__getstructoffset())->Compress());
03645 return(1 || funcname || hash || result7 || libp) ;
03646 }
03647
03648 static int G__G__Net_150_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03649 {
03650 G__letint(result7, 105, (long) ((TMessage*) G__getstructoffset())->Uncompress());
03651 return(1 || funcname || hash || result7 || libp) ;
03652 }
03653
03654 static int G__G__Net_150_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03655 {
03656 G__letint(result7, 67, (long) ((const TMessage*) G__getstructoffset())->CompBuffer());
03657 return(1 || funcname || hash || result7 || libp) ;
03658 }
03659
03660 static int G__G__Net_150_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03661 {
03662 G__letint(result7, 105, (long) ((const TMessage*) G__getstructoffset())->CompLength());
03663 return(1 || funcname || hash || result7 || libp) ;
03664 }
03665
03666 static int G__G__Net_150_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03667 {
03668 switch (libp->paran) {
03669 case 1:
03670 TMessage::EnableSchemaEvolutionForAll((Bool_t) G__int(libp->para[0]));
03671 G__setnull(result7);
03672 break;
03673 case 0:
03674 TMessage::EnableSchemaEvolutionForAll();
03675 G__setnull(result7);
03676 break;
03677 }
03678 return(1 || funcname || hash || result7 || libp) ;
03679 }
03680
03681 static int G__G__Net_150_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03682 {
03683 G__letint(result7, 103, (long) TMessage::UsesSchemaEvolutionForAll());
03684 return(1 || funcname || hash || result7 || libp) ;
03685 }
03686
03687 static int G__G__Net_150_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03688 {
03689 G__letint(result7, 85, (long) TMessage::Class());
03690 return(1 || funcname || hash || result7 || libp) ;
03691 }
03692
03693 static int G__G__Net_150_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03694 {
03695 G__letint(result7, 67, (long) TMessage::Class_Name());
03696 return(1 || funcname || hash || result7 || libp) ;
03697 }
03698
03699 static int G__G__Net_150_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03700 {
03701 G__letint(result7, 115, (long) TMessage::Class_Version());
03702 return(1 || funcname || hash || result7 || libp) ;
03703 }
03704
03705 static int G__G__Net_150_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03706 {
03707 TMessage::Dictionary();
03708 G__setnull(result7);
03709 return(1 || funcname || hash || result7 || libp) ;
03710 }
03711
03712 static int G__G__Net_150_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03713 {
03714 ((TMessage*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
03715 G__setnull(result7);
03716 return(1 || funcname || hash || result7 || libp) ;
03717 }
03718
03719 static int G__G__Net_150_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03720 {
03721 G__letint(result7, 67, (long) TMessage::DeclFileName());
03722 return(1 || funcname || hash || result7 || libp) ;
03723 }
03724
03725 static int G__G__Net_150_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03726 {
03727 G__letint(result7, 105, (long) TMessage::ImplFileLine());
03728 return(1 || funcname || hash || result7 || libp) ;
03729 }
03730
03731 static int G__G__Net_150_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03732 {
03733 G__letint(result7, 67, (long) TMessage::ImplFileName());
03734 return(1 || funcname || hash || result7 || libp) ;
03735 }
03736
03737 static int G__G__Net_150_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03738 {
03739 G__letint(result7, 105, (long) TMessage::DeclFileLine());
03740 return(1 || funcname || hash || result7 || libp) ;
03741 }
03742
03743
03744 typedef TMessage G__TTMessage;
03745 static int G__G__Net_150_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03746 {
03747 char* gvp = (char*) G__getgvp();
03748 long soff = G__getstructoffset();
03749 int n = G__getaryconstruct();
03750
03751
03752
03753
03754
03755 if (!soff) {
03756 return(1);
03757 }
03758 if (n) {
03759 if (gvp == (char*)G__PVOID) {
03760 delete[] (TMessage*) soff;
03761 } else {
03762 G__setgvp((long) G__PVOID);
03763 for (int i = n - 1; i >= 0; --i) {
03764 ((TMessage*) (soff+(sizeof(TMessage)*i)))->~G__TTMessage();
03765 }
03766 G__setgvp((long)gvp);
03767 }
03768 } else {
03769 if (gvp == (char*)G__PVOID) {
03770 delete (TMessage*) soff;
03771 } else {
03772 G__setgvp((long) G__PVOID);
03773 ((TMessage*) (soff))->~G__TTMessage();
03774 G__setgvp((long)gvp);
03775 }
03776 }
03777 G__setnull(result7);
03778 return(1 || funcname || hash || result7 || libp) ;
03779 }
03780
03781
03782
03783 static int G__G__Net_152_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03784 {
03785 TSocket* p = NULL;
03786 char* gvp = (char*) G__getgvp();
03787 switch (libp->paran) {
03788 case 3:
03789
03790 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03791 p = new TSocket(
03792 *((TInetAddress*) G__int(libp->para[0])), (const char*) G__int(libp->para[1])
03793 , (Int_t) G__int(libp->para[2]));
03794 } else {
03795 p = new((void*) gvp) TSocket(
03796 *((TInetAddress*) G__int(libp->para[0])), (const char*) G__int(libp->para[1])
03797 , (Int_t) G__int(libp->para[2]));
03798 }
03799 break;
03800 case 2:
03801
03802 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03803 p = new TSocket(*((TInetAddress*) G__int(libp->para[0])), (const char*) G__int(libp->para[1]));
03804 } else {
03805 p = new((void*) gvp) TSocket(*((TInetAddress*) G__int(libp->para[0])), (const char*) G__int(libp->para[1]));
03806 }
03807 break;
03808 }
03809 result7->obj.i = (long) p;
03810 result7->ref = (long) p;
03811 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__NetLN_TSocket));
03812 return(1 || funcname || hash || result7 || libp) ;
03813 }
03814
03815 static int G__G__Net_152_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03816 {
03817 TSocket* p = NULL;
03818 char* gvp = (char*) G__getgvp();
03819 switch (libp->paran) {
03820 case 3:
03821
03822 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03823 p = new TSocket(
03824 *((TInetAddress*) G__int(libp->para[0])), (Int_t) G__int(libp->para[1])
03825 , (Int_t) G__int(libp->para[2]));
03826 } else {
03827 p = new((void*) gvp) TSocket(
03828 *((TInetAddress*) G__int(libp->para[0])), (Int_t) G__int(libp->para[1])
03829 , (Int_t) G__int(libp->para[2]));
03830 }
03831 break;
03832 case 2:
03833
03834 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03835 p = new TSocket(*((TInetAddress*) G__int(libp->para[0])), (Int_t) G__int(libp->para[1]));
03836 } else {
03837 p = new((void*) gvp) TSocket(*((TInetAddress*) G__int(libp->para[0])), (Int_t) G__int(libp->para[1]));
03838 }
03839 break;
03840 }
03841 result7->obj.i = (long) p;
03842 result7->ref = (long) p;
03843 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__NetLN_TSocket));
03844 return(1 || funcname || hash || result7 || libp) ;
03845 }
03846
03847 static int G__G__Net_152_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03848 {
03849 TSocket* p = NULL;
03850 char* gvp = (char*) G__getgvp();
03851 switch (libp->paran) {
03852 case 3:
03853
03854 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03855 p = new TSocket(
03856 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
03857 , (Int_t) G__int(libp->para[2]));
03858 } else {
03859 p = new((void*) gvp) TSocket(
03860 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
03861 , (Int_t) G__int(libp->para[2]));
03862 }
03863 break;
03864 case 2:
03865
03866 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03867 p = new TSocket((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
03868 } else {
03869 p = new((void*) gvp) TSocket((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
03870 }
03871 break;
03872 }
03873 result7->obj.i = (long) p;
03874 result7->ref = (long) p;
03875 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__NetLN_TSocket));
03876 return(1 || funcname || hash || result7 || libp) ;
03877 }
03878
03879 static int G__G__Net_152_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03880 {
03881 TSocket* p = NULL;
03882 char* gvp = (char*) G__getgvp();
03883 switch (libp->paran) {
03884 case 3:
03885
03886 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03887 p = new TSocket(
03888 (const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
03889 , (Int_t) G__int(libp->para[2]));
03890 } else {
03891 p = new((void*) gvp) TSocket(
03892 (const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
03893 , (Int_t) G__int(libp->para[2]));
03894 }
03895 break;
03896 case 2:
03897
03898 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03899 p = new TSocket((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
03900 } else {
03901 p = new((void*) gvp) TSocket((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
03902 }
03903 break;
03904 }
03905 result7->obj.i = (long) p;
03906 result7->ref = (long) p;
03907 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__NetLN_TSocket));
03908 return(1 || funcname || hash || result7 || libp) ;
03909 }
03910
03911 static int G__G__Net_152_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03912 {
03913 TSocket* p = NULL;
03914 char* gvp = (char*) G__getgvp();
03915
03916 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03917 p = new TSocket((const char*) G__int(libp->para[0]));
03918 } else {
03919 p = new((void*) gvp) TSocket((const char*) G__int(libp->para[0]));
03920 }
03921 result7->obj.i = (long) p;
03922 result7->ref = (long) p;
03923 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__NetLN_TSocket));
03924 return(1 || funcname || hash || result7 || libp) ;
03925 }
03926
03927 static int G__G__Net_152_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03928 {
03929 TSocket* p = NULL;
03930 char* gvp = (char*) G__getgvp();
03931
03932 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03933 p = new TSocket((Int_t) G__int(libp->para[0]));
03934 } else {
03935 p = new((void*) gvp) TSocket((Int_t) G__int(libp->para[0]));
03936 }
03937 result7->obj.i = (long) p;
03938 result7->ref = (long) p;
03939 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__NetLN_TSocket));
03940 return(1 || funcname || hash || result7 || libp) ;
03941 }
03942
03943 static int G__G__Net_152_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03944 {
03945 TSocket* p = NULL;
03946 char* gvp = (char*) G__getgvp();
03947
03948 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03949 p = new TSocket((Int_t) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
03950 } else {
03951 p = new((void*) gvp) TSocket((Int_t) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
03952 }
03953 result7->obj.i = (long) p;
03954 result7->ref = (long) p;
03955 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__NetLN_TSocket));
03956 return(1 || funcname || hash || result7 || libp) ;
03957 }
03958
03959 static int G__G__Net_152_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03960 {
03961 TSocket* p = NULL;
03962 char* gvp = (char*) G__getgvp();
03963
03964 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03965 p = new TSocket(*(TSocket*) libp->para[0].ref);
03966 } else {
03967 p = new((void*) gvp) TSocket(*(TSocket*) libp->para[0].ref);
03968 }
03969 result7->obj.i = (long) p;
03970 result7->ref = (long) p;
03971 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__NetLN_TSocket));
03972 return(1 || funcname || hash || result7 || libp) ;
03973 }
03974
03975 static int G__G__Net_152_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03976 {
03977 switch (libp->paran) {
03978 case 1:
03979 ((TSocket*) G__getstructoffset())->Close((Option_t*) G__int(libp->para[0]));
03980 G__setnull(result7);
03981 break;
03982 case 0:
03983 ((TSocket*) G__getstructoffset())->Close();
03984 G__setnull(result7);
03985 break;
03986 }
03987 return(1 || funcname || hash || result7 || libp) ;
03988 }
03989
03990 static int G__G__Net_152_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03991 {
03992 G__letint(result7, 105, (long) ((const TSocket*) G__getstructoffset())->GetDescriptor());
03993 return(1 || funcname || hash || result7 || libp) ;
03994 }
03995
03996 static int G__G__Net_152_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03997 {
03998 {
03999 const TInetAddress* pobj;
04000 const TInetAddress xobj = ((const TSocket*) G__getstructoffset())->GetInetAddress();
04001 pobj = new TInetAddress(xobj);
04002 result7->obj.i = (long) ((void*) pobj);
04003 result7->ref = result7->obj.i;
04004 G__store_tempobject(*result7);
04005 }
04006 return(1 || funcname || hash || result7 || libp) ;
04007 }
04008
04009 static int G__G__Net_152_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04010 {
04011 {
04012 TInetAddress* pobj;
04013 TInetAddress xobj = ((TSocket*) G__getstructoffset())->GetLocalInetAddress();
04014 pobj = new TInetAddress(xobj);
04015 result7->obj.i = (long) ((void*) pobj);
04016 result7->ref = result7->obj.i;
04017 G__store_tempobject(*result7);
04018 }
04019 return(1 || funcname || hash || result7 || libp) ;
04020 }
04021
04022 static int G__G__Net_152_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04023 {
04024 G__letint(result7, 105, (long) ((const TSocket*) G__getstructoffset())->GetPort());
04025 return(1 || funcname || hash || result7 || libp) ;
04026 }
04027
04028 static int G__G__Net_152_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04029 {
04030 G__letint(result7, 67, (long) ((const TSocket*) G__getstructoffset())->GetService());
04031 return(1 || funcname || hash || result7 || libp) ;
04032 }
04033
04034 static int G__G__Net_152_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04035 {
04036 G__letint(result7, 105, (long) ((const TSocket*) G__getstructoffset())->GetServType());
04037 return(1 || funcname || hash || result7 || libp) ;
04038 }
04039
04040 static int G__G__Net_152_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04041 {
04042 G__letint(result7, 105, (long) ((TSocket*) G__getstructoffset())->GetLocalPort());
04043 return(1 || funcname || hash || result7 || libp) ;
04044 }
04045
04046 static int G__G__Net_152_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04047 {
04048 G__letint(result7, 104, (long) ((const TSocket*) G__getstructoffset())->GetBytesSent());
04049 return(1 || funcname || hash || result7 || libp) ;
04050 }
04051
04052 static int G__G__Net_152_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04053 {
04054 G__letint(result7, 104, (long) ((const TSocket*) G__getstructoffset())->GetBytesRecv());
04055 return(1 || funcname || hash || result7 || libp) ;
04056 }
04057
04058 static int G__G__Net_152_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04059 {
04060 G__letint(result7, 105, (long) ((const TSocket*) G__getstructoffset())->GetCompressionLevel());
04061 return(1 || funcname || hash || result7 || libp) ;
04062 }
04063
04064 static int G__G__Net_152_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04065 {
04066 G__letint(result7, 105, (long) ((const TSocket*) G__getstructoffset())->GetErrorCode());
04067 return(1 || funcname || hash || result7 || libp) ;
04068 }
04069
04070 static int G__G__Net_152_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04071 {
04072 G__letint(result7, 105, (long) ((TSocket*) G__getstructoffset())->GetOption((ESockOptions) G__int(libp->para[0]), *(Int_t*) G__Intref(&libp->para[1])));
04073 return(1 || funcname || hash || result7 || libp) ;
04074 }
04075
04076 static int G__G__Net_152_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04077 {
04078 G__letint(result7, 105, (long) ((const TSocket*) G__getstructoffset())->GetRemoteProtocol());
04079 return(1 || funcname || hash || result7 || libp) ;
04080 }
04081
04082 static int G__G__Net_152_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04083 {
04084 G__letint(result7, 85, (long) ((const TSocket*) G__getstructoffset())->GetSecContext());
04085 return(1 || funcname || hash || result7 || libp) ;
04086 }
04087
04088 static int G__G__Net_152_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04089 {
04090 G__letint(result7, 105, (long) ((const TSocket*) G__getstructoffset())->GetTcpWindowSize());
04091 return(1 || funcname || hash || result7 || libp) ;
04092 }
04093
04094 static int G__G__Net_152_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04095 {
04096 {
04097 TTimeStamp* pobj;
04098 TTimeStamp xobj = ((TSocket*) G__getstructoffset())->GetLastUsage();
04099 pobj = new TTimeStamp(xobj);
04100 result7->obj.i = (long) ((void*) pobj);
04101 result7->ref = result7->obj.i;
04102 G__store_tempobject(*result7);
04103 }
04104 return(1 || funcname || hash || result7 || libp) ;
04105 }
04106
04107 static int G__G__Net_152_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04108 {
04109 G__letint(result7, 67, (long) ((const TSocket*) G__getstructoffset())->GetUrl());
04110 return(1 || funcname || hash || result7 || libp) ;
04111 }
04112
04113 static int G__G__Net_152_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04114 {
04115 G__letint(result7, 103, (long) ((const TSocket*) G__getstructoffset())->IsAuthenticated());
04116 return(1 || funcname || hash || result7 || libp) ;
04117 }
04118
04119 static int G__G__Net_152_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04120 {
04121 G__letint(result7, 103, (long) ((const TSocket*) G__getstructoffset())->IsValid());
04122 return(1 || funcname || hash || result7 || libp) ;
04123 }
04124
04125 static int G__G__Net_152_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04126 {
04127 G__letint(result7, 105, (long) ((TSocket*) G__getstructoffset())->Recv(libp->para[0].ref ? *(TMessage**) libp->para[0].ref : *(TMessage**) (void*) (&G__Mlong(libp->para[0]))));
04128 return(1 || funcname || hash || result7 || libp) ;
04129 }
04130
04131 static int G__G__Net_152_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04132 {
04133 G__letint(result7, 105, (long) ((TSocket*) G__getstructoffset())->Recv(*(Int_t*) G__Intref(&libp->para[0]), *(Int_t*) G__Intref(&libp->para[1])));
04134 return(1 || funcname || hash || result7 || libp) ;
04135 }
04136
04137 static int G__G__Net_152_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04138 {
04139 G__letint(result7, 105, (long) ((TSocket*) G__getstructoffset())->Recv((char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
04140 return(1 || funcname || hash || result7 || libp) ;
04141 }
04142
04143 static int G__G__Net_152_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04144 {
04145 G__letint(result7, 105, (long) ((TSocket*) G__getstructoffset())->Recv((char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
04146 , *(Int_t*) G__Intref(&libp->para[2])));
04147 return(1 || funcname || hash || result7 || libp) ;
04148 }
04149
04150 static int G__G__Net_152_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04151 {
04152 switch (libp->paran) {
04153 case 3:
04154 G__letint(result7, 105, (long) ((TSocket*) G__getstructoffset())->RecvRaw((void*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
04155 , (ESendRecvOptions) G__int(libp->para[2])));
04156 break;
04157 case 2:
04158 G__letint(result7, 105, (long) ((TSocket*) G__getstructoffset())->RecvRaw((void*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
04159 break;
04160 }
04161 return(1 || funcname || hash || result7 || libp) ;
04162 }
04163
04164 static int G__G__Net_152_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04165 {
04166 G__letint(result7, 105, (long) ((TSocket*) G__getstructoffset())->Reconnect());
04167 return(1 || funcname || hash || result7 || libp) ;
04168 }
04169
04170 static int G__G__Net_152_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04171 {
04172 switch (libp->paran) {
04173 case 2:
04174 G__letint(result7, 105, (long) ((TSocket*) G__getstructoffset())->Select((Int_t) G__int(libp->para[0]), (Long_t) G__int(libp->para[1])));
04175 break;
04176 case 1:
04177 G__letint(result7, 105, (long) ((TSocket*) G__getstructoffset())->Select((Int_t) G__int(libp->para[0])));
04178 break;
04179 case 0:
04180 G__letint(result7, 105, (long) ((TSocket*) G__getstructoffset())->Select());
04181 break;
04182 }
04183 return(1 || funcname || hash || result7 || libp) ;
04184 }
04185
04186 static int G__G__Net_152_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04187 {
04188 G__letint(result7, 105, (long) ((TSocket*) G__getstructoffset())->Send(*(TMessage*) libp->para[0].ref));
04189 return(1 || funcname || hash || result7 || libp) ;
04190 }
04191
04192 static int G__G__Net_152_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04193 {
04194 G__letint(result7, 105, (long) ((TSocket*) G__getstructoffset())->Send((Int_t) G__int(libp->para[0])));
04195 return(1 || funcname || hash || result7 || libp) ;
04196 }
04197
04198 static int G__G__Net_152_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04199 {
04200 G__letint(result7, 105, (long) ((TSocket*) G__getstructoffset())->Send((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
04201 return(1 || funcname || hash || result7 || libp) ;
04202 }
04203
04204 static int G__G__Net_152_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04205 {
04206 switch (libp->paran) {
04207 case 2:
04208 G__letint(result7, 105, (long) ((TSocket*) G__getstructoffset())->Send((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
04209 break;
04210 case 1:
04211 G__letint(result7, 105, (long) ((TSocket*) G__getstructoffset())->Send((const char*) G__int(libp->para[0])));
04212 break;
04213 }
04214 return(1 || funcname || hash || result7 || libp) ;
04215 }
04216
04217 static int G__G__Net_152_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04218 {
04219 switch (libp->paran) {
04220 case 2:
04221 G__letint(result7, 105, (long) ((TSocket*) G__getstructoffset())->SendObject((TObject*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
04222 break;
04223 case 1:
04224 G__letint(result7, 105, (long) ((TSocket*) G__getstructoffset())->SendObject((TObject*) G__int(libp->para[0])));
04225 break;
04226 }
04227 return(1 || funcname || hash || result7 || libp) ;
04228 }
04229
04230 static int G__G__Net_152_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04231 {
04232 switch (libp->paran) {
04233 case 3:
04234 G__letint(result7, 105, (long) ((TSocket*) G__getstructoffset())->SendRaw((void*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
04235 , (ESendRecvOptions) G__int(libp->para[2])));
04236 break;
04237 case 2:
04238 G__letint(result7, 105, (long) ((TSocket*) G__getstructoffset())->SendRaw((void*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
04239 break;
04240 }
04241 return(1 || funcname || hash || result7 || libp) ;
04242 }
04243
04244 static int G__G__Net_152_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04245 {
04246 switch (libp->paran) {
04247 case 1:
04248 ((TSocket*) G__getstructoffset())->SetCompressionLevel((Int_t) G__int(libp->para[0]));
04249 G__setnull(result7);
04250 break;
04251 case 0:
04252 ((TSocket*) G__getstructoffset())->SetCompressionLevel();
04253 G__setnull(result7);
04254 break;
04255 }
04256 return(1 || funcname || hash || result7 || libp) ;
04257 }
04258
04259 static int G__G__Net_152_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04260 {
04261 G__letint(result7, 105, (long) ((TSocket*) G__getstructoffset())->SetOption((ESockOptions) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
04262 return(1 || funcname || hash || result7 || libp) ;
04263 }
04264
04265 static int G__G__Net_152_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04266 {
04267 ((TSocket*) G__getstructoffset())->SetRemoteProtocol((Int_t) G__int(libp->para[0]));
04268 G__setnull(result7);
04269 return(1 || funcname || hash || result7 || libp) ;
04270 }
04271
04272 static int G__G__Net_152_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04273 {
04274 ((TSocket*) G__getstructoffset())->SetSecContext((TSecContext*) G__int(libp->para[0]));
04275 G__setnull(result7);
04276 return(1 || funcname || hash || result7 || libp) ;
04277 }
04278
04279 static int G__G__Net_152_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04280 {
04281 ((TSocket*) G__getstructoffset())->SetService((const char*) G__int(libp->para[0]));
04282 G__setnull(result7);
04283 return(1 || funcname || hash || result7 || libp) ;
04284 }
04285
04286 static int G__G__Net_152_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04287 {
04288 ((TSocket*) G__getstructoffset())->SetServType((Int_t) G__int(libp->para[0]));
04289 G__setnull(result7);
04290 return(1 || funcname || hash || result7 || libp) ;
04291 }
04292
04293 static int G__G__Net_152_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04294 {
04295 ((TSocket*) G__getstructoffset())->SetUrl((const char*) G__int(libp->para[0]));
04296 G__setnull(result7);
04297 return(1 || funcname || hash || result7 || libp) ;
04298 }
04299
04300 static int G__G__Net_152_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04301 {
04302 ((TSocket*) G__getstructoffset())->Touch();
04303 G__setnull(result7);
04304 return(1 || funcname || hash || result7 || libp) ;
04305 }
04306
04307 static int G__G__Net_152_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04308 {
04309 G__letint(result7, 105, (long) TSocket::GetClientProtocol());
04310 return(1 || funcname || hash || result7 || libp) ;
04311 }
04312
04313 static int G__G__Net_152_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04314 {
04315 G__letULonglong(result7, 109, (G__uint64) TSocket::GetSocketBytesSent());
04316 return(1 || funcname || hash || result7 || libp) ;
04317 }
04318
04319 static int G__G__Net_152_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04320 {
04321 G__letULonglong(result7, 109, (G__uint64) TSocket::GetSocketBytesRecv());
04322 return(1 || funcname || hash || result7 || libp) ;
04323 }
04324
04325 static int G__G__Net_152_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04326 {
04327 switch (libp->paran) {
04328 case 6:
04329 G__letint(result7, 85, (long) TSocket::CreateAuthSocket((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
04330 , (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
04331 , (Int_t) G__int(libp->para[4]), (TSocket*) G__int(libp->para[5])));
04332 break;
04333 case 5:
04334 G__letint(result7, 85, (long) TSocket::CreateAuthSocket((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
04335 , (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
04336 , (Int_t) G__int(libp->para[4])));
04337 break;
04338 case 4:
04339 G__letint(result7, 85, (long) TSocket::CreateAuthSocket((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
04340 , (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])));
04341 break;
04342 case 3:
04343 G__letint(result7, 85, (long) TSocket::CreateAuthSocket((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
04344 , (Int_t) G__int(libp->para[2])));
04345 break;
04346 }
04347 return(1 || funcname || hash || result7 || libp) ;
04348 }
04349
04350 static int G__G__Net_152_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04351 {
04352 switch (libp->paran) {
04353 case 4:
04354 G__letint(result7, 85, (long) TSocket::CreateAuthSocket((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
04355 , (Int_t) G__int(libp->para[2]), (TSocket*) G__int(libp->para[3])));
04356 break;
04357 case 3:
04358 G__letint(result7, 85, (long) TSocket::CreateAuthSocket((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
04359 , (Int_t) G__int(libp->para[2])));
04360 break;
04361 case 2:
04362 G__letint(result7, 85, (long) TSocket::CreateAuthSocket((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
04363 break;
04364 case 1:
04365 G__letint(result7, 85, (long) TSocket::CreateAuthSocket((const char*) G__int(libp->para[0])));
04366 break;
04367 }
04368 return(1 || funcname || hash || result7 || libp) ;
04369 }
04370
04371 static int G__G__Net_152_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04372 {
04373 TSocket::NetError((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
04374 G__setnull(result7);
04375 return(1 || funcname || hash || result7 || libp) ;
04376 }
04377
04378 static int G__G__Net_152_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04379 {
04380 G__letint(result7, 85, (long) TSocket::Class());
04381 return(1 || funcname || hash || result7 || libp) ;
04382 }
04383
04384 static int G__G__Net_152_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04385 {
04386 G__letint(result7, 67, (long) TSocket::Class_Name());
04387 return(1 || funcname || hash || result7 || libp) ;
04388 }
04389
04390 static int G__G__Net_152_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04391 {
04392 G__letint(result7, 115, (long) TSocket::Class_Version());
04393 return(1 || funcname || hash || result7 || libp) ;
04394 }
04395
04396 static int G__G__Net_152_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04397 {
04398 TSocket::Dictionary();
04399 G__setnull(result7);
04400 return(1 || funcname || hash || result7 || libp) ;
04401 }
04402
04403 static int G__G__Net_152_0_72(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04404 {
04405 ((TSocket*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
04406 G__setnull(result7);
04407 return(1 || funcname || hash || result7 || libp) ;
04408 }
04409
04410 static int G__G__Net_152_0_73(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04411 {
04412 G__letint(result7, 67, (long) TSocket::DeclFileName());
04413 return(1 || funcname || hash || result7 || libp) ;
04414 }
04415
04416 static int G__G__Net_152_0_74(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04417 {
04418 G__letint(result7, 105, (long) TSocket::ImplFileLine());
04419 return(1 || funcname || hash || result7 || libp) ;
04420 }
04421
04422 static int G__G__Net_152_0_75(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04423 {
04424 G__letint(result7, 67, (long) TSocket::ImplFileName());
04425 return(1 || funcname || hash || result7 || libp) ;
04426 }
04427
04428 static int G__G__Net_152_0_76(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04429 {
04430 G__letint(result7, 105, (long) TSocket::DeclFileLine());
04431 return(1 || funcname || hash || result7 || libp) ;
04432 }
04433
04434
04435 typedef TSocket G__TTSocket;
04436 static int G__G__Net_152_0_77(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04437 {
04438 char* gvp = (char*) G__getgvp();
04439 long soff = G__getstructoffset();
04440 int n = G__getaryconstruct();
04441
04442
04443
04444
04445
04446 if (!soff) {
04447 return(1);
04448 }
04449 if (n) {
04450 if (gvp == (char*)G__PVOID) {
04451 delete[] (TSocket*) soff;
04452 } else {
04453 G__setgvp((long) G__PVOID);
04454 for (int i = n - 1; i >= 0; --i) {
04455 ((TSocket*) (soff+(sizeof(TSocket)*i)))->~G__TTSocket();
04456 }
04457 G__setgvp((long)gvp);
04458 }
04459 } else {
04460 if (gvp == (char*)G__PVOID) {
04461 delete (TSocket*) soff;
04462 } else {
04463 G__setgvp((long) G__PVOID);
04464 ((TSocket*) (soff))->~G__TTSocket();
04465 G__setgvp((long)gvp);
04466 }
04467 }
04468 G__setnull(result7);
04469 return(1 || funcname || hash || result7 || libp) ;
04470 }
04471
04472
04473
04474 static int G__G__Net_153_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04475 {
04476 TPSocket* p = NULL;
04477 char* gvp = (char*) G__getgvp();
04478 switch (libp->paran) {
04479 case 4:
04480
04481 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04482 p = new TPSocket(
04483 *((TInetAddress*) G__int(libp->para[0])), (const char*) G__int(libp->para[1])
04484 , (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
04485 } else {
04486 p = new((void*) gvp) TPSocket(
04487 *((TInetAddress*) G__int(libp->para[0])), (const char*) G__int(libp->para[1])
04488 , (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
04489 }
04490 break;
04491 case 3:
04492
04493 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04494 p = new TPSocket(
04495 *((TInetAddress*) G__int(libp->para[0])), (const char*) G__int(libp->para[1])
04496 , (Int_t) G__int(libp->para[2]));
04497 } else {
04498 p = new((void*) gvp) TPSocket(
04499 *((TInetAddress*) G__int(libp->para[0])), (const char*) G__int(libp->para[1])
04500 , (Int_t) G__int(libp->para[2]));
04501 }
04502 break;
04503 }
04504 result7->obj.i = (long) p;
04505 result7->ref = (long) p;
04506 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__NetLN_TPSocket));
04507 return(1 || funcname || hash || result7 || libp) ;
04508 }
04509
04510 static int G__G__Net_153_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04511 {
04512 TPSocket* p = NULL;
04513 char* gvp = (char*) G__getgvp();
04514 switch (libp->paran) {
04515 case 4:
04516
04517 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04518 p = new TPSocket(
04519 *((TInetAddress*) G__int(libp->para[0])), (Int_t) G__int(libp->para[1])
04520 , (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
04521 } else {
04522 p = new((void*) gvp) TPSocket(
04523 *((TInetAddress*) G__int(libp->para[0])), (Int_t) G__int(libp->para[1])
04524 , (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
04525 }
04526 break;
04527 case 3:
04528
04529 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04530 p = new TPSocket(
04531 *((TInetAddress*) G__int(libp->para[0])), (Int_t) G__int(libp->para[1])
04532 , (Int_t) G__int(libp->para[2]));
04533 } else {
04534 p = new((void*) gvp) TPSocket(
04535 *((TInetAddress*) G__int(libp->para[0])), (Int_t) G__int(libp->para[1])
04536 , (Int_t) G__int(libp->para[2]));
04537 }
04538 break;
04539 }
04540 result7->obj.i = (long) p;
04541 result7->ref = (long) p;
04542 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__NetLN_TPSocket));
04543 return(1 || funcname || hash || result7 || libp) ;
04544 }
04545
04546 static int G__G__Net_153_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04547 {
04548 TPSocket* p = NULL;
04549 char* gvp = (char*) G__getgvp();
04550 switch (libp->paran) {
04551 case 4:
04552
04553 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04554 p = new TPSocket(
04555 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
04556 , (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
04557 } else {
04558 p = new((void*) gvp) TPSocket(
04559 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
04560 , (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
04561 }
04562 break;
04563 case 3:
04564
04565 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04566 p = new TPSocket(
04567 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
04568 , (Int_t) G__int(libp->para[2]));
04569 } else {
04570 p = new((void*) gvp) TPSocket(
04571 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
04572 , (Int_t) G__int(libp->para[2]));
04573 }
04574 break;
04575 }
04576 result7->obj.i = (long) p;
04577 result7->ref = (long) p;
04578 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__NetLN_TPSocket));
04579 return(1 || funcname || hash || result7 || libp) ;
04580 }
04581
04582 static int G__G__Net_153_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04583 {
04584 TPSocket* p = NULL;
04585 char* gvp = (char*) G__getgvp();
04586 switch (libp->paran) {
04587 case 4:
04588
04589 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04590 p = new TPSocket(
04591 (const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
04592 , (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
04593 } else {
04594 p = new((void*) gvp) TPSocket(
04595 (const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
04596 , (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
04597 }
04598 break;
04599 case 3:
04600
04601 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04602 p = new TPSocket(
04603 (const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
04604 , (Int_t) G__int(libp->para[2]));
04605 } else {
04606 p = new((void*) gvp) TPSocket(
04607 (const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
04608 , (Int_t) G__int(libp->para[2]));
04609 }
04610 break;
04611 }
04612 result7->obj.i = (long) p;
04613 result7->ref = (long) p;
04614 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__NetLN_TPSocket));
04615 return(1 || funcname || hash || result7 || libp) ;
04616 }
04617
04618 static int G__G__Net_153_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04619 {
04620 TPSocket* p = NULL;
04621 char* gvp = (char*) G__getgvp();
04622
04623 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04624 p = new TPSocket(
04625 (const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
04626 , (Int_t) G__int(libp->para[2]), (TSocket*) G__int(libp->para[3]));
04627 } else {
04628 p = new((void*) gvp) TPSocket(
04629 (const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
04630 , (Int_t) G__int(libp->para[2]), (TSocket*) G__int(libp->para[3]));
04631 }
04632 result7->obj.i = (long) p;
04633 result7->ref = (long) p;
04634 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__NetLN_TPSocket));
04635 return(1 || funcname || hash || result7 || libp) ;
04636 }
04637
04638 static int G__G__Net_153_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04639 {
04640 G__letint(result7, 105, (long) ((const TPSocket*) G__getstructoffset())->GetErrorCode());
04641 return(1 || funcname || hash || result7 || libp) ;
04642 }
04643
04644 static int G__G__Net_153_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04645 {
04646 G__letint(result7, 105, (long) ((const TPSocket*) G__getstructoffset())->GetSize());
04647 return(1 || funcname || hash || result7 || libp) ;
04648 }
04649
04650 static int G__G__Net_153_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04651 {
04652 G__letint(result7, 85, (long) TPSocket::Class());
04653 return(1 || funcname || hash || result7 || libp) ;
04654 }
04655
04656 static int G__G__Net_153_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04657 {
04658 G__letint(result7, 67, (long) TPSocket::Class_Name());
04659 return(1 || funcname || hash || result7 || libp) ;
04660 }
04661
04662 static int G__G__Net_153_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04663 {
04664 G__letint(result7, 115, (long) TPSocket::Class_Version());
04665 return(1 || funcname || hash || result7 || libp) ;
04666 }
04667
04668 static int G__G__Net_153_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04669 {
04670 TPSocket::Dictionary();
04671 G__setnull(result7);
04672 return(1 || funcname || hash || result7 || libp) ;
04673 }
04674
04675 static int G__G__Net_153_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04676 {
04677 ((TPSocket*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
04678 G__setnull(result7);
04679 return(1 || funcname || hash || result7 || libp) ;
04680 }
04681
04682 static int G__G__Net_153_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04683 {
04684 G__letint(result7, 67, (long) TPSocket::DeclFileName());
04685 return(1 || funcname || hash || result7 || libp) ;
04686 }
04687
04688 static int G__G__Net_153_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04689 {
04690 G__letint(result7, 105, (long) TPSocket::ImplFileLine());
04691 return(1 || funcname || hash || result7 || libp) ;
04692 }
04693
04694 static int G__G__Net_153_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04695 {
04696 G__letint(result7, 67, (long) TPSocket::ImplFileName());
04697 return(1 || funcname || hash || result7 || libp) ;
04698 }
04699
04700 static int G__G__Net_153_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04701 {
04702 G__letint(result7, 105, (long) TPSocket::DeclFileLine());
04703 return(1 || funcname || hash || result7 || libp) ;
04704 }
04705
04706
04707 typedef TPSocket G__TTPSocket;
04708 static int G__G__Net_153_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04709 {
04710 char* gvp = (char*) G__getgvp();
04711 long soff = G__getstructoffset();
04712 int n = G__getaryconstruct();
04713
04714
04715
04716
04717
04718 if (!soff) {
04719 return(1);
04720 }
04721 if (n) {
04722 if (gvp == (char*)G__PVOID) {
04723 delete[] (TPSocket*) soff;
04724 } else {
04725 G__setgvp((long) G__PVOID);
04726 for (int i = n - 1; i >= 0; --i) {
04727 ((TPSocket*) (soff+(sizeof(TPSocket)*i)))->~G__TTPSocket();
04728 }
04729 G__setgvp((long)gvp);
04730 }
04731 } else {
04732 if (gvp == (char*)G__PVOID) {
04733 delete (TPSocket*) soff;
04734 } else {
04735 G__setgvp((long) G__PVOID);
04736 ((TPSocket*) (soff))->~G__TTPSocket();
04737 G__setgvp((long)gvp);
04738 }
04739 }
04740 G__setnull(result7);
04741 return(1 || funcname || hash || result7 || libp) ;
04742 }
04743
04744
04745
04746 static int G__G__Net_162_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04747 {
04748 TMonitor* p = NULL;
04749 char* gvp = (char*) G__getgvp();
04750 switch (libp->paran) {
04751 case 1:
04752
04753 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04754 p = new TMonitor((Bool_t) G__int(libp->para[0]));
04755 } else {
04756 p = new((void*) gvp) TMonitor((Bool_t) G__int(libp->para[0]));
04757 }
04758 break;
04759 case 0:
04760 int n = G__getaryconstruct();
04761 if (n) {
04762 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04763 p = new TMonitor[n];
04764 } else {
04765 p = new((void*) gvp) TMonitor[n];
04766 }
04767 } else {
04768 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04769 p = new TMonitor;
04770 } else {
04771 p = new((void*) gvp) TMonitor;
04772 }
04773 }
04774 break;
04775 }
04776 result7->obj.i = (long) p;
04777 result7->ref = (long) p;
04778 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__NetLN_TMonitor));
04779 return(1 || funcname || hash || result7 || libp) ;
04780 }
04781
04782 static int G__G__Net_162_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04783 {
04784 TMonitor* p = NULL;
04785 char* gvp = (char*) G__getgvp();
04786
04787 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04788 p = new TMonitor(*(TMonitor*) libp->para[0].ref);
04789 } else {
04790 p = new((void*) gvp) TMonitor(*(TMonitor*) libp->para[0].ref);
04791 }
04792 result7->obj.i = (long) p;
04793 result7->ref = (long) p;
04794 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__NetLN_TMonitor));
04795 return(1 || funcname || hash || result7 || libp) ;
04796 }
04797
04798 static int G__G__Net_162_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04799 {
04800 switch (libp->paran) {
04801 case 2:
04802 ((TMonitor*) G__getstructoffset())->Add((TSocket*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
04803 G__setnull(result7);
04804 break;
04805 case 1:
04806 ((TMonitor*) G__getstructoffset())->Add((TSocket*) G__int(libp->para[0]));
04807 G__setnull(result7);
04808 break;
04809 }
04810 return(1 || funcname || hash || result7 || libp) ;
04811 }
04812
04813 static int G__G__Net_162_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04814 {
04815 switch (libp->paran) {
04816 case 2:
04817 ((TMonitor*) G__getstructoffset())->SetInterest((TSocket*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
04818 G__setnull(result7);
04819 break;
04820 case 1:
04821 ((TMonitor*) G__getstructoffset())->SetInterest((TSocket*) G__int(libp->para[0]));
04822 G__setnull(result7);
04823 break;
04824 }
04825 return(1 || funcname || hash || result7 || libp) ;
04826 }
04827
04828 static int G__G__Net_162_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04829 {
04830 ((TMonitor*) G__getstructoffset())->Remove((TSocket*) G__int(libp->para[0]));
04831 G__setnull(result7);
04832 return(1 || funcname || hash || result7 || libp) ;
04833 }
04834
04835 static int G__G__Net_162_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04836 {
04837 ((TMonitor*) G__getstructoffset())->RemoveAll();
04838 G__setnull(result7);
04839 return(1 || funcname || hash || result7 || libp) ;
04840 }
04841
04842 static int G__G__Net_162_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04843 {
04844 ((TMonitor*) G__getstructoffset())->Activate((TSocket*) G__int(libp->para[0]));
04845 G__setnull(result7);
04846 return(1 || funcname || hash || result7 || libp) ;
04847 }
04848
04849 static int G__G__Net_162_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04850 {
04851 ((TMonitor*) G__getstructoffset())->ActivateAll();
04852 G__setnull(result7);
04853 return(1 || funcname || hash || result7 || libp) ;
04854 }
04855
04856 static int G__G__Net_162_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04857 {
04858 ((TMonitor*) G__getstructoffset())->DeActivate((TSocket*) G__int(libp->para[0]));
04859 G__setnull(result7);
04860 return(1 || funcname || hash || result7 || libp) ;
04861 }
04862
04863 static int G__G__Net_162_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04864 {
04865 ((TMonitor*) G__getstructoffset())->DeActivateAll();
04866 G__setnull(result7);
04867 return(1 || funcname || hash || result7 || libp) ;
04868 }
04869
04870 static int G__G__Net_162_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04871 {
04872 ((TMonitor*) G__getstructoffset())->Ready((TSocket*) G__int(libp->para[0]));
04873 G__setnull(result7);
04874 return(1 || funcname || hash || result7 || libp) ;
04875 }
04876
04877 static int G__G__Net_162_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04878 {
04879 ((TMonitor*) G__getstructoffset())->Interrupt();
04880 G__setnull(result7);
04881 return(1 || funcname || hash || result7 || libp) ;
04882 }
04883
04884 static int G__G__Net_162_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04885 {
04886 ((TMonitor*) G__getstructoffset())->ResetInterrupt();
04887 G__setnull(result7);
04888 return(1 || funcname || hash || result7 || libp) ;
04889 }
04890
04891 static int G__G__Net_162_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04892 {
04893 G__letint(result7, 85, (long) ((TMonitor*) G__getstructoffset())->Select());
04894 return(1 || funcname || hash || result7 || libp) ;
04895 }
04896
04897 static int G__G__Net_162_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04898 {
04899 G__letint(result7, 85, (long) ((TMonitor*) G__getstructoffset())->Select((Long_t) G__int(libp->para[0])));
04900 return(1 || funcname || hash || result7 || libp) ;
04901 }
04902
04903 static int G__G__Net_162_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04904 {
04905 G__letint(result7, 105, (long) ((TMonitor*) G__getstructoffset())->Select((TList*) G__int(libp->para[0]), (TList*) G__int(libp->para[1])
04906 , (Long_t) G__int(libp->para[2])));
04907 return(1 || funcname || hash || result7 || libp) ;
04908 }
04909
04910 static int G__G__Net_162_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04911 {
04912 switch (libp->paran) {
04913 case 1:
04914 G__letint(result7, 105, (long) ((const TMonitor*) G__getstructoffset())->GetActive((Long_t) G__int(libp->para[0])));
04915 break;
04916 case 0:
04917 G__letint(result7, 105, (long) ((const TMonitor*) G__getstructoffset())->GetActive());
04918 break;
04919 }
04920 return(1 || funcname || hash || result7 || libp) ;
04921 }
04922
04923 static int G__G__Net_162_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04924 {
04925 G__letint(result7, 105, (long) ((const TMonitor*) G__getstructoffset())->GetDeActive());
04926 return(1 || funcname || hash || result7 || libp) ;
04927 }
04928
04929 static int G__G__Net_162_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04930 {
04931 G__letint(result7, 85, (long) ((const TMonitor*) G__getstructoffset())->GetListOfActives());
04932 return(1 || funcname || hash || result7 || libp) ;
04933 }
04934
04935 static int G__G__Net_162_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04936 {
04937 G__letint(result7, 85, (long) ((const TMonitor*) G__getstructoffset())->GetListOfDeActives());
04938 return(1 || funcname || hash || result7 || libp) ;
04939 }
04940
04941 static int G__G__Net_162_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04942 {
04943 G__letint(result7, 103, (long) ((const TMonitor*) G__getstructoffset())->IsActive((TSocket*) G__int(libp->para[0])));
04944 return(1 || funcname || hash || result7 || libp) ;
04945 }
04946
04947 static int G__G__Net_162_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04948 {
04949 G__letint(result7, 85, (long) TMonitor::Class());
04950 return(1 || funcname || hash || result7 || libp) ;
04951 }
04952
04953 static int G__G__Net_162_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04954 {
04955 G__letint(result7, 67, (long) TMonitor::Class_Name());
04956 return(1 || funcname || hash || result7 || libp) ;
04957 }
04958
04959 static int G__G__Net_162_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04960 {
04961 G__letint(result7, 115, (long) TMonitor::Class_Version());
04962 return(1 || funcname || hash || result7 || libp) ;
04963 }
04964
04965 static int G__G__Net_162_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04966 {
04967 TMonitor::Dictionary();
04968 G__setnull(result7);
04969 return(1 || funcname || hash || result7 || libp) ;
04970 }
04971
04972 static int G__G__Net_162_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04973 {
04974 ((TMonitor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
04975 G__setnull(result7);
04976 return(1 || funcname || hash || result7 || libp) ;
04977 }
04978
04979 static int G__G__Net_162_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04980 {
04981 G__letint(result7, 67, (long) TMonitor::DeclFileName());
04982 return(1 || funcname || hash || result7 || libp) ;
04983 }
04984
04985 static int G__G__Net_162_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04986 {
04987 G__letint(result7, 105, (long) TMonitor::ImplFileLine());
04988 return(1 || funcname || hash || result7 || libp) ;
04989 }
04990
04991 static int G__G__Net_162_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04992 {
04993 G__letint(result7, 67, (long) TMonitor::ImplFileName());
04994 return(1 || funcname || hash || result7 || libp) ;
04995 }
04996
04997 static int G__G__Net_162_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04998 {
04999 G__letint(result7, 105, (long) TMonitor::DeclFileLine());
05000 return(1 || funcname || hash || result7 || libp) ;
05001 }
05002
05003
05004 typedef TMonitor G__TTMonitor;
05005 static int G__G__Net_162_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05006 {
05007 char* gvp = (char*) G__getgvp();
05008 long soff = G__getstructoffset();
05009 int n = G__getaryconstruct();
05010
05011
05012
05013
05014
05015 if (!soff) {
05016 return(1);
05017 }
05018 if (n) {
05019 if (gvp == (char*)G__PVOID) {
05020 delete[] (TMonitor*) soff;
05021 } else {
05022 G__setgvp((long) G__PVOID);
05023 for (int i = n - 1; i >= 0; --i) {
05024 ((TMonitor*) (soff+(sizeof(TMonitor)*i)))->~G__TTMonitor();
05025 }
05026 G__setgvp((long)gvp);
05027 }
05028 } else {
05029 if (gvp == (char*)G__PVOID) {
05030 delete (TMonitor*) soff;
05031 } else {
05032 G__setgvp((long) G__PVOID);
05033 ((TMonitor*) (soff))->~G__TTMonitor();
05034 G__setgvp((long)gvp);
05035 }
05036 }
05037 G__setnull(result7);
05038 return(1 || funcname || hash || result7 || libp) ;
05039 }
05040
05041
05042
05043 static int G__G__Net_165_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05044 {
05045 TApplicationRemote* p = NULL;
05046 char* gvp = (char*) G__getgvp();
05047 switch (libp->paran) {
05048 case 3:
05049
05050 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05051 p = new TApplicationRemote(
05052 (const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
05053 , (const char*) G__int(libp->para[2]));
05054 } else {
05055 p = new((void*) gvp) TApplicationRemote(
05056 (const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
05057 , (const char*) G__int(libp->para[2]));
05058 }
05059 break;
05060 case 2:
05061
05062 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05063 p = new TApplicationRemote((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
05064 } else {
05065 p = new((void*) gvp) TApplicationRemote((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
05066 }
05067 break;
05068 case 1:
05069
05070 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05071 p = new TApplicationRemote((const char*) G__int(libp->para[0]));
05072 } else {
05073 p = new((void*) gvp) TApplicationRemote((const char*) G__int(libp->para[0]));
05074 }
05075 break;
05076 }
05077 result7->obj.i = (long) p;
05078 result7->ref = (long) p;
05079 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__NetLN_TApplicationRemote));
05080 return(1 || funcname || hash || result7 || libp) ;
05081 }
05082
05083 static int G__G__Net_165_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05084 {
05085 switch (libp->paran) {
05086 case 3:
05087 G__letint(result7, 105, (long) ((TApplicationRemote*) G__getstructoffset())->SendFile((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
05088 , (const char*) G__int(libp->para[2])));
05089 break;
05090 case 2:
05091 G__letint(result7, 105, (long) ((TApplicationRemote*) G__getstructoffset())->SendFile((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
05092 break;
05093 case 1:
05094 G__letint(result7, 105, (long) ((TApplicationRemote*) G__getstructoffset())->SendFile((const char*) G__int(libp->para[0])));
05095 break;
05096 }
05097 return(1 || funcname || hash || result7 || libp) ;
05098 }
05099
05100 static int G__G__Net_165_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05101 {
05102 G__letint(result7, 105, (long) ((TApplicationRemote*) G__getstructoffset())->SendObject((TObject*) G__int(libp->para[0])));
05103 return(1 || funcname || hash || result7 || libp) ;
05104 }
05105
05106 static int G__G__Net_165_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05107 {
05108 switch (libp->paran) {
05109 case 1:
05110 ((TApplicationRemote*) G__getstructoffset())->Interrupt((Int_t) G__int(libp->para[0]));
05111 G__setnull(result7);
05112 break;
05113 case 0:
05114 ((TApplicationRemote*) G__getstructoffset())->Interrupt();
05115 G__setnull(result7);
05116 break;
05117 }
05118 return(1 || funcname || hash || result7 || libp) ;
05119 }
05120
05121 static int G__G__Net_165_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05122 {
05123 G__letint(result7, 103, (long) ((const TApplicationRemote*) G__getstructoffset())->IsValid());
05124 return(1 || funcname || hash || result7 || libp) ;
05125 }
05126
05127 static int G__G__Net_165_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05128 {
05129 switch (libp->paran) {
05130 case 3:
05131 TApplicationRemote::SetPortParam((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
05132 , (Int_t) G__int(libp->para[2]));
05133 G__setnull(result7);
05134 break;
05135 case 2:
05136 TApplicationRemote::SetPortParam((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
05137 G__setnull(result7);
05138 break;
05139 case 1:
05140 TApplicationRemote::SetPortParam((Int_t) G__int(libp->para[0]));
05141 G__setnull(result7);
05142 break;
05143 case 0:
05144 TApplicationRemote::SetPortParam();
05145 G__setnull(result7);
05146 break;
05147 }
05148 return(1 || funcname || hash || result7 || libp) ;
05149 }
05150
05151 static int G__G__Net_165_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05152 {
05153 G__letint(result7, 85, (long) TApplicationRemote::Class());
05154 return(1 || funcname || hash || result7 || libp) ;
05155 }
05156
05157 static int G__G__Net_165_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05158 {
05159 G__letint(result7, 67, (long) TApplicationRemote::Class_Name());
05160 return(1 || funcname || hash || result7 || libp) ;
05161 }
05162
05163 static int G__G__Net_165_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05164 {
05165 G__letint(result7, 115, (long) TApplicationRemote::Class_Version());
05166 return(1 || funcname || hash || result7 || libp) ;
05167 }
05168
05169 static int G__G__Net_165_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05170 {
05171 TApplicationRemote::Dictionary();
05172 G__setnull(result7);
05173 return(1 || funcname || hash || result7 || libp) ;
05174 }
05175
05176 static int G__G__Net_165_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05177 {
05178 ((TApplicationRemote*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
05179 G__setnull(result7);
05180 return(1 || funcname || hash || result7 || libp) ;
05181 }
05182
05183 static int G__G__Net_165_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05184 {
05185 G__letint(result7, 67, (long) TApplicationRemote::DeclFileName());
05186 return(1 || funcname || hash || result7 || libp) ;
05187 }
05188
05189 static int G__G__Net_165_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05190 {
05191 G__letint(result7, 105, (long) TApplicationRemote::ImplFileLine());
05192 return(1 || funcname || hash || result7 || libp) ;
05193 }
05194
05195 static int G__G__Net_165_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05196 {
05197 G__letint(result7, 67, (long) TApplicationRemote::ImplFileName());
05198 return(1 || funcname || hash || result7 || libp) ;
05199 }
05200
05201 static int G__G__Net_165_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05202 {
05203 G__letint(result7, 105, (long) TApplicationRemote::DeclFileLine());
05204 return(1 || funcname || hash || result7 || libp) ;
05205 }
05206
05207
05208 typedef TApplicationRemote G__TTApplicationRemote;
05209 static int G__G__Net_165_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05210 {
05211 char* gvp = (char*) G__getgvp();
05212 long soff = G__getstructoffset();
05213 int n = G__getaryconstruct();
05214
05215
05216
05217
05218
05219 if (!soff) {
05220 return(1);
05221 }
05222 if (n) {
05223 if (gvp == (char*)G__PVOID) {
05224 delete[] (TApplicationRemote*) soff;
05225 } else {
05226 G__setgvp((long) G__PVOID);
05227 for (int i = n - 1; i >= 0; --i) {
05228 ((TApplicationRemote*) (soff+(sizeof(TApplicationRemote)*i)))->~G__TTApplicationRemote();
05229 }
05230 G__setgvp((long)gvp);
05231 }
05232 } else {
05233 if (gvp == (char*)G__PVOID) {
05234 delete (TApplicationRemote*) soff;
05235 } else {
05236 G__setgvp((long) G__PVOID);
05237 ((TApplicationRemote*) (soff))->~G__TTApplicationRemote();
05238 G__setgvp((long)gvp);
05239 }
05240 }
05241 G__setnull(result7);
05242 return(1 || funcname || hash || result7 || libp) ;
05243 }
05244
05245
05246
05247 static int G__G__Net_170_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05248 {
05249 TApplicationServer* p = NULL;
05250 char* gvp = (char*) G__getgvp();
05251
05252 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05253 p = new TApplicationServer(
05254 (Int_t*) G__int(libp->para[0]), (char**) G__int(libp->para[1])
05255 , (FILE*) G__int(libp->para[2]), (const char*) G__int(libp->para[3]));
05256 } else {
05257 p = new((void*) gvp) TApplicationServer(
05258 (Int_t*) G__int(libp->para[0]), (char**) G__int(libp->para[1])
05259 , (FILE*) G__int(libp->para[2]), (const char*) G__int(libp->para[3]));
05260 }
05261 result7->obj.i = (long) p;
05262 result7->ref = (long) p;
05263 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__NetLN_TApplicationServer));
05264 return(1 || funcname || hash || result7 || libp) ;
05265 }
05266
05267 static int G__G__Net_170_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05268 {
05269 G__letint(result7, 105, (long) ((const TApplicationServer*) G__getstructoffset())->GetProtocol());
05270 return(1 || funcname || hash || result7 || libp) ;
05271 }
05272
05273 static int G__G__Net_170_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05274 {
05275 G__letint(result7, 105, (long) ((const TApplicationServer*) G__getstructoffset())->GetPort());
05276 return(1 || funcname || hash || result7 || libp) ;
05277 }
05278
05279 static int G__G__Net_170_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05280 {
05281 G__letint(result7, 67, (long) ((const TApplicationServer*) G__getstructoffset())->GetUser());
05282 return(1 || funcname || hash || result7 || libp) ;
05283 }
05284
05285 static int G__G__Net_170_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05286 {
05287 G__letint(result7, 67, (long) ((const TApplicationServer*) G__getstructoffset())->GetHost());
05288 return(1 || funcname || hash || result7 || libp) ;
05289 }
05290
05291 static int G__G__Net_170_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05292 {
05293 G__letint(result7, 85, (long) ((const TApplicationServer*) G__getstructoffset())->GetSocket());
05294 return(1 || funcname || hash || result7 || libp) ;
05295 }
05296
05297 static int G__G__Net_170_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05298 {
05299 ((TApplicationServer*) G__getstructoffset())->HandleSocketInput();
05300 G__setnull(result7);
05301 return(1 || funcname || hash || result7 || libp) ;
05302 }
05303
05304 static int G__G__Net_170_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05305 {
05306 ((TApplicationServer*) G__getstructoffset())->HandleUrgentData();
05307 G__setnull(result7);
05308 return(1 || funcname || hash || result7 || libp) ;
05309 }
05310
05311 static int G__G__Net_170_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05312 {
05313 ((TApplicationServer*) G__getstructoffset())->HandleSigPipe();
05314 G__setnull(result7);
05315 return(1 || funcname || hash || result7 || libp) ;
05316 }
05317
05318 static int G__G__Net_170_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05319 {
05320 ((TApplicationServer*) G__getstructoffset())->Interrupt();
05321 G__setnull(result7);
05322 return(1 || funcname || hash || result7 || libp) ;
05323 }
05324
05325 static int G__G__Net_170_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05326 {
05327 G__letint(result7, 103, (long) ((const TApplicationServer*) G__getstructoffset())->IsValid());
05328 return(1 || funcname || hash || result7 || libp) ;
05329 }
05330
05331 static int G__G__Net_170_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05332 {
05333 ((TApplicationServer*) G__getstructoffset())->Reset((const char*) G__int(libp->para[0]));
05334 G__setnull(result7);
05335 return(1 || funcname || hash || result7 || libp) ;
05336 }
05337
05338 static int G__G__Net_170_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05339 {
05340 G__letint(result7, 105, (long) ((TApplicationServer*) G__getstructoffset())->ReceiveFile((const char*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])
05341 , (Long64_t) G__Longlong(libp->para[2])));
05342 return(1 || funcname || hash || result7 || libp) ;
05343 }
05344
05345 static int G__G__Net_170_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05346 {
05347 switch (libp->paran) {
05348 case 3:
05349 ((TApplicationServer*) G__getstructoffset())->SendLogFile((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
05350 , (Int_t) G__int(libp->para[2]));
05351 G__setnull(result7);
05352 break;
05353 case 2:
05354 ((TApplicationServer*) G__getstructoffset())->SendLogFile((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
05355 G__setnull(result7);
05356 break;
05357 case 1:
05358 ((TApplicationServer*) G__getstructoffset())->SendLogFile((Int_t) G__int(libp->para[0]));
05359 G__setnull(result7);
05360 break;
05361 case 0:
05362 ((TApplicationServer*) G__getstructoffset())->SendLogFile();
05363 G__setnull(result7);
05364 break;
05365 }
05366 return(1 || funcname || hash || result7 || libp) ;
05367 }
05368
05369 static int G__G__Net_170_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05370 {
05371 G__letint(result7, 105, (long) ((TApplicationServer*) G__getstructoffset())->BrowseDirectory((const char*) G__int(libp->para[0])));
05372 return(1 || funcname || hash || result7 || libp) ;
05373 }
05374
05375 static int G__G__Net_170_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05376 {
05377 G__letint(result7, 105, (long) ((TApplicationServer*) G__getstructoffset())->BrowseFile((const char*) G__int(libp->para[0])));
05378 return(1 || funcname || hash || result7 || libp) ;
05379 }
05380
05381 static int G__G__Net_170_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05382 {
05383 G__letint(result7, 105, (long) ((TApplicationServer*) G__getstructoffset())->BrowseKey((const char*) G__int(libp->para[0])));
05384 return(1 || funcname || hash || result7 || libp) ;
05385 }
05386
05387 static int G__G__Net_170_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05388 {
05389 G__letint(result7, 85, (long) TApplicationServer::Class());
05390 return(1 || funcname || hash || result7 || libp) ;
05391 }
05392
05393 static int G__G__Net_170_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05394 {
05395 G__letint(result7, 67, (long) TApplicationServer::Class_Name());
05396 return(1 || funcname || hash || result7 || libp) ;
05397 }
05398
05399 static int G__G__Net_170_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05400 {
05401 G__letint(result7, 115, (long) TApplicationServer::Class_Version());
05402 return(1 || funcname || hash || result7 || libp) ;
05403 }
05404
05405 static int G__G__Net_170_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05406 {
05407 TApplicationServer::Dictionary();
05408 G__setnull(result7);
05409 return(1 || funcname || hash || result7 || libp) ;
05410 }
05411
05412 static int G__G__Net_170_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05413 {
05414 ((TApplicationServer*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
05415 G__setnull(result7);
05416 return(1 || funcname || hash || result7 || libp) ;
05417 }
05418
05419 static int G__G__Net_170_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05420 {
05421 G__letint(result7, 67, (long) TApplicationServer::DeclFileName());
05422 return(1 || funcname || hash || result7 || libp) ;
05423 }
05424
05425 static int G__G__Net_170_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05426 {
05427 G__letint(result7, 105, (long) TApplicationServer::ImplFileLine());
05428 return(1 || funcname || hash || result7 || libp) ;
05429 }
05430
05431 static int G__G__Net_170_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05432 {
05433 G__letint(result7, 67, (long) TApplicationServer::ImplFileName());
05434 return(1 || funcname || hash || result7 || libp) ;
05435 }
05436
05437 static int G__G__Net_170_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05438 {
05439 G__letint(result7, 105, (long) TApplicationServer::DeclFileLine());
05440 return(1 || funcname || hash || result7 || libp) ;
05441 }
05442
05443
05444 typedef TApplicationServer G__TTApplicationServer;
05445 static int G__G__Net_170_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05446 {
05447 char* gvp = (char*) G__getgvp();
05448 long soff = G__getstructoffset();
05449 int n = G__getaryconstruct();
05450
05451
05452
05453
05454
05455 if (!soff) {
05456 return(1);
05457 }
05458 if (n) {
05459 if (gvp == (char*)G__PVOID) {
05460 delete[] (TApplicationServer*) soff;
05461 } else {
05462 G__setgvp((long) G__PVOID);
05463 for (int i = n - 1; i >= 0; --i) {
05464 ((TApplicationServer*) (soff+(sizeof(TApplicationServer)*i)))->~G__TTApplicationServer();
05465 }
05466 G__setgvp((long)gvp);
05467 }
05468 } else {
05469 if (gvp == (char*)G__PVOID) {
05470 delete (TApplicationServer*) soff;
05471 } else {
05472 G__setgvp((long) G__PVOID);
05473 ((TApplicationServer*) (soff))->~G__TTApplicationServer();
05474 G__setgvp((long)gvp);
05475 }
05476 }
05477 G__setnull(result7);
05478 return(1 || funcname || hash || result7 || libp) ;
05479 }
05480
05481
05482
05483 static int G__G__Net_174_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05484 {
05485 TFileStager* p = NULL;
05486 char* gvp = (char*) G__getgvp();
05487
05488 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05489 p = new TFileStager((const char*) G__int(libp->para[0]));
05490 } else {
05491 p = new((void*) gvp) TFileStager((const char*) G__int(libp->para[0]));
05492 }
05493 result7->obj.i = (long) p;
05494 result7->ref = (long) p;
05495 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__NetLN_TFileStager));
05496 return(1 || funcname || hash || result7 || libp) ;
05497 }
05498
05499 static int G__G__Net_174_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05500 {
05501 G__letint(result7, 85, (long) ((TFileStager*) G__getstructoffset())->GetStaged((TCollection*) G__int(libp->para[0])));
05502 return(1 || funcname || hash || result7 || libp) ;
05503 }
05504
05505 static int G__G__Net_174_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05506 {
05507 G__letint(result7, 103, (long) ((TFileStager*) G__getstructoffset())->IsStaged((const char*) G__int(libp->para[0])));
05508 return(1 || funcname || hash || result7 || libp) ;
05509 }
05510
05511 static int G__G__Net_174_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05512 {
05513 G__letint(result7, 105, (long) ((TFileStager*) G__getstructoffset())->Locate((const char*) G__int(libp->para[0]), *(TString*) libp->para[1].ref));
05514 return(1 || funcname || hash || result7 || libp) ;
05515 }
05516
05517 static int G__G__Net_174_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05518 {
05519 G__letint(result7, 103, (long) ((TFileStager*) G__getstructoffset())->Matches((const char*) G__int(libp->para[0])));
05520 return(1 || funcname || hash || result7 || libp) ;
05521 }
05522
05523 static int G__G__Net_174_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05524 {
05525 switch (libp->paran) {
05526 case 2:
05527 G__letint(result7, 103, (long) ((TFileStager*) G__getstructoffset())->Stage((const char*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])));
05528 break;
05529 case 1:
05530 G__letint(result7, 103, (long) ((TFileStager*) G__getstructoffset())->Stage((const char*) G__int(libp->para[0])));
05531 break;
05532 }
05533 return(1 || funcname || hash || result7 || libp) ;
05534 }
05535
05536 static int G__G__Net_174_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05537 {
05538 switch (libp->paran) {
05539 case 2:
05540 G__letint(result7, 103, (long) ((TFileStager*) G__getstructoffset())->Stage((TCollection*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])));
05541 break;
05542 case 1:
05543 G__letint(result7, 103, (long) ((TFileStager*) G__getstructoffset())->Stage((TCollection*) G__int(libp->para[0])));
05544 break;
05545 }
05546 return(1 || funcname || hash || result7 || libp) ;
05547 }
05548
05549 static int G__G__Net_174_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05550 {
05551 G__letint(result7, 103, (long) ((const TFileStager*) G__getstructoffset())->IsValid());
05552 return(1 || funcname || hash || result7 || libp) ;
05553 }
05554
05555 static int G__G__Net_174_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05556 {
05557 {
05558 TString* pobj;
05559 TString xobj = TFileStager::GetPathName((TObject*) G__int(libp->para[0]));
05560 pobj = new TString(xobj);
05561 result7->obj.i = (long) ((void*) pobj);
05562 result7->ref = result7->obj.i;
05563 G__store_tempobject(*result7);
05564 }
05565 return(1 || funcname || hash || result7 || libp) ;
05566 }
05567
05568 static int G__G__Net_174_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05569 {
05570 G__letint(result7, 85, (long) TFileStager::Open((const char*) G__int(libp->para[0])));
05571 return(1 || funcname || hash || result7 || libp) ;
05572 }
05573
05574 static int G__G__Net_174_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05575 {
05576 G__letint(result7, 85, (long) TFileStager::Class());
05577 return(1 || funcname || hash || result7 || libp) ;
05578 }
05579
05580 static int G__G__Net_174_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05581 {
05582 G__letint(result7, 67, (long) TFileStager::Class_Name());
05583 return(1 || funcname || hash || result7 || libp) ;
05584 }
05585
05586 static int G__G__Net_174_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05587 {
05588 G__letint(result7, 115, (long) TFileStager::Class_Version());
05589 return(1 || funcname || hash || result7 || libp) ;
05590 }
05591
05592 static int G__G__Net_174_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05593 {
05594 TFileStager::Dictionary();
05595 G__setnull(result7);
05596 return(1 || funcname || hash || result7 || libp) ;
05597 }
05598
05599 static int G__G__Net_174_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05600 {
05601 ((TFileStager*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
05602 G__setnull(result7);
05603 return(1 || funcname || hash || result7 || libp) ;
05604 }
05605
05606 static int G__G__Net_174_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05607 {
05608 G__letint(result7, 67, (long) TFileStager::DeclFileName());
05609 return(1 || funcname || hash || result7 || libp) ;
05610 }
05611
05612 static int G__G__Net_174_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05613 {
05614 G__letint(result7, 105, (long) TFileStager::ImplFileLine());
05615 return(1 || funcname || hash || result7 || libp) ;
05616 }
05617
05618 static int G__G__Net_174_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05619 {
05620 G__letint(result7, 67, (long) TFileStager::ImplFileName());
05621 return(1 || funcname || hash || result7 || libp) ;
05622 }
05623
05624 static int G__G__Net_174_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05625 {
05626 G__letint(result7, 105, (long) TFileStager::DeclFileLine());
05627 return(1 || funcname || hash || result7 || libp) ;
05628 }
05629
05630
05631 static int G__G__Net_174_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05632
05633 {
05634 TFileStager* p;
05635 void* tmp = (void*) G__int(libp->para[0]);
05636 p = new TFileStager(*(TFileStager*) tmp);
05637 result7->obj.i = (long) p;
05638 result7->ref = (long) p;
05639 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__NetLN_TFileStager));
05640 return(1 || funcname || hash || result7 || libp) ;
05641 }
05642
05643
05644 typedef TFileStager G__TTFileStager;
05645 static int G__G__Net_174_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05646 {
05647 char* gvp = (char*) G__getgvp();
05648 long soff = G__getstructoffset();
05649 int n = G__getaryconstruct();
05650
05651
05652
05653
05654
05655 if (!soff) {
05656 return(1);
05657 }
05658 if (n) {
05659 if (gvp == (char*)G__PVOID) {
05660 delete[] (TFileStager*) soff;
05661 } else {
05662 G__setgvp((long) G__PVOID);
05663 for (int i = n - 1; i >= 0; --i) {
05664 ((TFileStager*) (soff+(sizeof(TFileStager)*i)))->~G__TTFileStager();
05665 }
05666 G__setgvp((long)gvp);
05667 }
05668 } else {
05669 if (gvp == (char*)G__PVOID) {
05670 delete (TFileStager*) soff;
05671 } else {
05672 G__setgvp((long) G__PVOID);
05673 ((TFileStager*) (soff))->~G__TTFileStager();
05674 G__setgvp((long)gvp);
05675 }
05676 }
05677 G__setnull(result7);
05678 return(1 || funcname || hash || result7 || libp) ;
05679 }
05680
05681
05682 static int G__G__Net_174_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05683 {
05684 TFileStager* dest = (TFileStager*) G__getstructoffset();
05685 *dest = *(TFileStager*) libp->para[0].ref;
05686 const TFileStager& obj = *dest;
05687 result7->ref = (long) (&obj);
05688 result7->obj.i = (long) (&obj);
05689 return(1 || funcname || hash || result7 || libp) ;
05690 }
05691
05692
05693
05694 static int G__G__Net_180_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05695 {
05696 TServerSocket* p = NULL;
05697 char* gvp = (char*) G__getgvp();
05698 switch (libp->paran) {
05699 case 4:
05700
05701 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05702 p = new TServerSocket(
05703 (Int_t) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])
05704 , (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
05705 } else {
05706 p = new((void*) gvp) TServerSocket(
05707 (Int_t) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])
05708 , (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
05709 }
05710 break;
05711 case 3:
05712
05713 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05714 p = new TServerSocket(
05715 (Int_t) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])
05716 , (Int_t) G__int(libp->para[2]));
05717 } else {
05718 p = new((void*) gvp) TServerSocket(
05719 (Int_t) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])
05720 , (Int_t) G__int(libp->para[2]));
05721 }
05722 break;
05723 case 2:
05724
05725 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05726 p = new TServerSocket((Int_t) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
05727 } else {
05728 p = new((void*) gvp) TServerSocket((Int_t) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
05729 }
05730 break;
05731 case 1:
05732
05733 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05734 p = new TServerSocket((Int_t) G__int(libp->para[0]));
05735 } else {
05736 p = new((void*) gvp) TServerSocket((Int_t) G__int(libp->para[0]));
05737 }
05738 break;
05739 }
05740 result7->obj.i = (long) p;
05741 result7->ref = (long) p;
05742 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__NetLN_TServerSocket));
05743 return(1 || funcname || hash || result7 || libp) ;
05744 }
05745
05746 static int G__G__Net_180_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05747 {
05748 TServerSocket* p = NULL;
05749 char* gvp = (char*) G__getgvp();
05750 switch (libp->paran) {
05751 case 4:
05752
05753 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05754 p = new TServerSocket(
05755 (const char*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])
05756 , (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
05757 } else {
05758 p = new((void*) gvp) TServerSocket(
05759 (const char*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])
05760 , (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
05761 }
05762 break;
05763 case 3:
05764
05765 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05766 p = new TServerSocket(
05767 (const char*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])
05768 , (Int_t) G__int(libp->para[2]));
05769 } else {
05770 p = new((void*) gvp) TServerSocket(
05771 (const char*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])
05772 , (Int_t) G__int(libp->para[2]));
05773 }
05774 break;
05775 case 2:
05776
05777 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05778 p = new TServerSocket((const char*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
05779 } else {
05780 p = new((void*) gvp) TServerSocket((const char*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
05781 }
05782 break;
05783 case 1:
05784
05785 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05786 p = new TServerSocket((const char*) G__int(libp->para[0]));
05787 } else {
05788 p = new((void*) gvp) TServerSocket((const char*) G__int(libp->para[0]));
05789 }
05790 break;
05791 }
05792 result7->obj.i = (long) p;
05793 result7->ref = (long) p;
05794 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__NetLN_TServerSocket));
05795 return(1 || funcname || hash || result7 || libp) ;
05796 }
05797
05798 static int G__G__Net_180_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05799 {
05800 switch (libp->paran) {
05801 case 1:
05802 G__letint(result7, 85, (long) ((TServerSocket*) G__getstructoffset())->Accept((UChar_t) G__int(libp->para[0])));
05803 break;
05804 case 0:
05805 G__letint(result7, 85, (long) ((TServerSocket*) G__getstructoffset())->Accept());
05806 break;
05807 }
05808 return(1 || funcname || hash || result7 || libp) ;
05809 }
05810
05811 static int G__G__Net_180_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05812 {
05813 G__letint(result7, 98, (long) TServerSocket::GetAcceptOptions());
05814 return(1 || funcname || hash || result7 || libp) ;
05815 }
05816
05817 static int G__G__Net_180_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05818 {
05819 TServerSocket::SetAcceptOptions((UChar_t) G__int(libp->para[0]));
05820 G__setnull(result7);
05821 return(1 || funcname || hash || result7 || libp) ;
05822 }
05823
05824 static int G__G__Net_180_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05825 {
05826 TServerSocket::ShowAcceptOptions();
05827 G__setnull(result7);
05828 return(1 || funcname || hash || result7 || libp) ;
05829 }
05830
05831 static int G__G__Net_180_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05832 {
05833 G__letint(result7, 85, (long) TServerSocket::Class());
05834 return(1 || funcname || hash || result7 || libp) ;
05835 }
05836
05837 static int G__G__Net_180_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05838 {
05839 G__letint(result7, 67, (long) TServerSocket::Class_Name());
05840 return(1 || funcname || hash || result7 || libp) ;
05841 }
05842
05843 static int G__G__Net_180_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05844 {
05845 G__letint(result7, 115, (long) TServerSocket::Class_Version());
05846 return(1 || funcname || hash || result7 || libp) ;
05847 }
05848
05849 static int G__G__Net_180_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05850 {
05851 TServerSocket::Dictionary();
05852 G__setnull(result7);
05853 return(1 || funcname || hash || result7 || libp) ;
05854 }
05855
05856 static int G__G__Net_180_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05857 {
05858 ((TServerSocket*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
05859 G__setnull(result7);
05860 return(1 || funcname || hash || result7 || libp) ;
05861 }
05862
05863 static int G__G__Net_180_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05864 {
05865 G__letint(result7, 67, (long) TServerSocket::DeclFileName());
05866 return(1 || funcname || hash || result7 || libp) ;
05867 }
05868
05869 static int G__G__Net_180_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05870 {
05871 G__letint(result7, 105, (long) TServerSocket::ImplFileLine());
05872 return(1 || funcname || hash || result7 || libp) ;
05873 }
05874
05875 static int G__G__Net_180_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05876 {
05877 G__letint(result7, 67, (long) TServerSocket::ImplFileName());
05878 return(1 || funcname || hash || result7 || libp) ;
05879 }
05880
05881 static int G__G__Net_180_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05882 {
05883 G__letint(result7, 105, (long) TServerSocket::DeclFileLine());
05884 return(1 || funcname || hash || result7 || libp) ;
05885 }
05886
05887
05888 typedef TServerSocket G__TTServerSocket;
05889 static int G__G__Net_180_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05890 {
05891 char* gvp = (char*) G__getgvp();
05892 long soff = G__getstructoffset();
05893 int n = G__getaryconstruct();
05894
05895
05896
05897
05898
05899 if (!soff) {
05900 return(1);
05901 }
05902 if (n) {
05903 if (gvp == (char*)G__PVOID) {
05904 delete[] (TServerSocket*) soff;
05905 } else {
05906 G__setgvp((long) G__PVOID);
05907 for (int i = n - 1; i >= 0; --i) {
05908 ((TServerSocket*) (soff+(sizeof(TServerSocket)*i)))->~G__TTServerSocket();
05909 }
05910 G__setgvp((long)gvp);
05911 }
05912 } else {
05913 if (gvp == (char*)G__PVOID) {
05914 delete (TServerSocket*) soff;
05915 } else {
05916 G__setgvp((long) G__PVOID);
05917 ((TServerSocket*) (soff))->~G__TTServerSocket();
05918 G__setgvp((long)gvp);
05919 }
05920 }
05921 G__setnull(result7);
05922 return(1 || funcname || hash || result7 || libp) ;
05923 }
05924
05925
05926
05927 static int G__G__Net_208_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05928 {
05929 TFTP* p = NULL;
05930 char* gvp = (char*) G__getgvp();
05931 switch (libp->paran) {
05932 case 4:
05933
05934 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05935 p = new TFTP(
05936 (const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
05937 , (Int_t) G__int(libp->para[2]), (TSocket*) G__int(libp->para[3]));
05938 } else {
05939 p = new((void*) gvp) TFTP(
05940 (const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
05941 , (Int_t) G__int(libp->para[2]), (TSocket*) G__int(libp->para[3]));
05942 }
05943 break;
05944 case 3:
05945
05946 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05947 p = new TFTP(
05948 (const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
05949 , (Int_t) G__int(libp->para[2]));
05950 } else {
05951 p = new((void*) gvp) TFTP(
05952 (const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
05953 , (Int_t) G__int(libp->para[2]));
05954 }
05955 break;
05956 case 2:
05957
05958 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05959 p = new TFTP((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
05960 } else {
05961 p = new((void*) gvp) TFTP((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
05962 }
05963 break;
05964 case 1:
05965
05966 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05967 p = new TFTP((const char*) G__int(libp->para[0]));
05968 } else {
05969 p = new((void*) gvp) TFTP((const char*) G__int(libp->para[0]));
05970 }
05971 break;
05972 }
05973 result7->obj.i = (long) p;
05974 result7->ref = (long) p;
05975 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__NetLN_TFTP));
05976 return(1 || funcname || hash || result7 || libp) ;
05977 }
05978
05979 static int G__G__Net_208_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05980 {
05981 ((TFTP*) G__getstructoffset())->SetBlockSize((Int_t) G__int(libp->para[0]));
05982 G__setnull(result7);
05983 return(1 || funcname || hash || result7 || libp) ;
05984 }
05985
05986 static int G__G__Net_208_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05987 {
05988 G__letint(result7, 105, (long) ((const TFTP*) G__getstructoffset())->GetBlockSize());
05989 return(1 || funcname || hash || result7 || libp) ;
05990 }
05991
05992 static int G__G__Net_208_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05993 {
05994 ((TFTP*) G__getstructoffset())->SetRestartAt((Long64_t) G__Longlong(libp->para[0]));
05995 G__setnull(result7);
05996 return(1 || funcname || hash || result7 || libp) ;
05997 }
05998
05999 static int G__G__Net_208_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06000 {
06001 G__letLonglong(result7, 110, (G__int64) ((const TFTP*) G__getstructoffset())->GetRestartAt());
06002 return(1 || funcname || hash || result7 || libp) ;
06003 }
06004
06005 static int G__G__Net_208_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06006 {
06007 G__letint(result7, 105, (long) ((const TFTP*) G__getstructoffset())->GetMode());
06008 return(1 || funcname || hash || result7 || libp) ;
06009 }
06010
06011 static int G__G__Net_208_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06012 {
06013 G__letint(result7, 103, (long) ((const TFTP*) G__getstructoffset())->IsOpen());
06014 return(1 || funcname || hash || result7 || libp) ;
06015 }
06016
06017 static int G__G__Net_208_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06018 {
06019 switch (libp->paran) {
06020 case 2:
06021 G__letLonglong(result7, 110, (G__int64) ((TFTP*) G__getstructoffset())->PutFile((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
06022 break;
06023 case 1:
06024 G__letLonglong(result7, 110, (G__int64) ((TFTP*) G__getstructoffset())->PutFile((const char*) G__int(libp->para[0])));
06025 break;
06026 }
06027 return(1 || funcname || hash || result7 || libp) ;
06028 }
06029
06030 static int G__G__Net_208_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06031 {
06032 switch (libp->paran) {
06033 case 2:
06034 G__letLonglong(result7, 110, (G__int64) ((TFTP*) G__getstructoffset())->GetFile((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
06035 break;
06036 case 1:
06037 G__letLonglong(result7, 110, (G__int64) ((TFTP*) G__getstructoffset())->GetFile((const char*) G__int(libp->para[0])));
06038 break;
06039 }
06040 return(1 || funcname || hash || result7 || libp) ;
06041 }
06042
06043 static int G__G__Net_208_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06044 {
06045 switch (libp->paran) {
06046 case 3:
06047 G__letint(result7, 103, (long) ((TFTP*) G__getstructoffset())->AccessPathName((const char*) G__int(libp->para[0]), (EAccessMode) G__int(libp->para[1])
06048 , (Bool_t) G__int(libp->para[2])));
06049 break;
06050 case 2:
06051 G__letint(result7, 103, (long) ((TFTP*) G__getstructoffset())->AccessPathName((const char*) G__int(libp->para[0]), (EAccessMode) G__int(libp->para[1])));
06052 break;
06053 case 1:
06054 G__letint(result7, 103, (long) ((TFTP*) G__getstructoffset())->AccessPathName((const char*) G__int(libp->para[0])));
06055 break;
06056 }
06057 return(1 || funcname || hash || result7 || libp) ;
06058 }
06059
06060 static int G__G__Net_208_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06061 {
06062 switch (libp->paran) {
06063 case 1:
06064 G__letint(result7, 67, (long) ((TFTP*) G__getstructoffset())->GetDirEntry((Bool_t) G__int(libp->para[0])));
06065 break;
06066 case 0:
06067 G__letint(result7, 67, (long) ((TFTP*) G__getstructoffset())->GetDirEntry());
06068 break;
06069 }
06070 return(1 || funcname || hash || result7 || libp) ;
06071 }
06072
06073 static int G__G__Net_208_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06074 {
06075 switch (libp->paran) {
06076 case 3:
06077 G__letint(result7, 105, (long) ((TFTP*) G__getstructoffset())->GetPathInfo((const char*) G__int(libp->para[0]), *(FileStat_t*) libp->para[1].ref
06078 , (Bool_t) G__int(libp->para[2])));
06079 break;
06080 case 2:
06081 G__letint(result7, 105, (long) ((TFTP*) G__getstructoffset())->GetPathInfo((const char*) G__int(libp->para[0]), *(FileStat_t*) libp->para[1].ref));
06082 break;
06083 }
06084 return(1 || funcname || hash || result7 || libp) ;
06085 }
06086
06087 static int G__G__Net_208_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06088 {
06089 G__letint(result7, 105, (long) ((const TFTP*) G__getstructoffset())->ChangeDirectory((const char*) G__int(libp->para[0])));
06090 return(1 || funcname || hash || result7 || libp) ;
06091 }
06092
06093 static int G__G__Net_208_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06094 {
06095 switch (libp->paran) {
06096 case 2:
06097 G__letint(result7, 105, (long) ((const TFTP*) G__getstructoffset())->MakeDirectory((const char*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])));
06098 break;
06099 case 1:
06100 G__letint(result7, 105, (long) ((const TFTP*) G__getstructoffset())->MakeDirectory((const char*) G__int(libp->para[0])));
06101 break;
06102 }
06103 return(1 || funcname || hash || result7 || libp) ;
06104 }
06105
06106 static int G__G__Net_208_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06107 {
06108 G__letint(result7, 105, (long) ((const TFTP*) G__getstructoffset())->DeleteDirectory((const char*) G__int(libp->para[0])));
06109 return(1 || funcname || hash || result7 || libp) ;
06110 }
06111
06112 static int G__G__Net_208_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06113 {
06114 switch (libp->paran) {
06115 case 1:
06116 G__letint(result7, 105, (long) ((const TFTP*) G__getstructoffset())->ListDirectory((Option_t*) G__int(libp->para[0])));
06117 break;
06118 case 0:
06119 G__letint(result7, 105, (long) ((const TFTP*) G__getstructoffset())->ListDirectory());
06120 break;
06121 }
06122 return(1 || funcname || hash || result7 || libp) ;
06123 }
06124
06125 static int G__G__Net_208_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06126 {
06127 switch (libp->paran) {
06128 case 1:
06129 ((TFTP*) G__getstructoffset())->FreeDirectory((Bool_t) G__int(libp->para[0]));
06130 G__setnull(result7);
06131 break;
06132 case 0:
06133 ((TFTP*) G__getstructoffset())->FreeDirectory();
06134 G__setnull(result7);
06135 break;
06136 }
06137 return(1 || funcname || hash || result7 || libp) ;
06138 }
06139
06140 static int G__G__Net_208_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06141 {
06142 switch (libp->paran) {
06143 case 2:
06144 G__letint(result7, 103, (long) ((TFTP*) G__getstructoffset())->OpenDirectory((const char*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])));
06145 break;
06146 case 1:
06147 G__letint(result7, 103, (long) ((TFTP*) G__getstructoffset())->OpenDirectory((const char*) G__int(libp->para[0])));
06148 break;
06149 }
06150 return(1 || funcname || hash || result7 || libp) ;
06151 }
06152
06153 static int G__G__Net_208_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06154 {
06155 G__letint(result7, 105, (long) ((const TFTP*) G__getstructoffset())->PrintDirectory());
06156 return(1 || funcname || hash || result7 || libp) ;
06157 }
06158
06159 static int G__G__Net_208_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06160 {
06161 G__letint(result7, 105, (long) ((const TFTP*) G__getstructoffset())->RenameFile((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
06162 return(1 || funcname || hash || result7 || libp) ;
06163 }
06164
06165 static int G__G__Net_208_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06166 {
06167 G__letint(result7, 105, (long) ((const TFTP*) G__getstructoffset())->DeleteFile((const char*) G__int(libp->para[0])));
06168 return(1 || funcname || hash || result7 || libp) ;
06169 }
06170
06171 static int G__G__Net_208_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06172 {
06173 G__letint(result7, 105, (long) ((const TFTP*) G__getstructoffset())->ChangePermission((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
06174 return(1 || funcname || hash || result7 || libp) ;
06175 }
06176
06177 static int G__G__Net_208_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06178 {
06179 G__letint(result7, 105, (long) ((TFTP*) G__getstructoffset())->Close());
06180 return(1 || funcname || hash || result7 || libp) ;
06181 }
06182
06183 static int G__G__Net_208_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06184 {
06185 ((TFTP*) G__getstructoffset())->Binary();
06186 G__setnull(result7);
06187 return(1 || funcname || hash || result7 || libp) ;
06188 }
06189
06190 static int G__G__Net_208_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06191 {
06192 ((TFTP*) G__getstructoffset())->Ascii();
06193 G__setnull(result7);
06194 return(1 || funcname || hash || result7 || libp) ;
06195 }
06196
06197 static int G__G__Net_208_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06198 {
06199 G__letint(result7, 85, (long) ((const TFTP*) G__getstructoffset())->GetSocket());
06200 return(1 || funcname || hash || result7 || libp) ;
06201 }
06202
06203 static int G__G__Net_208_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06204 {
06205 switch (libp->paran) {
06206 case 2:
06207 ((TFTP*) G__getstructoffset())->put((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
06208 G__setnull(result7);
06209 break;
06210 case 1:
06211 ((TFTP*) G__getstructoffset())->put((const char*) G__int(libp->para[0]));
06212 G__setnull(result7);
06213 break;
06214 }
06215 return(1 || funcname || hash || result7 || libp) ;
06216 }
06217
06218 static int G__G__Net_208_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06219 {
06220 switch (libp->paran) {
06221 case 2:
06222 ((TFTP*) G__getstructoffset())->get((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
06223 G__setnull(result7);
06224 break;
06225 case 1:
06226 ((TFTP*) G__getstructoffset())->get((const char*) G__int(libp->para[0]));
06227 G__setnull(result7);
06228 break;
06229 }
06230 return(1 || funcname || hash || result7 || libp) ;
06231 }
06232
06233 static int G__G__Net_208_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06234 {
06235 ((const TFTP*) G__getstructoffset())->cd((const char*) G__int(libp->para[0]));
06236 G__setnull(result7);
06237 return(1 || funcname || hash || result7 || libp) ;
06238 }
06239
06240 static int G__G__Net_208_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06241 {
06242 ((const TFTP*) G__getstructoffset())->mkdir((const char*) G__int(libp->para[0]));
06243 G__setnull(result7);
06244 return(1 || funcname || hash || result7 || libp) ;
06245 }
06246
06247 static int G__G__Net_208_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06248 {
06249 ((const TFTP*) G__getstructoffset())->rmdir((const char*) G__int(libp->para[0]));
06250 G__setnull(result7);
06251 return(1 || funcname || hash || result7 || libp) ;
06252 }
06253
06254 static int G__G__Net_208_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06255 {
06256 ((const TFTP*) G__getstructoffset())->pwd();
06257 G__setnull(result7);
06258 return(1 || funcname || hash || result7 || libp) ;
06259 }
06260
06261 static int G__G__Net_208_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06262 {
06263 ((const TFTP*) G__getstructoffset())->mv((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
06264 G__setnull(result7);
06265 return(1 || funcname || hash || result7 || libp) ;
06266 }
06267
06268 static int G__G__Net_208_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06269 {
06270 ((const TFTP*) G__getstructoffset())->rm((const char*) G__int(libp->para[0]));
06271 G__setnull(result7);
06272 return(1 || funcname || hash || result7 || libp) ;
06273 }
06274
06275 static int G__G__Net_208_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06276 {
06277 ((const TFTP*) G__getstructoffset())->chmod((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
06278 G__setnull(result7);
06279 return(1 || funcname || hash || result7 || libp) ;
06280 }
06281
06282 static int G__G__Net_208_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06283 {
06284 ((TFTP*) G__getstructoffset())->bye();
06285 G__setnull(result7);
06286 return(1 || funcname || hash || result7 || libp) ;
06287 }
06288
06289 static int G__G__Net_208_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06290 {
06291 ((TFTP*) G__getstructoffset())->bin();
06292 G__setnull(result7);
06293 return(1 || funcname || hash || result7 || libp) ;
06294 }
06295
06296 static int G__G__Net_208_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06297 {
06298 ((TFTP*) G__getstructoffset())->ascii();
06299 G__setnull(result7);
06300 return(1 || funcname || hash || result7 || libp) ;
06301 }
06302
06303 static int G__G__Net_208_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06304 {
06305 G__letint(result7, 85, (long) TFTP::Class());
06306 return(1 || funcname || hash || result7 || libp) ;
06307 }
06308
06309 static int G__G__Net_208_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06310 {
06311 G__letint(result7, 67, (long) TFTP::Class_Name());
06312 return(1 || funcname || hash || result7 || libp) ;
06313 }
06314
06315 static int G__G__Net_208_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06316 {
06317 G__letint(result7, 115, (long) TFTP::Class_Version());
06318 return(1 || funcname || hash || result7 || libp) ;
06319 }
06320
06321 static int G__G__Net_208_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06322 {
06323 TFTP::Dictionary();
06324 G__setnull(result7);
06325 return(1 || funcname || hash || result7 || libp) ;
06326 }
06327
06328 static int G__G__Net_208_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06329 {
06330 ((TFTP*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
06331 G__setnull(result7);
06332 return(1 || funcname || hash || result7 || libp) ;
06333 }
06334
06335 static int G__G__Net_208_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06336 {
06337 G__letint(result7, 67, (long) TFTP::DeclFileName());
06338 return(1 || funcname || hash || result7 || libp) ;
06339 }
06340
06341 static int G__G__Net_208_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06342 {
06343 G__letint(result7, 105, (long) TFTP::ImplFileLine());
06344 return(1 || funcname || hash || result7 || libp) ;
06345 }
06346
06347 static int G__G__Net_208_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06348 {
06349 G__letint(result7, 67, (long) TFTP::ImplFileName());
06350 return(1 || funcname || hash || result7 || libp) ;
06351 }
06352
06353 static int G__G__Net_208_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06354 {
06355 G__letint(result7, 105, (long) TFTP::DeclFileLine());
06356 return(1 || funcname || hash || result7 || libp) ;
06357 }
06358
06359
06360 typedef TFTP G__TTFTP;
06361 static int G__G__Net_208_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06362 {
06363 char* gvp = (char*) G__getgvp();
06364 long soff = G__getstructoffset();
06365 int n = G__getaryconstruct();
06366
06367
06368
06369
06370
06371 if (!soff) {
06372 return(1);
06373 }
06374 if (n) {
06375 if (gvp == (char*)G__PVOID) {
06376 delete[] (TFTP*) soff;
06377 } else {
06378 G__setgvp((long) G__PVOID);
06379 for (int i = n - 1; i >= 0; --i) {
06380 ((TFTP*) (soff+(sizeof(TFTP)*i)))->~G__TTFTP();
06381 }
06382 G__setgvp((long)gvp);
06383 }
06384 } else {
06385 if (gvp == (char*)G__PVOID) {
06386 delete (TFTP*) soff;
06387 } else {
06388 G__setgvp((long) G__PVOID);
06389 ((TFTP*) (soff))->~G__TTFTP();
06390 G__setgvp((long)gvp);
06391 }
06392 }
06393 G__setnull(result7);
06394 return(1 || funcname || hash || result7 || libp) ;
06395 }
06396
06397
06398
06399 static int G__G__Net_213_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06400 {
06401 TGridResult* p = NULL;
06402 char* gvp = (char*) G__getgvp();
06403 int n = G__getaryconstruct();
06404 if (n) {
06405 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06406 p = new TGridResult[n];
06407 } else {
06408 p = new((void*) gvp) TGridResult[n];
06409 }
06410 } else {
06411 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06412 p = new TGridResult;
06413 } else {
06414 p = new((void*) gvp) TGridResult;
06415 }
06416 }
06417 result7->obj.i = (long) p;
06418 result7->ref = (long) p;
06419 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__NetLN_TGridResult));
06420 return(1 || funcname || hash || result7 || libp) ;
06421 }
06422
06423 static int G__G__Net_213_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06424 {
06425 G__letint(result7, 67, (long) ((const TGridResult*) G__getstructoffset())->GetFileName((UInt_t) G__int(libp->para[0])));
06426 return(1 || funcname || hash || result7 || libp) ;
06427 }
06428
06429 static int G__G__Net_213_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06430 {
06431 G__letint(result7, 67, (long) ((const TGridResult*) G__getstructoffset())->GetFileNamePath((UInt_t) G__int(libp->para[0])));
06432 return(1 || funcname || hash || result7 || libp) ;
06433 }
06434
06435 static int G__G__Net_213_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06436 {
06437 G__letint(result7, 67, (long) ((const TGridResult*) G__getstructoffset())->GetPath((UInt_t) G__int(libp->para[0])));
06438 return(1 || funcname || hash || result7 || libp) ;
06439 }
06440
06441 static int G__G__Net_213_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06442 {
06443 G__letint(result7, 85, (long) ((const TGridResult*) G__getstructoffset())->GetEntryList((UInt_t) G__int(libp->para[0])));
06444 return(1 || funcname || hash || result7 || libp) ;
06445 }
06446
06447 static int G__G__Net_213_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06448 {
06449 G__letint(result7, 67, (long) ((const TGridResult*) G__getstructoffset())->GetKey((UInt_t) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
06450 return(1 || funcname || hash || result7 || libp) ;
06451 }
06452
06453 static int G__G__Net_213_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06454 {
06455 G__letint(result7, 103, (long) ((TGridResult*) G__getstructoffset())->SetKey((UInt_t) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
06456 , (const char*) G__int(libp->para[2])));
06457 return(1 || funcname || hash || result7 || libp) ;
06458 }
06459
06460 static int G__G__Net_213_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06461 {
06462 G__letint(result7, 85, (long) ((const TGridResult*) G__getstructoffset())->GetFileInfoList());
06463 return(1 || funcname || hash || result7 || libp) ;
06464 }
06465
06466 static int G__G__Net_213_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06467 {
06468 G__letint(result7, 85, (long) TGridResult::Class());
06469 return(1 || funcname || hash || result7 || libp) ;
06470 }
06471
06472 static int G__G__Net_213_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06473 {
06474 G__letint(result7, 67, (long) TGridResult::Class_Name());
06475 return(1 || funcname || hash || result7 || libp) ;
06476 }
06477
06478 static int G__G__Net_213_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06479 {
06480 G__letint(result7, 115, (long) TGridResult::Class_Version());
06481 return(1 || funcname || hash || result7 || libp) ;
06482 }
06483
06484 static int G__G__Net_213_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06485 {
06486 TGridResult::Dictionary();
06487 G__setnull(result7);
06488 return(1 || funcname || hash || result7 || libp) ;
06489 }
06490
06491 static int G__G__Net_213_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06492 {
06493 ((TGridResult*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
06494 G__setnull(result7);
06495 return(1 || funcname || hash || result7 || libp) ;
06496 }
06497
06498 static int G__G__Net_213_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06499 {
06500 G__letint(result7, 67, (long) TGridResult::DeclFileName());
06501 return(1 || funcname || hash || result7 || libp) ;
06502 }
06503
06504 static int G__G__Net_213_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06505 {
06506 G__letint(result7, 105, (long) TGridResult::ImplFileLine());
06507 return(1 || funcname || hash || result7 || libp) ;
06508 }
06509
06510 static int G__G__Net_213_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06511 {
06512 G__letint(result7, 67, (long) TGridResult::ImplFileName());
06513 return(1 || funcname || hash || result7 || libp) ;
06514 }
06515
06516 static int G__G__Net_213_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06517 {
06518 G__letint(result7, 105, (long) TGridResult::DeclFileLine());
06519 return(1 || funcname || hash || result7 || libp) ;
06520 }
06521
06522
06523 typedef TGridResult G__TTGridResult;
06524 static int G__G__Net_213_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06525 {
06526 char* gvp = (char*) G__getgvp();
06527 long soff = G__getstructoffset();
06528 int n = G__getaryconstruct();
06529
06530
06531
06532
06533
06534 if (!soff) {
06535 return(1);
06536 }
06537 if (n) {
06538 if (gvp == (char*)G__PVOID) {
06539 delete[] (TGridResult*) soff;
06540 } else {
06541 G__setgvp((long) G__PVOID);
06542 for (int i = n - 1; i >= 0; --i) {
06543 ((TGridResult*) (soff+(sizeof(TGridResult)*i)))->~G__TTGridResult();
06544 }
06545 G__setgvp((long)gvp);
06546 }
06547 } else {
06548 if (gvp == (char*)G__PVOID) {
06549 delete (TGridResult*) soff;
06550 } else {
06551 G__setgvp((long) G__PVOID);
06552 ((TGridResult*) (soff))->~G__TTGridResult();
06553 G__setgvp((long)gvp);
06554 }
06555 }
06556 G__setnull(result7);
06557 return(1 || funcname || hash || result7 || libp) ;
06558 }
06559
06560
06561
06562 static int G__G__Net_215_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06563 {
06564 TGridCollection* p = NULL;
06565 char* gvp = (char*) G__getgvp();
06566 int n = G__getaryconstruct();
06567 if (n) {
06568 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06569 p = new TGridCollection[n];
06570 } else {
06571 p = new((void*) gvp) TGridCollection[n];
06572 }
06573 } else {
06574 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06575 p = new TGridCollection;
06576 } else {
06577 p = new((void*) gvp) TGridCollection;
06578 }
06579 }
06580 result7->obj.i = (long) p;
06581 result7->ref = (long) p;
06582 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__NetLN_TGridCollection));
06583 return(1 || funcname || hash || result7 || libp) ;
06584 }
06585
06586 static int G__G__Net_215_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06587 {
06588 ((TGridCollection*) G__getstructoffset())->Reset();
06589 G__setnull(result7);
06590 return(1 || funcname || hash || result7 || libp) ;
06591 }
06592
06593 static int G__G__Net_215_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06594 {
06595 G__letint(result7, 85, (long) ((TGridCollection*) G__getstructoffset())->Next());
06596 return(1 || funcname || hash || result7 || libp) ;
06597 }
06598
06599 static int G__G__Net_215_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06600 {
06601 G__letint(result7, 103, (long) ((TGridCollection*) G__getstructoffset())->Remove((TMap*) G__int(libp->para[0])));
06602 return(1 || funcname || hash || result7 || libp) ;
06603 }
06604
06605 static int G__G__Net_215_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06606 {
06607 switch (libp->paran) {
06608 case 1:
06609 G__letint(result7, 67, (long) ((TGridCollection*) G__getstructoffset())->GetTURL((const char*) G__int(libp->para[0])));
06610 break;
06611 case 0:
06612 G__letint(result7, 67, (long) ((TGridCollection*) G__getstructoffset())->GetTURL());
06613 break;
06614 }
06615 return(1 || funcname || hash || result7 || libp) ;
06616 }
06617
06618 static int G__G__Net_215_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06619 {
06620 switch (libp->paran) {
06621 case 1:
06622 G__letint(result7, 67, (long) ((TGridCollection*) G__getstructoffset())->GetSURL((const char*) G__int(libp->para[0])));
06623 break;
06624 case 0:
06625 G__letint(result7, 67, (long) ((TGridCollection*) G__getstructoffset())->GetSURL());
06626 break;
06627 }
06628 return(1 || funcname || hash || result7 || libp) ;
06629 }
06630
06631 static int G__G__Net_215_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06632 {
06633 switch (libp->paran) {
06634 case 1:
06635 G__letint(result7, 67, (long) ((TGridCollection*) G__getstructoffset())->GetLFN((const char*) G__int(libp->para[0])));
06636 break;
06637 case 0:
06638 G__letint(result7, 67, (long) ((TGridCollection*) G__getstructoffset())->GetLFN());
06639 break;
06640 }
06641 return(1 || funcname || hash || result7 || libp) ;
06642 }
06643
06644 static int G__G__Net_215_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06645 {
06646 switch (libp->paran) {
06647 case 1:
06648 G__letLonglong(result7, 110, (G__int64) ((TGridCollection*) G__getstructoffset())->GetSize((const char*) G__int(libp->para[0])));
06649 break;
06650 case 0:
06651 G__letLonglong(result7, 110, (G__int64) ((TGridCollection*) G__getstructoffset())->GetSize());
06652 break;
06653 }
06654 return(1 || funcname || hash || result7 || libp) ;
06655 }
06656
06657 static int G__G__Net_215_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06658 {
06659 switch (libp->paran) {
06660 case 1:
06661 G__letint(result7, 103, (long) ((TGridCollection*) G__getstructoffset())->IsOnline((const char*) G__int(libp->para[0])));
06662 break;
06663 case 0:
06664 G__letint(result7, 103, (long) ((TGridCollection*) G__getstructoffset())->IsOnline());
06665 break;
06666 }
06667 return(1 || funcname || hash || result7 || libp) ;
06668 }
06669
06670 static int G__G__Net_215_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06671 {
06672 switch (libp->paran) {
06673 case 1:
06674 G__letint(result7, 103, (long) ((TGridCollection*) G__getstructoffset())->IsSelected((const char*) G__int(libp->para[0])));
06675 break;
06676 case 0:
06677 G__letint(result7, 103, (long) ((TGridCollection*) G__getstructoffset())->IsSelected());
06678 break;
06679 }
06680 return(1 || funcname || hash || result7 || libp) ;
06681 }
06682
06683 static int G__G__Net_215_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06684 {
06685 ((TGridCollection*) G__getstructoffset())->Status();
06686 G__setnull(result7);
06687 return(1 || funcname || hash || result7 || libp) ;
06688 }
06689
06690 static int G__G__Net_215_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06691 {
06692 ((TGridCollection*) G__getstructoffset())->SetTag((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
06693 , (TMap*) G__int(libp->para[2]));
06694 G__setnull(result7);
06695 return(1 || funcname || hash || result7 || libp) ;
06696 }
06697
06698 static int G__G__Net_215_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06699 {
06700 switch (libp->paran) {
06701 case 3:
06702 G__letint(result7, 103, (long) ((TGridCollection*) G__getstructoffset())->SelectFile((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
06703 , (Int_t) G__int(libp->para[2])));
06704 break;
06705 case 2:
06706 G__letint(result7, 103, (long) ((TGridCollection*) G__getstructoffset())->SelectFile((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
06707 break;
06708 case 1:
06709 G__letint(result7, 103, (long) ((TGridCollection*) G__getstructoffset())->SelectFile((const char*) G__int(libp->para[0])));
06710 break;
06711 }
06712 return(1 || funcname || hash || result7 || libp) ;
06713 }
06714
06715 static int G__G__Net_215_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06716 {
06717 switch (libp->paran) {
06718 case 3:
06719 G__letint(result7, 103, (long) ((TGridCollection*) G__getstructoffset())->DeselectFile((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
06720 , (Int_t) G__int(libp->para[2])));
06721 break;
06722 case 2:
06723 G__letint(result7, 103, (long) ((TGridCollection*) G__getstructoffset())->DeselectFile((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
06724 break;
06725 case 1:
06726 G__letint(result7, 103, (long) ((TGridCollection*) G__getstructoffset())->DeselectFile((const char*) G__int(libp->para[0])));
06727 break;
06728 }
06729 return(1 || funcname || hash || result7 || libp) ;
06730 }
06731
06732 static int G__G__Net_215_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06733 {
06734 G__letint(result7, 103, (long) ((TGridCollection*) G__getstructoffset())->InvertSelection());
06735 return(1 || funcname || hash || result7 || libp) ;
06736 }
06737
06738 static int G__G__Net_215_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06739 {
06740 switch (libp->paran) {
06741 case 1:
06742 G__letint(result7, 103, (long) ((TGridCollection*) G__getstructoffset())->DownscaleSelection((UInt_t) G__int(libp->para[0])));
06743 break;
06744 case 0:
06745 G__letint(result7, 103, (long) ((TGridCollection*) G__getstructoffset())->DownscaleSelection());
06746 break;
06747 }
06748 return(1 || funcname || hash || result7 || libp) ;
06749 }
06750
06751 static int G__G__Net_215_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06752 {
06753 switch (libp->paran) {
06754 case 5:
06755 G__letint(result7, 103, (long) ((TGridCollection*) G__getstructoffset())->ExportXML((const char*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])
06756 , (Bool_t) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
06757 , (const char*) G__int(libp->para[4])));
06758 break;
06759 case 4:
06760 G__letint(result7, 103, (long) ((TGridCollection*) G__getstructoffset())->ExportXML((const char*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])
06761 , (Bool_t) G__int(libp->para[2]), (const char*) G__int(libp->para[3])));
06762 break;
06763 case 3:
06764 G__letint(result7, 103, (long) ((TGridCollection*) G__getstructoffset())->ExportXML((const char*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])
06765 , (Bool_t) G__int(libp->para[2])));
06766 break;
06767 case 2:
06768 G__letint(result7, 103, (long) ((TGridCollection*) G__getstructoffset())->ExportXML((const char*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])));
06769 break;
06770 case 1:
06771 G__letint(result7, 103, (long) ((TGridCollection*) G__getstructoffset())->ExportXML((const char*) G__int(libp->para[0])));
06772 break;
06773 }
06774 return(1 || funcname || hash || result7 || libp) ;
06775 }
06776
06777 static int G__G__Net_215_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06778 {
06779 G__letint(result7, 67, (long) ((TGridCollection*) G__getstructoffset())->GetExportUrl());
06780 return(1 || funcname || hash || result7 || libp) ;
06781 }
06782
06783 static int G__G__Net_215_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06784 {
06785 switch (libp->paran) {
06786 case 1:
06787 G__letint(result7, 103, (long) ((TGridCollection*) G__getstructoffset())->SetExportUrl((const char*) G__int(libp->para[0])));
06788 break;
06789 case 0:
06790 G__letint(result7, 103, (long) ((TGridCollection*) G__getstructoffset())->SetExportUrl());
06791 break;
06792 }
06793 return(1 || funcname || hash || result7 || libp) ;
06794 }
06795
06796 static int G__G__Net_215_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06797 {
06798 G__letint(result7, 85, (long) ((TGridCollection*) G__getstructoffset())->OpenFile((const char*) G__int(libp->para[0])));
06799 return(1 || funcname || hash || result7 || libp) ;
06800 }
06801
06802 static int G__G__Net_215_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06803 {
06804 G__letint(result7, 85, (long) ((const TGridCollection*) G__getstructoffset())->GetFileGroupList());
06805 return(1 || funcname || hash || result7 || libp) ;
06806 }
06807
06808 static int G__G__Net_215_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06809 {
06810 G__letint(result7, 85, (long) ((TGridCollection*) G__getstructoffset())->GetEntryList((const char*) G__int(libp->para[0])));
06811 return(1 || funcname || hash || result7 || libp) ;
06812 }
06813
06814 static int G__G__Net_215_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06815 {
06816 G__letint(result7, 104, (long) ((const TGridCollection*) G__getstructoffset())->GetNofGroups());
06817 return(1 || funcname || hash || result7 || libp) ;
06818 }
06819
06820 static int G__G__Net_215_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06821 {
06822 G__letint(result7, 104, (long) ((const TGridCollection*) G__getstructoffset())->GetNofGroupfiles());
06823 return(1 || funcname || hash || result7 || libp) ;
06824 }
06825
06826 static int G__G__Net_215_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06827 {
06828 G__letint(result7, 103, (long) ((TGridCollection*) G__getstructoffset())->OverlapCollection((TGridCollection*) G__int(libp->para[0])));
06829 return(1 || funcname || hash || result7 || libp) ;
06830 }
06831
06832 static int G__G__Net_215_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06833 {
06834 ((TGridCollection*) G__getstructoffset())->Add((TGridCollection*) G__int(libp->para[0]));
06835 G__setnull(result7);
06836 return(1 || funcname || hash || result7 || libp) ;
06837 }
06838
06839 static int G__G__Net_215_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06840 {
06841 switch (libp->paran) {
06842 case 2:
06843 G__letint(result7, 103, (long) ((TGridCollection*) G__getstructoffset())->Stage((Bool_t) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])));
06844 break;
06845 case 1:
06846 G__letint(result7, 103, (long) ((TGridCollection*) G__getstructoffset())->Stage((Bool_t) G__int(libp->para[0])));
06847 break;
06848 case 0:
06849 G__letint(result7, 103, (long) ((TGridCollection*) G__getstructoffset())->Stage());
06850 break;
06851 }
06852 return(1 || funcname || hash || result7 || libp) ;
06853 }
06854
06855 static int G__G__Net_215_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06856 {
06857 switch (libp->paran) {
06858 case 1:
06859 G__letint(result7, 103, (long) ((TGridCollection*) G__getstructoffset())->Prepare((Bool_t) G__int(libp->para[0])));
06860 break;
06861 case 0:
06862 G__letint(result7, 103, (long) ((TGridCollection*) G__getstructoffset())->Prepare());
06863 break;
06864 }
06865 return(1 || funcname || hash || result7 || libp) ;
06866 }
06867
06868 static int G__G__Net_215_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06869 {
06870 switch (libp->paran) {
06871 case 1:
06872 G__letint(result7, 103, (long) ((TGridCollection*) G__getstructoffset())->CheckIfOnline((Bool_t) G__int(libp->para[0])));
06873 break;
06874 case 0:
06875 G__letint(result7, 103, (long) ((TGridCollection*) G__getstructoffset())->CheckIfOnline());
06876 break;
06877 }
06878 return(1 || funcname || hash || result7 || libp) ;
06879 }
06880
06881 static int G__G__Net_215_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06882 {
06883 G__letint(result7, 85, (long) ((TGridCollection*) G__getstructoffset())->GetDataset((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
06884 , (const char*) G__int(libp->para[2])));
06885 return(1 || funcname || hash || result7 || libp) ;
06886 }
06887
06888 static int G__G__Net_215_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06889 {
06890 switch (libp->paran) {
06891 case 3:
06892 G__letint(result7, 85, (long) ((TGridCollection*) G__getstructoffset())->GetGridResult((const char*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])
06893 , (Bool_t) G__int(libp->para[2])));
06894 break;
06895 case 2:
06896 G__letint(result7, 85, (long) ((TGridCollection*) G__getstructoffset())->GetGridResult((const char*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])));
06897 break;
06898 case 1:
06899 G__letint(result7, 85, (long) ((TGridCollection*) G__getstructoffset())->GetGridResult((const char*) G__int(libp->para[0])));
06900 break;
06901 case 0:
06902 G__letint(result7, 85, (long) ((TGridCollection*) G__getstructoffset())->GetGridResult());
06903 break;
06904 }
06905 return(1 || funcname || hash || result7 || libp) ;
06906 }
06907
06908 static int G__G__Net_215_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06909 {
06910 switch (libp->paran) {
06911 case 1:
06912 G__letint(result7, 103, (long) ((TGridCollection*) G__getstructoffset())->LookupSUrls((Bool_t) G__int(libp->para[0])));
06913 break;
06914 case 0:
06915 G__letint(result7, 103, (long) ((TGridCollection*) G__getstructoffset())->LookupSUrls());
06916 break;
06917 }
06918 return(1 || funcname || hash || result7 || libp) ;
06919 }
06920
06921 static int G__G__Net_215_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06922 {
06923 G__letint(result7, 85, (long) ((const TGridCollection*) G__getstructoffset())->GetTagFilterList());
06924 return(1 || funcname || hash || result7 || libp) ;
06925 }
06926
06927 static int G__G__Net_215_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06928 {
06929 ((TGridCollection*) G__getstructoffset())->SetTagFilterList((TList*) G__int(libp->para[0]));
06930 G__setnull(result7);
06931 return(1 || funcname || hash || result7 || libp) ;
06932 }
06933
06934 static int G__G__Net_215_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06935 {
06936 G__letint(result7, 67, (long) ((const TGridCollection*) G__getstructoffset())->GetCollectionName());
06937 return(1 || funcname || hash || result7 || libp) ;
06938 }
06939
06940 static int G__G__Net_215_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06941 {
06942 G__letint(result7, 67, (long) ((const TGridCollection*) G__getstructoffset())->GetInfoComment());
06943 return(1 || funcname || hash || result7 || libp) ;
06944 }
06945
06946 static int G__G__Net_215_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06947 {
06948 switch (libp->paran) {
06949 case 2:
06950 G__letint(result7, 85, (long) ((const TGridCollection*) G__getstructoffset())->GetFileCollection((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
06951 break;
06952 case 1:
06953 G__letint(result7, 85, (long) ((const TGridCollection*) G__getstructoffset())->GetFileCollection((const char*) G__int(libp->para[0])));
06954 break;
06955 case 0:
06956 G__letint(result7, 85, (long) ((const TGridCollection*) G__getstructoffset())->GetFileCollection());
06957 break;
06958 }
06959 return(1 || funcname || hash || result7 || libp) ;
06960 }
06961
06962 static int G__G__Net_215_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06963 {
06964 G__letint(result7, 85, (long) TGridCollection::Class());
06965 return(1 || funcname || hash || result7 || libp) ;
06966 }
06967
06968 static int G__G__Net_215_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06969 {
06970 G__letint(result7, 67, (long) TGridCollection::Class_Name());
06971 return(1 || funcname || hash || result7 || libp) ;
06972 }
06973
06974 static int G__G__Net_215_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06975 {
06976 G__letint(result7, 115, (long) TGridCollection::Class_Version());
06977 return(1 || funcname || hash || result7 || libp) ;
06978 }
06979
06980 static int G__G__Net_215_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06981 {
06982 TGridCollection::Dictionary();
06983 G__setnull(result7);
06984 return(1 || funcname || hash || result7 || libp) ;
06985 }
06986
06987 static int G__G__Net_215_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06988 {
06989 ((TGridCollection*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
06990 G__setnull(result7);
06991 return(1 || funcname || hash || result7 || libp) ;
06992 }
06993
06994 static int G__G__Net_215_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06995 {
06996 G__letint(result7, 67, (long) TGridCollection::DeclFileName());
06997 return(1 || funcname || hash || result7 || libp) ;
06998 }
06999
07000 static int G__G__Net_215_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07001 {
07002 G__letint(result7, 105, (long) TGridCollection::ImplFileLine());
07003 return(1 || funcname || hash || result7 || libp) ;
07004 }
07005
07006 static int G__G__Net_215_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07007 {
07008 G__letint(result7, 67, (long) TGridCollection::ImplFileName());
07009 return(1 || funcname || hash || result7 || libp) ;
07010 }
07011
07012 static int G__G__Net_215_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07013 {
07014 G__letint(result7, 105, (long) TGridCollection::DeclFileLine());
07015 return(1 || funcname || hash || result7 || libp) ;
07016 }
07017
07018
07019 static int G__G__Net_215_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07020
07021 {
07022 TGridCollection* p;
07023 void* tmp = (void*) G__int(libp->para[0]);
07024 p = new TGridCollection(*(TGridCollection*) tmp);
07025 result7->obj.i = (long) p;
07026 result7->ref = (long) p;
07027 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__NetLN_TGridCollection));
07028 return(1 || funcname || hash || result7 || libp) ;
07029 }
07030
07031
07032 typedef TGridCollection G__TTGridCollection;
07033 static int G__G__Net_215_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07034 {
07035 char* gvp = (char*) G__getgvp();
07036 long soff = G__getstructoffset();
07037 int n = G__getaryconstruct();
07038
07039
07040
07041
07042
07043 if (!soff) {
07044 return(1);
07045 }
07046 if (n) {
07047 if (gvp == (char*)G__PVOID) {
07048 delete[] (TGridCollection*) soff;
07049 } else {
07050 G__setgvp((long) G__PVOID);
07051 for (int i = n - 1; i >= 0; --i) {
07052 ((TGridCollection*) (soff+(sizeof(TGridCollection)*i)))->~G__TTGridCollection();
07053 }
07054 G__setgvp((long)gvp);
07055 }
07056 } else {
07057 if (gvp == (char*)G__PVOID) {
07058 delete (TGridCollection*) soff;
07059 } else {
07060 G__setgvp((long) G__PVOID);
07061 ((TGridCollection*) (soff))->~G__TTGridCollection();
07062 G__setgvp((long)gvp);
07063 }
07064 }
07065 G__setnull(result7);
07066 return(1 || funcname || hash || result7 || libp) ;
07067 }
07068
07069
07070 static int G__G__Net_215_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07071 {
07072 TGridCollection* dest = (TGridCollection*) G__getstructoffset();
07073 *dest = *(TGridCollection*) libp->para[0].ref;
07074 const TGridCollection& obj = *dest;
07075 result7->ref = (long) (&obj);
07076 result7->obj.i = (long) (&obj);
07077 return(1 || funcname || hash || result7 || libp) ;
07078 }
07079
07080
07081
07082 static int G__G__Net_216_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07083 {
07084 G__letint(result7, 105, (long) ((const TGridJobStatus*) G__getstructoffset())->GetStatus());
07085 return(1 || funcname || hash || result7 || libp) ;
07086 }
07087
07088 static int G__G__Net_216_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07089 {
07090 G__letint(result7, 85, (long) TGridJobStatus::Class());
07091 return(1 || funcname || hash || result7 || libp) ;
07092 }
07093
07094 static int G__G__Net_216_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07095 {
07096 G__letint(result7, 67, (long) TGridJobStatus::Class_Name());
07097 return(1 || funcname || hash || result7 || libp) ;
07098 }
07099
07100 static int G__G__Net_216_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07101 {
07102 G__letint(result7, 115, (long) TGridJobStatus::Class_Version());
07103 return(1 || funcname || hash || result7 || libp) ;
07104 }
07105
07106 static int G__G__Net_216_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07107 {
07108 TGridJobStatus::Dictionary();
07109 G__setnull(result7);
07110 return(1 || funcname || hash || result7 || libp) ;
07111 }
07112
07113 static int G__G__Net_216_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07114 {
07115 ((TGridJobStatus*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
07116 G__setnull(result7);
07117 return(1 || funcname || hash || result7 || libp) ;
07118 }
07119
07120 static int G__G__Net_216_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07121 {
07122 G__letint(result7, 67, (long) TGridJobStatus::DeclFileName());
07123 return(1 || funcname || hash || result7 || libp) ;
07124 }
07125
07126 static int G__G__Net_216_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07127 {
07128 G__letint(result7, 105, (long) TGridJobStatus::ImplFileLine());
07129 return(1 || funcname || hash || result7 || libp) ;
07130 }
07131
07132 static int G__G__Net_216_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07133 {
07134 G__letint(result7, 67, (long) TGridJobStatus::ImplFileName());
07135 return(1 || funcname || hash || result7 || libp) ;
07136 }
07137
07138 static int G__G__Net_216_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07139 {
07140 G__letint(result7, 105, (long) TGridJobStatus::DeclFileLine());
07141 return(1 || funcname || hash || result7 || libp) ;
07142 }
07143
07144
07145 typedef TGridJobStatus G__TTGridJobStatus;
07146 static int G__G__Net_216_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07147 {
07148 char* gvp = (char*) G__getgvp();
07149 long soff = G__getstructoffset();
07150 int n = G__getaryconstruct();
07151
07152
07153
07154
07155
07156 if (!soff) {
07157 return(1);
07158 }
07159 if (n) {
07160 if (gvp == (char*)G__PVOID) {
07161 delete[] (TGridJobStatus*) soff;
07162 } else {
07163 G__setgvp((long) G__PVOID);
07164 for (int i = n - 1; i >= 0; --i) {
07165 ((TGridJobStatus*) (soff+(sizeof(TGridJobStatus)*i)))->~G__TTGridJobStatus();
07166 }
07167 G__setgvp((long)gvp);
07168 }
07169 } else {
07170 if (gvp == (char*)G__PVOID) {
07171 delete (TGridJobStatus*) soff;
07172 } else {
07173 G__setgvp((long) G__PVOID);
07174 ((TGridJobStatus*) (soff))->~G__TTGridJobStatus();
07175 G__setgvp((long)gvp);
07176 }
07177 }
07178 G__setnull(result7);
07179 return(1 || funcname || hash || result7 || libp) ;
07180 }
07181
07182
07183 static int G__G__Net_216_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07184 {
07185 TGridJobStatus* dest = (TGridJobStatus*) G__getstructoffset();
07186 *dest = *(TGridJobStatus*) libp->para[0].ref;
07187 const TGridJobStatus& obj = *dest;
07188 result7->ref = (long) (&obj);
07189 result7->obj.i = (long) (&obj);
07190 return(1 || funcname || hash || result7 || libp) ;
07191 }
07192
07193
07194
07195 static int G__G__Net_217_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07196 {
07197 {
07198 TString* pobj;
07199 TString xobj = ((TGridJob*) G__getstructoffset())->GetJobID();
07200 pobj = new TString(xobj);
07201 result7->obj.i = (long) ((void*) pobj);
07202 result7->ref = result7->obj.i;
07203 G__store_tempobject(*result7);
07204 }
07205 return(1 || funcname || hash || result7 || libp) ;
07206 }
07207
07208 static int G__G__Net_217_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07209 {
07210 G__letint(result7, 85, (long) ((const TGridJob*) G__getstructoffset())->GetJobStatus());
07211 return(1 || funcname || hash || result7 || libp) ;
07212 }
07213
07214 static int G__G__Net_217_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07215 {
07216 switch (libp->paran) {
07217 case 2:
07218 G__letint(result7, 105, (long) ((TGridJob*) G__getstructoffset())->GetOutputSandbox((const char*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])));
07219 break;
07220 case 1:
07221 G__letint(result7, 105, (long) ((TGridJob*) G__getstructoffset())->GetOutputSandbox((const char*) G__int(libp->para[0])));
07222 break;
07223 }
07224 return(1 || funcname || hash || result7 || libp) ;
07225 }
07226
07227 static int G__G__Net_217_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07228 {
07229 G__letint(result7, 103, (long) ((TGridJob*) G__getstructoffset())->Resubmit());
07230 return(1 || funcname || hash || result7 || libp) ;
07231 }
07232
07233 static int G__G__Net_217_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07234 {
07235 G__letint(result7, 103, (long) ((TGridJob*) G__getstructoffset())->Cancel());
07236 return(1 || funcname || hash || result7 || libp) ;
07237 }
07238
07239 static int G__G__Net_217_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07240 {
07241 G__letint(result7, 85, (long) TGridJob::Class());
07242 return(1 || funcname || hash || result7 || libp) ;
07243 }
07244
07245 static int G__G__Net_217_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07246 {
07247 G__letint(result7, 67, (long) TGridJob::Class_Name());
07248 return(1 || funcname || hash || result7 || libp) ;
07249 }
07250
07251 static int G__G__Net_217_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07252 {
07253 G__letint(result7, 115, (long) TGridJob::Class_Version());
07254 return(1 || funcname || hash || result7 || libp) ;
07255 }
07256
07257 static int G__G__Net_217_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07258 {
07259 TGridJob::Dictionary();
07260 G__setnull(result7);
07261 return(1 || funcname || hash || result7 || libp) ;
07262 }
07263
07264 static int G__G__Net_217_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07265 {
07266 ((TGridJob*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
07267 G__setnull(result7);
07268 return(1 || funcname || hash || result7 || libp) ;
07269 }
07270
07271 static int G__G__Net_217_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07272 {
07273 G__letint(result7, 67, (long) TGridJob::DeclFileName());
07274 return(1 || funcname || hash || result7 || libp) ;
07275 }
07276
07277 static int G__G__Net_217_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07278 {
07279 G__letint(result7, 105, (long) TGridJob::ImplFileLine());
07280 return(1 || funcname || hash || result7 || libp) ;
07281 }
07282
07283 static int G__G__Net_217_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07284 {
07285 G__letint(result7, 67, (long) TGridJob::ImplFileName());
07286 return(1 || funcname || hash || result7 || libp) ;
07287 }
07288
07289 static int G__G__Net_217_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07290 {
07291 G__letint(result7, 105, (long) TGridJob::DeclFileLine());
07292 return(1 || funcname || hash || result7 || libp) ;
07293 }
07294
07295
07296 typedef TGridJob G__TTGridJob;
07297 static int G__G__Net_217_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07298 {
07299 char* gvp = (char*) G__getgvp();
07300 long soff = G__getstructoffset();
07301 int n = G__getaryconstruct();
07302
07303
07304
07305
07306
07307 if (!soff) {
07308 return(1);
07309 }
07310 if (n) {
07311 if (gvp == (char*)G__PVOID) {
07312 delete[] (TGridJob*) soff;
07313 } else {
07314 G__setgvp((long) G__PVOID);
07315 for (int i = n - 1; i >= 0; --i) {
07316 ((TGridJob*) (soff+(sizeof(TGridJob)*i)))->~G__TTGridJob();
07317 }
07318 G__setgvp((long)gvp);
07319 }
07320 } else {
07321 if (gvp == (char*)G__PVOID) {
07322 delete (TGridJob*) soff;
07323 } else {
07324 G__setgvp((long) G__PVOID);
07325 ((TGridJob*) (soff))->~G__TTGridJob();
07326 G__setgvp((long)gvp);
07327 }
07328 }
07329 G__setnull(result7);
07330 return(1 || funcname || hash || result7 || libp) ;
07331 }
07332
07333
07334 static int G__G__Net_217_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07335 {
07336 TGridJob* dest = (TGridJob*) G__getstructoffset();
07337 *dest = *(TGridJob*) libp->para[0].ref;
07338 const TGridJob& obj = *dest;
07339 result7->ref = (long) (&obj);
07340 result7->obj.i = (long) (&obj);
07341 return(1 || funcname || hash || result7 || libp) ;
07342 }
07343
07344
07345
07346 static int G__G__Net_218_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07347 {
07348 ((TGridJDL*) G__getstructoffset())->SetValue((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
07349 G__setnull(result7);
07350 return(1 || funcname || hash || result7 || libp) ;
07351 }
07352
07353 static int G__G__Net_218_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07354 {
07355 G__letint(result7, 67, (long) ((TGridJDL*) G__getstructoffset())->GetValue((const char*) G__int(libp->para[0])));
07356 return(1 || funcname || hash || result7 || libp) ;
07357 }
07358
07359 static int G__G__Net_218_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07360 {
07361 ((TGridJDL*) G__getstructoffset())->SetDescription((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
07362 G__setnull(result7);
07363 return(1 || funcname || hash || result7 || libp) ;
07364 }
07365
07366 static int G__G__Net_218_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07367 {
07368 G__letint(result7, 67, (long) ((TGridJDL*) G__getstructoffset())->GetDescription((const char*) G__int(libp->para[0])));
07369 return(1 || funcname || hash || result7 || libp) ;
07370 }
07371
07372 static int G__G__Net_218_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07373 {
07374 {
07375 TString* pobj;
07376 TString xobj = ((TGridJDL*) G__getstructoffset())->AddQuotes((const char*) G__int(libp->para[0]));
07377 pobj = new TString(xobj);
07378 result7->obj.i = (long) ((void*) pobj);
07379 result7->ref = result7->obj.i;
07380 G__store_tempobject(*result7);
07381 }
07382 return(1 || funcname || hash || result7 || libp) ;
07383 }
07384
07385 static int G__G__Net_218_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07386 {
07387 ((TGridJDL*) G__getstructoffset())->AddToSet((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
07388 G__setnull(result7);
07389 return(1 || funcname || hash || result7 || libp) ;
07390 }
07391
07392 static int G__G__Net_218_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07393 {
07394 ((TGridJDL*) G__getstructoffset())->AddToSetDescription((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
07395 G__setnull(result7);
07396 return(1 || funcname || hash || result7 || libp) ;
07397 }
07398
07399 static int G__G__Net_218_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07400 {
07401 {
07402 TString* pobj;
07403 TString xobj = ((TGridJDL*) G__getstructoffset())->Generate();
07404 pobj = new TString(xobj);
07405 result7->obj.i = (long) ((void*) pobj);
07406 result7->ref = result7->obj.i;
07407 G__store_tempobject(*result7);
07408 }
07409 return(1 || funcname || hash || result7 || libp) ;
07410 }
07411
07412 static int G__G__Net_218_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07413 {
07414 switch (libp->paran) {
07415 case 2:
07416 ((TGridJDL*) G__getstructoffset())->SetExecutable((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
07417 G__setnull(result7);
07418 break;
07419 case 1:
07420 ((TGridJDL*) G__getstructoffset())->SetExecutable((const char*) G__int(libp->para[0]));
07421 G__setnull(result7);
07422 break;
07423 case 0:
07424 ((TGridJDL*) G__getstructoffset())->SetExecutable();
07425 G__setnull(result7);
07426 break;
07427 }
07428 return(1 || funcname || hash || result7 || libp) ;
07429 }
07430
07431 static int G__G__Net_218_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07432 {
07433 switch (libp->paran) {
07434 case 2:
07435 ((TGridJDL*) G__getstructoffset())->SetArguments((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
07436 G__setnull(result7);
07437 break;
07438 case 1:
07439 ((TGridJDL*) G__getstructoffset())->SetArguments((const char*) G__int(libp->para[0]));
07440 G__setnull(result7);
07441 break;
07442 case 0:
07443 ((TGridJDL*) G__getstructoffset())->SetArguments();
07444 G__setnull(result7);
07445 break;
07446 }
07447 return(1 || funcname || hash || result7 || libp) ;
07448 }
07449
07450 static int G__G__Net_218_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07451 {
07452 switch (libp->paran) {
07453 case 2:
07454 ((TGridJDL*) G__getstructoffset())->SetEMail((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
07455 G__setnull(result7);
07456 break;
07457 case 1:
07458 ((TGridJDL*) G__getstructoffset())->SetEMail((const char*) G__int(libp->para[0]));
07459 G__setnull(result7);
07460 break;
07461 case 0:
07462 ((TGridJDL*) G__getstructoffset())->SetEMail();
07463 G__setnull(result7);
07464 break;
07465 }
07466 return(1 || funcname || hash || result7 || libp) ;
07467 }
07468
07469 static int G__G__Net_218_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07470 {
07471 switch (libp->paran) {
07472 case 2:
07473 ((TGridJDL*) G__getstructoffset())->SetOutputDirectory((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
07474 G__setnull(result7);
07475 break;
07476 case 1:
07477 ((TGridJDL*) G__getstructoffset())->SetOutputDirectory((const char*) G__int(libp->para[0]));
07478 G__setnull(result7);
07479 break;
07480 case 0:
07481 ((TGridJDL*) G__getstructoffset())->SetOutputDirectory();
07482 G__setnull(result7);
07483 break;
07484 }
07485 return(1 || funcname || hash || result7 || libp) ;
07486 }
07487
07488 static int G__G__Net_218_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07489 {
07490 switch (libp->paran) {
07491 case 2:
07492 ((TGridJDL*) G__getstructoffset())->SetPrice((UInt_t) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
07493 G__setnull(result7);
07494 break;
07495 case 1:
07496 ((TGridJDL*) G__getstructoffset())->SetPrice((UInt_t) G__int(libp->para[0]));
07497 G__setnull(result7);
07498 break;
07499 case 0:
07500 ((TGridJDL*) G__getstructoffset())->SetPrice();
07501 G__setnull(result7);
07502 break;
07503 }
07504 return(1 || funcname || hash || result7 || libp) ;
07505 }
07506
07507 static int G__G__Net_218_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07508 {
07509 switch (libp->paran) {
07510 case 2:
07511 ((TGridJDL*) G__getstructoffset())->SetTTL((UInt_t) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
07512 G__setnull(result7);
07513 break;
07514 case 1:
07515 ((TGridJDL*) G__getstructoffset())->SetTTL((UInt_t) G__int(libp->para[0]));
07516 G__setnull(result7);
07517 break;
07518 case 0:
07519 ((TGridJDL*) G__getstructoffset())->SetTTL();
07520 G__setnull(result7);
07521 break;
07522 }
07523 return(1 || funcname || hash || result7 || libp) ;
07524 }
07525
07526 static int G__G__Net_218_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07527 {
07528 switch (libp->paran) {
07529 case 2:
07530 ((TGridJDL*) G__getstructoffset())->SetJobTag((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
07531 G__setnull(result7);
07532 break;
07533 case 1:
07534 ((TGridJDL*) G__getstructoffset())->SetJobTag((const char*) G__int(libp->para[0]));
07535 G__setnull(result7);
07536 break;
07537 case 0:
07538 ((TGridJDL*) G__getstructoffset())->SetJobTag();
07539 G__setnull(result7);
07540 break;
07541 }
07542 return(1 || funcname || hash || result7 || libp) ;
07543 }
07544
07545 static int G__G__Net_218_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07546 {
07547 switch (libp->paran) {
07548 case 2:
07549 ((TGridJDL*) G__getstructoffset())->SetInputDataListFormat((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
07550 G__setnull(result7);
07551 break;
07552 case 1:
07553 ((TGridJDL*) G__getstructoffset())->SetInputDataListFormat((const char*) G__int(libp->para[0]));
07554 G__setnull(result7);
07555 break;
07556 case 0:
07557 ((TGridJDL*) G__getstructoffset())->SetInputDataListFormat();
07558 G__setnull(result7);
07559 break;
07560 }
07561 return(1 || funcname || hash || result7 || libp) ;
07562 }
07563
07564 static int G__G__Net_218_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07565 {
07566 switch (libp->paran) {
07567 case 2:
07568 ((TGridJDL*) G__getstructoffset())->SetInputDataList((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
07569 G__setnull(result7);
07570 break;
07571 case 1:
07572 ((TGridJDL*) G__getstructoffset())->SetInputDataList((const char*) G__int(libp->para[0]));
07573 G__setnull(result7);
07574 break;
07575 case 0:
07576 ((TGridJDL*) G__getstructoffset())->SetInputDataList();
07577 G__setnull(result7);
07578 break;
07579 }
07580 return(1 || funcname || hash || result7 || libp) ;
07581 }
07582
07583 static int G__G__Net_218_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07584 {
07585 switch (libp->paran) {
07586 case 6:
07587 ((TGridJDL*) G__getstructoffset())->SetSplitMode((const char*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
07588 , (UInt_t) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
07589 , (const char*) G__int(libp->para[4]), (const char*) G__int(libp->para[5]));
07590 G__setnull(result7);
07591 break;
07592 case 5:
07593 ((TGridJDL*) G__getstructoffset())->SetSplitMode((const char*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
07594 , (UInt_t) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
07595 , (const char*) G__int(libp->para[4]));
07596 G__setnull(result7);
07597 break;
07598 case 4:
07599 ((TGridJDL*) G__getstructoffset())->SetSplitMode((const char*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
07600 , (UInt_t) G__int(libp->para[2]), (const char*) G__int(libp->para[3]));
07601 G__setnull(result7);
07602 break;
07603 case 3:
07604 ((TGridJDL*) G__getstructoffset())->SetSplitMode((const char*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
07605 , (UInt_t) G__int(libp->para[2]));
07606 G__setnull(result7);
07607 break;
07608 case 2:
07609 ((TGridJDL*) G__getstructoffset())->SetSplitMode((const char*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
07610 G__setnull(result7);
07611 break;
07612 case 1:
07613 ((TGridJDL*) G__getstructoffset())->SetSplitMode((const char*) G__int(libp->para[0]));
07614 G__setnull(result7);
07615 break;
07616 }
07617 return(1 || funcname || hash || result7 || libp) ;
07618 }
07619
07620 static int G__G__Net_218_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07621 {
07622 switch (libp->paran) {
07623 case 2:
07624 ((TGridJDL*) G__getstructoffset())->SetSplitArguments((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
07625 G__setnull(result7);
07626 break;
07627 case 1:
07628 ((TGridJDL*) G__getstructoffset())->SetSplitArguments((const char*) G__int(libp->para[0]));
07629 G__setnull(result7);
07630 break;
07631 case 0:
07632 ((TGridJDL*) G__getstructoffset())->SetSplitArguments();
07633 G__setnull(result7);
07634 break;
07635 }
07636 return(1 || funcname || hash || result7 || libp) ;
07637 }
07638
07639 static int G__G__Net_218_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07640 {
07641 switch (libp->paran) {
07642 case 2:
07643 ((TGridJDL*) G__getstructoffset())->SetValidationCommand((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
07644 G__setnull(result7);
07645 break;
07646 case 1:
07647 ((TGridJDL*) G__getstructoffset())->SetValidationCommand((const char*) G__int(libp->para[0]));
07648 G__setnull(result7);
07649 break;
07650 }
07651 return(1 || funcname || hash || result7 || libp) ;
07652 }
07653
07654 static int G__G__Net_218_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07655 {
07656 switch (libp->paran) {
07657 case 2:
07658 ((TGridJDL*) G__getstructoffset())->AddToInputSandbox((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
07659 G__setnull(result7);
07660 break;
07661 case 1:
07662 ((TGridJDL*) G__getstructoffset())->AddToInputSandbox((const char*) G__int(libp->para[0]));
07663 G__setnull(result7);
07664 break;
07665 case 0:
07666 ((TGridJDL*) G__getstructoffset())->AddToInputSandbox();
07667 G__setnull(result7);
07668 break;
07669 }
07670 return(1 || funcname || hash || result7 || libp) ;
07671 }
07672
07673 static int G__G__Net_218_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07674 {
07675 switch (libp->paran) {
07676 case 2:
07677 ((TGridJDL*) G__getstructoffset())->AddToOutputSandbox((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
07678 G__setnull(result7);
07679 break;
07680 case 1:
07681 ((TGridJDL*) G__getstructoffset())->AddToOutputSandbox((const char*) G__int(libp->para[0]));
07682 G__setnull(result7);
07683 break;
07684 case 0:
07685 ((TGridJDL*) G__getstructoffset())->AddToOutputSandbox();
07686 G__setnull(result7);
07687 break;
07688 }
07689 return(1 || funcname || hash || result7 || libp) ;
07690 }
07691
07692 static int G__G__Net_218_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07693 {
07694 switch (libp->paran) {
07695 case 2:
07696 ((TGridJDL*) G__getstructoffset())->AddToInputData((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
07697 G__setnull(result7);
07698 break;
07699 case 1:
07700 ((TGridJDL*) G__getstructoffset())->AddToInputData((const char*) G__int(libp->para[0]));
07701 G__setnull(result7);
07702 break;
07703 case 0:
07704 ((TGridJDL*) G__getstructoffset())->AddToInputData();
07705 G__setnull(result7);
07706 break;
07707 }
07708 return(1 || funcname || hash || result7 || libp) ;
07709 }
07710
07711 static int G__G__Net_218_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07712 {
07713 switch (libp->paran) {
07714 case 2:
07715 ((TGridJDL*) G__getstructoffset())->AddToInputDataCollection((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
07716 G__setnull(result7);
07717 break;
07718 case 1:
07719 ((TGridJDL*) G__getstructoffset())->AddToInputDataCollection((const char*) G__int(libp->para[0]));
07720 G__setnull(result7);
07721 break;
07722 case 0:
07723 ((TGridJDL*) G__getstructoffset())->AddToInputDataCollection();
07724 G__setnull(result7);
07725 break;
07726 }
07727 return(1 || funcname || hash || result7 || libp) ;
07728 }
07729
07730 static int G__G__Net_218_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07731 {
07732 switch (libp->paran) {
07733 case 2:
07734 ((TGridJDL*) G__getstructoffset())->AddToRequirements((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
07735 G__setnull(result7);
07736 break;
07737 case 1:
07738 ((TGridJDL*) G__getstructoffset())->AddToRequirements((const char*) G__int(libp->para[0]));
07739 G__setnull(result7);
07740 break;
07741 case 0:
07742 ((TGridJDL*) G__getstructoffset())->AddToRequirements();
07743 G__setnull(result7);
07744 break;
07745 }
07746 return(1 || funcname || hash || result7 || libp) ;
07747 }
07748
07749 static int G__G__Net_218_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07750 {
07751 switch (libp->paran) {
07752 case 4:
07753 ((TGridJDL*) G__getstructoffset())->AddToPackages((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
07754 , (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3]));
07755 G__setnull(result7);
07756 break;
07757 case 3:
07758 ((TGridJDL*) G__getstructoffset())->AddToPackages((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
07759 , (const char*) G__int(libp->para[2]));
07760 G__setnull(result7);
07761 break;
07762 case 2:
07763 ((TGridJDL*) G__getstructoffset())->AddToPackages((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
07764 G__setnull(result7);
07765 break;
07766 case 1:
07767 ((TGridJDL*) G__getstructoffset())->AddToPackages((const char*) G__int(libp->para[0]));
07768 G__setnull(result7);
07769 break;
07770 case 0:
07771 ((TGridJDL*) G__getstructoffset())->AddToPackages();
07772 G__setnull(result7);
07773 break;
07774 }
07775 return(1 || funcname || hash || result7 || libp) ;
07776 }
07777
07778 static int G__G__Net_218_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07779 {
07780 switch (libp->paran) {
07781 case 2:
07782 ((TGridJDL*) G__getstructoffset())->AddToOutputArchive((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
07783 G__setnull(result7);
07784 break;
07785 case 1:
07786 ((TGridJDL*) G__getstructoffset())->AddToOutputArchive((const char*) G__int(libp->para[0]));
07787 G__setnull(result7);
07788 break;
07789 case 0:
07790 ((TGridJDL*) G__getstructoffset())->AddToOutputArchive();
07791 G__setnull(result7);
07792 break;
07793 }
07794 return(1 || funcname || hash || result7 || libp) ;
07795 }
07796
07797 static int G__G__Net_218_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07798 {
07799 G__letint(result7, 85, (long) TGridJDL::Class());
07800 return(1 || funcname || hash || result7 || libp) ;
07801 }
07802
07803 static int G__G__Net_218_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07804 {
07805 G__letint(result7, 67, (long) TGridJDL::Class_Name());
07806 return(1 || funcname || hash || result7 || libp) ;
07807 }
07808
07809 static int G__G__Net_218_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07810 {
07811 G__letint(result7, 115, (long) TGridJDL::Class_Version());
07812 return(1 || funcname || hash || result7 || libp) ;
07813 }
07814
07815 static int G__G__Net_218_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07816 {
07817 TGridJDL::Dictionary();
07818 G__setnull(result7);
07819 return(1 || funcname || hash || result7 || libp) ;
07820 }
07821
07822 static int G__G__Net_218_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07823 {
07824 ((TGridJDL*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
07825 G__setnull(result7);
07826 return(1 || funcname || hash || result7 || libp) ;
07827 }
07828
07829 static int G__G__Net_218_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07830 {
07831 G__letint(result7, 67, (long) TGridJDL::DeclFileName());
07832 return(1 || funcname || hash || result7 || libp) ;
07833 }
07834
07835 static int G__G__Net_218_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07836 {
07837 G__letint(result7, 105, (long) TGridJDL::ImplFileLine());
07838 return(1 || funcname || hash || result7 || libp) ;
07839 }
07840
07841 static int G__G__Net_218_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07842 {
07843 G__letint(result7, 67, (long) TGridJDL::ImplFileName());
07844 return(1 || funcname || hash || result7 || libp) ;
07845 }
07846
07847 static int G__G__Net_218_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07848 {
07849 G__letint(result7, 105, (long) TGridJDL::DeclFileLine());
07850 return(1 || funcname || hash || result7 || libp) ;
07851 }
07852
07853
07854 typedef TGridJDL G__TTGridJDL;
07855 static int G__G__Net_218_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07856 {
07857 char* gvp = (char*) G__getgvp();
07858 long soff = G__getstructoffset();
07859 int n = G__getaryconstruct();
07860
07861
07862
07863
07864
07865 if (!soff) {
07866 return(1);
07867 }
07868 if (n) {
07869 if (gvp == (char*)G__PVOID) {
07870 delete[] (TGridJDL*) soff;
07871 } else {
07872 G__setgvp((long) G__PVOID);
07873 for (int i = n - 1; i >= 0; --i) {
07874 ((TGridJDL*) (soff+(sizeof(TGridJDL)*i)))->~G__TTGridJDL();
07875 }
07876 G__setgvp((long)gvp);
07877 }
07878 } else {
07879 if (gvp == (char*)G__PVOID) {
07880 delete (TGridJDL*) soff;
07881 } else {
07882 G__setgvp((long) G__PVOID);
07883 ((TGridJDL*) (soff))->~G__TTGridJDL();
07884 G__setgvp((long)gvp);
07885 }
07886 }
07887 G__setnull(result7);
07888 return(1 || funcname || hash || result7 || libp) ;
07889 }
07890
07891
07892
07893 static int G__G__Net_219_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07894 {
07895 TGridJobStatusList* p = NULL;
07896 char* gvp = (char*) G__getgvp();
07897 int n = G__getaryconstruct();
07898 if (n) {
07899 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07900 p = new TGridJobStatusList[n];
07901 } else {
07902 p = new((void*) gvp) TGridJobStatusList[n];
07903 }
07904 } else {
07905 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07906 p = new TGridJobStatusList;
07907 } else {
07908 p = new((void*) gvp) TGridJobStatusList;
07909 }
07910 }
07911 result7->obj.i = (long) p;
07912 result7->ref = (long) p;
07913 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__NetLN_TGridJobStatusList));
07914 return(1 || funcname || hash || result7 || libp) ;
07915 }
07916
07917 static int G__G__Net_219_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07918 {
07919 G__letint(result7, 85, (long) TGridJobStatusList::Class());
07920 return(1 || funcname || hash || result7 || libp) ;
07921 }
07922
07923 static int G__G__Net_219_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07924 {
07925 G__letint(result7, 67, (long) TGridJobStatusList::Class_Name());
07926 return(1 || funcname || hash || result7 || libp) ;
07927 }
07928
07929 static int G__G__Net_219_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07930 {
07931 G__letint(result7, 115, (long) TGridJobStatusList::Class_Version());
07932 return(1 || funcname || hash || result7 || libp) ;
07933 }
07934
07935 static int G__G__Net_219_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07936 {
07937 TGridJobStatusList::Dictionary();
07938 G__setnull(result7);
07939 return(1 || funcname || hash || result7 || libp) ;
07940 }
07941
07942 static int G__G__Net_219_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07943 {
07944 ((TGridJobStatusList*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
07945 G__setnull(result7);
07946 return(1 || funcname || hash || result7 || libp) ;
07947 }
07948
07949 static int G__G__Net_219_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07950 {
07951 G__letint(result7, 67, (long) TGridJobStatusList::DeclFileName());
07952 return(1 || funcname || hash || result7 || libp) ;
07953 }
07954
07955 static int G__G__Net_219_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07956 {
07957 G__letint(result7, 105, (long) TGridJobStatusList::ImplFileLine());
07958 return(1 || funcname || hash || result7 || libp) ;
07959 }
07960
07961 static int G__G__Net_219_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07962 {
07963 G__letint(result7, 67, (long) TGridJobStatusList::ImplFileName());
07964 return(1 || funcname || hash || result7 || libp) ;
07965 }
07966
07967 static int G__G__Net_219_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07968 {
07969 G__letint(result7, 105, (long) TGridJobStatusList::DeclFileLine());
07970 return(1 || funcname || hash || result7 || libp) ;
07971 }
07972
07973
07974 typedef TGridJobStatusList G__TTGridJobStatusList;
07975 static int G__G__Net_219_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07976 {
07977 char* gvp = (char*) G__getgvp();
07978 long soff = G__getstructoffset();
07979 int n = G__getaryconstruct();
07980
07981
07982
07983
07984
07985 if (!soff) {
07986 return(1);
07987 }
07988 if (n) {
07989 if (gvp == (char*)G__PVOID) {
07990 delete[] (TGridJobStatusList*) soff;
07991 } else {
07992 G__setgvp((long) G__PVOID);
07993 for (int i = n - 1; i >= 0; --i) {
07994 ((TGridJobStatusList*) (soff+(sizeof(TGridJobStatusList)*i)))->~G__TTGridJobStatusList();
07995 }
07996 G__setgvp((long)gvp);
07997 }
07998 } else {
07999 if (gvp == (char*)G__PVOID) {
08000 delete (TGridJobStatusList*) soff;
08001 } else {
08002 G__setgvp((long) G__PVOID);
08003 ((TGridJobStatusList*) (soff))->~G__TTGridJobStatusList();
08004 G__setgvp((long)gvp);
08005 }
08006 }
08007 G__setnull(result7);
08008 return(1 || funcname || hash || result7 || libp) ;
08009 }
08010
08011
08012
08013 static int G__G__Net_220_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08014 {
08015 TGrid* p = NULL;
08016 char* gvp = (char*) G__getgvp();
08017 int n = G__getaryconstruct();
08018 if (n) {
08019 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08020 p = new TGrid[n];
08021 } else {
08022 p = new((void*) gvp) TGrid[n];
08023 }
08024 } else {
08025 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08026 p = new TGrid;
08027 } else {
08028 p = new((void*) gvp) TGrid;
08029 }
08030 }
08031 result7->obj.i = (long) p;
08032 result7->ref = (long) p;
08033 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__NetLN_TGrid));
08034 return(1 || funcname || hash || result7 || libp) ;
08035 }
08036
08037 static int G__G__Net_220_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08038 {
08039 G__letint(result7, 67, (long) ((const TGrid*) G__getstructoffset())->GridUrl());
08040 return(1 || funcname || hash || result7 || libp) ;
08041 }
08042
08043 static int G__G__Net_220_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08044 {
08045 G__letint(result7, 67, (long) ((const TGrid*) G__getstructoffset())->GetGrid());
08046 return(1 || funcname || hash || result7 || libp) ;
08047 }
08048
08049 static int G__G__Net_220_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08050 {
08051 G__letint(result7, 67, (long) ((const TGrid*) G__getstructoffset())->GetHost());
08052 return(1 || funcname || hash || result7 || libp) ;
08053 }
08054
08055 static int G__G__Net_220_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08056 {
08057 G__letint(result7, 67, (long) ((const TGrid*) G__getstructoffset())->GetUser());
08058 return(1 || funcname || hash || result7 || libp) ;
08059 }
08060
08061 static int G__G__Net_220_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08062 {
08063 G__letint(result7, 67, (long) ((const TGrid*) G__getstructoffset())->GetPw());
08064 return(1 || funcname || hash || result7 || libp) ;
08065 }
08066
08067 static int G__G__Net_220_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08068 {
08069 G__letint(result7, 67, (long) ((const TGrid*) G__getstructoffset())->GetOptions());
08070 return(1 || funcname || hash || result7 || libp) ;
08071 }
08072
08073 static int G__G__Net_220_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08074 {
08075 G__letint(result7, 105, (long) ((const TGrid*) G__getstructoffset())->GetPort());
08076 return(1 || funcname || hash || result7 || libp) ;
08077 }
08078
08079 static int G__G__Net_220_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08080 {
08081 G__letint(result7, 103, (long) ((const TGrid*) G__getstructoffset())->IsConnected());
08082 return(1 || funcname || hash || result7 || libp) ;
08083 }
08084
08085 static int G__G__Net_220_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08086 {
08087 ((TGrid*) G__getstructoffset())->Shell();
08088 G__setnull(result7);
08089 return(1 || funcname || hash || result7 || libp) ;
08090 }
08091
08092 static int G__G__Net_220_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08093 {
08094 ((TGrid*) G__getstructoffset())->Stdout();
08095 G__setnull(result7);
08096 return(1 || funcname || hash || result7 || libp) ;
08097 }
08098
08099 static int G__G__Net_220_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08100 {
08101 ((TGrid*) G__getstructoffset())->Stderr();
08102 G__setnull(result7);
08103 return(1 || funcname || hash || result7 || libp) ;
08104 }
08105
08106 static int G__G__Net_220_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08107 {
08108 switch (libp->paran) {
08109 case 3:
08110 G__letint(result7, 85, (long) ((TGrid*) G__getstructoffset())->Command((const char*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])
08111 , (UInt_t) G__int(libp->para[2])));
08112 break;
08113 case 2:
08114 G__letint(result7, 85, (long) ((TGrid*) G__getstructoffset())->Command((const char*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])));
08115 break;
08116 case 1:
08117 G__letint(result7, 85, (long) ((TGrid*) G__getstructoffset())->Command((const char*) G__int(libp->para[0])));
08118 break;
08119 }
08120 return(1 || funcname || hash || result7 || libp) ;
08121 }
08122
08123 static int G__G__Net_220_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08124 {
08125 switch (libp->paran) {
08126 case 4:
08127 G__letint(result7, 85, (long) ((TGrid*) G__getstructoffset())->Query((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
08128 , (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])));
08129 break;
08130 case 3:
08131 G__letint(result7, 85, (long) ((TGrid*) G__getstructoffset())->Query((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
08132 , (const char*) G__int(libp->para[2])));
08133 break;
08134 case 2:
08135 G__letint(result7, 85, (long) ((TGrid*) G__getstructoffset())->Query((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
08136 break;
08137 }
08138 return(1 || funcname || hash || result7 || libp) ;
08139 }
08140
08141 static int G__G__Net_220_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08142 {
08143 G__letint(result7, 85, (long) ((TGrid*) G__getstructoffset())->LocateSites());
08144 return(1 || funcname || hash || result7 || libp) ;
08145 }
08146
08147 static int G__G__Net_220_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08148 {
08149 switch (libp->paran) {
08150 case 3:
08151 G__letint(result7, 85, (long) ((TGrid*) G__getstructoffset())->Ls((const char*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
08152 , (Bool_t) G__int(libp->para[2])));
08153 break;
08154 case 2:
08155 G__letint(result7, 85, (long) ((TGrid*) G__getstructoffset())->Ls((const char*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])));
08156 break;
08157 case 1:
08158 G__letint(result7, 85, (long) ((TGrid*) G__getstructoffset())->Ls((const char*) G__int(libp->para[0])));
08159 break;
08160 case 0:
08161 G__letint(result7, 85, (long) ((TGrid*) G__getstructoffset())->Ls());
08162 break;
08163 }
08164 return(1 || funcname || hash || result7 || libp) ;
08165 }
08166
08167 static int G__G__Net_220_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08168 {
08169 switch (libp->paran) {
08170 case 1:
08171 G__letint(result7, 67, (long) ((TGrid*) G__getstructoffset())->Pwd((Bool_t) G__int(libp->para[0])));
08172 break;
08173 case 0:
08174 G__letint(result7, 67, (long) ((TGrid*) G__getstructoffset())->Pwd());
08175 break;
08176 }
08177 return(1 || funcname || hash || result7 || libp) ;
08178 }
08179
08180 static int G__G__Net_220_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08181 {
08182 G__letint(result7, 67, (long) ((TGrid*) G__getstructoffset())->GetHomeDirectory());
08183 return(1 || funcname || hash || result7 || libp) ;
08184 }
08185
08186 static int G__G__Net_220_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08187 {
08188 switch (libp->paran) {
08189 case 2:
08190 G__letint(result7, 103, (long) ((TGrid*) G__getstructoffset())->Cd((const char*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])));
08191 break;
08192 case 1:
08193 G__letint(result7, 103, (long) ((TGrid*) G__getstructoffset())->Cd((const char*) G__int(libp->para[0])));
08194 break;
08195 case 0:
08196 G__letint(result7, 103, (long) ((TGrid*) G__getstructoffset())->Cd());
08197 break;
08198 }
08199 return(1 || funcname || hash || result7 || libp) ;
08200 }
08201
08202 static int G__G__Net_220_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08203 {
08204 switch (libp->paran) {
08205 case 3:
08206 G__letint(result7, 105, (long) ((TGrid*) G__getstructoffset())->Mkdir((const char*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
08207 , (Bool_t) G__int(libp->para[2])));
08208 break;
08209 case 2:
08210 G__letint(result7, 105, (long) ((TGrid*) G__getstructoffset())->Mkdir((const char*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])));
08211 break;
08212 case 1:
08213 G__letint(result7, 105, (long) ((TGrid*) G__getstructoffset())->Mkdir((const char*) G__int(libp->para[0])));
08214 break;
08215 case 0:
08216 G__letint(result7, 105, (long) ((TGrid*) G__getstructoffset())->Mkdir());
08217 break;
08218 }
08219 return(1 || funcname || hash || result7 || libp) ;
08220 }
08221
08222 static int G__G__Net_220_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08223 {
08224 switch (libp->paran) {
08225 case 3:
08226 G__letint(result7, 103, (long) ((TGrid*) G__getstructoffset())->Rmdir((const char*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
08227 , (Bool_t) G__int(libp->para[2])));
08228 break;
08229 case 2:
08230 G__letint(result7, 103, (long) ((TGrid*) G__getstructoffset())->Rmdir((const char*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])));
08231 break;
08232 case 1:
08233 G__letint(result7, 103, (long) ((TGrid*) G__getstructoffset())->Rmdir((const char*) G__int(libp->para[0])));
08234 break;
08235 case 0:
08236 G__letint(result7, 103, (long) ((TGrid*) G__getstructoffset())->Rmdir());
08237 break;
08238 }
08239 return(1 || funcname || hash || result7 || libp) ;
08240 }
08241
08242 static int G__G__Net_220_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08243 {
08244 switch (libp->paran) {
08245 case 6:
08246 G__letint(result7, 103, (long) ((TGrid*) G__getstructoffset())->Register((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
08247 , (Long_t) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
08248 , (const char*) G__int(libp->para[4]), (Bool_t) G__int(libp->para[5])));
08249 break;
08250 case 5:
08251 G__letint(result7, 103, (long) ((TGrid*) G__getstructoffset())->Register((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
08252 , (Long_t) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
08253 , (const char*) G__int(libp->para[4])));
08254 break;
08255 case 4:
08256 G__letint(result7, 103, (long) ((TGrid*) G__getstructoffset())->Register((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
08257 , (Long_t) G__int(libp->para[2]), (const char*) G__int(libp->para[3])));
08258 break;
08259 case 3:
08260 G__letint(result7, 103, (long) ((TGrid*) G__getstructoffset())->Register((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
08261 , (Long_t) G__int(libp->para[2])));
08262 break;
08263 case 2:
08264 G__letint(result7, 103, (long) ((TGrid*) G__getstructoffset())->Register((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
08265 break;
08266 }
08267 return(1 || funcname || hash || result7 || libp) ;
08268 }
08269
08270 static int G__G__Net_220_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08271 {
08272 switch (libp->paran) {
08273 case 3:
08274 G__letint(result7, 103, (long) ((TGrid*) G__getstructoffset())->Rm((const char*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
08275 , (Bool_t) G__int(libp->para[2])));
08276 break;
08277 case 2:
08278 G__letint(result7, 103, (long) ((TGrid*) G__getstructoffset())->Rm((const char*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])));
08279 break;
08280 case 1:
08281 G__letint(result7, 103, (long) ((TGrid*) G__getstructoffset())->Rm((const char*) G__int(libp->para[0])));
08282 break;
08283 }
08284 return(1 || funcname || hash || result7 || libp) ;
08285 }
08286
08287 static int G__G__Net_220_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08288 {
08289 G__letint(result7, 85, (long) ((TGrid*) G__getstructoffset())->Submit((const char*) G__int(libp->para[0])));
08290 return(1 || funcname || hash || result7 || libp) ;
08291 }
08292
08293 static int G__G__Net_220_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08294 {
08295 G__letint(result7, 85, (long) ((TGrid*) G__getstructoffset())->GetJDLGenerator());
08296 return(1 || funcname || hash || result7 || libp) ;
08297 }
08298
08299 static int G__G__Net_220_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08300 {
08301 switch (libp->paran) {
08302 case 2:
08303 G__letint(result7, 85, (long) ((TGrid*) G__getstructoffset())->OpenCollection((const char*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])));
08304 break;
08305 case 1:
08306 G__letint(result7, 85, (long) ((TGrid*) G__getstructoffset())->OpenCollection((const char*) G__int(libp->para[0])));
08307 break;
08308 }
08309 return(1 || funcname || hash || result7 || libp) ;
08310 }
08311
08312 static int G__G__Net_220_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08313 {
08314 switch (libp->paran) {
08315 case 2:
08316 G__letint(result7, 85, (long) ((TGrid*) G__getstructoffset())->OpenCollectionQuery((TGridResult*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])));
08317 break;
08318 case 1:
08319 G__letint(result7, 85, (long) ((TGrid*) G__getstructoffset())->OpenCollectionQuery((TGridResult*) G__int(libp->para[0])));
08320 break;
08321 }
08322 return(1 || funcname || hash || result7 || libp) ;
08323 }
08324
08325 static int G__G__Net_220_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08326 {
08327 switch (libp->paran) {
08328 case 2:
08329 G__letint(result7, 85, (long) ((TGrid*) G__getstructoffset())->Ps((const char*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])));
08330 break;
08331 case 1:
08332 G__letint(result7, 85, (long) ((TGrid*) G__getstructoffset())->Ps((const char*) G__int(libp->para[0])));
08333 break;
08334 }
08335 return(1 || funcname || hash || result7 || libp) ;
08336 }
08337
08338 static int G__G__Net_220_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08339 {
08340 G__letint(result7, 103, (long) ((TGrid*) G__getstructoffset())->KillById(*((TString*) G__int(libp->para[0]))));
08341 return(1 || funcname || hash || result7 || libp) ;
08342 }
08343
08344 static int G__G__Net_220_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08345 {
08346 G__letint(result7, 103, (long) ((TGrid*) G__getstructoffset())->ResubmitById(*((TString*) G__int(libp->para[0]))));
08347 return(1 || funcname || hash || result7 || libp) ;
08348 }
08349
08350 static int G__G__Net_220_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08351 {
08352 G__letint(result7, 103, (long) ((TGrid*) G__getstructoffset())->Kill((TGridJob*) G__int(libp->para[0])));
08353 return(1 || funcname || hash || result7 || libp) ;
08354 }
08355
08356 static int G__G__Net_220_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08357 {
08358 G__letint(result7, 103, (long) ((TGrid*) G__getstructoffset())->Resubmit((TGridJob*) G__int(libp->para[0])));
08359 return(1 || funcname || hash || result7 || libp) ;
08360 }
08361
08362 static int G__G__Net_220_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08363 {
08364 switch (libp->paran) {
08365 case 4:
08366 G__letint(result7, 85, (long) TGrid::Connect((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
08367 , (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])));
08368 break;
08369 case 3:
08370 G__letint(result7, 85, (long) TGrid::Connect((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
08371 , (const char*) G__int(libp->para[2])));
08372 break;
08373 case 2:
08374 G__letint(result7, 85, (long) TGrid::Connect((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
08375 break;
08376 case 1:
08377 G__letint(result7, 85, (long) TGrid::Connect((const char*) G__int(libp->para[0])));
08378 break;
08379 }
08380 return(1 || funcname || hash || result7 || libp) ;
08381 }
08382
08383 static int G__G__Net_220_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08384 {
08385 G__letint(result7, 85, (long) TGrid::Class());
08386 return(1 || funcname || hash || result7 || libp) ;
08387 }
08388
08389 static int G__G__Net_220_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08390 {
08391 G__letint(result7, 67, (long) TGrid::Class_Name());
08392 return(1 || funcname || hash || result7 || libp) ;
08393 }
08394
08395 static int G__G__Net_220_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08396 {
08397 G__letint(result7, 115, (long) TGrid::Class_Version());
08398 return(1 || funcname || hash || result7 || libp) ;
08399 }
08400
08401 static int G__G__Net_220_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08402 {
08403 TGrid::Dictionary();
08404 G__setnull(result7);
08405 return(1 || funcname || hash || result7 || libp) ;
08406 }
08407
08408 static int G__G__Net_220_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08409 {
08410 ((TGrid*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
08411 G__setnull(result7);
08412 return(1 || funcname || hash || result7 || libp) ;
08413 }
08414
08415 static int G__G__Net_220_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08416 {
08417 G__letint(result7, 67, (long) TGrid::DeclFileName());
08418 return(1 || funcname || hash || result7 || libp) ;
08419 }
08420
08421 static int G__G__Net_220_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08422 {
08423 G__letint(result7, 105, (long) TGrid::ImplFileLine());
08424 return(1 || funcname || hash || result7 || libp) ;
08425 }
08426
08427 static int G__G__Net_220_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08428 {
08429 G__letint(result7, 67, (long) TGrid::ImplFileName());
08430 return(1 || funcname || hash || result7 || libp) ;
08431 }
08432
08433 static int G__G__Net_220_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08434 {
08435 G__letint(result7, 105, (long) TGrid::DeclFileLine());
08436 return(1 || funcname || hash || result7 || libp) ;
08437 }
08438
08439
08440 static int G__G__Net_220_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08441
08442 {
08443 TGrid* p;
08444 void* tmp = (void*) G__int(libp->para[0]);
08445 p = new TGrid(*(TGrid*) tmp);
08446 result7->obj.i = (long) p;
08447 result7->ref = (long) p;
08448 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__NetLN_TGrid));
08449 return(1 || funcname || hash || result7 || libp) ;
08450 }
08451
08452
08453 typedef TGrid G__TTGrid;
08454 static int G__G__Net_220_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08455 {
08456 char* gvp = (char*) G__getgvp();
08457 long soff = G__getstructoffset();
08458 int n = G__getaryconstruct();
08459
08460
08461
08462
08463
08464 if (!soff) {
08465 return(1);
08466 }
08467 if (n) {
08468 if (gvp == (char*)G__PVOID) {
08469 delete[] (TGrid*) soff;
08470 } else {
08471 G__setgvp((long) G__PVOID);
08472 for (int i = n - 1; i >= 0; --i) {
08473 ((TGrid*) (soff+(sizeof(TGrid)*i)))->~G__TTGrid();
08474 }
08475 G__setgvp((long)gvp);
08476 }
08477 } else {
08478 if (gvp == (char*)G__PVOID) {
08479 delete (TGrid*) soff;
08480 } else {
08481 G__setgvp((long) G__PVOID);
08482 ((TGrid*) (soff))->~G__TTGrid();
08483 G__setgvp((long)gvp);
08484 }
08485 }
08486 G__setnull(result7);
08487 return(1 || funcname || hash || result7 || libp) ;
08488 }
08489
08490
08491 static int G__G__Net_220_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08492 {
08493 TGrid* dest = (TGrid*) G__getstructoffset();
08494 *dest = *(TGrid*) libp->para[0].ref;
08495 const TGrid& obj = *dest;
08496 result7->ref = (long) (&obj);
08497 result7->obj.i = (long) (&obj);
08498 return(1 || funcname || hash || result7 || libp) ;
08499 }
08500
08501
08502
08503 static int G__G__Net_248_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08504 {
08505 TNetFile* p = NULL;
08506 char* gvp = (char*) G__getgvp();
08507 switch (libp->paran) {
08508 case 5:
08509
08510 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08511 p = new TNetFile(
08512 (const char*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
08513 , (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
08514 , (Int_t) G__int(libp->para[4]));
08515 } else {
08516 p = new((void*) gvp) TNetFile(
08517 (const char*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
08518 , (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
08519 , (Int_t) G__int(libp->para[4]));
08520 }
08521 break;
08522 case 4:
08523
08524 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08525 p = new TNetFile(
08526 (const char*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
08527 , (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
08528 } else {
08529 p = new((void*) gvp) TNetFile(
08530 (const char*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
08531 , (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
08532 }
08533 break;
08534 case 3:
08535
08536 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08537 p = new TNetFile(
08538 (const char*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
08539 , (const char*) G__int(libp->para[2]));
08540 } else {
08541 p = new((void*) gvp) TNetFile(
08542 (const char*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
08543 , (const char*) G__int(libp->para[2]));
08544 }
08545 break;
08546 case 2:
08547
08548 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08549 p = new TNetFile((const char*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1]));
08550 } else {
08551 p = new((void*) gvp) TNetFile((const char*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1]));
08552 }
08553 break;
08554 case 1:
08555
08556 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08557 p = new TNetFile((const char*) G__int(libp->para[0]));
08558 } else {
08559 p = new((void*) gvp) TNetFile((const char*) G__int(libp->para[0]));
08560 }
08561 break;
08562 }
08563 result7->obj.i = (long) p;
08564 result7->ref = (long) p;
08565 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__NetLN_TNetFile));
08566 return(1 || funcname || hash || result7 || libp) ;
08567 }
08568
08569 static int G__G__Net_248_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08570 {
08571 TNetFile* p = NULL;
08572 char* gvp = (char*) G__getgvp();
08573 int n = G__getaryconstruct();
08574 if (n) {
08575 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08576 p = new TNetFile[n];
08577 } else {
08578 p = new((void*) gvp) TNetFile[n];
08579 }
08580 } else {
08581 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08582 p = new TNetFile;
08583 } else {
08584 p = new((void*) gvp) TNetFile;
08585 }
08586 }
08587 result7->obj.i = (long) p;
08588 result7->ref = (long) p;
08589 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__NetLN_TNetFile));
08590 return(1 || funcname || hash || result7 || libp) ;
08591 }
08592
08593 static int G__G__Net_248_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08594 {
08595 G__letint(result7, 105, (long) ((const TNetFile*) G__getstructoffset())->GetErrorCode());
08596 return(1 || funcname || hash || result7 || libp) ;
08597 }
08598
08599 static int G__G__Net_248_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08600 {
08601 G__letint(result7, 85, (long) TNetFile::Class());
08602 return(1 || funcname || hash || result7 || libp) ;
08603 }
08604
08605 static int G__G__Net_248_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08606 {
08607 G__letint(result7, 67, (long) TNetFile::Class_Name());
08608 return(1 || funcname || hash || result7 || libp) ;
08609 }
08610
08611 static int G__G__Net_248_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08612 {
08613 G__letint(result7, 115, (long) TNetFile::Class_Version());
08614 return(1 || funcname || hash || result7 || libp) ;
08615 }
08616
08617 static int G__G__Net_248_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08618 {
08619 TNetFile::Dictionary();
08620 G__setnull(result7);
08621 return(1 || funcname || hash || result7 || libp) ;
08622 }
08623
08624 static int G__G__Net_248_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08625 {
08626 ((TNetFile*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
08627 G__setnull(result7);
08628 return(1 || funcname || hash || result7 || libp) ;
08629 }
08630
08631 static int G__G__Net_248_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08632 {
08633 G__letint(result7, 67, (long) TNetFile::DeclFileName());
08634 return(1 || funcname || hash || result7 || libp) ;
08635 }
08636
08637 static int G__G__Net_248_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08638 {
08639 G__letint(result7, 105, (long) TNetFile::ImplFileLine());
08640 return(1 || funcname || hash || result7 || libp) ;
08641 }
08642
08643 static int G__G__Net_248_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08644 {
08645 G__letint(result7, 67, (long) TNetFile::ImplFileName());
08646 return(1 || funcname || hash || result7 || libp) ;
08647 }
08648
08649 static int G__G__Net_248_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08650 {
08651 G__letint(result7, 105, (long) TNetFile::DeclFileLine());
08652 return(1 || funcname || hash || result7 || libp) ;
08653 }
08654
08655
08656 typedef TNetFile G__TTNetFile;
08657 static int G__G__Net_248_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08658 {
08659 char* gvp = (char*) G__getgvp();
08660 long soff = G__getstructoffset();
08661 int n = G__getaryconstruct();
08662
08663
08664
08665
08666
08667 if (!soff) {
08668 return(1);
08669 }
08670 if (n) {
08671 if (gvp == (char*)G__PVOID) {
08672 delete[] (TNetFile*) soff;
08673 } else {
08674 G__setgvp((long) G__PVOID);
08675 for (int i = n - 1; i >= 0; --i) {
08676 ((TNetFile*) (soff+(sizeof(TNetFile)*i)))->~G__TTNetFile();
08677 }
08678 G__setgvp((long)gvp);
08679 }
08680 } else {
08681 if (gvp == (char*)G__PVOID) {
08682 delete (TNetFile*) soff;
08683 } else {
08684 G__setgvp((long) G__PVOID);
08685 ((TNetFile*) (soff))->~G__TTNetFile();
08686 G__setgvp((long)gvp);
08687 }
08688 }
08689 G__setnull(result7);
08690 return(1 || funcname || hash || result7 || libp) ;
08691 }
08692
08693
08694
08695 static int G__G__Net_249_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08696 {
08697 TNetSystem* p = NULL;
08698 char* gvp = (char*) G__getgvp();
08699 switch (libp->paran) {
08700 case 1:
08701
08702 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08703 p = new TNetSystem((Bool_t) G__int(libp->para[0]));
08704 } else {
08705 p = new((void*) gvp) TNetSystem((Bool_t) G__int(libp->para[0]));
08706 }
08707 break;
08708 case 0:
08709 int n = G__getaryconstruct();
08710 if (n) {
08711 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08712 p = new TNetSystem[n];
08713 } else {
08714 p = new((void*) gvp) TNetSystem[n];
08715 }
08716 } else {
08717 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08718 p = new TNetSystem;
08719 } else {
08720 p = new((void*) gvp) TNetSystem;
08721 }
08722 }
08723 break;
08724 }
08725 result7->obj.i = (long) p;
08726 result7->ref = (long) p;
08727 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__NetLN_TNetSystem));
08728 return(1 || funcname || hash || result7 || libp) ;
08729 }
08730
08731 static int G__G__Net_249_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08732 {
08733 TNetSystem* p = NULL;
08734 char* gvp = (char*) G__getgvp();
08735 switch (libp->paran) {
08736 case 2:
08737
08738 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08739 p = new TNetSystem((const char*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
08740 } else {
08741 p = new((void*) gvp) TNetSystem((const char*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
08742 }
08743 break;
08744 case 1:
08745
08746 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08747 p = new TNetSystem((const char*) G__int(libp->para[0]));
08748 } else {
08749 p = new((void*) gvp) TNetSystem((const char*) G__int(libp->para[0]));
08750 }
08751 break;
08752 }
08753 result7->obj.i = (long) p;
08754 result7->ref = (long) p;
08755 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__NetLN_TNetSystem));
08756 return(1 || funcname || hash || result7 || libp) ;
08757 }
08758
08759 static int G__G__Net_249_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08760 {
08761 switch (libp->paran) {
08762 case 1:
08763 ((TNetSystem*) G__getstructoffset())->FreeDirectory((void*) G__int(libp->para[0]));
08764 G__setnull(result7);
08765 break;
08766 case 0:
08767 ((TNetSystem*) G__getstructoffset())->FreeDirectory();
08768 G__setnull(result7);
08769 break;
08770 }
08771 return(1 || funcname || hash || result7 || libp) ;
08772 }
08773
08774 static int G__G__Net_249_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08775 {
08776 switch (libp->paran) {
08777 case 1:
08778 G__letint(result7, 67, (long) ((TNetSystem*) G__getstructoffset())->GetDirEntry((void*) G__int(libp->para[0])));
08779 break;
08780 case 0:
08781 G__letint(result7, 67, (long) ((TNetSystem*) G__getstructoffset())->GetDirEntry());
08782 break;
08783 }
08784 return(1 || funcname || hash || result7 || libp) ;
08785 }
08786
08787 static int G__G__Net_249_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08788 {
08789 G__letint(result7, 85, (long) TNetSystem::Class());
08790 return(1 || funcname || hash || result7 || libp) ;
08791 }
08792
08793 static int G__G__Net_249_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08794 {
08795 G__letint(result7, 67, (long) TNetSystem::Class_Name());
08796 return(1 || funcname || hash || result7 || libp) ;
08797 }
08798
08799 static int G__G__Net_249_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08800 {
08801 G__letint(result7, 115, (long) TNetSystem::Class_Version());
08802 return(1 || funcname || hash || result7 || libp) ;
08803 }
08804
08805 static int G__G__Net_249_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08806 {
08807 TNetSystem::Dictionary();
08808 G__setnull(result7);
08809 return(1 || funcname || hash || result7 || libp) ;
08810 }
08811
08812 static int G__G__Net_249_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08813 {
08814 ((TNetSystem*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
08815 G__setnull(result7);
08816 return(1 || funcname || hash || result7 || libp) ;
08817 }
08818
08819 static int G__G__Net_249_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08820 {
08821 G__letint(result7, 67, (long) TNetSystem::DeclFileName());
08822 return(1 || funcname || hash || result7 || libp) ;
08823 }
08824
08825 static int G__G__Net_249_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08826 {
08827 G__letint(result7, 105, (long) TNetSystem::ImplFileLine());
08828 return(1 || funcname || hash || result7 || libp) ;
08829 }
08830
08831 static int G__G__Net_249_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08832 {
08833 G__letint(result7, 67, (long) TNetSystem::ImplFileName());
08834 return(1 || funcname || hash || result7 || libp) ;
08835 }
08836
08837 static int G__G__Net_249_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08838 {
08839 G__letint(result7, 105, (long) TNetSystem::DeclFileLine());
08840 return(1 || funcname || hash || result7 || libp) ;
08841 }
08842
08843
08844 typedef TNetSystem G__TTNetSystem;
08845 static int G__G__Net_249_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08846 {
08847 char* gvp = (char*) G__getgvp();
08848 long soff = G__getstructoffset();
08849 int n = G__getaryconstruct();
08850
08851
08852
08853
08854
08855 if (!soff) {
08856 return(1);
08857 }
08858 if (n) {
08859 if (gvp == (char*)G__PVOID) {
08860 delete[] (TNetSystem*) soff;
08861 } else {
08862 G__setgvp((long) G__PVOID);
08863 for (int i = n - 1; i >= 0; --i) {
08864 ((TNetSystem*) (soff+(sizeof(TNetSystem)*i)))->~G__TTNetSystem();
08865 }
08866 G__setgvp((long)gvp);
08867 }
08868 } else {
08869 if (gvp == (char*)G__PVOID) {
08870 delete (TNetSystem*) soff;
08871 } else {
08872 G__setgvp((long) G__PVOID);
08873 ((TNetSystem*) (soff))->~G__TTNetSystem();
08874 G__setgvp((long)gvp);
08875 }
08876 }
08877 G__setnull(result7);
08878 return(1 || funcname || hash || result7 || libp) ;
08879 }
08880
08881
08882
08883 static int G__G__Net_250_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08884 {
08885 TSecContext* p = NULL;
08886 char* gvp = (char*) G__getgvp();
08887 switch (libp->paran) {
08888 case 7:
08889
08890 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08891 p = new TSecContext(
08892 (const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
08893 , (Int_t) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
08894 , (const char*) G__int(libp->para[4]), *((TDatime*) G__int(libp->para[5]))
08895 , (void*) G__int(libp->para[6]));
08896 } else {
08897 p = new((void*) gvp) TSecContext(
08898 (const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
08899 , (Int_t) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
08900 , (const char*) G__int(libp->para[4]), *((TDatime*) G__int(libp->para[5]))
08901 , (void*) G__int(libp->para[6]));
08902 }
08903 break;
08904 case 6:
08905
08906 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08907 p = new TSecContext(
08908 (const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
08909 , (Int_t) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
08910 , (const char*) G__int(libp->para[4]), *((TDatime*) G__int(libp->para[5])));
08911 } else {
08912 p = new((void*) gvp) TSecContext(
08913 (const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
08914 , (Int_t) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
08915 , (const char*) G__int(libp->para[4]), *((TDatime*) G__int(libp->para[5])));
08916 }
08917 break;
08918 case 5:
08919
08920 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08921 p = new TSecContext(
08922 (const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
08923 , (Int_t) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
08924 , (const char*) G__int(libp->para[4]));
08925 } else {
08926 p = new((void*) gvp) TSecContext(
08927 (const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
08928 , (Int_t) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
08929 , (const char*) G__int(libp->para[4]));
08930 }
08931 break;
08932 }
08933 result7->obj.i = (long) p;
08934 result7->ref = (long) p;
08935 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__NetLN_TSecContext));
08936 return(1 || funcname || hash || result7 || libp) ;
08937 }
08938
08939 static int G__G__Net_250_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08940 {
08941 TSecContext* p = NULL;
08942 char* gvp = (char*) G__getgvp();
08943 switch (libp->paran) {
08944 case 8:
08945
08946 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08947 p = new TSecContext(
08948 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
08949 , (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
08950 , (const char*) G__int(libp->para[4]), (const char*) G__int(libp->para[5])
08951 , *((TDatime*) G__int(libp->para[6])), (void*) G__int(libp->para[7]));
08952 } else {
08953 p = new((void*) gvp) TSecContext(
08954 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
08955 , (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
08956 , (const char*) G__int(libp->para[4]), (const char*) G__int(libp->para[5])
08957 , *((TDatime*) G__int(libp->para[6])), (void*) G__int(libp->para[7]));
08958 }
08959 break;
08960 case 7:
08961
08962 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08963 p = new TSecContext(
08964 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
08965 , (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
08966 , (const char*) G__int(libp->para[4]), (const char*) G__int(libp->para[5])
08967 , *((TDatime*) G__int(libp->para[6])));
08968 } else {
08969 p = new((void*) gvp) TSecContext(
08970 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
08971 , (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
08972 , (const char*) G__int(libp->para[4]), (const char*) G__int(libp->para[5])
08973 , *((TDatime*) G__int(libp->para[6])));
08974 }
08975 break;
08976 case 6:
08977
08978 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08979 p = new TSecContext(
08980 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
08981 , (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
08982 , (const char*) G__int(libp->para[4]), (const char*) G__int(libp->para[5]));
08983 } else {
08984 p = new((void*) gvp) TSecContext(
08985 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
08986 , (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
08987 , (const char*) G__int(libp->para[4]), (const char*) G__int(libp->para[5]));
08988 }
08989 break;
08990 }
08991 result7->obj.i = (long) p;
08992 result7->ref = (long) p;
08993 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__NetLN_TSecContext));
08994 return(1 || funcname || hash || result7 || libp) ;
08995 }
08996
08997 static int G__G__Net_250_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08998 {
08999 ((TSecContext*) G__getstructoffset())->AddForCleanup((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
09000 , (Int_t) G__int(libp->para[2]));
09001 G__setnull(result7);
09002 return(1 || funcname || hash || result7 || libp) ;
09003 }
09004
09005 static int G__G__Net_250_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09006 {
09007 G__letint(result7, 67, (long) ((TSecContext*) G__getstructoffset())->AsString(*(TString*) libp->para[0].ref));
09008 return(1 || funcname || hash || result7 || libp) ;
09009 }
09010
09011 static int G__G__Net_250_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09012 {
09013 switch (libp->paran) {
09014 case 1:
09015 ((TSecContext*) G__getstructoffset())->DeActivate((Option_t*) G__int(libp->para[0]));
09016 G__setnull(result7);
09017 break;
09018 case 0:
09019 ((TSecContext*) G__getstructoffset())->DeActivate();
09020 G__setnull(result7);
09021 break;
09022 }
09023 return(1 || funcname || hash || result7 || libp) ;
09024 }
09025
09026 static int G__G__Net_250_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09027 {
09028 G__letint(result7, 89, (long) ((const TSecContext*) G__getstructoffset())->GetContext());
09029 return(1 || funcname || hash || result7 || libp) ;
09030 }
09031
09032 static int G__G__Net_250_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09033 {
09034 {
09035 const TDatime* pobj;
09036 const TDatime xobj = ((const TSecContext*) G__getstructoffset())->GetExpDate();
09037 pobj = new TDatime(xobj);
09038 result7->obj.i = (long) ((void*) pobj);
09039 result7->ref = result7->obj.i;
09040 G__store_tempobject(*result7);
09041 }
09042 return(1 || funcname || hash || result7 || libp) ;
09043 }
09044
09045 static int G__G__Net_250_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09046 {
09047 G__letint(result7, 67, (long) ((const TSecContext*) G__getstructoffset())->GetHost());
09048 return(1 || funcname || hash || result7 || libp) ;
09049 }
09050
09051 static int G__G__Net_250_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09052 {
09053 G__letint(result7, 67, (long) ((const TSecContext*) G__getstructoffset())->GetID());
09054 return(1 || funcname || hash || result7 || libp) ;
09055 }
09056
09057 static int G__G__Net_250_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09058 {
09059 G__letint(result7, 105, (long) ((const TSecContext*) G__getstructoffset())->GetMethod());
09060 return(1 || funcname || hash || result7 || libp) ;
09061 }
09062
09063 static int G__G__Net_250_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09064 {
09065 G__letint(result7, 67, (long) ((const TSecContext*) G__getstructoffset())->GetMethodName());
09066 return(1 || funcname || hash || result7 || libp) ;
09067 }
09068
09069 static int G__G__Net_250_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09070 {
09071 G__letint(result7, 105, (long) ((const TSecContext*) G__getstructoffset())->GetOffSet());
09072 return(1 || funcname || hash || result7 || libp) ;
09073 }
09074
09075 static int G__G__Net_250_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09076 {
09077 G__letint(result7, 85, (long) ((const TSecContext*) G__getstructoffset())->GetSecContextCleanup());
09078 return(1 || funcname || hash || result7 || libp) ;
09079 }
09080
09081 static int G__G__Net_250_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09082 {
09083 G__letint(result7, 67, (long) ((const TSecContext*) G__getstructoffset())->GetToken());
09084 return(1 || funcname || hash || result7 || libp) ;
09085 }
09086
09087 static int G__G__Net_250_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09088 {
09089 G__letint(result7, 67, (long) ((const TSecContext*) G__getstructoffset())->GetUser());
09090 return(1 || funcname || hash || result7 || libp) ;
09091 }
09092
09093 static int G__G__Net_250_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09094 {
09095 G__letint(result7, 103, (long) ((TSecContext*) G__getstructoffset())->IsA((const char*) G__int(libp->para[0])));
09096 return(1 || funcname || hash || result7 || libp) ;
09097 }
09098
09099 static int G__G__Net_250_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09100 {
09101 G__letint(result7, 103, (long) ((const TSecContext*) G__getstructoffset())->IsActive());
09102 return(1 || funcname || hash || result7 || libp) ;
09103 }
09104
09105 static int G__G__Net_250_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09106 {
09107 ((TSecContext*) G__getstructoffset())->SetExpDate(*((TDatime*) G__int(libp->para[0])));
09108 G__setnull(result7);
09109 return(1 || funcname || hash || result7 || libp) ;
09110 }
09111
09112 static int G__G__Net_250_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09113 {
09114 ((TSecContext*) G__getstructoffset())->SetID((const char*) G__int(libp->para[0]));
09115 G__setnull(result7);
09116 return(1 || funcname || hash || result7 || libp) ;
09117 }
09118
09119 static int G__G__Net_250_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09120 {
09121 ((TSecContext*) G__getstructoffset())->SetOffSet((Int_t) G__int(libp->para[0]));
09122 G__setnull(result7);
09123 return(1 || funcname || hash || result7 || libp) ;
09124 }
09125
09126 static int G__G__Net_250_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09127 {
09128 ((TSecContext*) G__getstructoffset())->SetUser((const char*) G__int(libp->para[0]));
09129 G__setnull(result7);
09130 return(1 || funcname || hash || result7 || libp) ;
09131 }
09132
09133 static int G__G__Net_250_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09134 {
09135 G__letint(result7, 85, (long) TSecContext::Class());
09136 return(1 || funcname || hash || result7 || libp) ;
09137 }
09138
09139 static int G__G__Net_250_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09140 {
09141 G__letint(result7, 67, (long) TSecContext::Class_Name());
09142 return(1 || funcname || hash || result7 || libp) ;
09143 }
09144
09145 static int G__G__Net_250_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09146 {
09147 G__letint(result7, 115, (long) TSecContext::Class_Version());
09148 return(1 || funcname || hash || result7 || libp) ;
09149 }
09150
09151 static int G__G__Net_250_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09152 {
09153 TSecContext::Dictionary();
09154 G__setnull(result7);
09155 return(1 || funcname || hash || result7 || libp) ;
09156 }
09157
09158 static int G__G__Net_250_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09159 {
09160 ((TSecContext*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
09161 G__setnull(result7);
09162 return(1 || funcname || hash || result7 || libp) ;
09163 }
09164
09165 static int G__G__Net_250_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09166 {
09167 G__letint(result7, 67, (long) TSecContext::DeclFileName());
09168 return(1 || funcname || hash || result7 || libp) ;
09169 }
09170
09171 static int G__G__Net_250_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09172 {
09173 G__letint(result7, 105, (long) TSecContext::ImplFileLine());
09174 return(1 || funcname || hash || result7 || libp) ;
09175 }
09176
09177 static int G__G__Net_250_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09178 {
09179 G__letint(result7, 67, (long) TSecContext::ImplFileName());
09180 return(1 || funcname || hash || result7 || libp) ;
09181 }
09182
09183 static int G__G__Net_250_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09184 {
09185 G__letint(result7, 105, (long) TSecContext::DeclFileLine());
09186 return(1 || funcname || hash || result7 || libp) ;
09187 }
09188
09189
09190 typedef TSecContext G__TTSecContext;
09191 static int G__G__Net_250_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09192 {
09193 char* gvp = (char*) G__getgvp();
09194 long soff = G__getstructoffset();
09195 int n = G__getaryconstruct();
09196
09197
09198
09199
09200
09201 if (!soff) {
09202 return(1);
09203 }
09204 if (n) {
09205 if (gvp == (char*)G__PVOID) {
09206 delete[] (TSecContext*) soff;
09207 } else {
09208 G__setgvp((long) G__PVOID);
09209 for (int i = n - 1; i >= 0; --i) {
09210 ((TSecContext*) (soff+(sizeof(TSecContext)*i)))->~G__TTSecContext();
09211 }
09212 G__setgvp((long)gvp);
09213 }
09214 } else {
09215 if (gvp == (char*)G__PVOID) {
09216 delete (TSecContext*) soff;
09217 } else {
09218 G__setgvp((long) G__PVOID);
09219 ((TSecContext*) (soff))->~G__TTSecContext();
09220 G__setgvp((long)gvp);
09221 }
09222 }
09223 G__setnull(result7);
09224 return(1 || funcname || hash || result7 || libp) ;
09225 }
09226
09227
09228
09229 static int G__G__Net_252_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09230 {
09231 TSecContextCleanup* p = NULL;
09232 char* gvp = (char*) G__getgvp();
09233
09234 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09235 p = new TSecContextCleanup(
09236 (Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
09237 , (Int_t) G__int(libp->para[2]));
09238 } else {
09239 p = new((void*) gvp) TSecContextCleanup(
09240 (Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
09241 , (Int_t) G__int(libp->para[2]));
09242 }
09243 result7->obj.i = (long) p;
09244 result7->ref = (long) p;
09245 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__NetLN_TSecContextCleanup));
09246 return(1 || funcname || hash || result7 || libp) ;
09247 }
09248
09249 static int G__G__Net_252_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09250 {
09251 G__letint(result7, 105, (long) ((const TSecContextCleanup*) G__getstructoffset())->GetPort());
09252 return(1 || funcname || hash || result7 || libp) ;
09253 }
09254
09255 static int G__G__Net_252_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09256 {
09257 G__letint(result7, 105, (long) ((const TSecContextCleanup*) G__getstructoffset())->GetProtocol());
09258 return(1 || funcname || hash || result7 || libp) ;
09259 }
09260
09261 static int G__G__Net_252_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09262 {
09263 G__letint(result7, 105, (long) ((const TSecContextCleanup*) G__getstructoffset())->GetType());
09264 return(1 || funcname || hash || result7 || libp) ;
09265 }
09266
09267 static int G__G__Net_252_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09268 {
09269 G__letint(result7, 85, (long) TSecContextCleanup::Class());
09270 return(1 || funcname || hash || result7 || libp) ;
09271 }
09272
09273 static int G__G__Net_252_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09274 {
09275 G__letint(result7, 67, (long) TSecContextCleanup::Class_Name());
09276 return(1 || funcname || hash || result7 || libp) ;
09277 }
09278
09279 static int G__G__Net_252_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09280 {
09281 G__letint(result7, 115, (long) TSecContextCleanup::Class_Version());
09282 return(1 || funcname || hash || result7 || libp) ;
09283 }
09284
09285 static int G__G__Net_252_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09286 {
09287 TSecContextCleanup::Dictionary();
09288 G__setnull(result7);
09289 return(1 || funcname || hash || result7 || libp) ;
09290 }
09291
09292 static int G__G__Net_252_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09293 {
09294 ((TSecContextCleanup*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
09295 G__setnull(result7);
09296 return(1 || funcname || hash || result7 || libp) ;
09297 }
09298
09299 static int G__G__Net_252_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09300 {
09301 G__letint(result7, 67, (long) TSecContextCleanup::DeclFileName());
09302 return(1 || funcname || hash || result7 || libp) ;
09303 }
09304
09305 static int G__G__Net_252_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09306 {
09307 G__letint(result7, 105, (long) TSecContextCleanup::ImplFileLine());
09308 return(1 || funcname || hash || result7 || libp) ;
09309 }
09310
09311 static int G__G__Net_252_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09312 {
09313 G__letint(result7, 67, (long) TSecContextCleanup::ImplFileName());
09314 return(1 || funcname || hash || result7 || libp) ;
09315 }
09316
09317 static int G__G__Net_252_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09318 {
09319 G__letint(result7, 105, (long) TSecContextCleanup::DeclFileLine());
09320 return(1 || funcname || hash || result7 || libp) ;
09321 }
09322
09323
09324 static int G__G__Net_252_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09325
09326 {
09327 TSecContextCleanup* p;
09328 void* tmp = (void*) G__int(libp->para[0]);
09329 p = new TSecContextCleanup(*(TSecContextCleanup*) tmp);
09330 result7->obj.i = (long) p;
09331 result7->ref = (long) p;
09332 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__NetLN_TSecContextCleanup));
09333 return(1 || funcname || hash || result7 || libp) ;
09334 }
09335
09336
09337 typedef TSecContextCleanup G__TTSecContextCleanup;
09338 static int G__G__Net_252_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09339 {
09340 char* gvp = (char*) G__getgvp();
09341 long soff = G__getstructoffset();
09342 int n = G__getaryconstruct();
09343
09344
09345
09346
09347
09348 if (!soff) {
09349 return(1);
09350 }
09351 if (n) {
09352 if (gvp == (char*)G__PVOID) {
09353 delete[] (TSecContextCleanup*) soff;
09354 } else {
09355 G__setgvp((long) G__PVOID);
09356 for (int i = n - 1; i >= 0; --i) {
09357 ((TSecContextCleanup*) (soff+(sizeof(TSecContextCleanup)*i)))->~G__TTSecContextCleanup();
09358 }
09359 G__setgvp((long)gvp);
09360 }
09361 } else {
09362 if (gvp == (char*)G__PVOID) {
09363 delete (TSecContextCleanup*) soff;
09364 } else {
09365 G__setgvp((long) G__PVOID);
09366 ((TSecContextCleanup*) (soff))->~G__TTSecContextCleanup();
09367 G__setgvp((long)gvp);
09368 }
09369 }
09370 G__setnull(result7);
09371 return(1 || funcname || hash || result7 || libp) ;
09372 }
09373
09374
09375 static int G__G__Net_252_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09376 {
09377 TSecContextCleanup* dest = (TSecContextCleanup*) G__getstructoffset();
09378 *dest = *(TSecContextCleanup*) libp->para[0].ref;
09379 const TSecContextCleanup& obj = *dest;
09380 result7->ref = (long) (&obj);
09381 result7->obj.i = (long) (&obj);
09382 return(1 || funcname || hash || result7 || libp) ;
09383 }
09384
09385
09386
09387 static int G__G__Net_271_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09388 {
09389 TPServerSocket* p = NULL;
09390 char* gvp = (char*) G__getgvp();
09391 switch (libp->paran) {
09392 case 4:
09393
09394 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09395 p = new TPServerSocket(
09396 (Int_t) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])
09397 , (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
09398 } else {
09399 p = new((void*) gvp) TPServerSocket(
09400 (Int_t) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])
09401 , (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
09402 }
09403 break;
09404 case 3:
09405
09406 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09407 p = new TPServerSocket(
09408 (Int_t) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])
09409 , (Int_t) G__int(libp->para[2]));
09410 } else {
09411 p = new((void*) gvp) TPServerSocket(
09412 (Int_t) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])
09413 , (Int_t) G__int(libp->para[2]));
09414 }
09415 break;
09416 case 2:
09417
09418 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09419 p = new TPServerSocket((Int_t) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
09420 } else {
09421 p = new((void*) gvp) TPServerSocket((Int_t) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
09422 }
09423 break;
09424 case 1:
09425
09426 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09427 p = new TPServerSocket((Int_t) G__int(libp->para[0]));
09428 } else {
09429 p = new((void*) gvp) TPServerSocket((Int_t) G__int(libp->para[0]));
09430 }
09431 break;
09432 }
09433 result7->obj.i = (long) p;
09434 result7->ref = (long) p;
09435 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__NetLN_TPServerSocket));
09436 return(1 || funcname || hash || result7 || libp) ;
09437 }
09438
09439 static int G__G__Net_271_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09440 {
09441 TPServerSocket* p = NULL;
09442 char* gvp = (char*) G__getgvp();
09443 switch (libp->paran) {
09444 case 4:
09445
09446 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09447 p = new TPServerSocket(
09448 (const char*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])
09449 , (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
09450 } else {
09451 p = new((void*) gvp) TPServerSocket(
09452 (const char*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])
09453 , (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
09454 }
09455 break;
09456 case 3:
09457
09458 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09459 p = new TPServerSocket(
09460 (const char*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])
09461 , (Int_t) G__int(libp->para[2]));
09462 } else {
09463 p = new((void*) gvp) TPServerSocket(
09464 (const char*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])
09465 , (Int_t) G__int(libp->para[2]));
09466 }
09467 break;
09468 case 2:
09469
09470 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09471 p = new TPServerSocket((const char*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
09472 } else {
09473 p = new((void*) gvp) TPServerSocket((const char*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
09474 }
09475 break;
09476 case 1:
09477
09478 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09479 p = new TPServerSocket((const char*) G__int(libp->para[0]));
09480 } else {
09481 p = new((void*) gvp) TPServerSocket((const char*) G__int(libp->para[0]));
09482 }
09483 break;
09484 }
09485 result7->obj.i = (long) p;
09486 result7->ref = (long) p;
09487 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__NetLN_TPServerSocket));
09488 return(1 || funcname || hash || result7 || libp) ;
09489 }
09490
09491 static int G__G__Net_271_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09492 {
09493 G__letint(result7, 85, (long) TPServerSocket::Class());
09494 return(1 || funcname || hash || result7 || libp) ;
09495 }
09496
09497 static int G__G__Net_271_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09498 {
09499 G__letint(result7, 67, (long) TPServerSocket::Class_Name());
09500 return(1 || funcname || hash || result7 || libp) ;
09501 }
09502
09503 static int G__G__Net_271_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09504 {
09505 G__letint(result7, 115, (long) TPServerSocket::Class_Version());
09506 return(1 || funcname || hash || result7 || libp) ;
09507 }
09508
09509 static int G__G__Net_271_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09510 {
09511 TPServerSocket::Dictionary();
09512 G__setnull(result7);
09513 return(1 || funcname || hash || result7 || libp) ;
09514 }
09515
09516 static int G__G__Net_271_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09517 {
09518 ((TPServerSocket*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
09519 G__setnull(result7);
09520 return(1 || funcname || hash || result7 || libp) ;
09521 }
09522
09523 static int G__G__Net_271_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09524 {
09525 G__letint(result7, 67, (long) TPServerSocket::DeclFileName());
09526 return(1 || funcname || hash || result7 || libp) ;
09527 }
09528
09529 static int G__G__Net_271_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09530 {
09531 G__letint(result7, 105, (long) TPServerSocket::ImplFileLine());
09532 return(1 || funcname || hash || result7 || libp) ;
09533 }
09534
09535 static int G__G__Net_271_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09536 {
09537 G__letint(result7, 67, (long) TPServerSocket::ImplFileName());
09538 return(1 || funcname || hash || result7 || libp) ;
09539 }
09540
09541 static int G__G__Net_271_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09542 {
09543 G__letint(result7, 105, (long) TPServerSocket::DeclFileLine());
09544 return(1 || funcname || hash || result7 || libp) ;
09545 }
09546
09547
09548 typedef TPServerSocket G__TTPServerSocket;
09549 static int G__G__Net_271_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09550 {
09551 char* gvp = (char*) G__getgvp();
09552 long soff = G__getstructoffset();
09553 int n = G__getaryconstruct();
09554
09555
09556
09557
09558
09559 if (!soff) {
09560 return(1);
09561 }
09562 if (n) {
09563 if (gvp == (char*)G__PVOID) {
09564 delete[] (TPServerSocket*) soff;
09565 } else {
09566 G__setgvp((long) G__PVOID);
09567 for (int i = n - 1; i >= 0; --i) {
09568 ((TPServerSocket*) (soff+(sizeof(TPServerSocket)*i)))->~G__TTPServerSocket();
09569 }
09570 G__setgvp((long)gvp);
09571 }
09572 } else {
09573 if (gvp == (char*)G__PVOID) {
09574 delete (TPServerSocket*) soff;
09575 } else {
09576 G__setgvp((long) G__PVOID);
09577 ((TPServerSocket*) (soff))->~G__TTPServerSocket();
09578 G__setgvp((long)gvp);
09579 }
09580 }
09581 G__setnull(result7);
09582 return(1 || funcname || hash || result7 || libp) ;
09583 }
09584
09585
09586
09587 static int G__G__Net_272_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09588 {
09589 TSQLColumnInfo* p = NULL;
09590 char* gvp = (char*) G__getgvp();
09591 int n = G__getaryconstruct();
09592 if (n) {
09593 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09594 p = new TSQLColumnInfo[n];
09595 } else {
09596 p = new((void*) gvp) TSQLColumnInfo[n];
09597 }
09598 } else {
09599 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09600 p = new TSQLColumnInfo;
09601 } else {
09602 p = new((void*) gvp) TSQLColumnInfo;
09603 }
09604 }
09605 result7->obj.i = (long) p;
09606 result7->ref = (long) p;
09607 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__NetLN_TSQLColumnInfo));
09608 return(1 || funcname || hash || result7 || libp) ;
09609 }
09610
09611 static int G__G__Net_272_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09612 {
09613 TSQLColumnInfo* p = NULL;
09614 char* gvp = (char*) G__getgvp();
09615 switch (libp->paran) {
09616 case 8:
09617
09618 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09619 p = new TSQLColumnInfo(
09620 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
09621 , (Bool_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
09622 , (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])
09623 , (Int_t) G__int(libp->para[6]), (Int_t) G__int(libp->para[7]));
09624 } else {
09625 p = new((void*) gvp) TSQLColumnInfo(
09626 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
09627 , (Bool_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
09628 , (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])
09629 , (Int_t) G__int(libp->para[6]), (Int_t) G__int(libp->para[7]));
09630 }
09631 break;
09632 case 7:
09633
09634 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09635 p = new TSQLColumnInfo(
09636 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
09637 , (Bool_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
09638 , (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])
09639 , (Int_t) G__int(libp->para[6]));
09640 } else {
09641 p = new((void*) gvp) TSQLColumnInfo(
09642 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
09643 , (Bool_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
09644 , (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])
09645 , (Int_t) G__int(libp->para[6]));
09646 }
09647 break;
09648 case 6:
09649
09650 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09651 p = new TSQLColumnInfo(
09652 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
09653 , (Bool_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
09654 , (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5]));
09655 } else {
09656 p = new((void*) gvp) TSQLColumnInfo(
09657 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
09658 , (Bool_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
09659 , (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5]));
09660 }
09661 break;
09662 case 5:
09663
09664 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09665 p = new TSQLColumnInfo(
09666 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
09667 , (Bool_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
09668 , (Int_t) G__int(libp->para[4]));
09669 } else {
09670 p = new((void*) gvp) TSQLColumnInfo(
09671 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
09672 , (Bool_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
09673 , (Int_t) G__int(libp->para[4]));
09674 }
09675 break;
09676 case 4:
09677
09678 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09679 p = new TSQLColumnInfo(
09680 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
09681 , (Bool_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
09682 } else {
09683 p = new((void*) gvp) TSQLColumnInfo(
09684 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
09685 , (Bool_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
09686 }
09687 break;
09688 case 3:
09689
09690 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09691 p = new TSQLColumnInfo(
09692 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
09693 , (Bool_t) G__int(libp->para[2]));
09694 } else {
09695 p = new((void*) gvp) TSQLColumnInfo(
09696 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
09697 , (Bool_t) G__int(libp->para[2]));
09698 }
09699 break;
09700 case 2:
09701
09702 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09703 p = new TSQLColumnInfo((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
09704 } else {
09705 p = new((void*) gvp) TSQLColumnInfo((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
09706 }
09707 break;
09708 case 1:
09709
09710 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09711 p = new TSQLColumnInfo((const char*) G__int(libp->para[0]));
09712 } else {
09713 p = new((void*) gvp) TSQLColumnInfo((const char*) G__int(libp->para[0]));
09714 }
09715 break;
09716 }
09717 result7->obj.i = (long) p;
09718 result7->ref = (long) p;
09719 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__NetLN_TSQLColumnInfo));
09720 return(1 || funcname || hash || result7 || libp) ;
09721 }
09722
09723 static int G__G__Net_272_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09724 {
09725 G__letint(result7, 67, (long) ((const TSQLColumnInfo*) G__getstructoffset())->GetTypeName());
09726 return(1 || funcname || hash || result7 || libp) ;
09727 }
09728
09729 static int G__G__Net_272_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09730 {
09731 G__letint(result7, 103, (long) ((const TSQLColumnInfo*) G__getstructoffset())->IsNullable());
09732 return(1 || funcname || hash || result7 || libp) ;
09733 }
09734
09735 static int G__G__Net_272_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09736 {
09737 G__letint(result7, 105, (long) ((const TSQLColumnInfo*) G__getstructoffset())->GetSQLType());
09738 return(1 || funcname || hash || result7 || libp) ;
09739 }
09740
09741 static int G__G__Net_272_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09742 {
09743 G__letint(result7, 105, (long) ((const TSQLColumnInfo*) G__getstructoffset())->GetSize());
09744 return(1 || funcname || hash || result7 || libp) ;
09745 }
09746
09747 static int G__G__Net_272_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09748 {
09749 G__letint(result7, 105, (long) ((const TSQLColumnInfo*) G__getstructoffset())->GetLength());
09750 return(1 || funcname || hash || result7 || libp) ;
09751 }
09752
09753 static int G__G__Net_272_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09754 {
09755 G__letint(result7, 105, (long) ((const TSQLColumnInfo*) G__getstructoffset())->GetScale());
09756 return(1 || funcname || hash || result7 || libp) ;
09757 }
09758
09759 static int G__G__Net_272_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09760 {
09761 G__letint(result7, 105, (long) ((const TSQLColumnInfo*) G__getstructoffset())->GetSigned());
09762 return(1 || funcname || hash || result7 || libp) ;
09763 }
09764
09765 static int G__G__Net_272_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09766 {
09767 G__letint(result7, 103, (long) ((const TSQLColumnInfo*) G__getstructoffset())->IsSigned());
09768 return(1 || funcname || hash || result7 || libp) ;
09769 }
09770
09771 static int G__G__Net_272_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09772 {
09773 G__letint(result7, 103, (long) ((const TSQLColumnInfo*) G__getstructoffset())->IsUnsigned());
09774 return(1 || funcname || hash || result7 || libp) ;
09775 }
09776
09777 static int G__G__Net_272_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09778 {
09779 G__letint(result7, 85, (long) TSQLColumnInfo::Class());
09780 return(1 || funcname || hash || result7 || libp) ;
09781 }
09782
09783 static int G__G__Net_272_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09784 {
09785 G__letint(result7, 67, (long) TSQLColumnInfo::Class_Name());
09786 return(1 || funcname || hash || result7 || libp) ;
09787 }
09788
09789 static int G__G__Net_272_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09790 {
09791 G__letint(result7, 115, (long) TSQLColumnInfo::Class_Version());
09792 return(1 || funcname || hash || result7 || libp) ;
09793 }
09794
09795 static int G__G__Net_272_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09796 {
09797 TSQLColumnInfo::Dictionary();
09798 G__setnull(result7);
09799 return(1 || funcname || hash || result7 || libp) ;
09800 }
09801
09802 static int G__G__Net_272_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09803 {
09804 ((TSQLColumnInfo*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
09805 G__setnull(result7);
09806 return(1 || funcname || hash || result7 || libp) ;
09807 }
09808
09809 static int G__G__Net_272_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09810 {
09811 G__letint(result7, 67, (long) TSQLColumnInfo::DeclFileName());
09812 return(1 || funcname || hash || result7 || libp) ;
09813 }
09814
09815 static int G__G__Net_272_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09816 {
09817 G__letint(result7, 105, (long) TSQLColumnInfo::ImplFileLine());
09818 return(1 || funcname || hash || result7 || libp) ;
09819 }
09820
09821 static int G__G__Net_272_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09822 {
09823 G__letint(result7, 67, (long) TSQLColumnInfo::ImplFileName());
09824 return(1 || funcname || hash || result7 || libp) ;
09825 }
09826
09827 static int G__G__Net_272_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09828 {
09829 G__letint(result7, 105, (long) TSQLColumnInfo::DeclFileLine());
09830 return(1 || funcname || hash || result7 || libp) ;
09831 }
09832
09833
09834 static int G__G__Net_272_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09835
09836 {
09837 TSQLColumnInfo* p;
09838 void* tmp = (void*) G__int(libp->para[0]);
09839 p = new TSQLColumnInfo(*(TSQLColumnInfo*) tmp);
09840 result7->obj.i = (long) p;
09841 result7->ref = (long) p;
09842 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__NetLN_TSQLColumnInfo));
09843 return(1 || funcname || hash || result7 || libp) ;
09844 }
09845
09846
09847 typedef TSQLColumnInfo G__TTSQLColumnInfo;
09848 static int G__G__Net_272_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09849 {
09850 char* gvp = (char*) G__getgvp();
09851 long soff = G__getstructoffset();
09852 int n = G__getaryconstruct();
09853
09854
09855
09856
09857
09858 if (!soff) {
09859 return(1);
09860 }
09861 if (n) {
09862 if (gvp == (char*)G__PVOID) {
09863 delete[] (TSQLColumnInfo*) soff;
09864 } else {
09865 G__setgvp((long) G__PVOID);
09866 for (int i = n - 1; i >= 0; --i) {
09867 ((TSQLColumnInfo*) (soff+(sizeof(TSQLColumnInfo)*i)))->~G__TTSQLColumnInfo();
09868 }
09869 G__setgvp((long)gvp);
09870 }
09871 } else {
09872 if (gvp == (char*)G__PVOID) {
09873 delete (TSQLColumnInfo*) soff;
09874 } else {
09875 G__setgvp((long) G__PVOID);
09876 ((TSQLColumnInfo*) (soff))->~G__TTSQLColumnInfo();
09877 G__setgvp((long)gvp);
09878 }
09879 }
09880 G__setnull(result7);
09881 return(1 || funcname || hash || result7 || libp) ;
09882 }
09883
09884
09885 static int G__G__Net_272_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09886 {
09887 TSQLColumnInfo* dest = (TSQLColumnInfo*) G__getstructoffset();
09888 *dest = *(TSQLColumnInfo*) libp->para[0].ref;
09889 const TSQLColumnInfo& obj = *dest;
09890 result7->ref = (long) (&obj);
09891 result7->obj.i = (long) (&obj);
09892 return(1 || funcname || hash || result7 || libp) ;
09893 }
09894
09895
09896
09897 static int G__G__Net_275_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09898 {
09899 switch (libp->paran) {
09900 case 1:
09901 ((TSQLServer*) G__getstructoffset())->Close((Option_t*) G__int(libp->para[0]));
09902 G__setnull(result7);
09903 break;
09904 case 0:
09905 ((TSQLServer*) G__getstructoffset())->Close();
09906 G__setnull(result7);
09907 break;
09908 }
09909 return(1 || funcname || hash || result7 || libp) ;
09910 }
09911
09912 static int G__G__Net_275_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09913 {
09914 G__letint(result7, 85, (long) ((TSQLServer*) G__getstructoffset())->Query((const char*) G__int(libp->para[0])));
09915 return(1 || funcname || hash || result7 || libp) ;
09916 }
09917
09918 static int G__G__Net_275_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09919 {
09920 G__letint(result7, 103, (long) ((TSQLServer*) G__getstructoffset())->Exec((const char*) G__int(libp->para[0])));
09921 return(1 || funcname || hash || result7 || libp) ;
09922 }
09923
09924 static int G__G__Net_275_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09925 {
09926 switch (libp->paran) {
09927 case 2:
09928 G__letint(result7, 85, (long) ((TSQLServer*) G__getstructoffset())->Statement((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
09929 break;
09930 case 1:
09931 G__letint(result7, 85, (long) ((TSQLServer*) G__getstructoffset())->Statement((const char*) G__int(libp->para[0])));
09932 break;
09933 }
09934 return(1 || funcname || hash || result7 || libp) ;
09935 }
09936
09937 static int G__G__Net_275_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09938 {
09939 G__letint(result7, 103, (long) ((const TSQLServer*) G__getstructoffset())->HasStatement());
09940 return(1 || funcname || hash || result7 || libp) ;
09941 }
09942
09943 static int G__G__Net_275_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09944 {
09945 G__letint(result7, 105, (long) ((TSQLServer*) G__getstructoffset())->SelectDataBase((const char*) G__int(libp->para[0])));
09946 return(1 || funcname || hash || result7 || libp) ;
09947 }
09948
09949 static int G__G__Net_275_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09950 {
09951 switch (libp->paran) {
09952 case 1:
09953 G__letint(result7, 85, (long) ((TSQLServer*) G__getstructoffset())->GetDataBases((const char*) G__int(libp->para[0])));
09954 break;
09955 case 0:
09956 G__letint(result7, 85, (long) ((TSQLServer*) G__getstructoffset())->GetDataBases());
09957 break;
09958 }
09959 return(1 || funcname || hash || result7 || libp) ;
09960 }
09961
09962 static int G__G__Net_275_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09963 {
09964 switch (libp->paran) {
09965 case 2:
09966 G__letint(result7, 85, (long) ((TSQLServer*) G__getstructoffset())->GetTables((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
09967 break;
09968 case 1:
09969 G__letint(result7, 85, (long) ((TSQLServer*) G__getstructoffset())->GetTables((const char*) G__int(libp->para[0])));
09970 break;
09971 }
09972 return(1 || funcname || hash || result7 || libp) ;
09973 }
09974
09975 static int G__G__Net_275_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09976 {
09977 switch (libp->paran) {
09978 case 1:
09979 G__letint(result7, 85, (long) ((TSQLServer*) G__getstructoffset())->GetTablesList((const char*) G__int(libp->para[0])));
09980 break;
09981 case 0:
09982 G__letint(result7, 85, (long) ((TSQLServer*) G__getstructoffset())->GetTablesList());
09983 break;
09984 }
09985 return(1 || funcname || hash || result7 || libp) ;
09986 }
09987
09988 static int G__G__Net_275_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09989 {
09990 G__letint(result7, 103, (long) ((TSQLServer*) G__getstructoffset())->HasTable((const char*) G__int(libp->para[0])));
09991 return(1 || funcname || hash || result7 || libp) ;
09992 }
09993
09994 static int G__G__Net_275_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09995 {
09996 G__letint(result7, 85, (long) ((TSQLServer*) G__getstructoffset())->GetTableInfo((const char*) G__int(libp->para[0])));
09997 return(1 || funcname || hash || result7 || libp) ;
09998 }
09999
10000 static int G__G__Net_275_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10001 {
10002 switch (libp->paran) {
10003 case 3:
10004 G__letint(result7, 85, (long) ((TSQLServer*) G__getstructoffset())->GetColumns((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
10005 , (const char*) G__int(libp->para[2])));
10006 break;
10007 case 2:
10008 G__letint(result7, 85, (long) ((TSQLServer*) G__getstructoffset())->GetColumns((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
10009 break;
10010 }
10011 return(1 || funcname || hash || result7 || libp) ;
10012 }
10013
10014 static int G__G__Net_275_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10015 {
10016 G__letint(result7, 105, (long) ((TSQLServer*) G__getstructoffset())->GetMaxIdentifierLength());
10017 return(1 || funcname || hash || result7 || libp) ;
10018 }
10019
10020 static int G__G__Net_275_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10021 {
10022 G__letint(result7, 105, (long) ((TSQLServer*) G__getstructoffset())->CreateDataBase((const char*) G__int(libp->para[0])));
10023 return(1 || funcname || hash || result7 || libp) ;
10024 }
10025
10026 static int G__G__Net_275_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10027 {
10028 G__letint(result7, 105, (long) ((TSQLServer*) G__getstructoffset())->DropDataBase((const char*) G__int(libp->para[0])));
10029 return(1 || funcname || hash || result7 || libp) ;
10030 }
10031
10032 static int G__G__Net_275_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10033 {
10034 G__letint(result7, 105, (long) ((TSQLServer*) G__getstructoffset())->Reload());
10035 return(1 || funcname || hash || result7 || libp) ;
10036 }
10037
10038 static int G__G__Net_275_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10039 {
10040 G__letint(result7, 105, (long) ((TSQLServer*) G__getstructoffset())->Shutdown());
10041 return(1 || funcname || hash || result7 || libp) ;
10042 }
10043
10044 static int G__G__Net_275_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10045 {
10046 G__letint(result7, 67, (long) ((TSQLServer*) G__getstructoffset())->ServerInfo());
10047 return(1 || funcname || hash || result7 || libp) ;
10048 }
10049
10050 static int G__G__Net_275_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10051 {
10052 G__letint(result7, 103, (long) ((const TSQLServer*) G__getstructoffset())->IsConnected());
10053 return(1 || funcname || hash || result7 || libp) ;
10054 }
10055
10056 static int G__G__Net_275_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10057 {
10058 G__letint(result7, 67, (long) ((const TSQLServer*) G__getstructoffset())->GetDBMS());
10059 return(1 || funcname || hash || result7 || libp) ;
10060 }
10061
10062 static int G__G__Net_275_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10063 {
10064 G__letint(result7, 67, (long) ((const TSQLServer*) G__getstructoffset())->GetDB());
10065 return(1 || funcname || hash || result7 || libp) ;
10066 }
10067
10068 static int G__G__Net_275_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10069 {
10070 G__letint(result7, 67, (long) ((const TSQLServer*) G__getstructoffset())->GetHost());
10071 return(1 || funcname || hash || result7 || libp) ;
10072 }
10073
10074 static int G__G__Net_275_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10075 {
10076 G__letint(result7, 105, (long) ((const TSQLServer*) G__getstructoffset())->GetPort());
10077 return(1 || funcname || hash || result7 || libp) ;
10078 }
10079
10080 static int G__G__Net_275_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10081 {
10082 G__letint(result7, 103, (long) ((const TSQLServer*) G__getstructoffset())->IsError());
10083 return(1 || funcname || hash || result7 || libp) ;
10084 }
10085
10086 static int G__G__Net_275_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10087 {
10088 G__letint(result7, 105, (long) ((const TSQLServer*) G__getstructoffset())->GetErrorCode());
10089 return(1 || funcname || hash || result7 || libp) ;
10090 }
10091
10092 static int G__G__Net_275_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10093 {
10094 G__letint(result7, 67, (long) ((const TSQLServer*) G__getstructoffset())->GetErrorMsg());
10095 return(1 || funcname || hash || result7 || libp) ;
10096 }
10097
10098 static int G__G__Net_275_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10099 {
10100 switch (libp->paran) {
10101 case 1:
10102 ((TSQLServer*) G__getstructoffset())->EnableErrorOutput((Bool_t) G__int(libp->para[0]));
10103 G__setnull(result7);
10104 break;
10105 case 0:
10106 ((TSQLServer*) G__getstructoffset())->EnableErrorOutput();
10107 G__setnull(result7);
10108 break;
10109 }
10110 return(1 || funcname || hash || result7 || libp) ;
10111 }
10112
10113 static int G__G__Net_275_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10114 {
10115 G__letint(result7, 103, (long) ((TSQLServer*) G__getstructoffset())->StartTransaction());
10116 return(1 || funcname || hash || result7 || libp) ;
10117 }
10118
10119 static int G__G__Net_275_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10120 {
10121 G__letint(result7, 103, (long) ((TSQLServer*) G__getstructoffset())->Commit());
10122 return(1 || funcname || hash || result7 || libp) ;
10123 }
10124
10125 static int G__G__Net_275_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10126 {
10127 G__letint(result7, 103, (long) ((TSQLServer*) G__getstructoffset())->Rollback());
10128 return(1 || funcname || hash || result7 || libp) ;
10129 }
10130
10131 static int G__G__Net_275_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10132 {
10133 G__letint(result7, 103, (long) ((TSQLServer*) G__getstructoffset())->PingVerify());
10134 return(1 || funcname || hash || result7 || libp) ;
10135 }
10136
10137 static int G__G__Net_275_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10138 {
10139 G__letint(result7, 105, (long) ((TSQLServer*) G__getstructoffset())->Ping());
10140 return(1 || funcname || hash || result7 || libp) ;
10141 }
10142
10143 static int G__G__Net_275_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10144 {
10145 G__letint(result7, 85, (long) TSQLServer::Connect((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
10146 , (const char*) G__int(libp->para[2])));
10147 return(1 || funcname || hash || result7 || libp) ;
10148 }
10149
10150 static int G__G__Net_275_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10151 {
10152 switch (libp->paran) {
10153 case 1:
10154 TSQLServer::SetFloatFormat((const char*) G__int(libp->para[0]));
10155 G__setnull(result7);
10156 break;
10157 case 0:
10158 TSQLServer::SetFloatFormat();
10159 G__setnull(result7);
10160 break;
10161 }
10162 return(1 || funcname || hash || result7 || libp) ;
10163 }
10164
10165 static int G__G__Net_275_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10166 {
10167 G__letint(result7, 67, (long) TSQLServer::GetFloatFormat());
10168 return(1 || funcname || hash || result7 || libp) ;
10169 }
10170
10171 static int G__G__Net_275_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10172 {
10173 G__letint(result7, 85, (long) TSQLServer::Class());
10174 return(1 || funcname || hash || result7 || libp) ;
10175 }
10176
10177 static int G__G__Net_275_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10178 {
10179 G__letint(result7, 67, (long) TSQLServer::Class_Name());
10180 return(1 || funcname || hash || result7 || libp) ;
10181 }
10182
10183 static int G__G__Net_275_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10184 {
10185 G__letint(result7, 115, (long) TSQLServer::Class_Version());
10186 return(1 || funcname || hash || result7 || libp) ;
10187 }
10188
10189 static int G__G__Net_275_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10190 {
10191 TSQLServer::Dictionary();
10192 G__setnull(result7);
10193 return(1 || funcname || hash || result7 || libp) ;
10194 }
10195
10196 static int G__G__Net_275_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10197 {
10198 ((TSQLServer*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
10199 G__setnull(result7);
10200 return(1 || funcname || hash || result7 || libp) ;
10201 }
10202
10203 static int G__G__Net_275_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10204 {
10205 G__letint(result7, 67, (long) TSQLServer::DeclFileName());
10206 return(1 || funcname || hash || result7 || libp) ;
10207 }
10208
10209 static int G__G__Net_275_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10210 {
10211 G__letint(result7, 105, (long) TSQLServer::ImplFileLine());
10212 return(1 || funcname || hash || result7 || libp) ;
10213 }
10214
10215 static int G__G__Net_275_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10216 {
10217 G__letint(result7, 67, (long) TSQLServer::ImplFileName());
10218 return(1 || funcname || hash || result7 || libp) ;
10219 }
10220
10221 static int G__G__Net_275_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10222 {
10223 G__letint(result7, 105, (long) TSQLServer::DeclFileLine());
10224 return(1 || funcname || hash || result7 || libp) ;
10225 }
10226
10227
10228 typedef TSQLServer G__TTSQLServer;
10229 static int G__G__Net_275_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10230 {
10231 char* gvp = (char*) G__getgvp();
10232 long soff = G__getstructoffset();
10233 int n = G__getaryconstruct();
10234
10235
10236
10237
10238
10239 if (!soff) {
10240 return(1);
10241 }
10242 if (n) {
10243 if (gvp == (char*)G__PVOID) {
10244 delete[] (TSQLServer*) soff;
10245 } else {
10246 G__setgvp((long) G__PVOID);
10247 for (int i = n - 1; i >= 0; --i) {
10248 ((TSQLServer*) (soff+(sizeof(TSQLServer)*i)))->~G__TTSQLServer();
10249 }
10250 G__setgvp((long)gvp);
10251 }
10252 } else {
10253 if (gvp == (char*)G__PVOID) {
10254 delete (TSQLServer*) soff;
10255 } else {
10256 G__setgvp((long) G__PVOID);
10257 ((TSQLServer*) (soff))->~G__TTSQLServer();
10258 G__setgvp((long)gvp);
10259 }
10260 }
10261 G__setnull(result7);
10262 return(1 || funcname || hash || result7 || libp) ;
10263 }
10264
10265
10266 static int G__G__Net_275_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10267 {
10268 TSQLServer* dest = (TSQLServer*) G__getstructoffset();
10269 *dest = *(TSQLServer*) libp->para[0].ref;
10270 const TSQLServer& obj = *dest;
10271 result7->ref = (long) (&obj);
10272 result7->obj.i = (long) (&obj);
10273 return(1 || funcname || hash || result7 || libp) ;
10274 }
10275
10276
10277
10278 static int G__G__Net_276_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10279 {
10280 TSQLMonitoringWriter* p = NULL;
10281 char* gvp = (char*) G__getgvp();
10282
10283 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10284 p = new TSQLMonitoringWriter(
10285 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
10286 , (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3]));
10287 } else {
10288 p = new((void*) gvp) TSQLMonitoringWriter(
10289 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
10290 , (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3]));
10291 }
10292 result7->obj.i = (long) p;
10293 result7->ref = (long) p;
10294 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__NetLN_TSQLMonitoringWriter));
10295 return(1 || funcname || hash || result7 || libp) ;
10296 }
10297
10298 static int G__G__Net_276_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10299 {
10300 G__letint(result7, 85, (long) TSQLMonitoringWriter::Class());
10301 return(1 || funcname || hash || result7 || libp) ;
10302 }
10303
10304 static int G__G__Net_276_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10305 {
10306 G__letint(result7, 67, (long) TSQLMonitoringWriter::Class_Name());
10307 return(1 || funcname || hash || result7 || libp) ;
10308 }
10309
10310 static int G__G__Net_276_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10311 {
10312 G__letint(result7, 115, (long) TSQLMonitoringWriter::Class_Version());
10313 return(1 || funcname || hash || result7 || libp) ;
10314 }
10315
10316 static int G__G__Net_276_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10317 {
10318 TSQLMonitoringWriter::Dictionary();
10319 G__setnull(result7);
10320 return(1 || funcname || hash || result7 || libp) ;
10321 }
10322
10323 static int G__G__Net_276_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10324 {
10325 ((TSQLMonitoringWriter*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
10326 G__setnull(result7);
10327 return(1 || funcname || hash || result7 || libp) ;
10328 }
10329
10330 static int G__G__Net_276_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10331 {
10332 G__letint(result7, 67, (long) TSQLMonitoringWriter::DeclFileName());
10333 return(1 || funcname || hash || result7 || libp) ;
10334 }
10335
10336 static int G__G__Net_276_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10337 {
10338 G__letint(result7, 105, (long) TSQLMonitoringWriter::ImplFileLine());
10339 return(1 || funcname || hash || result7 || libp) ;
10340 }
10341
10342 static int G__G__Net_276_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10343 {
10344 G__letint(result7, 67, (long) TSQLMonitoringWriter::ImplFileName());
10345 return(1 || funcname || hash || result7 || libp) ;
10346 }
10347
10348 static int G__G__Net_276_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10349 {
10350 G__letint(result7, 105, (long) TSQLMonitoringWriter::DeclFileLine());
10351 return(1 || funcname || hash || result7 || libp) ;
10352 }
10353
10354
10355 typedef TSQLMonitoringWriter G__TTSQLMonitoringWriter;
10356 static int G__G__Net_276_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10357 {
10358 char* gvp = (char*) G__getgvp();
10359 long soff = G__getstructoffset();
10360 int n = G__getaryconstruct();
10361
10362
10363
10364
10365
10366 if (!soff) {
10367 return(1);
10368 }
10369 if (n) {
10370 if (gvp == (char*)G__PVOID) {
10371 delete[] (TSQLMonitoringWriter*) soff;
10372 } else {
10373 G__setgvp((long) G__PVOID);
10374 for (int i = n - 1; i >= 0; --i) {
10375 ((TSQLMonitoringWriter*) (soff+(sizeof(TSQLMonitoringWriter)*i)))->~G__TTSQLMonitoringWriter();
10376 }
10377 G__setgvp((long)gvp);
10378 }
10379 } else {
10380 if (gvp == (char*)G__PVOID) {
10381 delete (TSQLMonitoringWriter*) soff;
10382 } else {
10383 G__setgvp((long) G__PVOID);
10384 ((TSQLMonitoringWriter*) (soff))->~G__TTSQLMonitoringWriter();
10385 G__setgvp((long)gvp);
10386 }
10387 }
10388 G__setnull(result7);
10389 return(1 || funcname || hash || result7 || libp) ;
10390 }
10391
10392
10393
10394 static int G__G__Net_277_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10395 {
10396 switch (libp->paran) {
10397 case 1:
10398 ((TSQLRow*) G__getstructoffset())->Close((Option_t*) G__int(libp->para[0]));
10399 G__setnull(result7);
10400 break;
10401 case 0:
10402 ((TSQLRow*) G__getstructoffset())->Close();
10403 G__setnull(result7);
10404 break;
10405 }
10406 return(1 || funcname || hash || result7 || libp) ;
10407 }
10408
10409 static int G__G__Net_277_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10410 {
10411 G__letint(result7, 107, (long) ((TSQLRow*) G__getstructoffset())->GetFieldLength((Int_t) G__int(libp->para[0])));
10412 return(1 || funcname || hash || result7 || libp) ;
10413 }
10414
10415 static int G__G__Net_277_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10416 {
10417 G__letint(result7, 67, (long) ((TSQLRow*) G__getstructoffset())->GetField((Int_t) G__int(libp->para[0])));
10418 return(1 || funcname || hash || result7 || libp) ;
10419 }
10420
10421 static int G__G__Net_277_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10422 {
10423 G__letint(result7, 67, (long) ((TSQLRow*) G__getstructoffset())->operator[]((Int_t) G__int(libp->para[0])));
10424 return(1 || funcname || hash || result7 || libp) ;
10425 }
10426
10427 static int G__G__Net_277_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10428 {
10429 G__letint(result7, 85, (long) TSQLRow::Class());
10430 return(1 || funcname || hash || result7 || libp) ;
10431 }
10432
10433 static int G__G__Net_277_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10434 {
10435 G__letint(result7, 67, (long) TSQLRow::Class_Name());
10436 return(1 || funcname || hash || result7 || libp) ;
10437 }
10438
10439 static int G__G__Net_277_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10440 {
10441 G__letint(result7, 115, (long) TSQLRow::Class_Version());
10442 return(1 || funcname || hash || result7 || libp) ;
10443 }
10444
10445 static int G__G__Net_277_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10446 {
10447 TSQLRow::Dictionary();
10448 G__setnull(result7);
10449 return(1 || funcname || hash || result7 || libp) ;
10450 }
10451
10452 static int G__G__Net_277_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10453 {
10454 ((TSQLRow*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
10455 G__setnull(result7);
10456 return(1 || funcname || hash || result7 || libp) ;
10457 }
10458
10459 static int G__G__Net_277_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10460 {
10461 G__letint(result7, 67, (long) TSQLRow::DeclFileName());
10462 return(1 || funcname || hash || result7 || libp) ;
10463 }
10464
10465 static int G__G__Net_277_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10466 {
10467 G__letint(result7, 105, (long) TSQLRow::ImplFileLine());
10468 return(1 || funcname || hash || result7 || libp) ;
10469 }
10470
10471 static int G__G__Net_277_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10472 {
10473 G__letint(result7, 67, (long) TSQLRow::ImplFileName());
10474 return(1 || funcname || hash || result7 || libp) ;
10475 }
10476
10477 static int G__G__Net_277_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10478 {
10479 G__letint(result7, 105, (long) TSQLRow::DeclFileLine());
10480 return(1 || funcname || hash || result7 || libp) ;
10481 }
10482
10483
10484 typedef TSQLRow G__TTSQLRow;
10485 static int G__G__Net_277_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10486 {
10487 char* gvp = (char*) G__getgvp();
10488 long soff = G__getstructoffset();
10489 int n = G__getaryconstruct();
10490
10491
10492
10493
10494
10495 if (!soff) {
10496 return(1);
10497 }
10498 if (n) {
10499 if (gvp == (char*)G__PVOID) {
10500 delete[] (TSQLRow*) soff;
10501 } else {
10502 G__setgvp((long) G__PVOID);
10503 for (int i = n - 1; i >= 0; --i) {
10504 ((TSQLRow*) (soff+(sizeof(TSQLRow)*i)))->~G__TTSQLRow();
10505 }
10506 G__setgvp((long)gvp);
10507 }
10508 } else {
10509 if (gvp == (char*)G__PVOID) {
10510 delete (TSQLRow*) soff;
10511 } else {
10512 G__setgvp((long) G__PVOID);
10513 ((TSQLRow*) (soff))->~G__TTSQLRow();
10514 G__setgvp((long)gvp);
10515 }
10516 }
10517 G__setnull(result7);
10518 return(1 || funcname || hash || result7 || libp) ;
10519 }
10520
10521
10522 static int G__G__Net_277_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10523 {
10524 TSQLRow* dest = (TSQLRow*) G__getstructoffset();
10525 *dest = *(TSQLRow*) libp->para[0].ref;
10526 const TSQLRow& obj = *dest;
10527 result7->ref = (long) (&obj);
10528 result7->obj.i = (long) (&obj);
10529 return(1 || funcname || hash || result7 || libp) ;
10530 }
10531
10532
10533
10534 static int G__G__Net_278_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10535 {
10536 switch (libp->paran) {
10537 case 1:
10538 ((TSQLResult*) G__getstructoffset())->Close((Option_t*) G__int(libp->para[0]));
10539 G__setnull(result7);
10540 break;
10541 case 0:
10542 ((TSQLResult*) G__getstructoffset())->Close();
10543 G__setnull(result7);
10544 break;
10545 }
10546 return(1 || funcname || hash || result7 || libp) ;
10547 }
10548
10549 static int G__G__Net_278_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10550 {
10551 G__letint(result7, 105, (long) ((TSQLResult*) G__getstructoffset())->GetFieldCount());
10552 return(1 || funcname || hash || result7 || libp) ;
10553 }
10554
10555 static int G__G__Net_278_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10556 {
10557 G__letint(result7, 67, (long) ((TSQLResult*) G__getstructoffset())->GetFieldName((Int_t) G__int(libp->para[0])));
10558 return(1 || funcname || hash || result7 || libp) ;
10559 }
10560
10561 static int G__G__Net_278_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10562 {
10563 G__letint(result7, 105, (long) ((const TSQLResult*) G__getstructoffset())->GetRowCount());
10564 return(1 || funcname || hash || result7 || libp) ;
10565 }
10566
10567 static int G__G__Net_278_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10568 {
10569 G__letint(result7, 85, (long) ((TSQLResult*) G__getstructoffset())->Next());
10570 return(1 || funcname || hash || result7 || libp) ;
10571 }
10572
10573 static int G__G__Net_278_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10574 {
10575 G__letint(result7, 85, (long) TSQLResult::Class());
10576 return(1 || funcname || hash || result7 || libp) ;
10577 }
10578
10579 static int G__G__Net_278_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10580 {
10581 G__letint(result7, 67, (long) TSQLResult::Class_Name());
10582 return(1 || funcname || hash || result7 || libp) ;
10583 }
10584
10585 static int G__G__Net_278_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10586 {
10587 G__letint(result7, 115, (long) TSQLResult::Class_Version());
10588 return(1 || funcname || hash || result7 || libp) ;
10589 }
10590
10591 static int G__G__Net_278_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10592 {
10593 TSQLResult::Dictionary();
10594 G__setnull(result7);
10595 return(1 || funcname || hash || result7 || libp) ;
10596 }
10597
10598 static int G__G__Net_278_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10599 {
10600 ((TSQLResult*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
10601 G__setnull(result7);
10602 return(1 || funcname || hash || result7 || libp) ;
10603 }
10604
10605 static int G__G__Net_278_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10606 {
10607 G__letint(result7, 67, (long) TSQLResult::DeclFileName());
10608 return(1 || funcname || hash || result7 || libp) ;
10609 }
10610
10611 static int G__G__Net_278_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10612 {
10613 G__letint(result7, 105, (long) TSQLResult::ImplFileLine());
10614 return(1 || funcname || hash || result7 || libp) ;
10615 }
10616
10617 static int G__G__Net_278_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10618 {
10619 G__letint(result7, 67, (long) TSQLResult::ImplFileName());
10620 return(1 || funcname || hash || result7 || libp) ;
10621 }
10622
10623 static int G__G__Net_278_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10624 {
10625 G__letint(result7, 105, (long) TSQLResult::DeclFileLine());
10626 return(1 || funcname || hash || result7 || libp) ;
10627 }
10628
10629
10630 typedef TSQLResult G__TTSQLResult;
10631 static int G__G__Net_278_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10632 {
10633 char* gvp = (char*) G__getgvp();
10634 long soff = G__getstructoffset();
10635 int n = G__getaryconstruct();
10636
10637
10638
10639
10640
10641 if (!soff) {
10642 return(1);
10643 }
10644 if (n) {
10645 if (gvp == (char*)G__PVOID) {
10646 delete[] (TSQLResult*) soff;
10647 } else {
10648 G__setgvp((long) G__PVOID);
10649 for (int i = n - 1; i >= 0; --i) {
10650 ((TSQLResult*) (soff+(sizeof(TSQLResult)*i)))->~G__TTSQLResult();
10651 }
10652 G__setgvp((long)gvp);
10653 }
10654 } else {
10655 if (gvp == (char*)G__PVOID) {
10656 delete (TSQLResult*) soff;
10657 } else {
10658 G__setgvp((long) G__PVOID);
10659 ((TSQLResult*) (soff))->~G__TTSQLResult();
10660 G__setgvp((long)gvp);
10661 }
10662 }
10663 G__setnull(result7);
10664 return(1 || funcname || hash || result7 || libp) ;
10665 }
10666
10667
10668 static int G__G__Net_278_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10669 {
10670 TSQLResult* dest = (TSQLResult*) G__getstructoffset();
10671 *dest = *(TSQLResult*) libp->para[0].ref;
10672 const TSQLResult& obj = *dest;
10673 result7->ref = (long) (&obj);
10674 result7->obj.i = (long) (&obj);
10675 return(1 || funcname || hash || result7 || libp) ;
10676 }
10677
10678
10679
10680 static int G__G__Net_279_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10681 {
10682 G__letint(result7, 105, (long) ((const TSQLStatement*) G__getstructoffset())->GetBufferLength());
10683 return(1 || funcname || hash || result7 || libp) ;
10684 }
10685
10686 static int G__G__Net_279_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10687 {
10688 G__letint(result7, 105, (long) ((TSQLStatement*) G__getstructoffset())->GetNumParameters());
10689 return(1 || funcname || hash || result7 || libp) ;
10690 }
10691
10692 static int G__G__Net_279_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10693 {
10694 G__letint(result7, 103, (long) ((TSQLStatement*) G__getstructoffset())->NextIteration());
10695 return(1 || funcname || hash || result7 || libp) ;
10696 }
10697
10698 static int G__G__Net_279_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10699 {
10700 G__letint(result7, 103, (long) ((TSQLStatement*) G__getstructoffset())->SetNull((Int_t) G__int(libp->para[0])));
10701 return(1 || funcname || hash || result7 || libp) ;
10702 }
10703
10704 static int G__G__Net_279_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10705 {
10706 G__letint(result7, 103, (long) ((TSQLStatement*) G__getstructoffset())->SetInt((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
10707 return(1 || funcname || hash || result7 || libp) ;
10708 }
10709
10710 static int G__G__Net_279_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10711 {
10712 G__letint(result7, 103, (long) ((TSQLStatement*) G__getstructoffset())->SetUInt((Int_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])));
10713 return(1 || funcname || hash || result7 || libp) ;
10714 }
10715
10716 static int G__G__Net_279_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10717 {
10718 G__letint(result7, 103, (long) ((TSQLStatement*) G__getstructoffset())->SetLong((Int_t) G__int(libp->para[0]), (Long_t) G__int(libp->para[1])));
10719 return(1 || funcname || hash || result7 || libp) ;
10720 }
10721
10722 static int G__G__Net_279_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10723 {
10724 G__letint(result7, 103, (long) ((TSQLStatement*) G__getstructoffset())->SetLong64((Int_t) G__int(libp->para[0]), (Long64_t) G__Longlong(libp->para[1])));
10725 return(1 || funcname || hash || result7 || libp) ;
10726 }
10727
10728 static int G__G__Net_279_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10729 {
10730 G__letint(result7, 103, (long) ((TSQLStatement*) G__getstructoffset())->SetULong64((Int_t) G__int(libp->para[0]), (ULong64_t) G__ULonglong(libp->para[1])));
10731 return(1 || funcname || hash || result7 || libp) ;
10732 }
10733
10734 static int G__G__Net_279_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10735 {
10736 G__letint(result7, 103, (long) ((TSQLStatement*) G__getstructoffset())->SetDouble((Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])));
10737 return(1 || funcname || hash || result7 || libp) ;
10738 }
10739
10740 static int G__G__Net_279_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10741 {
10742 switch (libp->paran) {
10743 case 3:
10744 G__letint(result7, 103, (long) ((TSQLStatement*) G__getstructoffset())->SetString((Int_t) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
10745 , (Int_t) G__int(libp->para[2])));
10746 break;
10747 case 2:
10748 G__letint(result7, 103, (long) ((TSQLStatement*) G__getstructoffset())->SetString((Int_t) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
10749 break;
10750 }
10751 return(1 || funcname || hash || result7 || libp) ;
10752 }
10753
10754 static int G__G__Net_279_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10755 {
10756 G__letint(result7, 103, (long) ((TSQLStatement*) G__getstructoffset())->SetDate((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
10757 , (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])));
10758 return(1 || funcname || hash || result7 || libp) ;
10759 }
10760
10761 static int G__G__Net_279_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10762 {
10763 G__letint(result7, 103, (long) ((TSQLStatement*) G__getstructoffset())->SetDate((Int_t) G__int(libp->para[0]), *(TDatime*) libp->para[1].ref));
10764 return(1 || funcname || hash || result7 || libp) ;
10765 }
10766
10767 static int G__G__Net_279_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10768 {
10769 G__letint(result7, 103, (long) ((TSQLStatement*) G__getstructoffset())->SetTime((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
10770 , (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])));
10771 return(1 || funcname || hash || result7 || libp) ;
10772 }
10773
10774 static int G__G__Net_279_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10775 {
10776 G__letint(result7, 103, (long) ((TSQLStatement*) G__getstructoffset())->SetTime((Int_t) G__int(libp->para[0]), *(TDatime*) libp->para[1].ref));
10777 return(1 || funcname || hash || result7 || libp) ;
10778 }
10779
10780 static int G__G__Net_279_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10781 {
10782 G__letint(result7, 103, (long) ((TSQLStatement*) G__getstructoffset())->SetDatime(
10783 (Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
10784 , (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
10785 , (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])
10786 , (Int_t) G__int(libp->para[6])));
10787 return(1 || funcname || hash || result7 || libp) ;
10788 }
10789
10790 static int G__G__Net_279_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10791 {
10792 G__letint(result7, 103, (long) ((TSQLStatement*) G__getstructoffset())->SetDatime((Int_t) G__int(libp->para[0]), *(TDatime*) libp->para[1].ref));
10793 return(1 || funcname || hash || result7 || libp) ;
10794 }
10795
10796 static int G__G__Net_279_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10797 {
10798 switch (libp->paran) {
10799 case 8:
10800 G__letint(result7, 103, (long) ((TSQLStatement*) G__getstructoffset())->SetTimestamp(
10801 (Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
10802 , (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
10803 , (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])
10804 , (Int_t) G__int(libp->para[6]), (Int_t) G__int(libp->para[7])));
10805 break;
10806 case 7:
10807 G__letint(result7, 103, (long) ((TSQLStatement*) G__getstructoffset())->SetTimestamp(
10808 (Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
10809 , (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
10810 , (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])
10811 , (Int_t) G__int(libp->para[6])));
10812 break;
10813 }
10814 return(1 || funcname || hash || result7 || libp) ;
10815 }
10816
10817 static int G__G__Net_279_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10818 {
10819 G__letint(result7, 103, (long) ((TSQLStatement*) G__getstructoffset())->SetTimestamp((Int_t) G__int(libp->para[0]), *(TDatime*) libp->para[1].ref));
10820 return(1 || funcname || hash || result7 || libp) ;
10821 }
10822
10823 static int G__G__Net_279_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10824 {
10825 ((TSQLStatement*) G__getstructoffset())->SetTimeFormating((const char*) G__int(libp->para[0]));
10826 G__setnull(result7);
10827 return(1 || funcname || hash || result7 || libp) ;
10828 }
10829
10830 static int G__G__Net_279_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10831 {
10832 switch (libp->paran) {
10833 case 4:
10834 G__letint(result7, 103, (long) ((TSQLStatement*) G__getstructoffset())->SetBinary((Int_t) G__int(libp->para[0]), (void*) G__int(libp->para[1])
10835 , (Long_t) G__int(libp->para[2]), (Long_t) G__int(libp->para[3])));
10836 break;
10837 case 3:
10838 G__letint(result7, 103, (long) ((TSQLStatement*) G__getstructoffset())->SetBinary((Int_t) G__int(libp->para[0]), (void*) G__int(libp->para[1])
10839 , (Long_t) G__int(libp->para[2])));
10840 break;
10841 }
10842 return(1 || funcname || hash || result7 || libp) ;
10843 }
10844
10845 static int G__G__Net_279_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10846 {
10847 G__letint(result7, 103, (long) ((TSQLStatement*) G__getstructoffset())->Process());
10848 return(1 || funcname || hash || result7 || libp) ;
10849 }
10850
10851 static int G__G__Net_279_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10852 {
10853 G__letint(result7, 105, (long) ((TSQLStatement*) G__getstructoffset())->GetNumAffectedRows());
10854 return(1 || funcname || hash || result7 || libp) ;
10855 }
10856
10857 static int G__G__Net_279_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10858 {
10859 G__letint(result7, 103, (long) ((TSQLStatement*) G__getstructoffset())->StoreResult());
10860 return(1 || funcname || hash || result7 || libp) ;
10861 }
10862
10863 static int G__G__Net_279_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10864 {
10865 G__letint(result7, 105, (long) ((TSQLStatement*) G__getstructoffset())->GetNumFields());
10866 return(1 || funcname || hash || result7 || libp) ;
10867 }
10868
10869 static int G__G__Net_279_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10870 {
10871 G__letint(result7, 67, (long) ((TSQLStatement*) G__getstructoffset())->GetFieldName((Int_t) G__int(libp->para[0])));
10872 return(1 || funcname || hash || result7 || libp) ;
10873 }
10874
10875 static int G__G__Net_279_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10876 {
10877 G__letint(result7, 103, (long) ((TSQLStatement*) G__getstructoffset())->SetMaxFieldSize((Int_t) G__int(libp->para[0]), (Long_t) G__int(libp->para[1])));
10878 return(1 || funcname || hash || result7 || libp) ;
10879 }
10880
10881 static int G__G__Net_279_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10882 {
10883 G__letint(result7, 103, (long) ((TSQLStatement*) G__getstructoffset())->NextResultRow());
10884 return(1 || funcname || hash || result7 || libp) ;
10885 }
10886
10887 static int G__G__Net_279_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10888 {
10889 G__letint(result7, 103, (long) ((TSQLStatement*) G__getstructoffset())->IsNull((Int_t) G__int(libp->para[0])));
10890 return(1 || funcname || hash || result7 || libp) ;
10891 }
10892
10893 static int G__G__Net_279_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10894 {
10895 G__letint(result7, 105, (long) ((TSQLStatement*) G__getstructoffset())->GetInt((Int_t) G__int(libp->para[0])));
10896 return(1 || funcname || hash || result7 || libp) ;
10897 }
10898
10899 static int G__G__Net_279_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10900 {
10901 G__letint(result7, 104, (long) ((TSQLStatement*) G__getstructoffset())->GetUInt((Int_t) G__int(libp->para[0])));
10902 return(1 || funcname || hash || result7 || libp) ;
10903 }
10904
10905 static int G__G__Net_279_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10906 {
10907 G__letint(result7, 108, (long) ((TSQLStatement*) G__getstructoffset())->GetLong((Int_t) G__int(libp->para[0])));
10908 return(1 || funcname || hash || result7 || libp) ;
10909 }
10910
10911 static int G__G__Net_279_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10912 {
10913 G__letLonglong(result7, 110, (G__int64) ((TSQLStatement*) G__getstructoffset())->GetLong64((Int_t) G__int(libp->para[0])));
10914 return(1 || funcname || hash || result7 || libp) ;
10915 }
10916
10917 static int G__G__Net_279_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10918 {
10919 G__letULonglong(result7, 109, (G__uint64) ((TSQLStatement*) G__getstructoffset())->GetULong64((Int_t) G__int(libp->para[0])));
10920 return(1 || funcname || hash || result7 || libp) ;
10921 }
10922
10923 static int G__G__Net_279_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10924 {
10925 G__letdouble(result7, 100, (double) ((TSQLStatement*) G__getstructoffset())->GetDouble((Int_t) G__int(libp->para[0])));
10926 return(1 || funcname || hash || result7 || libp) ;
10927 }
10928
10929 static int G__G__Net_279_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10930 {
10931 G__letint(result7, 67, (long) ((TSQLStatement*) G__getstructoffset())->GetString((Int_t) G__int(libp->para[0])));
10932 return(1 || funcname || hash || result7 || libp) ;
10933 }
10934
10935 static int G__G__Net_279_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10936 {
10937 G__letint(result7, 103, (long) ((TSQLStatement*) G__getstructoffset())->GetBinary((Int_t) G__int(libp->para[0]), libp->para[1].ref ? *(void**) libp->para[1].ref : *(void**) (void*) (&G__Mlong(libp->para[1]))
10938 , *(Long_t*) G__Longref(&libp->para[2])));
10939 return(1 || funcname || hash || result7 || libp) ;
10940 }
10941
10942 static int G__G__Net_279_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10943 {
10944 G__letint(result7, 103, (long) ((TSQLStatement*) G__getstructoffset())->GetDate((Int_t) G__int(libp->para[0]), *(Int_t*) G__Intref(&libp->para[1])
10945 , *(Int_t*) G__Intref(&libp->para[2]), *(Int_t*) G__Intref(&libp->para[3])));
10946 return(1 || funcname || hash || result7 || libp) ;
10947 }
10948
10949 static int G__G__Net_279_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10950 {
10951 G__letint(result7, 103, (long) ((TSQLStatement*) G__getstructoffset())->GetTime((Int_t) G__int(libp->para[0]), *(Int_t*) G__Intref(&libp->para[1])
10952 , *(Int_t*) G__Intref(&libp->para[2]), *(Int_t*) G__Intref(&libp->para[3])));
10953 return(1 || funcname || hash || result7 || libp) ;
10954 }
10955
10956 static int G__G__Net_279_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10957 {
10958 G__letint(result7, 103, (long) ((TSQLStatement*) G__getstructoffset())->GetDatime(
10959 (Int_t) G__int(libp->para[0]), *(Int_t*) G__Intref(&libp->para[1])
10960 , *(Int_t*) G__Intref(&libp->para[2]), *(Int_t*) G__Intref(&libp->para[3])
10961 , *(Int_t*) G__Intref(&libp->para[4]), *(Int_t*) G__Intref(&libp->para[5])
10962 , *(Int_t*) G__Intref(&libp->para[6])));
10963 return(1 || funcname || hash || result7 || libp) ;
10964 }
10965
10966 static int G__G__Net_279_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10967 {
10968 {
10969 TDatime* pobj;
10970 TDatime xobj = ((TSQLStatement*) G__getstructoffset())->GetDatime((Int_t) G__int(libp->para[0]));
10971 pobj = new TDatime(xobj);
10972 result7->obj.i = (long) ((void*) pobj);
10973 result7->ref = result7->obj.i;
10974 G__store_tempobject(*result7);
10975 }
10976 return(1 || funcname || hash || result7 || libp) ;
10977 }
10978
10979 static int G__G__Net_279_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10980 {
10981 G__letint(result7, 105, (long) ((TSQLStatement*) G__getstructoffset())->GetYear((Int_t) G__int(libp->para[0])));
10982 return(1 || funcname || hash || result7 || libp) ;
10983 }
10984
10985 static int G__G__Net_279_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10986 {
10987 G__letint(result7, 105, (long) ((TSQLStatement*) G__getstructoffset())->GetMonth((Int_t) G__int(libp->para[0])));
10988 return(1 || funcname || hash || result7 || libp) ;
10989 }
10990
10991 static int G__G__Net_279_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10992 {
10993 G__letint(result7, 105, (long) ((TSQLStatement*) G__getstructoffset())->GetDay((Int_t) G__int(libp->para[0])));
10994 return(1 || funcname || hash || result7 || libp) ;
10995 }
10996
10997 static int G__G__Net_279_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10998 {
10999 G__letint(result7, 105, (long) ((TSQLStatement*) G__getstructoffset())->GetHour((Int_t) G__int(libp->para[0])));
11000 return(1 || funcname || hash || result7 || libp) ;
11001 }
11002
11003 static int G__G__Net_279_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11004 {
11005 G__letint(result7, 105, (long) ((TSQLStatement*) G__getstructoffset())->GetMinute((Int_t) G__int(libp->para[0])));
11006 return(1 || funcname || hash || result7 || libp) ;
11007 }
11008
11009 static int G__G__Net_279_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11010 {
11011 G__letint(result7, 105, (long) ((TSQLStatement*) G__getstructoffset())->GetSecond((Int_t) G__int(libp->para[0])));
11012 return(1 || funcname || hash || result7 || libp) ;
11013 }
11014
11015 static int G__G__Net_279_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11016 {
11017 G__letint(result7, 103, (long) ((TSQLStatement*) G__getstructoffset())->GetTimestamp(
11018 (Int_t) G__int(libp->para[0]), *(Int_t*) G__Intref(&libp->para[1])
11019 , *(Int_t*) G__Intref(&libp->para[2]), *(Int_t*) G__Intref(&libp->para[3])
11020 , *(Int_t*) G__Intref(&libp->para[4]), *(Int_t*) G__Intref(&libp->para[5])
11021 , *(Int_t*) G__Intref(&libp->para[6]), *(Int_t*) G__Intref(&libp->para[7])));
11022 return(1 || funcname || hash || result7 || libp) ;
11023 }
11024
11025 static int G__G__Net_279_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11026 {
11027 {
11028 TDatime* pobj;
11029 TDatime xobj = ((TSQLStatement*) G__getstructoffset())->GetTimestamp((Int_t) G__int(libp->para[0]));
11030 pobj = new TDatime(xobj);
11031 result7->obj.i = (long) ((void*) pobj);
11032 result7->ref = result7->obj.i;
11033 G__store_tempobject(*result7);
11034 }
11035 return(1 || funcname || hash || result7 || libp) ;
11036 }
11037
11038 static int G__G__Net_279_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11039 {
11040 G__letint(result7, 103, (long) ((const TSQLStatement*) G__getstructoffset())->IsError());
11041 return(1 || funcname || hash || result7 || libp) ;
11042 }
11043
11044 static int G__G__Net_279_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11045 {
11046 G__letint(result7, 105, (long) ((const TSQLStatement*) G__getstructoffset())->GetErrorCode());
11047 return(1 || funcname || hash || result7 || libp) ;
11048 }
11049
11050 static int G__G__Net_279_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11051 {
11052 G__letint(result7, 67, (long) ((const TSQLStatement*) G__getstructoffset())->GetErrorMsg());
11053 return(1 || funcname || hash || result7 || libp) ;
11054 }
11055
11056 static int G__G__Net_279_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11057 {
11058 switch (libp->paran) {
11059 case 1:
11060 ((TSQLStatement*) G__getstructoffset())->EnableErrorOutput((Bool_t) G__int(libp->para[0]));
11061 G__setnull(result7);
11062 break;
11063 case 0:
11064 ((TSQLStatement*) G__getstructoffset())->EnableErrorOutput();
11065 G__setnull(result7);
11066 break;
11067 }
11068 return(1 || funcname || hash || result7 || libp) ;
11069 }
11070
11071 static int G__G__Net_279_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11072 {
11073 G__letint(result7, 85, (long) TSQLStatement::Class());
11074 return(1 || funcname || hash || result7 || libp) ;
11075 }
11076
11077 static int G__G__Net_279_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11078 {
11079 G__letint(result7, 67, (long) TSQLStatement::Class_Name());
11080 return(1 || funcname || hash || result7 || libp) ;
11081 }
11082
11083 static int G__G__Net_279_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11084 {
11085 G__letint(result7, 115, (long) TSQLStatement::Class_Version());
11086 return(1 || funcname || hash || result7 || libp) ;
11087 }
11088
11089 static int G__G__Net_279_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11090 {
11091 TSQLStatement::Dictionary();
11092 G__setnull(result7);
11093 return(1 || funcname || hash || result7 || libp) ;
11094 }
11095
11096 static int G__G__Net_279_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11097 {
11098 ((TSQLStatement*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
11099 G__setnull(result7);
11100 return(1 || funcname || hash || result7 || libp) ;
11101 }
11102
11103 static int G__G__Net_279_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11104 {
11105 G__letint(result7, 67, (long) TSQLStatement::DeclFileName());
11106 return(1 || funcname || hash || result7 || libp) ;
11107 }
11108
11109 static int G__G__Net_279_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11110 {
11111 G__letint(result7, 105, (long) TSQLStatement::ImplFileLine());
11112 return(1 || funcname || hash || result7 || libp) ;
11113 }
11114
11115 static int G__G__Net_279_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11116 {
11117 G__letint(result7, 67, (long) TSQLStatement::ImplFileName());
11118 return(1 || funcname || hash || result7 || libp) ;
11119 }
11120
11121 static int G__G__Net_279_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11122 {
11123 G__letint(result7, 105, (long) TSQLStatement::DeclFileLine());
11124 return(1 || funcname || hash || result7 || libp) ;
11125 }
11126
11127
11128 typedef TSQLStatement G__TTSQLStatement;
11129 static int G__G__Net_279_0_69(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11130 {
11131 char* gvp = (char*) G__getgvp();
11132 long soff = G__getstructoffset();
11133 int n = G__getaryconstruct();
11134
11135
11136
11137
11138
11139 if (!soff) {
11140 return(1);
11141 }
11142 if (n) {
11143 if (gvp == (char*)G__PVOID) {
11144 delete[] (TSQLStatement*) soff;
11145 } else {
11146 G__setgvp((long) G__PVOID);
11147 for (int i = n - 1; i >= 0; --i) {
11148 ((TSQLStatement*) (soff+(sizeof(TSQLStatement)*i)))->~G__TTSQLStatement();
11149 }
11150 G__setgvp((long)gvp);
11151 }
11152 } else {
11153 if (gvp == (char*)G__PVOID) {
11154 delete (TSQLStatement*) soff;
11155 } else {
11156 G__setgvp((long) G__PVOID);
11157 ((TSQLStatement*) (soff))->~G__TTSQLStatement();
11158 G__setgvp((long)gvp);
11159 }
11160 }
11161 G__setnull(result7);
11162 return(1 || funcname || hash || result7 || libp) ;
11163 }
11164
11165
11166 static int G__G__Net_279_0_70(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11167 {
11168 TSQLStatement* dest = (TSQLStatement*) G__getstructoffset();
11169 *dest = *(TSQLStatement*) libp->para[0].ref;
11170 const TSQLStatement& obj = *dest;
11171 result7->ref = (long) (&obj);
11172 result7->obj.i = (long) (&obj);
11173 return(1 || funcname || hash || result7 || libp) ;
11174 }
11175
11176
11177
11178 static int G__G__Net_280_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11179 {
11180 TSQLTableInfo* p = NULL;
11181 char* gvp = (char*) G__getgvp();
11182 int n = G__getaryconstruct();
11183 if (n) {
11184 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11185 p = new TSQLTableInfo[n];
11186 } else {
11187 p = new((void*) gvp) TSQLTableInfo[n];
11188 }
11189 } else {
11190 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11191 p = new TSQLTableInfo;
11192 } else {
11193 p = new((void*) gvp) TSQLTableInfo;
11194 }
11195 }
11196 result7->obj.i = (long) p;
11197 result7->ref = (long) p;
11198 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__NetLN_TSQLTableInfo));
11199 return(1 || funcname || hash || result7 || libp) ;
11200 }
11201
11202 static int G__G__Net_280_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11203 {
11204 TSQLTableInfo* p = NULL;
11205 char* gvp = (char*) G__getgvp();
11206 switch (libp->paran) {
11207 case 6:
11208
11209 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11210 p = new TSQLTableInfo(
11211 (const char*) G__int(libp->para[0]), (TList*) G__int(libp->para[1])
11212 , (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
11213 , (const char*) G__int(libp->para[4]), (const char*) G__int(libp->para[5]));
11214 } else {
11215 p = new((void*) gvp) TSQLTableInfo(
11216 (const char*) G__int(libp->para[0]), (TList*) G__int(libp->para[1])
11217 , (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
11218 , (const char*) G__int(libp->para[4]), (const char*) G__int(libp->para[5]));
11219 }
11220 break;
11221 case 5:
11222
11223 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11224 p = new TSQLTableInfo(
11225 (const char*) G__int(libp->para[0]), (TList*) G__int(libp->para[1])
11226 , (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
11227 , (const char*) G__int(libp->para[4]));
11228 } else {
11229 p = new((void*) gvp) TSQLTableInfo(
11230 (const char*) G__int(libp->para[0]), (TList*) G__int(libp->para[1])
11231 , (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
11232 , (const char*) G__int(libp->para[4]));
11233 }
11234 break;
11235 case 4:
11236
11237 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11238 p = new TSQLTableInfo(
11239 (const char*) G__int(libp->para[0]), (TList*) G__int(libp->para[1])
11240 , (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3]));
11241 } else {
11242 p = new((void*) gvp) TSQLTableInfo(
11243 (const char*) G__int(libp->para[0]), (TList*) G__int(libp->para[1])
11244 , (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3]));
11245 }
11246 break;
11247 case 3:
11248
11249 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11250 p = new TSQLTableInfo(
11251 (const char*) G__int(libp->para[0]), (TList*) G__int(libp->para[1])
11252 , (const char*) G__int(libp->para[2]));
11253 } else {
11254 p = new((void*) gvp) TSQLTableInfo(
11255 (const char*) G__int(libp->para[0]), (TList*) G__int(libp->para[1])
11256 , (const char*) G__int(libp->para[2]));
11257 }
11258 break;
11259 case 2:
11260
11261 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11262 p = new TSQLTableInfo((const char*) G__int(libp->para[0]), (TList*) G__int(libp->para[1]));
11263 } else {
11264 p = new((void*) gvp) TSQLTableInfo((const char*) G__int(libp->para[0]), (TList*) G__int(libp->para[1]));
11265 }
11266 break;
11267 }
11268 result7->obj.i = (long) p;
11269 result7->ref = (long) p;
11270 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__NetLN_TSQLTableInfo));
11271 return(1 || funcname || hash || result7 || libp) ;
11272 }
11273
11274 static int G__G__Net_280_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11275 {
11276 G__letint(result7, 85, (long) ((const TSQLTableInfo*) G__getstructoffset())->GetColumns());
11277 return(1 || funcname || hash || result7 || libp) ;
11278 }
11279
11280 static int G__G__Net_280_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11281 {
11282 G__letint(result7, 85, (long) ((TSQLTableInfo*) G__getstructoffset())->FindColumn((const char*) G__int(libp->para[0])));
11283 return(1 || funcname || hash || result7 || libp) ;
11284 }
11285
11286 static int G__G__Net_280_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11287 {
11288 G__letint(result7, 67, (long) ((const TSQLTableInfo*) G__getstructoffset())->GetEngine());
11289 return(1 || funcname || hash || result7 || libp) ;
11290 }
11291
11292 static int G__G__Net_280_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11293 {
11294 G__letint(result7, 67, (long) ((const TSQLTableInfo*) G__getstructoffset())->GetCreateTime());
11295 return(1 || funcname || hash || result7 || libp) ;
11296 }
11297
11298 static int G__G__Net_280_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11299 {
11300 G__letint(result7, 67, (long) ((const TSQLTableInfo*) G__getstructoffset())->GetUpdateTime());
11301 return(1 || funcname || hash || result7 || libp) ;
11302 }
11303
11304 static int G__G__Net_280_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11305 {
11306 G__letint(result7, 85, (long) TSQLTableInfo::Class());
11307 return(1 || funcname || hash || result7 || libp) ;
11308 }
11309
11310 static int G__G__Net_280_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11311 {
11312 G__letint(result7, 67, (long) TSQLTableInfo::Class_Name());
11313 return(1 || funcname || hash || result7 || libp) ;
11314 }
11315
11316 static int G__G__Net_280_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11317 {
11318 G__letint(result7, 115, (long) TSQLTableInfo::Class_Version());
11319 return(1 || funcname || hash || result7 || libp) ;
11320 }
11321
11322 static int G__G__Net_280_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11323 {
11324 TSQLTableInfo::Dictionary();
11325 G__setnull(result7);
11326 return(1 || funcname || hash || result7 || libp) ;
11327 }
11328
11329 static int G__G__Net_280_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11330 {
11331 ((TSQLTableInfo*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
11332 G__setnull(result7);
11333 return(1 || funcname || hash || result7 || libp) ;
11334 }
11335
11336 static int G__G__Net_280_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11337 {
11338 G__letint(result7, 67, (long) TSQLTableInfo::DeclFileName());
11339 return(1 || funcname || hash || result7 || libp) ;
11340 }
11341
11342 static int G__G__Net_280_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11343 {
11344 G__letint(result7, 105, (long) TSQLTableInfo::ImplFileLine());
11345 return(1 || funcname || hash || result7 || libp) ;
11346 }
11347
11348 static int G__G__Net_280_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11349 {
11350 G__letint(result7, 67, (long) TSQLTableInfo::ImplFileName());
11351 return(1 || funcname || hash || result7 || libp) ;
11352 }
11353
11354 static int G__G__Net_280_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11355 {
11356 G__letint(result7, 105, (long) TSQLTableInfo::DeclFileLine());
11357 return(1 || funcname || hash || result7 || libp) ;
11358 }
11359
11360
11361 static int G__G__Net_280_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11362
11363 {
11364 TSQLTableInfo* p;
11365 void* tmp = (void*) G__int(libp->para[0]);
11366 p = new TSQLTableInfo(*(TSQLTableInfo*) tmp);
11367 result7->obj.i = (long) p;
11368 result7->ref = (long) p;
11369 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__NetLN_TSQLTableInfo));
11370 return(1 || funcname || hash || result7 || libp) ;
11371 }
11372
11373
11374 typedef TSQLTableInfo G__TTSQLTableInfo;
11375 static int G__G__Net_280_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11376 {
11377 char* gvp = (char*) G__getgvp();
11378 long soff = G__getstructoffset();
11379 int n = G__getaryconstruct();
11380
11381
11382
11383
11384
11385 if (!soff) {
11386 return(1);
11387 }
11388 if (n) {
11389 if (gvp == (char*)G__PVOID) {
11390 delete[] (TSQLTableInfo*) soff;
11391 } else {
11392 G__setgvp((long) G__PVOID);
11393 for (int i = n - 1; i >= 0; --i) {
11394 ((TSQLTableInfo*) (soff+(sizeof(TSQLTableInfo)*i)))->~G__TTSQLTableInfo();
11395 }
11396 G__setgvp((long)gvp);
11397 }
11398 } else {
11399 if (gvp == (char*)G__PVOID) {
11400 delete (TSQLTableInfo*) soff;
11401 } else {
11402 G__setgvp((long) G__PVOID);
11403 ((TSQLTableInfo*) (soff))->~G__TTSQLTableInfo();
11404 G__setgvp((long)gvp);
11405 }
11406 }
11407 G__setnull(result7);
11408 return(1 || funcname || hash || result7 || libp) ;
11409 }
11410
11411
11412 static int G__G__Net_280_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11413 {
11414 TSQLTableInfo* dest = (TSQLTableInfo*) G__getstructoffset();
11415 *dest = *(TSQLTableInfo*) libp->para[0].ref;
11416 const TSQLTableInfo& obj = *dest;
11417 result7->ref = (long) (&obj);
11418 result7->obj.i = (long) (&obj);
11419 return(1 || funcname || hash || result7 || libp) ;
11420 }
11421
11422
11423
11424 static int G__G__Net_283_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11425 {
11426 TWebFile* p = NULL;
11427 char* gvp = (char*) G__getgvp();
11428 switch (libp->paran) {
11429 case 2:
11430
11431 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11432 p = new TWebFile((const char*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1]));
11433 } else {
11434 p = new((void*) gvp) TWebFile((const char*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1]));
11435 }
11436 break;
11437 case 1:
11438
11439 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11440 p = new TWebFile((const char*) G__int(libp->para[0]));
11441 } else {
11442 p = new((void*) gvp) TWebFile((const char*) G__int(libp->para[0]));
11443 }
11444 break;
11445 }
11446 result7->obj.i = (long) p;
11447 result7->ref = (long) p;
11448 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__NetLN_TWebFile));
11449 return(1 || funcname || hash || result7 || libp) ;
11450 }
11451
11452 static int G__G__Net_283_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11453 {
11454 TWebFile* p = NULL;
11455 char* gvp = (char*) G__getgvp();
11456 switch (libp->paran) {
11457 case 2:
11458
11459 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11460 p = new TWebFile(*((TUrl*) G__int(libp->para[0])), (Option_t*) G__int(libp->para[1]));
11461 } else {
11462 p = new((void*) gvp) TWebFile(*((TUrl*) G__int(libp->para[0])), (Option_t*) G__int(libp->para[1]));
11463 }
11464 break;
11465 case 1:
11466
11467 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11468 p = new TWebFile(*((TUrl*) G__int(libp->para[0])));
11469 } else {
11470 p = new((void*) gvp) TWebFile(*((TUrl*) G__int(libp->para[0])));
11471 }
11472 break;
11473 }
11474 result7->obj.i = (long) p;
11475 result7->ref = (long) p;
11476 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__NetLN_TWebFile));
11477 return(1 || funcname || hash || result7 || libp) ;
11478 }
11479
11480 static int G__G__Net_283_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11481 {
11482 TWebFile::SetProxy((const char*) G__int(libp->para[0]));
11483 G__setnull(result7);
11484 return(1 || funcname || hash || result7 || libp) ;
11485 }
11486
11487 static int G__G__Net_283_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11488 {
11489 G__letint(result7, 67, (long) TWebFile::GetProxy());
11490 return(1 || funcname || hash || result7 || libp) ;
11491 }
11492
11493 static int G__G__Net_283_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11494 {
11495 G__letint(result7, 85, (long) TWebFile::Class());
11496 return(1 || funcname || hash || result7 || libp) ;
11497 }
11498
11499 static int G__G__Net_283_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11500 {
11501 G__letint(result7, 67, (long) TWebFile::Class_Name());
11502 return(1 || funcname || hash || result7 || libp) ;
11503 }
11504
11505 static int G__G__Net_283_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11506 {
11507 G__letint(result7, 115, (long) TWebFile::Class_Version());
11508 return(1 || funcname || hash || result7 || libp) ;
11509 }
11510
11511 static int G__G__Net_283_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11512 {
11513 TWebFile::Dictionary();
11514 G__setnull(result7);
11515 return(1 || funcname || hash || result7 || libp) ;
11516 }
11517
11518 static int G__G__Net_283_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11519 {
11520 ((TWebFile*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
11521 G__setnull(result7);
11522 return(1 || funcname || hash || result7 || libp) ;
11523 }
11524
11525 static int G__G__Net_283_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11526 {
11527 G__letint(result7, 67, (long) TWebFile::DeclFileName());
11528 return(1 || funcname || hash || result7 || libp) ;
11529 }
11530
11531 static int G__G__Net_283_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11532 {
11533 G__letint(result7, 105, (long) TWebFile::ImplFileLine());
11534 return(1 || funcname || hash || result7 || libp) ;
11535 }
11536
11537 static int G__G__Net_283_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11538 {
11539 G__letint(result7, 67, (long) TWebFile::ImplFileName());
11540 return(1 || funcname || hash || result7 || libp) ;
11541 }
11542
11543 static int G__G__Net_283_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11544 {
11545 G__letint(result7, 105, (long) TWebFile::DeclFileLine());
11546 return(1 || funcname || hash || result7 || libp) ;
11547 }
11548
11549
11550 typedef TWebFile G__TTWebFile;
11551 static int G__G__Net_283_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11552 {
11553 char* gvp = (char*) G__getgvp();
11554 long soff = G__getstructoffset();
11555 int n = G__getaryconstruct();
11556
11557
11558
11559
11560
11561 if (!soff) {
11562 return(1);
11563 }
11564 if (n) {
11565 if (gvp == (char*)G__PVOID) {
11566 delete[] (TWebFile*) soff;
11567 } else {
11568 G__setgvp((long) G__PVOID);
11569 for (int i = n - 1; i >= 0; --i) {
11570 ((TWebFile*) (soff+(sizeof(TWebFile)*i)))->~G__TTWebFile();
11571 }
11572 G__setgvp((long)gvp);
11573 }
11574 } else {
11575 if (gvp == (char*)G__PVOID) {
11576 delete (TWebFile*) soff;
11577 } else {
11578 G__setgvp((long) G__PVOID);
11579 ((TWebFile*) (soff))->~G__TTWebFile();
11580 G__setgvp((long)gvp);
11581 }
11582 }
11583 G__setnull(result7);
11584 return(1 || funcname || hash || result7 || libp) ;
11585 }
11586
11587
11588
11589 static int G__G__Net_284_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11590 {
11591 TWebSystem* p = NULL;
11592 char* gvp = (char*) G__getgvp();
11593 int n = G__getaryconstruct();
11594 if (n) {
11595 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11596 p = new TWebSystem[n];
11597 } else {
11598 p = new((void*) gvp) TWebSystem[n];
11599 }
11600 } else {
11601 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11602 p = new TWebSystem;
11603 } else {
11604 p = new((void*) gvp) TWebSystem;
11605 }
11606 }
11607 result7->obj.i = (long) p;
11608 result7->ref = (long) p;
11609 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__NetLN_TWebSystem));
11610 return(1 || funcname || hash || result7 || libp) ;
11611 }
11612
11613 static int G__G__Net_284_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11614 {
11615 G__letint(result7, 85, (long) TWebSystem::Class());
11616 return(1 || funcname || hash || result7 || libp) ;
11617 }
11618
11619 static int G__G__Net_284_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11620 {
11621 G__letint(result7, 67, (long) TWebSystem::Class_Name());
11622 return(1 || funcname || hash || result7 || libp) ;
11623 }
11624
11625 static int G__G__Net_284_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11626 {
11627 G__letint(result7, 115, (long) TWebSystem::Class_Version());
11628 return(1 || funcname || hash || result7 || libp) ;
11629 }
11630
11631 static int G__G__Net_284_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11632 {
11633 TWebSystem::Dictionary();
11634 G__setnull(result7);
11635 return(1 || funcname || hash || result7 || libp) ;
11636 }
11637
11638 static int G__G__Net_284_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11639 {
11640 ((TWebSystem*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
11641 G__setnull(result7);
11642 return(1 || funcname || hash || result7 || libp) ;
11643 }
11644
11645 static int G__G__Net_284_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11646 {
11647 G__letint(result7, 67, (long) TWebSystem::DeclFileName());
11648 return(1 || funcname || hash || result7 || libp) ;
11649 }
11650
11651 static int G__G__Net_284_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11652 {
11653 G__letint(result7, 105, (long) TWebSystem::ImplFileLine());
11654 return(1 || funcname || hash || result7 || libp) ;
11655 }
11656
11657 static int G__G__Net_284_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11658 {
11659 G__letint(result7, 67, (long) TWebSystem::ImplFileName());
11660 return(1 || funcname || hash || result7 || libp) ;
11661 }
11662
11663 static int G__G__Net_284_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11664 {
11665 G__letint(result7, 105, (long) TWebSystem::DeclFileLine());
11666 return(1 || funcname || hash || result7 || libp) ;
11667 }
11668
11669
11670 typedef TWebSystem G__TTWebSystem;
11671 static int G__G__Net_284_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11672 {
11673 char* gvp = (char*) G__getgvp();
11674 long soff = G__getstructoffset();
11675 int n = G__getaryconstruct();
11676
11677
11678
11679
11680
11681 if (!soff) {
11682 return(1);
11683 }
11684 if (n) {
11685 if (gvp == (char*)G__PVOID) {
11686 delete[] (TWebSystem*) soff;
11687 } else {
11688 G__setgvp((long) G__PVOID);
11689 for (int i = n - 1; i >= 0; --i) {
11690 ((TWebSystem*) (soff+(sizeof(TWebSystem)*i)))->~G__TTWebSystem();
11691 }
11692 G__setgvp((long)gvp);
11693 }
11694 } else {
11695 if (gvp == (char*)G__PVOID) {
11696 delete (TWebSystem*) soff;
11697 } else {
11698 G__setgvp((long) G__PVOID);
11699 ((TWebSystem*) (soff))->~G__TTWebSystem();
11700 G__setgvp((long)gvp);
11701 }
11702 }
11703 G__setnull(result7);
11704 return(1 || funcname || hash || result7 || libp) ;
11705 }
11706
11707
11708
11709
11710
11711
11712
11713
11714
11715
11716
11717
11718
11719
11720
11721
11722
11723
11724
11725
11726
11727
11728
11729
11730
11731
11732
11733
11734
11735
11736
11737
11738
11739
11740
11741
11742
11743
11744
11745
11746
11747
11748
11749
11750
11751
11752
11753
11754
11755
11756
11757
11758
11759
11760
11761
11762
11763
11764
11765
11766
11767
11768
11769
11770
11771
11772
11773
11774
11775
11776
11777
11778
11779
11780
11781 class G__Sizep2memfuncG__Net {
11782 public:
11783 G__Sizep2memfuncG__Net(): p(&G__Sizep2memfuncG__Net::sizep2memfunc) {}
11784 size_t sizep2memfunc() { return(sizeof(p)); }
11785 private:
11786 size_t (G__Sizep2memfuncG__Net::*p)();
11787 };
11788
11789 size_t G__get_sizep2memfuncG__Net()
11790 {
11791 G__Sizep2memfuncG__Net a;
11792 G__setsizep2memfunc((int)a.sizep2memfunc());
11793 return((size_t)a.sizep2memfunc());
11794 }
11795
11796
11797
11798
11799
11800
11801
11802
11803
11804
11805
11806 extern "C" void G__cpp_setup_inheritanceG__Net() {
11807
11808
11809 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__NetLN_TMessage))) {
11810 TMessage *G__Lderived;
11811 G__Lderived=(TMessage*)0x1000;
11812 {
11813 TBufferFile *G__Lpbase=(TBufferFile*)G__Lderived;
11814 G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TMessage),G__get_linked_tagnum(&G__G__NetLN_TBufferFile),(long)G__Lpbase-(long)G__Lderived,1,1);
11815 }
11816 {
11817 TBuffer *G__Lpbase=(TBuffer*)G__Lderived;
11818 G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TMessage),G__get_linked_tagnum(&G__G__NetLN_TBuffer),(long)G__Lpbase-(long)G__Lderived,1,0);
11819 }
11820 {
11821 TObject *G__Lpbase=(TObject*)G__Lderived;
11822 G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TMessage),G__get_linked_tagnum(&G__G__NetLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
11823 }
11824 }
11825 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__NetLN_TSocket))) {
11826 TSocket *G__Lderived;
11827 G__Lderived=(TSocket*)0x1000;
11828 {
11829 TNamed *G__Lpbase=(TNamed*)G__Lderived;
11830 G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TSocket),G__get_linked_tagnum(&G__G__NetLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
11831 }
11832 {
11833 TObject *G__Lpbase=(TObject*)G__Lderived;
11834 G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TSocket),G__get_linked_tagnum(&G__G__NetLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
11835 }
11836 }
11837 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__NetLN_TPSocket))) {
11838 TPSocket *G__Lderived;
11839 G__Lderived=(TPSocket*)0x1000;
11840 {
11841 TSocket *G__Lpbase=(TSocket*)G__Lderived;
11842 G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TPSocket),G__get_linked_tagnum(&G__G__NetLN_TSocket),(long)G__Lpbase-(long)G__Lderived,1,1);
11843 }
11844 {
11845 TNamed *G__Lpbase=(TNamed*)G__Lderived;
11846 G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TPSocket),G__get_linked_tagnum(&G__G__NetLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
11847 }
11848 {
11849 TObject *G__Lpbase=(TObject*)G__Lderived;
11850 G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TPSocket),G__get_linked_tagnum(&G__G__NetLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
11851 }
11852 }
11853 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__NetLN_TMonitor))) {
11854 TMonitor *G__Lderived;
11855 G__Lderived=(TMonitor*)0x1000;
11856 {
11857 TObject *G__Lpbase=(TObject*)G__Lderived;
11858 G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TMonitor),G__get_linked_tagnum(&G__G__NetLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
11859 }
11860 {
11861 TQObject *G__Lpbase=(TQObject*)G__Lderived;
11862 G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TMonitor),G__get_linked_tagnum(&G__G__NetLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,1);
11863 }
11864 }
11865 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__NetLN_TApplicationRemote))) {
11866 TApplicationRemote *G__Lderived;
11867 G__Lderived=(TApplicationRemote*)0x1000;
11868 {
11869 TApplication *G__Lpbase=(TApplication*)G__Lderived;
11870 G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TApplicationRemote),G__get_linked_tagnum(&G__G__NetLN_TApplication),(long)G__Lpbase-(long)G__Lderived,1,1);
11871 }
11872 {
11873 TObject *G__Lpbase=(TObject*)G__Lderived;
11874 G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TApplicationRemote),G__get_linked_tagnum(&G__G__NetLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
11875 }
11876 {
11877 TQObject *G__Lpbase=(TQObject*)G__Lderived;
11878 G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TApplicationRemote),G__get_linked_tagnum(&G__G__NetLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
11879 }
11880 }
11881 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__NetLN_TApplicationServer))) {
11882 TApplicationServer *G__Lderived;
11883 G__Lderived=(TApplicationServer*)0x1000;
11884 {
11885 TApplication *G__Lpbase=(TApplication*)G__Lderived;
11886 G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TApplicationServer),G__get_linked_tagnum(&G__G__NetLN_TApplication),(long)G__Lpbase-(long)G__Lderived,1,1);
11887 }
11888 {
11889 TObject *G__Lpbase=(TObject*)G__Lderived;
11890 G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TApplicationServer),G__get_linked_tagnum(&G__G__NetLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
11891 }
11892 {
11893 TQObject *G__Lpbase=(TQObject*)G__Lderived;
11894 G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TApplicationServer),G__get_linked_tagnum(&G__G__NetLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
11895 }
11896 }
11897 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__NetLN_TFileStager))) {
11898 TFileStager *G__Lderived;
11899 G__Lderived=(TFileStager*)0x1000;
11900 {
11901 TNamed *G__Lpbase=(TNamed*)G__Lderived;
11902 G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TFileStager),G__get_linked_tagnum(&G__G__NetLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
11903 }
11904 {
11905 TObject *G__Lpbase=(TObject*)G__Lderived;
11906 G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TFileStager),G__get_linked_tagnum(&G__G__NetLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
11907 }
11908 }
11909 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__NetLN_TServerSocket))) {
11910 TServerSocket *G__Lderived;
11911 G__Lderived=(TServerSocket*)0x1000;
11912 {
11913 TSocket *G__Lpbase=(TSocket*)G__Lderived;
11914 G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TServerSocket),G__get_linked_tagnum(&G__G__NetLN_TSocket),(long)G__Lpbase-(long)G__Lderived,1,1);
11915 }
11916 {
11917 TNamed *G__Lpbase=(TNamed*)G__Lderived;
11918 G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TServerSocket),G__get_linked_tagnum(&G__G__NetLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
11919 }
11920 {
11921 TObject *G__Lpbase=(TObject*)G__Lderived;
11922 G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TServerSocket),G__get_linked_tagnum(&G__G__NetLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
11923 }
11924 }
11925 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__NetLN_TFTP))) {
11926 TFTP *G__Lderived;
11927 G__Lderived=(TFTP*)0x1000;
11928 {
11929 TObject *G__Lpbase=(TObject*)G__Lderived;
11930 G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TFTP),G__get_linked_tagnum(&G__G__NetLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
11931 }
11932 }
11933 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__NetLN_TGridResult))) {
11934 TGridResult *G__Lderived;
11935 G__Lderived=(TGridResult*)0x1000;
11936 {
11937 TList *G__Lpbase=(TList*)G__Lderived;
11938 G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TGridResult),G__get_linked_tagnum(&G__G__NetLN_TList),(long)G__Lpbase-(long)G__Lderived,1,1);
11939 }
11940 {
11941 TSeqCollection *G__Lpbase=(TSeqCollection*)G__Lderived;
11942 G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TGridResult),G__get_linked_tagnum(&G__G__NetLN_TSeqCollection),(long)G__Lpbase-(long)G__Lderived,1,0);
11943 }
11944 {
11945 TCollection *G__Lpbase=(TCollection*)G__Lderived;
11946 G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TGridResult),G__get_linked_tagnum(&G__G__NetLN_TCollection),(long)G__Lpbase-(long)G__Lderived,1,0);
11947 }
11948 {
11949 TObject *G__Lpbase=(TObject*)G__Lderived;
11950 G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TGridResult),G__get_linked_tagnum(&G__G__NetLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
11951 }
11952 }
11953 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__NetLN_TGridCollection))) {
11954 TGridCollection *G__Lderived;
11955 G__Lderived=(TGridCollection*)0x1000;
11956 {
11957 TObject *G__Lpbase=(TObject*)G__Lderived;
11958 G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TGridCollection),G__get_linked_tagnum(&G__G__NetLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
11959 }
11960 }
11961 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__NetLN_TGridJobStatus))) {
11962 TGridJobStatus *G__Lderived;
11963 G__Lderived=(TGridJobStatus*)0x1000;
11964 {
11965 TNamed *G__Lpbase=(TNamed*)G__Lderived;
11966 G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TGridJobStatus),G__get_linked_tagnum(&G__G__NetLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
11967 }
11968 {
11969 TObject *G__Lpbase=(TObject*)G__Lderived;
11970 G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TGridJobStatus),G__get_linked_tagnum(&G__G__NetLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
11971 }
11972 }
11973 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__NetLN_TGridJob))) {
11974 TGridJob *G__Lderived;
11975 G__Lderived=(TGridJob*)0x1000;
11976 {
11977 TObject *G__Lpbase=(TObject*)G__Lderived;
11978 G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TGridJob),G__get_linked_tagnum(&G__G__NetLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
11979 }
11980 }
11981 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__NetLN_TGridJDL))) {
11982 TGridJDL *G__Lderived;
11983 G__Lderived=(TGridJDL*)0x1000;
11984 {
11985 TObject *G__Lpbase=(TObject*)G__Lderived;
11986 G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TGridJDL),G__get_linked_tagnum(&G__G__NetLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
11987 }
11988 }
11989 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__NetLN_TGridJobStatusList))) {
11990 TGridJobStatusList *G__Lderived;
11991 G__Lderived=(TGridJobStatusList*)0x1000;
11992 {
11993 TList *G__Lpbase=(TList*)G__Lderived;
11994 G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TGridJobStatusList),G__get_linked_tagnum(&G__G__NetLN_TList),(long)G__Lpbase-(long)G__Lderived,1,1);
11995 }
11996 {
11997 TSeqCollection *G__Lpbase=(TSeqCollection*)G__Lderived;
11998 G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TGridJobStatusList),G__get_linked_tagnum(&G__G__NetLN_TSeqCollection),(long)G__Lpbase-(long)G__Lderived,1,0);
11999 }
12000 {
12001 TCollection *G__Lpbase=(TCollection*)G__Lderived;
12002 G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TGridJobStatusList),G__get_linked_tagnum(&G__G__NetLN_TCollection),(long)G__Lpbase-(long)G__Lderived,1,0);
12003 }
12004 {
12005 TObject *G__Lpbase=(TObject*)G__Lderived;
12006 G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TGridJobStatusList),G__get_linked_tagnum(&G__G__NetLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12007 }
12008 }
12009 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__NetLN_TGrid))) {
12010 TGrid *G__Lderived;
12011 G__Lderived=(TGrid*)0x1000;
12012 {
12013 TObject *G__Lpbase=(TObject*)G__Lderived;
12014 G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TGrid),G__get_linked_tagnum(&G__G__NetLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
12015 }
12016 }
12017 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__NetLN_TNetFile))) {
12018 TNetFile *G__Lderived;
12019 G__Lderived=(TNetFile*)0x1000;
12020 {
12021 TFile *G__Lpbase=(TFile*)G__Lderived;
12022 G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TNetFile),G__get_linked_tagnum(&G__G__NetLN_TFile),(long)G__Lpbase-(long)G__Lderived,1,1);
12023 }
12024 {
12025 TDirectoryFile *G__Lpbase=(TDirectoryFile*)G__Lderived;
12026 G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TNetFile),G__get_linked_tagnum(&G__G__NetLN_TDirectoryFile),(long)G__Lpbase-(long)G__Lderived,1,0);
12027 }
12028 {
12029 TDirectory *G__Lpbase=(TDirectory*)G__Lderived;
12030 G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TNetFile),G__get_linked_tagnum(&G__G__NetLN_TDirectory),(long)G__Lpbase-(long)G__Lderived,1,0);
12031 }
12032 {
12033 TNamed *G__Lpbase=(TNamed*)G__Lderived;
12034 G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TNetFile),G__get_linked_tagnum(&G__G__NetLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
12035 }
12036 {
12037 TObject *G__Lpbase=(TObject*)G__Lderived;
12038 G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TNetFile),G__get_linked_tagnum(&G__G__NetLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12039 }
12040 }
12041 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__NetLN_TNetSystem))) {
12042 TNetSystem *G__Lderived;
12043 G__Lderived=(TNetSystem*)0x1000;
12044 {
12045 TSystem *G__Lpbase=(TSystem*)G__Lderived;
12046 G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TNetSystem),G__get_linked_tagnum(&G__G__NetLN_TSystem),(long)G__Lpbase-(long)G__Lderived,1,1);
12047 }
12048 {
12049 TNamed *G__Lpbase=(TNamed*)G__Lderived;
12050 G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TNetSystem),G__get_linked_tagnum(&G__G__NetLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
12051 }
12052 {
12053 TObject *G__Lpbase=(TObject*)G__Lderived;
12054 G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TNetSystem),G__get_linked_tagnum(&G__G__NetLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12055 }
12056 }
12057 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__NetLN_TSecContext))) {
12058 TSecContext *G__Lderived;
12059 G__Lderived=(TSecContext*)0x1000;
12060 {
12061 TObject *G__Lpbase=(TObject*)G__Lderived;
12062 G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TSecContext),G__get_linked_tagnum(&G__G__NetLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
12063 }
12064 }
12065 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__NetLN_TSecContextCleanup))) {
12066 TSecContextCleanup *G__Lderived;
12067 G__Lderived=(TSecContextCleanup*)0x1000;
12068 {
12069 TObject *G__Lpbase=(TObject*)G__Lderived;
12070 G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TSecContextCleanup),G__get_linked_tagnum(&G__G__NetLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
12071 }
12072 }
12073 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__NetLN_TPServerSocket))) {
12074 TPServerSocket *G__Lderived;
12075 G__Lderived=(TPServerSocket*)0x1000;
12076 {
12077 TServerSocket *G__Lpbase=(TServerSocket*)G__Lderived;
12078 G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TPServerSocket),G__get_linked_tagnum(&G__G__NetLN_TServerSocket),(long)G__Lpbase-(long)G__Lderived,1,1);
12079 }
12080 {
12081 TSocket *G__Lpbase=(TSocket*)G__Lderived;
12082 G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TPServerSocket),G__get_linked_tagnum(&G__G__NetLN_TSocket),(long)G__Lpbase-(long)G__Lderived,1,0);
12083 }
12084 {
12085 TNamed *G__Lpbase=(TNamed*)G__Lderived;
12086 G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TPServerSocket),G__get_linked_tagnum(&G__G__NetLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
12087 }
12088 {
12089 TObject *G__Lpbase=(TObject*)G__Lderived;
12090 G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TPServerSocket),G__get_linked_tagnum(&G__G__NetLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12091 }
12092 }
12093 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__NetLN_TSQLColumnInfo))) {
12094 TSQLColumnInfo *G__Lderived;
12095 G__Lderived=(TSQLColumnInfo*)0x1000;
12096 {
12097 TNamed *G__Lpbase=(TNamed*)G__Lderived;
12098 G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TSQLColumnInfo),G__get_linked_tagnum(&G__G__NetLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
12099 }
12100 {
12101 TObject *G__Lpbase=(TObject*)G__Lderived;
12102 G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TSQLColumnInfo),G__get_linked_tagnum(&G__G__NetLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12103 }
12104 }
12105 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__NetLN_TSQLServer))) {
12106 TSQLServer *G__Lderived;
12107 G__Lderived=(TSQLServer*)0x1000;
12108 {
12109 TObject *G__Lpbase=(TObject*)G__Lderived;
12110 G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TSQLServer),G__get_linked_tagnum(&G__G__NetLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
12111 }
12112 }
12113 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__NetLN_TSQLMonitoringWriter))) {
12114 TSQLMonitoringWriter *G__Lderived;
12115 G__Lderived=(TSQLMonitoringWriter*)0x1000;
12116 {
12117 TVirtualMonitoringWriter *G__Lpbase=(TVirtualMonitoringWriter*)G__Lderived;
12118 G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TSQLMonitoringWriter),G__get_linked_tagnum(&G__G__NetLN_TVirtualMonitoringWriter),(long)G__Lpbase-(long)G__Lderived,1,1);
12119 }
12120 {
12121 TNamed *G__Lpbase=(TNamed*)G__Lderived;
12122 G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TSQLMonitoringWriter),G__get_linked_tagnum(&G__G__NetLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
12123 }
12124 {
12125 TObject *G__Lpbase=(TObject*)G__Lderived;
12126 G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TSQLMonitoringWriter),G__get_linked_tagnum(&G__G__NetLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12127 }
12128 }
12129 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__NetLN_TSQLRow))) {
12130 TSQLRow *G__Lderived;
12131 G__Lderived=(TSQLRow*)0x1000;
12132 {
12133 TObject *G__Lpbase=(TObject*)G__Lderived;
12134 G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TSQLRow),G__get_linked_tagnum(&G__G__NetLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
12135 }
12136 }
12137 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__NetLN_TSQLResult))) {
12138 TSQLResult *G__Lderived;
12139 G__Lderived=(TSQLResult*)0x1000;
12140 {
12141 TObject *G__Lpbase=(TObject*)G__Lderived;
12142 G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TSQLResult),G__get_linked_tagnum(&G__G__NetLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
12143 }
12144 }
12145 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__NetLN_TSQLStatement))) {
12146 TSQLStatement *G__Lderived;
12147 G__Lderived=(TSQLStatement*)0x1000;
12148 {
12149 TObject *G__Lpbase=(TObject*)G__Lderived;
12150 G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TSQLStatement),G__get_linked_tagnum(&G__G__NetLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
12151 }
12152 }
12153 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__NetLN_TSQLTableInfo))) {
12154 TSQLTableInfo *G__Lderived;
12155 G__Lderived=(TSQLTableInfo*)0x1000;
12156 {
12157 TNamed *G__Lpbase=(TNamed*)G__Lderived;
12158 G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TSQLTableInfo),G__get_linked_tagnum(&G__G__NetLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
12159 }
12160 {
12161 TObject *G__Lpbase=(TObject*)G__Lderived;
12162 G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TSQLTableInfo),G__get_linked_tagnum(&G__G__NetLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12163 }
12164 }
12165 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__NetLN_TWebFile))) {
12166 TWebFile *G__Lderived;
12167 G__Lderived=(TWebFile*)0x1000;
12168 {
12169 TFile *G__Lpbase=(TFile*)G__Lderived;
12170 G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TWebFile),G__get_linked_tagnum(&G__G__NetLN_TFile),(long)G__Lpbase-(long)G__Lderived,1,1);
12171 }
12172 {
12173 TDirectoryFile *G__Lpbase=(TDirectoryFile*)G__Lderived;
12174 G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TWebFile),G__get_linked_tagnum(&G__G__NetLN_TDirectoryFile),(long)G__Lpbase-(long)G__Lderived,1,0);
12175 }
12176 {
12177 TDirectory *G__Lpbase=(TDirectory*)G__Lderived;
12178 G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TWebFile),G__get_linked_tagnum(&G__G__NetLN_TDirectory),(long)G__Lpbase-(long)G__Lderived,1,0);
12179 }
12180 {
12181 TNamed *G__Lpbase=(TNamed*)G__Lderived;
12182 G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TWebFile),G__get_linked_tagnum(&G__G__NetLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
12183 }
12184 {
12185 TObject *G__Lpbase=(TObject*)G__Lderived;
12186 G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TWebFile),G__get_linked_tagnum(&G__G__NetLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12187 }
12188 }
12189 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__NetLN_TWebSystem))) {
12190 TWebSystem *G__Lderived;
12191 G__Lderived=(TWebSystem*)0x1000;
12192 {
12193 TSystem *G__Lpbase=(TSystem*)G__Lderived;
12194 G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TWebSystem),G__get_linked_tagnum(&G__G__NetLN_TSystem),(long)G__Lpbase-(long)G__Lderived,1,1);
12195 }
12196 {
12197 TNamed *G__Lpbase=(TNamed*)G__Lderived;
12198 G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TWebSystem),G__get_linked_tagnum(&G__G__NetLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
12199 }
12200 {
12201 TObject *G__Lpbase=(TObject*)G__Lderived;
12202 G__inheritance_setup(G__get_linked_tagnum(&G__G__NetLN_TWebSystem),G__get_linked_tagnum(&G__G__NetLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12203 }
12204 }
12205 }
12206
12207
12208
12209
12210 extern "C" void G__cpp_setup_typetableG__Net() {
12211
12212
12213 G__search_typename2("UChar_t",98,-1,0,-1);
12214 G__setnewtype(-1,"Unsigned Character 1 byte (unsigned char)",0);
12215 G__search_typename2("Int_t",105,-1,0,-1);
12216 G__setnewtype(-1,"Signed integer 4 bytes (int)",0);
12217 G__search_typename2("UInt_t",104,-1,0,-1);
12218 G__setnewtype(-1,"Unsigned integer 4 bytes (unsigned int)",0);
12219 G__search_typename2("Long_t",108,-1,0,-1);
12220 G__setnewtype(-1,"Signed long integer 4 bytes (long)",0);
12221 G__search_typename2("ULong_t",107,-1,0,-1);
12222 G__setnewtype(-1,"Unsigned long integer 4 bytes (unsigned long)",0);
12223 G__search_typename2("Double_t",100,-1,0,-1);
12224 G__setnewtype(-1,"Double 8 bytes",0);
12225 G__search_typename2("Bool_t",103,-1,0,-1);
12226 G__setnewtype(-1,"Boolean (0=false, 1=true) (bool)",0);
12227 G__search_typename2("Version_t",115,-1,0,-1);
12228 G__setnewtype(-1,"Class version identifier (short)",0);
12229 G__search_typename2("Option_t",99,-1,256,-1);
12230 G__setnewtype(-1,"Option string (const char)",0);
12231 G__search_typename2("Long64_t",110,-1,0,-1);
12232 G__setnewtype(-1,"Portable signed long integer 8 bytes",0);
12233 G__search_typename2("ULong64_t",109,-1,0,-1);
12234 G__setnewtype(-1,"Portable unsigned long integer 8 bytes",0);
12235 G__search_typename2("vector<ROOT::TSchemaHelper>",117,G__get_linked_tagnum(&G__G__NetLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR),0,-1);
12236 G__setnewtype(-1,NULL,0);
12237 G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__NetLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__NetLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
12238 G__setnewtype(-1,NULL,0);
12239 G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__NetLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__NetLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
12240 G__setnewtype(-1,NULL,0);
12241 G__search_typename2("vector<TVirtualArray*>",117,G__get_linked_tagnum(&G__G__NetLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR),0,-1);
12242 G__setnewtype(-1,NULL,0);
12243 G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__NetLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__NetLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR));
12244 G__setnewtype(-1,NULL,0);
12245 G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__NetLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__NetLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR));
12246 G__setnewtype(-1,NULL,0);
12247 G__search_typename2("iterator<std::bidirectional_iterator_tag,TObject*,std::ptrdiff_t,const TObject**,const TObject*&>",117,G__get_linked_tagnum(&G__G__NetLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
12248 G__setnewtype(-1,NULL,0);
12249 G__search_typename2("iterator<bidirectional_iterator_tag,TObject*>",117,G__get_linked_tagnum(&G__G__NetLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
12250 G__setnewtype(-1,NULL,0);
12251 G__search_typename2("iterator<bidirectional_iterator_tag,TObject*,long>",117,G__get_linked_tagnum(&G__G__NetLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
12252 G__setnewtype(-1,NULL,0);
12253 G__search_typename2("iterator<bidirectional_iterator_tag,TObject*,long,const TObject**>",117,G__get_linked_tagnum(&G__G__NetLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
12254 G__setnewtype(-1,NULL,0);
12255 G__search_typename2("vector<TStreamerInfo*>",117,G__get_linked_tagnum(&G__G__NetLN_vectorlETStreamerInfomUcOallocatorlETStreamerInfomUgRsPgR),0,-1);
12256 G__setnewtype(-1,NULL,0);
12257 G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__NetLN_reverse_iteratorlEvectorlETStreamerInfomUcOallocatorlETStreamerInfomUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__NetLN_vectorlETStreamerInfomUcOallocatorlETStreamerInfomUgRsPgR));
12258 G__setnewtype(-1,NULL,0);
12259 G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__NetLN_reverse_iteratorlEvectorlETStreamerInfomUcOallocatorlETStreamerInfomUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__NetLN_vectorlETStreamerInfomUcOallocatorlETStreamerInfomUgRsPgR));
12260 G__setnewtype(-1,NULL,0);
12261 G__search_typename2("vector<UInt_t>",117,G__get_linked_tagnum(&G__G__NetLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR),0,-1);
12262 G__setnewtype(-1,NULL,0);
12263 G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__NetLN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__NetLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR));
12264 G__setnewtype(-1,NULL,0);
12265 G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__NetLN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__NetLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR));
12266 G__setnewtype(-1,NULL,0);
12267 G__search_typename2("vector<unsigned int>",117,G__get_linked_tagnum(&G__G__NetLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR),0,-1);
12268 G__setnewtype(-1,NULL,0);
12269 G__search_typename2("vector<TString>",117,G__get_linked_tagnum(&G__G__NetLN_vectorlETStringcOallocatorlETStringgRsPgR),0,-1);
12270 G__setnewtype(-1,NULL,0);
12271 G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__NetLN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__NetLN_vectorlETStringcOallocatorlETStringgRsPgR));
12272 G__setnewtype(-1,NULL,0);
12273 G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__NetLN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__NetLN_vectorlETStringcOallocatorlETStringgRsPgR));
12274 G__setnewtype(-1,NULL,0);
12275 }
12276
12277
12278
12279
12280
12281
12282
12283
12284 static void G__setup_memvarTMessage(void) {
12285 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__NetLN_TMessage));
12286 { TMessage *p; p=(TMessage*)0x1000; if (p) { }
12287 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TList),-1,-1,4,"fInfos=",0,"Array of TStreamerInfo used in WriteObject");
12288 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TBits),-1,-1,4,"fBitsPIDs=",0,"Array of bits to mark the TProcessIDs uids written to the message");
12289 G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"fWhat=",0,"Message type");
12290 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TClass),-1,-1,4,"fClass=",0,"If message is kMESS_OBJECT pointer to object's class");
12291 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fCompress=",0,"Compression level from 0 (not compressed) to 9 (max compression)");
12292 G__memvar_setup((void*)0,67,0,0,-1,-1,-1,4,"fBufComp=",0,"Compressed buffer");
12293 G__memvar_setup((void*)0,67,0,0,-1,-1,-1,4,"fBufCompCur=",0,"Current position in compressed buffer");
12294 G__memvar_setup((void*)0,67,0,0,-1,-1,-1,4,"fCompPos=",0,"Position of fBufCur when message was compressed");
12295 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fEvolution=",0,"True if support for schema evolution required");
12296 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-2,4,"fgEvolution=",0,"True if global support for schema evolution required");
12297 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
12298 }
12299 G__tag_memvar_reset();
12300 }
12301
12302
12303
12304 static void G__setup_memvarTSocket(void) {
12305 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__NetLN_TSocket));
12306 { TSocket *p; p=(TSocket*)0x1000; if (p) { }
12307 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_TSocketcLcLEStatusBits),-1,-2,1,G__FastAllocString(2048).Format("kIsUnix=%lldLL",(long long)TSocket::kIsUnix).data(),0,(char*)NULL);
12308 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_TSocketcLcLEInterest),-1,-2,1,G__FastAllocString(2048).Format("kRead=%lldLL",(long long)TSocket::kRead).data(),0,(char*)NULL);
12309 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_TSocketcLcLEInterest),-1,-2,1,G__FastAllocString(2048).Format("kWrite=%lldLL",(long long)TSocket::kWrite).data(),0,(char*)NULL);
12310 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_TSocketcLcLEServiceType),-1,-2,1,G__FastAllocString(2048).Format("kSOCKD=%lldLL",(long long)TSocket::kSOCKD).data(),0,(char*)NULL);
12311 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_TSocketcLcLEServiceType),-1,-2,1,G__FastAllocString(2048).Format("kROOTD=%lldLL",(long long)TSocket::kROOTD).data(),0,(char*)NULL);
12312 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_TSocketcLcLEServiceType),-1,-2,1,G__FastAllocString(2048).Format("kPROOFD=%lldLL",(long long)TSocket::kPROOFD).data(),0,(char*)NULL);
12313 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TInetAddress),-1,-1,2,"fAddress=",0,"remote internet address and port #");
12314 G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fBytesRecv=",0,"total bytes received over this socket");
12315 G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fBytesSent=",0,"total bytes sent using this socket");
12316 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fCompress=",0,"compression level from 0 (not compressed)");
12317 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TInetAddress),-1,-1,2,"fLocalAddress=",0,"local internet address and port #");
12318 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fRemoteProtocol=",0,"protocol of remote daemon");
12319 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TSecContext),-1,-1,2,"fSecContext=",0,"after a successful Authenticate call");
12320 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TString),-1,-1,2,"fService=",0,"name of service (matches remote port #)");
12321 G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__NetLN_TSocketcLcLEServiceType),-1,-1,2,"fServType=",0,"remote service type");
12322 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fSocket=",0,"socket descriptor");
12323 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fTcpWindowSize=",0,"TCP window size (default 65535);");
12324 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TString),-1,-1,2,"fUrl=",0,"needs this for special authentication options");
12325 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TBits),-1,-1,2,"fBitsInfo=",0,"bits array to mark TStreamerInfo classes already sent");
12326 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TList),-1,-1,2,"fUUIDs=",0,"list of TProcessIDs already sent through the socket");
12327 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TVirtualMutex),-1,-1,2,"fLastUsageMtx=",0,"Protect last usage setting / reading");
12328 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TTimeStamp),-1,-1,2,"fLastUsage=",0,"Time stamp of last usage");
12329 G__memvar_setup((void*)0,109,0,0,-1,G__defined_typename("ULong64_t"),-2,2,"fgBytesRecv=",0,"total bytes received by all socket objects");
12330 G__memvar_setup((void*)0,109,0,0,-1,G__defined_typename("ULong64_t"),-2,2,"fgBytesSent=",0,"total bytes sent by all socket objects");
12331 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-2,2,"fgClientProtocol=",0,"client \"protocol\" version");
12332 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
12333 }
12334 G__tag_memvar_reset();
12335 }
12336
12337
12338
12339 static void G__setup_memvarTPSocket(void) {
12340 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__NetLN_TPSocket));
12341 { TPSocket *p; p=(TPSocket*)0x1000; if (p) { }
12342 G__memvar_setup((void*)0,85,2,0,G__get_linked_tagnum(&G__G__NetLN_TSocket),-1,-1,4,"fSockets=",0,"array of parallel sockets");
12343 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TMonitor),-1,-1,4,"fWriteMonitor=",0,"monitor write on parallel sockets");
12344 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TMonitor),-1,-1,4,"fReadMonitor=",0,"monitor read from parallel sockets");
12345 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fSize=",0,"number of parallel sockets");
12346 G__memvar_setup((void*)0,73,0,0,-1,G__defined_typename("Int_t"),-1,4,"fWriteBytesLeft=",0,"bytes left to write for specified socket");
12347 G__memvar_setup((void*)0,73,0,0,-1,G__defined_typename("Int_t"),-1,4,"fReadBytesLeft=",0,"bytes left to read for specified socket");
12348 G__memvar_setup((void*)0,67,2,0,-1,-1,-1,4,"fWritePtr=",0,"pointer to write buffer for specified socket");
12349 G__memvar_setup((void*)0,67,2,0,-1,-1,-1,4,"fReadPtr=",0,"pointer to read buffer for specified socket");
12350 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
12351 }
12352 G__tag_memvar_reset();
12353 }
12354
12355
12356
12357 static void G__setup_memvarTMonitor(void) {
12358 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__NetLN_TMonitor));
12359 { TMonitor *p; p=(TMonitor*)0x1000; if (p) { }
12360 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TList),-1,-1,4,"fActive=",0,"list of sockets to monitor");
12361 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TList),-1,-1,4,"fDeActive=",0,"list of (temporary) disabled sockets");
12362 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TSocket),-1,-1,4,"fReady=",0,"socket which is ready to be read or written");
12363 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fMainLoop=",0,"true if monitoring sockets within the main event loop");
12364 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fInterrupt=",0,"flags an interrupt to Select");
12365 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_TMonitorcLcLEInterest),-1,-2,1,G__FastAllocString(2048).Format("kRead=%lldLL",(long long)TMonitor::kRead).data(),0,(char*)NULL);
12366 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_TMonitorcLcLEInterest),-1,-2,1,G__FastAllocString(2048).Format("kWrite=%lldLL",(long long)TMonitor::kWrite).data(),0,(char*)NULL);
12367 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
12368 }
12369 G__tag_memvar_reset();
12370 }
12371
12372
12373
12374 static void G__setup_memvarTApplicationRemote(void) {
12375 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__NetLN_TApplicationRemote));
12376 { TApplicationRemote *p; p=(TApplicationRemote*)0x1000; if (p) { }
12377 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_TApplicationRemotecLcLESendFileOpt),-1,-2,1,G__FastAllocString(2048).Format("kAscii=%lldLL",(long long)TApplicationRemote::kAscii).data(),0,(char*)NULL);
12378 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_TApplicationRemotecLcLESendFileOpt),-1,-2,1,G__FastAllocString(2048).Format("kBinary=%lldLL",(long long)TApplicationRemote::kBinary).data(),0,(char*)NULL);
12379 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_TApplicationRemotecLcLESendFileOpt),-1,-2,1,G__FastAllocString(2048).Format("kForce=%lldLL",(long long)TApplicationRemote::kForce).data(),0,(char*)NULL);
12380 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_TApplicationRemotecLcLEStatusBits),-1,-2,1,G__FastAllocString(2048).Format("kCollecting=%lldLL",(long long)TApplicationRemote::kCollecting).data(),0,(char*)NULL);
12381 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TString),-1,-1,4,"fName=",0,"Unique name identifying this instance");
12382 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fProtocol=",0,"server protocol version number");
12383 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TUrl),-1,-1,4,"fUrl=",0,"server's url");
12384 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TSocket),-1,-1,4,"fSocket=",0,"socket connection to server");
12385 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TMonitor),-1,-1,4,"fMonitor=",0,"monitor for the input socket");
12386 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fInterrupt=",0,"flag interrupt state");
12387 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TSignalHandler),-1,-1,4,"fIntHandler=",0,"interrupt signal handler (ctrl-c)");
12388 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TString),-1,-1,4,"fLogFilePath=",0,"Full remote path to log file");
12389 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_THashList),-1,-1,4,"fFileList=",0,"List of files already uploaded");
12390 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TObject),-1,-1,4,"fReceivedObject=",0,"last received object");
12391 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TSeqCollection),-1,-1,4,"fRootFiles=",0,"list of (remote) root files");
12392 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TRemoteObject),-1,-1,4,"fWorkingDir=",0,"working (remote) directory");
12393 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-2,4,"fgPortAttempts=",0,"number of attempts to find a port");
12394 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-2,4,"fgPortLower=",0,"lower bound for ports");
12395 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-2,4,"fgPortUpper=",0,"upper bound for ports");
12396 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
12397 }
12398 G__tag_memvar_reset();
12399 }
12400
12401
12402
12403 static void G__setup_memvarTApplicationServer(void) {
12404 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__NetLN_TApplicationServer));
12405 { TApplicationServer *p; p=(TApplicationServer*)0x1000; if (p) { }
12406 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fProtocol=",0,"user protocol version number");
12407 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TUrl),-1,-1,4,"fUrl=",0,"user's url");
12408 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TSocket),-1,-1,4,"fSocket=",0,"socket connection to user");
12409 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fIsValid=",0,"flag validity");
12410 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fInterrupt=",0,"flag interrupt state");
12411 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TString),-1,-1,4,"fLogFilePath=",0,"Path to log file");
12412 G__memvar_setup((void*)0,69,0,0,-1,-1,-1,4,"fLogFile=",0,"log file");
12413 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fLogFileDes=",0,"log file descriptor");
12414 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fRealTimeLog=",0,"TRUE if log messages should be send back in real-time");
12415 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TString),-1,-1,4,"fSessId=",0,"Identifier for this session");
12416 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TString),-1,-1,4,"fWorkDir=",0,"Working dir");
12417 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TList),-1,-1,4,"fSentCanvases=",0,"List of canvases already sent");
12418 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TRemoteObject),-1,-1,4,"fWorkingDir=",0,"Working (remote) directory");
12419 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
12420 }
12421 G__tag_memvar_reset();
12422 }
12423
12424
12425
12426 static void G__setup_memvarTFileStager(void) {
12427 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__NetLN_TFileStager));
12428 { TFileStager *p; p=(TFileStager*)0x1000; if (p) { }
12429 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
12430 }
12431 G__tag_memvar_reset();
12432 }
12433
12434
12435
12436 static void G__setup_memvarTServerSocket(void) {
12437 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__NetLN_TServerSocket));
12438 { TServerSocket *p; p=(TServerSocket*)0x1000; if (p) { }
12439 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TSeqCollection),-1,-1,4,"fSecContexts=",0,"List of TSecContext with cleanup info");
12440 G__memvar_setup((void*)0,89,0,0,-1,G__defined_typename("SrvAuth_t"),-2,4,"fgSrvAuthHook=",0,(char*)NULL);
12441 G__memvar_setup((void*)0,89,0,0,-1,G__defined_typename("SrvClup_t"),-2,4,"fgSrvAuthClupHook=",0,(char*)NULL);
12442 G__memvar_setup((void*)0,98,0,0,-1,G__defined_typename("UChar_t"),-2,4,"fgAcceptOpt=",0,"Default accept options");
12443 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_TServerSocketcLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kDefaultBacklog=%lldLL",(long long)TServerSocket::kDefaultBacklog).data(),0,(char*)NULL);
12444 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
12445 }
12446 G__tag_memvar_reset();
12447 }
12448
12449
12450
12451 static void G__setup_memvarTFTP(void) {
12452 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__NetLN_TFTP));
12453 { TFTP *p; p=(TFTP*)0x1000; if (p) { }
12454 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TString),-1,-1,4,"fHost=",0,"FQDN of remote host");
12455 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TString),-1,-1,4,"fUser=",0,"remote user");
12456 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fPort=",0,"port to which to connect");
12457 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fParallel=",0,"number of parallel sockets");
12458 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fWindowSize=",0,"tcp window size used");
12459 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fProtocol=",0,"rootd protocol level");
12460 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fLastBlock=",0,"last block successfully transfered");
12461 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fBlockSize=",0,"size of data buffer used to transfer");
12462 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fMode=",0,"binary or ascii file transfer mode");
12463 G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,4,"fRestartAt=",0,"restart transmission at specified offset");
12464 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TString),-1,-1,4,"fCurrentFile=",0,"file currently being get or put");
12465 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TSocket),-1,-1,4,"fSocket=",0,"! connection to rootd");
12466 G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,4,"fBytesWrite=",0,"number of bytes sent");
12467 G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,4,"fBytesRead=",0,"number of bytes received");
12468 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fDir=",0,"Indicates if a remote directory is open");
12469 G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-2,4,"fgBytesWrite=",0,"number of bytes sent by all TFTP objects");
12470 G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-2,4,"fgBytesRead=",0,"number of bytes received by all TFTP objects");
12471 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_TFTPcLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kDfltBlockSize=%lldLL",(long long)TFTP::kDfltBlockSize).data(),0,(char*)NULL);
12472 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_TFTPcLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kDfltWindowSize=%lldLL",(long long)TFTP::kDfltWindowSize).data(),0,(char*)NULL);
12473 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_TFTPcLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kBinary=%lldLL",(long long)TFTP::kBinary).data(),0,(char*)NULL);
12474 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_TFTPcLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kAscii=%lldLL",(long long)TFTP::kAscii).data(),0,(char*)NULL);
12475 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
12476 }
12477 G__tag_memvar_reset();
12478 }
12479
12480
12481
12482 static void G__setup_memvarTGridResult(void) {
12483 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__NetLN_TGridResult));
12484 { TGridResult *p; p=(TGridResult*)0x1000; if (p) { }
12485 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
12486 }
12487 G__tag_memvar_reset();
12488 }
12489
12490
12491
12492 static void G__setup_memvarTGridCollection(void) {
12493 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__NetLN_TGridCollection));
12494 { TGridCollection *p; p=(TGridCollection*)0x1000; if (p) { }
12495 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
12496 }
12497 G__tag_memvar_reset();
12498 }
12499
12500
12501
12502 static void G__setup_memvarTGridJobStatus(void) {
12503 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__NetLN_TGridJobStatus));
12504 { TGridJobStatus *p; p=(TGridJobStatus*)0x1000; if (p) { }
12505 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_TGridJobStatuscLcLEGridJobStatus),-1,-2,1,G__FastAllocString(2048).Format("kUNKNOWN=%lldLL",(long long)TGridJobStatus::kUNKNOWN).data(),0,(char*)NULL);
12506 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_TGridJobStatuscLcLEGridJobStatus),-1,-2,1,G__FastAllocString(2048).Format("kWAITING=%lldLL",(long long)TGridJobStatus::kWAITING).data(),0,(char*)NULL);
12507 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_TGridJobStatuscLcLEGridJobStatus),-1,-2,1,G__FastAllocString(2048).Format("kRUNNING=%lldLL",(long long)TGridJobStatus::kRUNNING).data(),0,(char*)NULL);
12508 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_TGridJobStatuscLcLEGridJobStatus),-1,-2,1,G__FastAllocString(2048).Format("kABORTED=%lldLL",(long long)TGridJobStatus::kABORTED).data(),0,(char*)NULL);
12509 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_TGridJobStatuscLcLEGridJobStatus),-1,-2,1,G__FastAllocString(2048).Format("kFAIL=%lldLL",(long long)TGridJobStatus::kFAIL).data(),0,(char*)NULL);
12510 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_TGridJobStatuscLcLEGridJobStatus),-1,-2,1,G__FastAllocString(2048).Format("kDONE=%lldLL",(long long)TGridJobStatus::kDONE).data(),0,(char*)NULL);
12511 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
12512 }
12513 G__tag_memvar_reset();
12514 }
12515
12516
12517
12518 static void G__setup_memvarTGridJob(void) {
12519 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__NetLN_TGridJob));
12520 { TGridJob *p; p=(TGridJob*)0x1000; if (p) { }
12521 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TString),-1,-1,2,"fJobID=",0,"the job's ID");
12522 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
12523 }
12524 G__tag_memvar_reset();
12525 }
12526
12527
12528
12529 static void G__setup_memvarTGridJDL(void) {
12530 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__NetLN_TGridJDL));
12531 { TGridJDL *p; p=(TGridJDL*)0x1000; if (p) { }
12532 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TMap),-1,-1,2,"fMap=",0,"stores the key, value pairs of the JDL");
12533 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TMap),-1,-1,2,"fDescriptionMap=",0,"stores the key, value pairs of the JDL");
12534 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
12535 }
12536 G__tag_memvar_reset();
12537 }
12538
12539
12540
12541 static void G__setup_memvarTGridJobStatusList(void) {
12542 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__NetLN_TGridJobStatusList));
12543 { TGridJobStatusList *p; p=(TGridJobStatusList*)0x1000; if (p) { }
12544 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TString),-1,-1,2,"fJobID=",0,"the job's ID");
12545 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
12546 }
12547 G__tag_memvar_reset();
12548 }
12549
12550
12551
12552 static void G__setup_memvarTGrid(void) {
12553 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__NetLN_TGrid));
12554 { TGrid *p; p=(TGrid*)0x1000; if (p) { }
12555 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TString),-1,-1,2,"fGridUrl=",0,"the GRID url used to create the grid connection");
12556 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TString),-1,-1,2,"fGrid=",0,"type of GRID (AliEn, Globus, ...)");
12557 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TString),-1,-1,2,"fHost=",0,"GRID portal to which we are connected");
12558 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TString),-1,-1,2,"fUser=",0,"user name");
12559 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TString),-1,-1,2,"fPw=",0,"user passwd");
12560 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TString),-1,-1,2,"fOptions=",0,"options specified");
12561 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fPort=",0,"port to which we are connected");
12562 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
12563 }
12564 G__tag_memvar_reset();
12565 }
12566
12567
12568
12569 static void G__setup_memvarTNetFile(void) {
12570 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__NetLN_TNetFile));
12571 { TNetFile *p; p=(TNetFile*)0x1000; if (p) { }
12572 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TUrl),-1,-1,2,"fEndpointUrl=",0,"URL of realfile (after possible redirection)");
12573 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TString),-1,-1,2,"fUser=",0,"remote user name");
12574 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TSocket),-1,-1,2,"fSocket=",0,"connection to rootd server");
12575 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fProtocol=",0,"rootd protocol level");
12576 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fErrorCode=",0,"error code returned by rootd (matching gRootdErrStr)");
12577 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNetopt=",0,"initial network options (used for ReOpen())");
12578 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
12579 }
12580 G__tag_memvar_reset();
12581 }
12582
12583
12584
12585 static void G__setup_memvarTNetSystem(void) {
12586 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__NetLN_TNetSystem));
12587 { TNetSystem *p; p=(TNetSystem*)0x1000; if (p) { }
12588 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fDir=",0,"true if a directory is open remotely");
12589 G__memvar_setup((void*)0,89,0,0,-1,-1,-1,4,"fDirp=",0,"directory handler");
12590 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TFTP),-1,-1,4,"fFTP=",0,"Connection to rootd");
12591 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TString),-1,-1,4,"fHost=",0,"Remote host");
12592 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fFTPOwner=",0,"True if owner of the FTP instance");
12593 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TString),-1,-1,4,"fUser=",0,"Remote user");
12594 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fPort=",0,"Remote port");
12595 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsLocal=",0,"TRUE if the path points to this host");
12596 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TString),-1,-1,2,"fLocalPrefix=",0,"if fIsLocal, prefix to be prepend locally");
12597 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
12598 }
12599 G__tag_memvar_reset();
12600 }
12601
12602
12603
12604 static void G__setup_memvarTSecContext(void) {
12605 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__NetLN_TSecContext));
12606 { TSecContext *p; p=(TSecContext*)0x1000; if (p) { }
12607 G__memvar_setup((void*)0,89,0,0,-1,-1,-1,4,"fContext=",0,"Krb5, Globus: ptr to specific sec context");
12608 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TList),-1,-1,4,"fCleanup=",0,"Points to list with info for remote cleanup");
12609 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TDatime),-1,-1,4,"fExpDate=",0,"Expiring date (one sec precision)");
12610 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TString),-1,-1,4,"fHost=",0,"Remote host name");
12611 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TString),-1,-1,4,"fID=",0,"String identifying uniquely this context");
12612 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fMethod=",0,"Authentication method used");
12613 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TString),-1,-1,4,"fMethodName=",0,"Authentication method name");
12614 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fOffSet=",0,"offset in remote host auth tab file (in bytes)");
12615 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TString),-1,-1,4,"fToken=",0,"Token identifying this authentication");
12616 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TString),-1,-1,4,"fUser=",0,"Remote login username");
12617 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
12618 }
12619 G__tag_memvar_reset();
12620 }
12621
12622
12623
12624 static void G__setup_memvarTSecContextCleanup(void) {
12625 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__NetLN_TSecContextCleanup));
12626 { TSecContextCleanup *p; p=(TSecContextCleanup*)0x1000; if (p) { }
12627 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fPort=",0,(char*)NULL);
12628 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fServerProtocol=",0,(char*)NULL);
12629 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fServerType=",0,"0 = sockd, 1 = rootd, 2 = proofd");
12630 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
12631 }
12632 G__tag_memvar_reset();
12633 }
12634
12635
12636
12637 static void G__setup_memvarTPServerSocket(void) {
12638 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__NetLN_TPServerSocket));
12639 { TPServerSocket *p; p=(TPServerSocket*)0x1000; if (p) { }
12640 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fTcpWindowSize=",0,"size of tcp window (for window scaling)");
12641 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
12642 }
12643 G__tag_memvar_reset();
12644 }
12645
12646
12647
12648 static void G__setup_memvarTSQLColumnInfo(void) {
12649 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__NetLN_TSQLColumnInfo));
12650 { TSQLColumnInfo *p; p=(TSQLColumnInfo*)0x1000; if (p) { }
12651 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TString),-1,-1,2,"fTypeName=",0,"! sql type name, as reported by DB. Should be as much as close to declaration of column in CREATE TABLE query");
12652 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fSQLType=",0,"! datatype code (see TSQLServer::ESQLDataTypes constants), -1 if not defeined");
12653 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fSize=",0,"! size of column in bytes, -1 if not defing");
12654 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fLength=",0,"! datatype length definition, for instance VARCHAR(len) or FLOAT(len), -1 if not defined");
12655 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fScale=",0,"! datatype scale factor, used for instance in NUMBER(len,scale) definition. -1 if not defined");
12656 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fSigned=",0,"! if datatype signed or not, 0 - kFALSE, 1 - kTRUE, -1 - unknown");
12657 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fNullable=",0,"! identify if value can be NULL ");
12658 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
12659 }
12660 G__tag_memvar_reset();
12661 }
12662
12663
12664
12665 static void G__setup_memvarTSQLServer(void) {
12666 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__NetLN_TSQLServer));
12667 { TSQLServer *p; p=(TSQLServer*)0x1000; if (p) { }
12668 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TString),-1,-1,2,"fType=",0,"type of DBMS (MySQL, Oracle, SysBase, ...)");
12669 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TString),-1,-1,2,"fHost=",0,"host to which we are connected");
12670 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TString),-1,-1,2,"fDB=",0,"currently selected DB");
12671 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fPort=",0,"port to which we are connected");
12672 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fErrorCode=",0,"error code of last operation");
12673 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TString),-1,-1,2,"fErrorMsg=",0,"error message of last operation");
12674 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fErrorOut=",0,"enable error output");
12675 G__memvar_setup((void*)0,67,0,1,-1,-1,-2,2,"fgFloatFmt=",0,"! printf argument for floats and doubles, either \"%f\" or \"%e\" or \"%10f\" and so on");
12676 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_TSQLServercLcLESQLDataTypes),-1,-2,1,G__FastAllocString(2048).Format("kSQL_NONE=%lldLL",(long long)TSQLServer::kSQL_NONE).data(),0,(char*)NULL);
12677 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_TSQLServercLcLESQLDataTypes),-1,-2,1,G__FastAllocString(2048).Format("kSQL_CHAR=%lldLL",(long long)TSQLServer::kSQL_CHAR).data(),0,(char*)NULL);
12678 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_TSQLServercLcLESQLDataTypes),-1,-2,1,G__FastAllocString(2048).Format("kSQL_VARCHAR=%lldLL",(long long)TSQLServer::kSQL_VARCHAR).data(),0,(char*)NULL);
12679 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_TSQLServercLcLESQLDataTypes),-1,-2,1,G__FastAllocString(2048).Format("kSQL_INTEGER=%lldLL",(long long)TSQLServer::kSQL_INTEGER).data(),0,(char*)NULL);
12680 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_TSQLServercLcLESQLDataTypes),-1,-2,1,G__FastAllocString(2048).Format("kSQL_FLOAT=%lldLL",(long long)TSQLServer::kSQL_FLOAT).data(),0,(char*)NULL);
12681 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_TSQLServercLcLESQLDataTypes),-1,-2,1,G__FastAllocString(2048).Format("kSQL_DOUBLE=%lldLL",(long long)TSQLServer::kSQL_DOUBLE).data(),0,(char*)NULL);
12682 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_TSQLServercLcLESQLDataTypes),-1,-2,1,G__FastAllocString(2048).Format("kSQL_NUMERIC=%lldLL",(long long)TSQLServer::kSQL_NUMERIC).data(),0,(char*)NULL);
12683 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_TSQLServercLcLESQLDataTypes),-1,-2,1,G__FastAllocString(2048).Format("kSQL_BINARY=%lldLL",(long long)TSQLServer::kSQL_BINARY).data(),0,(char*)NULL);
12684 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_TSQLServercLcLESQLDataTypes),-1,-2,1,G__FastAllocString(2048).Format("kSQL_TIMESTAMP=%lldLL",(long long)TSQLServer::kSQL_TIMESTAMP).data(),0,(char*)NULL);
12685 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
12686 }
12687 G__tag_memvar_reset();
12688 }
12689
12690
12691
12692 static void G__setup_memvarTSQLMonitoringWriter(void) {
12693 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__NetLN_TSQLMonitoringWriter));
12694 { TSQLMonitoringWriter *p; p=(TSQLMonitoringWriter*)0x1000; if (p) { }
12695 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TSQLServer),-1,-1,4,"fDB=",0,"SQL database where to write");
12696 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TString),-1,-1,4,"fTable=",0,"SQL table name");
12697 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
12698 }
12699 G__tag_memvar_reset();
12700 }
12701
12702
12703
12704 static void G__setup_memvarTSQLRow(void) {
12705 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__NetLN_TSQLRow));
12706 { TSQLRow *p; p=(TSQLRow*)0x1000; if (p) { }
12707 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
12708 }
12709 G__tag_memvar_reset();
12710 }
12711
12712
12713
12714 static void G__setup_memvarTSQLResult(void) {
12715 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__NetLN_TSQLResult));
12716 { TSQLResult *p; p=(TSQLResult*)0x1000; if (p) { }
12717 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fRowCount=",0,"number of rows in result");
12718 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
12719 }
12720 G__tag_memvar_reset();
12721 }
12722
12723
12724
12725 static void G__setup_memvarTSQLStatement(void) {
12726 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__NetLN_TSQLStatement));
12727 { TSQLStatement *p; p=(TSQLStatement*)0x1000; if (p) { }
12728 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fErrorCode=",0,"error code of last operation");
12729 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TString),-1,-1,2,"fErrorMsg=",0,"error message of last operation");
12730 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fErrorOut=",0,"enable error output ");
12731 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
12732 }
12733 G__tag_memvar_reset();
12734 }
12735
12736
12737
12738 static void G__setup_memvarTSQLTableInfo(void) {
12739 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__NetLN_TSQLTableInfo));
12740 { TSQLTableInfo *p; p=(TSQLTableInfo*)0x1000; if (p) { }
12741 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TList),-1,-1,2,"fColumns=",0,"! list of TSQLColumnInfo objects, describing each table column");
12742 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TString),-1,-1,2,"fEngine=",0,"! SQL tables engine name");
12743 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TString),-1,-1,2,"fCreateTime=",0,"! table creation time ");
12744 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TString),-1,-1,2,"fUpdateTime=",0,"! table update time");
12745 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
12746 }
12747 G__tag_memvar_reset();
12748 }
12749
12750
12751
12752 static void G__setup_memvarTWebFile(void) {
12753 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__NetLN_TWebFile));
12754 { TWebFile *p; p=(TWebFile*)0x1000; if (p) { }
12755 G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,4,"fSize=",0,"file size");
12756 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TSocket),-1,-1,4,"fSocket=",0,"socket for HTTP/1.1 (stays alive between calls)");
12757 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TUrl),-1,-1,4,"fProxy=",0,"proxy URL");
12758 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fHasModRoot=",0,"true if server has mod_root installed");
12759 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fHTTP11=",0,"true if server support HTTP/1.1");
12760 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fNoProxy=",0,"don't use proxy");
12761 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TString),-1,-1,4,"fMsgReadBuffer=",0,"cache ReadBuffer() msg");
12762 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TString),-1,-1,4,"fMsgReadBuffer10=",0,"cache ReadBuffer10() msg");
12763 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TString),-1,-1,4,"fMsgGetHead=",0,"cache GetHead() msg");
12764 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TString),-1,-1,4,"fBasicUrl=",0,"basic url without authentication and options");
12765 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TUrl),-1,-1,4,"fUrlOrg=",0,"save original url in case of temp redirection");
12766 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TString),-1,-1,4,"fBasicUrlOrg=",0,"save original url in case of temp redirection");
12767 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__NetLN_TUrl),-1,-2,4,"fgProxy=",0,"globally set proxy URL");
12768 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
12769 }
12770 G__tag_memvar_reset();
12771 }
12772
12773
12774
12775 static void G__setup_memvarTWebSystem(void) {
12776 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__NetLN_TWebSystem));
12777 { TWebSystem *p; p=(TWebSystem*)0x1000; if (p) { }
12778 G__memvar_setup((void*)0,89,0,0,-1,-1,-1,4,"fDirp=",0,"directory handler");
12779 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__NetLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
12780 }
12781 G__tag_memvar_reset();
12782 }
12783
12784 extern "C" void G__cpp_setup_memvarG__Net() {
12785 }
12786
12787
12788
12789
12790
12791
12792
12793
12794
12795
12796
12797
12798 static void G__setup_memfuncTMessage(void) {
12799
12800 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__NetLN_TMessage));
12801 G__memfunc_setup("TMessage",793,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__NetLN_TMessage), -1, 0, 1, 1, 4, 0, "u 'TMessage' - 11 - -", "not implemented", (void*) NULL, 0);
12802 G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "u 'TMessage' - 11 - -", "not implemented", (void*) NULL, 0);
12803 G__memfunc_setup("TestBitNumber",1320,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 4, 8, "h - 'UInt_t' 0 - bitnumber", (char*)NULL, (void*) NULL, 0);
12804 G__memfunc_setup("TMessage",793,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__NetLN_TMessage), -1, 0, 2, 1, 2, 0,
12805 "Y - - 0 - buf i - 'Int_t' 0 - bufsize", "only called by T(P)Socket::Recv()", (void*) NULL, 0);
12806 G__memfunc_setup("SetLength",910,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 8, "", "only called by T(P)Socket::Send()", (void*) NULL, 0);
12807 G__memfunc_setup("TMessage",793,G__G__Net_150_0_6, 105, G__get_linked_tagnum(&G__G__NetLN_TMessage), -1, 0, 2, 1, 1, 0,
12808 "h - 'UInt_t' 0 'kMESS_ANY' what i - 'Int_t' 0 'TBuffer::kInitialSize' bufsiz", (char*)NULL, (void*) NULL, 0);
12809 G__memfunc_setup("ForceWriteInfo",1414,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0,
12810 "U 'TVirtualStreamerInfo' - 0 - info g - 'Bool_t' 0 - force", (char*)NULL, (void*) NULL, 1);
12811 G__memfunc_setup("Forward",725,G__G__Net_150_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
12812 G__memfunc_setup("GetClass",790,G__G__Net_150_0_9, 85, G__get_linked_tagnum(&G__G__NetLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
12813 G__memfunc_setup("TagStreamerInfo",1515,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TVirtualStreamerInfo' - 0 - info", (char*)NULL, (void*) NULL, 1);
12814 G__memfunc_setup("Reset",515,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
12815 G__memfunc_setup("Reset",515,G__G__Net_150_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - what", (char*)NULL, (void*) NULL, 0);
12816 G__memfunc_setup("What",404,G__G__Net_150_0_13, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
12817 G__memfunc_setup("SetWhat",704,G__G__Net_150_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - what", (char*)NULL, (void*) NULL, 0);
12818 G__memfunc_setup("EnableSchemaEvolution",2141,G__G__Net_150_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' enable", (char*)NULL, (void*) NULL, 0);
12819 G__memfunc_setup("UsesSchemaEvolution",1974,G__G__Net_150_0_16, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
12820 G__memfunc_setup("SetCompressionLevel",1974,G__G__Net_150_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '1' level", (char*)NULL, (void*) NULL, 0);
12821 G__memfunc_setup("GetCompressionLevel",1962,G__G__Net_150_0_18, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
12822 G__memfunc_setup("Compress",844,G__G__Net_150_0_19, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
12823 G__memfunc_setup("Uncompress",1071,G__G__Net_150_0_20, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
12824 G__memfunc_setup("CompBuffer",1001,G__G__Net_150_0_21, 67, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
12825 G__memfunc_setup("CompLength",1009,G__G__Net_150_0_22, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
12826 G__memfunc_setup("WriteObject",1122,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 10 - obj", (char*)NULL, (void*) NULL, 1);
12827 G__memfunc_setup("WriteProcessID",1399,(G__InterfaceMethod) NULL,114, -1, G__defined_typename("UShort_t"), 0, 1, 1, 1, 0, "U 'TProcessID' - 0 - pid", (char*)NULL, (void*) NULL, 1);
12828 G__memfunc_setup("EnableSchemaEvolutionForAll",2717,G__G__Net_150_0_25, 121, -1, -1, 0, 1, 3, 1, 0, "g - 'Bool_t' 0 'kTRUE' enable", (char*)NULL, (void*) G__func2void( (void (*)(Bool_t))(&TMessage::EnableSchemaEvolutionForAll) ), 0);
12829 G__memfunc_setup("UsesSchemaEvolutionForAll",2550,G__G__Net_150_0_26, 103, -1, G__defined_typename("Bool_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Bool_t (*)())(&TMessage::UsesSchemaEvolutionForAll) ), 0);
12830 G__memfunc_setup("Class",502,G__G__Net_150_0_27, 85, G__get_linked_tagnum(&G__G__NetLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMessage::Class) ), 0);
12831 G__memfunc_setup("Class_Name",982,G__G__Net_150_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMessage::Class_Name) ), 0);
12832 G__memfunc_setup("Class_Version",1339,G__G__Net_150_0_29, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMessage::Class_Version) ), 0);
12833 G__memfunc_setup("Dictionary",1046,G__G__Net_150_0_30, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMessage::Dictionary) ), 0);
12834 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__NetLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
12835 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
12836 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
12837 G__memfunc_setup("StreamerNVirtual",1656,G__G__Net_150_0_34, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
12838 G__memfunc_setup("DeclFileName",1145,G__G__Net_150_0_35, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMessage::DeclFileName) ), 0);
12839 G__memfunc_setup("ImplFileLine",1178,G__G__Net_150_0_36, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMessage::ImplFileLine) ), 0);
12840 G__memfunc_setup("ImplFileName",1171,G__G__Net_150_0_37, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMessage::ImplFileName) ), 0);
12841 G__memfunc_setup("DeclFileLine",1152,G__G__Net_150_0_38, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMessage::DeclFileLine) ), 0);
12842
12843 G__memfunc_setup("~TMessage", 919, G__G__Net_150_0_39, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
12844 G__tag_memfunc_reset();
12845 }
12846
12847 static void G__setup_memfuncTSocket(void) {
12848
12849 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__NetLN_TSocket));
12850 G__memfunc_setup("TSocket",701,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__NetLN_TSocket), -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
12851 G__memfunc_setup("Authenticate",1247,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 2, 0, "C - - 10 - user", (char*)NULL, (void*) NULL, 0);
12852 G__memfunc_setup("SetDescriptor",1355,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "i - 'Int_t' 0 - desc", (char*)NULL, (void*) NULL, 0);
12853 G__memfunc_setup("SendStreamerInfos",1740,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "u 'TMessage' - 11 - mess", (char*)NULL, (void*) NULL, 0);
12854 G__memfunc_setup("RecvStreamerInfos",1746,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 2, 0, "U 'TMessage' - 0 - mess", (char*)NULL, (void*) NULL, 0);
12855 G__memfunc_setup("SendProcessIDs",1385,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "u 'TMessage' - 11 - mess", (char*)NULL, (void*) NULL, 0);
12856 G__memfunc_setup("RecvProcessIDs",1391,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 2, 0, "U 'TMessage' - 0 - mess", (char*)NULL, (void*) NULL, 0);
12857 G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__NetLN_TSocket), -1, 1, 1, 1, 4, 0, "u 'TSocket' - 11 - -", "not implemented", (void*) NULL, 0);
12858 G__memfunc_setup("GetOption",921,(G__InterfaceMethod) NULL, 67, -1, G__defined_typename("Option_t"), 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 1);
12859 G__memfunc_setup("TSocket",701,G__G__Net_152_0_10, 105, G__get_linked_tagnum(&G__G__NetLN_TSocket), -1, 0, 3, 1, 1, 0,
12860 "u 'TInetAddress' - 0 - address C - - 10 - service "
12861 "i - 'Int_t' 0 '-1' tcpwindowsize", (char*)NULL, (void*) NULL, 0);
12862 G__memfunc_setup("TSocket",701,G__G__Net_152_0_11, 105, G__get_linked_tagnum(&G__G__NetLN_TSocket), -1, 0, 3, 1, 1, 0,
12863 "u 'TInetAddress' - 0 - address i - 'Int_t' 0 - port "
12864 "i - 'Int_t' 0 '-1' tcpwindowsize", (char*)NULL, (void*) NULL, 0);
12865 G__memfunc_setup("TSocket",701,G__G__Net_152_0_12, 105, G__get_linked_tagnum(&G__G__NetLN_TSocket), -1, 0, 3, 1, 1, 0,
12866 "C - - 10 - host C - - 10 - service "
12867 "i - 'Int_t' 0 '-1' tcpwindowsize", (char*)NULL, (void*) NULL, 0);
12868 G__memfunc_setup("TSocket",701,G__G__Net_152_0_13, 105, G__get_linked_tagnum(&G__G__NetLN_TSocket), -1, 0, 3, 1, 1, 0,
12869 "C - - 10 - host i - 'Int_t' 0 - port "
12870 "i - 'Int_t' 0 '-1' tcpwindowsize", (char*)NULL, (void*) NULL, 0);
12871 G__memfunc_setup("TSocket",701,G__G__Net_152_0_14, 105, G__get_linked_tagnum(&G__G__NetLN_TSocket), -1, 0, 1, 1, 1, 0, "C - - 10 - sockpath", (char*)NULL, (void*) NULL, 0);
12872 G__memfunc_setup("TSocket",701,G__G__Net_152_0_15, 105, G__get_linked_tagnum(&G__G__NetLN_TSocket), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - descriptor", (char*)NULL, (void*) NULL, 0);
12873 G__memfunc_setup("TSocket",701,G__G__Net_152_0_16, 105, G__get_linked_tagnum(&G__G__NetLN_TSocket), -1, 0, 2, 1, 1, 0,
12874 "i - 'Int_t' 0 - descriptor C - - 10 - sockpath", (char*)NULL, (void*) NULL, 0);
12875 G__memfunc_setup("TSocket",701,G__G__Net_152_0_17, 105, G__get_linked_tagnum(&G__G__NetLN_TSocket), -1, 0, 1, 1, 1, 0, "u 'TSocket' - 11 - s", (char*)NULL, (void*) NULL, 0);
12876 G__memfunc_setup("Close",502,G__G__Net_152_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' opt", (char*)NULL, (void*) NULL, 1);
12877 G__memfunc_setup("GetDescriptor",1343,G__G__Net_152_0_19, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
12878 G__memfunc_setup("GetInetAddress",1398,G__G__Net_152_0_20, 117, G__get_linked_tagnum(&G__G__NetLN_TInetAddress), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
12879 G__memfunc_setup("GetLocalInetAddress",1889,G__G__Net_152_0_21, 117, G__get_linked_tagnum(&G__G__NetLN_TInetAddress), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
12880 G__memfunc_setup("GetPort",709,G__G__Net_152_0_22, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
12881 G__memfunc_setup("GetService",1009,G__G__Net_152_0_23, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
12882 G__memfunc_setup("GetServType",1122,G__G__Net_152_0_24, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
12883 G__memfunc_setup("GetLocalPort",1200,G__G__Net_152_0_25, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
12884 G__memfunc_setup("GetBytesSent",1217,G__G__Net_152_0_26, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
12885 G__memfunc_setup("GetBytesRecv",1207,G__G__Net_152_0_27, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
12886 G__memfunc_setup("GetCompressionLevel",1962,G__G__Net_152_0_28, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
12887 G__memfunc_setup("GetErrorCode",1189,G__G__Net_152_0_29, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
12888 G__memfunc_setup("GetOption",921,G__G__Net_152_0_30, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0,
12889 "i 'ESockOptions' - 0 - opt i - 'Int_t' 1 - val", (char*)NULL, (void*) NULL, 1);
12890 G__memfunc_setup("GetRemoteProtocol",1758,G__G__Net_152_0_31, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
12891 G__memfunc_setup("GetSecContext",1312,G__G__Net_152_0_32, 85, G__get_linked_tagnum(&G__G__NetLN_TSecContext), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
12892 G__memfunc_setup("GetTcpWindowSize",1626,G__G__Net_152_0_33, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
12893 G__memfunc_setup("GetLastUsage",1193,G__G__Net_152_0_34, 117, G__get_linked_tagnum(&G__G__NetLN_TTimeStamp), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
12894 G__memfunc_setup("GetUrl",595,G__G__Net_152_0_35, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
12895 G__memfunc_setup("IsAuthenticated",1535,G__G__Net_152_0_36, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
12896 G__memfunc_setup("IsValid",684,G__G__Net_152_0_37, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
12897 G__memfunc_setup("Recv",400,G__G__Net_152_0_38, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "U 'TMessage' - 1 - mess", (char*)NULL, (void*) NULL, 1);
12898 G__memfunc_setup("Recv",400,G__G__Net_152_0_39, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0,
12899 "i - 'Int_t' 1 - status i - 'Int_t' 1 - kind", (char*)NULL, (void*) NULL, 1);
12900 G__memfunc_setup("Recv",400,G__G__Net_152_0_40, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0,
12901 "C - - 0 - mess i - 'Int_t' 0 - max", (char*)NULL, (void*) NULL, 1);
12902 G__memfunc_setup("Recv",400,G__G__Net_152_0_41, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0,
12903 "C - - 0 - mess i - 'Int_t' 0 - max "
12904 "i - 'Int_t' 1 - kind", (char*)NULL, (void*) NULL, 1);
12905 G__memfunc_setup("RecvRaw",698,G__G__Net_152_0_42, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0,
12906 "Y - - 0 - buffer i - 'Int_t' 0 - length "
12907 "i 'ESendRecvOptions' - 0 'kDefault' opt", (char*)NULL, (void*) NULL, 1);
12908 G__memfunc_setup("Reconnect",929,G__G__Net_152_0_43, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
12909 G__memfunc_setup("Select",608,G__G__Net_152_0_44, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0,
12910 "i - 'Int_t' 0 'kRead' interest l - 'Long_t' 0 '-1' timeout", (char*)NULL, (void*) NULL, 1);
12911 G__memfunc_setup("Send",394,G__G__Net_152_0_45, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "u 'TMessage' - 11 - mess", (char*)NULL, (void*) NULL, 1);
12912 G__memfunc_setup("Send",394,G__G__Net_152_0_46, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - kind", (char*)NULL, (void*) NULL, 1);
12913 G__memfunc_setup("Send",394,G__G__Net_152_0_47, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0,
12914 "i - 'Int_t' 0 - status i - 'Int_t' 0 - kind", (char*)NULL, (void*) NULL, 1);
12915 G__memfunc_setup("Send",394,G__G__Net_152_0_48, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0,
12916 "C - - 10 - mess i - 'Int_t' 0 'kMESS_STRING' kind", (char*)NULL, (void*) NULL, 1);
12917 G__memfunc_setup("SendObject",993,G__G__Net_152_0_49, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0,
12918 "U 'TObject' - 10 - obj i - 'Int_t' 0 'kMESS_OBJECT' kind", (char*)NULL, (void*) NULL, 1);
12919 G__memfunc_setup("SendRaw",692,G__G__Net_152_0_50, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0,
12920 "Y - - 10 - buffer i - 'Int_t' 0 - length "
12921 "i 'ESendRecvOptions' - 0 'kDefault' opt", (char*)NULL, (void*) NULL, 1);
12922 G__memfunc_setup("SetCompressionLevel",1974,G__G__Net_152_0_51, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '1' level", (char*)NULL, (void*) NULL, 0);
12923 G__memfunc_setup("SetOption",933,G__G__Net_152_0_52, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0,
12924 "i 'ESockOptions' - 0 - opt i - 'Int_t' 0 - val", (char*)NULL, (void*) NULL, 1);
12925 G__memfunc_setup("SetRemoteProtocol",1770,G__G__Net_152_0_53, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - rproto", (char*)NULL, (void*) NULL, 0);
12926 G__memfunc_setup("SetSecContext",1324,G__G__Net_152_0_54, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TSecContext' - 0 - ctx", (char*)NULL, (void*) NULL, 0);
12927 G__memfunc_setup("SetService",1021,G__G__Net_152_0_55, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - service", (char*)NULL, (void*) NULL, 0);
12928 G__memfunc_setup("SetServType",1134,G__G__Net_152_0_56, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - st", (char*)NULL, (void*) NULL, 0);
12929 G__memfunc_setup("SetUrl",607,G__G__Net_152_0_57, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - url", (char*)NULL, (void*) NULL, 0);
12930 G__memfunc_setup("Touch",515,G__G__Net_152_0_58, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
12931 G__memfunc_setup("GetClientProtocol",1745,G__G__Net_152_0_59, 105, -1, G__defined_typename("Int_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Int_t (*)())(&TSocket::GetClientProtocol) ), 0);
12932 G__memfunc_setup("GetSocketBytesSent",1834,G__G__Net_152_0_60, 109, -1, G__defined_typename("ULong64_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (ULong64_t (*)())(&TSocket::GetSocketBytesSent) ), 0);
12933 G__memfunc_setup("GetSocketBytesRecv",1824,G__G__Net_152_0_61, 109, -1, G__defined_typename("ULong64_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (ULong64_t (*)())(&TSocket::GetSocketBytesRecv) ), 0);
12934 G__memfunc_setup("CreateAuthSocket",1615,G__G__Net_152_0_62, 85, G__get_linked_tagnum(&G__G__NetLN_TSocket), -1, 0, 6, 3, 1, 0,
12935 "C - - 10 - user C - - 10 - host "
12936 "i - 'Int_t' 0 - port i - 'Int_t' 0 '0' size "
12937 "i - 'Int_t' 0 '-1' tcpwindowsize U 'TSocket' - 0 '0' s", (char*)NULL, (void*) G__func2void( (TSocket* (*)(const char*, const char*, Int_t, Int_t, Int_t, TSocket*))(&TSocket::CreateAuthSocket) ), 0);
12938 G__memfunc_setup("CreateAuthSocket",1615,G__G__Net_152_0_63, 85, G__get_linked_tagnum(&G__G__NetLN_TSocket), -1, 0, 4, 3, 1, 0,
12939 "C - - 10 - url i - 'Int_t' 0 '0' size "
12940 "i - 'Int_t' 0 '-1' tcpwindowsize U 'TSocket' - 0 '0' s", (char*)NULL, (void*) G__func2void( (TSocket* (*)(const char*, Int_t, Int_t, TSocket*))(&TSocket::CreateAuthSocket) ), 0);
12941 G__memfunc_setup("NetError",817,G__G__Net_152_0_64, 121, -1, -1, 0, 2, 3, 1, 0,
12942 "C - - 10 - where i - 'Int_t' 0 - error", (char*)NULL, (void*) G__func2void( (void (*)(const char*, Int_t))(&TSocket::NetError) ), 0);
12943 G__memfunc_setup("Class",502,G__G__Net_152_0_65, 85, G__get_linked_tagnum(&G__G__NetLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TSocket::Class) ), 0);
12944 G__memfunc_setup("Class_Name",982,G__G__Net_152_0_66, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSocket::Class_Name) ), 0);
12945 G__memfunc_setup("Class_Version",1339,G__G__Net_152_0_67, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TSocket::Class_Version) ), 0);
12946 G__memfunc_setup("Dictionary",1046,G__G__Net_152_0_68, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TSocket::Dictionary) ), 0);
12947 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__NetLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
12948 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
12949 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
12950 G__memfunc_setup("StreamerNVirtual",1656,G__G__Net_152_0_72, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
12951 G__memfunc_setup("DeclFileName",1145,G__G__Net_152_0_73, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSocket::DeclFileName) ), 0);
12952 G__memfunc_setup("ImplFileLine",1178,G__G__Net_152_0_74, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TSocket::ImplFileLine) ), 0);
12953 G__memfunc_setup("ImplFileName",1171,G__G__Net_152_0_75, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSocket::ImplFileName) ), 0);
12954 G__memfunc_setup("DeclFileLine",1152,G__G__Net_152_0_76, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TSocket::DeclFileLine) ), 0);
12955
12956 G__memfunc_setup("~TSocket", 827, G__G__Net_152_0_77, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
12957 G__tag_memfunc_reset();
12958 }
12959
12960 static void G__setup_memfuncTPSocket(void) {
12961
12962 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__NetLN_TPSocket));
12963 G__memfunc_setup("TPSocket",781,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__NetLN_TPSocket), -1, 0, 2, 1, 4, 0,
12964 "U 'TSocket' - 2 - pSockets i - 'Int_t' 0 - size", (char*)NULL, (void*) NULL, 0);
12965 G__memfunc_setup("TPSocket",781,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__NetLN_TPSocket), -1, 0, 1, 1, 4, 0, "u 'TPSocket' - 11 - -", "not implemented", (void*) NULL, 0);
12966 G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "u 'TPSocket' - 11 - -", "idem", (void*) NULL, 0);
12967 G__memfunc_setup("Init",404,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 0,
12968 "i - 'Int_t' 0 - tcpwindowsize U 'TSocket' - 0 '0' sock", (char*)NULL, (void*) NULL, 0);
12969 G__memfunc_setup("GetOption",921,(G__InterfaceMethod) NULL, 67, -1, G__defined_typename("Option_t"), 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 1);
12970 G__memfunc_setup("TPSocket",781,G__G__Net_153_0_6, 105, G__get_linked_tagnum(&G__G__NetLN_TPSocket), -1, 0, 4, 1, 1, 0,
12971 "u 'TInetAddress' - 0 - address C - - 10 - service "
12972 "i - 'Int_t' 0 - size i - 'Int_t' 0 '-1' tcpwindowsize", (char*)NULL, (void*) NULL, 0);
12973 G__memfunc_setup("TPSocket",781,G__G__Net_153_0_7, 105, G__get_linked_tagnum(&G__G__NetLN_TPSocket), -1, 0, 4, 1, 1, 0,
12974 "u 'TInetAddress' - 0 - address i - 'Int_t' 0 - port "
12975 "i - 'Int_t' 0 - size i - 'Int_t' 0 '-1' tcpwindowsize", (char*)NULL, (void*) NULL, 0);
12976 G__memfunc_setup("TPSocket",781,G__G__Net_153_0_8, 105, G__get_linked_tagnum(&G__G__NetLN_TPSocket), -1, 0, 4, 1, 1, 0,
12977 "C - - 10 - host C - - 10 - service "
12978 "i - 'Int_t' 0 - size i - 'Int_t' 0 '-1' tcpwindowsize", (char*)NULL, (void*) NULL, 0);
12979 G__memfunc_setup("TPSocket",781,G__G__Net_153_0_9, 105, G__get_linked_tagnum(&G__G__NetLN_TPSocket), -1, 0, 4, 1, 1, 0,
12980 "C - - 10 - host i - 'Int_t' 0 - port "
12981 "i - 'Int_t' 0 - size i - 'Int_t' 0 '-1' tcpwindowsize", (char*)NULL, (void*) NULL, 0);
12982 G__memfunc_setup("TPSocket",781,G__G__Net_153_0_10, 105, G__get_linked_tagnum(&G__G__NetLN_TPSocket), -1, 0, 4, 1, 1, 0,
12983 "C - - 10 - host i - 'Int_t' 0 - port "
12984 "i - 'Int_t' 0 - size U 'TSocket' - 0 - sock", (char*)NULL, (void*) NULL, 0);
12985 G__memfunc_setup("Close",502,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' opt", (char*)NULL, (void*) NULL, 1);
12986 G__memfunc_setup("GetDescriptor",1343,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
12987 G__memfunc_setup("GetLocalInetAddress",1889,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__NetLN_TInetAddress), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
12988 G__memfunc_setup("Send",394,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "u 'TMessage' - 11 - mess", (char*)NULL, (void*) NULL, 1);
12989 G__memfunc_setup("Send",394,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - kind", (char*)NULL, (void*) NULL, 1);
12990 G__memfunc_setup("Send",394,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0,
12991 "i - 'Int_t' 0 - status i - 'Int_t' 0 - kind", (char*)NULL, (void*) NULL, 1);
12992 G__memfunc_setup("Send",394,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0,
12993 "C - - 10 - mess i - 'Int_t' 0 'kMESS_STRING' kind", (char*)NULL, (void*) NULL, 1);
12994 G__memfunc_setup("SendRaw",692,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0,
12995 "Y - - 10 - buffer i - 'Int_t' 0 - length "
12996 "i 'ESendRecvOptions' - 0 - opt", (char*)NULL, (void*) NULL, 1);
12997 G__memfunc_setup("Recv",400,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "U 'TMessage' - 1 - mess", (char*)NULL, (void*) NULL, 1);
12998 G__memfunc_setup("Recv",400,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0,
12999 "i - 'Int_t' 1 - status i - 'Int_t' 1 - kind", (char*)NULL, (void*) NULL, 1);
13000 G__memfunc_setup("Recv",400,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0,
13001 "C - - 0 - mess i - 'Int_t' 0 - max", (char*)NULL, (void*) NULL, 1);
13002 G__memfunc_setup("Recv",400,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0,
13003 "C - - 0 - mess i - 'Int_t' 0 - max "
13004 "i - 'Int_t' 1 - kind", (char*)NULL, (void*) NULL, 1);
13005 G__memfunc_setup("RecvRaw",698,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0,
13006 "Y - - 0 - buffer i - 'Int_t' 0 - length "
13007 "i 'ESendRecvOptions' - 0 - opt", (char*)NULL, (void*) NULL, 1);
13008 G__memfunc_setup("IsValid",684,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
13009 G__memfunc_setup("GetErrorCode",1189,G__G__Net_153_0_25, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
13010 G__memfunc_setup("SetOption",933,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0,
13011 "i 'ESockOptions' - 0 - opt i - 'Int_t' 0 - val", (char*)NULL, (void*) NULL, 1);
13012 G__memfunc_setup("GetOption",921,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0,
13013 "i 'ESockOptions' - 0 - opt i - 'Int_t' 1 - val", (char*)NULL, (void*) NULL, 1);
13014 G__memfunc_setup("GetSize",699,G__G__Net_153_0_28, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
13015 G__memfunc_setup("Class",502,G__G__Net_153_0_29, 85, G__get_linked_tagnum(&G__G__NetLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TPSocket::Class) ), 0);
13016 G__memfunc_setup("Class_Name",982,G__G__Net_153_0_30, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPSocket::Class_Name) ), 0);
13017 G__memfunc_setup("Class_Version",1339,G__G__Net_153_0_31, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TPSocket::Class_Version) ), 0);
13018 G__memfunc_setup("Dictionary",1046,G__G__Net_153_0_32, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TPSocket::Dictionary) ), 0);
13019 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__NetLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
13020 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
13021 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
13022 G__memfunc_setup("StreamerNVirtual",1656,G__G__Net_153_0_36, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
13023 G__memfunc_setup("DeclFileName",1145,G__G__Net_153_0_37, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPSocket::DeclFileName) ), 0);
13024 G__memfunc_setup("ImplFileLine",1178,G__G__Net_153_0_38, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPSocket::ImplFileLine) ), 0);
13025 G__memfunc_setup("ImplFileName",1171,G__G__Net_153_0_39, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPSocket::ImplFileName) ), 0);
13026 G__memfunc_setup("DeclFileLine",1152,G__G__Net_153_0_40, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPSocket::DeclFileLine) ), 0);
13027
13028 G__memfunc_setup("~TPSocket", 907, G__G__Net_153_0_41, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
13029 G__tag_memfunc_reset();
13030 }
13031
13032 static void G__setup_memfuncTMonitor(void) {
13033
13034 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__NetLN_TMonitor));
13035 G__memfunc_setup("SetReady",801,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TSocket' - 0 - sock", (char*)NULL, (void*) NULL, 0);
13036 G__memfunc_setup("GetSender",897,(G__InterfaceMethod) NULL, 89, -1, -1, 0, 0, 1, 4, 0, "", "used to get gTQSender", (void*) NULL, 1);
13037 G__memfunc_setup("TMonitor",828,G__G__Net_162_0_3, 105, G__get_linked_tagnum(&G__G__NetLN_TMonitor), -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' mainloop", (char*)NULL, (void*) NULL, 0);
13038 G__memfunc_setup("TMonitor",828,G__G__Net_162_0_4, 105, G__get_linked_tagnum(&G__G__NetLN_TMonitor), -1, 0, 1, 1, 1, 0, "u 'TMonitor' - 11 - m", (char*)NULL, (void*) NULL, 0);
13039 G__memfunc_setup("Add",265,G__G__Net_162_0_5, 121, -1, -1, 0, 2, 1, 1, 0,
13040 "U 'TSocket' - 0 - sock i - 'Int_t' 0 'kRead' interest", (char*)NULL, (void*) NULL, 1);
13041 G__memfunc_setup("SetInterest",1146,G__G__Net_162_0_6, 121, -1, -1, 0, 2, 1, 1, 0,
13042 "U 'TSocket' - 0 - sock i - 'Int_t' 0 'kRead' interest", (char*)NULL, (void*) NULL, 1);
13043 G__memfunc_setup("Remove",622,G__G__Net_162_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TSocket' - 0 - sock", (char*)NULL, (void*) NULL, 1);
13044 G__memfunc_setup("RemoveAll",903,G__G__Net_162_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
13045 G__memfunc_setup("Activate",817,G__G__Net_162_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TSocket' - 0 - sock", (char*)NULL, (void*) NULL, 1);
13046 G__memfunc_setup("ActivateAll",1098,G__G__Net_162_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
13047 G__memfunc_setup("DeActivate",986,G__G__Net_162_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TSocket' - 0 - sock", (char*)NULL, (void*) NULL, 1);
13048 G__memfunc_setup("DeActivateAll",1267,G__G__Net_162_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
13049 G__memfunc_setup("Ready",501,G__G__Net_162_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TSocket' - 0 - sock", "*SIGNAL*", (void*) NULL, 1);
13050 G__memfunc_setup("Interrupt",973,G__G__Net_162_0_14, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
13051 G__memfunc_setup("ResetInterrupt",1488,G__G__Net_162_0_15, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
13052 G__memfunc_setup("Select",608,G__G__Net_162_0_16, 85, G__get_linked_tagnum(&G__G__NetLN_TSocket), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
13053 G__memfunc_setup("Select",608,G__G__Net_162_0_17, 85, G__get_linked_tagnum(&G__G__NetLN_TSocket), -1, 0, 1, 1, 1, 0, "l - 'Long_t' 0 - timeout", (char*)NULL, (void*) NULL, 0);
13054 G__memfunc_setup("Select",608,G__G__Net_162_0_18, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0,
13055 "U 'TList' - 0 - rdready U 'TList' - 0 - wrready "
13056 "l - 'Long_t' 0 - timeout", (char*)NULL, (void*) NULL, 0);
13057 G__memfunc_setup("GetActive",892,G__G__Net_162_0_19, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "l - 'Long_t' 0 '-1' timeout", (char*)NULL, (void*) NULL, 0);
13058 G__memfunc_setup("GetDeActive",1061,G__G__Net_162_0_20, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
13059 G__memfunc_setup("GetListOfActives",1600,G__G__Net_162_0_21, 85, G__get_linked_tagnum(&G__G__NetLN_TList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
13060 G__memfunc_setup("GetListOfDeActives",1769,G__G__Net_162_0_22, 85, G__get_linked_tagnum(&G__G__NetLN_TList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
13061 G__memfunc_setup("IsActive",792,G__G__Net_162_0_23, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "U 'TSocket' - 0 - s", (char*)NULL, (void*) NULL, 0);
13062 G__memfunc_setup("Class",502,G__G__Net_162_0_24, 85, G__get_linked_tagnum(&G__G__NetLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMonitor::Class) ), 0);
13063 G__memfunc_setup("Class_Name",982,G__G__Net_162_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMonitor::Class_Name) ), 0);
13064 G__memfunc_setup("Class_Version",1339,G__G__Net_162_0_26, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMonitor::Class_Version) ), 0);
13065 G__memfunc_setup("Dictionary",1046,G__G__Net_162_0_27, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMonitor::Dictionary) ), 0);
13066 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__NetLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
13067 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
13068 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
13069 G__memfunc_setup("StreamerNVirtual",1656,G__G__Net_162_0_31, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
13070 G__memfunc_setup("DeclFileName",1145,G__G__Net_162_0_32, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMonitor::DeclFileName) ), 0);
13071 G__memfunc_setup("ImplFileLine",1178,G__G__Net_162_0_33, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMonitor::ImplFileLine) ), 0);
13072 G__memfunc_setup("ImplFileName",1171,G__G__Net_162_0_34, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMonitor::ImplFileName) ), 0);
13073 G__memfunc_setup("DeclFileLine",1152,G__G__Net_162_0_35, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMonitor::DeclFileLine) ), 0);
13074
13075 G__memfunc_setup("~TMonitor", 954, G__G__Net_162_0_36, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
13076 G__tag_memfunc_reset();
13077 }
13078
13079 static void G__setup_memfuncTApplicationRemote(void) {
13080
13081 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__NetLN_TApplicationRemote));
13082 G__memfunc_setup("Broadcast",915,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 4, 0, "u 'TMessage' - 11 - mess", (char*)NULL, (void*) NULL, 0);
13083 G__memfunc_setup("Broadcast",915,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 4, 0,
13084 "C - - 10 - mess i - 'Int_t' 0 'kMESS_STRING' kind "
13085 "i - 'Int_t' 0 'kRRT_Undef' type", (char*)NULL, (void*) NULL, 0);
13086 G__memfunc_setup("Broadcast",915,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 4, 0,
13087 "i - 'Int_t' 0 - kind i - 'Int_t' 0 'kRRT_Undef' type", (char*)NULL, (void*) NULL, 0);
13088 G__memfunc_setup("BroadcastObject",1514,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 4, 0,
13089 "U 'TObject' - 10 - obj i - 'Int_t' 0 'kMESS_OBJECT' kind", (char*)NULL, (void*) NULL, 0);
13090 G__memfunc_setup("BroadcastRaw",1213,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 4, 0,
13091 "Y - - 10 - buffer i - 'Int_t' 0 - length", (char*)NULL, (void*) NULL, 0);
13092 G__memfunc_setup("CheckFile",862,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 4, 0,
13093 "C - - 10 - file l - 'Long_t' 0 - modtime", (char*)NULL, (void*) NULL, 0);
13094 G__memfunc_setup("Collect",710,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 4, 0, "l - 'Long_t' 0 '-1' timeout", (char*)NULL, (void*) NULL, 0);
13095 G__memfunc_setup("CollectInput",1238,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
13096 G__memfunc_setup("RecvLogFile",1074,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "i - 'Int_t' 0 - size", (char*)NULL, (void*) NULL, 0);
13097 G__memfunc_setup("TApplicationRemote",1844,G__G__Net_165_0_10, 105, G__get_linked_tagnum(&G__G__NetLN_TApplicationRemote), -1, 0, 3, 1, 1, 0,
13098 "C - - 10 - url i - 'Int_t' 0 '0' debug "
13099 "C - - 10 '0' script", (char*)NULL, (void*) NULL, 0);
13100 G__memfunc_setup("Browse",626,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TBrowser' - 0 - b", (char*)NULL, (void*) NULL, 1);
13101 G__memfunc_setup("IsFolder",792,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
13102 G__memfunc_setup("ApplicationName",1525,(G__InterfaceMethod) NULL,67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
13103 G__memfunc_setup("ProcessLine",1127,(G__InterfaceMethod) NULL,108, -1, G__defined_typename("Long_t"), 0, 3, 1, 1, 0,
13104 "C - - 10 - line g - 'Bool_t' 0 'kFALSE' - "
13105 "I - 'Int_t' 0 '0' error", (char*)NULL, (void*) NULL, 1);
13106 G__memfunc_setup("SendFile",778,G__G__Net_165_0_15, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0,
13107 "C - - 10 - file i - 'Int_t' 0 'kAscii' opt "
13108 "C - - 10 '0' rfile", (char*)NULL, (void*) NULL, 0);
13109 G__memfunc_setup("SendObject",993,G__G__Net_165_0_16, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "U 'TObject' - 10 - obj", (char*)NULL, (void*) NULL, 0);
13110 G__memfunc_setup("Interrupt",973,G__G__Net_165_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 'kRRI_Hard' type", (char*)NULL, (void*) NULL, 0);
13111 G__memfunc_setup("IsValid",684,G__G__Net_165_0_18, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
13112 G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
13113 G__memfunc_setup("Terminate",937,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '0' status", (char*)NULL, (void*) NULL, 1);
13114 G__memfunc_setup("SetPortParam",1218,G__G__Net_165_0_21, 121, -1, -1, 0, 3, 3, 1, 0,
13115 "i - 'Int_t' 0 '-1' lower i - 'Int_t' 0 '-1' upper "
13116 "i - 'Int_t' 0 '-1' attempts", (char*)NULL, (void*) G__func2void( (void (*)(Int_t, Int_t, Int_t))(&TApplicationRemote::SetPortParam) ), 0);
13117 G__memfunc_setup("Class",502,G__G__Net_165_0_22, 85, G__get_linked_tagnum(&G__G__NetLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TApplicationRemote::Class) ), 0);
13118 G__memfunc_setup("Class_Name",982,G__G__Net_165_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TApplicationRemote::Class_Name) ), 0);
13119 G__memfunc_setup("Class_Version",1339,G__G__Net_165_0_24, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TApplicationRemote::Class_Version) ), 0);
13120 G__memfunc_setup("Dictionary",1046,G__G__Net_165_0_25, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TApplicationRemote::Dictionary) ), 0);
13121 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__NetLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
13122 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
13123 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
13124 G__memfunc_setup("StreamerNVirtual",1656,G__G__Net_165_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
13125 G__memfunc_setup("DeclFileName",1145,G__G__Net_165_0_30, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TApplicationRemote::DeclFileName) ), 0);
13126 G__memfunc_setup("ImplFileLine",1178,G__G__Net_165_0_31, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TApplicationRemote::ImplFileLine) ), 0);
13127 G__memfunc_setup("ImplFileName",1171,G__G__Net_165_0_32, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TApplicationRemote::ImplFileName) ), 0);
13128 G__memfunc_setup("DeclFileLine",1152,G__G__Net_165_0_33, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TApplicationRemote::DeclFileLine) ), 0);
13129
13130 G__memfunc_setup("~TApplicationRemote", 1970, G__G__Net_165_0_34, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
13131 G__tag_memfunc_reset();
13132 }
13133
13134 static void G__setup_memfuncTApplicationServer(void) {
13135
13136 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__NetLN_TApplicationServer));
13137 G__memfunc_setup("ExecLogon",900,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
13138 G__memfunc_setup("Setup",529,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
13139 G__memfunc_setup("SendCanvases",1214,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 4, 0, "", "Send back to client any created canvas", (void*) NULL, 0);
13140 G__memfunc_setup("HandleCheckFile",1450,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "U 'TMessage' - 0 - mess", (char*)NULL, (void*) NULL, 0);
13141 G__memfunc_setup("ErrorHandler",1224,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 4, 3, 2, 0,
13142 "i - 'Int_t' 0 - level g - 'Bool_t' 0 - abort "
13143 "C - - 10 - location C - - 10 - msg", (char*)NULL, (void*) NULL, 0);
13144 G__memfunc_setup("TApplicationServer",1855,G__G__Net_170_0_6, 105, G__get_linked_tagnum(&G__G__NetLN_TApplicationServer), -1, 0, 4, 1, 1, 0,
13145 "I - 'Int_t' 0 - argc C - - 2 - argv "
13146 "E - - 0 - flog C - - 10 - logfile", (char*)NULL, (void*) NULL, 0);
13147 G__memfunc_setup("GetOptions",1036,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0,
13148 "I - 'Int_t' 0 - argc C - - 2 - argv", (char*)NULL, (void*) NULL, 1);
13149 G__memfunc_setup("GetProtocol",1138,G__G__Net_170_0_8, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
13150 G__memfunc_setup("GetPort",709,G__G__Net_170_0_9, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
13151 G__memfunc_setup("GetUser",703,G__G__Net_170_0_10, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
13152 G__memfunc_setup("GetHost",702,G__G__Net_170_0_11, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
13153 G__memfunc_setup("GetSocket",905,G__G__Net_170_0_12, 85, G__get_linked_tagnum(&G__G__NetLN_TSocket), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
13154 G__memfunc_setup("HandleSocketInput",1733,G__G__Net_170_0_13, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
13155 G__memfunc_setup("HandleUrgentData",1595,G__G__Net_170_0_14, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
13156 G__memfunc_setup("HandleSigPipe",1277,G__G__Net_170_0_15, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
13157 G__memfunc_setup("Interrupt",973,G__G__Net_170_0_16, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
13158 G__memfunc_setup("IsValid",684,G__G__Net_170_0_17, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
13159 G__memfunc_setup("ProcessLine",1127,(G__InterfaceMethod) NULL,108, -1, G__defined_typename("Long_t"), 0, 3, 1, 1, 0,
13160 "C - - 10 - line g - 'Bool_t' 0 'kFALSE' - "
13161 "I - 'Int_t' 0 '0' err", (char*)NULL, (void*) NULL, 1);
13162 G__memfunc_setup("Reset",515,G__G__Net_170_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - dir", (char*)NULL, (void*) NULL, 0);
13163 G__memfunc_setup("ReceiveFile",1091,G__G__Net_170_0_20, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0,
13164 "C - - 10 - file g - 'Bool_t' 0 - bin "
13165 "n - 'Long64_t' 0 - size", (char*)NULL, (void*) NULL, 0);
13166 G__memfunc_setup("Run",309,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kFALSE' retrn", (char*)NULL, (void*) NULL, 1);
13167 G__memfunc_setup("SendLogFile",1068,G__G__Net_170_0_22, 121, -1, -1, 0, 3, 1, 1, 0,
13168 "i - 'Int_t' 0 '0' status i - 'Int_t' 0 '-1' start "
13169 "i - 'Int_t' 0 '-1' end", (char*)NULL, (void*) NULL, 0);
13170 G__memfunc_setup("BrowseDirectory",1575,G__G__Net_170_0_23, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "C - - 10 - dirname", (char*)NULL, (void*) NULL, 0);
13171 G__memfunc_setup("BrowseFile",1010,G__G__Net_170_0_24, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "C - - 10 - fname", (char*)NULL, (void*) NULL, 0);
13172 G__memfunc_setup("BrowseKey",923,G__G__Net_170_0_25, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "C - - 10 - keyname", (char*)NULL, (void*) NULL, 0);
13173 G__memfunc_setup("Terminate",937,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - status", (char*)NULL, (void*) NULL, 1);
13174 G__memfunc_setup("Class",502,G__G__Net_170_0_27, 85, G__get_linked_tagnum(&G__G__NetLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TApplicationServer::Class) ), 0);
13175 G__memfunc_setup("Class_Name",982,G__G__Net_170_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TApplicationServer::Class_Name) ), 0);
13176 G__memfunc_setup("Class_Version",1339,G__G__Net_170_0_29, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TApplicationServer::Class_Version) ), 0);
13177 G__memfunc_setup("Dictionary",1046,G__G__Net_170_0_30, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TApplicationServer::Dictionary) ), 0);
13178 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__NetLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
13179 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
13180 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
13181 G__memfunc_setup("StreamerNVirtual",1656,G__G__Net_170_0_34, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
13182 G__memfunc_setup("DeclFileName",1145,G__G__Net_170_0_35, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TApplicationServer::DeclFileName) ), 0);
13183 G__memfunc_setup("ImplFileLine",1178,G__G__Net_170_0_36, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TApplicationServer::ImplFileLine) ), 0);
13184 G__memfunc_setup("ImplFileName",1171,G__G__Net_170_0_37, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TApplicationServer::ImplFileName) ), 0);
13185 G__memfunc_setup("DeclFileLine",1152,G__G__Net_170_0_38, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TApplicationServer::DeclFileLine) ), 0);
13186
13187 G__memfunc_setup("~TApplicationServer", 1981, G__G__Net_170_0_39, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
13188 G__tag_memfunc_reset();
13189 }
13190
13191 static void G__setup_memfuncTFileStager(void) {
13192
13193 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__NetLN_TFileStager));
13194 G__memfunc_setup("TFileStager",1082,G__G__Net_174_0_1, 105, G__get_linked_tagnum(&G__G__NetLN_TFileStager), -1, 0, 1, 1, 1, 0, "C - - 10 - stager", (char*)NULL, (void*) NULL, 0);
13195 G__memfunc_setup("GetStaged",888,G__G__Net_174_0_2, 85, G__get_linked_tagnum(&G__G__NetLN_TList), -1, 0, 1, 1, 1, 0, "U 'TCollection' - 0 - pathlist", (char*)NULL, (void*) NULL, 1);
13196 G__memfunc_setup("IsStaged",788,G__G__Net_174_0_3, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "C - - 10 - -", (char*)NULL, (void*) NULL, 1);
13197 G__memfunc_setup("Locate",600,G__G__Net_174_0_4, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0,
13198 "C - - 10 - u u 'TString' - 1 - f", (char*)NULL, (void*) NULL, 1);
13199 G__memfunc_setup("Matches",709,G__G__Net_174_0_5, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "C - - 10 - s", (char*)NULL, (void*) NULL, 1);
13200 G__memfunc_setup("Stage",500,G__G__Net_174_0_6, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0,
13201 "C - - 10 - - C - 'Option_t' 10 '0' -", (char*)NULL, (void*) NULL, 1);
13202 G__memfunc_setup("Stage",500,G__G__Net_174_0_7, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0,
13203 "U 'TCollection' - 0 - pathlist C - 'Option_t' 10 '0' opt", (char*)NULL, (void*) NULL, 1);
13204 G__memfunc_setup("IsValid",684,G__G__Net_174_0_8, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
13205 G__memfunc_setup("GetPathName",1070,G__G__Net_174_0_9, 117, G__get_linked_tagnum(&G__G__NetLN_TString), -1, 0, 1, 3, 1, 0, "U 'TObject' - 0 - o", (char*)NULL, (void*) G__func2void( (TString (*)(TObject*))(&TFileStager::GetPathName) ), 0);
13206 G__memfunc_setup("Open",402,G__G__Net_174_0_10, 85, G__get_linked_tagnum(&G__G__NetLN_TFileStager), -1, 0, 1, 3, 1, 0, "C - - 10 - stager", (char*)NULL, (void*) G__func2void( (TFileStager* (*)(const char*))(&TFileStager::Open) ), 0);
13207 G__memfunc_setup("Class",502,G__G__Net_174_0_11, 85, G__get_linked_tagnum(&G__G__NetLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TFileStager::Class) ), 0);
13208 G__memfunc_setup("Class_Name",982,G__G__Net_174_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TFileStager::Class_Name) ), 0);
13209 G__memfunc_setup("Class_Version",1339,G__G__Net_174_0_13, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TFileStager::Class_Version) ), 0);
13210 G__memfunc_setup("Dictionary",1046,G__G__Net_174_0_14, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TFileStager::Dictionary) ), 0);
13211 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__NetLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
13212 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
13213 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
13214 G__memfunc_setup("StreamerNVirtual",1656,G__G__Net_174_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
13215 G__memfunc_setup("DeclFileName",1145,G__G__Net_174_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TFileStager::DeclFileName) ), 0);
13216 G__memfunc_setup("ImplFileLine",1178,G__G__Net_174_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TFileStager::ImplFileLine) ), 0);
13217 G__memfunc_setup("ImplFileName",1171,G__G__Net_174_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TFileStager::ImplFileName) ), 0);
13218 G__memfunc_setup("DeclFileLine",1152,G__G__Net_174_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TFileStager::DeclFileLine) ), 0);
13219
13220 G__memfunc_setup("TFileStager", 1082, G__G__Net_174_0_23, (int) ('i'), G__get_linked_tagnum(&G__G__NetLN_TFileStager), -1, 0, 1, 1, 1, 0, "u 'TFileStager' - 11 - -", (char*) NULL, (void*) NULL, 0);
13221
13222 G__memfunc_setup("~TFileStager", 1208, G__G__Net_174_0_24, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
13223
13224 G__memfunc_setup("operator=", 937, G__G__Net_174_0_25, (int) ('u'), G__get_linked_tagnum(&G__G__NetLN_TFileStager), -1, 1, 1, 1, 1, 0, "u 'TFileStager' - 11 - -", (char*) NULL, (void*) NULL, 0);
13225 G__tag_memfunc_reset();
13226 }
13227
13228 static void G__setup_memfuncTServerSocket(void) {
13229
13230 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__NetLN_TServerSocket));
13231 G__memfunc_setup("TServerSocket",1332,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__NetLN_TServerSocket), -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
13232 G__memfunc_setup("TServerSocket",1332,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__NetLN_TServerSocket), -1, 0, 1, 1, 4, 0, "u 'TServerSocket' - 11 - -", (char*)NULL, (void*) NULL, 0);
13233 G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "u 'TServerSocket' - 11 - -", (char*)NULL, (void*) NULL, 0);
13234 G__memfunc_setup("Authenticate",1247,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 4, 0, "U 'TSocket' - 0 - -", (char*)NULL, (void*) NULL, 0);
13235 G__memfunc_setup("TServerSocket",1332,G__G__Net_180_0_5, 105, G__get_linked_tagnum(&G__G__NetLN_TServerSocket), -1, 0, 4, 1, 1, 0,
13236 "i - 'Int_t' 0 - port g - 'Bool_t' 0 'kFALSE' reuse "
13237 "i - 'Int_t' 0 'kDefaultBacklog' backlog i - 'Int_t' 0 '-1' tcpwindowsize", (char*)NULL, (void*) NULL, 0);
13238 G__memfunc_setup("TServerSocket",1332,G__G__Net_180_0_6, 105, G__get_linked_tagnum(&G__G__NetLN_TServerSocket), -1, 0, 4, 1, 1, 0,
13239 "C - - 10 - service g - 'Bool_t' 0 'kFALSE' reuse "
13240 "i - 'Int_t' 0 'kDefaultBacklog' backlog i - 'Int_t' 0 '-1' tcpwindowsize", (char*)NULL, (void*) NULL, 0);
13241 G__memfunc_setup("Accept",592,G__G__Net_180_0_7, 85, G__get_linked_tagnum(&G__G__NetLN_TSocket), -1, 0, 1, 1, 1, 0, "b - 'UChar_t' 0 '0' Opt", (char*)NULL, (void*) NULL, 1);
13242 G__memfunc_setup("GetLocalInetAddress",1889,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__NetLN_TInetAddress), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
13243 G__memfunc_setup("GetLocalPort",1200,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
13244 G__memfunc_setup("Send",394,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "u 'TMessage' - 11 - -", (char*)NULL, (void*) NULL, 1);
13245 G__memfunc_setup("Send",394,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
13246 G__memfunc_setup("Send",394,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0,
13247 "i - 'Int_t' 0 - - i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
13248 G__memfunc_setup("Send",394,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0,
13249 "C - - 10 - - i - 'Int_t' 0 'kMESS_STRING' -", (char*)NULL, (void*) NULL, 1);
13250 G__memfunc_setup("SendObject",993,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0,
13251 "U 'TObject' - 10 - - i - 'Int_t' 0 'kMESS_OBJECT' -", (char*)NULL, (void*) NULL, 1);
13252 G__memfunc_setup("SendRaw",692,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0,
13253 "Y - - 10 - - i - 'Int_t' 0 - - "
13254 "i 'ESendRecvOptions' - 0 'kDefault' -", (char*)NULL, (void*) NULL, 1);
13255 G__memfunc_setup("Recv",400,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "U 'TMessage' - 1 - -", (char*)NULL, (void*) NULL, 1);
13256 G__memfunc_setup("Recv",400,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0,
13257 "i - 'Int_t' 1 - - i - 'Int_t' 1 - -", (char*)NULL, (void*) NULL, 1);
13258 G__memfunc_setup("Recv",400,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0,
13259 "C - - 0 - - i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
13260 G__memfunc_setup("Recv",400,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0,
13261 "C - - 0 - - i - 'Int_t' 0 - - "
13262 "i - 'Int_t' 1 - -", (char*)NULL, (void*) NULL, 1);
13263 G__memfunc_setup("RecvRaw",698,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0,
13264 "Y - - 0 - - i - 'Int_t' 0 - - "
13265 "i 'ESendRecvOptions' - 0 'kDefault' -", (char*)NULL, (void*) NULL, 1);
13266 G__memfunc_setup("GetAcceptOptions",1628,G__G__Net_180_0_21, 98, -1, G__defined_typename("UChar_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (UChar_t (*)())(&TServerSocket::GetAcceptOptions) ), 0);
13267 G__memfunc_setup("SetAcceptOptions",1640,G__G__Net_180_0_22, 121, -1, -1, 0, 1, 3, 1, 0, "b - 'UChar_t' 0 - Opt", (char*)NULL, (void*) G__func2void( (void (*)(UChar_t))(&TServerSocket::SetAcceptOptions) ), 0);
13268 G__memfunc_setup("ShowAcceptOptions",1757,G__G__Net_180_0_23, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TServerSocket::ShowAcceptOptions) ), 0);
13269 G__memfunc_setup("Class",502,G__G__Net_180_0_24, 85, G__get_linked_tagnum(&G__G__NetLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TServerSocket::Class) ), 0);
13270 G__memfunc_setup("Class_Name",982,G__G__Net_180_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TServerSocket::Class_Name) ), 0);
13271 G__memfunc_setup("Class_Version",1339,G__G__Net_180_0_26, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TServerSocket::Class_Version) ), 0);
13272 G__memfunc_setup("Dictionary",1046,G__G__Net_180_0_27, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TServerSocket::Dictionary) ), 0);
13273 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__NetLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
13274 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
13275 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
13276 G__memfunc_setup("StreamerNVirtual",1656,G__G__Net_180_0_31, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
13277 G__memfunc_setup("DeclFileName",1145,G__G__Net_180_0_32, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TServerSocket::DeclFileName) ), 0);
13278 G__memfunc_setup("ImplFileLine",1178,G__G__Net_180_0_33, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TServerSocket::ImplFileLine) ), 0);
13279 G__memfunc_setup("ImplFileName",1171,G__G__Net_180_0_34, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TServerSocket::ImplFileName) ), 0);
13280 G__memfunc_setup("DeclFileLine",1152,G__G__Net_180_0_35, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TServerSocket::DeclFileLine) ), 0);
13281
13282 G__memfunc_setup("~TServerSocket", 1458, G__G__Net_180_0_36, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
13283 G__tag_memfunc_reset();
13284 }
13285
13286 static void G__setup_memfuncTFTP(void) {
13287
13288 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__NetLN_TFTP));
13289 G__memfunc_setup("TFTP",318,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__NetLN_TFTP), -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
13290 G__memfunc_setup("TFTP",318,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__NetLN_TFTP), -1, 0, 1, 1, 4, 0, "u 'TFTP' - 11 - -", "not implemented", (void*) NULL, 0);
13291 G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "u 'TFTP' - 11 - -", "idem", (void*) NULL, 0);
13292 G__memfunc_setup("Init",404,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 4, 0,
13293 "C - - 10 - url i - 'Int_t' 0 - parallel "
13294 "i - 'Int_t' 0 - wsize", (char*)NULL, (void*) NULL, 0);
13295 G__memfunc_setup("PrintError",1047,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 8,
13296 "C - - 10 - where i - 'Int_t' 0 - err", (char*)NULL, (void*) NULL, 0);
13297 G__memfunc_setup("Recv",400,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 4, 8,
13298 "i - 'Int_t' 1 - status i 'EMessageTypes' - 1 - kind", (char*)NULL, (void*) NULL, 0);
13299 G__memfunc_setup("SetMode",689,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "i - 'Int_t' 0 - mode", (char*)NULL, (void*) NULL, 0);
13300 G__memfunc_setup("TFTP",318,G__G__Net_208_0_8, 105, G__get_linked_tagnum(&G__G__NetLN_TFTP), -1, 0, 4, 1, 1, 0,
13301 "C - - 10 - url i - 'Int_t' 0 '1' parallel "
13302 "i - 'Int_t' 0 'kDfltWindowSize' wsize U 'TSocket' - 0 '0' sock", (char*)NULL, (void*) NULL, 0);
13303 G__memfunc_setup("SetBlockSize",1202,G__G__Net_208_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - blockSize", (char*)NULL, (void*) NULL, 0);
13304 G__memfunc_setup("GetBlockSize",1190,G__G__Net_208_0_10, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
13305 G__memfunc_setup("SetRestartAt",1222,G__G__Net_208_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "n - 'Long64_t' 0 - at", (char*)NULL, (void*) NULL, 0);
13306 G__memfunc_setup("GetRestartAt",1210,G__G__Net_208_0_12, 110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
13307 G__memfunc_setup("GetMode",677,G__G__Net_208_0_13, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
13308 G__memfunc_setup("IsOpen",590,G__G__Net_208_0_14, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
13309 G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' opt", (char*)NULL, (void*) NULL, 1);
13310 G__memfunc_setup("PutFile",697,G__G__Net_208_0_16, 110, -1, G__defined_typename("Long64_t"), 0, 2, 1, 1, 0,
13311 "C - - 10 - file C - - 10 '0' remoteName", (char*)NULL, (void*) NULL, 0);
13312 G__memfunc_setup("GetFile",672,G__G__Net_208_0_17, 110, -1, G__defined_typename("Long64_t"), 0, 2, 1, 1, 0,
13313 "C - - 10 - file C - - 10 '0' localName", (char*)NULL, (void*) NULL, 0);
13314 G__memfunc_setup("AccessPathName",1376,G__G__Net_208_0_18, 103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0,
13315 "C - - 10 - path i 'EAccessMode' - 0 'kFileExists' mode "
13316 "g - 'Bool_t' 0 'kFALSE' print", (char*)NULL, (void*) NULL, 0);
13317 G__memfunc_setup("GetDirEntry",1105,G__G__Net_208_0_19, 67, -1, -1, 0, 1, 1, 1, 1, "g - 'Bool_t' 0 'kFALSE' print", (char*)NULL, (void*) NULL, 0);
13318 G__memfunc_setup("GetPathInfo",1081,G__G__Net_208_0_20, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0,
13319 "C - - 10 - path u 'FileStat_t' - 1 - buf "
13320 "g - 'Bool_t' 0 'kFALSE' print", (char*)NULL, (void*) NULL, 0);
13321 G__memfunc_setup("ChangeDirectory",1531,G__G__Net_208_0_21, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "C - - 10 - dir", (char*)NULL, (void*) NULL, 0);
13322 G__memfunc_setup("MakeDirectory",1331,G__G__Net_208_0_22, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 8,
13323 "C - - 10 - dir g - 'Bool_t' 0 'kFALSE' print", (char*)NULL, (void*) NULL, 0);
13324 G__memfunc_setup("DeleteDirectory",1544,G__G__Net_208_0_23, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "C - - 10 - dir", (char*)NULL, (void*) NULL, 0);
13325 G__memfunc_setup("ListDirectory",1361,G__G__Net_208_0_24, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' cmd", (char*)NULL, (void*) NULL, 0);
13326 G__memfunc_setup("FreeDirectory",1335,G__G__Net_208_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kFALSE' print", (char*)NULL, (void*) NULL, 0);
13327 G__memfunc_setup("OpenDirectory",1351,G__G__Net_208_0_26, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0,
13328 "C - - 10 - name g - 'Bool_t' 0 'kFALSE' print", (char*)NULL, (void*) NULL, 0);
13329 G__memfunc_setup("PrintDirectory",1474,G__G__Net_208_0_27, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
13330 G__memfunc_setup("RenameFile",984,G__G__Net_208_0_28, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 8,
13331 "C - - 10 - file1 C - - 10 - file2", (char*)NULL, (void*) NULL, 0);
13332 G__memfunc_setup("DeleteFile",979,G__G__Net_208_0_29, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "C - - 10 - file", (char*)NULL, (void*) NULL, 0);
13333 G__memfunc_setup("ChangePermission",1647,G__G__Net_208_0_30, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 8,
13334 "C - - 10 - file i - 'Int_t' 0 - mode", (char*)NULL, (void*) NULL, 0);
13335 G__memfunc_setup("Close",502,G__G__Net_208_0_31, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
13336 G__memfunc_setup("Binary",613,G__G__Net_208_0_32, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
13337 G__memfunc_setup("Ascii",489,G__G__Net_208_0_33, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
13338 G__memfunc_setup("GetSocket",905,G__G__Net_208_0_34, 85, G__get_linked_tagnum(&G__G__NetLN_TSocket), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
13339 G__memfunc_setup("put",345,G__G__Net_208_0_35, 121, -1, -1, 0, 2, 1, 1, 0,
13340 "C - - 10 - file C - - 10 '0' remoteName", (char*)NULL, (void*) NULL, 0);
13341 G__memfunc_setup("get",320,G__G__Net_208_0_36, 121, -1, -1, 0, 2, 1, 1, 0,
13342 "C - - 10 - file C - - 10 '0' localName", (char*)NULL, (void*) NULL, 0);
13343 G__memfunc_setup("cd",199,G__G__Net_208_0_37, 121, -1, -1, 0, 1, 1, 1, 8, "C - - 10 - dir", (char*)NULL, (void*) NULL, 0);
13344 G__memfunc_setup("mkdir",535,G__G__Net_208_0_38, 121, -1, -1, 0, 1, 1, 1, 8, "C - - 10 - dir", (char*)NULL, (void*) NULL, 0);
13345 G__memfunc_setup("rmdir",542,G__G__Net_208_0_39, 121, -1, -1, 0, 1, 1, 1, 8, "C - - 10 - dir", (char*)NULL, (void*) NULL, 0);
13346 G__memfunc_setup("ls",223,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' cmd", (char*)NULL, (void*) NULL, 1);
13347 G__memfunc_setup("pwd",331,G__G__Net_208_0_41, 121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
13348 G__memfunc_setup("mv",227,G__G__Net_208_0_42, 121, -1, -1, 0, 2, 1, 1, 8,
13349 "C - - 10 - file1 C - - 10 - file2", (char*)NULL, (void*) NULL, 0);
13350 G__memfunc_setup("rm",223,G__G__Net_208_0_43, 121, -1, -1, 0, 1, 1, 1, 8, "C - - 10 - file", (char*)NULL, (void*) NULL, 0);
13351 G__memfunc_setup("chmod",523,G__G__Net_208_0_44, 121, -1, -1, 0, 2, 1, 1, 8,
13352 "C - - 10 - file i - 'Int_t' 0 - mode", (char*)NULL, (void*) NULL, 0);
13353 G__memfunc_setup("bye",320,G__G__Net_208_0_45, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
13354 G__memfunc_setup("bin",313,G__G__Net_208_0_46, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
13355 G__memfunc_setup("ascii",521,G__G__Net_208_0_47, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
13356 G__memfunc_setup("Class",502,G__G__Net_208_0_48, 85, G__get_linked_tagnum(&G__G__NetLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TFTP::Class) ), 0);
13357 G__memfunc_setup("Class_Name",982,G__G__Net_208_0_49, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TFTP::Class_Name) ), 0);
13358 G__memfunc_setup("Class_Version",1339,G__G__Net_208_0_50, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TFTP::Class_Version) ), 0);
13359 G__memfunc_setup("Dictionary",1046,G__G__Net_208_0_51, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TFTP::Dictionary) ), 0);
13360 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__NetLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
13361 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
13362 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
13363 G__memfunc_setup("StreamerNVirtual",1656,G__G__Net_208_0_55, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
13364 G__memfunc_setup("DeclFileName",1145,G__G__Net_208_0_56, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TFTP::DeclFileName) ), 0);
13365 G__memfunc_setup("ImplFileLine",1178,G__G__Net_208_0_57, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TFTP::ImplFileLine) ), 0);
13366 G__memfunc_setup("ImplFileName",1171,G__G__Net_208_0_58, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TFTP::ImplFileName) ), 0);
13367 G__memfunc_setup("DeclFileLine",1152,G__G__Net_208_0_59, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TFTP::DeclFileLine) ), 0);
13368
13369 G__memfunc_setup("~TFTP", 444, G__G__Net_208_0_60, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
13370 G__tag_memfunc_reset();
13371 }
13372
13373 static void G__setup_memfuncTGridResult(void) {
13374
13375 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__NetLN_TGridResult));
13376 G__memfunc_setup("TGridResult",1113,G__G__Net_213_0_1, 105, G__get_linked_tagnum(&G__G__NetLN_TGridResult), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
13377 G__memfunc_setup("GetFileName",1057,G__G__Net_213_0_2, 67, -1, -1, 0, 1, 1, 1, 9, "h - 'UInt_t' 0 - -", (char*)NULL, (void*) NULL, 1);
13378 G__memfunc_setup("GetFileNamePath",1454,G__G__Net_213_0_3, 67, -1, -1, 0, 1, 1, 1, 9, "h - 'UInt_t' 0 - -", (char*)NULL, (void*) NULL, 1);
13379 G__memfunc_setup("GetPath",685,G__G__Net_213_0_4, 67, -1, -1, 0, 1, 1, 1, 9, "h - 'UInt_t' 0 - -", (char*)NULL, (void*) NULL, 1);
13380 G__memfunc_setup("GetEntryList",1230,G__G__Net_213_0_5, 85, G__get_linked_tagnum(&G__G__NetLN_TEntryList), -1, 0, 1, 1, 1, 9, "h - 'UInt_t' 0 - -", (char*)NULL, (void*) NULL, 1);
13381 G__memfunc_setup("GetKey",585,G__G__Net_213_0_6, 67, -1, -1, 0, 2, 1, 1, 9,
13382 "h - 'UInt_t' 0 - - C - - 10 - -", (char*)NULL, (void*) NULL, 1);
13383 G__memfunc_setup("SetKey",597,G__G__Net_213_0_7, 103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0,
13384 "h - 'UInt_t' 0 - - C - - 10 - - "
13385 "C - - 10 - -", (char*)NULL, (void*) NULL, 1);
13386 G__memfunc_setup("GetFileInfoList",1480,G__G__Net_213_0_8, 85, G__get_linked_tagnum(&G__G__NetLN_TList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
13387 G__memfunc_setup("Class",502,G__G__Net_213_0_9, 85, G__get_linked_tagnum(&G__G__NetLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGridResult::Class) ), 0);
13388 G__memfunc_setup("Class_Name",982,G__G__Net_213_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGridResult::Class_Name) ), 0);
13389 G__memfunc_setup("Class_Version",1339,G__G__Net_213_0_11, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGridResult::Class_Version) ), 0);
13390 G__memfunc_setup("Dictionary",1046,G__G__Net_213_0_12, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGridResult::Dictionary) ), 0);
13391 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__NetLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
13392 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
13393 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
13394 G__memfunc_setup("StreamerNVirtual",1656,G__G__Net_213_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
13395 G__memfunc_setup("DeclFileName",1145,G__G__Net_213_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGridResult::DeclFileName) ), 0);
13396 G__memfunc_setup("ImplFileLine",1178,G__G__Net_213_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGridResult::ImplFileLine) ), 0);
13397 G__memfunc_setup("ImplFileName",1171,G__G__Net_213_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGridResult::ImplFileName) ), 0);
13398 G__memfunc_setup("DeclFileLine",1152,G__G__Net_213_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGridResult::DeclFileLine) ), 0);
13399
13400 G__memfunc_setup("~TGridResult", 1239, G__G__Net_213_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
13401 G__tag_memfunc_reset();
13402 }
13403
13404 static void G__setup_memfuncTGridCollection(void) {
13405
13406 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__NetLN_TGridCollection));
13407 G__memfunc_setup("TGridCollection",1510,G__G__Net_215_0_1, 105, G__get_linked_tagnum(&G__G__NetLN_TGridCollection), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
13408 G__memfunc_setup("Reset",515,G__G__Net_215_0_2, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
13409 G__memfunc_setup("Next",415,G__G__Net_215_0_3, 85, G__get_linked_tagnum(&G__G__NetLN_TMap), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
13410 G__memfunc_setup("Remove",622,G__G__Net_215_0_4, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'TMap' - 0 - -", (char*)NULL, (void*) NULL, 1);
13411 G__memfunc_setup("GetTURL",615,G__G__Net_215_0_5, 67, -1, -1, 0, 1, 1, 1, 1, "C - - 10 '\"\"' -", (char*)NULL, (void*) NULL, 1);
13412 G__memfunc_setup("GetSURL",614,G__G__Net_215_0_6, 67, -1, -1, 0, 1, 1, 1, 1, "C - - 10 '\"\"' -", (char*)NULL, (void*) NULL, 1);
13413 G__memfunc_setup("GetLFN",512,G__G__Net_215_0_7, 67, -1, -1, 0, 1, 1, 1, 1, "C - - 10 '\"\"' -", (char*)NULL, (void*) NULL, 1);
13414 G__memfunc_setup("GetSize",699,G__G__Net_215_0_8, 110, -1, G__defined_typename("Long64_t"), 0, 1, 1, 1, 0, "C - - 10 '\"\"' -", (char*)NULL, (void*) NULL, 1);
13415 G__memfunc_setup("IsOnline",801,G__G__Net_215_0_9, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "C - - 10 '\"\"' -", (char*)NULL, (void*) NULL, 1);
13416 G__memfunc_setup("IsSelected",997,G__G__Net_215_0_10, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "C - - 10 '\"\"' -", (char*)NULL, (void*) NULL, 1);
13417 G__memfunc_setup("Status",644,G__G__Net_215_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
13418 G__memfunc_setup("SetTag",584,G__G__Net_215_0_12, 121, -1, -1, 0, 3, 1, 1, 0,
13419 "C - - 10 - - C - - 10 - - "
13420 "U 'TMap' - 0 - -", (char*)NULL, (void*) NULL, 1);
13421 G__memfunc_setup("SelectFile",992,G__G__Net_215_0_13, 103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0,
13422 "C - - 10 - - i - 'Int_t' 0 '-1' - "
13423 "i - 'Int_t' 0 '-1' -", (char*)NULL, (void*) NULL, 1);
13424 G__memfunc_setup("DeselectFile",1193,G__G__Net_215_0_14, 103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0,
13425 "C - - 10 - - i - 'Int_t' 0 '-1' - "
13426 "i - 'Int_t' 0 '-1' -", (char*)NULL, (void*) NULL, 1);
13427 G__memfunc_setup("InvertSelection",1566,G__G__Net_215_0_15, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
13428 G__memfunc_setup("DownscaleSelection",1862,G__G__Net_215_0_16, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "h - 'UInt_t' 0 '2' -", (char*)NULL, (void*) NULL, 1);
13429 G__memfunc_setup("ExportXML",883,G__G__Net_215_0_17, 103, -1, G__defined_typename("Bool_t"), 0, 5, 1, 1, 0,
13430 "C - - 10 - - g - 'Bool_t' 0 'kTRUE' - "
13431 "g - 'Bool_t' 0 'kTRUE' - C - - 10 '\"ROOT xml\"' - "
13432 "C - - 10 '\"Exported XML\"' -", (char*)NULL, (void*) NULL, 1);
13433 G__memfunc_setup("GetExportUrl",1237,G__G__Net_215_0_18, 67, -1, -1, 0, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 1);
13434 G__memfunc_setup("SetExportUrl",1249,G__G__Net_215_0_19, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "C - - 10 '0' -", (char*)NULL, (void*) NULL, 1);
13435 G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 - -", (char*)NULL, (void*) NULL, 1);
13436 G__memfunc_setup("OpenFile",786,G__G__Net_215_0_21, 85, G__get_linked_tagnum(&G__G__NetLN_TFile), -1, 0, 1, 1, 1, 0, "C - - 10 - -", (char*)NULL, (void*) NULL, 1);
13437 G__memfunc_setup("GetFileGroupList",1609,G__G__Net_215_0_22, 85, G__get_linked_tagnum(&G__G__NetLN_TList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
13438 G__memfunc_setup("GetEntryList",1230,G__G__Net_215_0_23, 85, G__get_linked_tagnum(&G__G__NetLN_TEntryList), -1, 0, 1, 1, 1, 0, "C - - 10 - -", (char*)NULL, (void*) NULL, 1);
13439 G__memfunc_setup("GetNofGroups",1219,G__G__Net_215_0_24, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
13440 G__memfunc_setup("GetNofGroupfiles",1635,G__G__Net_215_0_25, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
13441 G__memfunc_setup("OverlapCollection",1765,G__G__Net_215_0_26, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'TGridCollection' - 0 - -", (char*)NULL, (void*) NULL, 1);
13442 G__memfunc_setup("Add",265,G__G__Net_215_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGridCollection' - 0 - -", (char*)NULL, (void*) NULL, 1);
13443 G__memfunc_setup("Stage",500,G__G__Net_215_0_28, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0,
13444 "g - 'Bool_t' 0 'kFALSE' - C - 'Option_t' 10 '\"\"' -", (char*)NULL, (void*) NULL, 1);
13445 G__memfunc_setup("Prepare",719,G__G__Net_215_0_29, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kFALSE' -", (char*)NULL, (void*) NULL, 1);
13446 G__memfunc_setup("CheckIfOnline",1266,G__G__Net_215_0_30, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kFALSE' -", (char*)NULL, (void*) NULL, 1);
13447 G__memfunc_setup("GetDataset",998,G__G__Net_215_0_31, 85, G__get_linked_tagnum(&G__G__NetLN_TDSet), -1, 0, 3, 1, 1, 0,
13448 "C - - 10 - - C - - 10 - - "
13449 "C - - 10 - -", (char*)NULL, (void*) NULL, 1);
13450 G__memfunc_setup("GetGridResult",1317,G__G__Net_215_0_32, 85, G__get_linked_tagnum(&G__G__NetLN_TGridResult), -1, 0, 3, 1, 1, 0,
13451 "C - - 10 '\"\"' - g - 'Bool_t' 0 'kTRUE' - "
13452 "g - 'Bool_t' 0 'kFALSE' -", (char*)NULL, (void*) NULL, 1);
13453 G__memfunc_setup("LookupSUrls",1139,G__G__Net_215_0_33, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' -", (char*)NULL, (void*) NULL, 1);
13454 G__memfunc_setup("GetTagFilterList",1598,G__G__Net_215_0_34, 85, G__get_linked_tagnum(&G__G__NetLN_TList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
13455 G__memfunc_setup("SetTagFilterList",1610,G__G__Net_215_0_35, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TList' - 0 - -", (char*)NULL, (void*) NULL, 1);
13456 G__memfunc_setup("GetCollectionName",1709,G__G__Net_215_0_36, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
13457 G__memfunc_setup("GetInfoComment",1407,G__G__Net_215_0_37, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
13458 G__memfunc_setup("GetFileCollection",1708,G__G__Net_215_0_38, 85, G__get_linked_tagnum(&G__G__NetLN_TFileCollection), -1, 0, 2, 1, 1, 8,
13459 "C - - 10 '\"\"' - C - - 10 '\"\"' -", (char*)NULL, (void*) NULL, 1);
13460 G__memfunc_setup("Class",502,G__G__Net_215_0_39, 85, G__get_linked_tagnum(&G__G__NetLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGridCollection::Class) ), 0);
13461 G__memfunc_setup("Class_Name",982,G__G__Net_215_0_40, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGridCollection::Class_Name) ), 0);
13462 G__memfunc_setup("Class_Version",1339,G__G__Net_215_0_41, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGridCollection::Class_Version) ), 0);
13463 G__memfunc_setup("Dictionary",1046,G__G__Net_215_0_42, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGridCollection::Dictionary) ), 0);
13464 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__NetLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
13465 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
13466 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
13467 G__memfunc_setup("StreamerNVirtual",1656,G__G__Net_215_0_46, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
13468 G__memfunc_setup("DeclFileName",1145,G__G__Net_215_0_47, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGridCollection::DeclFileName) ), 0);
13469 G__memfunc_setup("ImplFileLine",1178,G__G__Net_215_0_48, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGridCollection::ImplFileLine) ), 0);
13470 G__memfunc_setup("ImplFileName",1171,G__G__Net_215_0_49, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGridCollection::ImplFileName) ), 0);
13471 G__memfunc_setup("DeclFileLine",1152,G__G__Net_215_0_50, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGridCollection::DeclFileLine) ), 0);
13472
13473 G__memfunc_setup("TGridCollection", 1510, G__G__Net_215_0_51, (int) ('i'), G__get_linked_tagnum(&G__G__NetLN_TGridCollection), -1, 0, 1, 1, 1, 0, "u 'TGridCollection' - 11 - -", (char*) NULL, (void*) NULL, 0);
13474
13475 G__memfunc_setup("~TGridCollection", 1636, G__G__Net_215_0_52, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
13476
13477 G__memfunc_setup("operator=", 937, G__G__Net_215_0_53, (int) ('u'), G__get_linked_tagnum(&G__G__NetLN_TGridCollection), -1, 1, 1, 1, 1, 0, "u 'TGridCollection' - 11 - -", (char*) NULL, (void*) NULL, 0);
13478 G__tag_memfunc_reset();
13479 }
13480
13481 static void G__setup_memfuncTGridJobStatus(void) {
13482
13483 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__NetLN_TGridJobStatus));
13484 G__memfunc_setup("GetStatus",932,G__G__Net_216_0_2, 105, G__get_linked_tagnum(&G__G__NetLN_TGridJobStatuscLcLEGridJobStatus), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
13485 G__memfunc_setup("Class",502,G__G__Net_216_0_3, 85, G__get_linked_tagnum(&G__G__NetLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGridJobStatus::Class) ), 0);
13486 G__memfunc_setup("Class_Name",982,G__G__Net_216_0_4, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGridJobStatus::Class_Name) ), 0);
13487 G__memfunc_setup("Class_Version",1339,G__G__Net_216_0_5, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGridJobStatus::Class_Version) ), 0);
13488 G__memfunc_setup("Dictionary",1046,G__G__Net_216_0_6, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGridJobStatus::Dictionary) ), 0);
13489 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__NetLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
13490 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
13491 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
13492 G__memfunc_setup("StreamerNVirtual",1656,G__G__Net_216_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
13493 G__memfunc_setup("DeclFileName",1145,G__G__Net_216_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGridJobStatus::DeclFileName) ), 0);
13494 G__memfunc_setup("ImplFileLine",1178,G__G__Net_216_0_12, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGridJobStatus::ImplFileLine) ), 0);
13495 G__memfunc_setup("ImplFileName",1171,G__G__Net_216_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGridJobStatus::ImplFileName) ), 0);
13496 G__memfunc_setup("DeclFileLine",1152,G__G__Net_216_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGridJobStatus::DeclFileLine) ), 0);
13497
13498 G__memfunc_setup("~TGridJobStatus", 1527, G__G__Net_216_0_15, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
13499
13500 G__memfunc_setup("operator=", 937, G__G__Net_216_0_16, (int) ('u'), G__get_linked_tagnum(&G__G__NetLN_TGridJobStatus), -1, 1, 1, 1, 1, 0, "u 'TGridJobStatus' - 11 - -", (char*) NULL, (void*) NULL, 0);
13501 G__tag_memfunc_reset();
13502 }
13503
13504 static void G__setup_memfuncTGridJob(void) {
13505
13506 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__NetLN_TGridJob));
13507 G__memfunc_setup("GetJobID",712,G__G__Net_217_0_2, 117, G__get_linked_tagnum(&G__G__NetLN_TString), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
13508 G__memfunc_setup("GetJobStatus",1215,G__G__Net_217_0_3, 85, G__get_linked_tagnum(&G__G__NetLN_TGridJobStatus), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
13509 G__memfunc_setup("GetOutputSandbox",1664,G__G__Net_217_0_4, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0,
13510 "C - - 10 - localpath C - 'Option_t' 10 '0' opt", (char*)NULL, (void*) NULL, 1);
13511 G__memfunc_setup("Resubmit",843,G__G__Net_217_0_5, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
13512 G__memfunc_setup("Cancel",582,G__G__Net_217_0_6, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
13513 G__memfunc_setup("Class",502,G__G__Net_217_0_7, 85, G__get_linked_tagnum(&G__G__NetLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGridJob::Class) ), 0);
13514 G__memfunc_setup("Class_Name",982,G__G__Net_217_0_8, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGridJob::Class_Name) ), 0);
13515 G__memfunc_setup("Class_Version",1339,G__G__Net_217_0_9, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGridJob::Class_Version) ), 0);
13516 G__memfunc_setup("Dictionary",1046,G__G__Net_217_0_10, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGridJob::Dictionary) ), 0);
13517 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__NetLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
13518 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
13519 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
13520 G__memfunc_setup("StreamerNVirtual",1656,G__G__Net_217_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
13521 G__memfunc_setup("DeclFileName",1145,G__G__Net_217_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGridJob::DeclFileName) ), 0);
13522 G__memfunc_setup("ImplFileLine",1178,G__G__Net_217_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGridJob::ImplFileLine) ), 0);
13523 G__memfunc_setup("ImplFileName",1171,G__G__Net_217_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGridJob::ImplFileName) ), 0);
13524 G__memfunc_setup("DeclFileLine",1152,G__G__Net_217_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGridJob::DeclFileLine) ), 0);
13525
13526 G__memfunc_setup("~TGridJob", 883, G__G__Net_217_0_19, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
13527
13528 G__memfunc_setup("operator=", 937, G__G__Net_217_0_20, (int) ('u'), G__get_linked_tagnum(&G__G__NetLN_TGridJob), -1, 1, 1, 1, 1, 0, "u 'TGridJob' - 11 - -", (char*) NULL, (void*) NULL, 0);
13529 G__tag_memfunc_reset();
13530 }
13531
13532 static void G__setup_memfuncTGridJDL(void) {
13533
13534 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__NetLN_TGridJDL));
13535 G__memfunc_setup("SetValue",809,G__G__Net_218_0_2, 121, -1, -1, 0, 2, 1, 1, 0,
13536 "C - - 10 - key C - - 10 - value", (char*)NULL, (void*) NULL, 0);
13537 G__memfunc_setup("GetValue",797,G__G__Net_218_0_3, 67, -1, -1, 0, 1, 1, 1, 1, "C - - 10 - key", (char*)NULL, (void*) NULL, 0);
13538 G__memfunc_setup("SetDescription",1456,G__G__Net_218_0_4, 121, -1, -1, 0, 2, 1, 1, 0,
13539 "C - - 10 - key C - - 10 - description", (char*)NULL, (void*) NULL, 0);
13540 G__memfunc_setup("GetDescription",1444,G__G__Net_218_0_5, 67, -1, -1, 0, 1, 1, 1, 1, "C - - 10 - key", (char*)NULL, (void*) NULL, 0);
13541 G__memfunc_setup("AddQuotes",906,G__G__Net_218_0_6, 117, G__get_linked_tagnum(&G__G__NetLN_TString), -1, 0, 1, 1, 1, 0, "C - - 10 - value", (char*)NULL, (void*) NULL, 0);
13542 G__memfunc_setup("AddToSet",760,G__G__Net_218_0_7, 121, -1, -1, 0, 2, 1, 1, 0,
13543 "C - - 10 - key C - - 10 - value", (char*)NULL, (void*) NULL, 0);
13544 G__memfunc_setup("AddToSetDescription",1916,G__G__Net_218_0_8, 121, -1, -1, 0, 2, 1, 1, 0,
13545 "C - - 10 - key C - - 10 - description", (char*)NULL, (void*) NULL, 0);
13546 G__memfunc_setup("Generate",811,G__G__Net_218_0_9, 117, G__get_linked_tagnum(&G__G__NetLN_TString), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
13547 G__memfunc_setup("Clear",487,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '0' -", (char*)NULL, (void*) NULL, 1);
13548 G__memfunc_setup("SetExecutable",1326,G__G__Net_218_0_11, 121, -1, -1, 0, 2, 1, 1, 0,
13549 "C - - 10 '0' value C - - 10 '0' description", (char*)NULL, (void*) NULL, 3);
13550 G__memfunc_setup("SetArguments",1250,G__G__Net_218_0_12, 121, -1, -1, 0, 2, 1, 1, 0,
13551 "C - - 10 '0' value C - - 10 '0' description", (char*)NULL, (void*) NULL, 3);
13552 G__memfunc_setup("SetEMail",756,G__G__Net_218_0_13, 121, -1, -1, 0, 2, 1, 1, 0,
13553 "C - - 10 '0' value C - - 10 '0' description", (char*)NULL, (void*) NULL, 3);
13554 G__memfunc_setup("SetOutputDirectory",1906,G__G__Net_218_0_14, 121, -1, -1, 0, 2, 1, 1, 0,
13555 "C - - 10 '0' value C - - 10 '0' description", (char*)NULL, (void*) NULL, 3);
13556 G__memfunc_setup("SetPrice",799,G__G__Net_218_0_15, 121, -1, -1, 0, 2, 1, 1, 0,
13557 "h - 'UInt_t' 0 '1' price C - - 10 '0' description", (char*)NULL, (void*) NULL, 3);
13558 G__memfunc_setup("SetTTL",544,G__G__Net_218_0_16, 121, -1, -1, 0, 2, 1, 1, 0,
13559 "h - 'UInt_t' 0 '72000' ttl C - - 10 '0' description", (char*)NULL, (void*) NULL, 3);
13560 G__memfunc_setup("SetJobTag",867,G__G__Net_218_0_17, 121, -1, -1, 0, 2, 1, 1, 0,
13561 "C - - 10 '0' jobtag C - - 10 '0' description", (char*)NULL, (void*) NULL, 3);
13562 G__memfunc_setup("SetInputDataListFormat",2235,G__G__Net_218_0_18, 121, -1, -1, 0, 2, 1, 1, 0,
13563 "C - - 10 '\"xml-single\"' format C - - 10 '0' description", (char*)NULL, (void*) NULL, 3);
13564 G__memfunc_setup("SetInputDataList",1618,G__G__Net_218_0_19, 121, -1, -1, 0, 2, 1, 1, 0,
13565 "C - - 10 '\"collection.xml\"' list C - - 10 '0' description", (char*)NULL, (void*) NULL, 3);
13566 G__memfunc_setup("SetSplitMode",1213,G__G__Net_218_0_20, 121, -1, -1, 0, 6, 1, 1, 0,
13567 "C - - 10 - value h - 'UInt_t' 0 '0' maxnumberofinputfiles "
13568 "h - 'UInt_t' 0 '0' maxinputfilesize C - - 10 '0' d1 "
13569 "C - - 10 '0' d2 C - - 10 '0' d3", (char*)NULL, (void*) NULL, 3);
13570 G__memfunc_setup("SetSplitArguments",1774,G__G__Net_218_0_21, 121, -1, -1, 0, 2, 1, 1, 0,
13571 "C - - 10 '0' splitarguments C - - 10 '0' description", (char*)NULL, (void*) NULL, 3);
13572 G__memfunc_setup("SetValidationCommand",2038,G__G__Net_218_0_22, 121, -1, -1, 0, 2, 1, 1, 0,
13573 "C - - 10 - value C - - 10 '0' description", (char*)NULL, (void*) NULL, 3);
13574 G__memfunc_setup("AddToInputSandbox",1707,G__G__Net_218_0_23, 121, -1, -1, 0, 2, 1, 1, 0,
13575 "C - - 10 '0' value C - - 10 '0' description", (char*)NULL, (void*) NULL, 3);
13576 G__memfunc_setup("AddToOutputSandbox",1836,G__G__Net_218_0_24, 121, -1, -1, 0, 2, 1, 1, 0,
13577 "C - - 10 '0' value C - - 10 '0' description", (char*)NULL, (void*) NULL, 3);
13578 G__memfunc_setup("AddToInputData",1366,G__G__Net_218_0_25, 121, -1, -1, 0, 2, 1, 1, 0,
13579 "C - - 10 '0' value C - - 10 '0' description", (char*)NULL, (void*) NULL, 3);
13580 G__memfunc_setup("AddToInputDataCollection",2402,G__G__Net_218_0_26, 121, -1, -1, 0, 2, 1, 1, 0,
13581 "C - - 10 '0' value C - - 10 '0' description", (char*)NULL, (void*) NULL, 3);
13582 G__memfunc_setup("AddToRequirements",1744,G__G__Net_218_0_27, 121, -1, -1, 0, 2, 1, 1, 0,
13583 "C - - 10 '0' value C - - 10 '0' description", (char*)NULL, (void*) NULL, 3);
13584 G__memfunc_setup("AddToPackages",1259,G__G__Net_218_0_28, 121, -1, -1, 0, 4, 1, 1, 0,
13585 "C - - 10 '\"AliRoot\"' name C - - 10 '\"default\"' version "
13586 "C - - 10 '\"VO_ALICE\"' type C - - 10 '0' description", (char*)NULL, (void*) NULL, 3);
13587 G__memfunc_setup("AddToOutputArchive",1823,G__G__Net_218_0_29, 121, -1, -1, 0, 2, 1, 1, 0,
13588 "C - - 10 '0' value C - - 10 '0' description", (char*)NULL, (void*) NULL, 3);
13589 G__memfunc_setup("Class",502,G__G__Net_218_0_30, 85, G__get_linked_tagnum(&G__G__NetLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGridJDL::Class) ), 0);
13590 G__memfunc_setup("Class_Name",982,G__G__Net_218_0_31, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGridJDL::Class_Name) ), 0);
13591 G__memfunc_setup("Class_Version",1339,G__G__Net_218_0_32, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGridJDL::Class_Version) ), 0);
13592 G__memfunc_setup("Dictionary",1046,G__G__Net_218_0_33, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGridJDL::Dictionary) ), 0);
13593 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__NetLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
13594 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
13595 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
13596 G__memfunc_setup("StreamerNVirtual",1656,G__G__Net_218_0_37, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
13597 G__memfunc_setup("DeclFileName",1145,G__G__Net_218_0_38, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGridJDL::DeclFileName) ), 0);
13598 G__memfunc_setup("ImplFileLine",1178,G__G__Net_218_0_39, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGridJDL::ImplFileLine) ), 0);
13599 G__memfunc_setup("ImplFileName",1171,G__G__Net_218_0_40, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGridJDL::ImplFileName) ), 0);
13600 G__memfunc_setup("DeclFileLine",1152,G__G__Net_218_0_41, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGridJDL::DeclFileLine) ), 0);
13601
13602 G__memfunc_setup("~TGridJDL", 818, G__G__Net_218_0_42, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
13603 G__tag_memfunc_reset();
13604 }
13605
13606 static void G__setup_memfuncTGridJobStatusList(void) {
13607
13608 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__NetLN_TGridJobStatusList));
13609 G__memfunc_setup("TGridJobStatusList",1813,G__G__Net_219_0_1, 105, G__get_linked_tagnum(&G__G__NetLN_TGridJobStatusList), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
13610 G__memfunc_setup("Class",502,G__G__Net_219_0_2, 85, G__get_linked_tagnum(&G__G__NetLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGridJobStatusList::Class) ), 0);
13611 G__memfunc_setup("Class_Name",982,G__G__Net_219_0_3, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGridJobStatusList::Class_Name) ), 0);
13612 G__memfunc_setup("Class_Version",1339,G__G__Net_219_0_4, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGridJobStatusList::Class_Version) ), 0);
13613 G__memfunc_setup("Dictionary",1046,G__G__Net_219_0_5, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGridJobStatusList::Dictionary) ), 0);
13614 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__NetLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
13615 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
13616 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
13617 G__memfunc_setup("StreamerNVirtual",1656,G__G__Net_219_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
13618 G__memfunc_setup("DeclFileName",1145,G__G__Net_219_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGridJobStatusList::DeclFileName) ), 0);
13619 G__memfunc_setup("ImplFileLine",1178,G__G__Net_219_0_11, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGridJobStatusList::ImplFileLine) ), 0);
13620 G__memfunc_setup("ImplFileName",1171,G__G__Net_219_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGridJobStatusList::ImplFileName) ), 0);
13621 G__memfunc_setup("DeclFileLine",1152,G__G__Net_219_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGridJobStatusList::DeclFileLine) ), 0);
13622
13623 G__memfunc_setup("~TGridJobStatusList", 1939, G__G__Net_219_0_14, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
13624 G__tag_memfunc_reset();
13625 }
13626
13627 static void G__setup_memfuncTGrid(void) {
13628
13629 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__NetLN_TGrid));
13630 G__memfunc_setup("TGrid",474,G__G__Net_220_0_1, 105, G__get_linked_tagnum(&G__G__NetLN_TGrid), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
13631 G__memfunc_setup("GridUrl",697,G__G__Net_220_0_2, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
13632 G__memfunc_setup("GetGrid",678,G__G__Net_220_0_3, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
13633 G__memfunc_setup("GetHost",702,G__G__Net_220_0_4, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
13634 G__memfunc_setup("GetUser",703,G__G__Net_220_0_5, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
13635 G__memfunc_setup("GetPw",487,G__G__Net_220_0_6, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
13636 G__memfunc_setup("GetOptions",1036,G__G__Net_220_0_7, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
13637 G__memfunc_setup("GetPort",709,G__G__Net_220_0_8, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
13638 G__memfunc_setup("IsConnected",1103,G__G__Net_220_0_9, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
13639 G__memfunc_setup("Shell",504,G__G__Net_220_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
13640 G__memfunc_setup("Stdout",643,G__G__Net_220_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
13641 G__memfunc_setup("Stderr",628,G__G__Net_220_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
13642 G__memfunc_setup("Command",703,G__G__Net_220_0_13, 85, G__get_linked_tagnum(&G__G__NetLN_TGridResult), -1, 0, 3, 1, 1, 0,
13643 "C - - 10 - - g - 'Bool_t' 0 'kFALSE' - "
13644 "h - 'UInt_t' 0 '2' -", (char*)NULL, (void*) NULL, 1);
13645 G__memfunc_setup("Query",534,G__G__Net_220_0_14, 85, G__get_linked_tagnum(&G__G__NetLN_TGridResult), -1, 0, 4, 1, 1, 0,
13646 "C - - 10 - - C - - 10 - - "
13647 "C - - 10 '\"\"' - C - - 10 '\"\"' -", (char*)NULL, (void*) NULL, 1);
13648 G__memfunc_setup("LocateSites",1120,G__G__Net_220_0_15, 85, G__get_linked_tagnum(&G__G__NetLN_TGridResult), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
13649 G__memfunc_setup("Ls",191,G__G__Net_220_0_16, 85, G__get_linked_tagnum(&G__G__NetLN_TGridResult), -1, 0, 3, 1, 1, 0,
13650 "C - - 10 '\"\"' - C - 'Option_t' 10 '\"\"' - "
13651 "g - 'Bool_t' 0 'kFALSE' -", (char*)NULL, (void*) NULL, 1);
13652 G__memfunc_setup("Pwd",299,G__G__Net_220_0_17, 67, -1, -1, 0, 1, 1, 1, 1, "g - 'Bool_t' 0 'kFALSE' -", (char*)NULL, (void*) NULL, 1);
13653 G__memfunc_setup("GetHomeDirectory",1630,G__G__Net_220_0_18, 67, -1, -1, 0, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 1);
13654 G__memfunc_setup("Cd",167,G__G__Net_220_0_19, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0,
13655 "C - - 10 '\"\"' - g - 'Bool_t' 0 'kFALSE' -", (char*)NULL, (void*) NULL, 1);
13656 G__memfunc_setup("Mkdir",503,G__G__Net_220_0_20, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0,
13657 "C - - 10 '\"\"' - C - 'Option_t' 10 '\"\"' - "
13658 "g - 'Bool_t' 0 'kFALSE' -", (char*)NULL, (void*) NULL, 1);
13659 G__memfunc_setup("Rmdir",510,G__G__Net_220_0_21, 103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0,
13660 "C - - 10 '\"\"' - C - 'Option_t' 10 '\"\"' - "
13661 "g - 'Bool_t' 0 'kFALSE' -", (char*)NULL, (void*) NULL, 1);
13662 G__memfunc_setup("Register",837,G__G__Net_220_0_22, 103, -1, G__defined_typename("Bool_t"), 0, 6, 1, 1, 0,
13663 "C - - 10 - - C - - 10 - - "
13664 "l - 'Long_t' 0 '-1' - C - - 10 '0' - "
13665 "C - - 10 '0' - g - 'Bool_t' 0 'kFALSE' -", (char*)NULL, (void*) NULL, 1);
13666 G__memfunc_setup("Rm",191,G__G__Net_220_0_23, 103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0,
13667 "C - - 10 - - C - 'Option_t' 10 '\"\"' - "
13668 "g - 'Bool_t' 0 'kFALSE' -", (char*)NULL, (void*) NULL, 1);
13669 G__memfunc_setup("Submit",628,G__G__Net_220_0_24, 85, G__get_linked_tagnum(&G__G__NetLN_TGridJob), -1, 0, 1, 1, 1, 0, "C - - 10 - -", (char*)NULL, (void*) NULL, 1);
13670 G__memfunc_setup("GetJDLGenerator",1441,G__G__Net_220_0_25, 85, G__get_linked_tagnum(&G__G__NetLN_TGridJDL), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
13671 G__memfunc_setup("OpenCollection",1438,G__G__Net_220_0_26, 85, G__get_linked_tagnum(&G__G__NetLN_TGridCollection), -1, 0, 2, 1, 1, 0,
13672 "C - - 10 - - h - 'UInt_t' 0 '1000000' -", (char*)NULL, (void*) NULL, 1);
13673 G__memfunc_setup("OpenCollectionQuery",1972,G__G__Net_220_0_27, 85, G__get_linked_tagnum(&G__G__NetLN_TGridCollection), -1, 0, 2, 1, 1, 0,
13674 "U 'TGridResult' - 0 - - g - 'Bool_t' 0 'kFALSE' -", (char*)NULL, (void*) NULL, 1);
13675 G__memfunc_setup("Ps",195,G__G__Net_220_0_28, 85, G__get_linked_tagnum(&G__G__NetLN_TGridJobStatusList), -1, 0, 2, 1, 1, 0,
13676 "C - - 10 - - g - 'Bool_t' 0 'kTRUE' -", (char*)NULL, (void*) NULL, 1);
13677 G__memfunc_setup("KillById",756,G__G__Net_220_0_29, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "u 'TString' - 0 - -", (char*)NULL, (void*) NULL, 1);
13678 G__memfunc_setup("ResubmitById",1203,G__G__Net_220_0_30, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "u 'TString' - 0 - -", (char*)NULL, (void*) NULL, 1);
13679 G__memfunc_setup("Kill",396,G__G__Net_220_0_31, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'TGridJob' - 0 - gridjob", (char*)NULL, (void*) NULL, 1);
13680 G__memfunc_setup("Resubmit",843,G__G__Net_220_0_32, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'TGridJob' - 0 - gridjob", (char*)NULL, (void*) NULL, 1);
13681 G__memfunc_setup("Connect",714,G__G__Net_220_0_33, 85, G__get_linked_tagnum(&G__G__NetLN_TGrid), -1, 0, 4, 3, 1, 0,
13682 "C - - 10 - grid C - - 10 '0' uid "
13683 "C - - 10 '0' pw C - - 10 '0' options", (char*)NULL, (void*) G__func2void( (TGrid* (*)(const char*, const char*, const char*, const char*))(&TGrid::Connect) ), 0);
13684 G__memfunc_setup("Class",502,G__G__Net_220_0_34, 85, G__get_linked_tagnum(&G__G__NetLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGrid::Class) ), 0);
13685 G__memfunc_setup("Class_Name",982,G__G__Net_220_0_35, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGrid::Class_Name) ), 0);
13686 G__memfunc_setup("Class_Version",1339,G__G__Net_220_0_36, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGrid::Class_Version) ), 0);
13687 G__memfunc_setup("Dictionary",1046,G__G__Net_220_0_37, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGrid::Dictionary) ), 0);
13688 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__NetLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
13689 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
13690 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
13691 G__memfunc_setup("StreamerNVirtual",1656,G__G__Net_220_0_41, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
13692 G__memfunc_setup("DeclFileName",1145,G__G__Net_220_0_42, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGrid::DeclFileName) ), 0);
13693 G__memfunc_setup("ImplFileLine",1178,G__G__Net_220_0_43, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGrid::ImplFileLine) ), 0);
13694 G__memfunc_setup("ImplFileName",1171,G__G__Net_220_0_44, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGrid::ImplFileName) ), 0);
13695 G__memfunc_setup("DeclFileLine",1152,G__G__Net_220_0_45, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGrid::DeclFileLine) ), 0);
13696
13697 G__memfunc_setup("TGrid", 474, G__G__Net_220_0_46, (int) ('i'), G__get_linked_tagnum(&G__G__NetLN_TGrid), -1, 0, 1, 1, 1, 0, "u 'TGrid' - 11 - -", (char*) NULL, (void*) NULL, 0);
13698
13699 G__memfunc_setup("~TGrid", 600, G__G__Net_220_0_47, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
13700
13701 G__memfunc_setup("operator=", 937, G__G__Net_220_0_48, (int) ('u'), G__get_linked_tagnum(&G__G__NetLN_TGrid), -1, 1, 1, 1, 1, 0, "u 'TGrid' - 11 - -", (char*) NULL, (void*) NULL, 0);
13702 G__tag_memfunc_reset();
13703 }
13704
13705 static void G__setup_memfuncTNetFile(void) {
13706
13707 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__NetLN_TNetFile));
13708 G__memfunc_setup("TNetFile",763,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__NetLN_TNetFile), -1, 0, 1, 1, 2, 0, "u 'TNetFile' - 11 - -", "NetFile cannot be copied", (void*) NULL, 0);
13709 G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__NetLN_TNetFile), -1, 1, 1, 1, 2, 0, "u 'TNetFile' - 11 - -", "NetFile cannot be copied", (void*) NULL, 0);
13710 G__memfunc_setup("TNetFile",763,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__NetLN_TNetFile), -1, 0, 4, 1, 2, 0,
13711 "C - - 10 - url C - - 10 - ftitle "
13712 "i - 'Int_t' 0 - comp g - 'Bool_t' 0 - -", (char*)NULL, (void*) NULL, 0);
13713 G__memfunc_setup("ConnectServer",1345,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 6, 1, 2, 0,
13714 "I - 'Int_t' 0 - stat I 'EMessageTypes' - 0 - kind "
13715 "i - 'Int_t' 0 - netopt i - 'Int_t' 0 - tcpwindowsize "
13716 "g - 'Bool_t' 0 - forceOpen g - 'Bool_t' 0 - forceRead", (char*)NULL, (void*) NULL, 1);
13717 G__memfunc_setup("Create",596,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 2, 0,
13718 "C - - 10 - url C - 'Option_t' 10 - option "
13719 "i - 'Int_t' 0 - netopt", (char*)NULL, (void*) NULL, 1);
13720 G__memfunc_setup("Create",596,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 2, 0,
13721 "U 'TSocket' - 0 - s C - 'Option_t' 10 - option "
13722 "i - 'Int_t' 0 - netopt", (char*)NULL, (void*) NULL, 1);
13723 G__memfunc_setup("Init",404,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "g - 'Bool_t' 0 - create", (char*)NULL, (void*) NULL, 1);
13724 G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 8, "C - 'Option_t' 10 - option", (char*)NULL, (void*) NULL, 1);
13725 G__memfunc_setup("PrintError",1047,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 0,
13726 "C - - 10 - where i - 'Int_t' 0 - err", (char*)NULL, (void*) NULL, 0);
13727 G__memfunc_setup("Recv",400,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 2, 0,
13728 "i - 'Int_t' 1 - status i 'EMessageTypes' - 1 - kind", (char*)NULL, (void*) NULL, 0);
13729 G__memfunc_setup("SysOpen",721,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 2, 0,
13730 "C - - 10 - pathname i - 'Int_t' 0 - flags "
13731 "h - 'UInt_t' 0 - mode", (char*)NULL, (void*) NULL, 1);
13732 G__memfunc_setup("SysClose",821,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 2, 0, "i - 'Int_t' 0 - fd", (char*)NULL, (void*) NULL, 1);
13733 G__memfunc_setup("SysStat",731,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 5, 1, 2, 0,
13734 "i - 'Int_t' 0 - fd L - 'Long_t' 0 - id "
13735 "N - 'Long64_t' 0 - size L - 'Long_t' 0 - flags "
13736 "L - 'Long_t' 0 - modtime", (char*)NULL, (void*) NULL, 1);
13737 G__memfunc_setup("TNetFile",763,G__G__Net_248_0_14, 105, G__get_linked_tagnum(&G__G__NetLN_TNetFile), -1, 0, 5, 1, 1, 0,
13738 "C - - 10 - url C - 'Option_t' 10 '\"\"' option "
13739 "C - - 10 '\"\"' ftitle i - 'Int_t' 0 '1' compress "
13740 "i - 'Int_t' 0 '0' netopt", (char*)NULL, (void*) NULL, 0);
13741 G__memfunc_setup("TNetFile",763,G__G__Net_248_0_15, 105, G__get_linked_tagnum(&G__G__NetLN_TNetFile), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
13742 G__memfunc_setup("Close",502,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", "*MENU*", (void*) NULL, 1);
13743 G__memfunc_setup("Flush",514,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
13744 G__memfunc_setup("GetErrorCode",1189,G__G__Net_248_0_18, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
13745 G__memfunc_setup("IsOpen",590,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
13746 G__memfunc_setup("Matches",709,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "C - - 10 - url", (char*)NULL, (void*) NULL, 1);
13747 G__memfunc_setup("ReOpen",585,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "C - 'Option_t' 10 - mode", (char*)NULL, (void*) NULL, 1);
13748 G__memfunc_setup("ReadBuffer",982,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0,
13749 "C - - 0 - buf i - 'Int_t' 0 - len", (char*)NULL, (void*) NULL, 1);
13750 G__memfunc_setup("ReadBuffer",982,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0,
13751 "C - - 0 - buf n - 'Long64_t' 0 - pos "
13752 "i - 'Int_t' 0 - len", (char*)NULL, (void*) NULL, 1);
13753 G__memfunc_setup("ReadBuffers",1097,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 4, 1, 1, 0,
13754 "C - - 0 - buf N - 'Long64_t' 0 - pos "
13755 "I - 'Int_t' 0 - len i - 'Int_t' 0 - nbuf", (char*)NULL, (void*) NULL, 1);
13756 G__memfunc_setup("WriteBuffer",1125,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0,
13757 "C - - 10 - buf i - 'Int_t' 0 - len", (char*)NULL, (void*) NULL, 1);
13758 G__memfunc_setup("Seek",392,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0,
13759 "n - 'Long64_t' 0 - offset i 'TFile::ERelativeTo' - 0 'kBeg' pos", (char*)NULL, (void*) NULL, 1);
13760 G__memfunc_setup("GetEndpointUrl",1428,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__NetLN_TUrl), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
13761 G__memfunc_setup("Class",502,G__G__Net_248_0_28, 85, G__get_linked_tagnum(&G__G__NetLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TNetFile::Class) ), 0);
13762 G__memfunc_setup("Class_Name",982,G__G__Net_248_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TNetFile::Class_Name) ), 0);
13763 G__memfunc_setup("Class_Version",1339,G__G__Net_248_0_30, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TNetFile::Class_Version) ), 0);
13764 G__memfunc_setup("Dictionary",1046,G__G__Net_248_0_31, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TNetFile::Dictionary) ), 0);
13765 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__NetLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
13766 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
13767 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
13768 G__memfunc_setup("StreamerNVirtual",1656,G__G__Net_248_0_35, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
13769 G__memfunc_setup("DeclFileName",1145,G__G__Net_248_0_36, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TNetFile::DeclFileName) ), 0);
13770 G__memfunc_setup("ImplFileLine",1178,G__G__Net_248_0_37, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TNetFile::ImplFileLine) ), 0);
13771 G__memfunc_setup("ImplFileName",1171,G__G__Net_248_0_38, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TNetFile::ImplFileName) ), 0);
13772 G__memfunc_setup("DeclFileLine",1152,G__G__Net_248_0_39, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TNetFile::DeclFileLine) ), 0);
13773
13774 G__memfunc_setup("~TNetFile", 889, G__G__Net_248_0_40, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
13775 G__tag_memfunc_reset();
13776 }
13777
13778 static void G__setup_memfuncTNetSystem(void) {
13779
13780 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__NetLN_TNetSystem));
13781 G__memfunc_setup("TNetSystem",1024,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__NetLN_TNetSystem), -1, 0, 1, 1, 4, 0, "u 'TNetSystem' - 11 - -", "not implemented", (void*) NULL, 0);
13782 G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__NetLN_TNetSystem), -1, 1, 1, 1, 4, 0, "u 'TNetSystem' - 11 - -", "not implemented", (void*) NULL, 0);
13783 G__memfunc_setup("GetDirPtr",885,(G__InterfaceMethod) NULL, 89, -1, -1, 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 1);
13784 G__memfunc_setup("Create",596,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 0,
13785 "C - - 10 - url U 'TSocket' - 0 '0' sock", (char*)NULL, (void*) NULL, 0);
13786 G__memfunc_setup("InitRemoteEntity",1661,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "C - - 10 - url", (char*)NULL, (void*) NULL, 0);
13787 G__memfunc_setup("TNetSystem",1024,G__G__Net_249_0_6, 105, G__get_linked_tagnum(&G__G__NetLN_TNetSystem), -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' ftpowner", (char*)NULL, (void*) NULL, 0);
13788 G__memfunc_setup("TNetSystem",1024,G__G__Net_249_0_7, 105, G__get_linked_tagnum(&G__G__NetLN_TNetSystem), -1, 0, 2, 1, 1, 0,
13789 "C - - 10 - url g - 'Bool_t' 0 'kTRUE' ftpowner", (char*)NULL, (void*) NULL, 0);
13790 G__memfunc_setup("ConsistentWith",1478,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0,
13791 "C - - 10 - path Y - - 0 - dirptr", (char*)NULL, (void*) NULL, 1);
13792 G__memfunc_setup("MakeDirectory",1331,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
13793 G__memfunc_setup("OpenDirectory",1351,(G__InterfaceMethod) NULL,89, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
13794 G__memfunc_setup("FreeDirectory",1335,G__G__Net_249_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "Y - - 0 '0' dirp", (char*)NULL, (void*) NULL, 1);
13795 G__memfunc_setup("GetDirEntry",1105,G__G__Net_249_0_12, 67, -1, -1, 0, 1, 1, 1, 1, "Y - - 0 '0' dirp", (char*)NULL, (void*) NULL, 1);
13796 G__memfunc_setup("GetPathInfo",1081,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0,
13797 "C - - 10 - path u 'FileStat_t' - 1 - buf", (char*)NULL, (void*) NULL, 1);
13798 G__memfunc_setup("AccessPathName",1376,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0,
13799 "C - - 10 - path i 'EAccessMode' - 0 - mode", (char*)NULL, (void*) NULL, 1);
13800 G__memfunc_setup("Unlink",625,(G__InterfaceMethod) NULL,105, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - path", (char*)NULL, (void*) NULL, 1);
13801 G__memfunc_setup("Class",502,G__G__Net_249_0_16, 85, G__get_linked_tagnum(&G__G__NetLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TNetSystem::Class) ), 0);
13802 G__memfunc_setup("Class_Name",982,G__G__Net_249_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TNetSystem::Class_Name) ), 0);
13803 G__memfunc_setup("Class_Version",1339,G__G__Net_249_0_18, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TNetSystem::Class_Version) ), 0);
13804 G__memfunc_setup("Dictionary",1046,G__G__Net_249_0_19, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TNetSystem::Dictionary) ), 0);
13805 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__NetLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
13806 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
13807 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
13808 G__memfunc_setup("StreamerNVirtual",1656,G__G__Net_249_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
13809 G__memfunc_setup("DeclFileName",1145,G__G__Net_249_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TNetSystem::DeclFileName) ), 0);
13810 G__memfunc_setup("ImplFileLine",1178,G__G__Net_249_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TNetSystem::ImplFileLine) ), 0);
13811 G__memfunc_setup("ImplFileName",1171,G__G__Net_249_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TNetSystem::ImplFileName) ), 0);
13812 G__memfunc_setup("DeclFileLine",1152,G__G__Net_249_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TNetSystem::DeclFileLine) ), 0);
13813
13814 G__memfunc_setup("~TNetSystem", 1150, G__G__Net_249_0_28, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
13815 G__tag_memfunc_reset();
13816 }
13817
13818 static void G__setup_memfuncTSecContext(void) {
13819
13820 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__NetLN_TSecContext));
13821 G__memfunc_setup("CleanupSecContext",1736,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 4, 0, "g - 'Bool_t' 0 - all", (char*)NULL, (void*) NULL, 1);
13822 G__memfunc_setup("Cleanup",712,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
13823 G__memfunc_setup("TSecContext",1108,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__NetLN_TSecContext), -1, 0, 1, 1, 2, 0, "u 'TSecContext' - 11 - -", (char*)NULL, (void*) NULL, 0);
13824 G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__NetLN_TSecContext), -1, 1, 1, 1, 2, 0, "u 'TSecContext' - 11 - -", (char*)NULL, (void*) NULL, 0);
13825 G__memfunc_setup("TSecContext",1108,G__G__Net_250_0_5, 105, G__get_linked_tagnum(&G__G__NetLN_TSecContext), -1, 0, 7, 1, 1, 0,
13826 "C - - 10 - url i - 'Int_t' 0 - meth "
13827 "i - 'Int_t' 0 - offset C - - 10 - id "
13828 "C - - 10 - token u 'TDatime' - 0 'kROOTTZERO' expdate "
13829 "Y - - 0 '0' ctx", (char*)NULL, (void*) NULL, 0);
13830 G__memfunc_setup("TSecContext",1108,G__G__Net_250_0_6, 105, G__get_linked_tagnum(&G__G__NetLN_TSecContext), -1, 0, 8, 1, 1, 0,
13831 "C - - 10 - user C - - 10 - host "
13832 "i - 'Int_t' 0 - meth i - 'Int_t' 0 - offset "
13833 "C - - 10 - id C - - 10 - token "
13834 "u 'TDatime' - 0 'kROOTTZERO' expdate Y - - 0 '0' ctx", (char*)NULL, (void*) NULL, 0);
13835 G__memfunc_setup("AddForCleanup",1272,G__G__Net_250_0_7, 121, -1, -1, 0, 3, 1, 1, 0,
13836 "i - 'Int_t' 0 - port i - 'Int_t' 0 - proto "
13837 "i - 'Int_t' 0 - type", (char*)NULL, (void*) NULL, 0);
13838 G__memfunc_setup("AsString",811,G__G__Net_250_0_8, 67, -1, -1, 0, 1, 1, 1, 1, "u 'TString' - 1 - out", (char*)NULL, (void*) NULL, 1);
13839 G__memfunc_setup("DeActivate",986,G__G__Net_250_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"CR\"' opt", (char*)NULL, (void*) NULL, 1);
13840 G__memfunc_setup("GetContext",1029,G__G__Net_250_0_10, 89, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
13841 G__memfunc_setup("GetExpDate",971,G__G__Net_250_0_11, 117, G__get_linked_tagnum(&G__G__NetLN_TDatime), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
13842 G__memfunc_setup("GetHost",702,G__G__Net_250_0_12, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
13843 G__memfunc_setup("GetID",429,G__G__Net_250_0_13, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
13844 G__memfunc_setup("GetMethod",897,G__G__Net_250_0_14, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
13845 G__memfunc_setup("GetMethodName",1282,G__G__Net_250_0_15, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
13846 G__memfunc_setup("GetOffSet",871,G__G__Net_250_0_16, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
13847 G__memfunc_setup("GetSecContextCleanup",2024,G__G__Net_250_0_17, 85, G__get_linked_tagnum(&G__G__NetLN_TList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
13848 G__memfunc_setup("GetToken",801,G__G__Net_250_0_18, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
13849 G__memfunc_setup("GetUser",703,G__G__Net_250_0_19, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
13850 G__memfunc_setup("IsA",253,G__G__Net_250_0_20, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "C - - 10 - methodname", (char*)NULL, (void*) NULL, 0);
13851 G__memfunc_setup("IsActive",792,G__G__Net_250_0_21, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
13852 G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"F\"' option", (char*)NULL, (void*) NULL, 1);
13853 G__memfunc_setup("SetExpDate",983,G__G__Net_250_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TDatime' - 0 - expdate", (char*)NULL, (void*) NULL, 0);
13854 G__memfunc_setup("SetID",441,G__G__Net_250_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - id", (char*)NULL, (void*) NULL, 0);
13855 G__memfunc_setup("SetOffSet",883,G__G__Net_250_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - offset", (char*)NULL, (void*) NULL, 0);
13856 G__memfunc_setup("SetUser",715,G__G__Net_250_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - user", (char*)NULL, (void*) NULL, 0);
13857 G__memfunc_setup("Class",502,G__G__Net_250_0_27, 85, G__get_linked_tagnum(&G__G__NetLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TSecContext::Class) ), 0);
13858 G__memfunc_setup("Class_Name",982,G__G__Net_250_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSecContext::Class_Name) ), 0);
13859 G__memfunc_setup("Class_Version",1339,G__G__Net_250_0_29, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TSecContext::Class_Version) ), 0);
13860 G__memfunc_setup("Dictionary",1046,G__G__Net_250_0_30, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TSecContext::Dictionary) ), 0);
13861 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__NetLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
13862 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
13863 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
13864 G__memfunc_setup("StreamerNVirtual",1656,G__G__Net_250_0_34, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
13865 G__memfunc_setup("DeclFileName",1145,G__G__Net_250_0_35, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSecContext::DeclFileName) ), 0);
13866 G__memfunc_setup("ImplFileLine",1178,G__G__Net_250_0_36, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TSecContext::ImplFileLine) ), 0);
13867 G__memfunc_setup("ImplFileName",1171,G__G__Net_250_0_37, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSecContext::ImplFileName) ), 0);
13868 G__memfunc_setup("DeclFileLine",1152,G__G__Net_250_0_38, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TSecContext::DeclFileLine) ), 0);
13869
13870 G__memfunc_setup("~TSecContext", 1234, G__G__Net_250_0_39, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
13871 G__tag_memfunc_reset();
13872 }
13873
13874 static void G__setup_memfuncTSecContextCleanup(void) {
13875
13876 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__NetLN_TSecContextCleanup));
13877 G__memfunc_setup("TSecContextCleanup",1820,G__G__Net_252_0_1, 105, G__get_linked_tagnum(&G__G__NetLN_TSecContextCleanup), -1, 0, 3, 1, 1, 0,
13878 "i - 'Int_t' 0 - port i - 'Int_t' 0 - proto "
13879 "i - 'Int_t' 0 - type", (char*)NULL, (void*) NULL, 0);
13880 G__memfunc_setup("GetPort",709,G__G__Net_252_0_2, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
13881 G__memfunc_setup("GetProtocol",1138,G__G__Net_252_0_3, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
13882 G__memfunc_setup("GetType",706,G__G__Net_252_0_4, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
13883 G__memfunc_setup("Class",502,G__G__Net_252_0_5, 85, G__get_linked_tagnum(&G__G__NetLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TSecContextCleanup::Class) ), 0);
13884 G__memfunc_setup("Class_Name",982,G__G__Net_252_0_6, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSecContextCleanup::Class_Name) ), 0);
13885 G__memfunc_setup("Class_Version",1339,G__G__Net_252_0_7, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TSecContextCleanup::Class_Version) ), 0);
13886 G__memfunc_setup("Dictionary",1046,G__G__Net_252_0_8, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TSecContextCleanup::Dictionary) ), 0);
13887 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__NetLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
13888 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
13889 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
13890 G__memfunc_setup("StreamerNVirtual",1656,G__G__Net_252_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
13891 G__memfunc_setup("DeclFileName",1145,G__G__Net_252_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSecContextCleanup::DeclFileName) ), 0);
13892 G__memfunc_setup("ImplFileLine",1178,G__G__Net_252_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TSecContextCleanup::ImplFileLine) ), 0);
13893 G__memfunc_setup("ImplFileName",1171,G__G__Net_252_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSecContextCleanup::ImplFileName) ), 0);
13894 G__memfunc_setup("DeclFileLine",1152,G__G__Net_252_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TSecContextCleanup::DeclFileLine) ), 0);
13895
13896 G__memfunc_setup("TSecContextCleanup", 1820, G__G__Net_252_0_17, (int) ('i'), G__get_linked_tagnum(&G__G__NetLN_TSecContextCleanup), -1, 0, 1, 1, 1, 0, "u 'TSecContextCleanup' - 11 - -", (char*) NULL, (void*) NULL, 0);
13897
13898 G__memfunc_setup("~TSecContextCleanup", 1946, G__G__Net_252_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
13899
13900 G__memfunc_setup("operator=", 937, G__G__Net_252_0_19, (int) ('u'), G__get_linked_tagnum(&G__G__NetLN_TSecContextCleanup), -1, 1, 1, 1, 1, 0, "u 'TSecContextCleanup' - 11 - -", (char*) NULL, (void*) NULL, 0);
13901 G__tag_memfunc_reset();
13902 }
13903
13904 static void G__setup_memfuncTPServerSocket(void) {
13905
13906 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__NetLN_TPServerSocket));
13907 G__memfunc_setup("TPServerSocket",1412,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__NetLN_TPServerSocket), -1, 0, 1, 1, 4, 0, "u 'TPServerSocket' - 11 - -", "not implemented", (void*) NULL, 0);
13908 G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "u 'TPServerSocket' - 11 - -", "idem", (void*) NULL, 0);
13909 G__memfunc_setup("TPServerSocket",1412,G__G__Net_271_0_3, 105, G__get_linked_tagnum(&G__G__NetLN_TPServerSocket), -1, 0, 4, 1, 1, 0,
13910 "i - 'Int_t' 0 - port g - 'Bool_t' 0 'kFALSE' reuse "
13911 "i - 'Int_t' 0 'kDefaultBacklog' backlog i - 'Int_t' 0 '-1' tcpwindowsize", (char*)NULL, (void*) NULL, 0);
13912 G__memfunc_setup("TPServerSocket",1412,G__G__Net_271_0_4, 105, G__get_linked_tagnum(&G__G__NetLN_TPServerSocket), -1, 0, 4, 1, 1, 0,
13913 "C - - 10 - service g - 'Bool_t' 0 'kFALSE' reuse "
13914 "i - 'Int_t' 0 'kDefaultBacklog' backlog i - 'Int_t' 0 '-1' tcpwindowsize", (char*)NULL, (void*) NULL, 0);
13915 G__memfunc_setup("Accept",592,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__NetLN_TSocket), -1, 0, 1, 1, 1, 0, "b - 'UChar_t' 0 'kSrvNoAuth' Opt", (char*)NULL, (void*) NULL, 1);
13916 G__memfunc_setup("Class",502,G__G__Net_271_0_6, 85, G__get_linked_tagnum(&G__G__NetLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TPServerSocket::Class) ), 0);
13917 G__memfunc_setup("Class_Name",982,G__G__Net_271_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPServerSocket::Class_Name) ), 0);
13918 G__memfunc_setup("Class_Version",1339,G__G__Net_271_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TPServerSocket::Class_Version) ), 0);
13919 G__memfunc_setup("Dictionary",1046,G__G__Net_271_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TPServerSocket::Dictionary) ), 0);
13920 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__NetLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
13921 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
13922 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
13923 G__memfunc_setup("StreamerNVirtual",1656,G__G__Net_271_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
13924 G__memfunc_setup("DeclFileName",1145,G__G__Net_271_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPServerSocket::DeclFileName) ), 0);
13925 G__memfunc_setup("ImplFileLine",1178,G__G__Net_271_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPServerSocket::ImplFileLine) ), 0);
13926 G__memfunc_setup("ImplFileName",1171,G__G__Net_271_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPServerSocket::ImplFileName) ), 0);
13927 G__memfunc_setup("DeclFileLine",1152,G__G__Net_271_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPServerSocket::DeclFileLine) ), 0);
13928
13929 G__memfunc_setup("~TPServerSocket", 1538, G__G__Net_271_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
13930 G__tag_memfunc_reset();
13931 }
13932
13933 static void G__setup_memfuncTSQLColumnInfo(void) {
13934
13935 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__NetLN_TSQLColumnInfo));
13936 G__memfunc_setup("TSQLColumnInfo",1342,G__G__Net_272_0_1, 105, G__get_linked_tagnum(&G__G__NetLN_TSQLColumnInfo), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
13937 G__memfunc_setup("TSQLColumnInfo",1342,G__G__Net_272_0_2, 105, G__get_linked_tagnum(&G__G__NetLN_TSQLColumnInfo), -1, 0, 8, 1, 1, 0,
13938 "C - - 10 - columnname C - - 10 '\"unknown\"' sqltypename "
13939 "g - 'Bool_t' 0 'kFALSE' nullable i - 'Int_t' 0 '-1' sqltype "
13940 "i - 'Int_t' 0 '-1' size i - 'Int_t' 0 '-1' length "
13941 "i - 'Int_t' 0 '-1' scale i - 'Int_t' 0 '-1' sign", (char*)NULL, (void*) NULL, 0);
13942 G__memfunc_setup("GetTypeName",1091,G__G__Net_272_0_3, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
13943 G__memfunc_setup("IsNullable",1003,G__G__Net_272_0_4, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
13944 G__memfunc_setup("GetSQLType",946,G__G__Net_272_0_5, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
13945 G__memfunc_setup("GetSize",699,G__G__Net_272_0_6, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
13946 G__memfunc_setup("GetLength",898,G__G__Net_272_0_7, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
13947 G__memfunc_setup("GetScale",776,G__G__Net_272_0_8, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
13948 G__memfunc_setup("GetSigned",890,G__G__Net_272_0_9, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
13949 G__memfunc_setup("IsSigned",790,G__G__Net_272_0_10, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
13950 G__memfunc_setup("IsUnsigned",1017,G__G__Net_272_0_11, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
13951 G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
13952 G__memfunc_setup("Class",502,G__G__Net_272_0_13, 85, G__get_linked_tagnum(&G__G__NetLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TSQLColumnInfo::Class) ), 0);
13953 G__memfunc_setup("Class_Name",982,G__G__Net_272_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSQLColumnInfo::Class_Name) ), 0);
13954 G__memfunc_setup("Class_Version",1339,G__G__Net_272_0_15, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TSQLColumnInfo::Class_Version) ), 0);
13955 G__memfunc_setup("Dictionary",1046,G__G__Net_272_0_16, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TSQLColumnInfo::Dictionary) ), 0);
13956 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__NetLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
13957 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
13958 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
13959 G__memfunc_setup("StreamerNVirtual",1656,G__G__Net_272_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
13960 G__memfunc_setup("DeclFileName",1145,G__G__Net_272_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSQLColumnInfo::DeclFileName) ), 0);
13961 G__memfunc_setup("ImplFileLine",1178,G__G__Net_272_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TSQLColumnInfo::ImplFileLine) ), 0);
13962 G__memfunc_setup("ImplFileName",1171,G__G__Net_272_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSQLColumnInfo::ImplFileName) ), 0);
13963 G__memfunc_setup("DeclFileLine",1152,G__G__Net_272_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TSQLColumnInfo::DeclFileLine) ), 0);
13964
13965 G__memfunc_setup("TSQLColumnInfo", 1342, G__G__Net_272_0_25, (int) ('i'), G__get_linked_tagnum(&G__G__NetLN_TSQLColumnInfo), -1, 0, 1, 1, 1, 0, "u 'TSQLColumnInfo' - 11 - -", (char*) NULL, (void*) NULL, 0);
13966
13967 G__memfunc_setup("~TSQLColumnInfo", 1468, G__G__Net_272_0_26, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
13968
13969 G__memfunc_setup("operator=", 937, G__G__Net_272_0_27, (int) ('u'), G__get_linked_tagnum(&G__G__NetLN_TSQLColumnInfo), -1, 1, 1, 1, 1, 0, "u 'TSQLColumnInfo' - 11 - -", (char*) NULL, (void*) NULL, 0);
13970 G__tag_memfunc_reset();
13971 }
13972
13973 static void G__setup_memfuncTSQLServer(void) {
13974
13975 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__NetLN_TSQLServer));
13976 G__memfunc_setup("ClearError",1009,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
13977 G__memfunc_setup("SetError",822,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 2, 0,
13978 "i - 'Int_t' 0 - code C - - 10 - msg "
13979 "C - - 10 '0' method", (char*)NULL, (void*) NULL, 0);
13980 G__memfunc_setup("Close",502,G__G__Net_275_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 3);
13981 G__memfunc_setup("Query",534,G__G__Net_275_0_5, 85, G__get_linked_tagnum(&G__G__NetLN_TSQLResult), -1, 0, 1, 1, 1, 0, "C - - 10 - sql", (char*)NULL, (void*) NULL, 3);
13982 G__memfunc_setup("Exec",389,G__G__Net_275_0_6, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "C - - 10 - sql", (char*)NULL, (void*) NULL, 1);
13983 G__memfunc_setup("Statement",949,G__G__Net_275_0_7, 85, G__get_linked_tagnum(&G__G__NetLN_TSQLStatement), -1, 0, 2, 1, 1, 0,
13984 "C - - 10 - - i - 'Int_t' 0 '100' -", (char*)NULL, (void*) NULL, 1);
13985 G__memfunc_setup("HasStatement",1233,G__G__Net_275_0_8, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
13986 G__memfunc_setup("SelectDataBase",1365,G__G__Net_275_0_9, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "C - - 10 - dbname", (char*)NULL, (void*) NULL, 3);
13987 G__memfunc_setup("GetDataBases",1160,G__G__Net_275_0_10, 85, G__get_linked_tagnum(&G__G__NetLN_TSQLResult), -1, 0, 1, 1, 1, 0, "C - - 10 '0' wild", (char*)NULL, (void*) NULL, 3);
13988 G__memfunc_setup("GetTables",891,G__G__Net_275_0_11, 85, G__get_linked_tagnum(&G__G__NetLN_TSQLResult), -1, 0, 2, 1, 1, 0,
13989 "C - - 10 - dbname C - - 10 '0' wild", (char*)NULL, (void*) NULL, 3);
13990 G__memfunc_setup("GetTablesList",1303,G__G__Net_275_0_12, 85, G__get_linked_tagnum(&G__G__NetLN_TList), -1, 0, 1, 1, 1, 0, "C - - 10 '0' wild", (char*)NULL, (void*) NULL, 1);
13991 G__memfunc_setup("HasTable",772,G__G__Net_275_0_13, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "C - - 10 - tablename", (char*)NULL, (void*) NULL, 1);
13992 G__memfunc_setup("GetTableInfo",1172,G__G__Net_275_0_14, 85, G__get_linked_tagnum(&G__G__NetLN_TSQLTableInfo), -1, 0, 1, 1, 1, 0, "C - - 10 - tablename", (char*)NULL, (void*) NULL, 1);
13993 G__memfunc_setup("GetColumns",1025,G__G__Net_275_0_15, 85, G__get_linked_tagnum(&G__G__NetLN_TSQLResult), -1, 0, 3, 1, 1, 0,
13994 "C - - 10 - dbname C - - 10 - table "
13995 "C - - 10 '0' wild", (char*)NULL, (void*) NULL, 3);
13996 G__memfunc_setup("GetMaxIdentifierLength",2219,G__G__Net_275_0_16, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
13997 G__memfunc_setup("CreateDataBase",1353,G__G__Net_275_0_17, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "C - - 10 - dbname", (char*)NULL, (void*) NULL, 3);
13998 G__memfunc_setup("DropDataBase",1162,G__G__Net_275_0_18, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "C - - 10 - dbname", (char*)NULL, (void*) NULL, 3);
13999 G__memfunc_setup("Reload",599,G__G__Net_275_0_19, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
14000 G__memfunc_setup("Shutdown",860,G__G__Net_275_0_20, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
14001 G__memfunc_setup("ServerInfo",1027,G__G__Net_275_0_21, 67, -1, -1, 0, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 3);
14002 G__memfunc_setup("IsConnected",1103,G__G__Net_275_0_22, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14003 G__memfunc_setup("GetDBMS",582,G__G__Net_275_0_23, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
14004 G__memfunc_setup("GetDB",422,G__G__Net_275_0_24, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
14005 G__memfunc_setup("GetHost",702,G__G__Net_275_0_25, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
14006 G__memfunc_setup("GetPort",709,G__G__Net_275_0_26, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
14007 G__memfunc_setup("IsError",710,G__G__Net_275_0_27, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14008 G__memfunc_setup("GetErrorCode",1189,G__G__Net_275_0_28, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14009 G__memfunc_setup("GetErrorMsg",1105,G__G__Net_275_0_29, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
14010 G__memfunc_setup("EnableErrorOutput",1762,G__G__Net_275_0_30, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' on", (char*)NULL, (void*) NULL, 1);
14011 G__memfunc_setup("StartTransaction",1684,G__G__Net_275_0_31, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
14012 G__memfunc_setup("Commit",617,G__G__Net_275_0_32, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
14013 G__memfunc_setup("Rollback",810,G__G__Net_275_0_33, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
14014 G__memfunc_setup("PingVerify",1027,G__G__Net_275_0_34, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
14015 G__memfunc_setup("Ping",398,G__G__Net_275_0_35, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
14016 G__memfunc_setup("Connect",714,G__G__Net_275_0_36, 85, G__get_linked_tagnum(&G__G__NetLN_TSQLServer), -1, 0, 3, 3, 1, 0,
14017 "C - - 10 - db C - - 10 - uid "
14018 "C - - 10 - pw", (char*)NULL, (void*) G__func2void( (TSQLServer* (*)(const char*, const char*, const char*))(&TSQLServer::Connect) ), 0);
14019 G__memfunc_setup("SetFloatFormat",1419,G__G__Net_275_0_37, 121, -1, -1, 0, 1, 3, 1, 0, "C - - 10 '\"%e\"' fmt", (char*)NULL, (void*) G__func2void( (void (*)(const char*))(&TSQLServer::SetFloatFormat) ), 0);
14020 G__memfunc_setup("GetFloatFormat",1407,G__G__Net_275_0_38, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSQLServer::GetFloatFormat) ), 0);
14021 G__memfunc_setup("Class",502,G__G__Net_275_0_39, 85, G__get_linked_tagnum(&G__G__NetLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TSQLServer::Class) ), 0);
14022 G__memfunc_setup("Class_Name",982,G__G__Net_275_0_40, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSQLServer::Class_Name) ), 0);
14023 G__memfunc_setup("Class_Version",1339,G__G__Net_275_0_41, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TSQLServer::Class_Version) ), 0);
14024 G__memfunc_setup("Dictionary",1046,G__G__Net_275_0_42, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TSQLServer::Dictionary) ), 0);
14025 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__NetLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14026 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
14027 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
14028 G__memfunc_setup("StreamerNVirtual",1656,G__G__Net_275_0_46, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
14029 G__memfunc_setup("DeclFileName",1145,G__G__Net_275_0_47, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSQLServer::DeclFileName) ), 0);
14030 G__memfunc_setup("ImplFileLine",1178,G__G__Net_275_0_48, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TSQLServer::ImplFileLine) ), 0);
14031 G__memfunc_setup("ImplFileName",1171,G__G__Net_275_0_49, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSQLServer::ImplFileName) ), 0);
14032 G__memfunc_setup("DeclFileLine",1152,G__G__Net_275_0_50, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TSQLServer::DeclFileLine) ), 0);
14033
14034 G__memfunc_setup("~TSQLServer", 1081, G__G__Net_275_0_51, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
14035
14036 G__memfunc_setup("operator=", 937, G__G__Net_275_0_52, (int) ('u'), G__get_linked_tagnum(&G__G__NetLN_TSQLServer), -1, 1, 1, 1, 1, 0, "u 'TSQLServer' - 11 - -", (char*) NULL, (void*) NULL, 0);
14037 G__tag_memfunc_reset();
14038 }
14039
14040 static void G__setup_memfuncTSQLMonitoringWriter(void) {
14041
14042 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__NetLN_TSQLMonitoringWriter));
14043 G__memfunc_setup("TSQLMonitoringWriter",2023,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__NetLN_TSQLMonitoringWriter), -1, 0, 1, 1, 4, 0, "u 'TSQLMonitoringWriter' - 11 - -", "not implemented", (void*) NULL, 0);
14044 G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__NetLN_TSQLMonitoringWriter), -1, 1, 1, 1, 4, 0, "u 'TSQLMonitoringWriter' - 11 - -", "not implemented", (void*) NULL, 0);
14045 G__memfunc_setup("TSQLMonitoringWriter",2023,G__G__Net_276_0_3, 105, G__get_linked_tagnum(&G__G__NetLN_TSQLMonitoringWriter), -1, 0, 4, 1, 1, 0,
14046 "C - - 10 - serv C - - 10 - user "
14047 "C - - 10 - pass C - - 10 - table", (char*)NULL, (void*) NULL, 0);
14048 G__memfunc_setup("SendParameters",1438,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0,
14049 "U 'TList' - 0 - values C - - 10 - -", (char*)NULL, (void*) NULL, 1);
14050 G__memfunc_setup("Class",502,G__G__Net_276_0_5, 85, G__get_linked_tagnum(&G__G__NetLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TSQLMonitoringWriter::Class) ), 0);
14051 G__memfunc_setup("Class_Name",982,G__G__Net_276_0_6, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSQLMonitoringWriter::Class_Name) ), 0);
14052 G__memfunc_setup("Class_Version",1339,G__G__Net_276_0_7, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TSQLMonitoringWriter::Class_Version) ), 0);
14053 G__memfunc_setup("Dictionary",1046,G__G__Net_276_0_8, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TSQLMonitoringWriter::Dictionary) ), 0);
14054 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__NetLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14055 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
14056 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
14057 G__memfunc_setup("StreamerNVirtual",1656,G__G__Net_276_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
14058 G__memfunc_setup("DeclFileName",1145,G__G__Net_276_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSQLMonitoringWriter::DeclFileName) ), 0);
14059 G__memfunc_setup("ImplFileLine",1178,G__G__Net_276_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TSQLMonitoringWriter::ImplFileLine) ), 0);
14060 G__memfunc_setup("ImplFileName",1171,G__G__Net_276_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSQLMonitoringWriter::ImplFileName) ), 0);
14061 G__memfunc_setup("DeclFileLine",1152,G__G__Net_276_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TSQLMonitoringWriter::DeclFileLine) ), 0);
14062
14063 G__memfunc_setup("~TSQLMonitoringWriter", 2149, G__G__Net_276_0_17, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
14064 G__tag_memfunc_reset();
14065 }
14066
14067 static void G__setup_memfuncTSQLRow(void) {
14068
14069 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__NetLN_TSQLRow));
14070 G__memfunc_setup("Close",502,G__G__Net_277_0_2, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 3);
14071 G__memfunc_setup("GetFieldLength",1382,G__G__Net_277_0_3, 107, -1, G__defined_typename("ULong_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - field", (char*)NULL, (void*) NULL, 3);
14072 G__memfunc_setup("GetField",772,G__G__Net_277_0_4, 67, -1, -1, 0, 1, 1, 1, 1, "i - 'Int_t' 0 - field", (char*)NULL, (void*) NULL, 3);
14073 G__memfunc_setup("operator[]",1060,G__G__Net_277_0_5, 67, -1, -1, 0, 1, 1, 1, 1, "i - 'Int_t' 0 - field", (char*)NULL, (void*) NULL, 0);
14074 G__memfunc_setup("Class",502,G__G__Net_277_0_6, 85, G__get_linked_tagnum(&G__G__NetLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TSQLRow::Class) ), 0);
14075 G__memfunc_setup("Class_Name",982,G__G__Net_277_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSQLRow::Class_Name) ), 0);
14076 G__memfunc_setup("Class_Version",1339,G__G__Net_277_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TSQLRow::Class_Version) ), 0);
14077 G__memfunc_setup("Dictionary",1046,G__G__Net_277_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TSQLRow::Dictionary) ), 0);
14078 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__NetLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14079 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
14080 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
14081 G__memfunc_setup("StreamerNVirtual",1656,G__G__Net_277_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
14082 G__memfunc_setup("DeclFileName",1145,G__G__Net_277_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSQLRow::DeclFileName) ), 0);
14083 G__memfunc_setup("ImplFileLine",1178,G__G__Net_277_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TSQLRow::ImplFileLine) ), 0);
14084 G__memfunc_setup("ImplFileName",1171,G__G__Net_277_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSQLRow::ImplFileName) ), 0);
14085 G__memfunc_setup("DeclFileLine",1152,G__G__Net_277_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TSQLRow::DeclFileLine) ), 0);
14086
14087 G__memfunc_setup("~TSQLRow", 762, G__G__Net_277_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
14088
14089 G__memfunc_setup("operator=", 937, G__G__Net_277_0_19, (int) ('u'), G__get_linked_tagnum(&G__G__NetLN_TSQLRow), -1, 1, 1, 1, 1, 0, "u 'TSQLRow' - 11 - -", (char*) NULL, (void*) NULL, 0);
14090 G__tag_memfunc_reset();
14091 }
14092
14093 static void G__setup_memfuncTSQLResult(void) {
14094
14095 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__NetLN_TSQLResult));
14096 G__memfunc_setup("Close",502,G__G__Net_278_0_2, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 3);
14097 G__memfunc_setup("GetFieldCount",1293,G__G__Net_278_0_3, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
14098 G__memfunc_setup("GetFieldName",1157,G__G__Net_278_0_4, 67, -1, -1, 0, 1, 1, 1, 1, "i - 'Int_t' 0 - field", (char*)NULL, (void*) NULL, 3);
14099 G__memfunc_setup("GetRowCount",1121,G__G__Net_278_0_5, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14100 G__memfunc_setup("Next",415,G__G__Net_278_0_6, 85, G__get_linked_tagnum(&G__G__NetLN_TSQLRow), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
14101 G__memfunc_setup("Class",502,G__G__Net_278_0_7, 85, G__get_linked_tagnum(&G__G__NetLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TSQLResult::Class) ), 0);
14102 G__memfunc_setup("Class_Name",982,G__G__Net_278_0_8, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSQLResult::Class_Name) ), 0);
14103 G__memfunc_setup("Class_Version",1339,G__G__Net_278_0_9, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TSQLResult::Class_Version) ), 0);
14104 G__memfunc_setup("Dictionary",1046,G__G__Net_278_0_10, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TSQLResult::Dictionary) ), 0);
14105 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__NetLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14106 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
14107 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
14108 G__memfunc_setup("StreamerNVirtual",1656,G__G__Net_278_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
14109 G__memfunc_setup("DeclFileName",1145,G__G__Net_278_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSQLResult::DeclFileName) ), 0);
14110 G__memfunc_setup("ImplFileLine",1178,G__G__Net_278_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TSQLResult::ImplFileLine) ), 0);
14111 G__memfunc_setup("ImplFileName",1171,G__G__Net_278_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSQLResult::ImplFileName) ), 0);
14112 G__memfunc_setup("DeclFileLine",1152,G__G__Net_278_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TSQLResult::DeclFileLine) ), 0);
14113
14114 G__memfunc_setup("~TSQLResult", 1089, G__G__Net_278_0_19, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
14115
14116 G__memfunc_setup("operator=", 937, G__G__Net_278_0_20, (int) ('u'), G__get_linked_tagnum(&G__G__NetLN_TSQLResult), -1, 1, 1, 1, 1, 0, "u 'TSQLResult' - 11 - -", (char*) NULL, (void*) NULL, 0);
14117 G__tag_memfunc_reset();
14118 }
14119
14120 static void G__setup_memfuncTSQLStatement(void) {
14121
14122 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__NetLN_TSQLStatement));
14123 G__memfunc_setup("ClearError",1009,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
14124 G__memfunc_setup("SetError",822,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 2, 0,
14125 "i - 'Int_t' 0 - code C - - 10 - msg "
14126 "C - - 10 '0' method", (char*)NULL, (void*) NULL, 0);
14127 G__memfunc_setup("GetBufferLength",1500,G__G__Net_279_0_4, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
14128 G__memfunc_setup("GetNumParameters",1636,G__G__Net_279_0_5, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
14129 G__memfunc_setup("NextIteration",1358,G__G__Net_279_0_6, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
14130 G__memfunc_setup("SetNull",711,G__G__Net_279_0_7, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
14131 G__memfunc_setup("SetInt",599,G__G__Net_279_0_8, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0,
14132 "i - 'Int_t' 0 - - i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
14133 G__memfunc_setup("SetUInt",684,G__G__Net_279_0_9, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0,
14134 "i - 'Int_t' 0 - - h - 'UInt_t' 0 - -", (char*)NULL, (void*) NULL, 1);
14135 G__memfunc_setup("SetLong",700,G__G__Net_279_0_10, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0,
14136 "i - 'Int_t' 0 - - l - 'Long_t' 0 - -", (char*)NULL, (void*) NULL, 1);
14137 G__memfunc_setup("SetLong64",806,G__G__Net_279_0_11, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0,
14138 "i - 'Int_t' 0 - - n - 'Long64_t' 0 - -", (char*)NULL, (void*) NULL, 1);
14139 G__memfunc_setup("SetULong64",891,G__G__Net_279_0_12, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0,
14140 "i - 'Int_t' 0 - - m - 'ULong64_t' 0 - -", (char*)NULL, (void*) NULL, 1);
14141 G__memfunc_setup("SetDouble",903,G__G__Net_279_0_13, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0,
14142 "i - 'Int_t' 0 - - d - 'Double_t' 0 - -", (char*)NULL, (void*) NULL, 1);
14143 G__memfunc_setup("SetString",931,G__G__Net_279_0_14, 103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0,
14144 "i - 'Int_t' 0 - - C - - 10 - - "
14145 "i - 'Int_t' 0 '256' -", (char*)NULL, (void*) NULL, 1);
14146 G__memfunc_setup("SetDate",682,G__G__Net_279_0_15, 103, -1, G__defined_typename("Bool_t"), 0, 4, 1, 1, 0,
14147 "i - 'Int_t' 0 - - i - 'Int_t' 0 - - "
14148 "i - 'Int_t' 0 - - i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
14149 G__memfunc_setup("SetDate",682,G__G__Net_279_0_16, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0,
14150 "i - 'Int_t' 0 - - u 'TDatime' - 11 - -", (char*)NULL, (void*) NULL, 0);
14151 G__memfunc_setup("SetTime",699,G__G__Net_279_0_17, 103, -1, G__defined_typename("Bool_t"), 0, 4, 1, 1, 0,
14152 "i - 'Int_t' 0 - - i - 'Int_t' 0 - - "
14153 "i - 'Int_t' 0 - - i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
14154 G__memfunc_setup("SetTime",699,G__G__Net_279_0_18, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0,
14155 "i - 'Int_t' 0 - - u 'TDatime' - 11 - -", (char*)NULL, (void*) NULL, 0);
14156 G__memfunc_setup("SetDatime",896,G__G__Net_279_0_19, 103, -1, G__defined_typename("Bool_t"), 0, 7, 1, 1, 0,
14157 "i - 'Int_t' 0 - - i - 'Int_t' 0 - - "
14158 "i - 'Int_t' 0 - - i - 'Int_t' 0 - - "
14159 "i - 'Int_t' 0 - - i - 'Int_t' 0 - - "
14160 "i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
14161 G__memfunc_setup("SetDatime",896,G__G__Net_279_0_20, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0,
14162 "i - 'Int_t' 0 - - u 'TDatime' - 11 - -", (char*)NULL, (void*) NULL, 0);
14163 G__memfunc_setup("SetTimestamp",1248,G__G__Net_279_0_21, 103, -1, G__defined_typename("Bool_t"), 0, 8, 1, 1, 0,
14164 "i - 'Int_t' 0 - - i - 'Int_t' 0 - - "
14165 "i - 'Int_t' 0 - - i - 'Int_t' 0 - - "
14166 "i - 'Int_t' 0 - - i - 'Int_t' 0 - - "
14167 "i - 'Int_t' 0 - - i - 'Int_t' 0 '0' -", (char*)NULL, (void*) NULL, 1);
14168 G__memfunc_setup("SetTimestamp",1248,G__G__Net_279_0_22, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0,
14169 "i - 'Int_t' 0 - - u 'TDatime' - 11 - -", (char*)NULL, (void*) NULL, 0);
14170 G__memfunc_setup("SetTimeFormating",1634,G__G__Net_279_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - -", (char*)NULL, (void*) NULL, 1);
14171 G__memfunc_setup("SetBinary",913,G__G__Net_279_0_24, 103, -1, G__defined_typename("Bool_t"), 0, 4, 1, 1, 0,
14172 "i - 'Int_t' 0 - - Y - - 0 - - "
14173 "l - 'Long_t' 0 - - l - 'Long_t' 0 '0x1000' -", (char*)NULL, (void*) NULL, 1);
14174 G__memfunc_setup("Process",735,G__G__Net_279_0_25, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
14175 G__memfunc_setup("GetNumAffectedRows",1805,G__G__Net_279_0_26, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
14176 G__memfunc_setup("StoreResult",1164,G__G__Net_279_0_27, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
14177 G__memfunc_setup("GetNumFields",1191,G__G__Net_279_0_28, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
14178 G__memfunc_setup("GetFieldName",1157,G__G__Net_279_0_29, 67, -1, -1, 0, 1, 1, 1, 1, "i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 3);
14179 G__memfunc_setup("SetMaxFieldSize",1489,G__G__Net_279_0_30, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0,
14180 "i - 'Int_t' 0 - - l - 'Long_t' 0 - -", (char*)NULL, (void*) NULL, 1);
14181 G__memfunc_setup("NextResultRow",1366,G__G__Net_279_0_31, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
14182 G__memfunc_setup("IsNull",599,G__G__Net_279_0_32, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
14183 G__memfunc_setup("GetInt",587,G__G__Net_279_0_33, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
14184 G__memfunc_setup("GetUInt",672,G__G__Net_279_0_34, 104, -1, G__defined_typename("UInt_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
14185 G__memfunc_setup("GetLong",688,G__G__Net_279_0_35, 108, -1, G__defined_typename("Long_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
14186 G__memfunc_setup("GetLong64",794,G__G__Net_279_0_36, 110, -1, G__defined_typename("Long64_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
14187 G__memfunc_setup("GetULong64",879,G__G__Net_279_0_37, 109, -1, G__defined_typename("ULong64_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
14188 G__memfunc_setup("GetDouble",891,G__G__Net_279_0_38, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
14189 G__memfunc_setup("GetString",919,G__G__Net_279_0_39, 67, -1, -1, 0, 1, 1, 1, 1, "i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
14190 G__memfunc_setup("GetBinary",901,G__G__Net_279_0_40, 103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0,
14191 "i - 'Int_t' 0 - - Y - - 1 - - "
14192 "l - 'Long_t' 1 - -", (char*)NULL, (void*) NULL, 1);
14193 G__memfunc_setup("GetDate",670,G__G__Net_279_0_41, 103, -1, G__defined_typename("Bool_t"), 0, 4, 1, 1, 0,
14194 "i - 'Int_t' 0 - - i - 'Int_t' 1 - - "
14195 "i - 'Int_t' 1 - - i - 'Int_t' 1 - -", (char*)NULL, (void*) NULL, 1);
14196 G__memfunc_setup("GetTime",687,G__G__Net_279_0_42, 103, -1, G__defined_typename("Bool_t"), 0, 4, 1, 1, 0,
14197 "i - 'Int_t' 0 - - i - 'Int_t' 1 - - "
14198 "i - 'Int_t' 1 - - i - 'Int_t' 1 - -", (char*)NULL, (void*) NULL, 1);
14199 G__memfunc_setup("GetDatime",884,G__G__Net_279_0_43, 103, -1, G__defined_typename("Bool_t"), 0, 7, 1, 1, 0,
14200 "i - 'Int_t' 0 - - i - 'Int_t' 1 - - "
14201 "i - 'Int_t' 1 - - i - 'Int_t' 1 - - "
14202 "i - 'Int_t' 1 - - i - 'Int_t' 1 - - "
14203 "i - 'Int_t' 1 - -", (char*)NULL, (void*) NULL, 1);
14204 G__memfunc_setup("GetDatime",884,G__G__Net_279_0_44, 117, G__get_linked_tagnum(&G__G__NetLN_TDatime), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 0);
14205 G__memfunc_setup("GetYear",689,G__G__Net_279_0_45, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 0);
14206 G__memfunc_setup("GetMonth",806,G__G__Net_279_0_46, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 0);
14207 G__memfunc_setup("GetDay",574,G__G__Net_279_0_47, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 0);
14208 G__memfunc_setup("GetHour",702,G__G__Net_279_0_48, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 0);
14209 G__memfunc_setup("GetMinute",914,G__G__Net_279_0_49, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 0);
14210 G__memfunc_setup("GetSecond",892,G__G__Net_279_0_50, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 0);
14211 G__memfunc_setup("GetTimestamp",1236,G__G__Net_279_0_51, 103, -1, G__defined_typename("Bool_t"), 0, 8, 1, 1, 0,
14212 "i - 'Int_t' 0 - - i - 'Int_t' 1 - - "
14213 "i - 'Int_t' 1 - - i - 'Int_t' 1 - - "
14214 "i - 'Int_t' 1 - - i - 'Int_t' 1 - - "
14215 "i - 'Int_t' 1 - - i - 'Int_t' 1 - -", (char*)NULL, (void*) NULL, 1);
14216 G__memfunc_setup("GetTimestamp",1236,G__G__Net_279_0_52, 117, G__get_linked_tagnum(&G__G__NetLN_TDatime), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 0);
14217 G__memfunc_setup("IsError",710,G__G__Net_279_0_53, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14218 G__memfunc_setup("GetErrorCode",1189,G__G__Net_279_0_54, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14219 G__memfunc_setup("GetErrorMsg",1105,G__G__Net_279_0_55, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
14220 G__memfunc_setup("EnableErrorOutput",1762,G__G__Net_279_0_56, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' on", (char*)NULL, (void*) NULL, 1);
14221 G__memfunc_setup("Class",502,G__G__Net_279_0_57, 85, G__get_linked_tagnum(&G__G__NetLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TSQLStatement::Class) ), 0);
14222 G__memfunc_setup("Class_Name",982,G__G__Net_279_0_58, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSQLStatement::Class_Name) ), 0);
14223 G__memfunc_setup("Class_Version",1339,G__G__Net_279_0_59, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TSQLStatement::Class_Version) ), 0);
14224 G__memfunc_setup("Dictionary",1046,G__G__Net_279_0_60, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TSQLStatement::Dictionary) ), 0);
14225 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__NetLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14226 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
14227 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
14228 G__memfunc_setup("StreamerNVirtual",1656,G__G__Net_279_0_64, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
14229 G__memfunc_setup("DeclFileName",1145,G__G__Net_279_0_65, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSQLStatement::DeclFileName) ), 0);
14230 G__memfunc_setup("ImplFileLine",1178,G__G__Net_279_0_66, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TSQLStatement::ImplFileLine) ), 0);
14231 G__memfunc_setup("ImplFileName",1171,G__G__Net_279_0_67, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSQLStatement::ImplFileName) ), 0);
14232 G__memfunc_setup("DeclFileLine",1152,G__G__Net_279_0_68, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TSQLStatement::DeclFileLine) ), 0);
14233
14234 G__memfunc_setup("~TSQLStatement", 1399, G__G__Net_279_0_69, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
14235
14236 G__memfunc_setup("operator=", 937, G__G__Net_279_0_70, (int) ('u'), G__get_linked_tagnum(&G__G__NetLN_TSQLStatement), -1, 1, 1, 1, 1, 0, "u 'TSQLStatement' - 11 - -", (char*) NULL, (void*) NULL, 0);
14237 G__tag_memfunc_reset();
14238 }
14239
14240 static void G__setup_memfuncTSQLTableInfo(void) {
14241
14242 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__NetLN_TSQLTableInfo));
14243 G__memfunc_setup("TSQLTableInfo",1208,G__G__Net_280_0_1, 105, G__get_linked_tagnum(&G__G__NetLN_TSQLTableInfo), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
14244 G__memfunc_setup("TSQLTableInfo",1208,G__G__Net_280_0_2, 105, G__get_linked_tagnum(&G__G__NetLN_TSQLTableInfo), -1, 0, 6, 1, 1, 0,
14245 "C - - 10 - tablename U 'TList' - 0 - columns "
14246 "C - - 10 '\"SQL table\"' comment C - - 10 '0' engine "
14247 "C - - 10 '0' create_time C - - 10 '0' update_time", (char*)NULL, (void*) NULL, 0);
14248 G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
14249 G__memfunc_setup("GetColumns",1025,G__G__Net_280_0_4, 85, G__get_linked_tagnum(&G__G__NetLN_TList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
14250 G__memfunc_setup("FindColumn",1007,G__G__Net_280_0_5, 85, G__get_linked_tagnum(&G__G__NetLN_TSQLColumnInfo), -1, 0, 1, 1, 1, 0, "C - - 10 - columnname", (char*)NULL, (void*) NULL, 0);
14251 G__memfunc_setup("GetEngine",886,G__G__Net_280_0_6, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
14252 G__memfunc_setup("GetCreateTime",1283,G__G__Net_280_0_7, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
14253 G__memfunc_setup("GetUpdateTime",1298,G__G__Net_280_0_8, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
14254 G__memfunc_setup("Class",502,G__G__Net_280_0_9, 85, G__get_linked_tagnum(&G__G__NetLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TSQLTableInfo::Class) ), 0);
14255 G__memfunc_setup("Class_Name",982,G__G__Net_280_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSQLTableInfo::Class_Name) ), 0);
14256 G__memfunc_setup("Class_Version",1339,G__G__Net_280_0_11, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TSQLTableInfo::Class_Version) ), 0);
14257 G__memfunc_setup("Dictionary",1046,G__G__Net_280_0_12, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TSQLTableInfo::Dictionary) ), 0);
14258 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__NetLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14259 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
14260 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
14261 G__memfunc_setup("StreamerNVirtual",1656,G__G__Net_280_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
14262 G__memfunc_setup("DeclFileName",1145,G__G__Net_280_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSQLTableInfo::DeclFileName) ), 0);
14263 G__memfunc_setup("ImplFileLine",1178,G__G__Net_280_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TSQLTableInfo::ImplFileLine) ), 0);
14264 G__memfunc_setup("ImplFileName",1171,G__G__Net_280_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSQLTableInfo::ImplFileName) ), 0);
14265 G__memfunc_setup("DeclFileLine",1152,G__G__Net_280_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TSQLTableInfo::DeclFileLine) ), 0);
14266
14267 G__memfunc_setup("TSQLTableInfo", 1208, G__G__Net_280_0_21, (int) ('i'), G__get_linked_tagnum(&G__G__NetLN_TSQLTableInfo), -1, 0, 1, 1, 1, 0, "u 'TSQLTableInfo' - 11 - -", (char*) NULL, (void*) NULL, 0);
14268
14269 G__memfunc_setup("~TSQLTableInfo", 1334, G__G__Net_280_0_22, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
14270
14271 G__memfunc_setup("operator=", 937, G__G__Net_280_0_23, (int) ('u'), G__get_linked_tagnum(&G__G__NetLN_TSQLTableInfo), -1, 1, 1, 1, 1, 0, "u 'TSQLTableInfo' - 11 - -", (char*) NULL, (void*) NULL, 0);
14272 G__tag_memfunc_reset();
14273 }
14274
14275 static void G__setup_memfuncTWebFile(void) {
14276
14277 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__NetLN_TWebFile));
14278 G__memfunc_setup("TWebFile",754,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__NetLN_TWebFile), -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
14279 G__memfunc_setup("Init",404,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "g - 'Bool_t' 0 - readHeadOnly", (char*)NULL, (void*) NULL, 1);
14280 G__memfunc_setup("CheckProxy",1024,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
14281 G__memfunc_setup("BasicAuthentication",1954,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__NetLN_TString), -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
14282 G__memfunc_setup("GetHead",658,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
14283 G__memfunc_setup("GetLine",680,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 4, 0,
14284 "U 'TSocket' - 0 - s C - - 0 - line "
14285 "i - 'Int_t' 0 - maxsize", (char*)NULL, (void*) NULL, 0);
14286 G__memfunc_setup("GetHunk",694,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 4, 0,
14287 "U 'TSocket' - 0 - s C - - 0 - hunk "
14288 "i - 'Int_t' 0 - maxsize", (char*)NULL, (void*) NULL, 0);
14289 G__memfunc_setup("HttpTerminator",1477,(G__InterfaceMethod) NULL, 67, -1, -1, 0, 3, 1, 4, 1,
14290 "C - - 10 - start C - - 10 - peeked "
14291 "i - 'Int_t' 0 - peeklen", (char*)NULL, (void*) NULL, 0);
14292 G__memfunc_setup("GetFromWeb",978,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 4, 0,
14293 "C - - 0 - buf i - 'Int_t' 0 - len "
14294 "u 'TString' - 11 - msg", (char*)NULL, (void*) NULL, 0);
14295 G__memfunc_setup("GetFromWeb10",1075,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 4, 0,
14296 "C - - 0 - buf i - 'Int_t' 0 - len "
14297 "u 'TString' - 11 - msg", (char*)NULL, (void*) NULL, 0);
14298 G__memfunc_setup("ReadBuffer10",1079,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 4, 0,
14299 "C - - 0 - buf i - 'Int_t' 0 - len", (char*)NULL, (void*) NULL, 0);
14300 G__memfunc_setup("ReadBuffers10",1194,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 4, 1, 4, 0,
14301 "C - - 0 - buf N - 'Long64_t' 0 - pos "
14302 "I - 'Int_t' 0 - len i - 'Int_t' 0 - nbuf", (char*)NULL, (void*) NULL, 0);
14303 G__memfunc_setup("SetMsgReadBuffer10",1674,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 0,
14304 "C - - 10 '0' redirectLocation g - 'Bool_t' 0 'kFALSE' tempRedirect", (char*)NULL, (void*) NULL, 0);
14305 G__memfunc_setup("TWebFile",754,G__G__Net_283_0_14, 105, G__get_linked_tagnum(&G__G__NetLN_TWebFile), -1, 0, 2, 1, 1, 0,
14306 "C - - 10 - url C - 'Option_t' 10 '\"\"' opt", (char*)NULL, (void*) NULL, 0);
14307 G__memfunc_setup("TWebFile",754,G__G__Net_283_0_15, 105, G__get_linked_tagnum(&G__G__NetLN_TWebFile), -1, 0, 2, 1, 1, 0,
14308 "u 'TUrl' - 0 - url C - 'Option_t' 10 '\"\"' opt", (char*)NULL, (void*) NULL, 0);
14309 G__memfunc_setup("GetSize",699,(G__InterfaceMethod) NULL,110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14310 G__memfunc_setup("IsOpen",590,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14311 G__memfunc_setup("ReOpen",585,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "C - 'Option_t' 10 - mode", (char*)NULL, (void*) NULL, 1);
14312 G__memfunc_setup("ReadBuffer",982,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0,
14313 "C - - 0 - buf i - 'Int_t' 0 - len", (char*)NULL, (void*) NULL, 1);
14314 G__memfunc_setup("ReadBuffer",982,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0,
14315 "C - - 0 - buf n - 'Long64_t' 0 - pos "
14316 "i - 'Int_t' 0 - len", (char*)NULL, (void*) NULL, 1);
14317 G__memfunc_setup("ReadBuffers",1097,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 4, 1, 1, 0,
14318 "C - - 0 - buf N - 'Long64_t' 0 - pos "
14319 "I - 'Int_t' 0 - len i - 'Int_t' 0 - nbuf", (char*)NULL, (void*) NULL, 1);
14320 G__memfunc_setup("Seek",392,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0,
14321 "n - 'Long64_t' 0 - offset i 'TFile::ERelativeTo' - 0 'kBeg' pos", (char*)NULL, (void*) NULL, 1);
14322 G__memfunc_setup("SetProxy",846,G__G__Net_283_0_23, 121, -1, -1, 0, 1, 3, 1, 0, "C - - 10 - url", (char*)NULL, (void*) G__func2void( (void (*)(const char*))(&TWebFile::SetProxy) ), 0);
14323 G__memfunc_setup("GetProxy",834,G__G__Net_283_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TWebFile::GetProxy) ), 0);
14324 G__memfunc_setup("Class",502,G__G__Net_283_0_25, 85, G__get_linked_tagnum(&G__G__NetLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TWebFile::Class) ), 0);
14325 G__memfunc_setup("Class_Name",982,G__G__Net_283_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TWebFile::Class_Name) ), 0);
14326 G__memfunc_setup("Class_Version",1339,G__G__Net_283_0_27, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TWebFile::Class_Version) ), 0);
14327 G__memfunc_setup("Dictionary",1046,G__G__Net_283_0_28, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TWebFile::Dictionary) ), 0);
14328 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__NetLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14329 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
14330 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
14331 G__memfunc_setup("StreamerNVirtual",1656,G__G__Net_283_0_32, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
14332 G__memfunc_setup("DeclFileName",1145,G__G__Net_283_0_33, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TWebFile::DeclFileName) ), 0);
14333 G__memfunc_setup("ImplFileLine",1178,G__G__Net_283_0_34, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TWebFile::ImplFileLine) ), 0);
14334 G__memfunc_setup("ImplFileName",1171,G__G__Net_283_0_35, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TWebFile::ImplFileName) ), 0);
14335 G__memfunc_setup("DeclFileLine",1152,G__G__Net_283_0_36, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TWebFile::DeclFileLine) ), 0);
14336
14337 G__memfunc_setup("~TWebFile", 880, G__G__Net_283_0_37, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
14338 G__tag_memfunc_reset();
14339 }
14340
14341 static void G__setup_memfuncTWebSystem(void) {
14342
14343 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__NetLN_TWebSystem));
14344 G__memfunc_setup("GetDirPtr",885,(G__InterfaceMethod) NULL, 89, -1, -1, 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 1);
14345 G__memfunc_setup("TWebSystem",1015,G__G__Net_284_0_2, 105, G__get_linked_tagnum(&G__G__NetLN_TWebSystem), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
14346 G__memfunc_setup("MakeDirectory",1331,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
14347 G__memfunc_setup("OpenDirectory",1351,(G__InterfaceMethod) NULL,89, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
14348 G__memfunc_setup("FreeDirectory",1335,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "Y - - 0 - dirp", (char*)NULL, (void*) NULL, 1);
14349 G__memfunc_setup("GetDirEntry",1105,(G__InterfaceMethod) NULL,67, -1, -1, 0, 1, 1, 1, 1, "Y - - 0 - dirp", (char*)NULL, (void*) NULL, 1);
14350 G__memfunc_setup("GetPathInfo",1081,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0,
14351 "C - - 10 - path u 'FileStat_t' - 1 - buf", (char*)NULL, (void*) NULL, 1);
14352 G__memfunc_setup("AccessPathName",1376,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0,
14353 "C - - 10 - path i 'EAccessMode' - 0 - mode", (char*)NULL, (void*) NULL, 1);
14354 G__memfunc_setup("Unlink",625,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "C - - 10 - path", (char*)NULL, (void*) NULL, 1);
14355 G__memfunc_setup("Class",502,G__G__Net_284_0_10, 85, G__get_linked_tagnum(&G__G__NetLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TWebSystem::Class) ), 0);
14356 G__memfunc_setup("Class_Name",982,G__G__Net_284_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TWebSystem::Class_Name) ), 0);
14357 G__memfunc_setup("Class_Version",1339,G__G__Net_284_0_12, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TWebSystem::Class_Version) ), 0);
14358 G__memfunc_setup("Dictionary",1046,G__G__Net_284_0_13, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TWebSystem::Dictionary) ), 0);
14359 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__NetLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14360 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
14361 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
14362 G__memfunc_setup("StreamerNVirtual",1656,G__G__Net_284_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
14363 G__memfunc_setup("DeclFileName",1145,G__G__Net_284_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TWebSystem::DeclFileName) ), 0);
14364 G__memfunc_setup("ImplFileLine",1178,G__G__Net_284_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TWebSystem::ImplFileLine) ), 0);
14365 G__memfunc_setup("ImplFileName",1171,G__G__Net_284_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TWebSystem::ImplFileName) ), 0);
14366 G__memfunc_setup("DeclFileLine",1152,G__G__Net_284_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TWebSystem::DeclFileLine) ), 0);
14367
14368 G__memfunc_setup("~TWebSystem", 1141, G__G__Net_284_0_22, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
14369 G__tag_memfunc_reset();
14370 }
14371
14372
14373
14374
14375
14376 extern "C" void G__cpp_setup_memfuncG__Net() {
14377 }
14378
14379
14380
14381
14382 static void G__cpp_setup_global0() {
14383
14384
14385 G__resetplocal();
14386
14387 }
14388
14389 static void G__cpp_setup_global1() {
14390 }
14391
14392 static void G__cpp_setup_global2() {
14393 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kMESS_ZIP=536870912",0,(char*)NULL);
14394 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kMESS_ACK=268435456",0,(char*)NULL);
14395 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kMESS_ANY=0",0,(char*)NULL);
14396 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kMESS_OK=1",0,(char*)NULL);
14397 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kMESS_NOTOK=2",0,(char*)NULL);
14398 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kMESS_STRING=3",0,(char*)NULL);
14399 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kMESS_OBJECT=4",0,(char*)NULL);
14400 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kMESS_CINT=5",0,(char*)NULL);
14401 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kMESS_STREAMERINFO=6",0,(char*)NULL);
14402 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kMESS_PROCESSID=7",0,(char*)NULL);
14403 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_GROUPVIEW=1000",0,(char*)NULL);
14404 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_STOP=1001",0,(char*)NULL);
14405 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_FATAL=1002",0,(char*)NULL);
14406 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_LOGLEVEL=1003",0,(char*)NULL);
14407 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_LOGFILE=1004",0,(char*)NULL);
14408 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_LOGDONE=1005",0,(char*)NULL);
14409 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_STATUS=1006",0,(char*)NULL);
14410 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_PING=1007",0,(char*)NULL);
14411 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_PRINT=1008",0,(char*)NULL);
14412 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_RESET=1009",0,(char*)NULL);
14413 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_GETOBJECT=1010",0,(char*)NULL);
14414 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_GETPACKET=1011",0,(char*)NULL);
14415 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_CHECKFILE=1012",0,(char*)NULL);
14416 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_SENDFILE=1013",0,(char*)NULL);
14417 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_PARALLEL=1014",0,(char*)NULL);
14418 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_PROCESS=1015",0,(char*)NULL);
14419 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_OUTPUTLIST=1016",0,(char*)NULL);
14420 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_AUTOBIN=1017",0,(char*)NULL);
14421 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_CACHE=1018",0,(char*)NULL);
14422 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_GETENTRIES=1019",0,(char*)NULL);
14423 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_PROGRESS=1020",0,(char*)NULL);
14424 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_FEEDBACK=1021",0,(char*)NULL);
14425 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_STOPPROCESS=1022",0,(char*)NULL);
14426 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_HOSTAUTH=1023",0,(char*)NULL);
14427 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_GETSLAVEINFO=1024",0,(char*)NULL);
14428 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_GETTREEHEADER=1025",0,(char*)NULL);
14429 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_GETOUTPUTLIST=1026",0,(char*)NULL);
14430 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_GETSTATS=1027",0,(char*)NULL);
14431 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_GETPARALLEL=1028",0,(char*)NULL);
14432 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_VALIDATE_DSET=1029",0,(char*)NULL);
14433 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_DATA_READY=1030",0,(char*)NULL);
14434 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_QUERYLIST=1031",0,(char*)NULL);
14435 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_RETRIEVE=1032",0,(char*)NULL);
14436 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_ARCHIVE=1033",0,(char*)NULL);
14437 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_REMOVE=1034",0,(char*)NULL);
14438 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_STARTPROCESS=1035",0,(char*)NULL);
14439 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_SETIDLE=1036",0,(char*)NULL);
14440 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_QUERYSUBMITTED=1037",0,(char*)NULL);
14441 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_SESSIONTAG=1038",0,(char*)NULL);
14442 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_MAXQUERIES=1039",0,(char*)NULL);
14443 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_CLEANUPSESSION=1040",0,(char*)NULL);
14444 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_SERVERSTARTED=1041",0,(char*)NULL);
14445 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_DATASETS=1042",0,(char*)NULL);
14446 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_PACKAGE_LIST=1043",0,(char*)NULL);
14447 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_MESSAGE=1044",0,(char*)NULL);
14448 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_LIB_INC_PATH=1045",0,(char*)NULL);
14449 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_WORKERLISTS=1046",0,(char*)NULL);
14450 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_DATASET_STATUS=1047",0,(char*)NULL);
14451 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_OUTPUTOBJECT=1048",0,(char*)NULL);
14452 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_SETENV=1049",0,(char*)NULL);
14453 }
14454
14455 static void G__cpp_setup_global3() {
14456 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_REALTIMELOG=1050",0,(char*)NULL);
14457 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_VERSARCHCOMP=1051",0,(char*)NULL);
14458 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_ENDINIT=1052",0,(char*)NULL);
14459 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_TOUCH=1053",0,(char*)NULL);
14460 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_FORK=1054",0,(char*)NULL);
14461 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_GOASYNC=1055",0,(char*)NULL);
14462 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kPROOF_SUBMERGER=1056",0,(char*)NULL);
14463 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kROOTD_USER=2000",0,(char*)NULL);
14464 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kROOTD_PASS=2001",0,(char*)NULL);
14465 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kROOTD_AUTH=2002",0,(char*)NULL);
14466 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kROOTD_FSTAT=2003",0,(char*)NULL);
14467 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kROOTD_OPEN=2004",0,(char*)NULL);
14468 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kROOTD_PUT=2005",0,(char*)NULL);
14469 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kROOTD_GET=2006",0,(char*)NULL);
14470 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kROOTD_FLUSH=2007",0,(char*)NULL);
14471 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kROOTD_CLOSE=2008",0,(char*)NULL);
14472 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kROOTD_STAT=2009",0,(char*)NULL);
14473 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kROOTD_ACK=2010",0,(char*)NULL);
14474 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kROOTD_ERR=2011",0,(char*)NULL);
14475 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kROOTD_PROTOCOL=2012",0,(char*)NULL);
14476 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kROOTD_SRPUSER=2013",0,(char*)NULL);
14477 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kROOTD_SRPN=2014",0,(char*)NULL);
14478 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kROOTD_SRPG=2015",0,(char*)NULL);
14479 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kROOTD_SRPSALT=2016",0,(char*)NULL);
14480 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kROOTD_SRPA=2017",0,(char*)NULL);
14481 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kROOTD_SRPB=2018",0,(char*)NULL);
14482 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kROOTD_SRPRESPONSE=2019",0,(char*)NULL);
14483 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kROOTD_PUTFILE=2020",0,(char*)NULL);
14484 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kROOTD_GETFILE=2021",0,(char*)NULL);
14485 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kROOTD_CHDIR=2022",0,(char*)NULL);
14486 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kROOTD_MKDIR=2023",0,(char*)NULL);
14487 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kROOTD_RMDIR=2024",0,(char*)NULL);
14488 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kROOTD_LSDIR=2025",0,(char*)NULL);
14489 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kROOTD_PWD=2026",0,(char*)NULL);
14490 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kROOTD_MV=2027",0,(char*)NULL);
14491 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kROOTD_RM=2028",0,(char*)NULL);
14492 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kROOTD_CHMOD=2029",0,(char*)NULL);
14493 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kROOTD_KRB5=2030",0,(char*)NULL);
14494 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kROOTD_PROTOCOL2=2031",0,(char*)NULL);
14495 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kROOTD_BYE=2032",0,(char*)NULL);
14496 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kROOTD_GLOBUS=2033",0,(char*)NULL);
14497 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kROOTD_CLEANUP=2034",0,(char*)NULL);
14498 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kROOTD_SSH=2035",0,(char*)NULL);
14499 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kROOTD_RFIO=2036",0,(char*)NULL);
14500 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kROOTD_NEGOTIA=2037",0,(char*)NULL);
14501 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kROOTD_RSAKEY=2038",0,(char*)NULL);
14502 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kROOTD_ENCRYPT=2039",0,(char*)NULL);
14503 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kROOTD_OPENDIR=2040",0,(char*)NULL);
14504 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kROOTD_FREEDIR=2041",0,(char*)NULL);
14505 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kROOTD_DIRENTRY=2042",0,(char*)NULL);
14506 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kROOTD_ACCESS=2043",0,(char*)NULL);
14507 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_EMessageTypes),-1,-1,1,"kROOTD_GETS=2044",0,(char*)NULL);
14508 }
14509
14510 static void G__cpp_setup_global4() {
14511 G__memvar_setup((void*)(&gGrid),85,0,0,G__get_linked_tagnum(&G__G__NetLN_TGrid),-1,-1,1,"gGrid=",0,(char*)NULL);
14512 G__memvar_setup((void*)(&gGridJobStatusList),85,0,0,G__get_linked_tagnum(&G__G__NetLN_TGridJobStatusList),-1,-1,1,"gGridJobStatusList=",0,(char*)NULL);
14513 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_ESockOptions),-1,-1,1,"kSendBuffer=0",0,(char*)NULL);
14514 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_ESockOptions),-1,-1,1,"kRecvBuffer=1",0,(char*)NULL);
14515 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_ESockOptions),-1,-1,1,"kOobInline=2",0,(char*)NULL);
14516 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_ESockOptions),-1,-1,1,"kKeepAlive=3",0,(char*)NULL);
14517 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_ESockOptions),-1,-1,1,"kReuseAddr=4",0,(char*)NULL);
14518 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_ESockOptions),-1,-1,1,"kNoDelay=5",0,(char*)NULL);
14519 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_ESockOptions),-1,-1,1,"kNoBlock=6",0,(char*)NULL);
14520 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_ESockOptions),-1,-1,1,"kProcessGroup=7",0,(char*)NULL);
14521 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_ESockOptions),-1,-1,1,"kAtMark=8",0,(char*)NULL);
14522 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_ESockOptions),-1,-1,1,"kBytesToRead=9",0,(char*)NULL);
14523 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_ESendRecvOptions),-1,-1,1,"kDefault=0",0,(char*)NULL);
14524 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_ESendRecvOptions),-1,-1,1,"kOob=1",0,(char*)NULL);
14525 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_ESendRecvOptions),-1,-1,1,"kPeek=2",0,(char*)NULL);
14526 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__NetLN_ESendRecvOptions),-1,-1,1,"kDontBlock=3",0,(char*)NULL);
14527 G__memvar_setup((void*)(&kSrvAuth),98,0,1,-1,G__defined_typename("UChar_t"),-1,1,"kSrvAuth=",0,(char*)NULL);
14528 G__memvar_setup((void*)(&kSrvNoAuth),98,0,1,-1,G__defined_typename("UChar_t"),-1,1,"kSrvNoAuth=",0,(char*)NULL);
14529
14530 G__resetglobalenv();
14531 }
14532 extern "C" void G__cpp_setup_globalG__Net() {
14533 G__cpp_setup_global0();
14534 G__cpp_setup_global1();
14535 G__cpp_setup_global2();
14536 G__cpp_setup_global3();
14537 G__cpp_setup_global4();
14538 }
14539
14540
14541
14542
14543 static void G__cpp_setup_func0() {
14544 G__lastifuncposition();
14545
14546 }
14547
14548 static void G__cpp_setup_func1() {
14549 }
14550
14551 static void G__cpp_setup_func2() {
14552 }
14553
14554 static void G__cpp_setup_func3() {
14555 }
14556
14557 static void G__cpp_setup_func4() {
14558 }
14559
14560 static void G__cpp_setup_func5() {
14561 }
14562
14563 static void G__cpp_setup_func6() {
14564
14565 G__resetifuncposition();
14566 }
14567
14568 extern "C" void G__cpp_setup_funcG__Net() {
14569 G__cpp_setup_func0();
14570 G__cpp_setup_func1();
14571 G__cpp_setup_func2();
14572 G__cpp_setup_func3();
14573 G__cpp_setup_func4();
14574 G__cpp_setup_func5();
14575 G__cpp_setup_func6();
14576 }
14577
14578
14579
14580
14581
14582 G__linked_taginfo G__G__NetLN_TClass = { "TClass" , 99 , -1 };
14583 G__linked_taginfo G__G__NetLN_TBuffer = { "TBuffer" , 99 , -1 };
14584 G__linked_taginfo G__G__NetLN_TDirectory = { "TDirectory" , 99 , -1 };
14585 G__linked_taginfo G__G__NetLN_TMemberInspector = { "TMemberInspector" , 99 , -1 };
14586 G__linked_taginfo G__G__NetLN_TObject = { "TObject" , 99 , -1 };
14587 G__linked_taginfo G__G__NetLN_TNamed = { "TNamed" , 99 , -1 };
14588 G__linked_taginfo G__G__NetLN_TString = { "TString" , 99 , -1 };
14589 G__linked_taginfo G__G__NetLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR = { "vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >" , 99 , -1 };
14590 G__linked_taginfo G__G__NetLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR = { "reverse_iterator<vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >::iterator>" , 99 , -1 };
14591 G__linked_taginfo G__G__NetLN_TList = { "TList" , 99 , -1 };
14592 G__linked_taginfo G__G__NetLN_TBrowser = { "TBrowser" , 99 , -1 };
14593 G__linked_taginfo G__G__NetLN_TVirtualStreamerInfo = { "TVirtualStreamerInfo" , 99 , -1 };
14594 G__linked_taginfo G__G__NetLN_TProcessID = { "TProcessID" , 99 , -1 };
14595 G__linked_taginfo G__G__NetLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR = { "vector<TVirtualArray*,allocator<TVirtualArray*> >" , 99 , -1 };
14596 G__linked_taginfo G__G__NetLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TVirtualArray*,allocator<TVirtualArray*> >::iterator>" , 99 , -1 };
14597 G__linked_taginfo G__G__NetLN_TVirtualMutex = { "TVirtualMutex" , 99 , -1 };
14598 G__linked_taginfo G__G__NetLN_TQObject = { "TQObject" , 99 , -1 };
14599 G__linked_taginfo G__G__NetLN_TSignalHandler = { "TSignalHandler" , 99 , -1 };
14600 G__linked_taginfo G__G__NetLN_TApplication = { "TApplication" , 99 , -1 };
14601 G__linked_taginfo G__G__NetLN_TCollection = { "TCollection" , 99 , -1 };
14602 G__linked_taginfo G__G__NetLN_TMap = { "TMap" , 99 , -1 };
14603 G__linked_taginfo G__G__NetLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR = { "iterator<bidirectional_iterator_tag,TObject*,long,const TObject**,const TObject*&>" , 115 , -1 };
14604 G__linked_taginfo G__G__NetLN_THashList = { "THashList" , 99 , -1 };
14605 G__linked_taginfo G__G__NetLN_TUrl = { "TUrl" , 99 , -1 };
14606 G__linked_taginfo G__G__NetLN_TBufferFile = { "TBufferFile" , 99 , -1 };
14607 G__linked_taginfo G__G__NetLN_vectorlETStreamerInfomUcOallocatorlETStreamerInfomUgRsPgR = { "vector<TStreamerInfo*,allocator<TStreamerInfo*> >" , 99 , -1 };
14608 G__linked_taginfo G__G__NetLN_reverse_iteratorlEvectorlETStreamerInfomUcOallocatorlETStreamerInfomUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TStreamerInfo*,allocator<TStreamerInfo*> >::iterator>" , 99 , -1 };
14609 G__linked_taginfo G__G__NetLN_EMessageTypes = { "EMessageTypes" , 101 , -1 };
14610 G__linked_taginfo G__G__NetLN_TBits = { "TBits" , 99 , -1 };
14611 G__linked_taginfo G__G__NetLN_TMessage = { "TMessage" , 99 , -1 };
14612 G__linked_taginfo G__G__NetLN_TSocket = { "TSocket" , 99 , -1 };
14613 G__linked_taginfo G__G__NetLN_TPSocket = { "TPSocket" , 99 , -1 };
14614 G__linked_taginfo G__G__NetLN_TMonitor = { "TMonitor" , 99 , -1 };
14615 G__linked_taginfo G__G__NetLN_TRemoteObject = { "TRemoteObject" , 99 , -1 };
14616 G__linked_taginfo G__G__NetLN_TSeqCollection = { "TSeqCollection" , 99 , -1 };
14617 G__linked_taginfo G__G__NetLN_TApplicationRemote = { "TApplicationRemote" , 99 , -1 };
14618 G__linked_taginfo G__G__NetLN_TApplicationRemotecLcLESendFileOpt = { "TApplicationRemote::ESendFileOpt" , 101 , -1 };
14619 G__linked_taginfo G__G__NetLN_TApplicationRemotecLcLEStatusBits = { "TApplicationRemote::EStatusBits" , 101 , -1 };
14620 G__linked_taginfo G__G__NetLN_TApplicationServer = { "TApplicationServer" , 99 , -1 };
14621 G__linked_taginfo G__G__NetLN_TFileStager = { "TFileStager" , 99 , -1 };
14622 G__linked_taginfo G__G__NetLN_TInetAddress = { "TInetAddress" , 99 , -1 };
14623 G__linked_taginfo G__G__NetLN_TSystem = { "TSystem" , 99 , -1 };
14624 G__linked_taginfo G__G__NetLN_TServerSocket = { "TServerSocket" , 99 , -1 };
14625 G__linked_taginfo G__G__NetLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR = { "vector<unsigned int,allocator<unsigned int> >" , 99 , -1 };
14626 G__linked_taginfo G__G__NetLN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<unsigned int,allocator<unsigned int> >::iterator>" , 99 , -1 };
14627 G__linked_taginfo G__G__NetLN_vectorlETStringcOallocatorlETStringgRsPgR = { "vector<TString,allocator<TString> >" , 99 , -1 };
14628 G__linked_taginfo G__G__NetLN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TString,allocator<TString> >::iterator>" , 99 , -1 };
14629 G__linked_taginfo G__G__NetLN_EAccessMode = { "EAccessMode" , 101 , -1 };
14630 G__linked_taginfo G__G__NetLN_FileStat_t = { "FileStat_t" , 115 , -1 };
14631 G__linked_taginfo G__G__NetLN_TFTP = { "TFTP" , 99 , -1 };
14632 G__linked_taginfo G__G__NetLN_TFTPcLcLdA = { "TFTP::$" , 101 , -1 };
14633 G__linked_taginfo G__G__NetLN_TFile = { "TFile" , 99 , -1 };
14634 G__linked_taginfo G__G__NetLN_TEntryList = { "TEntryList" , 99 , -1 };
14635 G__linked_taginfo G__G__NetLN_TDSet = { "TDSet" , 99 , -1 };
14636 G__linked_taginfo G__G__NetLN_TGridResult = { "TGridResult" , 99 , -1 };
14637 G__linked_taginfo G__G__NetLN_TFileCollection = { "TFileCollection" , 99 , -1 };
14638 G__linked_taginfo G__G__NetLN_TGridCollection = { "TGridCollection" , 99 , -1 };
14639 G__linked_taginfo G__G__NetLN_TGridJobStatus = { "TGridJobStatus" , 99 , -1 };
14640 G__linked_taginfo G__G__NetLN_TGridJob = { "TGridJob" , 99 , -1 };
14641 G__linked_taginfo G__G__NetLN_TGridJDL = { "TGridJDL" , 99 , -1 };
14642 G__linked_taginfo G__G__NetLN_TGridJobStatusList = { "TGridJobStatusList" , 99 , -1 };
14643 G__linked_taginfo G__G__NetLN_TGrid = { "TGrid" , 99 , -1 };
14644 G__linked_taginfo G__G__NetLN_TGridJobStatuscLcLEGridJobStatus = { "TGridJobStatus::EGridJobStatus" , 101 , -1 };
14645 G__linked_taginfo G__G__NetLN_TMonitorcLcLEInterest = { "TMonitor::EInterest" , 101 , -1 };
14646 G__linked_taginfo G__G__NetLN_TDatime = { "TDatime" , 99 , -1 };
14647 G__linked_taginfo G__G__NetLN_TDirectoryFile = { "TDirectoryFile" , 99 , -1 };
14648 G__linked_taginfo G__G__NetLN_TFilecLcLERelativeTo = { "TFile::ERelativeTo" , 101 , -1 };
14649 G__linked_taginfo G__G__NetLN_TNetFile = { "TNetFile" , 99 , -1 };
14650 G__linked_taginfo G__G__NetLN_TNetSystem = { "TNetSystem" , 99 , -1 };
14651 G__linked_taginfo G__G__NetLN_TSecContext = { "TSecContext" , 99 , -1 };
14652 G__linked_taginfo G__G__NetLN_TSecContextCleanup = { "TSecContextCleanup" , 99 , -1 };
14653 G__linked_taginfo G__G__NetLN_TTimeStamp = { "TTimeStamp" , 99 , -1 };
14654 G__linked_taginfo G__G__NetLN_ESockOptions = { "ESockOptions" , 101 , -1 };
14655 G__linked_taginfo G__G__NetLN_ESendRecvOptions = { "ESendRecvOptions" , 101 , -1 };
14656 G__linked_taginfo G__G__NetLN_TSocketcLcLEStatusBits = { "TSocket::EStatusBits" , 101 , -1 };
14657 G__linked_taginfo G__G__NetLN_TSocketcLcLEInterest = { "TSocket::EInterest" , 101 , -1 };
14658 G__linked_taginfo G__G__NetLN_TSocketcLcLEServiceType = { "TSocket::EServiceType" , 101 , -1 };
14659 G__linked_taginfo G__G__NetLN_TServerSocketcLcLdA = { "TServerSocket::$" , 101 , -1 };
14660 G__linked_taginfo G__G__NetLN_TPServerSocket = { "TPServerSocket" , 99 , -1 };
14661 G__linked_taginfo G__G__NetLN_TSQLColumnInfo = { "TSQLColumnInfo" , 99 , -1 };
14662 G__linked_taginfo G__G__NetLN_TVirtualMonitoringWriter = { "TVirtualMonitoringWriter" , 99 , -1 };
14663 G__linked_taginfo G__G__NetLN_TSQLServer = { "TSQLServer" , 99 , -1 };
14664 G__linked_taginfo G__G__NetLN_TSQLMonitoringWriter = { "TSQLMonitoringWriter" , 99 , -1 };
14665 G__linked_taginfo G__G__NetLN_TSQLRow = { "TSQLRow" , 99 , -1 };
14666 G__linked_taginfo G__G__NetLN_TSQLResult = { "TSQLResult" , 99 , -1 };
14667 G__linked_taginfo G__G__NetLN_TSQLStatement = { "TSQLStatement" , 99 , -1 };
14668 G__linked_taginfo G__G__NetLN_TSQLTableInfo = { "TSQLTableInfo" , 99 , -1 };
14669 G__linked_taginfo G__G__NetLN_TSQLServercLcLESQLDataTypes = { "TSQLServer::ESQLDataTypes" , 101 , -1 };
14670 G__linked_taginfo G__G__NetLN_TWebFile = { "TWebFile" , 99 , -1 };
14671 G__linked_taginfo G__G__NetLN_TWebSystem = { "TWebSystem" , 99 , -1 };
14672
14673
14674 extern "C" void G__cpp_reset_tagtableG__Net() {
14675 G__G__NetLN_TClass.tagnum = -1 ;
14676 G__G__NetLN_TBuffer.tagnum = -1 ;
14677 G__G__NetLN_TDirectory.tagnum = -1 ;
14678 G__G__NetLN_TMemberInspector.tagnum = -1 ;
14679 G__G__NetLN_TObject.tagnum = -1 ;
14680 G__G__NetLN_TNamed.tagnum = -1 ;
14681 G__G__NetLN_TString.tagnum = -1 ;
14682 G__G__NetLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR.tagnum = -1 ;
14683 G__G__NetLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR.tagnum = -1 ;
14684 G__G__NetLN_TList.tagnum = -1 ;
14685 G__G__NetLN_TBrowser.tagnum = -1 ;
14686 G__G__NetLN_TVirtualStreamerInfo.tagnum = -1 ;
14687 G__G__NetLN_TProcessID.tagnum = -1 ;
14688 G__G__NetLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR.tagnum = -1 ;
14689 G__G__NetLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR.tagnum = -1 ;
14690 G__G__NetLN_TVirtualMutex.tagnum = -1 ;
14691 G__G__NetLN_TQObject.tagnum = -1 ;
14692 G__G__NetLN_TSignalHandler.tagnum = -1 ;
14693 G__G__NetLN_TApplication.tagnum = -1 ;
14694 G__G__NetLN_TCollection.tagnum = -1 ;
14695 G__G__NetLN_TMap.tagnum = -1 ;
14696 G__G__NetLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR.tagnum = -1 ;
14697 G__G__NetLN_THashList.tagnum = -1 ;
14698 G__G__NetLN_TUrl.tagnum = -1 ;
14699 G__G__NetLN_TBufferFile.tagnum = -1 ;
14700 G__G__NetLN_vectorlETStreamerInfomUcOallocatorlETStreamerInfomUgRsPgR.tagnum = -1 ;
14701 G__G__NetLN_reverse_iteratorlEvectorlETStreamerInfomUcOallocatorlETStreamerInfomUgRsPgRcLcLiteratorgR.tagnum = -1 ;
14702 G__G__NetLN_EMessageTypes.tagnum = -1 ;
14703 G__G__NetLN_TBits.tagnum = -1 ;
14704 G__G__NetLN_TMessage.tagnum = -1 ;
14705 G__G__NetLN_TSocket.tagnum = -1 ;
14706 G__G__NetLN_TPSocket.tagnum = -1 ;
14707 G__G__NetLN_TMonitor.tagnum = -1 ;
14708 G__G__NetLN_TRemoteObject.tagnum = -1 ;
14709 G__G__NetLN_TSeqCollection.tagnum = -1 ;
14710 G__G__NetLN_TApplicationRemote.tagnum = -1 ;
14711 G__G__NetLN_TApplicationRemotecLcLESendFileOpt.tagnum = -1 ;
14712 G__G__NetLN_TApplicationRemotecLcLEStatusBits.tagnum = -1 ;
14713 G__G__NetLN_TApplicationServer.tagnum = -1 ;
14714 G__G__NetLN_TFileStager.tagnum = -1 ;
14715 G__G__NetLN_TInetAddress.tagnum = -1 ;
14716 G__G__NetLN_TSystem.tagnum = -1 ;
14717 G__G__NetLN_TServerSocket.tagnum = -1 ;
14718 G__G__NetLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR.tagnum = -1 ;
14719 G__G__NetLN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR.tagnum = -1 ;
14720 G__G__NetLN_vectorlETStringcOallocatorlETStringgRsPgR.tagnum = -1 ;
14721 G__G__NetLN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR.tagnum = -1 ;
14722 G__G__NetLN_EAccessMode.tagnum = -1 ;
14723 G__G__NetLN_FileStat_t.tagnum = -1 ;
14724 G__G__NetLN_TFTP.tagnum = -1 ;
14725 G__G__NetLN_TFTPcLcLdA.tagnum = -1 ;
14726 G__G__NetLN_TFile.tagnum = -1 ;
14727 G__G__NetLN_TEntryList.tagnum = -1 ;
14728 G__G__NetLN_TDSet.tagnum = -1 ;
14729 G__G__NetLN_TGridResult.tagnum = -1 ;
14730 G__G__NetLN_TFileCollection.tagnum = -1 ;
14731 G__G__NetLN_TGridCollection.tagnum = -1 ;
14732 G__G__NetLN_TGridJobStatus.tagnum = -1 ;
14733 G__G__NetLN_TGridJob.tagnum = -1 ;
14734 G__G__NetLN_TGridJDL.tagnum = -1 ;
14735 G__G__NetLN_TGridJobStatusList.tagnum = -1 ;
14736 G__G__NetLN_TGrid.tagnum = -1 ;
14737 G__G__NetLN_TGridJobStatuscLcLEGridJobStatus.tagnum = -1 ;
14738 G__G__NetLN_TMonitorcLcLEInterest.tagnum = -1 ;
14739 G__G__NetLN_TDatime.tagnum = -1 ;
14740 G__G__NetLN_TDirectoryFile.tagnum = -1 ;
14741 G__G__NetLN_TFilecLcLERelativeTo.tagnum = -1 ;
14742 G__G__NetLN_TNetFile.tagnum = -1 ;
14743 G__G__NetLN_TNetSystem.tagnum = -1 ;
14744 G__G__NetLN_TSecContext.tagnum = -1 ;
14745 G__G__NetLN_TSecContextCleanup.tagnum = -1 ;
14746 G__G__NetLN_TTimeStamp.tagnum = -1 ;
14747 G__G__NetLN_ESockOptions.tagnum = -1 ;
14748 G__G__NetLN_ESendRecvOptions.tagnum = -1 ;
14749 G__G__NetLN_TSocketcLcLEStatusBits.tagnum = -1 ;
14750 G__G__NetLN_TSocketcLcLEInterest.tagnum = -1 ;
14751 G__G__NetLN_TSocketcLcLEServiceType.tagnum = -1 ;
14752 G__G__NetLN_TServerSocketcLcLdA.tagnum = -1 ;
14753 G__G__NetLN_TPServerSocket.tagnum = -1 ;
14754 G__G__NetLN_TSQLColumnInfo.tagnum = -1 ;
14755 G__G__NetLN_TVirtualMonitoringWriter.tagnum = -1 ;
14756 G__G__NetLN_TSQLServer.tagnum = -1 ;
14757 G__G__NetLN_TSQLMonitoringWriter.tagnum = -1 ;
14758 G__G__NetLN_TSQLRow.tagnum = -1 ;
14759 G__G__NetLN_TSQLResult.tagnum = -1 ;
14760 G__G__NetLN_TSQLStatement.tagnum = -1 ;
14761 G__G__NetLN_TSQLTableInfo.tagnum = -1 ;
14762 G__G__NetLN_TSQLServercLcLESQLDataTypes.tagnum = -1 ;
14763 G__G__NetLN_TWebFile.tagnum = -1 ;
14764 G__G__NetLN_TWebSystem.tagnum = -1 ;
14765 }
14766
14767
14768 extern "C" void G__cpp_setup_tagtableG__Net() {
14769
14770
14771 G__get_linked_tagnum_fwd(&G__G__NetLN_TClass);
14772 G__get_linked_tagnum_fwd(&G__G__NetLN_TBuffer);
14773 G__get_linked_tagnum_fwd(&G__G__NetLN_TDirectory);
14774 G__get_linked_tagnum_fwd(&G__G__NetLN_TMemberInspector);
14775 G__get_linked_tagnum_fwd(&G__G__NetLN_TObject);
14776 G__get_linked_tagnum_fwd(&G__G__NetLN_TNamed);
14777 G__get_linked_tagnum_fwd(&G__G__NetLN_TString);
14778 G__get_linked_tagnum_fwd(&G__G__NetLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR);
14779 G__get_linked_tagnum_fwd(&G__G__NetLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR);
14780 G__get_linked_tagnum_fwd(&G__G__NetLN_TList);
14781 G__get_linked_tagnum_fwd(&G__G__NetLN_TBrowser);
14782 G__get_linked_tagnum_fwd(&G__G__NetLN_TVirtualStreamerInfo);
14783 G__get_linked_tagnum_fwd(&G__G__NetLN_TProcessID);
14784 G__get_linked_tagnum_fwd(&G__G__NetLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR);
14785 G__get_linked_tagnum_fwd(&G__G__NetLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR);
14786 G__get_linked_tagnum_fwd(&G__G__NetLN_TVirtualMutex);
14787 G__get_linked_tagnum_fwd(&G__G__NetLN_TQObject);
14788 G__get_linked_tagnum_fwd(&G__G__NetLN_TSignalHandler);
14789 G__get_linked_tagnum_fwd(&G__G__NetLN_TApplication);
14790 G__get_linked_tagnum_fwd(&G__G__NetLN_TCollection);
14791 G__get_linked_tagnum_fwd(&G__G__NetLN_TMap);
14792 G__get_linked_tagnum_fwd(&G__G__NetLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR);
14793 G__get_linked_tagnum_fwd(&G__G__NetLN_THashList);
14794 G__get_linked_tagnum_fwd(&G__G__NetLN_TUrl);
14795 G__get_linked_tagnum_fwd(&G__G__NetLN_TBufferFile);
14796 G__get_linked_tagnum_fwd(&G__G__NetLN_vectorlETStreamerInfomUcOallocatorlETStreamerInfomUgRsPgR);
14797 G__get_linked_tagnum_fwd(&G__G__NetLN_reverse_iteratorlEvectorlETStreamerInfomUcOallocatorlETStreamerInfomUgRsPgRcLcLiteratorgR);
14798 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__NetLN_EMessageTypes),sizeof(int),-1,0,(char*)NULL,NULL,NULL);
14799 G__get_linked_tagnum_fwd(&G__G__NetLN_TBits);
14800 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__NetLN_TMessage),sizeof(TMessage),-1,65280,"Message buffer class",G__setup_memvarTMessage,G__setup_memfuncTMessage);
14801 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__NetLN_TSocket),sizeof(TSocket),-1,65280,"This class implements client sockets",G__setup_memvarTSocket,G__setup_memfuncTSocket);
14802 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__NetLN_TPSocket),sizeof(TPSocket),-1,65024,"Parallel client socket",G__setup_memvarTPSocket,G__setup_memfuncTPSocket);
14803 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__NetLN_TMonitor),sizeof(TMonitor),-1,30464,"Monitor activity on a set of TSocket objects",G__setup_memvarTMonitor,G__setup_memfuncTMonitor);
14804 G__get_linked_tagnum_fwd(&G__G__NetLN_TRemoteObject);
14805 G__get_linked_tagnum_fwd(&G__G__NetLN_TSeqCollection);
14806 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__NetLN_TApplicationRemote),sizeof(TApplicationRemote),-1,62464,"Remote Application Interface",G__setup_memvarTApplicationRemote,G__setup_memfuncTApplicationRemote);
14807 G__get_linked_tagnum_fwd(&G__G__NetLN_TApplicationRemotecLcLESendFileOpt);
14808 G__get_linked_tagnum_fwd(&G__G__NetLN_TApplicationRemotecLcLEStatusBits);
14809 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__NetLN_TApplicationServer),sizeof(TApplicationServer),-1,62464,"Remote Application Interface",G__setup_memvarTApplicationServer,G__setup_memfuncTApplicationServer);
14810 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__NetLN_TFileStager),sizeof(TFileStager),-1,62464,"ABC defining interface to a stager",G__setup_memvarTFileStager,G__setup_memfuncTFileStager);
14811 G__get_linked_tagnum_fwd(&G__G__NetLN_TInetAddress);
14812 G__get_linked_tagnum_fwd(&G__G__NetLN_TSystem);
14813 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__NetLN_TServerSocket),sizeof(TServerSocket),-1,65280,"This class implements server sockets",G__setup_memvarTServerSocket,G__setup_memfuncTServerSocket);
14814 G__get_linked_tagnum_fwd(&G__G__NetLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR);
14815 G__get_linked_tagnum_fwd(&G__G__NetLN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR);
14816 G__get_linked_tagnum_fwd(&G__G__NetLN_vectorlETStringcOallocatorlETStringgRsPgR);
14817 G__get_linked_tagnum_fwd(&G__G__NetLN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR);
14818 G__get_linked_tagnum_fwd(&G__G__NetLN_EAccessMode);
14819 G__get_linked_tagnum_fwd(&G__G__NetLN_FileStat_t);
14820 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__NetLN_TFTP),sizeof(TFTP),-1,65280,"File Transfer Protocol class using rootd",G__setup_memvarTFTP,G__setup_memfuncTFTP);
14821 G__get_linked_tagnum_fwd(&G__G__NetLN_TFTPcLcLdA);
14822 G__get_linked_tagnum_fwd(&G__G__NetLN_TFile);
14823 G__get_linked_tagnum_fwd(&G__G__NetLN_TEntryList);
14824 G__get_linked_tagnum_fwd(&G__G__NetLN_TDSet);
14825 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__NetLN_TGridResult),sizeof(TGridResult),-1,324864,"ABC defining interface to GRID result set",G__setup_memvarTGridResult,G__setup_memfuncTGridResult);
14826 G__get_linked_tagnum_fwd(&G__G__NetLN_TFileCollection);
14827 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__NetLN_TGridCollection),sizeof(TGridCollection),-1,292096,"ABC managing collection of files on the Grid",G__setup_memvarTGridCollection,G__setup_memfuncTGridCollection);
14828 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__NetLN_TGridJobStatus),sizeof(TGridJobStatus),-1,324865,"ABC defining status of a Grid job",G__setup_memvarTGridJobStatus,G__setup_memfuncTGridJobStatus);
14829 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__NetLN_TGridJob),sizeof(TGridJob),-1,324611,"ABC defining interface to a GRID job",G__setup_memvarTGridJob,G__setup_memfuncTGridJob);
14830 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__NetLN_TGridJDL),sizeof(TGridJDL),-1,292115,"ABC defining interface JDL generator",G__setup_memvarTGridJDL,G__setup_memfuncTGridJDL);
14831 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__NetLN_TGridJobStatusList),sizeof(TGridJobStatusList),-1,324864,"ABC defining interface to a list of GRID jobs",G__setup_memvarTGridJobStatusList,G__setup_memfuncTGridJobStatusList);
14832 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__NetLN_TGrid),sizeof(TGrid),-1,29952,"ABC defining interface to GRID services",G__setup_memvarTGrid,G__setup_memfuncTGrid);
14833 G__get_linked_tagnum_fwd(&G__G__NetLN_TGridJobStatuscLcLEGridJobStatus);
14834 G__get_linked_tagnum_fwd(&G__G__NetLN_TMonitorcLcLEInterest);
14835 G__get_linked_tagnum_fwd(&G__G__NetLN_TDatime);
14836 G__get_linked_tagnum_fwd(&G__G__NetLN_TDirectoryFile);
14837 G__get_linked_tagnum_fwd(&G__G__NetLN_TFilecLcLERelativeTo);
14838 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__NetLN_TNetFile),sizeof(TNetFile),-1,65280,"A ROOT file that reads/writes via a rootd server",G__setup_memvarTNetFile,G__setup_memfuncTNetFile);
14839 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__NetLN_TNetSystem),sizeof(TNetSystem),-1,65280,"Directory handler for NetSystem",G__setup_memvarTNetSystem,G__setup_memfuncTNetSystem);
14840 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__NetLN_TSecContext),sizeof(TSecContext),-1,65024,"Class providing host specific authentication information",G__setup_memvarTSecContext,G__setup_memfuncTSecContext);
14841 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__NetLN_TSecContextCleanup),sizeof(TSecContextCleanup),-1,62464,"Update the remote authentication table",G__setup_memvarTSecContextCleanup,G__setup_memfuncTSecContextCleanup);
14842 G__get_linked_tagnum_fwd(&G__G__NetLN_TTimeStamp);
14843 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__NetLN_ESockOptions),sizeof(int),-1,0,(char*)NULL,NULL,NULL);
14844 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__NetLN_ESendRecvOptions),sizeof(int),-1,0,(char*)NULL,NULL,NULL);
14845 G__get_linked_tagnum_fwd(&G__G__NetLN_TSocketcLcLEStatusBits);
14846 G__get_linked_tagnum_fwd(&G__G__NetLN_TSocketcLcLEInterest);
14847 G__get_linked_tagnum_fwd(&G__G__NetLN_TSocketcLcLEServiceType);
14848 G__get_linked_tagnum_fwd(&G__G__NetLN_TServerSocketcLcLdA);
14849 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__NetLN_TPServerSocket),sizeof(TPServerSocket),-1,65024,"Parallel server socket",G__setup_memvarTPServerSocket,G__setup_memfuncTPServerSocket);
14850 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__NetLN_TSQLColumnInfo),sizeof(TSQLColumnInfo),-1,62720,"Summury information about column from SQL table",G__setup_memvarTSQLColumnInfo,G__setup_memfuncTSQLColumnInfo);
14851 G__get_linked_tagnum_fwd(&G__G__NetLN_TVirtualMonitoringWriter);
14852 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__NetLN_TSQLServer),sizeof(TSQLServer),-1,29963,"Connection to SQL server",G__setup_memvarTSQLServer,G__setup_memfuncTSQLServer);
14853 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__NetLN_TSQLMonitoringWriter),sizeof(TSQLMonitoringWriter),-1,65024,"Sending monitoring data to a SQL DB",G__setup_memvarTSQLMonitoringWriter,G__setup_memfuncTSQLMonitoringWriter);
14854 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__NetLN_TSQLRow),sizeof(TSQLRow),-1,29955,"One row of an SQL query result",G__setup_memvarTSQLRow,G__setup_memfuncTSQLRow);
14855 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__NetLN_TSQLResult),sizeof(TSQLResult),-1,29956,"SQL query result",G__setup_memvarTSQLResult,G__setup_memfuncTSQLResult);
14856 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__NetLN_TSQLStatement),sizeof(TSQLStatement),-1,29960,"SQL statement",G__setup_memvarTSQLStatement,G__setup_memfuncTSQLStatement);
14857 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__NetLN_TSQLTableInfo),sizeof(TSQLTableInfo),-1,62720,"Summury information about SQL table",G__setup_memvarTSQLTableInfo,G__setup_memfuncTSQLTableInfo);
14858 G__get_linked_tagnum_fwd(&G__G__NetLN_TSQLServercLcLESQLDataTypes);
14859 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__NetLN_TWebFile),sizeof(TWebFile),-1,62720,"A ROOT file that reads via a http server",G__setup_memvarTWebFile,G__setup_memfuncTWebFile);
14860 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__NetLN_TWebSystem),sizeof(TWebSystem),-1,62720,"Directory handler for HTTP (TWebFiles)",G__setup_memvarTWebSystem,G__setup_memfuncTWebSystem);
14861 }
14862 extern "C" void G__cpp_setupG__Net(void) {
14863 G__check_setup_version(30051515,"G__cpp_setupG__Net()");
14864 G__set_cpp_environmentG__Net();
14865 G__cpp_setup_tagtableG__Net();
14866
14867 G__cpp_setup_inheritanceG__Net();
14868
14869 G__cpp_setup_typetableG__Net();
14870
14871 G__cpp_setup_memvarG__Net();
14872
14873 G__cpp_setup_memfuncG__Net();
14874 G__cpp_setup_globalG__Net();
14875 G__cpp_setup_funcG__Net();
14876
14877 if(0==G__getsizep2memfunc()) G__get_sizep2memfuncG__Net();
14878 return;
14879 }
14880 class G__cpp_setup_initG__Net {
14881 public:
14882 G__cpp_setup_initG__Net() { G__add_setup_func("G__Net",(G__incsetup)(&G__cpp_setupG__Net)); G__call_setup_funcs(); }
14883 ~G__cpp_setup_initG__Net() { G__remove_setup_func("G__Net"); }
14884 };
14885 G__cpp_setup_initG__Net G__cpp_setup_initializerG__Net;
14886
