ROOT  6.07/01
Reference Guide
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Groups Pages
TBufferSQL2.cxx
Go to the documentation of this file.
1 // @(#)root/sql:$Id$
2 // Author: Sergey Linev 20/11/2005
3 
4 /*************************************************************************
5  * Copyright (C) 1995-2005, Rene Brun and Fons Rademakers. *
6  * All rights reserved. *
7  * *
8  * For the licensing terms see $ROOTSYS/LICENSE. *
9  * For the list of contributors see $ROOTSYS/README/CREDITS. *
10  *************************************************************************/
11 
12 /**
13 \class TBufferSQL2
14 \ingroup IO
15 
16 Converts data to SQL statements or read data from SQL tables.
17 
18 Class for serializing/deserializing object to/from SQL data base.
19 It redefines most of TBuffer class function to convert simple types,
20 array of simple types and objects to/from TSQLStructure objects.
21 TBufferSQL2 class uses streaming mechanism, provided by ROOT system,
22 therefore most of ROOT and user classes can be stored. There are
23 limitations for complex objects like TTree, TClonesArray, TDirectory and
24 few other, which can not be converted to SQL (yet).
25 */
26 
27 #include "TBufferSQL2.h"
28 
29 #include "TObjArray.h"
30 #include "TROOT.h"
31 #include "TDataType.h"
32 #include "TClass.h"
33 #include "TClassTable.h"
34 #include "TMap.h"
35 #include "TExMap.h"
36 #include "TMethodCall.h"
37 #include "TStreamerInfo.h"
38 #include "TStreamerElement.h"
39 #include "TProcessID.h"
40 #include "TFile.h"
41 #include "TMemberStreamer.h"
42 #include "TStreamer.h"
43 #include "Riostream.h"
44 #include <stdlib.h>
45 #include "TStreamerInfoActions.h"
46 
47 #include "TSQLServer.h"
48 #include "TSQLResult.h"
49 #include "TSQLRow.h"
50 #include "TSQLStructure.h"
51 #include "TSQLObjectData.h"
52 #include "TSQLFile.h"
53 #include "TSQLClassInfo.h"
54 
55 #ifdef R__VISUAL_CPLUSPLUS
56 #define FLong64 "%I64d"
57 #define FULong64 "%I64u"
58 #else
59 #define FLong64 "%lld"
60 #define FULong64 "%llu"
61 #endif
62 
63 ClassImp(TBufferSQL2);
64 
65 ////////////////////////////////////////////////////////////////////////////////
66 /// Default constructor, should not be used
67 
68 TBufferSQL2::TBufferSQL2() :
69  TBufferFile(),
70  fSQL(0),
71  fStructure(0),
72  fStk(0),
73  fObjMap(0),
74  fReadBuffer(),
75  fErrorFlag(0),
76  fExpectedChain(kFALSE),
77  fCompressLevel(0),
78  fReadVersionBuffer(-1),
79  fObjIdCounter(1),
80  fIgnoreVerification(kFALSE),
81  fCurrentData(0),
82  fObjectsInfos(0),
83  fFirstObjId(0),
84  fLastObjId(0),
85  fPoolsMap(0)
86 {
87 }
88 
89 ////////////////////////////////////////////////////////////////////////////////
90 /// Creates buffer object to serailize/deserialize data to/from sql.
91 /// Mode should be either TBuffer::kRead or TBuffer::kWrite.
92 
93 TBufferSQL2::TBufferSQL2(TBuffer::EMode mode) :
94  TBufferFile(mode),
95  fSQL(0),
96  fStructure(0),
97  fStk(0),
98  fObjMap(0),
99  fReadBuffer(),
100  fErrorFlag(0),
101  fExpectedChain(kFALSE),
102  fCompressLevel(0),
103  fReadVersionBuffer(-1),
104  fObjIdCounter(1),
105  fIgnoreVerification(kFALSE),
106  fCurrentData(0),
107  fObjectsInfos(0),
108  fFirstObjId(0),
109  fLastObjId(0),
110  fPoolsMap(0)
111 {
112  SetParent(0);
113  SetBit(kCannotHandleMemberWiseStreaming);
114  SetBit(kTextBasedStreaming);
115 }
116 
117 ////////////////////////////////////////////////////////////////////////////////
118 /// Creates buffer object to serailize/deserialize data to/from sql.
119 /// This constructor should be used, if data from buffer supposed to be stored in file.
120 /// Mode should be either TBuffer::kRead or TBuffer::kWrite.
121 
122 TBufferSQL2::TBufferSQL2(TBuffer::EMode mode, TSQLFile* file) :
123  TBufferFile(mode),
124  fSQL(0),
125  fStructure(0),
126  fStk(0),
127  fObjMap(0),
128  fReadBuffer(),
129  fErrorFlag(0),
130  fExpectedChain(kFALSE),
131  fCompressLevel(0),
132  fReadVersionBuffer(-1),
133  fObjIdCounter(1),
134  fIgnoreVerification(kFALSE),
135  fCurrentData(0),
136  fObjectsInfos(0),
137  fFirstObjId(0),
138  fLastObjId(0),
139  fPoolsMap(0)
140 {
141  fBufSize = 1000000000;
142 
143  // for TClonesArray recognize if this is special case
144  SetBit(kCannotHandleMemberWiseStreaming);
145  SetBit(kTextBasedStreaming);
146 
147  SetParent(file);
148  fSQL = file;
149  if (file!=0)
150  SetCompressionLevel(file->GetCompressionLevel());
151 }
152 
153 ////////////////////////////////////////////////////////////////////////////////
154 /// Destroy sql buffer.
155 
156 TBufferSQL2::~TBufferSQL2()
157 {
158  if (fObjMap) delete fObjMap;
159 
160  if (fStructure!=0) {
161  delete fStructure;
162  fStructure = 0;
163  }
164 
165  if (fObjectsInfos!=0) {
166  fObjectsInfos->Delete();
167  delete fObjectsInfos;
168  }
169 
170  if (fPoolsMap!=0) {
171  fPoolsMap->DeleteValues();
172  delete fPoolsMap;
173  }
174 }
175 
176 ////////////////////////////////////////////////////////////////////////////////
177 /// Convert object of any class to sql structures
178 /// Return pointer on created TSQLStructure
179 /// TSQLStructure object will be owned by TBufferSQL2
180 
181 TSQLStructure* TBufferSQL2::SqlWriteAny(const void* obj, const TClass* cl, Long64_t objid)
182 {
183  fErrorFlag = 0;
184 
185  fStructure = 0;
186 
187  fFirstObjId = objid;
188  fObjIdCounter = objid;
189 
190  SqlWriteObject(obj, cl);
191 
192  if (gDebug>3)
193  if (fStructure!=0) {
194  std::cout << "==== Printout of Sql structures ===== " << std::endl;
195  fStructure->Print("*");
196  std::cout << "=========== End printout ============ " << std::endl;
197  }
198 
199  return fStructure;
200 }
201 
202 ////////////////////////////////////////////////////////////////////////////////
203 /// Recreate object from sql structure.
204 /// Return pointer to read object.
205 /// if (cl!=0) returns pointer to class of object
206 
207 void* TBufferSQL2::SqlReadAny(Long64_t keyid, Long64_t objid, TClass** cl, void* obj)
208 {
209  if (cl) *cl = 0;
210  if (fSQL==0) return 0;
211 
212  fCurrentData = 0;
213  fErrorFlag = 0;
214 
215  fReadVersionBuffer = -1;
216 
217  fObjectsInfos = fSQL->SQLObjectsInfo(keyid);
218 // fObjectsInfos = 0;
219  fFirstObjId = objid;
220  fLastObjId = objid;
221  if (fObjectsInfos!=0) {
222  TSQLObjectInfo* objinfo = (TSQLObjectInfo*) fObjectsInfos->Last();
223  if (objinfo!=0) fLastObjId = objinfo->GetObjId();
224  }
225 
226  return SqlReadObjectDirect(obj, cl, objid);
227 }
228 
229 ////////////////////////////////////////////////////////////////////////////////
230 /// Returns object info like classname and version
231 /// Should be taken from buffer, which is produced in the begginnig
232 
233 Bool_t TBufferSQL2::SqlObjectInfo(Long64_t objid, TString& clname, Version_t& version)
234 {
235  if ((objid<0) || (fObjectsInfos==0)) return kFALSE;
236 
237  // if (fObjectsInfos==0) return fSQL->SQLObjectInfo(objid, clname, version);
238 
239  // suppose that objects info are sorted out
240 
241  Long64_t shift = objid - fFirstObjId;
242 
243  TSQLObjectInfo* info = 0;
244  if ((shift>=0) && (shift<=fObjectsInfos->GetLast())) {
245  info = (TSQLObjectInfo*) fObjectsInfos->At(shift);
246  if (info->GetObjId()!=objid) info = 0;
247  }
248 
249  if (info==0) {
250  // I hope, i will never get inside it
251  Info("SqlObjectInfo", "Standard not works %lld", objid);
252  for (Int_t n=0;n<=fObjectsInfos->GetLast();n++) {
253  info = (TSQLObjectInfo*) fObjectsInfos->At(n);
254  if (info->GetObjId()==objid) break;
255  info = 0;
256  }
257  }
258 
259  if (info==0) return kFALSE;
260 
261  clname = info->GetObjClassName();
262  version = info->GetObjVersion();
263  return kTRUE;
264 }
265 
266 
267 ////////////////////////////////////////////////////////////////////////////////
268 /// Creates TSQLObjectData for specifed object id and specified class
269 ///
270 /// Object data for each class can be stored in two different tables.
271 /// First table contains data in column-wise form for simple types like integer,
272 /// strings and so on when second table contains any other data which cannot
273 /// be converted into column-wise representation.
274 /// TSQLObjectData will contain results of the requests to both such tables for
275 /// concrete object id.
276 
277 TSQLObjectData* TBufferSQL2::SqlObjectData(Long64_t objid, TSQLClassInfo* sqlinfo)
278 {
279  TSQLResult *classdata = 0;
280  TSQLRow *classrow = 0;
281 
282  if (sqlinfo->IsClassTableExist()) {
283 
284  TSQLObjectDataPool* pool = 0;
285 
286  if (fPoolsMap!=0)
287  pool = (TSQLObjectDataPool*) fPoolsMap->GetValue(sqlinfo);
288 
289  if ((pool==0) && (fLastObjId>=fFirstObjId)) {
290  if (gDebug>4) Info("SqlObjectData","Before request to %s",sqlinfo->GetClassTableName());
291  TSQLResult *alldata = fSQL->GetNormalClassDataAll(fFirstObjId, fLastObjId, sqlinfo);
292  if (gDebug>4) Info("SqlObjectData","After request res = 0x%lx",(Long_t)alldata);
293  if (alldata==0) {
294  Error("SqlObjectData","Cannot get data from table %s",sqlinfo->GetClassTableName());
295  return 0;
296  }
297 
298  if (fPoolsMap==0) fPoolsMap = new TMap();
299  pool = new TSQLObjectDataPool(sqlinfo, alldata);
300  fPoolsMap->Add(sqlinfo, pool);
301  }
302 
303  if (pool==0) return 0;
304 
305  if (pool->GetSqlInfo()!=sqlinfo) {
306  Error("SqlObjectData","Missmatch in pools map !!! CANNOT BE !!!");
307  return 0;
308  }
309 
310  classdata = pool->GetClassData();
311 
312  classrow = pool->GetObjectRow(objid);
313  if (classrow==0) {
314  Error("SqlObjectData","Can not find row for objid = %lld in table %s", objid, sqlinfo->GetClassTableName());
315  return 0;
316  }
317  }
318 
319  TSQLResult *blobdata = 0;
320  TSQLStatement* blobstmt = fSQL->GetBlobClassDataStmt(objid, sqlinfo);
321 
322  if (blobstmt==0) blobdata = fSQL->GetBlobClassData(objid, sqlinfo);
323 
324  return new TSQLObjectData(sqlinfo, objid, classdata, classrow, blobdata, blobstmt);
325 }
326 
327 ////////////////////////////////////////////////////////////////////////////////
328 /// Convert object into sql structures.
329 /// <b>It should be used only by TBufferSQL2 itself</b>
330 /// Use SqlWrite() functions to convert your object to sql
331 /// Redefined here to avoid gcc 3.x warning
332 
333 void TBufferSQL2::WriteObject(const TObject *obj)
334 {
335  TBufferFile::WriteObject(obj);
336 }
337 
338 ////////////////////////////////////////////////////////////////////////////////
339 /// Write object to buffer.
340 /// If object was written before, only pointer will be stored
341 /// Return id of saved object
342 
343 Int_t TBufferSQL2::SqlWriteObject(const void* obj, const TClass* cl, TMemberStreamer *streamer, Int_t streamer_index)
344 {
345  if (gDebug>1)
346  std::cout << " SqlWriteObject " << obj << " : cl = " << (cl ? cl->GetName() : "null") << std::endl;
347 
348  PushStack();
349 
350  Long64_t objid = -1;
351 
352  if (cl==0) obj = 0;
353 
354  if (obj==0)
355  objid = 0;
356  else
357  if (fObjMap!=0) {
358  ULong_t hash = TString::Hash(&obj, sizeof(void*));
359  Long_t value = fObjMap->GetValue(hash, (Long_t) obj);
360  if (value>0)
361  objid = fFirstObjId + value - 1;
362  }
363 
364  if (gDebug>1)
365  std::cout << " Find objectid = " << objid << std::endl;
366 
367  if (objid>=0) {
368  Stack()->SetObjectPointer(objid);
369  PopStack();
370  return objid;
371  }
372 
373  objid = fObjIdCounter++;
374 
375  Stack()->SetObjectRef(objid, cl);
376 
377  ULong_t hash = TString::Hash(&obj, sizeof(void*));
378  if (fObjMap==0) fObjMap = new TExMap();
379  if (fObjMap->GetValue(hash, (Long_t) obj)==0)
380  fObjMap->Add(hash, (Long_t) obj, (Long_t) objid - fFirstObjId + 1);
381 
382  if (streamer!=0)
383  (*streamer)(*this, (void*) obj, streamer_index);
384  else
385  ((TClass*)cl)->Streamer((void*)obj, *this);
386 
387  if (gDebug>1)
388  std::cout << "Done write of " << cl->GetName() << std::endl;
389 
390  PopStack();
391 
392  return objid;
393 }
394 
395 ////////////////////////////////////////////////////////////////////////////////
396 /// Read object from the buffer
397 
398 void* TBufferSQL2::SqlReadObject(void* obj, TClass** cl, TMemberStreamer *streamer, Int_t streamer_index, const TClass *onFileClass)
399 {
400  if (cl) *cl = 0;
401 
402  if (fErrorFlag>0) return obj;
403 
404  Bool_t findptr = kFALSE;
405 
406  const char* refid = fCurrentData->GetValue();
407  if ((refid==0) || (strlen(refid)==0)) {
408  Error("SqlReadObject","Invalid object reference value");
409  fErrorFlag = 1;
410  return obj;
411  }
412 
413  Long64_t objid = -1;
414  sscanf(refid, FLong64, &objid);
415 
416  if (gDebug>2)
417  Info("SqlReadObject","Starting objid = %lld column=%s", objid, fCurrentData->GetLocatedField());
418 
419  if (!fCurrentData->IsBlobData() ||
420  fCurrentData->VerifyDataType(sqlio::ObjectPtr,kFALSE)) {
421  if (objid==0) {
422  obj = 0;
423  findptr = kTRUE;
424  } else {
425  if (objid==-1) {
426  findptr = kTRUE;
427  } else {
428  if ((fObjMap!=0) && (objid>=fFirstObjId)) {
429  void* obj1 = (void*) (Long_t)fObjMap->GetValue((Long_t) objid - fFirstObjId);
430  if (obj1!=0) {
431  obj = obj1;
432  findptr = kTRUE;
433  TString clname;
434  Version_t version;
435  if ((cl!=0) && SqlObjectInfo(objid, clname, version))
436  *cl = TClass::GetClass(clname);
437  }
438  }
439  }
440  }
441  }
442 
443  if ((gDebug>3) && findptr)
444  std::cout << " Found pointer " << (obj ? obj : 0)
445  << " class = " << ((cl && *cl) ? (*cl)->GetName() : "null") << std::endl;
446 
447  if (findptr) {
448  fCurrentData->ShiftToNextValue();
449  return obj;
450  }
451 
452  if (fCurrentData->IsBlobData())
453  if (!fCurrentData->VerifyDataType(sqlio::ObjectRef)) {
454  Error("SqlReadObject","Object reference or pointer is not found in blob data");
455  fErrorFlag = 1;
456  return obj;
457  }
458 
459  fCurrentData->ShiftToNextValue();
460 
461  if ((gDebug>2) || (objid<0))
462  std::cout << "Found object reference " << objid << std::endl;
463 
464  return SqlReadObjectDirect(obj, cl, objid, streamer, streamer_index, onFileClass);
465 }
466 
467 ////////////////////////////////////////////////////////////////////////////////
468 /// Read object data.
469 /// Class name and version are taken from special objects table.
470 
471 void* TBufferSQL2::SqlReadObjectDirect(void* obj, TClass** cl, Long64_t objid, TMemberStreamer *streamer, Int_t streamer_index, const TClass *onFileClass)
472 {
473  TString clname;
474  Version_t version;
475 
476  if (!SqlObjectInfo(objid, clname, version)) return obj;
477 
478  if (gDebug>2)
479  Info("SqlReadObjectDirect","objid = %lld clname = %s ver = %d",objid, clname.Data(), version);
480 
481  TSQLClassInfo* sqlinfo = fSQL->FindSQLClassInfo(clname.Data(), version);
482 
483  TClass* objClass = TClass::GetClass(clname);
484  if (objClass == TDirectory::Class()) objClass = TDirectoryFile::Class();
485 
486  if ((objClass==0) || (sqlinfo==0)) {
487  Error("SqlReadObjectDirect","Class %s is not known", clname.Data());
488  return obj;
489  }
490 
491  if (obj==0) obj = objClass->New();
492 
493  if (fObjMap==0) fObjMap = new TExMap();
494 
495  fObjMap->Add((Long_t) objid - fFirstObjId, (Long_t) obj);
496 
497  PushStack()->SetObjectRef(objid, objClass);
498 
499  TSQLObjectData* olddata = fCurrentData;
500 
501  if (sqlinfo->IsClassTableExist()) {
502  // TObject and TString classes treated differently
503  if ((objClass==TObject::Class()) || (objClass==TString::Class())) {
504 
505  TSQLObjectData* objdata = new TSQLObjectData;
506  if (objClass==TObject::Class())
507  TSQLStructure::UnpackTObject(fSQL, this, objdata, objid, version);
508  else
509  if (objClass==TString::Class())
510  TSQLStructure::UnpackTString(fSQL, this, objdata, objid, version);
511 
512  Stack()->AddObjectData(objdata);
513  fCurrentData = objdata;
514  } else
515  // before normal streamer first version will be read and
516  // then streamer functions of TStreamerInfo class
517  fReadVersionBuffer = version;
518  } else {
519  TSQLObjectData* objdata = SqlObjectData(objid, sqlinfo);
520  if ((objdata==0) || !objdata->PrepareForRawData()) {
521  Error("SqlReadObjectDirect","No found raw data for obj %lld in class %s version %d table", objid, clname.Data(), version);
522  fErrorFlag = 1;
523  return obj;
524  }
525 
526  Stack()->AddObjectData(objdata);
527 
528  fCurrentData = objdata;
529  }
530 
531  if (streamer!=0) {
532  streamer->SetOnFileClass( onFileClass );
533  (*streamer)(*this, (void*)obj, streamer_index);
534  } else {
535  objClass->Streamer((void*)obj, *this, onFileClass);
536  }
537 
538  PopStack();
539 
540  if (gDebug>1)
541  std::cout << "Read object of class " << objClass->GetName() << " done" << std::endl << std::endl;
542 
543  if (cl!=0) *cl = objClass;
544 
545  fCurrentData = olddata;
546 
547  return obj;
548 }
549 
550 ////////////////////////////////////////////////////////////////////////////////
551 /// Function is called from TStreamerInfo WriteBuffer and Readbuffer functions
552 /// and indent new level in data structure.
553 /// This call indicates, that TStreamerInfo functions starts streaming
554 /// object data of correspondent class
555 
556 void TBufferSQL2::IncrementLevel(TVirtualStreamerInfo* info)
557 {
558  if (info==0) return;
559 
560  PushStack()->SetStreamerInfo((TStreamerInfo*)info);
561 
562  if (gDebug>2)
563  std::cout << " IncrementLevel " << info->GetName() << std::endl;
564 
565  WorkWithClass(info->GetName(), info->GetClassVersion());
566 }
567 
568 ////////////////////////////////////////////////////////////////////////////////
569 /// Function is called from TStreamerInfo WriteBuffer and Readbuffer functions
570 /// and decrease level in sql structure.
571 
572 void TBufferSQL2::DecrementLevel(TVirtualStreamerInfo* info)
573 {
574  TSQLStructure* curr = Stack();
575  if (curr->GetElement()) PopStack(); // for element
576  PopStack(); // for streamerinfo
577 
578  // restore value of object data
579  fCurrentData = Stack()->GetObjectData(kTRUE);
580 
581  fExpectedChain = kFALSE;
582 
583  if (gDebug>2)
584  std::cout << " DecrementLevel " << info->GetClass()->GetName() << std::endl;
585 }
586 
587 ////////////////////////////////////////////////////////////////////////////////
588 /// Function is called from TStreamerInfo WriteBuffer and Readbuffer functions
589 /// and add/verify next element in sql tables
590 /// This calls allows separate data, correspondent to one class member, from another
591 
592 void TBufferSQL2::SetStreamerElementNumber(TStreamerElement *elem, Int_t comp_type)
593 {
594  if (Stack()->GetElement()) PopStack(); // was with if (number > 0), i.e. not first element.
595  TSQLStructure* curr = Stack();
596 
597  TStreamerInfo* info = curr->GetStreamerInfo();
598  if (info==0) {
599  Error("SetStreamerElementNumber","Error in structures stack");
600  return;
601  }
602 
603  Int_t elem_type = elem->GetType();
604 
605  fExpectedChain = ((elem_type>0) && (elem_type<20)) &&
606  (comp_type - elem_type == TStreamerInfo::kOffsetL);
607 
608  WorkWithElement(elem, comp_type);
609 }
610 
611 ////////////////////////////////////////////////////////////////////////////////
612 /// This method inform buffer data of which class now
613 /// will be streamed. When reading, classversion should be specified
614 /// as was read by TBuffer::ReadVersion().
615 ///
616 /// ClassBegin(), ClassEnd() & ClassMemeber() should be used in
617 /// custom class streamers to specify which kind of data are
618 /// now streamed to/from buffer. That information is used to correctly
619 /// convert class data to/from "normal" sql tables with meaningfull names
620 /// and correct datatypes. Without that functions data from custom streamer
621 /// will be saved as "raw" data in special _streamer_ table one value after another
622 /// Such MUST be used when object is written with standard ROOT streaming
623 /// procedure, but should be read back in custom streamer.
624 /// For example, custom streamer of TNamed class may look like:
625 
626 void TBufferSQL2::ClassBegin(const TClass* cl, Version_t classversion)
627 {
628 // void TNamed::Streamer(TBuffer &b)
629 // UInt_t R__s, R__c;
630 // if (b.IsReading()) {
631 // Version_t R__v = b.ReadVersion(&R__s, &R__c);
632 // b.ClassBegin(TNamed::Class(), R__v);
633 // b.ClassMember("TObject");
634 // TObject::Streamer(b);
635 // b.ClassMember("fName","TString");
636 // fName.Streamer(b);
637 // b.ClassMember("fTitle","TString");
638 // fTitle.Streamer(b);
639 // b.ClassEnd(TNamed::Class());
640 // b.SetBufferOffset(R__s+R__c+sizeof(UInt_t));
641 // } else {
642 // TNamed::Class()->WriteBuffer(b,this);
643 // }
644 
645  if (classversion<0) classversion = cl->GetClassVersion();
646 
647  PushStack()->SetCustomClass(cl, classversion);
648 
649  if (gDebug>2) Info("ClassBegin", "%s", cl->GetName());
650 
651  WorkWithClass(cl->GetName(), classversion);
652 }
653 
654 ////////////////////////////////////////////////////////////////////////////////
655 /// Method indicates end of streaming of classdata in custom streamer.
656 /// See ClassBegin() method for more details.
657 
658 void TBufferSQL2::ClassEnd(const TClass* cl)
659 {
660  TSQLStructure* curr = Stack();
661  if (curr->GetType()==TSQLStructure::kSqlCustomElement) PopStack(); // for element
662  PopStack(); // for streamerinfo
663 
664  // restore value of object data
665  fCurrentData = Stack()->GetObjectData(kTRUE);
666 
667  fExpectedChain = kFALSE;
668 
669  if (gDebug>2) Info("ClassEnd","%s",cl->GetName());
670 }
671 
672 ////////////////////////////////////////////////////////////////////////////////
673 /// Method indicates name and typename of class memeber,
674 /// which should be now streamed in custom streamer
675 /// Following combinations are supported:
676 /// see TBufferXML::ClassMember for the details.
677 
678 void TBufferSQL2::ClassMember(const char* name, const char* typeName, Int_t arrsize1, Int_t arrsize2)
679 {
680  if (typeName==0) typeName = name;
681 
682  if ((name==0) || (strlen(name)==0)) {
683  Error("ClassMember","Invalid member name");
684  fErrorFlag = 1;
685  return;
686  }
687 
688  TString tname = typeName;
689 
690  Int_t typ_id = -1;
691 
692  if (strcmp(typeName,"raw:data")==0)
693  typ_id = TStreamerInfo::kMissing;
694 
695  if (typ_id<0) {
696  TDataType *dt = gROOT->GetType(typeName);
697  if (dt!=0)
698  if ((dt->GetType()>0) && (dt->GetType()<20))
699  typ_id = dt->GetType();
700  }
701 
702  if (typ_id<0)
703  if (strcmp(name, typeName)==0) {
704  TClass* cl = TClass::GetClass(tname.Data());
705  if (cl!=0) typ_id = TStreamerInfo::kBase;
706  }
707 
708  if (typ_id<0) {
709  Bool_t isptr = kFALSE;
710  if (tname[tname.Length()-1]=='*') {
711  tname.Resize(tname.Length()-1);
712  isptr = kTRUE;
713  }
714  TClass* cl = TClass::GetClass(tname.Data());
715  if (cl==0) {
716  Error("ClassMember","Invalid class specifier %s", typeName);
717  fErrorFlag = 1;
718  return;
719  }
720 
721  if (cl->IsTObject())
722  typ_id = isptr ? TStreamerInfo::kObjectp : TStreamerInfo::kObject;
723  else
724  typ_id = isptr ? TStreamerInfo::kAnyp : TStreamerInfo::kAny;
725 
726  if ((cl==TString::Class()) && !isptr)
727  typ_id = TStreamerInfo::kTString;
728  }
729 
730  TStreamerElement* elem = 0;
731 
732  if (typ_id == TStreamerInfo::kMissing) {
733  elem = new TStreamerElement(name,"title",0, typ_id, "raw:data");
734  } else
735 
736  if (typ_id==TStreamerInfo::kBase) {
737  TClass* cl = TClass::GetClass(tname.Data());
738  if (cl!=0) {
739  TStreamerBase* b = new TStreamerBase(tname.Data(), "title", 0);
740  b->SetBaseVersion(cl->GetClassVersion());
741  elem = b;
742  }
743  } else
744 
745  if ((typ_id>0) && (typ_id<20)) {
746  elem = new TStreamerBasicType(name, "title", 0, typ_id, typeName);
747  } else
748 
749  if ((typ_id==TStreamerInfo::kObject) ||
750  (typ_id==TStreamerInfo::kTObject) ||
751  (typ_id==TStreamerInfo::kTNamed)) {
752  elem = new TStreamerObject(name, "title", 0, tname.Data());
753  } else
754 
755  if (typ_id==TStreamerInfo::kObjectp) {
756  elem = new TStreamerObjectPointer(name, "title", 0, tname.Data());
757  } else
758 
759  if (typ_id==TStreamerInfo::kAny) {
760  elem = new TStreamerObjectAny(name, "title", 0, tname.Data());
761  } else
762 
763  if (typ_id==TStreamerInfo::kAnyp) {
764  elem = new TStreamerObjectAnyPointer(name, "title", 0, tname.Data());
765  } else
766 
767  if (typ_id==TStreamerInfo::kTString) {
768  elem = new TStreamerString(name, "title", 0);
769  }
770 
771  if (elem==0) {
772  Error("ClassMember","Invalid combination name = %s type = %s", name, typeName);
773  fErrorFlag = 1;
774  return;
775  }
776 
777  if (arrsize1>0) {
778  elem->SetArrayDim(arrsize2>0 ? 2 : 1);
779  elem->SetMaxIndex(0, arrsize1);
780  if (arrsize2>0)
781  elem->SetMaxIndex(1, arrsize2);
782  }
783 
784  // return stack to CustomClass node
785  if (Stack()->GetType()==TSQLStructure::kSqlCustomElement) PopStack();
786 
787  fExpectedChain = kFALSE;
788 
789  // we indicate that there is no streamerinfo
790  WorkWithElement(elem, -1);
791 }
792 
793 ////////////////////////////////////////////////////////////////////////////////
794 /// This function is a part of IncrementLevel method.
795 /// Also used in StartClass method
796 
797 void TBufferSQL2::WorkWithClass(const char* classname, Version_t classversion)
798 {
799  fExpectedChain = kFALSE;
800 
801  if (IsReading()) {
802  Long64_t objid = 0;
803 
804 // if ((fCurrentData!=0) && fCurrentData->VerifyDataType(sqlio::ObjectInst, kFALSE))
805 // if (!fCurrentData->IsBlobData()) Info("WorkWithClass","Big problem %s", fCurrentData->GetValue());
806 
807  if ((fCurrentData!=0) && fCurrentData->IsBlobData() &&
808  fCurrentData->VerifyDataType(sqlio::ObjectInst, kFALSE)) {
809  objid = atoi(fCurrentData->GetValue());
810  fCurrentData->ShiftToNextValue();
811  TString sobjid;
812  sobjid.Form("%lld",objid);
813  Stack()->ChangeValueOnly(sobjid.Data());
814  } else
815  objid = Stack()->DefineObjectId(kTRUE);
816  if (objid<0) {
817  Error("WorkWithClass","cannot define object id");
818  fErrorFlag = 1;
819  return;
820  }
821 
822  TSQLClassInfo* sqlinfo = fSQL->FindSQLClassInfo(classname, classversion);
823  if (sqlinfo==0) {
824  Error("WorkWithClass","Can not find table for class %s version %d", classname, classversion);
825  fErrorFlag = 1;
826  return;
827  }
828 
829  TSQLObjectData* objdata = SqlObjectData(objid, sqlinfo);
830  if (objdata==0) {
831  Error("WorkWithClass","Request error for data of object %lld for class %s version %d", objid, classname, classversion);
832  fErrorFlag = 1;
833  return;
834  }
835 
836  Stack()->AddObjectData(objdata);
837 
838  fCurrentData = objdata;
839  }
840 }
841 
842 ////////////////////////////////////////////////////////////////////////////////
843 /// This function is a part of SetStreamerElementNumber method.
844 /// It is introduced for reading of data for specified data memeber of class.
845 /// Used also in ReadFastArray methods to resolve problem of compressed data,
846 /// when several data memebers of the same basic type streamed with single ...FastArray call
847 
848 void TBufferSQL2::WorkWithElement(TStreamerElement* elem, Int_t /* comp_type */)
849 {
850  if (gDebug>2)
851  Info("WorkWithElement","elem = %s",elem->GetName());
852 
853  TSQLStructure* stack = Stack(1);
854  TStreamerInfo* info = stack->GetStreamerInfo();
855  Int_t number = info ? info->GetElements()->IndexOf(elem) : -1;
856 
857  if (number>=0)
858  PushStack()->SetStreamerElement(elem, number);
859  else
860  PushStack()->SetCustomElement(elem);
861 
862  if (IsReading()) {
863 
864  if (fCurrentData==0) {
865  Error("WorkWithElement","Object data is lost");
866  fErrorFlag = 1;
867  return;
868  }
869 
870  fCurrentData = Stack()->GetObjectData(kTRUE);
871 
872  Int_t located = Stack()->LocateElementColumn(fSQL, this, fCurrentData);
873 
874  if (located==TSQLStructure::kColUnknown) {
875  Error("WorkWithElement","Cannot locate correct column in the table");
876  fErrorFlag = 1;
877  return;
878  } else
879  if ((located==TSQLStructure::kColObject) ||
880  (located==TSQLStructure::kColObjectArray) ||
881  (located==TSQLStructure::kColParent)) {
882  // search again for object data while for BLOB it should be already assign
883  fCurrentData = Stack()->GetObjectData(kTRUE);
884  }
885  }
886 }
887 
888 ////////////////////////////////////////////////////////////////////////////////
889 /// Suppressed function of TBuffer
890 
891 TClass* TBufferSQL2::ReadClass(const TClass*, UInt_t*)
892 {
893  return 0;
894 }
895 
896 ////////////////////////////////////////////////////////////////////////////////
897 /// Suppressed function of TBuffer
898 
899 void TBufferSQL2::WriteClass(const TClass*)
900 {
901 }
902 
903 ////////////////////////////////////////////////////////////////////////////////
904 /// Suppressed function of TBuffer
905 
906 Int_t TBufferSQL2::CheckByteCount(UInt_t /*r_s */, UInt_t /*r_c*/, const TClass* /*cl*/)
907 {
908  return 0;
909 }
910 
911 ////////////////////////////////////////////////////////////////////////////////
912 /// Suppressed function of TBuffer
913 
914 Int_t TBufferSQL2::CheckByteCount(UInt_t, UInt_t, const char*)
915 {
916  return 0;
917 }
918 
919 ////////////////////////////////////////////////////////////////////////////////
920 /// Suppressed function of TBuffer
921 
922 void TBufferSQL2::SetByteCount(UInt_t, Bool_t)
923 {
924 }
925 
926 ////////////////////////////////////////////////////////////////////////////////
927 /// Skip class version from I/O buffer.
928 
929 void TBufferSQL2::SkipVersion(const TClass *cl)
930 {
931  ReadVersion(0,0,cl);
932 }
933 
934 ////////////////////////////////////////////////////////////////////////////////
935 /// Read version value from buffer
936 /// actually version is normally defined by table name
937 /// and kept in intermediate variable fReadVersionBuffer
938 
939 Version_t TBufferSQL2::ReadVersion(UInt_t *start, UInt_t *bcnt, const TClass *)
940 {
941  Version_t res = 0;
942 
943  if (start) *start = 0;
944  if (bcnt) *bcnt = 0;
945 
946  if (fReadVersionBuffer>=0) {
947  res = fReadVersionBuffer;
948  fReadVersionBuffer = -1;
949  if (gDebug>3)
950  std::cout << "TBufferSQL2::ReadVersion from buffer = " << res << std::endl;
951  } else
952  if ((fCurrentData!=0) && fCurrentData->IsBlobData() &&
953  fCurrentData->VerifyDataType(sqlio::Version)) {
954  TString value = fCurrentData->GetValue();
955  res = value.Atoi();
956  if (gDebug>3)
957  std::cout << "TBufferSQL2::ReadVersion from blob " << fCurrentData->GetBlobPrefixName() << " = " << res << std::endl;
958  fCurrentData->ShiftToNextValue();
959  } else {
960  Error("ReadVersion", "No correspondent tags to read version");
961  fErrorFlag = 1;
962  }
963 
964  return res;
965 }
966 
967 ////////////////////////////////////////////////////////////////////////////////
968 /// Copies class version to buffer, but not writes it to sql immidiately
969 /// Version will be used to produce complete table
970 /// name, which will include class version
971 
972 UInt_t TBufferSQL2::WriteVersion(const TClass *cl, Bool_t /* useBcnt */)
973 {
974  if (gDebug>2)
975  std::cout << "TBufferSQL2::WriteVersion " << (cl ? cl->GetName() : "null") << " ver = " << (cl ? cl->GetClassVersion() : 0) << std::endl;
976 
977  if (cl)
978  Stack()->AddVersion(cl);
979 
980  return 0;
981 }
982 
983 ////////////////////////////////////////////////////////////////////////////////
984 /// Read object from buffer. Only used from TBuffer.
985 
986 void* TBufferSQL2::ReadObjectAny(const TClass*)
987 {
988  return SqlReadObject(0);
989 }
990 
991 ////////////////////////////////////////////////////////////////////////////////
992 /// ?????? Skip any kind of object from buffer
993 /// !!!!!! fix me, not yet implemented
994 /// Should be just skip of current column later
995 
996 void TBufferSQL2::SkipObjectAny()
997 {
998 }
999 
1000 ////////////////////////////////////////////////////////////////////////////////
1001 /// Write object to buffer. Only used from TBuffer
1002 
1003 void TBufferSQL2::WriteObjectClass(const void *actualObjStart, const TClass *actualClass)
1004 {
1005  if (gDebug>2)
1006  std::cout << "TBufferSQL2::WriteObject of class " << (actualClass ? actualClass->GetName() : " null") << std::endl;
1007  SqlWriteObject(actualObjStart, actualClass);
1008 }
1009 
1010 #define SQLReadArrayUncompress(vname, arrsize) \
1011  { \
1012  while(indx<arrsize) \
1013  SqlReadBasic(vname[indx++]); \
1014  }
1015 
1016 
1017 #define SQLReadArrayCompress(vname, arrsize) \
1018  { \
1019  while(indx<arrsize) { \
1020  const char* name = fCurrentData->GetBlobPrefixName(); \
1021  Int_t first, last, res; \
1022  if (strstr(name,sqlio::IndexSepar)==0) { \
1023  res = sscanf(name,"[%d", &first); last = first; \
1024  } else res = sscanf(name,"[%d..%d", &first, &last); \
1025  if (gDebug>5) std::cout << name << " first = " << first << " last = " << last << " res = " << res << std::endl; \
1026  if ((first!=indx) || (last<first) || (last>=arrsize)) { \
1027  Error("SQLReadArrayCompress","Error reading array content %s", name); \
1028  fErrorFlag = 1; \
1029  break; \
1030  } \
1031  SqlReadBasic(vname[indx]); indx++; \
1032  while(indx<=last) \
1033  vname[indx++] = vname[first]; \
1034  } \
1035  }
1036 
1037 
1038 // macro to read content of array with compression
1039 #define SQLReadArrayContent(vname, arrsize, withsize) \
1040  { \
1041  if (gDebug>3) std::cout << "SQLReadArrayContent " << (arrsize) << std::endl; \
1042  PushStack()->SetArray(withsize ? arrsize : -1); \
1043  Int_t indx = 0; \
1044  if (fCurrentData->IsBlobData()) \
1045  SQLReadArrayCompress(vname, arrsize) \
1046  else \
1047  SQLReadArrayUncompress(vname, arrsize) \
1048  PopStack(); \
1049  if (gDebug>3) std::cout << "SQLReadArrayContent done " << std::endl; \
1050  }
1051 
1052 // macro to read array, which include size attribute
1053 #define TBufferSQL2_ReadArray(tname, vname) \
1054  { \
1055  Int_t n = SqlReadArraySize(); \
1056  if (n<=0) return 0; \
1057  if (!vname) vname = new tname[n]; \
1058  SQLReadArrayContent(vname, n, kTRUE); \
1059  return n; \
1060  }
1061 
1062 ////////////////////////////////////////////////////////////////////////////////
1063 /// Read Float16 value
1064 
1065 void TBufferSQL2::ReadFloat16 (Float_t *f, TStreamerElement * /*ele*/)
1066 {
1067  SqlReadBasic(*f);
1068 }
1069 
1070 ////////////////////////////////////////////////////////////////////////////////
1071 /// Read Double32 value
1072 
1073 void TBufferSQL2::ReadDouble32 (Double_t *d, TStreamerElement * /*ele*/)
1074 {
1075  SqlReadBasic(*d);
1076 }
1077 
1078 ////////////////////////////////////////////////////////////////////////////////
1079 /// Read a Double32_t from the buffer when the factor and minimun value have been specified
1080 /// see comments about Double32_t encoding at TBufferFile::WriteDouble32().
1081 /// Currently TBufferXML does not optimize space in this case.
1082 
1083 void TBufferSQL2::ReadWithFactor(Float_t *ptr, Double_t /* factor */, Double_t /* minvalue */)
1084 {
1085  SqlReadBasic(*ptr);
1086 }
1087 
1088 ////////////////////////////////////////////////////////////////////////////////
1089 /// Read a Float16_t from the buffer when the number of bits is specified (explicitly or not)
1090 /// see comments about Float16_t encoding at TBufferFile::WriteFloat16().
1091 /// Currently TBufferXML does not optimize space in this case.
1092 
1093 void TBufferSQL2::ReadWithNbits(Float_t *ptr, Int_t /* nbits */)
1094 {
1095  SqlReadBasic(*ptr);
1096 }
1097 
1098 ////////////////////////////////////////////////////////////////////////////////
1099 /// Read a Double32_t from the buffer when the factor and minimun value have been specified
1100 /// see comments about Double32_t encoding at TBufferFile::WriteDouble32().
1101 /// Currently TBufferXML does not optimize space in this case.
1102 
1103 void TBufferSQL2::ReadWithFactor(Double_t *ptr, Double_t /* factor */, Double_t /* minvalue */)
1104 {
1105  SqlReadBasic(*ptr);
1106 }
1107 
1108 ////////////////////////////////////////////////////////////////////////////////
1109 /// Read a Double32_t from the buffer when the number of bits is specified (explicitly or not)
1110 /// see comments about Double32_t encoding at TBufferFile::WriteDouble32().
1111 /// Currently TBufferXML does not optimize space in this case.
1112 
1113 void TBufferSQL2::ReadWithNbits(Double_t *ptr, Int_t /* nbits */)
1114 {
1115  SqlReadBasic(*ptr);
1116 }
1117 
1118 ////////////////////////////////////////////////////////////////////////////////
1119 /// Write Float16 value
1120 
1121 void TBufferSQL2::WriteFloat16 (Float_t *f, TStreamerElement * /*ele*/)
1122 {
1123  SqlWriteBasic(*f);
1124 }
1125 
1126 ////////////////////////////////////////////////////////////////////////////////
1127 /// Write Double32 value
1128 
1129 void TBufferSQL2::WriteDouble32 (Double_t *d, TStreamerElement * /*ele*/)
1130 {
1131  SqlWriteBasic(*d);
1132 }
1133 
1134 ////////////////////////////////////////////////////////////////////////////////
1135 /// Read array of Bool_t from buffer
1136 
1137 Int_t TBufferSQL2::ReadArray(Bool_t *&b)
1138 {
1139  TBufferSQL2_ReadArray(Bool_t,b);
1140 }
1141 
1142 ////////////////////////////////////////////////////////////////////////////////
1143 /// Read array of Char_t from buffer
1144 
1145 Int_t TBufferSQL2::ReadArray(Char_t *&c)
1146 {
1147  TBufferSQL2_ReadArray(Char_t,c);
1148 }
1149 
1150 ////////////////////////////////////////////////////////////////////////////////
1151 /// Read array of UChar_t from buffer
1152 
1153 Int_t TBufferSQL2::ReadArray(UChar_t *&c)
1154 {
1155  TBufferSQL2_ReadArray(UChar_t,c);
1156 }
1157 
1158 ////////////////////////////////////////////////////////////////////////////////
1159 /// Read array of Short_t from buffer
1160 
1161 Int_t TBufferSQL2::ReadArray(Short_t *&h)
1162 {
1163  TBufferSQL2_ReadArray(Short_t,h);
1164 }
1165 
1166 ////////////////////////////////////////////////////////////////////////////////
1167 /// Read array of UShort_t from buffer
1168 
1169 Int_t TBufferSQL2::ReadArray(UShort_t *&h)
1170 {
1171  TBufferSQL2_ReadArray(UShort_t,h);
1172 }
1173 
1174 ////////////////////////////////////////////////////////////////////////////////
1175 /// Read array of Int_t from buffer
1176 
1177 Int_t TBufferSQL2::ReadArray(Int_t *&i)
1178 {
1179  TBufferSQL2_ReadArray(Int_t,i);
1180 }
1181 
1182 ////////////////////////////////////////////////////////////////////////////////
1183 /// Read array of UInt_t from buffer
1184 
1185 Int_t TBufferSQL2::ReadArray(UInt_t *&i)
1186 {
1187  TBufferSQL2_ReadArray(UInt_t,i);
1188 }
1189 
1190 ////////////////////////////////////////////////////////////////////////////////
1191 /// Read array of Long_t from buffer
1192 
1193 Int_t TBufferSQL2::ReadArray(Long_t *&l)
1194 {
1195  TBufferSQL2_ReadArray(Long_t,l);
1196 }
1197 
1198 ////////////////////////////////////////////////////////////////////////////////
1199 /// Read array of ULong_t from buffer
1200 
1201 Int_t TBufferSQL2::ReadArray(ULong_t *&l)
1202 {
1203  TBufferSQL2_ReadArray(ULong_t,l);
1204 }
1205 
1206 ////////////////////////////////////////////////////////////////////////////////
1207 /// Read array of Long64_t from buffer
1208 
1209 Int_t TBufferSQL2::ReadArray(Long64_t *&l)
1210 {
1211  TBufferSQL2_ReadArray(Long64_t,l);
1212 }
1213 
1214 ////////////////////////////////////////////////////////////////////////////////
1215 /// Read array of ULong64_t from buffer
1216 
1217 Int_t TBufferSQL2::ReadArray(ULong64_t *&l)
1218 {
1219  TBufferSQL2_ReadArray(ULong64_t,l);
1220 }
1221 
1222 ////////////////////////////////////////////////////////////////////////////////
1223 /// Read array of Float_t from buffer
1224 
1225 Int_t TBufferSQL2::ReadArray(Float_t *&f)
1226 {
1227  TBufferSQL2_ReadArray(Float_t,f);
1228 }
1229 
1230 ////////////////////////////////////////////////////////////////////////////////
1231 /// Read array of Double_t from buffer
1232 
1233 Int_t TBufferSQL2::ReadArray(Double_t *&d)
1234 {
1235  TBufferSQL2_ReadArray(Double_t,d);
1236 }
1237 
1238 ////////////////////////////////////////////////////////////////////////////////
1239 /// Read array of Float16_t from buffer
1240 
1241 Int_t TBufferSQL2::ReadArrayFloat16(Float_t *&f, TStreamerElement * /*ele*/)
1242 {
1243  TBufferSQL2_ReadArray(Float_t,f);
1244 }
1245 
1246 ////////////////////////////////////////////////////////////////////////////////
1247 /// Read array of Double32_t from buffer
1248 
1249 Int_t TBufferSQL2::ReadArrayDouble32(Double_t *&d, TStreamerElement * /*ele*/)
1250 {
1251  TBufferSQL2_ReadArray(Double_t,d);
1252 }
1253 
1254 // macro to read static array, which include size attribute
1255 #define TBufferSQL2_ReadStaticArray(vname) \
1256  { \
1257  Int_t n = SqlReadArraySize(); \
1258  if (n<=0) return 0; \
1259  if (!vname) return 0; \
1260  SQLReadArrayContent(vname, n, kTRUE); \
1261  return n; \
1262  }
1263 
1264 ////////////////////////////////////////////////////////////////////////////////
1265 /// Read array of Bool_t from buffer
1266 
1267 Int_t TBufferSQL2::ReadStaticArray(Bool_t *b)
1268 {
1269  TBufferSQL2_ReadStaticArray(b);
1270 }
1271 
1272 ////////////////////////////////////////////////////////////////////////////////
1273 /// Read array of Char_t from buffer
1274 
1275 Int_t TBufferSQL2::ReadStaticArray(Char_t *c)
1276 {
1277  TBufferSQL2_ReadStaticArray(c);
1278 }
1279 
1280 ////////////////////////////////////////////////////////////////////////////////
1281 /// Read array of UChar_t from buffer
1282 
1283 Int_t TBufferSQL2::ReadStaticArray(UChar_t *c)
1284 {
1285  TBufferSQL2_ReadStaticArray(c);
1286 }
1287 
1288 ////////////////////////////////////////////////////////////////////////////////
1289 /// Read array of Short_t from buffer
1290 
1291 Int_t TBufferSQL2::ReadStaticArray(Short_t *h)
1292 {
1293  TBufferSQL2_ReadStaticArray(h);
1294 }
1295 
1296 ////////////////////////////////////////////////////////////////////////////////
1297 /// Read array of UShort_t from buffer
1298 
1299 Int_t TBufferSQL2::ReadStaticArray(UShort_t *h)
1300 {
1301  TBufferSQL2_ReadStaticArray(h);
1302 }
1303 
1304 ////////////////////////////////////////////////////////////////////////////////
1305 /// Read array of Int_t from buffer
1306 
1307 Int_t TBufferSQL2::ReadStaticArray(Int_t *i)
1308 {
1309  TBufferSQL2_ReadStaticArray(i);
1310 }
1311 
1312 ////////////////////////////////////////////////////////////////////////////////
1313 /// Read array of UInt_t from buffer
1314 
1315 Int_t TBufferSQL2::ReadStaticArray(UInt_t *i)
1316 {
1317  TBufferSQL2_ReadStaticArray(i);
1318 }
1319 
1320 ////////////////////////////////////////////////////////////////////////////////
1321 /// Read array of Long_t from buffer
1322 
1323 Int_t TBufferSQL2::ReadStaticArray(Long_t *l)
1324 {
1325  TBufferSQL2_ReadStaticArray(l);
1326 }
1327 
1328 ////////////////////////////////////////////////////////////////////////////////
1329 /// Read array of ULong_t from buffer
1330 
1331 Int_t TBufferSQL2::ReadStaticArray(ULong_t *l)
1332 {
1333  TBufferSQL2_ReadStaticArray(l);
1334 }
1335 
1336 ////////////////////////////////////////////////////////////////////////////////
1337 /// Read array of Long64_t from buffer
1338 
1339 Int_t TBufferSQL2::ReadStaticArray(Long64_t *l)
1340 {
1341  TBufferSQL2_ReadStaticArray(l);
1342 }
1343 
1344 ////////////////////////////////////////////////////////////////////////////////
1345 /// Read array of ULong64_t from buffer
1346 
1347 Int_t TBufferSQL2::ReadStaticArray(ULong64_t *l)
1348 {
1349  TBufferSQL2_ReadStaticArray(l);
1350 }
1351 
1352 ////////////////////////////////////////////////////////////////////////////////
1353 /// Read array of Float_t from buffer
1354 
1355 Int_t TBufferSQL2::ReadStaticArray(Float_t *f)
1356 {
1357  TBufferSQL2_ReadStaticArray(f);
1358 }
1359 
1360 ////////////////////////////////////////////////////////////////////////////////
1361 /// Read array of Double_t from buffer
1362 
1363 Int_t TBufferSQL2::ReadStaticArray(Double_t *d)
1364 {
1365  TBufferSQL2_ReadStaticArray(d);
1366 }
1367 
1368 ////////////////////////////////////////////////////////////////////////////////
1369 /// Read array of Float16_t from buffer
1370 
1371 Int_t TBufferSQL2::ReadStaticArrayFloat16(Float_t *f, TStreamerElement * /*ele*/)
1372 {
1373  TBufferSQL2_ReadStaticArray(f);
1374 }
1375 
1376 ////////////////////////////////////////////////////////////////////////////////
1377 /// Read array of Double32_t from buffer
1378 
1379 Int_t TBufferSQL2::ReadStaticArrayDouble32(Double_t *d, TStreamerElement * /*ele*/)
1380 {
1381  TBufferSQL2_ReadStaticArray(d);
1382 }
1383 
1384 // macro to read content of array, which not include size of array
1385 // macro also treat situation, when instead of one single array chain of several elements should be produced
1386 #define TBufferSQL2_ReadFastArray(vname) \
1387  { \
1388  if (n<=0) return; \
1389  TStreamerElement* elem = Stack(0)->GetElement(); \
1390  if ((elem!=0) && (elem->GetType()>TStreamerInfo::kOffsetL) && \
1391  (elem->GetType()<TStreamerInfo::kOffsetP) && \
1392  (elem->GetArrayLength()!=n)) fExpectedChain = kTRUE; \
1393  if (fExpectedChain) { \
1394  fExpectedChain = kFALSE; \
1395  Int_t startnumber = Stack(0)->GetElementNumber(); \
1396  TStreamerInfo* info = Stack(1)->GetStreamerInfo(); \
1397  Int_t index = 0; \
1398  while (index<n) { \
1399  elem = (TStreamerElement*)info->GetElements()->At(startnumber++); \
1400  if (index>1) { PopStack(); WorkWithElement(elem, elem->GetType()); } \
1401  if (elem->GetType()<TStreamerInfo::kOffsetL) { \
1402  SqlReadBasic(vname[index]); \
1403  index++; \
1404  } else { \
1405  Int_t elemlen = elem->GetArrayLength(); \
1406  SQLReadArrayContent((vname+index), elemlen, kFALSE); \
1407  index+=elemlen; \
1408  } \
1409  } \
1410  } else { \
1411  SQLReadArrayContent(vname, n, kFALSE); \
1412  } \
1413  }
1414 ////////////////////////////////////////////////////////////////////////////////
1415 /// Read array of Bool_t from buffer
1416 
1417 void TBufferSQL2::ReadFastArray(Bool_t *b, Int_t n)
1418 {
1419  TBufferSQL2_ReadFastArray(b);
1420 }
1421 
1422 ////////////////////////////////////////////////////////////////////////////////
1423 /// Read array of Char_t from buffer
1424 /// if nodename==CharStar, read all array as string
1425 
1426 void TBufferSQL2::ReadFastArray(Char_t *c, Int_t n)
1427 {
1428  if ((n>0) && fCurrentData->IsBlobData() &&
1429  fCurrentData->VerifyDataType(sqlio::CharStar, kFALSE)) {
1430  const char* buf = SqlReadCharStarValue();
1431  if ((buf==0) || (n<=0)) return;
1432  Int_t size = strlen(buf);
1433  if (size<n) size = n;
1434  memcpy(c, buf, size);
1435  } else {
1436  // std::cout << "call standard macro TBufferSQL2_ReadFastArray" << std::endl;
1437  TBufferSQL2_ReadFastArray(c);
1438  }
1439 }
1440 
1441 ////////////////////////////////////////////////////////////////////////////////
1442 /// Read array of UChar_t from buffer
1443 
1444 void TBufferSQL2::ReadFastArray(UChar_t *c, Int_t n)
1445 {
1446  TBufferSQL2_ReadFastArray(c);
1447 }
1448 
1449 ////////////////////////////////////////////////////////////////////////////////
1450 /// Read array of Short_t from buffer
1451 
1452 void TBufferSQL2::ReadFastArray(Short_t *h, Int_t n)
1453 {
1454  TBufferSQL2_ReadFastArray(h);
1455 }
1456 
1457 ////////////////////////////////////////////////////////////////////////////////
1458 /// Read array of UShort_t from buffer
1459 
1460 void TBufferSQL2::ReadFastArray(UShort_t *h, Int_t n)
1461 {
1462  TBufferSQL2_ReadFastArray(h);
1463 }
1464 
1465 ////////////////////////////////////////////////////////////////////////////////
1466 /// Read array of Int_t from buffer
1467 
1468 void TBufferSQL2::ReadFastArray(Int_t *i, Int_t n)
1469 {
1470  TBufferSQL2_ReadFastArray(i);
1471 }
1472 
1473 ////////////////////////////////////////////////////////////////////////////////
1474 /// Read array of UInt_t from buffer
1475 
1476 void TBufferSQL2::ReadFastArray(UInt_t *i, Int_t n)
1477 {
1478  TBufferSQL2_ReadFastArray(i);
1479 }
1480 
1481 ////////////////////////////////////////////////////////////////////////////////
1482 /// Read array of Long_t from buffer
1483 
1484 void TBufferSQL2::ReadFastArray(Long_t *l, Int_t n)
1485 {
1486  TBufferSQL2_ReadFastArray(l);
1487 }
1488 
1489 ////////////////////////////////////////////////////////////////////////////////
1490 /// Read array of ULong_t from buffer
1491 
1492 void TBufferSQL2::ReadFastArray(ULong_t *l, Int_t n)
1493 {
1494  TBufferSQL2_ReadFastArray(l);
1495 }
1496 
1497 ////////////////////////////////////////////////////////////////////////////////
1498 /// Read array of Long64_t from buffer
1499 
1500 void TBufferSQL2::ReadFastArray(Long64_t *l, Int_t n)
1501 {
1502  TBufferSQL2_ReadFastArray(l);
1503 }
1504 
1505 ////////////////////////////////////////////////////////////////////////////////
1506 /// Read array of ULong64_t from buffer
1507 
1508 void TBufferSQL2::ReadFastArray(ULong64_t *l, Int_t n)
1509 {
1510  TBufferSQL2_ReadFastArray(l);
1511 }
1512 
1513 ////////////////////////////////////////////////////////////////////////////////
1514 /// Read array of Float_t from buffer
1515 
1516 void TBufferSQL2::ReadFastArray(Float_t *f, Int_t n)
1517 {
1518  TBufferSQL2_ReadFastArray(f);
1519 }
1520 
1521 ////////////////////////////////////////////////////////////////////////////////
1522 /// Read array of Double_t from buffer
1523 
1524 void TBufferSQL2::ReadFastArray(Double_t *d, Int_t n)
1525 {
1526  TBufferSQL2_ReadFastArray(d);
1527 }
1528 
1529 ////////////////////////////////////////////////////////////////////////////////
1530 /// Read array of Float16_t from buffer
1531 
1532 void TBufferSQL2::ReadFastArrayFloat16(Float_t *f, Int_t n, TStreamerElement * /*ele*/)
1533 {
1534  TBufferSQL2_ReadFastArray(f);
1535 }
1536 
1537 ////////////////////////////////////////////////////////////////////////////////
1538 /// Read array of Float16_t from buffer
1539 
1540 void TBufferSQL2::ReadFastArrayWithFactor(Float_t *f, Int_t n, Double_t /* factor */, Double_t /* minvalue */)
1541 {
1542  TBufferSQL2_ReadFastArray(f);
1543 }
1544 
1545 ////////////////////////////////////////////////////////////////////////////////
1546 /// Read array of Float16_t from buffer
1547 
1548 void TBufferSQL2::ReadFastArrayWithNbits(Float_t *f, Int_t n, Int_t /*nbits*/)
1549 {
1550  TBufferSQL2_ReadFastArray(f);
1551 }
1552 
1553 ////////////////////////////////////////////////////////////////////////////////
1554 /// Read array of Double32_t from buffer
1555 
1556 void TBufferSQL2::ReadFastArrayDouble32(Double_t *d, Int_t n, TStreamerElement * /*ele*/)
1557 {
1558  TBufferSQL2_ReadFastArray(d);
1559 }
1560 
1561 ////////////////////////////////////////////////////////////////////////////////
1562 /// Read array of Double32_t from buffer
1563 
1564 void TBufferSQL2::ReadFastArrayWithFactor(Double_t *d, Int_t n, Double_t /* factor */, Double_t /* minvalue */)
1565 {
1566  TBufferSQL2_ReadFastArray(d);
1567 }
1568 ////////////////////////////////////////////////////////////////////////////////
1569 /// Read array of Double32_t from buffer
1570 
1571 void TBufferSQL2::ReadFastArrayWithNbits(Double_t *d, Int_t n, Int_t /*nbits*/)
1572 {
1573  TBufferSQL2_ReadFastArray(d);
1574 }
1575 
1576 ////////////////////////////////////////////////////////////////////////////////
1577 /// Same functionality as TBuffer::ReadFastArray(...) but
1578 /// instead of calling cl->Streamer(obj,buf) call here
1579 /// buf.StreamObject(obj, cl). In that case it is easy to understand where
1580 /// object data is started and finished
1581 
1582 void TBufferSQL2::ReadFastArray(void *start, const TClass *cl, Int_t n, TMemberStreamer *streamer, const TClass* onFileClass )
1583 {
1584  if (gDebug>2)
1585  Info("ReadFastArray","(void *");
1586 
1587  if (streamer) {
1588  StreamObject(start, streamer, cl, 0, onFileClass);
1589 // (*streamer)(*this,start,0);
1590  return;
1591  }
1592 
1593  int objectSize = cl->Size();
1594  char *obj = (char*)start;
1595  char *end = obj + n*objectSize;
1596 
1597  for(; obj<end; obj+=objectSize) {
1598  StreamObject(obj, cl, onFileClass);
1599  }
1600  // TBuffer::ReadFastArray(start, cl, n, s);
1601 }
1602 
1603 ////////////////////////////////////////////////////////////////////////////////
1604 /// Same functionality as TBuffer::ReadFastArray(...) but
1605 /// instead of calling cl->Streamer(obj,buf) call here
1606 /// buf.StreamObject(obj, cl). In that case it is easy to understand where
1607 /// object data is started and finished
1608 
1609 void TBufferSQL2::ReadFastArray(void **start, const TClass *cl, Int_t n, Bool_t isPreAlloc, TMemberStreamer *streamer, const TClass* onFileClass )
1610 {
1611  if (gDebug>2)
1612  Info("ReadFastArray","(void ** pre = %d n = %d", isPreAlloc, n);
1613 
1614  if (streamer) {
1615  if (isPreAlloc) {
1616  for (Int_t j=0;j<n;j++) {
1617  if (!start[j]) start[j] = ((TClass*)cl)->New();
1618  }
1619  }
1620  StreamObject((void*)start, streamer, cl, 0, onFileClass);
1621 // (*streamer)(*this,(void*)start,0);
1622  return;
1623  }
1624 
1625  if (!isPreAlloc) {
1626 
1627  for (Int_t j=0; j<n; j++){
1628  //delete the object or collection
1629  if (start[j] && TStreamerInfo::CanDelete()) ((TClass*)cl)->Destructor(start[j],kFALSE); // call delete and desctructor
1630  start[j] = ReadObjectAny(cl);
1631  }
1632 
1633  } else { //case //-> in comment
1634 
1635  for (Int_t j=0; j<n; j++) {
1636  if (!start[j]) start[j] = ((TClass*)cl)->New();
1637  StreamObject(start[j], cl, onFileClass);
1638  }
1639  }
1640 
1641  if (gDebug>2)
1642  Info("ReadFastArray","(void ** Done" );
1643 
1644  // TBuffer::ReadFastArray(startp, cl, n, isPreAlloc, s);
1645 }
1646 
1647 ////////////////////////////////////////////////////////////////////////////////
1648 /// Reads array size, written in raw data table.
1649 /// Used in ReadArray methods, where TBuffer need to read array size first.
1650 
1651 Int_t TBufferSQL2::SqlReadArraySize()
1652 {
1653  const char* value = SqlReadValue(sqlio::Array);
1654  if ((value==0) || (strlen(value)==0)) return 0;
1655  Int_t sz = atoi(value);
1656  return sz;
1657 }
1658 
1659 // macro to write content of noncompressed array, not used
1660 #define SQLWriteArrayNoncompress(vname, arrsize) \
1661  { \
1662  for(Int_t indx=0;indx<arrsize;indx++) { \
1663  SqlWriteBasic(vname[indx]); \
1664  Stack()->ChildArrayIndex(indx, 1); \
1665  } \
1666  }
1667 
1668 // macro to write content of compressed array
1669 #define SQLWriteArrayCompress(vname, arrsize) \
1670  { \
1671  Int_t indx = 0; \
1672  while(indx<arrsize) { \
1673  Int_t curr = indx; indx++; \
1674  while ((indx<arrsize) && (vname[indx]==vname[curr])) indx++; \
1675  SqlWriteBasic(vname[curr]); \
1676  Stack()->ChildArrayIndex(curr, indx-curr); \
1677  } \
1678  }
1679 
1680 #define SQLWriteArrayContent(vname, arrsize, withsize) \
1681  { \
1682  PushStack()->SetArray(withsize ? arrsize : -1); \
1683  if (fCompressLevel>0) { \
1684  SQLWriteArrayCompress(vname, arrsize) \
1685  } else { \
1686  SQLWriteArrayNoncompress(vname, arrsize) \
1687  } \
1688  PopStack(); \
1689  }
1690 
1691 // macro to write array, which include size
1692 #define TBufferSQL2_WriteArray(vname) \
1693  { \
1694  SQLWriteArrayContent(vname, n, kTRUE); \
1695  }
1696 
1697 ////////////////////////////////////////////////////////////////////////////////
1698 /// Write array of Bool_t to buffer
1699 
1700 void TBufferSQL2::WriteArray(const Bool_t *b, Int_t n)
1701 {
1702  TBufferSQL2_WriteArray(b);
1703 }
1704 
1705 ////////////////////////////////////////////////////////////////////////////////
1706 /// Write array of Char_t to buffer
1707 
1708 void TBufferSQL2::WriteArray(const Char_t *c, Int_t n)
1709 {
1710  TBufferSQL2_WriteArray(c);
1711 }
1712 
1713 ////////////////////////////////////////////////////////////////////////////////
1714 /// Write array of UChar_t to buffer
1715 
1716 void TBufferSQL2::WriteArray(const UChar_t *c, Int_t n)
1717 {
1718  TBufferSQL2_WriteArray(c);
1719 }
1720 
1721 ////////////////////////////////////////////////////////////////////////////////
1722 /// Write array of Short_t to buffer
1723 
1724 void TBufferSQL2::WriteArray(const Short_t *h, Int_t n)
1725 {
1726  TBufferSQL2_WriteArray(h);
1727 }
1728 
1729 ////////////////////////////////////////////////////////////////////////////////
1730 /// Write array of UShort_t to buffer
1731 
1732 void TBufferSQL2::WriteArray(const UShort_t *h, Int_t n)
1733 {
1734  TBufferSQL2_WriteArray(h);
1735 }
1736 
1737 ////////////////////////////////////////////////////////////////////////////////
1738 /// Write array of Int_ to buffer
1739 
1740 void TBufferSQL2::WriteArray(const Int_t *i, Int_t n)
1741 {
1742  TBufferSQL2_WriteArray(i);
1743 }
1744 
1745 ////////////////////////////////////////////////////////////////////////////////
1746 /// Write array of UInt_t to buffer
1747 
1748 void TBufferSQL2::WriteArray(const UInt_t *i, Int_t n)
1749 {
1750  TBufferSQL2_WriteArray(i);
1751 }
1752 
1753 ////////////////////////////////////////////////////////////////////////////////
1754 /// Write array of Long_t to buffer
1755 
1756 void TBufferSQL2::WriteArray(const Long_t *l, Int_t n)
1757 {
1758  TBufferSQL2_WriteArray(l);
1759 }
1760 
1761 ////////////////////////////////////////////////////////////////////////////////
1762 /// Write array of ULong_t to buffer
1763 
1764 void TBufferSQL2::WriteArray(const ULong_t *l, Int_t n)
1765 {
1766  TBufferSQL2_WriteArray(l);
1767 }
1768 
1769 ////////////////////////////////////////////////////////////////////////////////
1770 /// Write array of Long64_t to buffer
1771 
1772 void TBufferSQL2::WriteArray(const Long64_t *l, Int_t n)
1773 {
1774  TBufferSQL2_WriteArray(l);
1775 }
1776 
1777 ////////////////////////////////////////////////////////////////////////////////
1778 /// Write array of ULong64_t to buffer
1779 
1780 void TBufferSQL2::WriteArray(const ULong64_t *l, Int_t n)
1781 {
1782  TBufferSQL2_WriteArray(l);
1783 }
1784 
1785 ////////////////////////////////////////////////////////////////////////////////
1786 /// Write array of Float_t to buffer
1787 
1788 void TBufferSQL2::WriteArray(const Float_t *f, Int_t n)
1789 {
1790  TBufferSQL2_WriteArray(f);
1791 }
1792 
1793 ////////////////////////////////////////////////////////////////////////////////
1794 /// Write array of Double_t to buffer
1795 
1796 void TBufferSQL2::WriteArray(const Double_t *d, Int_t n)
1797 {
1798  TBufferSQL2_WriteArray(d);
1799 }
1800 
1801 ////////////////////////////////////////////////////////////////////////////////
1802 /// Write array of Float16_t to buffer
1803 
1804 void TBufferSQL2::WriteArrayFloat16(const Float_t *f, Int_t n, TStreamerElement * /*ele*/)
1805 {
1806  TBufferSQL2_WriteArray(f);
1807 }
1808 
1809 ////////////////////////////////////////////////////////////////////////////////
1810 /// Write array of Double32_t to buffer
1811 
1812 void TBufferSQL2::WriteArrayDouble32(const Double_t *d, Int_t n, TStreamerElement * /*ele*/)
1813 {
1814  TBufferSQL2_WriteArray(d);
1815 }
1816 
1817 // write array without size attribute
1818 // macro also treat situation, when instead of one single array chain of several elements should be produced
1819 #define TBufferSQL2_WriteFastArray(vname) \
1820  { \
1821  if (n<=0) return; \
1822  TStreamerElement* elem = Stack(0)->GetElement(); \
1823  if ((elem!=0) && (elem->GetType()>TStreamerInfo::kOffsetL) && \
1824  (elem->GetType()<TStreamerInfo::kOffsetP) && \
1825  (elem->GetArrayLength()!=n)) fExpectedChain = kTRUE; \
1826  if (fExpectedChain) { \
1827  TStreamerInfo* info = Stack(1)->GetStreamerInfo(); \
1828  Int_t startnumber = Stack(0)->GetElementNumber(); \
1829  Int_t index = 0; \
1830  while (index<n) { \
1831  elem = (TStreamerElement*)info->GetElements()->At(startnumber++); \
1832  if (index>0) { PopStack(); WorkWithElement(elem, elem->GetType()); } \
1833  if (elem->GetType()<TStreamerInfo::kOffsetL) { \
1834  SqlWriteBasic(vname[index]); \
1835  index++; \
1836  } else { \
1837  Int_t elemlen = elem->GetArrayLength(); \
1838  SQLWriteArrayContent((vname+index), elemlen, kFALSE); \
1839  index+=elemlen; \
1840  } \
1841  fExpectedChain = kFALSE; \
1842  } \
1843  } else { \
1844  SQLWriteArrayContent(vname, n, kFALSE); \
1845  } \
1846  }
1847 
1848 ////////////////////////////////////////////////////////////////////////////////
1849 /// Write array of Bool_t to buffer
1850 
1851 void TBufferSQL2::WriteFastArray(const Bool_t *b, Int_t n)
1852 {
1853  TBufferSQL2_WriteFastArray(b);
1854 }
1855 
1856 ////////////////////////////////////////////////////////////////////////////////
1857 /// Write array of Char_t to buffer
1858 /// it will be reproduced as CharStar node with string as attribute
1859 
1860 void TBufferSQL2::WriteFastArray(const Char_t *c, Int_t n)
1861 {
1862  Bool_t usedefault = (n==0) || fExpectedChain;
1863 
1864  const Char_t* ccc = c;
1865  // check if no zeros in the array
1866  if (!usedefault)
1867  for (int i=0;i<n;i++)
1868  if (*ccc++==0) { usedefault = kTRUE; break; }
1869 
1870  if (usedefault) {
1871  TBufferSQL2_WriteFastArray(c);
1872  } else {
1873  Char_t* buf = new Char_t[n+1];
1874  memcpy(buf, c, n);
1875  buf[n] = 0;
1876  SqlWriteValue(buf, sqlio::CharStar);
1877  delete[] buf;
1878  }
1879 }
1880 
1881 ////////////////////////////////////////////////////////////////////////////////
1882 /// Write array of UChar_t to buffer
1883 
1884 void TBufferSQL2::WriteFastArray(const UChar_t *c, Int_t n)
1885 {
1886  TBufferSQL2_WriteFastArray(c);
1887 }
1888 
1889 ////////////////////////////////////////////////////////////////////////////////
1890 /// Write array of Short_t to buffer
1891 
1892 void TBufferSQL2::WriteFastArray(const Short_t *h, Int_t n)
1893 {
1894  TBufferSQL2_WriteFastArray(h);
1895 }
1896 
1897 ////////////////////////////////////////////////////////////////////////////////
1898 /// Write array of UShort_t to buffer
1899 
1900 void TBufferSQL2::WriteFastArray(const UShort_t *h, Int_t n)
1901 {
1902  TBufferSQL2_WriteFastArray(h);
1903 }
1904 
1905 ////////////////////////////////////////////////////////////////////////////////
1906 /// Write array of Int_t to buffer
1907 
1908 void TBufferSQL2::WriteFastArray(const Int_t *i, Int_t n)
1909 {
1910  TBufferSQL2_WriteFastArray(i);
1911 }
1912 
1913 ////////////////////////////////////////////////////////////////////////////////
1914 /// Write array of UInt_t to buffer
1915 
1916 void TBufferSQL2::WriteFastArray(const UInt_t *i, Int_t n)
1917 {
1918  TBufferSQL2_WriteFastArray(i);
1919 }
1920 
1921 ////////////////////////////////////////////////////////////////////////////////
1922 /// Write array of Long_t to buffer
1923 
1924 void TBufferSQL2::WriteFastArray(const Long_t *l, Int_t n)
1925 {
1926  TBufferSQL2_WriteFastArray(l);
1927 }
1928 
1929 ////////////////////////////////////////////////////////////////////////////////
1930 /// Write array of ULong_t to buffer
1931 
1932 void TBufferSQL2::WriteFastArray(const ULong_t *l, Int_t n)
1933 {
1934  TBufferSQL2_WriteFastArray(l);
1935 }
1936 
1937 ////////////////////////////////////////////////////////////////////////////////
1938 /// Write array of Long64_t to buffer
1939 
1940 void TBufferSQL2::WriteFastArray(const Long64_t *l, Int_t n)
1941 {
1942  TBufferSQL2_WriteFastArray(l);
1943 }
1944 
1945 ////////////////////////////////////////////////////////////////////////////////
1946 /// Write array of ULong64_t to buffer
1947 
1948 void TBufferSQL2::WriteFastArray(const ULong64_t *l, Int_t n)
1949 {
1950  TBufferSQL2_WriteFastArray(l);
1951 }
1952 
1953 ////////////////////////////////////////////////////////////////////////////////
1954 /// Write array of Float_t to buffer
1955 
1956 void TBufferSQL2::WriteFastArray(const Float_t *f, Int_t n)
1957 {
1958  TBufferSQL2_WriteFastArray(f);
1959 }
1960 
1961 ////////////////////////////////////////////////////////////////////////////////
1962 /// Write array of Double_t to buffer
1963 
1964 void TBufferSQL2::WriteFastArray(const Double_t *d, Int_t n)
1965 {
1966  TBufferSQL2_WriteFastArray(d);
1967 }
1968 
1969 ////////////////////////////////////////////////////////////////////////////////
1970 /// Write array of Float16_t to buffer
1971 
1972 void TBufferSQL2::WriteFastArrayFloat16(const Float_t *f, Int_t n, TStreamerElement * /*ele*/)
1973 {
1974  TBufferSQL2_WriteFastArray(f);
1975 }
1976 
1977 ////////////////////////////////////////////////////////////////////////////////
1978 /// Write array of Double32_t to buffer
1979 
1980 void TBufferSQL2::WriteFastArrayDouble32(const Double_t *d, Int_t n, TStreamerElement * /*ele*/)
1981 {
1982  TBufferSQL2_WriteFastArray(d);
1983 }
1984 
1985 ////////////////////////////////////////////////////////////////////////////////
1986 /// Same functionality as TBuffer::WriteFastArray(...) but
1987 /// instead of calling cl->Streamer(obj,buf) call here
1988 /// buf.StreamObject(obj, cl). In that case it is easy to understand where
1989 /// object data is started and finished
1990 
1991 void TBufferSQL2::WriteFastArray(void *start, const TClass *cl, Int_t n, TMemberStreamer *streamer)
1992 {
1993  if (streamer) {
1994  StreamObject(start, streamer, cl, 0);
1995 // (*streamer)(*this, start, 0);
1996  return;
1997  }
1998 
1999  char *obj = (char*)start;
2000  if (!n) n=1;
2001  int size = cl->Size();
2002 
2003  for(Int_t j=0; j<n; j++,obj+=size)
2004  StreamObject(obj, cl);
2005 
2006  // TBuffer::WriteFastArray(start, cl, n, s);
2007 }
2008 
2009 ////////////////////////////////////////////////////////////////////////////////
2010 /// Same functionality as TBuffer::WriteFastArray(...) but
2011 /// instead of calling cl->Streamer(obj,buf) call here
2012 /// buf.StreamObject(obj, cl). In that case it is easy to understand where
2013 /// object data is started and finished
2014 
2015 Int_t TBufferSQL2::WriteFastArray(void **start, const TClass *cl, Int_t n, Bool_t isPreAlloc, TMemberStreamer *streamer)
2016 {
2017  if (streamer) {
2018  StreamObject((void*) start, streamer, cl, 0);
2019 // (*streamer)(*this,(void*)start,0);
2020  return 0;
2021  }
2022 
2023  int strInfo = 0;
2024 
2025  Int_t res = 0;
2026 
2027  if (!isPreAlloc) {
2028 
2029  for (Int_t j=0;j<n;j++) {
2030  //must write StreamerInfo if pointer is null
2031  if (!strInfo && !start[j] ) ForceWriteInfo(((TClass*)cl)->GetStreamerInfo(),kFALSE);
2032  strInfo = 2003;
2033  res |= WriteObjectAny(start[j],cl);
2034  }
2035 
2036  } else {
2037  //case //-> in comment
2038 
2039  for (Int_t j=0;j<n;j++) {
2040  if (!start[j]) start[j] = ((TClass*)cl)->New();
2041  StreamObject(start[j], cl);
2042  }
2043 
2044  }
2045  return res;
2046 
2047 // return TBuffer::WriteFastArray(startp, cl, n, isPreAlloc, s);
2048 }
2049 
2050 ////////////////////////////////////////////////////////////////////////////////
2051 /// Stream object to/from buffer
2052 
2053 void TBufferSQL2::StreamObject(void *obj, const type_info &typeinfo, const TClass *onFileClass)
2054 {
2055  StreamObject(obj, TClass::GetClass(typeinfo), onFileClass);
2056 }
2057 
2058 ////////////////////////////////////////////////////////////////////////////////
2059 /// Stream object to/from buffer
2060 
2061 void TBufferSQL2::StreamObject(void *obj, const char *className, const TClass *onFileClass)
2062 {
2063  StreamObject(obj, TClass::GetClass(className), onFileClass);
2064 }
2065 
2066 ////////////////////////////////////////////////////////////////////////////////
2067 /// Stream object to/from buffer
2068 
2069 void TBufferSQL2::StreamObject(void *obj, const TClass *cl, const TClass *onFileClass)
2070 {
2071  if (gDebug>1)
2072  std::cout << " TBufferSQL2::StreamObject class = " << (cl ? cl->GetName() : "none") << std::endl;
2073  if (IsReading())
2074  SqlReadObject(obj, 0, 0, 0, onFileClass);
2075  else
2076  SqlWriteObject(obj, cl);
2077 }
2078 
2079 ////////////////////////////////////////////////////////////////////////////////
2080 /// Stream object to/from buffer
2081 
2082 void TBufferSQL2::StreamObject(TObject *obj)
2083 {
2084  StreamObject(obj, obj ? obj->IsA() : TObject::Class());
2085 }
2086 
2087 ////////////////////////////////////////////////////////////////////////////////
2088 /// Stream object to/from buffer
2089 
2090 void TBufferSQL2::StreamObject(void *obj, TMemberStreamer *streamer, const TClass *cl, Int_t n, const TClass *onFileClass)
2091 {
2092  if (streamer==0) return;
2093 
2094  if (gDebug>1)
2095  std::cout << "Stream object of class = " << cl->GetName() << std::endl;
2096 // (*streamer)(*this, obj, n);
2097 
2098  if (IsReading())
2099  SqlReadObject(obj, 0, streamer, n, onFileClass);
2100  else
2101  SqlWriteObject(obj, cl, streamer, n);
2102 }
2103 
2104 // macro for right shift operator for basic type
2105 #define TBufferSQL2_operatorin(vname) \
2106  { \
2107  SqlReadBasic(vname); \
2108  }
2109 
2110 ////////////////////////////////////////////////////////////////////////////////
2111 /// Reads Bool_t value from buffer
2112 
2113 void TBufferSQL2::ReadBool(Bool_t &b)
2114 {
2115  TBufferSQL2_operatorin(b);
2116 }
2117 
2118 ////////////////////////////////////////////////////////////////////////////////
2119 /// Reads Char_t value from buffer
2120 
2121 void TBufferSQL2::ReadChar(Char_t &c)
2122 {
2123  TBufferSQL2_operatorin(c);
2124 }
2125 
2126 ////////////////////////////////////////////////////////////////////////////////
2127 /// Reads UChar_t value from buffer
2128 
2129 void TBufferSQL2::ReadUChar(UChar_t &c)
2130 {
2131  TBufferSQL2_operatorin(c);
2132 }
2133 
2134 ////////////////////////////////////////////////////////////////////////////////
2135 /// Reads Short_t value from buffer
2136 
2137 void TBufferSQL2::ReadShort(Short_t &h)
2138 {
2139  TBufferSQL2_operatorin(h);
2140 }
2141 
2142 ////////////////////////////////////////////////////////////////////////////////
2143 /// Reads UShort_t value from buffer
2144 
2145 void TBufferSQL2::ReadUShort(UShort_t &h)
2146 {
2147  TBufferSQL2_operatorin(h);
2148 }
2149 
2150 ////////////////////////////////////////////////////////////////////////////////
2151 /// Reads Int_t value from buffer
2152 
2153 void TBufferSQL2::ReadInt(Int_t &i)
2154 {
2155  TBufferSQL2_operatorin(i);
2156 }
2157 
2158 ////////////////////////////////////////////////////////////////////////////////
2159 /// Reads UInt_t value from buffer
2160 
2161 void TBufferSQL2::ReadUInt(UInt_t &i)
2162 {
2163  TBufferSQL2_operatorin(i);
2164 }
2165 
2166 ////////////////////////////////////////////////////////////////////////////////
2167 /// Reads Long_t value from buffer
2168 
2169 void TBufferSQL2::ReadLong(Long_t &l)
2170 {
2171  TBufferSQL2_operatorin(l);
2172 }
2173 
2174 ////////////////////////////////////////////////////////////////////////////////
2175 /// Reads ULong_t value from buffer
2176 
2177 void TBufferSQL2::ReadULong(ULong_t &l)
2178 {
2179  TBufferSQL2_operatorin(l);
2180 }
2181 
2182 ////////////////////////////////////////////////////////////////////////////////
2183 /// Reads Long64_t value from buffer
2184 
2185 void TBufferSQL2::ReadLong64(Long64_t &l)
2186 {
2187  TBufferSQL2_operatorin(l);
2188 }
2189 
2190 ////////////////////////////////////////////////////////////////////////////////
2191 /// Reads ULong64_t value from buffer
2192 
2193 void TBufferSQL2::ReadULong64(ULong64_t &l)
2194 {
2195  TBufferSQL2_operatorin(l);
2196 }
2197 
2198 ////////////////////////////////////////////////////////////////////////////////
2199 /// Reads Float_t value from buffer
2200 
2201 void TBufferSQL2::ReadFloat(Float_t &f)
2202 {
2203  TBufferSQL2_operatorin(f);
2204 }
2205 
2206 ////////////////////////////////////////////////////////////////////////////////
2207 /// Reads Double_t value from buffer
2208 
2209 void TBufferSQL2::ReadDouble(Double_t &d)
2210 {
2211  TBufferSQL2_operatorin(d);
2212 }
2213 
2214 ////////////////////////////////////////////////////////////////////////////////
2215 /// Reads array of characters from buffer
2216 
2217 void TBufferSQL2::ReadCharP(Char_t *c)
2218 {
2219  const char* buf = SqlReadCharStarValue();
2220  if (buf) strcpy(c, buf);
2221 }
2222 
2223 ////////////////////////////////////////////////////////////////////////////////
2224 /// Read a TString
2225 
2226 void TBufferSQL2::ReadTString(TString &s)
2227 {
2228  TBufferFile::ReadTString(s);
2229 }
2230 
2231 ////////////////////////////////////////////////////////////////////////////////
2232 /// Write a TString
2233 
2234 void TBufferSQL2::WriteTString(const TString &s)
2235 {
2236  TBufferFile::WriteTString(s);
2237 }
2238 
2239 ////////////////////////////////////////////////////////////////////////////////
2240 /// Read a std::string
2241 
2242 void TBufferSQL2::ReadStdString(std::string &s)
2243 {
2244  TBufferFile::ReadStdString(s);
2245 }
2246 
2247 ////////////////////////////////////////////////////////////////////////////////
2248 /// Write a std::string
2249 
2250 void TBufferSQL2::WriteStdString(const std::string &s)
2251 {
2252  TBufferFile::WriteStdString(s);
2253 }
2254 
2255 // macro for right shift operator for basic types
2256 #define TBufferSQL2_operatorout(vname) \
2257  { \
2258  SqlWriteBasic(vname); \
2259  }
2260 
2261 ////////////////////////////////////////////////////////////////////////////////
2262 /// Writes Bool_t value to buffer
2263 
2264 void TBufferSQL2::WriteBool(Bool_t b)
2265 {
2266  TBufferSQL2_operatorout(b);
2267 }
2268 
2269 ////////////////////////////////////////////////////////////////////////////////
2270 /// Writes Char_t value to buffer
2271 
2272 void TBufferSQL2::WriteChar(Char_t c)
2273 {
2274  TBufferSQL2_operatorout(c);
2275 }
2276 
2277 ////////////////////////////////////////////////////////////////////////////////
2278 /// Writes UChar_t value to buffer
2279 
2280 void TBufferSQL2::WriteUChar(UChar_t c)
2281 {
2282  TBufferSQL2_operatorout(c);
2283 }
2284 
2285 ////////////////////////////////////////////////////////////////////////////////
2286 /// Writes Short_t value to buffer
2287 
2288 void TBufferSQL2::WriteShort(Short_t h)
2289 {
2290  TBufferSQL2_operatorout(h);
2291 }
2292 
2293 ////////////////////////////////////////////////////////////////////////////////
2294 /// Writes UShort_t value to buffer
2295 
2296 void TBufferSQL2::WriteUShort(UShort_t h)
2297 {
2298  TBufferSQL2_operatorout(h);
2299 }
2300 
2301 ////////////////////////////////////////////////////////////////////////////////
2302 /// Writes Int_t value to buffer
2303 
2304 void TBufferSQL2::WriteInt(Int_t i)
2305 {
2306  TBufferSQL2_operatorout(i);
2307 }
2308 
2309 ////////////////////////////////////////////////////////////////////////////////
2310 /// Writes UInt_t value to buffer
2311 
2312 void TBufferSQL2::WriteUInt(UInt_t i)
2313 {
2314  TBufferSQL2_operatorout(i);
2315 }
2316 
2317 ////////////////////////////////////////////////////////////////////////////////
2318 /// Writes Long_t value to buffer
2319 
2320 void TBufferSQL2::WriteLong(Long_t l)
2321 {
2322  TBufferSQL2_operatorout(l);
2323 }
2324 
2325 ////////////////////////////////////////////////////////////////////////////////
2326 /// Writes ULong_t value to buffer
2327 
2328 void TBufferSQL2::WriteULong(ULong_t l)
2329 {
2330  TBufferSQL2_operatorout(l);
2331 }
2332 
2333 ////////////////////////////////////////////////////////////////////////////////
2334 /// Writes Long64_t value to buffer
2335 
2336 void TBufferSQL2::WriteLong64(Long64_t l)
2337 {
2338  TBufferSQL2_operatorout(l);
2339 }
2340 
2341 ////////////////////////////////////////////////////////////////////////////////
2342 /// Writes ULong64_t value to buffer
2343 
2344 void TBufferSQL2::WriteULong64(ULong64_t l)
2345 {
2346  TBufferSQL2_operatorout(l);
2347 }
2348 
2349 ////////////////////////////////////////////////////////////////////////////////
2350 /// Writes Float_t value to buffer
2351 
2352 void TBufferSQL2::WriteFloat(Float_t f)
2353 {
2354  TBufferSQL2_operatorout(f);
2355 }
2356 
2357 ////////////////////////////////////////////////////////////////////////////////
2358 /// Writes Double_t value to buffer
2359 
2360 void TBufferSQL2::WriteDouble(Double_t d)
2361 {
2362  TBufferSQL2_operatorout(d);
2363 }
2364 
2365 ////////////////////////////////////////////////////////////////////////////////
2366 /// Writes array of characters to buffer
2367 
2368 void TBufferSQL2::WriteCharP(const Char_t *c)
2369 {
2370  SqlWriteValue(c, sqlio::CharStar);
2371 }
2372 
2373 ////////////////////////////////////////////////////////////////////////////////
2374 /// converts Char_t to string and creates correspondent sql structure
2375 
2376 Bool_t TBufferSQL2::SqlWriteBasic(Char_t value)
2377 {
2378  char buf[50];
2379  snprintf(buf, sizeof(buf), "%d", value);
2380  return SqlWriteValue(buf, sqlio::Char);
2381 }
2382 
2383 ////////////////////////////////////////////////////////////////////////////////
2384 /// converts Short_t to string and creates correspondent sql structure
2385 
2386 Bool_t TBufferSQL2::SqlWriteBasic(Short_t value)
2387 {
2388  char buf[50];
2389  snprintf(buf, sizeof(buf), "%hd", value);
2390  return SqlWriteValue(buf, sqlio::Short);
2391 }
2392 
2393 ////////////////////////////////////////////////////////////////////////////////
2394 /// converts Int_t to string and creates correspondent sql structure
2395 
2396 Bool_t TBufferSQL2::SqlWriteBasic(Int_t value)
2397 {
2398  char buf[50];
2399  snprintf(buf, sizeof(buf), "%d", value);
2400  return SqlWriteValue(buf, sqlio::Int);
2401 }
2402 
2403 ////////////////////////////////////////////////////////////////////////////////
2404 /// converts Long_t to string and creates correspondent sql structure
2405 
2406 Bool_t TBufferSQL2::SqlWriteBasic(Long_t value)
2407 {
2408  char buf[50];
2409  snprintf(buf, sizeof(buf), "%ld", value);
2410  return SqlWriteValue(buf, sqlio::Long);
2411 }
2412 
2413 ////////////////////////////////////////////////////////////////////////////////
2414 /// converts Long64_t to string and creates correspondent sql structure
2415 
2416 Bool_t TBufferSQL2::SqlWriteBasic(Long64_t value)
2417 {
2418  char buf[50];
2419  snprintf(buf, sizeof(buf), "%lld", value);
2420  return SqlWriteValue(buf, sqlio::Long64);
2421 }
2422 
2423 ////////////////////////////////////////////////////////////////////////////////
2424 /// converts Float_t to string and creates correspondent sql structure
2425 
2426 Bool_t TBufferSQL2::SqlWriteBasic(Float_t value)
2427 {
2428  char buf[200];
2429  snprintf(buf, sizeof(buf), TSQLServer::GetFloatFormat(), value);
2430  return SqlWriteValue(buf, sqlio::Float);
2431 }
2432 
2433 ////////////////////////////////////////////////////////////////////////////////
2434 /// converts Double_t to string and creates correspondent sql structure
2435 
2436 Bool_t TBufferSQL2::SqlWriteBasic(Double_t value)
2437 {
2438  char buf[128];
2439  snprintf(buf, sizeof(buf), TSQLServer::GetFloatFormat(), value);
2440  return SqlWriteValue(buf, sqlio::Double);
2441 }
2442 
2443 ////////////////////////////////////////////////////////////////////////////////
2444 /// converts Bool_t to string and creates correspondent sql structure
2445 
2446 Bool_t TBufferSQL2::SqlWriteBasic(Bool_t value)
2447 {
2448  return SqlWriteValue(value ? sqlio::True : sqlio::False, sqlio::Bool);
2449 }
2450 
2451 ////////////////////////////////////////////////////////////////////////////////
2452 /// converts UChar_t to string and creates correspondent sql structure
2453 
2454 Bool_t TBufferSQL2::SqlWriteBasic(UChar_t value)
2455 {
2456  char buf[50];
2457  snprintf(buf, sizeof(buf), "%u", value);
2458  return SqlWriteValue(buf, sqlio::UChar);
2459 }
2460 
2461 ////////////////////////////////////////////////////////////////////////////////
2462 /// converts UShort_t to string and creates correspondent sql structure
2463 
2464 Bool_t TBufferSQL2::SqlWriteBasic(UShort_t value)
2465 {
2466  char buf[50];
2467  snprintf(buf, sizeof(buf), "%hu", value);
2468  return SqlWriteValue(buf, sqlio::UShort);
2469 }
2470 
2471 ////////////////////////////////////////////////////////////////////////////////
2472 /// converts UInt_t to string and creates correspondent sql structure
2473 
2474 Bool_t TBufferSQL2::SqlWriteBasic(UInt_t value)
2475 {
2476  char buf[50];
2477  snprintf(buf, sizeof(buf), "%u", value);
2478  return SqlWriteValue(buf, sqlio::UInt);
2479 }
2480 
2481 ////////////////////////////////////////////////////////////////////////////////
2482 /// converts ULong_t to string and creates correspondent sql structure
2483 
2484 Bool_t TBufferSQL2::SqlWriteBasic(ULong_t value)
2485 {
2486  char buf[50];
2487  snprintf(buf, sizeof(buf), "%lu", value);
2488  return SqlWriteValue(buf, sqlio::ULong);
2489 }
2490 
2491 ////////////////////////////////////////////////////////////////////////////////
2492 /// converts ULong64_t to string and creates correspondent sql structure
2493 
2494 Bool_t TBufferSQL2::SqlWriteBasic(ULong64_t value)
2495 {
2496  char buf[50];
2497  snprintf(buf, sizeof(buf), FULong64, value);
2498  return SqlWriteValue(buf, sqlio::ULong64);
2499 }
2500 
2501 //______________________________________________________________________________
2502 
2503 Bool_t TBufferSQL2::SqlWriteValue(const char* value, const char* tname)
2504 {
2505  // create structure in stack, which holds specified value
2506 
2507  Stack()->AddValue(value, tname);
2508 
2509  return kTRUE;
2510 }
2511 
2512 ////////////////////////////////////////////////////////////////////////////////
2513 /// Read current value from table and convert it to Char_t value
2514 
2515 void TBufferSQL2::SqlReadBasic(Char_t& value)
2516 {
2517  const char* res = SqlReadValue(sqlio::Char);
2518  if (res) {
2519  int n;
2520  sscanf(res,"%d", &n);
2521  value = n;
2522  } else
2523  value = 0;
2524 }
2525 
2526 ////////////////////////////////////////////////////////////////////////////////
2527 /// Read current value from table and convert it to Short_t value
2528 
2529 void TBufferSQL2::SqlReadBasic(Short_t& value)
2530 {
2531  const char* res = SqlReadValue(sqlio::Short);
2532  if (res)
2533  sscanf(res,"%hd", &value);
2534  else
2535  value = 0;
2536 }
2537 
2538 ////////////////////////////////////////////////////////////////////////////////
2539 /// Read current value from table and convert it to Int_t value
2540 
2541 void TBufferSQL2::SqlReadBasic(Int_t& value)
2542 {
2543  const char* res = SqlReadValue(sqlio::Int);
2544  if (res)
2545  sscanf(res,"%d", &value);
2546  else
2547  value = 0;
2548 }
2549 
2550 ////////////////////////////////////////////////////////////////////////////////
2551 /// Read current value from table and convert it to Long_t value
2552 
2553 void TBufferSQL2::SqlReadBasic(Long_t& value)
2554 {
2555  const char* res = SqlReadValue(sqlio::Long);
2556  if (res)
2557  sscanf(res,"%ld", &value);
2558  else
2559  value = 0;
2560 }
2561 
2562 ////////////////////////////////////////////////////////////////////////////////
2563 /// Read current value from table and convert it to Long64_t value
2564 
2565 void TBufferSQL2::SqlReadBasic(Long64_t& value)
2566 {
2567  const char* res = SqlReadValue(sqlio::Long64);
2568  if (res)
2569  sscanf(res, FLong64, &value);
2570  else
2571  value = 0;
2572 }
2573 
2574 ////////////////////////////////////////////////////////////////////////////////
2575 /// Read current value from table and convert it to Float_t value
2576 
2577 void TBufferSQL2::SqlReadBasic(Float_t& value)
2578 {
2579  const char* res = SqlReadValue(sqlio::Float);
2580  if (res)
2581  sscanf(res, "%f", &value);
2582  else
2583  value = 0.;
2584 }
2585 
2586 ////////////////////////////////////////////////////////////////////////////////
2587 /// Read current value from table and convert it to Double_t value
2588 
2589 void TBufferSQL2::SqlReadBasic(Double_t& value)
2590 {
2591  const char* res = SqlReadValue(sqlio::Double);
2592  if (res)
2593  sscanf(res, "%lf", &value);
2594  else
2595  value = 0.;
2596 }
2597 
2598 ////////////////////////////////////////////////////////////////////////////////
2599 /// Read current value from table and convert it to Bool_t value
2600 
2601 void TBufferSQL2::SqlReadBasic(Bool_t& value)
2602 {
2603  const char* res = SqlReadValue(sqlio::Bool);
2604  if (res)
2605  value = (strcmp(res, sqlio::True)==0);
2606  else
2607  value = kFALSE;
2608 }
2609 
2610 ////////////////////////////////////////////////////////////////////////////////
2611 /// Read current value from table and convert it to UChar_t value
2612 
2613 void TBufferSQL2::SqlReadBasic(UChar_t& value)
2614 {
2615  const char* res = SqlReadValue(sqlio::UChar);
2616  if (res) {
2617  unsigned int n;
2618  sscanf(res,"%ud", &n);
2619  value = n;
2620  } else
2621  value = 0;
2622 }
2623 
2624 ////////////////////////////////////////////////////////////////////////////////
2625 /// Read current value from table and convert it to UShort_t value
2626 
2627 void TBufferSQL2::SqlReadBasic(UShort_t& value)
2628 {
2629  const char* res = SqlReadValue(sqlio::UShort);
2630  if (res)
2631  sscanf(res,"%hud", &value);
2632  else
2633  value = 0;
2634 }
2635 
2636 ////////////////////////////////////////////////////////////////////////////////
2637 /// Read current value from table and convert it to UInt_t value
2638 
2639 void TBufferSQL2::SqlReadBasic(UInt_t& value)
2640 {
2641  const char* res = SqlReadValue(sqlio::UInt);
2642  if (res)
2643  sscanf(res,"%u", &value);
2644  else
2645  value = 0;
2646 }
2647 
2648 ////////////////////////////////////////////////////////////////////////////////
2649 /// Read current value from table and convert it to ULong_t value
2650 
2651 void TBufferSQL2::SqlReadBasic(ULong_t& value)
2652 {
2653  const char* res = SqlReadValue(sqlio::ULong);
2654  if (res)
2655  sscanf(res,"%lu", &value);
2656  else
2657  value = 0;
2658 }
2659 
2660 ////////////////////////////////////////////////////////////////////////////////
2661 /// Read current value from table and convert it to ULong64_t value
2662 
2663 void TBufferSQL2::SqlReadBasic(ULong64_t& value)
2664 {
2665  const char* res = SqlReadValue(sqlio::ULong64);
2666  if (res)
2667  sscanf(res, FULong64, &value);
2668  else
2669  value = 0;
2670 }
2671 
2672 ////////////////////////////////////////////////////////////////////////////////
2673 /// Read string value from current stack node
2674 
2675 const char* TBufferSQL2::SqlReadValue(const char* tname)
2676 {
2677  if (fErrorFlag>0) return 0;
2678 
2679  if (fCurrentData==0) {
2680  Error("SqlReadValue","No object data to read from");
2681  fErrorFlag = 1;
2682  return 0;
2683  }
2684 
2685  if (!fIgnoreVerification)
2686  if (!fCurrentData->VerifyDataType(tname)) {
2687  fErrorFlag = 1;
2688  return 0;
2689  }
2690 
2691  fReadBuffer = fCurrentData->GetValue();
2692 
2693  fCurrentData->ShiftToNextValue();
2694 
2695  if (gDebug>4)
2696  std::cout << " SqlReadValue " << tname << " = " << fReadBuffer << std::endl;
2697 
2698  return fReadBuffer.Data();
2699 }
2700 
2701 ////////////////////////////////////////////////////////////////////////////////
2702 /// Read CharStar value, if it has special code, request it from large table
2703 
2704 const char* TBufferSQL2::SqlReadCharStarValue()
2705 {
2706  const char* res = SqlReadValue(sqlio::CharStar);
2707  if ((res==0) || (fSQL==0)) return 0;
2708 
2709  Long64_t objid = Stack()->DefineObjectId(kTRUE);
2710 
2711  Int_t strid = fSQL->IsLongStringCode(objid, res);
2712  if (strid<=0) return res;
2713 
2714  fSQL->GetLongString(objid, strid, fReadBuffer);
2715 
2716  return fReadBuffer.Data();
2717 }
2718 
2719 
2720 ////////////////////////////////////////////////////////////////////////////////
2721 /// Push stack with structurual information about streamed object
2722 
2723 TSQLStructure* TBufferSQL2::PushStack()
2724 {
2725  TSQLStructure* res = new TSQLStructure;
2726  if (fStk==0) {
2727  fStructure = res;
2728  } else {
2729  fStk->Add(res);
2730  }
2731 
2732  fStk = res; // add in the stack
2733  return fStk;
2734 }
2735 
2736 ////////////////////////////////////////////////////////////////////////////////
2737 /// Pop stack
2738 
2739 TSQLStructure* TBufferSQL2::PopStack()
2740 {
2741  if (fStk==0) return 0;
2742  fStk = fStk->GetParent();
2743  return fStk;
2744 }
2745 
2746 ////////////////////////////////////////////////////////////////////////////////
2747 /// returns head of stack
2748 
2749 TSQLStructure* TBufferSQL2::Stack(Int_t depth)
2750 {
2751  TSQLStructure* curr = fStk;
2752  while ((depth-->0) && (curr!=0)) curr = curr->GetParent();
2753  return curr;
2754 }
2755 
2756 
2757 ////////////////////////////////////////////////////////////////////////////////
2758 /// set printf format for float/double members, default "%e"
2759 /// changes global TSQLServer variable
2760 
2761 void TBufferSQL2::SetFloatFormat(const char* fmt)
2762 {
2763  TSQLServer::SetFloatFormat(fmt);
2764 }
2765 
2766 ////////////////////////////////////////////////////////////////////////////////
2767 /// return current printf format for float/double members, default "%e"
2768 /// return format, hold by TSQLServer
2769 
2770 const char* TBufferSQL2::GetFloatFormat()
2771 {
2772  return TSQLServer::GetFloatFormat();
2773 }
2774 
2775 ////////////////////////////////////////////////////////////////////////////////
2776 /// Read one collection of objects from the buffer using the StreamerInfoLoopAction.
2777 /// The collection needs to be a split TClonesArray or a split vector of pointers.
2778 
2779 Int_t TBufferSQL2::ApplySequence(const TStreamerInfoActions::TActionSequence &sequence, void *obj)
2780 {
2781  TVirtualStreamerInfo *info = sequence.fStreamerInfo;
2782  IncrementLevel(info);
2783 
2784  if (gDebug) {
2785  //loop on all active members
2786  TStreamerInfoActions::ActionContainer_t::const_iterator end = sequence.fActions.end();
2787  for(TStreamerInfoActions::ActionContainer_t::const_iterator iter = sequence.fActions.begin();
2788  iter != end;
2789  ++iter) {
2790  // Idea: Try to remove this function call as it is really needed only for XML streaming.
2791  SetStreamerElementNumber((*iter).fConfiguration->fCompInfo->fElem,(*iter).fConfiguration->fCompInfo->fType);
2792  (*iter).PrintDebug(*this,obj);
2793  (*iter)(*this,obj);
2794  }
2795 
2796  } else {
2797  //loop on all active members
2798  TStreamerInfoActions::ActionContainer_t::const_iterator end = sequence.fActions.end();
2799  for(TStreamerInfoActions::ActionContainer_t::const_iterator iter = sequence.fActions.begin();
2800  iter != end;
2801  ++iter) {
2802  // Idea: Try to remove this function call as it is really needed only for XML streaming.
2803  SetStreamerElementNumber((*iter).fConfiguration->fCompInfo->fElem,(*iter).fConfiguration->fCompInfo->fType);
2804  (*iter)(*this,obj);
2805  }
2806  }
2807 
2808  DecrementLevel(info);
2809  return 0;
2810 }
2811 
2812 ////////////////////////////////////////////////////////////////////////////////
2813 /// Read one collection of objects from the buffer using the StreamerInfoLoopAction.
2814 /// The collection needs to be a split TClonesArray or a split vector of pointers.
2815 
2816 Int_t TBufferSQL2::ApplySequenceVecPtr(const TStreamerInfoActions::TActionSequence &sequence, void *start_collection, void *end_collection)
2817 {
2818  TVirtualStreamerInfo *info = sequence.fStreamerInfo;
2819  IncrementLevel(info);
2820 
2821  if (gDebug) {
2822  //loop on all active members
2823  TStreamerInfoActions::ActionContainer_t::const_iterator end = sequence.fActions.end();
2824  for(TStreamerInfoActions::ActionContainer_t::const_iterator iter = sequence.fActions.begin();
2825  iter != end;
2826  ++iter) {
2827  // Idea: Try to remove this function call as it is really needed only for XML streaming.
2828  SetStreamerElementNumber((*iter).fConfiguration->fCompInfo->fElem,(*iter).fConfiguration->fCompInfo->fType);
2829  (*iter).PrintDebug(*this,*(char**)start_collection); // Warning: This limits us to TClonesArray and vector of pointers.
2830  (*iter)(*this,start_collection,end_collection);
2831  }
2832 
2833  } else {
2834  //loop on all active members
2835  TStreamerInfoActions::ActionContainer_t::const_iterator end = sequence.fActions.end();
2836  for(TStreamerInfoActions::ActionContainer_t::const_iterator iter = sequence.fActions.begin();
2837  iter != end;
2838  ++iter) {
2839  // Idea: Try to remove this function call as it is really needed only for XML streaming.
2840  SetStreamerElementNumber((*iter).fConfiguration->fCompInfo->fElem,(*iter).fConfiguration->fCompInfo->fType);
2841  (*iter)(*this,start_collection,end_collection);
2842  }
2843  }
2844 
2845  DecrementLevel(info);
2846  return 0;
2847 }
2848 
2849 ////////////////////////////////////////////////////////////////////////////////
2850 /// Read one collection of objects from the buffer using the StreamerInfoLoopAction.
2851 
2852 Int_t TBufferSQL2::ApplySequence(const TStreamerInfoActions::TActionSequence &sequence, void *start_collection, void *end_collection)
2853 {
2854  TVirtualStreamerInfo *info = sequence.fStreamerInfo;
2855  IncrementLevel(info);
2856 
2857  TStreamerInfoActions::TLoopConfiguration *loopconfig = sequence.fLoopConfig;
2858  if (gDebug) {
2859 
2860  // Get the address of the first item for the PrintDebug.
2861  // (Performance is not essential here since we are going to print to
2862  // the screen anyway).
2863  void *arr0 = loopconfig->GetFirstAddress(start_collection,end_collection);
2864  // loop on all active members
2865  TStreamerInfoActions::ActionContainer_t::const_iterator end = sequence.fActions.end();
2866  for(TStreamerInfoActions::ActionContainer_t::const_iterator iter = sequence.fActions.begin();
2867  iter != end;
2868  ++iter) {
2869  // Idea: Try to remove this function call as it is really needed only for XML streaming.
2870  SetStreamerElementNumber((*iter).fConfiguration->fCompInfo->fElem,(*iter).fConfiguration->fCompInfo->fType);
2871  (*iter).PrintDebug(*this,arr0);
2872  (*iter)(*this,start_collection,end_collection,loopconfig);
2873  }
2874 
2875  } else {
2876  //loop on all active members
2877  TStreamerInfoActions::ActionContainer_t::const_iterator end = sequence.fActions.end();
2878  for(TStreamerInfoActions::ActionContainer_t::const_iterator iter = sequence.fActions.begin();
2879  iter != end;
2880  ++iter) {
2881  // Idea: Try to remove this function call as it is really needed only for XML streaming.
2882  SetStreamerElementNumber((*iter).fConfiguration->fCompInfo->fElem,(*iter).fConfiguration->fCompInfo->fType);
2883  (*iter)(*this,start_collection,end_collection,loopconfig);
2884  }
2885  }
2886 
2887  DecrementLevel(info);
2888  return 0;
2889 }
2890 
TStreamerInfo
Describe Streamer information for one class version.
Definition: TStreamerInfo.h:47
TBufferSQL2::IncrementLevel
virtual void IncrementLevel(TVirtualStreamerInfo *)
Function is called from TStreamerInfo WriteBuffer and Readbuffer functions and indent new level in da...
Definition: TBufferSQL2.cxx:556
TSQLFile::GetBlobClassData
TSQLResult * GetBlobClassData(Long64_t objid, TSQLClassInfo *sqlinfo)
Method return request results for specified objid from streamer classtable.
Definition: TSQLFile.cxx:2485
TBufferSQL2::SqlReadAny
void * SqlReadAny(Long64_t keyid, Long64_t objid, TClass **cl, void *obj=0)
Recreate object from sql structure.
Definition: TBufferSQL2.cxx:207
TBufferSQL2::ReadFastArrayDouble32
virtual void ReadFastArrayDouble32(Double_t *d, Int_t n, TStreamerElement *ele=0)
Read array of Double32_t from buffer.
Definition: TBufferSQL2.cxx:1556
TVirtualStreamerInfo::CanDelete
static Bool_t CanDelete()
static function returning true if ReadBuffer can delete object
Definition: TVirtualStreamerInfo.cxx:78
TSQLObjectDataPool
XML object keeper class.
Definition: TSQLObjectData.h:120
TBufferSQL2::ReadFloat
virtual void ReadFloat(Float_t &f)
Reads Float_t value from buffer.
Definition: TBufferSQL2.cxx:2201
TExMap::Add
void Add(ULong64_t hash, Long64_t key, Long64_t value)
Add an (key,value) pair to the table. The key should be unique.
Definition: TExMap.cxx:87
TBufferSQL2::ReadVersion
virtual Version_t ReadVersion(UInt_t *start=0, UInt_t *bcnt=0, const TClass *cl=0)
Read version value from buffer actually version is normally defined by table name and kept in interme...
Definition: TBufferSQL2.cxx:939
TBufferSQL2_ReadStaticArray
#define TBufferSQL2_ReadStaticArray(vname)
Definition: TBufferSQL2.cxx:1255
TBufferFile
The concrete implementation of TBuffer for writing/reading to/from a ROOT file or socket...
Definition: TBufferFile.h:51
TSQLObjectInfo
Info (classname, version) about object in database.
Definition: TSQLObjectData.h:31
TSQLStructure::GetStreamerInfo
TStreamerInfo * GetStreamerInfo() const
return TStreamerInfo* if type is kSqlStreamerInfo
Definition: TSQLStructure.cxx:560
Long64_t
long long Long64_t
Definition: RtypesCore.h:69
TSQLObjectDataPool::GetClassData
TSQLResult * GetClassData() const
Definition: TSQLObjectData.h:128
TSQLObjectData::ShiftToNextValue
void ShiftToNextValue()
shift to next column or next row in blob data
Definition: TSQLObjectData.cxx:310
TBuffer::IsReading
Bool_t IsReading() const
Definition: TBuffer.h:83
TSQLFile::GetNormalClassDataAll
TSQLResult * GetNormalClassDataAll(Long64_t minobjid, Long64_t maxobjid, TSQLClassInfo *sqlinfo)
Return data for several objects from the range from normal class table.
Definition: TSQLFile.cxx:2470
Version_t
short Version_t
Definition: RtypesCore.h:61
TDataType::GetType
Int_t GetType() const
Definition: TDataType.h:70
TString::Length
Ssiz_t Length() const
Definition: TString.h:390
TVirtualStreamerInfo::GetClass
virtual TClass * GetClass() const =0
TStreamerInfoActions::TActionSequence::fLoopConfig
TLoopConfiguration * fLoopConfig
If this is a bundle of memberwise streaming action, this configures the looping.
Definition: TStreamerInfoActions.h:148
TBufferSQL2::ClassBegin
virtual void ClassBegin(const TClass *, Version_t=-1)
This method inform buffer data of which class now will be streamed.
Definition: TBufferSQL2.cxx:626
Float_t
float Float_t
Definition: RtypesCore.h:53
TBufferSQL2::WriteFastArrayDouble32
virtual void WriteFastArrayDouble32(const Double_t *d, Int_t n, TStreamerElement *ele=0)
Write array of Double32_t to buffer.
Definition: TBufferSQL2.cxx:1980
TBufferSQL2::fObjMap
TExMap * fObjMap
! Map between stored objects and object id
Definition: TBufferSQL2.h:45
TObjArray::GetLast
Int_t GetLast() const
Return index of last object in array.
Definition: TObjArray.cxx:528
TSQLObjectInfo::GetObjVersion
Version_t GetObjVersion() const
Definition: TSQLObjectData.h:41
TSQLStructure::AddValue
void AddValue(const char *value, const char *tname=0)
Add child structure as value.
Definition: TSQLStructure.cxx:658
TBufferSQL2::ReadFastArrayWithFactor
virtual void ReadFastArrayWithFactor(Float_t *ptr, Int_t n, Double_t factor, Double_t minvalue)
Read array of Float16_t from buffer.
Definition: TBufferSQL2.cxx:1540
c
return c
Definition: entrylist_figure1.C:47
TBufferSQL2::ClassMember
virtual void ClassMember(const char *name, const char *typeName=0, Int_t arrsize1=-1, Int_t arrsize2=-1)
Method indicates name and typename of class memeber, which should be now streamed in custom streamer ...
Definition: TBufferSQL2.cxx:678
sqlio::Int
const char * Int
Definition: TSQLStructure.cxx:72
TBufferSQL2::WriteLong64
virtual void WriteLong64(Long64_t l)
Writes Long64_t value to buffer.
Definition: TBufferSQL2.cxx:2336
TObjArray::Delete
virtual void Delete(Option_t *option="")
Remove all objects from the array AND delete all heap based objects.
Definition: TObjArray.cxx:329
TBufferSQL2_WriteFastArray
#define TBufferSQL2_WriteFastArray(vname)
Definition: TBufferSQL2.cxx:1819
TBufferSQL2::ReadLong64
virtual void ReadLong64(Long64_t &l)
Reads Long64_t value from buffer.
Definition: TBufferSQL2.cxx:2185
TBufferSQL2::ReadDouble32
virtual void ReadDouble32(Double_t *d, TStreamerElement *ele=0)
Read Double32 value.
Definition: TBufferSQL2.cxx:1073
TBufferSQL2::ReadTString
virtual void ReadTString(TString &s)
Read a TString.
Definition: TBufferSQL2.cxx:2226
TBufferSQL2::SqlWriteObject
Int_t SqlWriteObject(const void *obj, const TClass *objClass, TMemberStreamer *streamer=0, Int_t streamer_index=0)
Write object to buffer.
Definition: TBufferSQL2.cxx:343
TBufferSQL2::SetFloatFormat
static void SetFloatFormat(const char *fmt="%e")
set printf format for float/double members, default "%e" changes global TSQLServer variable ...
Definition: TBufferSQL2.cxx:2761
TSQLStructure::GetParent
TSQLStructure * GetParent() const
Definition: TSQLStructure.h:136
TBufferFile::ReadTString
virtual void ReadTString(TString &s)
Read TString from TBuffer.
Definition: TBufferFile.cxx:253
TBufferSQL2::ReadFastArrayWithNbits
virtual void ReadFastArrayWithNbits(Float_t *ptr, Int_t n, Int_t nbits)
Read array of Float16_t from buffer.
Definition: TBufferSQL2.cxx:1548
UShort_t
unsigned short UShort_t
Definition: RtypesCore.h:36
h
TH1 * h
Definition: legend2.C:5
TSQLClassInfo::IsClassTableExist
Bool_t IsClassTableExist() const
Definition: TSQLClassInfo.h:72
TClass::IsTObject
Bool_t IsTObject() const
Return kTRUE is the class inherits from TObject.
Definition: TClass.cxx:5462
TObject::Info
virtual void Info(const char *method, const char *msgfmt,...) const
Issue info message.
Definition: TObject.cxx:892
TBufferSQL2::ReadFloat16
virtual void ReadFloat16(Float_t *f, TStreamerElement *ele=0)
Read Float16 value.
Definition: TBufferSQL2.cxx:1065
TBufferSQL2::SkipVersion
virtual void SkipVersion(const TClass *cl=0)
Skip class version from I/O buffer.
Definition: TBufferSQL2.cxx:929
TMap::Add
void Add(TObject *obj)
This function may not be used (but we need to provide it since it is a pure virtual in TCollection)...
Definition: TMap.cxx:53
TSQLFile::IsLongStringCode
Int_t IsLongStringCode(Long64_t objid, const char *value)
Checks if this is long string code returns 0, if not or string id.
Definition: TSQLFile.cxx:2256
gROOT
#define gROOT
Definition: TROOT.h:344
TSQLClassInfo
Contains information about tables specific to one class and version.
Definition: TSQLClassInfo.h:48
TBufferSQL2::ReadUShort
virtual void ReadUShort(UShort_t &s)
Reads UShort_t value from buffer.
Definition: TBufferSQL2.cxx:2145
TBufferSQL2::WriteObjectClass
virtual void WriteObjectClass(const void *actualObjStart, const TClass *actualClass)
Write object to buffer. Only used from TBuffer.
Definition: TBufferSQL2.cxx:1003
sqlio::Long
const char * Long
Definition: TSQLStructure.cxx:73
TString
Basic string class.
Definition: TString.h:137
TBufferSQL2::WriteFastArrayFloat16
virtual void WriteFastArrayFloat16(const Float_t *f, Int_t n, TStreamerElement *ele=0)
Write array of Float16_t to buffer.
Definition: TBufferSQL2.cxx:1972
TBufferSQL2::ReadBool
virtual void ReadBool(Bool_t &b)
Reads Bool_t value from buffer.
Definition: TBufferSQL2.cxx:2113
Int_t
int Int_t
Definition: RtypesCore.h:41
sqlio::ObjectInst
const char * ObjectInst
Definition: TSQLStructure.cxx:54
TBufferSQL2_WriteArray
#define TBufferSQL2_WriteArray(vname)
Definition: TBufferSQL2.cxx:1692
Bool_t
bool Bool_t
Definition: RtypesCore.h:59
TBufferSQL2::fErrorFlag
Int_t fErrorFlag
! Error id value
Definition: TBufferSQL2.h:47
kFALSE
const Bool_t kFALSE
Definition: Rtypes.h:92
TBufferSQL2::fStructure
TSQLStructure * fStructure
! structures, created by object storing
Definition: TBufferSQL2.h:43
TBuffer::SetParent
void SetParent(TObject *parent)
Set parent owning this buffer.
Definition: TBuffer.cxx:237
sqlio::Char
const char * Char
Definition: TSQLStructure.cxx:70
sqlio::Version
const char * Version
Definition: TSQLStructure.cxx:55
TSQLStructure::SetObjectRef
void SetObjectRef(Long64_t refid, const TClass *cl)
set structure type as kSqlObject
Definition: TSQLStructure.cxx:419
TBufferSQL2_ReadArray
#define TBufferSQL2_ReadArray(tname, vname)
Definition: TBufferSQL2.cxx:1053
TBufferSQL2::SqlObjectData
TSQLObjectData * SqlObjectData(Long64_t objid, TSQLClassInfo *sqlinfo)
Creates TSQLObjectData for specifed object id and specified class.
Definition: TBufferSQL2.cxx:277
RooStats::HistFactory::Constraint::GetType
Type GetType(const std::string &Name)
Definition: Systematics.cxx:34
TStreamerElement::SetArrayDim
virtual void SetArrayDim(Int_t dim)
Set number of array dimensions.
Definition: TStreamerElement.cxx:474
TBufferSQL2::WriteFastArray
virtual void WriteFastArray(const Bool_t *b, Int_t n)
Write array of Bool_t to buffer.
Definition: TBufferSQL2.cxx:1851
sqlio::UShort
const char * UShort
Definition: TSQLStructure.cxx:78
TBufferSQL2::ReadStdString
virtual void ReadStdString(std::string &s)
Read a std::string.
Definition: TBufferSQL2.cxx:2242
TBufferSQL2::WriteUChar
virtual void WriteUChar(UChar_t c)
Writes UChar_t value to buffer.
Definition: TBufferSQL2.cxx:2280
sqlio::UInt
const char * UInt
Definition: TSQLStructure.cxx:79
TBufferSQL2::SqlReadArraySize
Int_t SqlReadArraySize()
Reads array size, written in raw data table.
Definition: TBufferSQL2.cxx:1651
TStreamerElement::SetMaxIndex
virtual void SetMaxIndex(Int_t dim, Int_t max)
set maximum index for array with dimension dim
Definition: TStreamerElement.cxx:484
TBufferSQL2::fIgnoreVerification
Bool_t fIgnoreVerification
! ignore verification of names
Definition: TBufferSQL2.h:52
TBufferSQL2::fReadVersionBuffer
Int_t fReadVersionBuffer
! buffer, used to by ReadVersion method
Definition: TBufferSQL2.h:50
TSQLServer::GetFloatFormat
static const char * GetFloatFormat()
return current printf format for float/double members, default "%e"
Definition: TSQLServer.cxx:269
TBufferSQL2::PushStack
TSQLStructure * PushStack()
Push stack with structurual information about streamed object.
Definition: TBufferSQL2.cxx:2723
f
TFile * f
Definition: memstatExample.C:52
TSQLStructure::SetStreamerInfo
void SetStreamerInfo(const TStreamerInfo *info)
set structure type as kSqlStreamerInfo
Definition: TSQLStructure.cxx:458
TSQLObjectData
TSQLObjectData is used in TBufferSQL2 class in reading procedure.
Definition: TSQLObjectData.h:54
TObject::SetBit
void SetBit(UInt_t f, Bool_t set)
Set or unset the user status bits as specified in f.
Definition: TObject.cxx:732
TBufferSQL2::ReadUInt
virtual void ReadUInt(UInt_t &i)
Reads UInt_t value from buffer.
Definition: TBufferSQL2.cxx:2161
TBufferSQL2::WorkWithElement
void WorkWithElement(TStreamerElement *elem, Int_t comp_type)
This function is a part of SetStreamerElementNumber method.
Definition: TBufferSQL2.cxx:848
TBufferSQL2::ReadArray
virtual Int_t ReadArray(Bool_t *&b)
Read array of Bool_t from buffer.
Definition: TBufferSQL2.cxx:1137
FLong64
#define FLong64
Definition: TBufferSQL2.cxx:59
TBufferSQL2::ReadInt
virtual void ReadInt(Int_t &i)
Reads Int_t value from buffer.
Definition: TBufferSQL2.cxx:2153
TString::Data
const char * Data() const
Definition: TString.h:349
TSQLStructure::Add
void Add(TSQLStructure *child)
Add child strucure.
Definition: TSQLStructure.cxx:637
TBufferSQL2::WriteDouble
virtual void WriteDouble(Double_t d)
Writes Double_t value to buffer.
Definition: TBufferSQL2.cxx:2360
TVirtualStreamerInfo::GetClassVersion
virtual Int_t GetClassVersion() const =0
TSQLStructure::UnpackTObject
static Bool_t UnpackTObject(TSQLFile *f, TBufferSQL2 *buf, TSQLObjectData *data, Long64_t objid, Int_t clversion)
Unpack TObject data in form, understodable by custom TObject streamer.
Definition: TSQLStructure.cxx:2322
sqlio::True
const char * True
Definition: TSQLStructure.cxx:83
TStreamerInfoActions::TLoopConfiguration::GetFirstAddress
virtual void * GetFirstAddress(void *start, const void *end) const =0
TSQLStructure::SetStreamerElement
void SetStreamerElement(const TStreamerElement *elem, Int_t number)
set structure type as kSqlElement
Definition: TSQLStructure.cxx:467
TFile::GetCompressionLevel
Int_t GetCompressionLevel() const
Definition: TFile.h:357
Class
void Class()
Definition: Class.C:29
TBufferSQL2::fSQL
TSQLFile * fSQL
! instance of TSQLFile
Definition: TBufferSQL2.h:42
tornado.d
int d
Definition: tornado.py:11
TClass::New
void * New(ENewType defConstructor=kClassNew, Bool_t quiet=kFALSE) const
Return a pointer to a newly allocated object of this class.
Definition: TClass.cxx:4602
TBufferSQL2::WriteShort
virtual void WriteShort(Short_t s)
Writes Short_t value to buffer.
Definition: TBufferSQL2.cxx:2288
TBufferSQL2::WriteBool
virtual void WriteBool(Bool_t b)
Writes Bool_t value to buffer.
Definition: TBufferSQL2.cxx:2264
TBufferSQL2::WriteULong
virtual void WriteULong(ULong_t l)
Writes ULong_t value to buffer.
Definition: TBufferSQL2.cxx:2328
TBufferSQL2::SqlReadObject
void * SqlReadObject(void *obj, TClass **cl=0, TMemberStreamer *streamer=0, Int_t streamer_index=0, const TClass *onFileClass=0)
Read object from the buffer.
Definition: TBufferSQL2.cxx:398
iter
std::map< std::string, std::string >::const_iterator iter
Definition: TAlienJob.cxx:54
TSQLStructure
This is hierarhical structure, which is created when data is written by TBufferSQL2.
Definition: TSQLStructure.h:107
TSQLObjectDataPool::GetSqlInfo
TSQLClassInfo * GetSqlInfo() const
Definition: TSQLObjectData.h:127
TSQLObjectData::GetBlobPrefixName
const char * GetBlobPrefixName() const
Definition: TSQLObjectData.h:80
TBufferSQL2::WriteUShort
virtual void WriteUShort(UShort_t s)
Writes UShort_t value to buffer.
Definition: TBufferSQL2.cxx:2296
TMap::GetValue
TObject * GetValue(const char *keyname) const
Returns a pointer to the value associated with keyname as name of the key.
Definition: TMap.cxx:235
TString::Atoi
Int_t Atoi() const
Return integer value of string.
Definition: TString.cxx:1951
TObject::Error
virtual void Error(const char *method, const char *msgfmt,...) const
Issue error message.
Definition: TObject.cxx:918
TStreamerInfoActions::TLoopConfiguration
Base class of the Configurations for the member wise looping routines.
Definition: TStreamerInfoActions.h:51
TBufferSQL2::WriteClass
virtual void WriteClass(const TClass *cl)
Suppressed function of TBuffer.
Definition: TBufferSQL2.cxx:899
TBufferSQL2::WriteTString
virtual void WriteTString(const TString &s)
Write a TString.
Definition: TBufferSQL2.cxx:2234
TSQLFile::GetLongString
Bool_t GetLongString(Long64_t objid, Int_t strid, TString &value)
Returns value of string, extracted from special table, where long strings are stored.
Definition: TSQLFile.cxx:2293
TBufferSQL2::SqlWriteBasic
Bool_t SqlWriteBasic(Char_t value)
converts Char_t to string and creates correspondent sql structure
Definition: TBufferSQL2.cxx:2376
sqlio::UChar
const char * UChar
Definition: TSQLStructure.cxx:77
sqlio::Float
const char * Float
Definition: TSQLStructure.cxx:75
TBufferSQL2::WriteULong64
virtual void WriteULong64(ULong64_t l)
Writes ULong64_t value to buffer.
Definition: TBufferSQL2.cxx:2344
TSQLStructure::LocateElementColumn
Int_t LocateElementColumn(TSQLFile *f, TBufferSQL2 *buf, TSQLObjectData *data)
find column in TSQLObjectData object, which correspond to current element
Definition: TSQLStructure.cxx:2141
TBufferFile::WriteTString
virtual void WriteTString(const TString &s)
Write TString to TBuffer.
Definition: TBufferFile.cxx:278
TBufferSQL2::ReadStaticArrayDouble32
virtual Int_t ReadStaticArrayDouble32(Double_t *d, TStreamerElement *ele=0)
Read array of Double32_t from buffer.
Definition: TBufferSQL2.cxx:1379
TBufferSQL2::TBufferSQL2
TBufferSQL2()
Default constructor, should not be used.
Definition: TBufferSQL2.cxx:68
TBufferSQL2::GetFloatFormat
static const char * GetFloatFormat()
return current printf format for float/double members, default "%e" return format, hold by TSQLServer
Definition: TBufferSQL2.cxx:2770
TSQLStructure::UnpackTString
static Bool_t UnpackTString(TSQLFile *f, TBufferSQL2 *buf, TSQLObjectData *data, Long64_t objid, Int_t clversion)
Unpack TString data in form, understodable by custom TString streamer.
Definition: TSQLStructure.cxx:2353
TBufferSQL2::ReadCharP
virtual void ReadCharP(Char_t *c)
Reads array of characters from buffer.
Definition: TBufferSQL2.cxx:2217
TSQLStructure::GetObjectData
TSQLObjectData * GetObjectData(Bool_t search=false)
searchs for objects data
Definition: TSQLStructure.cxx:713
TBufferSQL2::WriteArrayDouble32
virtual void WriteArrayDouble32(const Double_t *d, Int_t n, TStreamerElement *ele=0)
Write array of Double32_t to buffer.
Definition: TBufferSQL2.cxx:1812
TObjArray::IndexOf
Int_t IndexOf(const TObject *obj) const
Definition: TObjArray.cxx:552
TSQLStructure::GetType
Int_t GetType() const
Definition: TSQLStructure.h:142
TExMap::GetValue
Long64_t GetValue(ULong64_t hash, Long64_t key)
Return the value belonging to specified key and hash value.
Definition: TExMap.cxx:173
TStreamerInfo::GetElements
TObjArray * GetElements() const
Definition: TStreamerInfo.h:215
TSQLFile
Access an SQL db via the TFile interface.
Definition: TSQLFile.h:32
sqlio::Array
const char * Array
Definition: TSQLStructure.cxx:68
TSQLObjectInfo::GetObjClassName
const char * GetObjClassName() const
Definition: TSQLObjectData.h:40
TSQLStructure::SetCustomClass
void SetCustomClass(const TClass *cl, Version_t version)
set structure type as kSqlCustomClass
Definition: TSQLStructure.cxx:477
TDataType
Basic data type descriptor (datatype information is obtained from CINT).
Definition: TDataType.h:46
TBufferSQL2::WriteLong
virtual void WriteLong(Long_t l)
Writes Long_t value to buffer.
Definition: TBufferSQL2.cxx:2320
TBufferFile::ReadStdString
virtual void ReadStdString(std::string &s)
Read std::string from TBuffer.
Definition: TBufferFile.cxx:297
TBufferSQL2::fStk
TSQLStructure * fStk
! pointer on current active structure (stack head)
Definition: TBufferSQL2.h:44
TSQLStructure::ChangeValueOnly
void ChangeValueOnly(const char *value)
change value of this structure used as "workaround" to keep object id in kSqlElement node ...
Definition: TSQLStructure.cxx:507
TSQLFile::FindSQLClassInfo
TSQLClassInfo * FindSQLClassInfo(const char *clname, Int_t version)
Return (if exists) TSQLClassInfo for specified class name and version.
Definition: TSQLFile.cxx:1790
TBufferSQL2::ReadArrayFloat16
virtual Int_t ReadArrayFloat16(Float_t *&f, TStreamerElement *ele=0)
Read array of Float16_t from buffer.
Definition: TBufferSQL2.cxx:1241
TSQLFile::GetBlobClassDataStmt
TSQLStatement * GetBlobClassDataStmt(Long64_t objid, TSQLClassInfo *sqlinfo)
Method return request results for specified objid from streamer classtable Data returned in form of s...
Definition: TSQLFile.cxx:2502
TSQLObjectData::VerifyDataType
Bool_t VerifyDataType(const char *tname, Bool_t errormsg=kTRUE)
checks if data type corresponds to that stored in raw table
Definition: TSQLObjectData.cxx:350
TSQLServer::SetFloatFormat
static void SetFloatFormat(const char *fmt="%e")
set printf format for float/double members, default "%e"
Definition: TSQLServer.cxx:260
TBufferSQL2::ReadArrayDouble32
virtual Int_t ReadArrayDouble32(Double_t *&d, TStreamerElement *ele=0)
Read array of Double32_t from buffer.
Definition: TBufferSQL2.cxx:1249
TString::Form
void Form(const char *fmt,...)
Formats a string using a printf style format descriptor.
Definition: TString.cxx:2308
UInt_t
unsigned int UInt_t
Definition: RtypesCore.h:42
sqlio::ULong
const char * ULong
Definition: TSQLStructure.cxx:80
TBufferSQL2::Stack
TSQLStructure * Stack(Int_t depth=0)
returns head of stack
Definition: TBufferSQL2.cxx:2749
Short_t
short Short_t
Definition: RtypesCore.h:35
l
TLine * l
Definition: textangle.C:4
TNamed::GetName
virtual const char * GetName() const
Returns name of object.
Definition: TNamed.h:51
sqlio::Double
const char * Double
Definition: TSQLStructure.cxx:76
TSQLFile::SQLObjectsInfo
TObjArray * SQLObjectsInfo(Long64_t keyid)
Produce array of TSQLObjectInfo objects for all objects, belong to that key Array should be deleted b...
Definition: TSQLFile.cxx:2393
TClass
The ROOT global object gROOT contains a list of all defined classes.
Definition: TClass.h:81
TSQLStructure::AddObjectData
void AddObjectData(TSQLObjectData *objdata)
add element with pointer to object data
Definition: TSQLStructure.cxx:703
TBufferSQL2::WriteArray
virtual void WriteArray(const Bool_t *b, Int_t n)
Write array of Bool_t to buffer.
Definition: TBufferSQL2.cxx:1700
TSQLObjectData::IsBlobData
Bool_t IsBlobData() const
Definition: TSQLObjectData.h:72
TClass::GetClassVersion
Version_t GetClassVersion() const
Definition: TClass.h:381
ClassImp
ClassImp(TBufferSQL2)
TBufferSQL2::ReadClass
virtual TClass * ReadClass(const TClass *cl=0, UInt_t *objTag=0)
Suppressed function of TBuffer.
Definition: TBufferSQL2.cxx:891
TBufferSQL2::ReadStaticArray
virtual Int_t ReadStaticArray(Bool_t *b)
Read array of Bool_t from buffer.
Definition: TBufferSQL2.cxx:1267
TSQLObjectDataPool::GetObjectRow
TSQLRow * GetObjectRow(Long64_t objid)
Returns single sql row with object data for that class.
Definition: TSQLObjectData.cxx:446
TBufferSQL2::ClassEnd
virtual void ClassEnd(const TClass *)
Method indicates end of streaming of classdata in custom streamer.
Definition: TBufferSQL2.cxx:658
TMap::DeleteValues
void DeleteValues()
Remove all (key,value) pairs from the map AND delete the values when they are allocated on the heap...
Definition: TMap.cxx:150
TBufferSQL2::ReadWithFactor
virtual void ReadWithFactor(Float_t *ptr, Double_t factor, Double_t minvalue)
Read a Double32_t from the buffer when the factor and minimun value have been specified see comments ...
Definition: TBufferSQL2.cxx:1083
TSQLStructure::SetCustomElement
void SetCustomElement(TStreamerElement *elem)
set structure type as kSqlCustomElement
Definition: TSQLStructure.cxx:487
TSQLObjectData::PrepareForRawData
Bool_t PrepareForRawData()
prepare to read data from raw table
Definition: TSQLObjectData.cxx:384
TBufferSQL2::ReadFastArrayFloat16
virtual void ReadFastArrayFloat16(Float_t *f, Int_t n, TStreamerElement *ele=0)
Read array of Float16_t from buffer.
Definition: TBufferSQL2.cxx:1532
TBufferSQL2
Converts data to SQL statements or read data from SQL tables.
Definition: TBufferSQL2.h:36
Long_t
long Long_t
Definition: RtypesCore.h:50
TBufferSQL2::ReadDouble
virtual void ReadDouble(Double_t &d)
Reads Double_t value from buffer.
Definition: TBufferSQL2.cxx:2209
TBufferSQL2::ReadWithNbits
virtual void ReadWithNbits(Float_t *ptr, Int_t nbits)
Read a Float16_t from the buffer when the number of bits is specified (explicitly or not) see comment...
Definition: TBufferSQL2.cxx:1093
FULong64
#define FULong64
Definition: TBufferSQL2.cxx:60
TBufferSQL2::SqlReadBasic
void SqlReadBasic(Char_t &value)
Read current value from table and convert it to Char_t value.
Definition: TBufferSQL2.cxx:2515
TSQLStructure::SetObjectPointer
void SetObjectPointer(Long64_t ptrid)
set structure type as kSqlPointer
Definition: TSQLStructure.cxx:429
TSQLStructure::AddVersion
void AddVersion(const TClass *cl, Int_t version=-100)
add child as version
Definition: TSQLStructure.cxx:648
TSQLObjectData::GetLocatedField
const char * GetLocatedField() const
Definition: TSQLObjectData.h:79
fildir.file
tuple file
Definition: fildir.py:20
TSQLObjectData::GetValue
const char * GetValue() const
Definition: TSQLObjectData.h:78
TSQLObjectInfo::GetObjId
Long64_t GetObjId() const
Definition: TSQLObjectData.h:39
Double_t
double Double_t
Definition: RtypesCore.h:55
TSQLClassInfo::GetClassTableName
const char * GetClassTableName() const
Definition: TSQLClassInfo.h:65
TMap
TMap implements an associative array of (key,value) pairs using a THashTable for efficient retrieval ...
Definition: TMap.h:44
ULong64_t
unsigned long long ULong64_t
Definition: RtypesCore.h:70
TBufferSQL2::SqlReadCharStarValue
const char * SqlReadCharStarValue()
Read CharStar value, if it has special code, request it from large table.
Definition: TBufferSQL2.cxx:2704
ULong_t
unsigned long ULong_t
Definition: RtypesCore.h:51
sqlio::ObjectPtr
const char * ObjectPtr
Definition: TSQLStructure.cxx:53
TBufferSQL2::SqlWriteValue
Bool_t SqlWriteValue(const char *value, const char *tname)
Definition: TBufferSQL2.cxx:2503
TSQLStructure::GetElement
TStreamerElement * GetElement() const
return TStremerElement* if type is kSqlElement
Definition: TSQLStructure.cxx:568
TBufferSQL2::SkipObjectAny
virtual void SkipObjectAny()
?????? Skip any kind of object from buffer !!!!!! fix me, not yet implemented Should be just skip of ...
Definition: TBufferSQL2.cxx:996
TBufferSQL2::WriteFloat
virtual void WriteFloat(Float_t f)
Writes Float_t value to buffer.
Definition: TBufferSQL2.cxx:2352
TBufferSQL2::WorkWithClass
void WorkWithClass(const char *classname, Version_t classversion)
This function is a part of IncrementLevel method.
Definition: TBufferSQL2.cxx:797
TBufferSQL2::WriteArrayFloat16
virtual void WriteArrayFloat16(const Float_t *f, Int_t n, TStreamerElement *ele=0)
Write array of Float16_t to buffer.
Definition: TBufferSQL2.cxx:1804
TBufferFile::ForceWriteInfo
virtual void ForceWriteInfo(TVirtualStreamerInfo *info, Bool_t force)
force writing the TStreamerInfo to the file
Definition: TBufferFile.cxx:3589
TBufferFile::WriteObject
virtual void WriteObject(const TObject *obj)
Write object to I/O buffer.
Definition: TBufferFile.cxx:2509
TBufferSQL2::SetCompressionLevel
void SetCompressionLevel(int level)
Definition: TBufferSQL2.h:123
sqlio::ULong64
const char * ULong64
Definition: TSQLStructure.cxx:81
TClass::GetClass
static TClass * GetClass(const char *name, Bool_t load=kTRUE, Bool_t silent=kFALSE)
Static method returning pointer to TClass of the specified class name.
Definition: TClass.cxx:2801
TBufferSQL2::WriteDouble32
virtual void WriteDouble32(Double_t *d, TStreamerElement *ele=0)
Write Double32 value.
Definition: TBufferSQL2.cxx:1129
TBufferSQL2::ReadChar
virtual void ReadChar(Char_t &c)
Reads Char_t value from buffer.
Definition: TBufferSQL2.cxx:2121
sqlio::CharStar
const char * CharStar
Definition: TSQLStructure.cxx:82
name
#define name(a, b)
Definition: linkTestLib0.cpp:5
sqlio::Bool
const char * Bool
Definition: TSQLStructure.cxx:69
TBufferSQL2::WriteInt
virtual void WriteInt(Int_t i)
Writes Int_t value to buffer.
Definition: TBufferSQL2.cxx:2304
TObject
Mother of all ROOT objects.
Definition: TObject.h:58
TBufferSQL2_operatorin
#define TBufferSQL2_operatorin(vname)
Definition: TBufferSQL2.cxx:2105
Char_t
char Char_t
Definition: RtypesCore.h:29
TObjArray::Last
TObject * Last() const
Return the object in the last filled slot. Returns 0 if no entries.
Definition: TObjArray.cxx:479
TBufferSQL2::DecrementLevel
virtual void DecrementLevel(TVirtualStreamerInfo *)
Function is called from TStreamerInfo WriteBuffer and Readbuffer functions and decrease level in sql ...
Definition: TBufferSQL2.cxx:572
TBufferSQL2::SqlObjectInfo
Bool_t SqlObjectInfo(Long64_t objid, TString &clname, Version_t &version)
Returns object info like classname and version Should be taken from buffer, which is produced in the ...
Definition: TBufferSQL2.cxx:233
TBufferSQL2::WriteObject
virtual void WriteObject(const TObject *obj)
Convert object into sql structures.
Definition: TBufferSQL2.cxx:333
fildir.obj1
tuple obj1
Definition: fildir.py:72
TSQLStructure::DefineObjectId
Long64_t DefineObjectId(Bool_t recursive=kTRUE)
defines current object id, to which this structure belong make life complicated, because some objects...
Definition: TSQLStructure.cxx:670
TBufferSQL2::ReadShort
virtual void ReadShort(Short_t &s)
Reads Short_t value from buffer.
Definition: TBufferSQL2.cxx:2137
TBufferFile::WriteStdString
virtual void WriteStdString(const std::string &s)
Write std::string to TBuffer.
Definition: TBufferFile.cxx:325
TBuffer::fBufSize
Int_t fBufSize
Definition: TBuffer.h:49
TStreamerElement::GetType
Int_t GetType() const
Definition: TStreamerElement.h:107
gDebug
R__EXTERN Int_t gDebug
Definition: Rtypes.h:128
TBufferSQL2::fObjIdCounter
Long64_t fObjIdCounter
! counter of objects id
Definition: TBufferSQL2.h:51
TBufferFile::WriteObjectAny
virtual Int_t WriteObjectAny(const void *obj, const TClass *ptrClass)
Write object to I/O buffer.
Definition: TBufferFile.cxx:2608
TBufferSQL2::ReadObjectAny
virtual void * ReadObjectAny(const TClass *clCast)
Read object from buffer. Only used from TBuffer.
Definition: TBufferSQL2.cxx:986
TBufferSQL2_operatorout
#define TBufferSQL2_operatorout(vname)
Definition: TBufferSQL2.cxx:2256
TBufferSQL2_ReadFastArray
#define TBufferSQL2_ReadFastArray(vname)
Definition: TBufferSQL2.cxx:1386
TStreamerBase::SetBaseVersion
void SetBaseVersion(Int_t v)
Definition: TStreamerElement.h:176
TBufferSQL2::WriteVersion
virtual UInt_t WriteVersion(const TClass *cl, Bool_t useBcnt=kFALSE)
Copies class version to buffer, but not writes it to sql immidiately Version will be used to produce ...
Definition: TBufferSQL2.cxx:972
UChar_t
unsigned char UChar_t
Definition: RtypesCore.h:34
TBufferSQL2::TSQLStructure
friend class TSQLStructure
Definition: TBufferSQL2.h:38
TBufferSQL2::~TBufferSQL2
virtual ~TBufferSQL2()
Destroy sql buffer.
Definition: TBufferSQL2.cxx:156
TBufferSQL2::SqlWriteAny
TSQLStructure * SqlWriteAny(const void *obj, const TClass *cl, Long64_t objid)
Convert object of any class to sql structures Return pointer on created TSQLStructure TSQLStructure o...
Definition: TBufferSQL2.cxx:181
TBufferSQL2::ReadULong
virtual void ReadULong(ULong_t &l)
Reads ULong_t value from buffer.
Definition: TBufferSQL2.cxx:2177
TBufferSQL2::ReadULong64
virtual void ReadULong64(ULong64_t &l)
Reads ULong64_t value from buffer.
Definition: TBufferSQL2.cxx:2193
TObjArray::At
TObject * At(Int_t idx) const
Definition: TObjArray.h:167
TBufferSQL2::SetByteCount
virtual void SetByteCount(UInt_t cntpos, Bool_t packInVersion=kFALSE)
Suppressed function of TBuffer.
Definition: TBufferSQL2.cxx:922
TClass::Streamer
void Streamer(void *obj, TBuffer &b, const TClass *onfile_class=0) const
Definition: TClass.h:539
TBufferSQL2::WriteStdString
virtual void WriteStdString(const std::string &s)
Write a std::string.
Definition: TBufferSQL2.cxx:2250
TBufferSQL2::WriteCharP
virtual void WriteCharP(const Char_t *c)
Writes array of characters to buffer.
Definition: TBufferSQL2.cxx:2368
TVirtualStreamerInfo
Abstract Interface class describing Streamer information for one class.
Definition: TVirtualStreamerInfo.h:41
kTRUE
const Bool_t kTRUE
Definition: Rtypes.h:91
TBufferSQL2::CheckByteCount
virtual Int_t CheckByteCount(UInt_t startpos, UInt_t bcnt, const TClass *clss)
Suppressed function of TBuffer.
Definition: TBufferSQL2.cxx:906
TBufferSQL2::fFirstObjId
Long64_t fFirstObjId
! id of first object to be read from the database
Definition: TBufferSQL2.h:55
TBufferSQL2::fReadBuffer
TString fReadBuffer
! Buffer for read value
Definition: TBufferSQL2.h:46
obj
TObject * obj
Definition: TStreamerInfo.cxx:83
TBufferSQL2::fLastObjId
Long64_t fLastObjId
! id of last object correspond to this key
Definition: TBufferSQL2.h:56
value
float value
Definition: math.cpp:443
TBufferSQL2::fObjectsInfos
TObjArray * fObjectsInfos
! array of objects info for selected key
Definition: TBufferSQL2.h:54
TBufferSQL2::ApplySequenceVecPtr
virtual Int_t ApplySequenceVecPtr(const TStreamerInfoActions::TActionSequence &sequence, void *start_collection, void *end_collection)
Read one collection of objects from the buffer using the StreamerInfoLoopAction.
Definition: TBufferSQL2.cxx:2816
TBufferSQL2::fExpectedChain
Bool_t fExpectedChain
! flag to resolve situation when several elements of same basic type stored as FastArray ...
Definition: TBufferSQL2.h:48
sqlio::ObjectRef
const char * ObjectRef
Definition: TSQLStructure.cxx:51
n
const Int_t n
Definition: legend1.C:16
TSQLStructure::Print
virtual void Print(Option_t *option="") const
print content of complete structure
Definition: TSQLStructure.cxx:726
TBufferSQL2::WriteUInt
virtual void WriteUInt(UInt_t i)
Writes UInt_t value to buffer.
Definition: TBufferSQL2.cxx:2312
TBufferSQL2::fPoolsMap
TMap * fPoolsMap
! map of pools with data from different tables
Definition: TBufferSQL2.h:57
TMemberStreamer::SetOnFileClass
virtual void SetOnFileClass(const TClass *cl)
Definition: TMemberStreamer.h:38
TClass::Size
Int_t Size() const
Return size of object of this class.
Definition: TClass.cxx:5243
TExMap
This class stores a (key,value) pair using an external hash.
Definition: TExMap.h:35
TBufferSQL2::PopStack
TSQLStructure * PopStack()
Pop stack.
Definition: TBufferSQL2.cxx:2739
TBufferSQL2::SqlReadObjectDirect
void * SqlReadObjectDirect(void *obj, TClass **cl, Long64_t objid, TMemberStreamer *streamer=0, Int_t streamer_index=0, const TClass *onFileClass=0)
Read object data.
Definition: TBufferSQL2.cxx:471
TBufferSQL2::ReadStaticArrayFloat16
virtual Int_t ReadStaticArrayFloat16(Float_t *f, TStreamerElement *ele=0)
Read array of Float16_t from buffer.
Definition: TBufferSQL2.cxx:1371
TBufferSQL2::ReadUChar
virtual void ReadUChar(UChar_t &c)
Reads UChar_t value from buffer.
Definition: TBufferSQL2.cxx:2129
sqlio::Long64
const char * Long64
Definition: TSQLStructure.cxx:74
TBufferSQL2::fCurrentData
TSQLObjectData * fCurrentData
!
Definition: TBufferSQL2.h:53
TBufferSQL2::SqlReadValue
const char * SqlReadValue(const char *tname)
Read string value from current stack node.
Definition: TBufferSQL2.cxx:2675
sqlio::False
const char * False
Definition: TSQLStructure.cxx:84
TString::Resize
void Resize(Ssiz_t n)
Resize the string. Truncate or add blanks as necessary.
Definition: TString.cxx:1045
TBufferSQL2::WriteFloat16
virtual void WriteFloat16(Float_t *f, TStreamerElement *ele=0)
Write Float16 value.
Definition: TBufferSQL2.cxx:1121
TBufferSQL2::ReadFastArray
virtual void ReadFastArray(Bool_t *b, Int_t n)
Read array of Bool_t from buffer.
Definition: TBufferSQL2.cxx:1417
TBufferSQL2::ApplySequence
virtual Int_t ApplySequence(const TStreamerInfoActions::TActionSequence &sequence, void *object)
Read one collection of objects from the buffer using the StreamerInfoLoopAction.
Definition: TBufferSQL2.cxx:2779
TBufferSQL2::ReadLong
virtual void ReadLong(Long_t &l)
Reads Long_t value from buffer.
Definition: TBufferSQL2.cxx:2169
TBufferSQL2::SetStreamerElementNumber
virtual void SetStreamerElementNumber(TStreamerElement *elem, Int_t comp_type)
Function is called from TStreamerInfo WriteBuffer and Readbuffer functions and add/verify next elemen...
Definition: TBufferSQL2.cxx:592
TBufferSQL2::StreamObject
virtual void StreamObject(void *obj, const type_info &typeinfo, const TClass *onFileClass=0)
Stream object to/from buffer.
Definition: TBufferSQL2.cxx:2053
TBufferSQL2::WriteChar
virtual void WriteChar(Char_t c)
Writes Char_t value to buffer.
Definition: TBufferSQL2.cxx:2272
TStreamerInfoActions::TActionSequence::fStreamerInfo
TVirtualStreamerInfo * fStreamerInfo
StreamerInfo used to derive these actions.
Definition: TStreamerInfoActions.h:147
sqlio::Short
const char * Short
Definition: TSQLStructure.cxx:71
TString::Hash
UInt_t Hash(ECaseCompare cmp=kExact) const
Return hash value.
Definition: TString.cxx:592