GammaWare  Head Version for release 0.9
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
BaseBuffer.h
Go to the documentation of this file.
1 /***************************************************************************
2  * Copyright (C) 2004 by Olivier Stezowski *
3  * stezow(AT)ipnl.in2p3.fr *
4  * *
5  * This program is free software; you can redistribute it and/or modify *
6  * it under the terms of the GNU General Public License as published by *
7  * the Free Software Foundation; either version 2 of the License, or *
8  * (at your option) any later version. *
9  * *
10  * This program is distributed in the hope that it will be useful, *
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of *
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
13  * GNU General Public License for more details. *
14  * *
15  * You should have received a copy of the GNU General Public License *
16  * along with this program; if not, write to the *
17  * Free Software Foundation, Inc., *
18  * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
19  ***************************************************************************/
20 
21 #ifndef ADF_BaseBuffer
22 #define ADF_BaseBuffer
23 #define ADF_BASEBUFFER_H ADF_BaseBuffer
24 
25 #ifndef ADF_ADFConfig
26 #include "ADFConfig.h"
27 #endif
28 
29 #include <cstring>
30 
31 namespace ADF
32 {
33 
34 const UInt_t aByte = 1u;
35 const UInt_t aKByte = 1024u;
36 const UInt_t aMByte = aKByte*aKByte;
37 const UInt_t aGByte = aKByte*aMByte;
38 
40 
48 class BaseBuffer
49 {
50 public:
52 
57  enum EStatus { kGood, kFail, kCorrupt } ;
58 
60 
68  enum EEndian { kLittle = 0, kBig = 1 } ;
69 
70  // enum ESeek { kBeg, kCur, kEnd} ;
71 
72 private:
74 
78  class Agent {
79  EEndian fEndian;
80  public:
81  Agent();
82  EEndian GetEndian() { return fEndian; }
83  };
84  static Agent gAgent; // static Agent *gAgent;
85 
86 public:
87  BaseBuffer();
88  virtual ~BaseBuffer();
89 
91 
94  static bool IsSysEndian(BaseBuffer::EEndian e)
95  { return gAgent.GetEndian() == e; }
96  static EEndian SysEndian()
97  { return gAgent.GetEndian() ; }
98 
99  static Char_t *New(Char_t *p, Int_t nb = 32*aKByte);
100  static Short_t *New(Short_t *p, Int_t nb = 32*aKByte);
101  static Int_t *New(Int_t *p, Int_t nb = 32*aKByte);
102  static UChar_t *New(UChar_t *p, Int_t nb = 32*aKByte);
103  static UShort_t *New(UShort_t *p, Int_t nb = 32*aKByte);
104  static UInt_t *New(UInt_t *p, Int_t nb = 32*aKByte);
105  static Float_t *New(Float_t *p, Int_t nb = 32*aKByte);
106  static Double_t *New(Double_t *p, Int_t nb = 32*aKByte);
107 
108  static void Zero(Char_t *p, Int_t nb)
109  { if ( nb < 1 ) return; ::memset(p,0,nb); }
110  static void Zero(Short_t *p, Int_t nb)
111  { if ( nb < 1 ) return; ::memset(p,0,sizeof(Short_t)*nb); }
112  static void Zero(Int_t *p, Int_t nb)
113  { if ( nb < 1 ) return; ::memset(p,0,sizeof(Int_t)*nb); }
114  static void Zero(UChar_t *p, Int_t nb)
115  { if ( nb < 1 ) return; ::memset(p,0,nb); }
116  static void Zero(UShort_t *p, Int_t nb)
117  { if ( nb < 1 ) return; ::memset(p,0,sizeof(UShort_t)*nb); }
118  static void Zero(UInt_t *p, Int_t nb)
119  { if ( nb < 1 ) return; ::memset(p,0,sizeof(UInt_t)*nb); }
120  static void Zero(Float_t *p, Int_t nb)
121  { if ( nb < 1 ) return; ::memset(p,0,sizeof(Float_t)*nb); }
122  static void Zero(Double_t *p, Int_t nb)
123  { if ( nb < 1 ) return; ::memset(p,0,sizeof(Double_t)*nb); }
124 
125  static Char_t *New(Char_t *p, UInt_t nb );
126  static Short_t *New(Short_t *p, UInt_t nb );
127  static Int_t *New(Int_t *p, UInt_t nb );
128  static UChar_t *New(UChar_t *p, UInt_t nb );
129  static UShort_t *New(UShort_t *p, UInt_t nb );
130  static UInt_t *New(UInt_t *p, UInt_t nb );
131  static Float_t *New(Float_t *p, UInt_t nb );
132  static Double_t *New(Double_t *p, UInt_t nb );
133 
134  static void Zero(Char_t *p, UInt_t nb)
135  { if ( nb < 1 ) return; ::memset(p,0,nb); }
136  static void Zero(Short_t *p, UInt_t nb)
137  { if ( nb < 1 ) return; ::memset(p,0,sizeof(Short_t)*nb); }
138  static void Zero(Int_t *p, UInt_t nb)
139  { if ( nb < 1 ) return; ::memset(p,0,sizeof(Int_t)*nb); }
140  static void Zero(UChar_t *p, UInt_t nb)
141  { if ( nb < 1 ) return; ::memset(p,0,nb); }
142  static void Zero(UShort_t *p, UInt_t nb)
143  { if ( nb < 1 ) return; ::memset(p,0,sizeof(UShort_t)*nb); }
144  static void Zero(UInt_t *p, UInt_t nb)
145  { if ( nb < 1 ) return; ::memset(p,0,sizeof(UInt_t)*nb); }
146  static void Zero(Float_t *p, UInt_t nb)
147  { if ( nb < 1 ) return; ::memset(p,0,sizeof(Float_t)*nb); }
148  static void Zero(Double_t *p, UInt_t nb)
149  { if ( nb < 1 ) return; ::memset(p,0,sizeof(Double_t)*nb); }
150 
151  static void Delete(Char_t *p)
152  { if ( p ) { delete [] p; p = NULL;} }
153  static void Delete(Short_t *p)
154  { if ( p ) { delete [] p; p = NULL;} }
155  static void Delete(Int_t *p)
156  { if ( p ) { delete [] p; p = NULL;} }
157  static void Delete(UChar_t *p)
158  { if ( p ) { delete [] p; p = NULL;} }
159  static void Delete(UShort_t *p)
160  { if ( p ) { delete [] p; p = NULL;} }
161  static void Delete(UInt_t *p)
162  { if ( p ) { delete [] p; p = NULL;} }
163  static void Delete(Float_t *p)
164  { if ( p ) { delete [] p; p = NULL;} }
165  static void Delete(Double_t *p)
166  { if ( p ) { delete [] p; p = NULL;} }
167 
169 
172  static void Copy(const void *from, void *to, Int_t size)
173  { if ( size > 0 ) ::memcpy(to,from,size); }
174  static void Copy(const void *from, void *to, UInt_t size)
175  { if ( size > 0 ) ::memcpy(to,from,size); }
176 
178 
184  static void Swap(Short_t, Char_t *);
185  static void Swap(UShort_t, Char_t *);
186  static void Swap(Int_t, Char_t *);
187  static void Swap(UInt_t, Char_t *);
188  static void Swap(Float_t, Char_t *);
189  static void Swap(Double_t, Char_t *);
190  static void Swap(Long64_t, Char_t *);
191  static void Swap(ULong64_t, Char_t *);
192  static void Swap(Long_t, Char_t *);
193  static void Swap(ULong_t, Char_t *);
194 
195  static void Swap(const Char_t *,Short_t &);
196  static void Swap(const Char_t *,UShort_t &);
197  static void Swap(const Char_t *,Int_t &);
198  static void Swap(const Char_t *,UInt_t &);
199  static void Swap(const Char_t *,Float_t &);
200  static void Swap(const Char_t *,Double_t &);
201  static void Swap(const Char_t *,Long64_t &);
202  static void Swap(const Char_t *,ULong64_t &);
203  static void Swap(const Char_t *,Long_t &);
204  static void Swap(const Char_t *,ULong_t &);
205 // void Test();
206 };
207 
208 // BaseBuffer inline members //////////////////////////////////////////////////////
209 inline Char_t * BaseBuffer::New(Char_t *p,Int_t nb)
210  { if ( nb < 1 ) return NULL; p = new Char_t[nb]; if ( p ) Zero(p,nb); return p; }
211 inline Short_t * BaseBuffer::New(Short_t *p,Int_t nb)
212  { if ( nb < 1 ) return NULL; p = new Short_t[nb]; if ( p ) Zero(p,nb); return p; }
213 inline Int_t * BaseBuffer::New(Int_t *p,Int_t nb)
214  { if ( nb < 1 ) return NULL; p = new Int_t[nb]; if ( p ) Zero(p,nb); return p; }
215 inline UChar_t * BaseBuffer::New(UChar_t *p,Int_t nb)
216  { if ( nb < 1 ) return NULL; p = new UChar_t[nb]; if ( p ) Zero(p,nb); return p; }
217 inline UShort_t * BaseBuffer::New(UShort_t *p,Int_t nb)
218  { if ( nb < 1 ) return NULL; p = new UShort_t[nb];if ( p ) Zero(p,nb); return p; }
219 inline UInt_t * BaseBuffer::New(UInt_t *p,Int_t nb)
220  { if ( nb < 1 ) return NULL; p = new UInt_t[nb]; if ( p ) Zero(p,nb); return p; }
221 inline Float_t * BaseBuffer::New(Float_t *p,Int_t nb)
222  { if ( nb < 1 ) return NULL; p = new Float_t[nb]; if ( p ) Zero(p,nb); return p; }
223 inline Double_t * BaseBuffer::New (Double_t * p,Int_t nb)
224  { if ( nb < 1 ) return NULL; p = new Double_t[nb]; if ( p ) Zero(p,nb); return p;}
225 
226 inline Char_t * BaseBuffer::New(Char_t *p,UInt_t nb)
227  { if ( nb < 1 ) return NULL; p = new Char_t[nb]; if ( p ) Zero(p,nb); return p; }
228 inline Short_t * BaseBuffer::New(Short_t *p,UInt_t nb)
229  { if ( nb < 1 ) return NULL; p = new Short_t[nb]; if ( p ) Zero(p,nb); return p; }
230 inline Int_t * BaseBuffer::New(Int_t *p,UInt_t nb)
231  { if ( nb < 1 ) return NULL; p = new Int_t[nb]; if ( p ) Zero(p,nb); return p; }
232 inline UChar_t * BaseBuffer::New(UChar_t *p,UInt_t nb)
233  { if ( nb < 1 ) return NULL; p = new UChar_t[nb]; if ( p ) Zero(p,nb); return p; }
234 inline UShort_t * BaseBuffer::New(UShort_t *p,UInt_t nb)
235  { if ( nb < 1 ) return NULL; p = new UShort_t[nb]; if ( p ) Zero(p,nb); return p; }
236 inline UInt_t * BaseBuffer::New(UInt_t *p,UInt_t nb)
237  { if ( nb < 1 ) return NULL; p = new UInt_t[nb]; if ( p ) Zero(p,nb); return p; }
238 inline Float_t * BaseBuffer::New(Float_t *p,UInt_t nb)
239  { if ( nb < 1 ) return NULL; p = new Float_t[nb]; if ( p ) Zero(p,nb); return p; }
240 inline Double_t * BaseBuffer::New (Double_t *p,UInt_t nb)
241  { if ( nb < 1 ) return NULL; p = new Double_t[nb]; if ( p ) Zero(p,nb); return p; }
242 
243 
244 inline void BaseBuffer::Swap(UShort_t x, Char_t *buf)
245 {
246 # if ADF_STANDALONE == 0 && defined(R__USEASMSWAP)
247  *((UShort_t *)buf) = Rbswap_16(x);
248 # else
249  // To work around a stupid optimization bug in MSVC++ 6.0
250  const UShort_t *intermediary = &x;
251  char *sw = (char *) intermediary;
252  buf[0] = sw[1];
253  buf[1] = sw[0];
254 # endif
255 }
256 inline void BaseBuffer::Swap(Short_t x, Char_t *buf)
257  { BaseBuffer::Swap((UShort_t) x,buf) ;}
258 
259 inline void BaseBuffer::Swap(UInt_t x, Char_t *buf)
260 {
261 # if ADF_STANDALONE == 0 && defined(R__USEASMSWAP)
262  *((UInt_t *)buf) = Rbswap_32(x);
263 # else
264  // To work around a stupid optimization bug in MSVC++ 6.0
265  const UInt_t *intermediary = &x;
266  char *sw = (char *)intermediary;
267  buf[0] = sw[3];
268  buf[1] = sw[2];
269  buf[2] = sw[1];
270  buf[3] = sw[0];
271 # endif
272 }
273 inline void BaseBuffer::Swap(Int_t x, Char_t *buf)
274  { BaseBuffer::Swap((UInt_t) x,buf);}
275 
276 inline void BaseBuffer::Swap(Float_t x, Char_t *buf)
277 {
278 # if ADF_STANDALONE == 0 && defined(R__USEASMSWAP)
279  union {
280  volatile UInt_t i;
281  volatile Float_t f;
282  } u;
283  u.f = x;
284  *((UInt_t *)buf) = Rbswap_32(u.i);
285 # else
286  union {
287  volatile char c[4];
288  volatile Float_t f;
289  } u;
290  u.f = x;
291  buf[0] = u.c[3];
292  buf[1] = u.c[2];
293  buf[2] = u.c[1];
294  buf[3] = u.c[0];
295 # endif
296 }
297 
298 inline void BaseBuffer::Swap(Double_t x, Char_t *buf)
299 {
300 # if ADF_STANDALONE == 0 && defined(R__USEASMSWAP)
301  union {
302  volatile ULong64_t l;
303  volatile Double_t d;
304  } u;
305  u.d = x;
306  *((ULong64_t *)buf) = Rbswap_64(u.l);
307 # else
308  union {
309  volatile char c[8];
310  volatile Double_t d;
311  } u;
312  u.d = x;
313  buf[0] = u.c[7];
314  buf[1] = u.c[6];
315  buf[2] = u.c[5];
316  buf[3] = u.c[4];
317  buf[4] = u.c[3];
318  buf[5] = u.c[2];
319  buf[6] = u.c[1];
320  buf[7] = u.c[0];
321 # endif
322 }
323 
324 inline void BaseBuffer::Swap(ULong64_t x, Char_t *buf)
325 {
326 # if ADF_STANDALONE == 0 && defined(R__USEASMSWAP)
327  *((ULong64_t *)buf) = Rbswap_64(x);
328 # else
329  // To work around a stupid optimization bug in MSVC++ 6.0
330  const ULong64_t *intermediary = &x;
331  char *sw = (char *)intermediary;
332  buf[0] = sw[7];
333  buf[1] = sw[6];
334  buf[2] = sw[5];
335  buf[3] = sw[4];
336  buf[4] = sw[3];
337  buf[5] = sw[2];
338  buf[6] = sw[1];
339  buf[7] = sw[0];
340 # endif
341 }
342 inline void BaseBuffer::Swap(Long64_t x, Char_t *buf)
343  { BaseBuffer::Swap((ULong64_t) x,buf) ;}
344 
345 inline void BaseBuffer::Swap(Long_t x, Char_t *buf)
346 {
347  const Long_t *intermediary = &x;
348  char *sw = (char *)intermediary;
349  if (sizeof(Long_t) == 8) {
350  buf[0] = sw[7];
351  buf[1] = sw[6];
352  buf[2] = sw[5];
353  buf[3] = sw[4];
354  buf[4] = sw[3];
355  buf[5] = sw[2];
356  buf[6] = sw[1];
357  buf[7] = sw[0];
358  } else {
359  if (x < 0) {
360  buf[0] = (char) -1;
361  buf[1] = (char) -1;
362  buf[2] = (char) -1;
363  buf[3] = (char) -1;
364  } else {
365  buf[0] = 0;
366  buf[1] = 0;
367  buf[2] = 0;
368  buf[3] = 0;
369  }
370  buf[4] = sw[3];
371  buf[5] = sw[2];
372  buf[6] = sw[1];
373  buf[7] = sw[0];
374  }
375 }
376 
377 inline void BaseBuffer::Swap(ULong_t x, Char_t *buf)
378 {
379  const ULong_t *intermediary = &x;
380  char *sw = (char *)intermediary;
381  if (sizeof(ULong_t) == 8) {
382  buf[0] = sw[7];
383  buf[1] = sw[6];
384  buf[2] = sw[5];
385  buf[3] = sw[4];
386  buf[4] = sw[3];
387  buf[5] = sw[2];
388  buf[6] = sw[1];
389  buf[7] = sw[0];
390  } else {
391  buf[0] = 0;
392  buf[1] = 0;
393  buf[2] = 0;
394  buf[3] = 0;
395  buf[4] = sw[3];
396  buf[5] = sw[2];
397  buf[6] = sw[1];
398  buf[7] = sw[0];
399  }
400 }
401 
402 inline void BaseBuffer::Swap(const Char_t *buf, UShort_t &x)
403 {
404 # if ADF_STANDALONE == 0 && defined(R__USEASMSWAP)
405  x = Rbswap_16(*((UShort_t *)buf));
406 # else
407  char *sw = (char *)&x;
408  sw[0] = buf[1];
409  sw[1] = buf[0];
410 # endif
411 }
412 
413 inline void BaseBuffer::Swap(const Char_t *buf, Short_t &x)
414 {
415 # if ADF_STANDALONE == 0 && defined(R__USEASMSWAP)
416  x = Rbswap_16(*((Short_t *)buf));
417 # else
418  char *sw = (char *)&x;
419  sw[0] = buf[1];
420  sw[1] = buf[0];
421 # endif
422 }
423 
424 inline void BaseBuffer::Swap(const Char_t *buf, UInt_t &x)
425 {
426 # if ADF_STANDALONE == 0 && defined(R__USEASMSWAP)
427  x = Rbswap_32(*((UInt_t *)buf));
428 # else
429  char *sw = (char *)&x;
430  sw[0] = buf[3];
431  sw[1] = buf[2];
432  sw[2] = buf[1];
433  sw[3] = buf[0];
434 # endif
435 }
436 
437 inline void BaseBuffer::Swap(const Char_t *buf, Int_t &x)
438 {
439 # if ADF_STANDALONE == 0 && defined(R__USEASMSWAP)
440  x = Rbswap_32(*((Int_t *)buf));
441 # else
442  char *sw = (char *)&x;
443  sw[0] = buf[3];
444  sw[1] = buf[2];
445  sw[2] = buf[1];
446  sw[3] = buf[0];
447 # endif
448 }
449 inline void BaseBuffer::Swap(const Char_t *buf, Float_t &x)
450 {
451 # if ADF_STANDALONE == 0 && defined(R__USEASMSWAP)
452  // Use a union to allow strict-aliasing
453  union {
454  volatile UInt_t i;
455  volatile Float_t f;
456  } u;
457  u.i = Rbswap_32(*((UInt_t *)buf));
458  x = u.f;
459 # else
460  union {
461  volatile char c[4];
462  volatile Float_t f;
463  } u;
464  u.c[0] = buf[3];
465  u.c[1] = buf[2];
466  u.c[2] = buf[1];
467  u.c[3] = buf[0];
468  x = u.f;
469 # endif
470 }
471 
472 inline void BaseBuffer::Swap(const Char_t *buf, Double_t &x)
473 {
474 # if ADF_STANDALONE == 0 && defined(R__USEASMSWAP)
475  // Use a union to allow strict-aliasing
476  union {
477  volatile ULong64_t l;
478  volatile Double_t d;
479  } u;
480  u.l = Rbswap_64(*((ULong64_t *)buf));
481  x = u.d;
482 # else
483  // Use an union to prevent over-zealous optimization by KCC
484  // related to aliasing double.
485  // + Use a volatile here to work around error in KCC optimizer
486  union {
487  volatile char c[8];
488  volatile Double_t d;
489  } u;
490  u.c[0] = buf[7];
491  u.c[1] = buf[6];
492  u.c[2] = buf[5];
493  u.c[3] = buf[4];
494  u.c[4] = buf[3];
495  u.c[5] = buf[2];
496  u.c[6] = buf[1];
497  u.c[7] = buf[0];
498  x = u.d;
499 # endif
500 }
501 
502 inline void BaseBuffer::Swap(const Char_t *buf, ULong64_t &x)
503 {
504 # if ADF_STANDALONE == 0 && defined(R__USEASMSWAP)
505  x = Rbswap_64(*((ULong64_t *)buf));
506 # else
507  char *sw = (char *)&x;
508  sw[0] = buf[7];
509  sw[1] = buf[6];
510  sw[2] = buf[5];
511  sw[3] = buf[4];
512  sw[4] = buf[3];
513  sw[5] = buf[2];
514  sw[6] = buf[1];
515  sw[7] = buf[0];
516 # endif
517 }
518 
519 inline void BaseBuffer::Swap(const Char_t *buf,Long64_t &x)
520 {
521 # if ADF_STANDALONE == 0 && defined(R__USEASMSWAP)
522  x = Rbswap_64(*((Long64_t *)buf));
523 # else
524  char *sw = (char *)&x;
525  sw[0] = buf[7];
526  sw[1] = buf[6];
527  sw[2] = buf[5];
528  sw[3] = buf[4];
529  sw[4] = buf[3];
530  sw[5] = buf[2];
531  sw[6] = buf[1];
532  sw[7] = buf[0];
533 # endif
534 }
535 
536 inline void BaseBuffer::Swap(const Char_t *buf,ULong_t &x)
537 {
538  char *sw = (char *)&x;
539  if (sizeof(ULong_t) == 8) {
540  sw[0] = buf[7];
541  sw[1] = buf[6];
542  sw[2] = buf[5];
543  sw[3] = buf[4];
544  sw[4] = buf[3];
545  sw[5] = buf[2];
546  sw[6] = buf[1];
547  sw[7] = buf[0];
548  } else {
549  sw[0] = buf[7];
550  sw[1] = buf[6];
551  sw[2] = buf[5];
552  sw[3] = buf[4];
553  }
554 }
555 
556 inline void BaseBuffer::Swap(const Char_t *buf,Long_t &x)
557 {
558  char *sw = (char *)&x;
559  if (sizeof(Long_t) == 8) {
560  sw[0] = buf[7];
561  sw[1] = buf[6];
562  sw[2] = buf[5];
563  sw[3] = buf[4];
564  sw[4] = buf[3];
565  sw[5] = buf[2];
566  sw[6] = buf[1];
567  sw[7] = buf[0];
568  } else {
569  sw[0] = buf[7];
570  sw[1] = buf[6];
571  sw[2] = buf[5];
572  sw[3] = buf[4];
573  }
574 }
575 
576 
577 
578 } // namespace ADF
579 
580 #endif
581 
582 
583 
584 
585 
ADF::BaseBuffer::Delete
static void Delete(UInt_t *p)
Definition: BaseBuffer.h:161
ADF::BaseBuffer::Delete
static void Delete(Int_t *p)
Definition: BaseBuffer.h:155
ADF::BaseBuffer::Zero
static void Zero(Int_t *p, Int_t nb)
Definition: BaseBuffer.h:112
ADF::BaseBuffer::Zero
static void Zero(Int_t *p, UInt_t nb)
Definition: BaseBuffer.h:138
ADF::BaseBuffer::Delete
static void Delete(Float_t *p)
Definition: BaseBuffer.h:163
ADF::BaseBuffer::Delete
static void Delete(Char_t *p)
Definition: BaseBuffer.h:151
ADF::BaseBuffer::~BaseBuffer
virtual ~BaseBuffer()
Definition: BaseBuffer.cpp:52
ADF::BaseBuffer::Swap
static void Swap(Short_t, Char_t *)
the Swap members
Definition: BaseBuffer.h:256
ADF::BaseBuffer::Zero
static void Zero(UShort_t *p, UInt_t nb)
Definition: BaseBuffer.h:142
ADF::BaseBuffer::Zero
static void Zero(UInt_t *p, Int_t nb)
Definition: BaseBuffer.h:118
ADF::BaseBuffer::Zero
static void Zero(Char_t *p, Int_t nb)
Definition: BaseBuffer.h:108
ADF::BaseBuffer::Zero
static void Zero(Short_t *p, Int_t nb)
Definition: BaseBuffer.h:110
ADF::BaseBuffer::Zero
static void Zero(Float_t *p, UInt_t nb)
Definition: BaseBuffer.h:146
ADF::aKByte
const UInt_t aKByte
Definition: BaseBuffer.h:35
ADF::BaseBuffer::Delete
static void Delete(UShort_t *p)
Definition: BaseBuffer.h:159
ADF::aMByte
const UInt_t aMByte
Definition: BaseBuffer.h:36
ADF::BaseBuffer
Base class for a buffer.
Definition: BaseBuffer.h:48
ADF::BaseBuffer::IsSysEndian
static bool IsSysEndian(BaseBuffer::EEndian e)
check out the endian type of the running system
Definition: BaseBuffer.h:94
ADF::BaseBuffer::SysEndian
static EEndian SysEndian()
Definition: BaseBuffer.h:96
ADF::BaseBuffer::Copy
static void Copy(const void *from, void *to, Int_t size)
copy the content from -> to
Definition: BaseBuffer.h:172
ADF::BaseBuffer::Zero
static void Zero(UInt_t *p, UInt_t nb)
Definition: BaseBuffer.h:144
ADF::BaseBuffer::Zero
static void Zero(Double_t *p, Int_t nb)
Definition: BaseBuffer.h:122
ADF::BaseBuffer::Zero
static void Zero(Double_t *p, UInt_t nb)
Definition: BaseBuffer.h:148
ADF::BaseBuffer::Zero
static void Zero(Float_t *p, Int_t nb)
Definition: BaseBuffer.h:120
ADF::BaseBuffer::Zero
static void Zero(Char_t *p, UInt_t nb)
Definition: BaseBuffer.h:134
ADFConfig.h
to set informations about the ADF configuration
ADF::BaseBuffer::Copy
static void Copy(const void *from, void *to, UInt_t size)
Definition: BaseBuffer.h:174
ADF::aByte
const UInt_t aByte
Definition: BaseBuffer.h:34
ADF::BaseBuffer::Zero
static void Zero(Short_t *p, UInt_t nb)
Definition: BaseBuffer.h:136
ADF::BaseBuffer::Zero
static void Zero(UChar_t *p, Int_t nb)
Definition: BaseBuffer.h:114
ADF::aGByte
const UInt_t aGByte
Definition: BaseBuffer.h:37
ADF::BaseBuffer::New
static Char_t * New(Char_t *p, Int_t nb=32 *aKByte)
Definition: BaseBuffer.h:209
ADF::BaseBuffer::Zero
static void Zero(UShort_t *p, Int_t nb)
Definition: BaseBuffer.h:116
ADF::BaseBuffer::Delete
static void Delete(Short_t *p)
Definition: BaseBuffer.h:153
ADF::BaseBuffer::Delete
static void Delete(Double_t *p)
Definition: BaseBuffer.h:165
ADF::BaseBuffer::Delete
static void Delete(UChar_t *p)
Definition: BaseBuffer.h:157
ADF::BaseBuffer::Zero
static void Zero(UChar_t *p, UInt_t nb)
Definition: BaseBuffer.h:140
ADF::BaseBuffer::EStatus
EStatus
Status for this buffer.
Definition: BaseBuffer.h:57
size
const Int_t size
Definition: BenchIO.C:24