ROOT logo
// @(#)root/base:$Id: TBuffer.h 27845 2009-03-17 15:23:30Z pcanal $
// Author: Rene Brun, Philippe Canal, Fons Rademakers   04/05/96

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/

#ifndef ROOT_TBuffer
#define ROOT_TBuffer


//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TBuffer                                                              //
//                                                                      //
// Buffer base class used for serializing objects.                      //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

#ifndef ROOT_TObject
#include "TObject.h"
#endif

class TVirtualStreamerInfo;
class TStreamerElement;
class TClass;
class TString;
class TProcessID;
class TClonesArray;
class TRefTable;

class TBuffer : public TObject {

protected:
   Bool_t           fMode;          //Read or write mode
   Int_t            fVersion;       //Buffer format version
   Int_t            fBufSize;       //Size of buffer
   char            *fBuffer;        //Buffer used to store objects
   char            *fBufCur;        //Current position in buffer
   char            *fBufMax;        //End of buffer
   TObject         *fParent;        //Pointer to parent object owning this buffer
   ReAllocCharFun_t fReAllocFunc;   //! Realloc function to be used when extending the buffer.

   // Default ctor
   TBuffer() : TObject(), fMode(0), fVersion(0), fBufSize(0), fBuffer(0),
     fBufCur(0), fBufMax(0), fParent(0), fReAllocFunc(0) {}

   // TBuffer objects cannot be copied or assigned
   TBuffer(const TBuffer &);           // not implemented
   void operator=(const TBuffer &);    // not implemented

   void Expand(Int_t newsize);  // expand buffer to newsize

   Int_t Read(const char *name) { return TObject::Read(name); }
   Int_t Write(const char *name, Int_t opt, Int_t bufs)
                              { return TObject::Write(name, opt, bufs); }
   Int_t Write(const char *name, Int_t opt, Int_t bufs) const
                              { return TObject::Write(name, opt, bufs); }

public:
   enum EMode { kRead = 0, kWrite = 1 };
   enum { kIsOwner = BIT(16) };                        //if set TBuffer owns fBuffer
   enum { kCannotHandleMemberWiseStreaming = BIT(17)}; //if set TClonesArray should not use member wise streaming
   enum { kInitialSize = 1024, kMinimalSize = 128 };

   TBuffer(EMode mode);
   TBuffer(EMode mode, Int_t bufsiz);
   TBuffer(EMode mode, Int_t bufsiz, void *buf, Bool_t adopt = kTRUE, ReAllocCharFun_t reallocfunc = 0);
   virtual ~TBuffer();

   Int_t    GetBufferVersion() const { return fVersion; }
   Bool_t   IsReading() const { return (fMode & kWrite) == 0; }
   Bool_t   IsWriting() const { return (fMode & kWrite) != 0; }
   void     SetReadMode();
   void     SetWriteMode();
   void     SetBuffer(void *buf, UInt_t bufsiz = 0, Bool_t adopt = kTRUE, ReAllocCharFun_t reallocfunc = 0);
   ReAllocCharFun_t GetReAllocFunc() const;
   void     SetReAllocFunc(ReAllocCharFun_t reallocfunc = 0);
   void     SetBufferOffset(Int_t offset = 0) { fBufCur = fBuffer+offset; }
   void     SetParent(TObject *parent);
   TObject *GetParent()  const;
   char    *Buffer()     const { return fBuffer; }
   Int_t    BufferSize() const { return fBufSize; }
   void     DetachBuffer() { fBuffer = 0; }
   Int_t    Length()     const { return (Int_t)(fBufCur - fBuffer); }

   virtual Bool_t     CheckObject(const TObject *obj) = 0;
   virtual Bool_t     CheckObject(const void *obj, const TClass *ptrClass) = 0;

   virtual Int_t      ReadBuf(void *buf, Int_t max) = 0;
   virtual void       WriteBuf(const void *buf, Int_t max) = 0;

   virtual char      *ReadString(char *s, Int_t max) = 0;
   virtual void       WriteString(const char *s) = 0;

   virtual Int_t      GetVersionOwner() const  = 0;
   virtual Int_t      GetMapCount() const  = 0;
   virtual void       GetMappedObject(UInt_t tag, void* &ptr, TClass* &ClassPtr) const = 0;
   virtual void       MapObject(const TObject *obj, UInt_t offset = 1) = 0;
   virtual void       MapObject(const void *obj, const TClass *cl, UInt_t offset = 1) = 0;
   virtual void       Reset() = 0;
   virtual void       InitMap() = 0;
   virtual void       ResetMap() = 0;
   virtual void       SetReadParam(Int_t mapsize) = 0;
   virtual void       SetWriteParam(Int_t mapsize) = 0;

   virtual Int_t      CheckByteCount(UInt_t startpos, UInt_t bcnt, const TClass *clss) = 0;
   virtual Int_t      CheckByteCount(UInt_t startpos, UInt_t bcnt, const char *classname) = 0;
   virtual void       SetByteCount(UInt_t cntpos, Bool_t packInVersion = kFALSE)= 0;

   virtual Version_t  ReadVersion(UInt_t *start = 0, UInt_t *bcnt = 0, const TClass *cl = 0) = 0;
   virtual UInt_t     WriteVersion(const TClass *cl, Bool_t useBcnt = kFALSE) = 0;
   virtual UInt_t     WriteVersionMemberWise(const TClass *cl, Bool_t useBcnt = kFALSE) = 0;

   virtual void      *ReadObjectAny(const TClass* cast) = 0;
   virtual void       SkipObjectAny() = 0;

   virtual void       IncrementLevel(TVirtualStreamerInfo* info) = 0;
   virtual void       SetStreamerElementNumber(Int_t) = 0;
   virtual void       DecrementLevel(TVirtualStreamerInfo*) = 0;

   virtual void       ClassBegin(const TClass*, Version_t = -1) = 0;
   virtual void       ClassEnd(const TClass*) = 0;
   virtual void       ClassMember(const char*, const char* = 0, Int_t = -1, Int_t = -1) = 0;
   virtual TVirtualStreamerInfo *GetInfo() = 0;

   virtual TClass    *ReadClass(const TClass *cl = 0, UInt_t *objTag = 0) = 0;
   virtual void       WriteClass(const TClass *cl) = 0;

   virtual TObject   *ReadObject(const TClass *cl) = 0;
   virtual void       WriteObject(const TObject *obj) = 0;

   virtual Int_t      WriteObjectAny(const void *obj, const TClass *ptrClass) = 0;

   virtual UShort_t   GetPidOffset() const  = 0;
   virtual void       SetPidOffset(UShort_t offset) = 0;
   virtual Int_t      GetBufferDisplacement() const  = 0;
   virtual void       SetBufferDisplacement() = 0;
   virtual void       SetBufferDisplacement(Int_t skipped) = 0;

   // basic types and arrays of basic types
   virtual   void     ReadFloat16 (Float_t *f, TStreamerElement *ele=0) = 0;
   virtual   void     WriteFloat16(Float_t *f, TStreamerElement *ele=0) = 0;
   virtual   void     ReadDouble32 (Double_t *d, TStreamerElement *ele=0) = 0;
   virtual   void     WriteDouble32(Double_t *d, TStreamerElement *ele=0) = 0;

   virtual   Int_t    ReadArray(Bool_t    *&b) = 0;
   virtual   Int_t    ReadArray(Char_t    *&c) = 0;
   virtual   Int_t    ReadArray(UChar_t   *&c) = 0;
   virtual   Int_t    ReadArray(Short_t   *&h) = 0;
   virtual   Int_t    ReadArray(UShort_t  *&h) = 0;
   virtual   Int_t    ReadArray(Int_t     *&i) = 0;
   virtual   Int_t    ReadArray(UInt_t    *&i) = 0;
   virtual   Int_t    ReadArray(Long_t    *&l) = 0;
   virtual   Int_t    ReadArray(ULong_t   *&l) = 0;
   virtual   Int_t    ReadArray(Long64_t  *&l) = 0;
   virtual   Int_t    ReadArray(ULong64_t *&l) = 0;
   virtual   Int_t    ReadArray(Float_t   *&f) = 0;
   virtual   Int_t    ReadArray(Double_t  *&d) = 0;
   virtual   Int_t    ReadArrayFloat16(Float_t *&f, TStreamerElement *ele=0) = 0;
   virtual   Int_t    ReadArrayDouble32(Double_t *&d, TStreamerElement *ele=0) = 0;

   virtual   Int_t    ReadStaticArray(Bool_t    *b) = 0;
   virtual   Int_t    ReadStaticArray(Char_t    *c) = 0;
   virtual   Int_t    ReadStaticArray(UChar_t   *c) = 0;
   virtual   Int_t    ReadStaticArray(Short_t   *h) = 0;
   virtual   Int_t    ReadStaticArray(UShort_t  *h) = 0;
   virtual   Int_t    ReadStaticArray(Int_t     *i) = 0;
   virtual   Int_t    ReadStaticArray(UInt_t    *i) = 0;
   virtual   Int_t    ReadStaticArray(Long_t    *l) = 0;
   virtual   Int_t    ReadStaticArray(ULong_t   *l) = 0;
   virtual   Int_t    ReadStaticArray(Long64_t  *l) = 0;
   virtual   Int_t    ReadStaticArray(ULong64_t *l) = 0;
   virtual   Int_t    ReadStaticArray(Float_t   *f) = 0;
   virtual   Int_t    ReadStaticArray(Double_t  *d) = 0;
   virtual   Int_t    ReadStaticArrayFloat16(Float_t  *f, TStreamerElement *ele=0) = 0;
   virtual   Int_t    ReadStaticArrayDouble32(Double_t  *d, TStreamerElement *ele=0) = 0;

   virtual   void     ReadFastArray(Bool_t    *b, Int_t n) = 0;
   virtual   void     ReadFastArray(Char_t    *c, Int_t n) = 0;
   virtual   void     ReadFastArrayString(Char_t *c, Int_t n) = 0;
   virtual   void     ReadFastArray(UChar_t   *c, Int_t n) = 0;
   virtual   void     ReadFastArray(Short_t   *h, Int_t n) = 0;
   virtual   void     ReadFastArray(UShort_t  *h, Int_t n) = 0;
   virtual   void     ReadFastArray(Int_t     *i, Int_t n) = 0;
   virtual   void     ReadFastArray(UInt_t    *i, Int_t n) = 0;
   virtual   void     ReadFastArray(Long_t    *l, Int_t n) = 0;
   virtual   void     ReadFastArray(ULong_t   *l, Int_t n) = 0;
   virtual   void     ReadFastArray(Long64_t  *l, Int_t n) = 0;
   virtual   void     ReadFastArray(ULong64_t *l, Int_t n) = 0;
   virtual   void     ReadFastArray(Float_t   *f, Int_t n) = 0;
   virtual   void     ReadFastArray(Double_t  *d, Int_t n) = 0;
   virtual   void     ReadFastArrayFloat16(Float_t  *f, Int_t n, TStreamerElement *ele=0) = 0;
   virtual   void     ReadFastArrayDouble32(Double_t  *d, Int_t n, TStreamerElement *ele=0) = 0;
   virtual   void     ReadFastArray(void  *start , const TClass *cl, Int_t n=1, TMemberStreamer *s=0, const TClass *onFileClass=0) = 0;
   virtual   void     ReadFastArray(void **startp, const TClass *cl, Int_t n=1, Bool_t isPreAlloc=kFALSE, TMemberStreamer *s=0, const TClass *onFileClass=0) = 0;

   virtual   void     WriteArray(const Bool_t    *b, Int_t n) = 0;
   virtual   void     WriteArray(const Char_t    *c, Int_t n) = 0;
   virtual   void     WriteArray(const UChar_t   *c, Int_t n) = 0;
   virtual   void     WriteArray(const Short_t   *h, Int_t n) = 0;
   virtual   void     WriteArray(const UShort_t  *h, Int_t n) = 0;
   virtual   void     WriteArray(const Int_t     *i, Int_t n) = 0;
   virtual   void     WriteArray(const UInt_t    *i, Int_t n) = 0;
   virtual   void     WriteArray(const Long_t    *l, Int_t n) = 0;
   virtual   void     WriteArray(const ULong_t   *l, Int_t n) = 0;
   virtual   void     WriteArray(const Long64_t  *l, Int_t n) = 0;
   virtual   void     WriteArray(const ULong64_t *l, Int_t n) = 0;
   virtual   void     WriteArray(const Float_t   *f, Int_t n) = 0;
   virtual   void     WriteArray(const Double_t  *d, Int_t n) = 0;
   virtual   void     WriteArrayFloat16(const Float_t  *f, Int_t n, TStreamerElement *ele=0) = 0;
   virtual   void     WriteArrayDouble32(const Double_t  *d, Int_t n, TStreamerElement *ele=0) = 0;

   virtual   void     WriteFastArray(const Bool_t    *b, Int_t n) = 0;
   virtual   void     WriteFastArray(const Char_t    *c, Int_t n) = 0;
   virtual   void     WriteFastArrayString(const Char_t    *c, Int_t n) = 0;
   virtual   void     WriteFastArray(const UChar_t   *c, Int_t n) = 0;
   virtual   void     WriteFastArray(const Short_t   *h, Int_t n) = 0;
   virtual   void     WriteFastArray(const UShort_t  *h, Int_t n) = 0;
   virtual   void     WriteFastArray(const Int_t     *i, Int_t n) = 0;
   virtual   void     WriteFastArray(const UInt_t    *i, Int_t n) = 0;
   virtual   void     WriteFastArray(const Long_t    *l, Int_t n) = 0;
   virtual   void     WriteFastArray(const ULong_t   *l, Int_t n) = 0;
   virtual   void     WriteFastArray(const Long64_t  *l, Int_t n) = 0;
   virtual   void     WriteFastArray(const ULong64_t *l, Int_t n) = 0;
   virtual   void     WriteFastArray(const Float_t   *f, Int_t n) = 0;
   virtual   void     WriteFastArray(const Double_t  *d, Int_t n) = 0;
   virtual   void     WriteFastArrayFloat16(const Float_t  *f, Int_t n, TStreamerElement *ele=0) = 0;
   virtual   void     WriteFastArrayDouble32(const Double_t  *d, Int_t n, TStreamerElement *ele=0) = 0;
   virtual   void     WriteFastArray(void  *start,  const TClass *cl, Int_t n=1, TMemberStreamer *s=0) = 0;
   virtual   Int_t    WriteFastArray(void **startp, const TClass *cl, Int_t n=1, Bool_t isPreAlloc=kFALSE, TMemberStreamer *s=0) = 0;

   virtual   void     StreamObject(void *obj, const type_info &typeinfo, const TClass* onFileClass = 0 ) = 0;
   virtual   void     StreamObject(void *obj, const char *className, const TClass* onFileClass = 0 ) = 0;
   virtual   void     StreamObject(void *obj, const TClass *cl, const TClass* onFileClass = 0 ) = 0;
   virtual   void     StreamObject(TObject *obj) = 0;

   virtual   void     ReadBool(Bool_t       &b) = 0;
   virtual   void     ReadChar(Char_t       &c) = 0;
   virtual   void     ReadUChar(UChar_t     &c) = 0;
   virtual   void     ReadShort(Short_t     &s) = 0;
   virtual   void     ReadUShort(UShort_t   &s) = 0;
   virtual   void     ReadInt(Int_t         &i) = 0;
   virtual   void     ReadUInt(UInt_t       &i) = 0;
   virtual   void     ReadLong(Long_t       &l) = 0;
   virtual   void     ReadULong(ULong_t     &l) = 0;
   virtual   void     ReadLong64(Long64_t   &l) = 0;
   virtual   void     ReadULong64(ULong64_t &l) = 0;
   virtual   void     ReadFloat(Float_t     &f) = 0;
   virtual   void     ReadDouble(Double_t   &d) = 0;
   virtual   void     ReadCharP(Char_t      *c) = 0;
   virtual   void     ReadTString(TString   &s) = 0;

   virtual   void     WriteBool(Bool_t       b) = 0;
   virtual   void     WriteChar(Char_t       c) = 0;
   virtual   void     WriteUChar(UChar_t     c) = 0;
   virtual   void     WriteShort(Short_t     s) = 0;
   virtual   void     WriteUShort(UShort_t   s) = 0;
   virtual   void     WriteInt(Int_t         i) = 0;
   virtual   void     WriteUInt(UInt_t       i) = 0;
   virtual   void     WriteLong(Long_t       l) = 0;
   virtual   void     WriteULong(ULong_t     l) = 0;
   virtual   void     WriteLong64(Long64_t   l) = 0;
   virtual   void     WriteULong64(ULong64_t l) = 0;
   virtual   void     WriteFloat(Float_t     f) = 0;
   virtual   void     WriteDouble(Double_t   d) = 0;
   virtual   void     WriteCharP(const Char_t *c) = 0;
   virtual   void     WriteTString(const TString &s) = 0;

   // Special basic ROOT objects and collections
   virtual   TProcessID *GetLastProcessID(TRefTable *reftable) const = 0;
   virtual   UInt_t      GetTRefExecId() = 0;
   virtual   TProcessID *ReadProcessID(UShort_t pidf) = 0;
   virtual   UShort_t    WriteProcessID(TProcessID *pid) = 0;

   // Utilities for TStreamerInfo
   virtual   void     ForceWriteInfo(TVirtualStreamerInfo *info, Bool_t force) = 0;
   virtual   void     ForceWriteInfoClones(TClonesArray *a) = 0;
   virtual   Int_t    ReadClones (TClonesArray *a, Int_t nobjects, Version_t objvers) = 0;
   virtual   Int_t    WriteClones(TClonesArray *a, Int_t nobjects) = 0;

   // Utilities for TClass
   virtual   Int_t    ReadClassEmulated(const TClass *cl, void *object, const TClass *onfile_class = 0) = 0;
   virtual   Int_t    ReadClassBuffer(const TClass *cl, void *pointer, const TClass *onfile_class = 0) = 0;
   virtual   Int_t    ReadClassBuffer(const TClass *cl, void *pointer, Int_t version, UInt_t start, UInt_t count, const TClass *onfile_class = 0) = 0;
   virtual   Int_t    WriteClassBuffer(const TClass *cl, void *pointer) = 0;

   static TClass *GetClass(const type_info &typeinfo);
   static TClass *GetClass(const char *className);

   ClassDef(TBuffer,0)  //Buffer base class used for serializing objects
};

//---------------------- TBuffer default external operators --------------------

inline TBuffer &operator>>(TBuffer &buf, Bool_t &b)   { buf.ReadBool(b);   return buf; }
inline TBuffer &operator>>(TBuffer &buf, Char_t &c)   { buf.ReadChar(c);   return buf; }
inline TBuffer &operator>>(TBuffer &buf, UChar_t &c)  { buf.ReadUChar(c);  return buf; }
inline TBuffer &operator>>(TBuffer &buf, Short_t &s)  { buf.ReadShort(s);  return buf; }
inline TBuffer &operator>>(TBuffer &buf, UShort_t &s) { buf.ReadUShort(s); return buf; }
inline TBuffer &operator>>(TBuffer &buf, Int_t &i)    { buf.ReadInt(i);    return buf; }
inline TBuffer &operator>>(TBuffer &buf, UInt_t &i)   { buf.ReadUInt(i);   return buf; }
inline TBuffer &operator>>(TBuffer &buf, Long_t &l)   { buf.ReadLong(l);   return buf; }
inline TBuffer &operator>>(TBuffer &buf, ULong_t &l)  { buf.ReadULong(l);  return buf; }
inline TBuffer &operator>>(TBuffer &buf, Long64_t &l) { buf.ReadLong64(l); return buf; }
inline TBuffer &operator>>(TBuffer &buf, ULong64_t &l){ buf.ReadULong64(l);return buf; }
inline TBuffer &operator>>(TBuffer &buf, Float_t &f)  { buf.ReadFloat(f);  return buf; }
inline TBuffer &operator>>(TBuffer &buf, Double_t &d) { buf.ReadDouble(d); return buf; }
inline TBuffer &operator>>(TBuffer &buf, Char_t *c)   { buf.ReadCharP(c);  return buf; }
inline TBuffer &operator>>(TBuffer &buf, TString &s)  { buf.ReadTString(s);return buf; }

inline TBuffer &operator<<(TBuffer &buf, Bool_t b)   { buf.WriteBool(b);   return buf; }
inline TBuffer &operator<<(TBuffer &buf, Char_t c)   { buf.WriteChar(c);   return buf; }
inline TBuffer &operator<<(TBuffer &buf, UChar_t c)  { buf.WriteUChar(c);  return buf; }
inline TBuffer &operator<<(TBuffer &buf, Short_t s)  { buf.WriteShort(s);  return buf; }
inline TBuffer &operator<<(TBuffer &buf, UShort_t s) { buf.WriteUShort(s); return buf; }
inline TBuffer &operator<<(TBuffer &buf, Int_t i)    { buf.WriteInt(i);    return buf; }
inline TBuffer &operator<<(TBuffer &buf, UInt_t i)   { buf.WriteUInt(i);   return buf; }
inline TBuffer &operator<<(TBuffer &buf, Long_t l)   { buf.WriteLong(l);   return buf; }
inline TBuffer &operator<<(TBuffer &buf, ULong_t l)  { buf.WriteULong(l);  return buf; }
inline TBuffer &operator<<(TBuffer &buf, Long64_t l) { buf.WriteLong64(l); return buf; }
inline TBuffer &operator<<(TBuffer &buf, ULong64_t l){ buf.WriteULong64(l);return buf; }
inline TBuffer &operator<<(TBuffer &buf, Float_t f)  { buf.WriteFloat(f);  return buf; }
inline TBuffer &operator<<(TBuffer &buf, Double_t d) { buf.WriteDouble(d); return buf; }
inline TBuffer &operator<<(TBuffer &buf, const Char_t *c)  { buf.WriteCharP(c);  return buf; }
inline TBuffer &operator<<(TBuffer &buf, const TString &s) { buf.WriteTString(s);return buf; }

#if !defined(R__CONCRETE_INPUT_OPERATOR)
#ifndef __CINT__

#if defined(R__SOLARIS) && defined(R__GNU)
#include <typeinfo>
#endif

template <class Tmpl> TBuffer &operator>>(TBuffer &buf, Tmpl *&obj)
{
   // Read TObject derived classes from a TBuffer. Need to provide
   // custom version for non-TObject derived classes.

   // This operator has to be a templated and/or automatically
   // generated if we want to be able to check the type of the
   // incoming object. I.e. a operator>>(TBuffer &buf, TObject *&)
   // would not be sufficient to pass the information 'which class do we want'
   // since the pointer could be zero (so typeid(*obj) is not usable).

   TClass *cl = TBuffer::GetClass(typeid(Tmpl));
   obj = (Tmpl *) ( (void*) buf.ReadObjectAny(cl) );
   return buf;
}

template <class Tmpl> TBuffer &operator<<(TBuffer &buf, const Tmpl *obj)
{
   TClass *cl = (obj) ? TBuffer::GetClass(typeid(*obj)) : 0;
   buf.WriteObjectAny(obj, cl);
   return buf;
}
#else
template <class Tmpl> TBuffer &operator>>(TBuffer &buf, Tmpl *&obj);
template <class Tmpl> TBuffer &operator<<(TBuffer &buf, Tmpl *&obj);
#endif
#endif

#if defined(R__TEMPLATE_OVERLOAD_BUG)
template <>
#endif
inline TBuffer &operator<<(TBuffer &buf, const TObject *obj)
   { buf.WriteObjectAny(obj, TObject::Class()); return buf; }

#endif
 TBuffer.h:1
 TBuffer.h:2
 TBuffer.h:3
 TBuffer.h:4
 TBuffer.h:5
 TBuffer.h:6
 TBuffer.h:7
 TBuffer.h:8
 TBuffer.h:9
 TBuffer.h:10
 TBuffer.h:11
 TBuffer.h:12
 TBuffer.h:13
 TBuffer.h:14
 TBuffer.h:15
 TBuffer.h:16
 TBuffer.h:17
 TBuffer.h:18
 TBuffer.h:19
 TBuffer.h:20
 TBuffer.h:21
 TBuffer.h:22
 TBuffer.h:23
 TBuffer.h:24
 TBuffer.h:25
 TBuffer.h:26
 TBuffer.h:27
 TBuffer.h:28
 TBuffer.h:29
 TBuffer.h:30
 TBuffer.h:31
 TBuffer.h:32
 TBuffer.h:33
 TBuffer.h:34
 TBuffer.h:35
 TBuffer.h:36
 TBuffer.h:37
 TBuffer.h:38
 TBuffer.h:39
 TBuffer.h:40
 TBuffer.h:41
 TBuffer.h:42
 TBuffer.h:43
 TBuffer.h:44
 TBuffer.h:45
 TBuffer.h:46
 TBuffer.h:47
 TBuffer.h:48
 TBuffer.h:49
 TBuffer.h:50
 TBuffer.h:51
 TBuffer.h:52
 TBuffer.h:53
 TBuffer.h:54
 TBuffer.h:55
 TBuffer.h:56
 TBuffer.h:57
 TBuffer.h:58
 TBuffer.h:59
 TBuffer.h:60
 TBuffer.h:61
 TBuffer.h:62
 TBuffer.h:63
 TBuffer.h:64
 TBuffer.h:65
 TBuffer.h:66
 TBuffer.h:67
 TBuffer.h:68
 TBuffer.h:69
 TBuffer.h:70
 TBuffer.h:71
 TBuffer.h:72
 TBuffer.h:73
 TBuffer.h:74
 TBuffer.h:75
 TBuffer.h:76
 TBuffer.h:77
 TBuffer.h:78
 TBuffer.h:79
 TBuffer.h:80
 TBuffer.h:81
 TBuffer.h:82
 TBuffer.h:83
 TBuffer.h:84
 TBuffer.h:85
 TBuffer.h:86
 TBuffer.h:87
 TBuffer.h:88
 TBuffer.h:89
 TBuffer.h:90
 TBuffer.h:91
 TBuffer.h:92
 TBuffer.h:93
 TBuffer.h:94
 TBuffer.h:95
 TBuffer.h:96
 TBuffer.h:97
 TBuffer.h:98
 TBuffer.h:99
 TBuffer.h:100
 TBuffer.h:101
 TBuffer.h:102
 TBuffer.h:103
 TBuffer.h:104
 TBuffer.h:105
 TBuffer.h:106
 TBuffer.h:107
 TBuffer.h:108
 TBuffer.h:109
 TBuffer.h:110
 TBuffer.h:111
 TBuffer.h:112
 TBuffer.h:113
 TBuffer.h:114
 TBuffer.h:115
 TBuffer.h:116
 TBuffer.h:117
 TBuffer.h:118
 TBuffer.h:119
 TBuffer.h:120
 TBuffer.h:121
 TBuffer.h:122
 TBuffer.h:123
 TBuffer.h:124
 TBuffer.h:125
 TBuffer.h:126
 TBuffer.h:127
 TBuffer.h:128
 TBuffer.h:129
 TBuffer.h:130
 TBuffer.h:131
 TBuffer.h:132
 TBuffer.h:133
 TBuffer.h:134
 TBuffer.h:135
 TBuffer.h:136
 TBuffer.h:137
 TBuffer.h:138
 TBuffer.h:139
 TBuffer.h:140
 TBuffer.h:141
 TBuffer.h:142
 TBuffer.h:143
 TBuffer.h:144
 TBuffer.h:145
 TBuffer.h:146
 TBuffer.h:147
 TBuffer.h:148
 TBuffer.h:149
 TBuffer.h:150
 TBuffer.h:151
 TBuffer.h:152
 TBuffer.h:153
 TBuffer.h:154
 TBuffer.h:155
 TBuffer.h:156
 TBuffer.h:157
 TBuffer.h:158
 TBuffer.h:159
 TBuffer.h:160
 TBuffer.h:161
 TBuffer.h:162
 TBuffer.h:163
 TBuffer.h:164
 TBuffer.h:165
 TBuffer.h:166
 TBuffer.h:167
 TBuffer.h:168
 TBuffer.h:169
 TBuffer.h:170
 TBuffer.h:171
 TBuffer.h:172
 TBuffer.h:173
 TBuffer.h:174
 TBuffer.h:175
 TBuffer.h:176
 TBuffer.h:177
 TBuffer.h:178
 TBuffer.h:179
 TBuffer.h:180
 TBuffer.h:181
 TBuffer.h:182
 TBuffer.h:183
 TBuffer.h:184
 TBuffer.h:185
 TBuffer.h:186
 TBuffer.h:187
 TBuffer.h:188
 TBuffer.h:189
 TBuffer.h:190
 TBuffer.h:191
 TBuffer.h:192
 TBuffer.h:193
 TBuffer.h:194
 TBuffer.h:195
 TBuffer.h:196
 TBuffer.h:197
 TBuffer.h:198
 TBuffer.h:199
 TBuffer.h:200
 TBuffer.h:201
 TBuffer.h:202
 TBuffer.h:203
 TBuffer.h:204
 TBuffer.h:205
 TBuffer.h:206
 TBuffer.h:207
 TBuffer.h:208
 TBuffer.h:209
 TBuffer.h:210
 TBuffer.h:211
 TBuffer.h:212
 TBuffer.h:213
 TBuffer.h:214
 TBuffer.h:215
 TBuffer.h:216
 TBuffer.h:217
 TBuffer.h:218
 TBuffer.h:219
 TBuffer.h:220
 TBuffer.h:221
 TBuffer.h:222
 TBuffer.h:223
 TBuffer.h:224
 TBuffer.h:225
 TBuffer.h:226
 TBuffer.h:227
 TBuffer.h:228
 TBuffer.h:229
 TBuffer.h:230
 TBuffer.h:231
 TBuffer.h:232
 TBuffer.h:233
 TBuffer.h:234
 TBuffer.h:235
 TBuffer.h:236
 TBuffer.h:237
 TBuffer.h:238
 TBuffer.h:239
 TBuffer.h:240
 TBuffer.h:241
 TBuffer.h:242
 TBuffer.h:243
 TBuffer.h:244
 TBuffer.h:245
 TBuffer.h:246
 TBuffer.h:247
 TBuffer.h:248
 TBuffer.h:249
 TBuffer.h:250
 TBuffer.h:251
 TBuffer.h:252
 TBuffer.h:253
 TBuffer.h:254
 TBuffer.h:255
 TBuffer.h:256
 TBuffer.h:257
 TBuffer.h:258
 TBuffer.h:259
 TBuffer.h:260
 TBuffer.h:261
 TBuffer.h:262
 TBuffer.h:263
 TBuffer.h:264
 TBuffer.h:265
 TBuffer.h:266
 TBuffer.h:267
 TBuffer.h:268
 TBuffer.h:269
 TBuffer.h:270
 TBuffer.h:271
 TBuffer.h:272
 TBuffer.h:273
 TBuffer.h:274
 TBuffer.h:275
 TBuffer.h:276
 TBuffer.h:277
 TBuffer.h:278
 TBuffer.h:279
 TBuffer.h:280
 TBuffer.h:281
 TBuffer.h:282
 TBuffer.h:283
 TBuffer.h:284
 TBuffer.h:285
 TBuffer.h:286
 TBuffer.h:287
 TBuffer.h:288
 TBuffer.h:289
 TBuffer.h:290
 TBuffer.h:291
 TBuffer.h:292
 TBuffer.h:293
 TBuffer.h:294
 TBuffer.h:295
 TBuffer.h:296
 TBuffer.h:297
 TBuffer.h:298
 TBuffer.h:299
 TBuffer.h:300
 TBuffer.h:301
 TBuffer.h:302
 TBuffer.h:303
 TBuffer.h:304
 TBuffer.h:305
 TBuffer.h:306
 TBuffer.h:307
 TBuffer.h:308
 TBuffer.h:309
 TBuffer.h:310
 TBuffer.h:311
 TBuffer.h:312
 TBuffer.h:313
 TBuffer.h:314
 TBuffer.h:315
 TBuffer.h:316
 TBuffer.h:317
 TBuffer.h:318
 TBuffer.h:319
 TBuffer.h:320
 TBuffer.h:321
 TBuffer.h:322
 TBuffer.h:323
 TBuffer.h:324
 TBuffer.h:325
 TBuffer.h:326
 TBuffer.h:327
 TBuffer.h:328
 TBuffer.h:329
 TBuffer.h:330
 TBuffer.h:331
 TBuffer.h:332
 TBuffer.h:333
 TBuffer.h:334
 TBuffer.h:335
 TBuffer.h:336
 TBuffer.h:337
 TBuffer.h:338
 TBuffer.h:339
 TBuffer.h:340
 TBuffer.h:341
 TBuffer.h:342
 TBuffer.h:343
 TBuffer.h:344
 TBuffer.h:345
 TBuffer.h:346
 TBuffer.h:347
 TBuffer.h:348
 TBuffer.h:349
 TBuffer.h:350
 TBuffer.h:351
 TBuffer.h:352
 TBuffer.h:353
 TBuffer.h:354
 TBuffer.h:355
 TBuffer.h:356
 TBuffer.h:357
 TBuffer.h:358
 TBuffer.h:359
 TBuffer.h:360
 TBuffer.h:361
 TBuffer.h:362
 TBuffer.h:363
 TBuffer.h:364
 TBuffer.h:365
 TBuffer.h:366
 TBuffer.h:367
 TBuffer.h:368
 TBuffer.h:369
 TBuffer.h:370
 TBuffer.h:371
 TBuffer.h:372
 TBuffer.h:373