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