Logo ROOT  
Reference Guide
TBufferSQL.cxx
Go to the documentation of this file.
1// @(#)root/tree:$Id$
2// Author: Philippe Canal and al. 08/2004
3
4/*************************************************************************
5 * Copyright (C) 1995-2000, 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/** \class TBufferSQL
13\ingroup tree
14Implement TBuffer for a SQL backend.
15*/
16
17#include "TError.h"
18
19#include "TBasketSQL.h"
20#include "TBufferSQL.h"
21#include "TSQLResult.h"
22#include "TSQLRow.h"
23
24#include <cstdio>
25#include <cstdlib>
26#include <iostream>
27
29
30////////////////////////////////////////////////////////////////////////////////
31/// Constructor.
32
34 TString *insert_query, TSQLRow ** r) :
36 fColumnVec(vc), fInsertQuery(insert_query), fRowPtr(r)
37{
38 fIter = fColumnVec->begin();
39}
40
41////////////////////////////////////////////////////////////////////////////////
42/// Constructor.
43
44TBufferSQL::TBufferSQL(TBuffer::EMode mode, Int_t bufsiz, std::vector<Int_t> *vc,
45 TString *insert_query, TSQLRow ** r) :
46 TBufferFile(mode,bufsiz),
47 fColumnVec(vc), fInsertQuery(insert_query), fRowPtr(r)
48{
49 fIter = fColumnVec->begin();
50}
51
52////////////////////////////////////////////////////////////////////////////////
53/// Constructor.
54
55TBufferSQL::TBufferSQL(TBuffer::EMode mode, Int_t bufsiz, std::vector<Int_t> *vc,
56 TString *insert_query, TSQLRow ** r,
57 void *buf, Bool_t adopt) :
58 TBufferFile(mode,bufsiz,buf,adopt),
59 fColumnVec(vc), fInsertQuery(insert_query), fRowPtr(r)
60{
61 fIter = fColumnVec->begin();
62}
63
64////////////////////////////////////////////////////////////////////////////////
65/// Constructor.
66
67TBufferSQL::TBufferSQL() : TBufferFile(), fColumnVec(0),fInsertQuery(0),fRowPtr(0)
68{
69}
70
71////////////////////////////////////////////////////////////////////////////////
72/// Destructor.
73
75{
76 delete fColumnVec;
77}
78
79////////////////////////////////////////////////////////////////////////////////
80/// Operator>>
81
83{
84 b = (Bool_t)atoi((*fRowPtr)->GetField(*fIter));
85
86 if (fIter != fColumnVec->end()) ++fIter;
87}
88
89////////////////////////////////////////////////////////////////////////////////
90/// Operator>>
91
93{
94 c = (Char_t)atoi((*fRowPtr)->GetField(*fIter));
95
96 if (fIter != fColumnVec->end()) ++fIter;
97}
98
99////////////////////////////////////////////////////////////////////////////////
100/// Operator>>
101
103{
104 h = (Short_t)atoi((*fRowPtr)->GetField(*fIter));
105
106 if (fIter != fColumnVec->end()) ++fIter;
107}
108
109////////////////////////////////////////////////////////////////////////////////
110/// Operator>>
111
113{
114 i = atoi((*fRowPtr)->GetField(*fIter));
115
116 if (fIter != fColumnVec->end()) ++fIter;
117}
118
119////////////////////////////////////////////////////////////////////////////////
120/// Operator>>
121
123{
124 f = atof((*fRowPtr)->GetField(*fIter));
125
126 if (fIter != fColumnVec->end()) ++fIter;
127}
128
129////////////////////////////////////////////////////////////////////////////////
130/// Operator>>
131
133{
134 l = atol((*fRowPtr)->GetField(*fIter));
135
136 if (fIter != fColumnVec->end()) ++fIter;
137}
138
139////////////////////////////////////////////////////////////////////////////////
140/// Operator>>
141
143{
144 d = atof((*fRowPtr)->GetField(*fIter));
145
146 if (fIter != fColumnVec->end()) ++fIter;
147}
148
149////////////////////////////////////////////////////////////////////////////////
150/// Operator<<
151
153{
154 (*fInsertQuery) += b;
155 (*fInsertQuery) += ",";
156 if (fIter != fColumnVec->end()) ++fIter;
157}
158
159////////////////////////////////////////////////////////////////////////////////
160/// Operator<<
161
163{
164 (*fInsertQuery) += c;
165 (*fInsertQuery) += ",";
166 if (fIter != fColumnVec->end()) ++fIter;
167}
168
169////////////////////////////////////////////////////////////////////////////////
170/// Operator<<
171
173{
174 (*fInsertQuery) += h;
175 (*fInsertQuery) += ",";
176 if (fIter != fColumnVec->end()) ++fIter;
177}
178
179////////////////////////////////////////////////////////////////////////////////
180/// Operator<<
181
183{
184 (*fInsertQuery) += i;
185 (*fInsertQuery) += ",";
186 if (fIter != fColumnVec->end()) ++fIter;
187}
188
189////////////////////////////////////////////////////////////////////////////////
190/// Operator<<
191
193{
194 (*fInsertQuery) += l;
195 (*fInsertQuery) += ",";
196 if (fIter != fColumnVec->end()) ++fIter;
197}
198
199////////////////////////////////////////////////////////////////////////////////
200/// Operator<<
201
203{
204 (*fInsertQuery) += f;
205 (*fInsertQuery) += ",";
206 if (fIter != fColumnVec->end()) ++fIter;
207}
208
209////////////////////////////////////////////////////////////////////////////////
210/// Operator<<
211
213{
214 (*fInsertQuery) += d;
215 (*fInsertQuery) += ",";
216 if (fIter != fColumnVec->end()) ++fIter;
217}
218
219////////////////////////////////////////////////////////////////////////////////
220/// Operator>>
221
223{
224 uc = (UChar_t)atoi((*fRowPtr)->GetField(*fIter));
225
226 if (fIter != fColumnVec->end()) ++fIter;
227}
228
229////////////////////////////////////////////////////////////////////////////////
230/// Operator>>
231
233{
234 us = (UShort_t)atoi((*fRowPtr)->GetField(*fIter));
235
236 if (fIter != fColumnVec->end()) ++fIter;
237}
238
239////////////////////////////////////////////////////////////////////////////////
240/// Operator>>
241
243{
244 TString val = (*fRowPtr)->GetField(*fIter);
245 Int_t code = sscanf(val.Data(), "%u",&ui);
246 if(code == 0) Error("operator>>(UInt_t&)","Error reading UInt_t");
247
248 if (fIter != fColumnVec->end()) ++fIter;
249}
250
251////////////////////////////////////////////////////////////////////////////////
252/// Operator>>
253
255{
256 TString val = (*fRowPtr)->GetField(*fIter);
257 Int_t code = sscanf(val.Data(), "%lu",&ul);
258 if(code == 0) Error("operator>>(ULong_t&)","Error reading ULong_t");
259
260 if (fIter != fColumnVec->end()) ++fIter;
261}
262
263////////////////////////////////////////////////////////////////////////////////
264/// Operator>>
265
267{
268 TString val = (*fRowPtr)->GetField(*fIter);
269 Int_t code = sscanf(val.Data(), "%lld",&ll);
270 if(code == 0) Error("operator>>(ULong_t&)","Error reading Long64_t");
271
272 if (fIter != fColumnVec->end()) ++fIter;
273}
274
275////////////////////////////////////////////////////////////////////////////////
276/// Operator>>
277
279{
280 TString val = (*fRowPtr)->GetField(*fIter);
281 Int_t code = sscanf(val.Data(), "%llu",&ull);
282 if(code == 0) Error("operator>>(ULong_t&)","Error reading ULong64_t");
283
284 if (fIter != fColumnVec->end()) ++fIter;
285}
286
287////////////////////////////////////////////////////////////////////////////////
288/// Operator>>
289
291{
292 strcpy(str,(*fRowPtr)->GetField(*fIter)); // Legacy interface, we have no way to know the user's buffer size ....
293 if (fIter != fColumnVec->end()) ++fIter;
294}
295
296////////////////////////////////////////////////////////////////////////////////
297/// Read a TString
298
300{
301 s = (*fRowPtr)->GetField(*fIter);
302 if (fIter != fColumnVec->end()) ++fIter;
303}
304
305////////////////////////////////////////////////////////////////////////////////
306/// Write a TString
307
309{
310 (*fInsertQuery) += s;
311 (*fInsertQuery) += ",";
312 if (fIter != fColumnVec->end()) ++fIter;
313}
314
315
316
317////////////////////////////////////////////////////////////////////////////////
318/// Read a std::string
319
320void TBufferSQL::ReadStdString(std::string *s)
321{
323}
324
325////////////////////////////////////////////////////////////////////////////////
326/// Write a std::string
327
328void TBufferSQL::WriteStdString(const std::string *s)
329{
331}
332
333////////////////////////////////////////////////////////////////////////////////
334/// Read a char* string
335
337{
339}
340
341////////////////////////////////////////////////////////////////////////////////
342/// Write a char* string
343
345{
347}
348
349
350// Method to send to database.
351
352////////////////////////////////////////////////////////////////////////////////
353/// Operator<<
354
356{
357 (*fInsertQuery) += uc;
358 (*fInsertQuery) += ",";
359 ++fIter;
360}
361
362////////////////////////////////////////////////////////////////////////////////
363/// Operator<<
364
366{
367 (*fInsertQuery) += us;
368 (*fInsertQuery) += ",";
369 ++fIter;
370}
371
372////////////////////////////////////////////////////////////////////////////////
373/// Operator<<
374
376{
377 (*fInsertQuery) += ui;
378 (*fInsertQuery) += ",";
379 ++fIter;
380}
381
382////////////////////////////////////////////////////////////////////////////////
383/// Operator<<
384
386{
387 (*fInsertQuery) += ul;
388 (*fInsertQuery) += ",";
389 ++fIter;
390}
391
392////////////////////////////////////////////////////////////////////////////////
393/// Operator<<
394
396{
397 (*fInsertQuery) += ll;
398 (*fInsertQuery) += ",";
399 ++fIter;
400}
401
402////////////////////////////////////////////////////////////////////////////////
403/// Operator<<
404
406{
407 (*fInsertQuery) += ull;
408 (*fInsertQuery) += ",";
409 ++fIter;
410}
411
412////////////////////////////////////////////////////////////////////////////////
413/// Operator<<
414
416{
417 (*fInsertQuery) += "\"";
418 (*fInsertQuery) += str;
419 (*fInsertQuery) += "\",";
420 ++fIter;
421}
422
423////////////////////////////////////////////////////////////////////////////////
424/// WriteFastArray SQL implementation.
425
427{
428 for(int i=0; i<n; ++i) {
429 (*fInsertQuery) += b[i];
430 (*fInsertQuery) += ",";
431 ++fIter;
432 }
433}
434
435////////////////////////////////////////////////////////////////////////////////
436/// WriteFastArray SQL implementation.
437
439{
440 for(int i=0; i<n; ++i) {
441 (*fInsertQuery) += (Short_t)c[i];
442 (*fInsertQuery) += ",";
443 ++fIter;
444 }
445}
446
447////////////////////////////////////////////////////////////////////////////////
448/// WriteFastArray SQL implementation.
449
451{
452 (*fInsertQuery) += "\"";
453 (*fInsertQuery) += c;
454 (*fInsertQuery) += "\",";
455 ++fIter;
456}
457
458////////////////////////////////////////////////////////////////////////////////
459/// WriteFastArray SQL implementation.
460
462{
463 for(int i=0; i<n; ++i) {
464 (*fInsertQuery) += uc[i];
465 (*fInsertQuery) += ",";
466 ++fIter;
467 }
468}
469
470////////////////////////////////////////////////////////////////////////////////
471/// WriteFastArray SQL implementation.
472
474{
475 for(int i=0; i<n; ++i) {
476 (*fInsertQuery) += h[i];
477 (*fInsertQuery) += ",";
478 ++fIter;
479 }
480}
481
482////////////////////////////////////////////////////////////////////////////////
483/// WriteFastArray SQL implementation.
484
486{
487 for(int i=0; i<n; ++i) {
488 (*fInsertQuery) += us[i];
489 (*fInsertQuery) += ",";
490 ++fIter;
491 }
492}
493
494////////////////////////////////////////////////////////////////////////////////
495/// WriteFastArray SQL implementation.
496
498{
499 // std::cerr << "Column: " <<*fIter << " i:" << *ii << std::endl;
500 for(int i=0; i<n; ++i) {
501 (*fInsertQuery) += ii[i];
502 (*fInsertQuery) += ",";
503 ++fIter;
504 }
505}
506
507////////////////////////////////////////////////////////////////////////////////
508/// WriteFastArray SQL implementation.
509
511{
512 for(int i=0; i<n; ++i) {
513 (*fInsertQuery) += ui[i];
514 (*fInsertQuery) += ",";
515 ++fIter;
516 }
517}
518
519////////////////////////////////////////////////////////////////////////////////
520/// WriteFastArray SQL implementation.
521
523{
524 for(int i=0; i<n; ++i) {
525 (*fInsertQuery)+= l[i];
526 (*fInsertQuery)+= ",";
527 ++fIter;
528 }
529}
530
531////////////////////////////////////////////////////////////////////////////////
532/// WriteFastArray SQL implementation.
533
535{
536 for(int i=0; i<n; ++i) {
537 (*fInsertQuery) += ul[i];
538 (*fInsertQuery) += ",";
539 ++fIter;
540 }
541}
542
543////////////////////////////////////////////////////////////////////////////////
544/// WriteFastArray SQL implementation.
545
547{
548 for(int i=0; i<n; ++i) {
549 (*fInsertQuery) += l[i];
550 (*fInsertQuery) += ",";
551 ++fIter;
552 }
553}
554
555////////////////////////////////////////////////////////////////////////////////
556/// WriteFastArray SQL implementation.
557
559{
560 for(int i=0; i<n; ++i) {
561 (*fInsertQuery) += ul[i];
562 (*fInsertQuery) += ",";
563 ++fIter;
564 }
565}
566
567////////////////////////////////////////////////////////////////////////////////
568/// WriteFastArray SQL implementation.
569
571{
572 for(int i=0; i<n; ++i) {
573 (*fInsertQuery) += f[i];
574 (*fInsertQuery) += ",";
575 ++fIter;
576 }
577}
578
579////////////////////////////////////////////////////////////////////////////////
580/// WriteFastArray SQL implementation.
581
583{
584 for(int i=0; i<n; ++i) {
585 (*fInsertQuery) += d[i];
586 (*fInsertQuery )+= ",";
587 ++fIter;
588 }
589}
590
591////////////////////////////////////////////////////////////////////////////////
592/// WriteFastArray SQL implementation.
593
595{
596 Fatal("WriteFastArray(void*, const TClass*, Int_t, TMemberStreamer *)","Not implemented yet");
597}
598
599////////////////////////////////////////////////////////////////////////////////
600/// WriteFastArray SQL implementation.
601
603{
604 Fatal("WriteFastArray(void **, const TClass*, Int_t, Bool_t, TMemberStreamer*)","Not implemented yet");
605 return 0;
606}
607
608////////////////////////////////////////////////////////////////////////////////
609/// ReadFastArray SQL implementation.
610
612{
613 for(int i=0; i<n; ++i) {
614 b[i] = (Bool_t)atoi((*fRowPtr)->GetField(*fIter));
615 ++fIter;
616 }
617}
618
619////////////////////////////////////////////////////////////////////////////////
620/// ReadFastArray SQL implementation.
621
623{
624 for(int i=0; i<n; ++i) {
625 c[i] = (Char_t)atoi((*fRowPtr)->GetField(*fIter));
626 ++fIter;
627 }
628}
629
630////////////////////////////////////////////////////////////////////////////////
631/// ReadFastArray SQL implementation.
632
634{
635 strcpy(c,((*fRowPtr)->GetField(*fIter)));
636 ++fIter;
637}
638
639////////////////////////////////////////////////////////////////////////////////
640/// ReadFastArray SQL implementation.
641
643{
644 for(int i=0; i<n; ++i) {
645 uc[i] = (UChar_t)atoi((*fRowPtr)->GetField(*fIter));
646 ++fIter;
647 }
648}
649
650////////////////////////////////////////////////////////////////////////////////
651/// ReadFastArray SQL implementation.
652
654{
655 for(int i=0; i<n; ++i) {
656 s[i] = (Short_t)atoi((*fRowPtr)->GetField(*fIter));
657 ++fIter;
658 }
659}
660
661////////////////////////////////////////////////////////////////////////////////
662/// ReadFastArray SQL implementation.
663
665{
666 for(int i=0; i<n; ++i) {
667 us[i] = (UShort_t)atoi((*fRowPtr)->GetField(*fIter));
668 ++fIter;
669 }
670}
671
672////////////////////////////////////////////////////////////////////////////////
673/// ReadFastArray SQL implementation.
674
676{
677 for(int i=0; i<n; ++i) {
678 in[i] = atoi((*fRowPtr)->GetField(*fIter));
679 ++fIter;
680 }
681}
682
683////////////////////////////////////////////////////////////////////////////////
684/// ReadFastArray SQL implementation.
685
687{
688 for(int i=0; i<n; ++i) {
689 ui[i] = atoi((*fRowPtr)->GetField(*fIter));
690 ++fIter;
691 }
692}
693
694////////////////////////////////////////////////////////////////////////////////
695/// ReadFastArray SQL implementation.
696
698{
699 for(int i=0; i<n; ++i) {
700 l[i] = atol((*fRowPtr)->GetField(*fIter));
701 ++fIter;
702 }
703}
704
705////////////////////////////////////////////////////////////////////////////////
706/// ReadFastArray SQL implementation.
707
709{
710 for(int i=0; i<n; ++i) {
711 (*this) >> ul[i];
712 }
713}
714
715////////////////////////////////////////////////////////////////////////////////
716/// ReadFastArray SQL implementation.
717
719{
720 for(int i=0; i<n; ++i) {
721 (*this) >> ll[i];
722 }
723}
724
725////////////////////////////////////////////////////////////////////////////////
726/// ReadFastArray SQL implementation.
727
729{
730 for(int i=0; i<n; ++i) {
731 (*this) >> ull[i];
732 }
733}
734
735////////////////////////////////////////////////////////////////////////////////
736/// ReadFastArray SQL implementation.
737
739{
740 for(int i=0; i<n; ++i) {
741 f[i] = atof((*fRowPtr)->GetField(*fIter));
742 ++fIter;
743 }
744}
745
746////////////////////////////////////////////////////////////////////////////////
747/// ReadFastArray SQL implementation.
748
750{
751 for(int i=0; i<n; ++i) {
752 d[i] = atof((*fRowPtr)->GetField(*fIter));
753 ++fIter;
754 }
755}
756
757////////////////////////////////////////////////////////////////////////////////
758/// ReadFastArray SQL implementation.
759
761{
762 Fatal("ReadFastArrayFloat16(Float_t *, Int_t , TStreamerElement *)","Not implemented yet");
763}
764
765////////////////////////////////////////////////////////////////////////////////
766/// Read array of Float16_t from buffer
767
769{
770 Fatal("ReadFastArrayWithFactor(Float_t *, Int_t, Double_t, Double_t)","Not implemented yet");
771}
772
773////////////////////////////////////////////////////////////////////////////////
774/// Read array of Float16_t from buffer
775
777{
778 Fatal("ReadFastArrayWithNbits(Float_t *, Int_t , Int_t )","Not implemented yet");
779}
780
781////////////////////////////////////////////////////////////////////////////////
782/// Read array of Double32_t from buffer
783
785{
786 Fatal("ReadFastArrayWithFactor(Double_t *, Int_t, Double_t, Double_t)","Not implemented yet");
787}
788
789////////////////////////////////////////////////////////////////////////////////
790/// Read array of Double32_t from buffer
791
793{
794 Fatal("ReadFastArrayWithNbits(Double_t *, Int_t , Int_t )","Not implemented yet");
795}
796
797////////////////////////////////////////////////////////////////////////////////
798/// ReadFastArray SQL implementation.
799
801{
802 Fatal("ReadFastArrayDouble32(Double_t *, Int_t , TStreamerElement *)","Not implemented yet");
803}
804
805////////////////////////////////////////////////////////////////////////////////
806/// ReadFastArray SQL implementation.
807
809{
810 Fatal("ReadFastArray(void *, const TClass *, Int_t, TMemberStreamer *, const TClass *)","Not implemented yet");
811}
812
813////////////////////////////////////////////////////////////////////////////////
814/// ReadFastArray SQL implementation.
815
817{
818 Fatal("ReadFastArray(void **, const TClass *, Int_t, Bool_t, TMemberStreamer *, const TClass *)","Not implemented yet");
819}
820
821////////////////////////////////////////////////////////////////////////////////
822/// Reset Offset.
823
825{
826 fIter = fColumnVec->begin();
827}
828
829#if 0
830////////////////////////////////////////////////////////////////////////////////
831
832void TBufferSQL::insert_test(const char* dsn, const char* usr,
833 const char* pwd, const TString& tblname)
834{
835 TString str;
836 TString select = "select * from ";
837 TString sql;
838 TSQLStatement* stmt;
839 sql = select + "ins";
840
841 con = gSQLDriverManager->GetConnection(dsn,usr,pwd);
842
843 if(!con)
844 printf("\n\n\nConnection NOT Successful\n\n\n");
845 else
846 printf("\n\n\nConnection Sucessful\n\n\n");
847
848 stmt = con->CreateStatement(0, odbc::ResultSet::CONCUR_READ_ONLY);
849
850 ptr = stmt->ExecuteQuery(sql.Data());
851 if(!ptr) printf("No recorSet found!");
852
853 ptr->Next();
854 ptr->MoveToInsertRow();
855 std::cerr << "IsAfterLast(): " << ptr->IsAfterLast() << std::endl;
856 ptr->UpdateInt(1, 5555);
857 ptr->InsertRow();
858 con->Commit();
859
860 ptr1 = stmt->ExecuteQuery(sql.Data());
861
862}
863#endif
#define d(i)
Definition: RSha256.hxx:102
#define f(i)
Definition: RSha256.hxx:104
#define c(i)
Definition: RSha256.hxx:101
#define h(i)
Definition: RSha256.hxx:106
bool Bool_t
Definition: RtypesCore.h:63
unsigned short UShort_t
Definition: RtypesCore.h:40
unsigned char UChar_t
Definition: RtypesCore.h:38
char Char_t
Definition: RtypesCore.h:37
long Long_t
Definition: RtypesCore.h:54
float Float_t
Definition: RtypesCore.h:57
short Short_t
Definition: RtypesCore.h:39
long long Long64_t
Definition: RtypesCore.h:80
unsigned long long ULong64_t
Definition: RtypesCore.h:81
unsigned long ULong_t
Definition: RtypesCore.h:55
#define ClassImp(name)
Definition: Rtypes.h:375
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t b
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t r
Option_t Option_t TPoint TPoint const char mode
The concrete implementation of TBuffer for writing/reading to/from a ROOT file or socket.
Definition: TBufferFile.h:47
void ReadCharStar(char *&s) override
Read char* from TBuffer.
void WriteCharStar(char *s) override
Write char* into TBuffer.
void WriteStdString(const std::string *s) override
Write std::string to TBuffer.
void ReadStdString(std::string *s) override
Read std::string from TBuffer.
Implement TBuffer for a SQL backend.
Definition: TBufferSQL.h:30
void ReadLong(Long_t &l) final
Operator>>
Definition: TBufferSQL.cxx:132
void WriteDouble(Double_t d) final
Operator<<.
Definition: TBufferSQL.cxx:212
~TBufferSQL()
Destructor.
Definition: TBufferSQL.cxx:74
TBufferSQL()
Constructor.
Definition: TBufferSQL.cxx:67
void ReadFastArrayFloat16(Float_t *f, Int_t n, TStreamerElement *ele=nullptr) final
ReadFastArray SQL implementation.
Definition: TBufferSQL.cxx:760
void WriteFastArray(const Bool_t *b, Int_t n) final
WriteFastArray SQL implementation.
Definition: TBufferSQL.cxx:426
void WriteULong(ULong_t l) final
Operator<<.
Definition: TBufferSQL.cxx:385
void WriteUInt(UInt_t i) final
Operator<<.
Definition: TBufferSQL.cxx:375
void WriteFloat(Float_t f) final
Operator<<.
Definition: TBufferSQL.cxx:202
void ReadULong64(ULong64_t &l) final
Operator>>
Definition: TBufferSQL.cxx:278
void ReadCharStar(char *&s) final
Read a char* string.
Definition: TBufferSQL.cxx:336
void ReadInt(Int_t &i) final
Operator>>
Definition: TBufferSQL.cxx:112
void ReadTString(TString &s) final
Read a TString.
Definition: TBufferSQL.cxx:299
void WriteUChar(UChar_t c) final
Operator<<.
Definition: TBufferSQL.cxx:355
void WriteShort(Short_t s) final
Operator<<.
Definition: TBufferSQL.cxx:172
void WriteUShort(UShort_t s) final
Operator<<.
Definition: TBufferSQL.cxx:365
void ReadBool(Bool_t &b) final
Operator>>
Definition: TBufferSQL.cxx:82
void ReadShort(Short_t &s) final
Operator>>
Definition: TBufferSQL.cxx:102
void WriteLong(Long_t l) final
Operator<<.
Definition: TBufferSQL.cxx:192
void ReadLong64(Long64_t &l) final
Operator>>
Definition: TBufferSQL.cxx:266
void ReadChar(Char_t &c) final
Operator>>
Definition: TBufferSQL.cxx:92
std::vector< Int_t > * fColumnVec
Definition: TBufferSQL.h:35
void WriteFastArrayString(const Char_t *c, Int_t n) final
WriteFastArray SQL implementation.
Definition: TBufferSQL.cxx:450
void ReadFastArrayString(Char_t *, Int_t) final
ReadFastArray SQL implementation.
Definition: TBufferSQL.cxx:633
void WriteStdString(const std::string *s) final
Write a std::string.
Definition: TBufferSQL.cxx:328
void ReadStdString(std::string *s) final
Read a std::string.
Definition: TBufferSQL.cxx:320
void WriteInt(Int_t i) final
Operator<<.
Definition: TBufferSQL.cxx:182
void ReadFastArray(Bool_t *, Int_t) final
ReadFastArray SQL implementation.
Definition: TBufferSQL.cxx:611
void ReadUShort(UShort_t &s) final
Operator>>
Definition: TBufferSQL.cxx:232
void ReadFastArrayWithFactor(Float_t *ptr, Int_t n, Double_t factor, Double_t minvalue) final
Read array of Float16_t from buffer.
Definition: TBufferSQL.cxx:768
void WriteTString(const TString &s) final
Write a TString.
Definition: TBufferSQL.cxx:308
void ReadUInt(UInt_t &i) final
Operator>>
Definition: TBufferSQL.cxx:242
void WriteBool(Bool_t b) final
Operator<<.
Definition: TBufferSQL.cxx:152
void WriteULong64(ULong64_t l) final
Operator<<.
Definition: TBufferSQL.cxx:405
void ReadCharP(Char_t *c) final
Operator>>
Definition: TBufferSQL.cxx:290
void WriteCharStar(char *s) final
Write a char* string.
Definition: TBufferSQL.cxx:344
void ReadFastArrayWithNbits(Float_t *ptr, Int_t n, Int_t nbits) final
Read array of Float16_t from buffer.
Definition: TBufferSQL.cxx:776
std::vector< Int_t >::const_iterator fIter
Definition: TBufferSQL.h:33
void ResetOffset()
Reset Offset.
Definition: TBufferSQL.cxx:824
void WriteCharP(const Char_t *c) final
Operator<<.
Definition: TBufferSQL.cxx:415
void WriteLong64(Long64_t l) final
Operator<<.
Definition: TBufferSQL.cxx:395
void ReadDouble(Double_t &d) final
Operator>>
Definition: TBufferSQL.cxx:142
void ReadULong(ULong_t &l) final
Operator>>
Definition: TBufferSQL.cxx:254
void ReadFastArrayDouble32(Double_t *d, Int_t n, TStreamerElement *ele=nullptr) final
ReadFastArray SQL implementation.
Definition: TBufferSQL.cxx:800
void ReadFloat(Float_t &f) final
Operator>>
Definition: TBufferSQL.cxx:122
void WriteChar(Char_t c) final
Operator<<.
Definition: TBufferSQL.cxx:162
void ReadUChar(UChar_t &c) final
Operator>>
Definition: TBufferSQL.cxx:222
TClass instances represent classes, structs and namespaces in the ROOT type system.
Definition: TClass.h:80
virtual void Error(const char *method, const char *msgfmt,...) const
Issue error message.
Definition: TObject.cxx:893
virtual void Fatal(const char *method, const char *msgfmt,...) const
Issue fatal error message.
Definition: TObject.cxx:921
Basic string class.
Definition: TString.h:136
const char * Data() const
Definition: TString.h:369
const Int_t n
Definition: legend1.C:16
static constexpr double us
static constexpr double s
TLine l
Definition: textangle.C:4
static byte * ptr1
Definition: gifdecode.c:16