library: libCore #include "TBuffer.h"

# TBuffer

class description - source file - inheritance tree (.pdf)

## class TBuffer : public TObject

| Inheritance Chart:
`TObject`
| <- | `TBuffer` |
<- |
`TBufferXML` |
`TMessage` |

        protected:

                        TBuffer()
                        TBuffer(const TBuffer&)
                  Int_t CheckByteCount(UInt_t startpos, UInt_t bcnt, const TClass* clss, const char* classname)
                   void CheckCount(UInt_t offset)
                 UInt_t CheckObject(UInt_t offset, const TClass* cl, Bool_t readClass = kFALSE)
                   void Expand(Int_t newsize)
                   void operator=(const TBuffer&)
          virtual Int_t Read(const char* name)
          virtual Int_t Write(const char* name, Int_t opt, Int_t bufs)
          virtual Int_t Write(const char* name, Int_t opt, Int_t bufs) const
           virtual void WriteObject(const void* actualObjStart, const TClass* actualClass)

        public:

                            TBuffer(TBuffer::EMode mode)
                            TBuffer(TBuffer::EMode mode, Int_t bufsiz)
                            TBuffer(TBuffer::EMode mode, Int_t bufsiz, void* buf, Bool_t adopt = kTRUE)
                    virtual ~TBuffer()
                      char* Buffer() const
                      Int_t BufferSize() const
              virtual Int_t CheckByteCount(UInt_t startpos, UInt_t bcnt, const TClass* clss)
              virtual Int_t CheckByteCount(UInt_t startpos, UInt_t bcnt, const char* classname)
                     Bool_t CheckObject(const TObject* obj)
                     Bool_t CheckObject(const void* obj, const TClass* ptrClass)
             static TClass* Class()
               virtual void DecrementLevel(TStreamerInfo*)
                       void DetachBuffer()
                      Int_t GetBufferDisplacement() const
                      Int_t GetBufferVersion() const
             static TClass* GetClass(const type_info& typeinfo)
             static TClass* GetClass(const char* className)
               static Int_t GetGlobalReadParam()
               static Int_t GetGlobalWriteParam()
             TStreamerInfo* GetInfo()
                      Int_t GetMapCount() const
                       void GetMappedObject(UInt_t tag, void*& ptr, TClass*& ClassPtr) const
                   TObject* GetParent() const
               virtual void IncrementLevel(TStreamerInfo* info)
                       void InitMap()
            virtual TClass* IsA() const
                     Bool_t IsReading() const
                     Bool_t IsWriting() const
                      Int_t Length() const
                       void MapObject(const TObject* obj, UInt_t offset = 1)
                       void MapObject(const void* obj, const TClass* cl, UInt_t offset = 1)
           virtual TBuffer& operator<<(Bool_t b)
           virtual TBuffer& operator<<(Char_t c)
           virtual TBuffer& operator<<(UChar_t c)
           virtual TBuffer& operator<<(Short_t h)
           virtual TBuffer& operator<<(UShort_t h)
           virtual TBuffer& operator<<(Int_t i)
           virtual TBuffer& operator<<(UInt_t i)
           virtual TBuffer& operator<<(Long_t l)
           virtual TBuffer& operator<<(ULong_t l)
           virtual TBuffer& operator<<(Long64_t l)
           virtual TBuffer& operator<<(ULong64_t l)
           virtual TBuffer& operator<<(Float_t f)
           virtual TBuffer& operator<<(Double_t d)
           virtual TBuffer& operator<<(const Char_t* c)
           virtual TBuffer& operator>>(Bool_t& b)
           virtual TBuffer& operator>>(Char_t& c)
           virtual TBuffer& operator>>(UChar_t& c)
           virtual TBuffer& operator>>(Short_t& h)
           virtual TBuffer& operator>>(UShort_t& h)
           virtual TBuffer& operator>>(Int_t& i)
           virtual TBuffer& operator>>(UInt_t& i)
           virtual TBuffer& operator>>(Long_t& l)
           virtual TBuffer& operator>>(ULong_t& l)
           virtual TBuffer& operator>>(Long64_t& l)
           virtual TBuffer& operator>>(ULong64_t& l)
           virtual TBuffer& operator>>(Float_t& f)
           virtual TBuffer& operator>>(Double_t& d)
           virtual TBuffer& operator>>(Char_t* c)
              virtual Int_t ReadArray(Bool_t*& b)
              virtual Int_t ReadArray(Char_t*& c)
              virtual Int_t ReadArray(UChar_t*& c)
              virtual Int_t ReadArray(Short_t*& h)
              virtual Int_t ReadArray(UShort_t*& h)
              virtual Int_t ReadArray(Int_t*& i)
              virtual Int_t ReadArray(UInt_t*& i)
              virtual Int_t ReadArray(Long_t*& l)
              virtual Int_t ReadArray(ULong_t*& l)
              virtual Int_t ReadArray(Long64_t*& l)
              virtual Int_t ReadArray(ULong64_t*& l)
              virtual Int_t ReadArray(Float_t*& f)
              virtual Int_t ReadArray(Double_t*& d)
              virtual Int_t ReadArrayDouble32(Double_t*& d, TStreamerElement* ele = 0)
                      Int_t ReadBuf(void* buf, Int_t max)
            virtual TClass* ReadClass(const TClass* cl = 0, UInt_t* objTag = 0)
               virtual void ReadDouble32(Double_t* d, TStreamerElement* ele = 0)
               virtual void ReadFastArray(Bool_t* b, Int_t n)
               virtual void ReadFastArray(Char_t* c, Int_t n)
               virtual void ReadFastArray(UChar_t* c, Int_t n)
               virtual void ReadFastArray(Short_t* h, Int_t n)
               virtual void ReadFastArray(UShort_t* h, Int_t n)
               virtual void ReadFastArray(Int_t* i, Int_t n)
               virtual void ReadFastArray(UInt_t* i, Int_t n)
               virtual void ReadFastArray(Long_t* l, Int_t n)
               virtual void ReadFastArray(ULong_t* l, Int_t n)
               virtual void ReadFastArray(Long64_t* l, Int_t n)
               virtual void ReadFastArray(ULong64_t* l, Int_t n)
               virtual void ReadFastArray(Float_t* f, Int_t n)
               virtual void ReadFastArray(Double_t* d, Int_t n)
               virtual void ReadFastArray(void* start, const TClass* cl, Int_t n = 1, TMemberStreamer* s = 0)
               virtual void ReadFastArray(void** startp, const TClass* cl, Int_t n = 1, Bool_t isPreAlloc = kFALSE, TMemberStreamer* s = 0)
               virtual void ReadFastArrayDouble32(Double_t* d, Int_t n, TStreamerElement* ele = 0)
           virtual TObject* ReadObject(const TClass* cl)
              virtual void* ReadObjectAny(const TClass* cast)
              virtual Int_t ReadStaticArray(Bool_t* b)
              virtual Int_t ReadStaticArray(Char_t* c)
              virtual Int_t ReadStaticArray(UChar_t* c)
              virtual Int_t ReadStaticArray(Short_t* h)
              virtual Int_t ReadStaticArray(UShort_t* h)
              virtual Int_t ReadStaticArray(Int_t* i)
              virtual Int_t ReadStaticArray(UInt_t* i)
              virtual Int_t ReadStaticArray(Long_t* l)
              virtual Int_t ReadStaticArray(ULong_t* l)
              virtual Int_t ReadStaticArray(Long64_t* l)
              virtual Int_t ReadStaticArray(ULong64_t* l)
              virtual Int_t ReadStaticArray(Float_t* f)
              virtual Int_t ReadStaticArray(Double_t* d)
              virtual Int_t ReadStaticArrayDouble32(Double_t* d, TStreamerElement* ele = 0)
                      char* ReadString(char* s, Int_t max)
          virtual Version_t ReadVersion(UInt_t* start = 0, UInt_t* bcnt = 0, const TClass* cl = 0)
               virtual void Reset()
                       void ResetMap()
                       void SetBuffer(void* buf, UInt_t bufsiz = 0, Bool_t adopt = kTRUE)
                       void SetBufferDisplacement(Int_t skipped)
                       void SetBufferDisplacement()
                       void SetBufferOffset(Int_t offset = 0)
               virtual void SetByteCount(UInt_t cntpos, Bool_t packInVersion = kFALSE)
                static void SetGlobalReadParam(Int_t mapsize)
                static void SetGlobalWriteParam(Int_t mapsize)
                       void SetParent(TObject* parent)
                       void SetReadMode()
                       void SetReadParam(Int_t mapsize)
               virtual void SetStreamerElementNumber(Int_t)
                       void SetWriteMode()
                       void SetWriteParam(Int_t mapsize)
               virtual void ShowMembers(TMemberInspector& insp, char* parent)
               virtual void SkipObjectAny()
               virtual void Streamer(TBuffer& b)
                       void StreamerNVirtual(TBuffer& b)
               virtual void StreamObject(void* obj, const type_info& typeinfo)
               virtual void StreamObject(void* obj, const char* className)
               virtual void StreamObject(void* obj, const TClass* cl)
               virtual void WriteArray(const Bool_t* b, Int_t n)
               virtual void WriteArray(const Char_t* c, Int_t n)
               virtual void WriteArray(const UChar_t* c, Int_t n)
               virtual void WriteArray(const Short_t* h, Int_t n)
               virtual void WriteArray(const UShort_t* h, Int_t n)
               virtual void WriteArray(const Int_t* i, Int_t n)
               virtual void WriteArray(const UInt_t* i, Int_t n)
               virtual void WriteArray(const Long_t* l, Int_t n)
               virtual void WriteArray(const ULong_t* l, Int_t n)
               virtual void WriteArray(const Long64_t* l, Int_t n)
               virtual void WriteArray(const ULong64_t* l, Int_t n)
               virtual void WriteArray(const Float_t* f, Int_t n)
               virtual void WriteArray(const Double_t* d, Int_t n)
               virtual void WriteArrayDouble32(const Double_t* d, Int_t n, TStreamerElement* ele = 0)
                       void WriteBuf(const void* buf, Int_t max)
               virtual void WriteClass(const TClass* cl)
               virtual void WriteDouble32(Double_t* d, TStreamerElement* ele = 0)
               virtual void WriteFastArray(const Bool_t* b, Int_t n)
               virtual void WriteFastArray(const Char_t* c, Int_t n)
               virtual void WriteFastArray(const UChar_t* c, Int_t n)
               virtual void WriteFastArray(const Short_t* h, Int_t n)
               virtual void WriteFastArray(const UShort_t* h, Int_t n)
               virtual void WriteFastArray(const Int_t* i, Int_t n)
               virtual void WriteFastArray(const UInt_t* i, Int_t n)
               virtual void WriteFastArray(const Long_t* l, Int_t n)
               virtual void WriteFastArray(const ULong_t* l, Int_t n)
               virtual void WriteFastArray(const Long64_t* l, Int_t n)
               virtual void WriteFastArray(const ULong64_t* l, Int_t n)
               virtual void WriteFastArray(const Float_t* f, Int_t n)
               virtual void WriteFastArray(const Double_t* d, Int_t n)
               virtual void WriteFastArray(void* start, const TClass* cl, Int_t n = 1, TMemberStreamer* s = 0)
              virtual Int_t WriteFastArray(void** startp, const TClass* cl, Int_t n = 1, Bool_t isPreAlloc = kFALSE, TMemberStreamer* s = 0)
               virtual void WriteFastArrayDouble32(const Double_t* d, Int_t n, TStreamerElement* ele = 0)
               virtual void WriteObject(const TObject* obj)
              virtual Int_t WriteObjectAny(const void* obj, const TClass* ptrClass)
                       void WriteString(const char* s)
             virtual UInt_t WriteVersion(const TClass* cl, Bool_t useBcnt = kFALSE)
             virtual UInt_t WriteVersionMemberWise(const TClass* cl, Bool_t useBcnt = kFALSE)

### Data Members

        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
                                                      Int_t fMapCount      Number of objects or classes in map
                                                      Int_t fMapSize       Default size of map
                                                      Int_t fDisplacement  Value to be added to the map offsets
                                                    TExMap* fMap           Map containing object,offset pairs for reading/writing
                                                    TExMap* fClassMap      Map containing object,class pairs for reading
                                                   TObject* fParent        Pointer to the buffer parent (file) where buffer is read/written
                                             TStreamerInfo* fInfo          Pointer to TStreamerInfo object writing/reading the buffer
          vector<TStreamerInfo*,allocator<TStreamerInfo*> > fInfos         Stack of pointers to the TStreamerInfos
                                               static Int_t fgMapSize      Default map size for all TBuffer objects

        public:

          static const TBuffer::EMode kRead
          static const TBuffer::EMode kWrite
          static const enum TBuffer:: kInitialSize
          static const enum TBuffer:: kMinimalSize
          static const enum TBuffer:: kMapSize
          static const enum TBuffer:: kStreamedMemberWise
          static const enum TBuffer:: kNotDecompressed
          static const enum TBuffer:: kIsOwner
          static const enum TBuffer:: kUser1
          static const enum TBuffer:: kUser2
          static const enum TBuffer:: kUser3

## Class Description

     TBuffer

     Buffer base class used for serializing objects.

TBuffer(EMode mode) : fInfo(0), fInfos(10)

     Create an I/O buffer object. Mode should be either TBuffer::kRead or
     TBuffer::kWrite. By default the I/O buffer has a size of
     TBuffer::kInitialSize (1024) bytes.

TBuffer(EMode mode, Int_t bufsiz) : fInfo(0), fInfos(10)

     Create an I/O buffer object. Mode should be either TBuffer::kRead or
     TBuffer::kWrite.

TBuffer(EMode mode, Int_t bufsiz, void *buf, Bool_t adopt) : fInfo(0), fInfos(10)

     Create an I/O buffer object. Mode should be either TBuffer::kRead or
     TBuffer::kWrite. By default the I/O buffer has a size of
     TBuffer::kInitialSize (1024) bytes. An external buffer can be passed
     to TBuffer via the buf argument. By default this buffer will be adopted
     unless adopt is false.

~TBuffer()

     Delete an I/O buffer object.

void SetBuffer(void *buf, UInt_t newsiz, Bool_t adopt)

     Sets a new buffer in an existing TBuffer object. If newsiz=0 then the
     new buffer is expected to have the same size as the previous buffer.
     The current buffer position is reset to the start of the buffer.
     If the TBuffer owned the previous buffer, it will be deleted prior
     to accepting the new buffer. By default the new buffer will be
     adopted unless adopt is false.

void CheckCount(UInt_t offset)

     Check if offset is not too large (< kMaxMapCount) when writing.

UInt_t CheckObject(UInt_t offset, const TClass *cl, Bool_t readClass)

     Check for object in the read map. If the object is 0 it still has to be
     read. Try to read it from the buffer starting at location offset. If the
     object is -1 then it really does not exist and we return 0. If the object
     exists just return the offset.

Bool_t CheckObject(const TObject *obj)

     Check if the specified object is already in the buffer.
     Returns kTRUE if object already in the buffer, kFALSE otherwise
     (also if obj is 0 or TBuffer not in writing mode).

Bool_t CheckObject(const void *obj, const TClass *ptrClass)

     Check if the specified object of the specified class is already in
     the buffer. Returns kTRUE if object already in the buffer,
     kFALSE otherwise (also if obj is 0 or TBuffer not in writing mode).

void Expand(Int_t newsize)

     Expand the I/O buffer to newsize bytes.

TObject* GetParent() const

     Return pointer to parent of this buffer.

void SetParent(TObject *parent)

     Set parent owning this buffer.

void GetMappedObject(UInt_t tag, void* &ptr, TClass* &ClassPtr) const

     Retrieve the object stored in the buffer's object map at 'tag'
     Set ptr and ClassPtr respectively to the address of the object and
     a pointer to its TClass.

void MapObject(const TObject *obj, UInt_t offset)

     Add object to the fMap container.
     If obj is not 0 add object to the map (in read mode also add 0 objects to
     the map). This method may only be called outside this class just before
     calling obj->Streamer() to prevent self reference of obj, in case obj
     contains (via via) a pointer to itself. In that case offset must be 1
     (default value for offset).

void MapObject(const void *obj, const TClass* cl, UInt_t offset)

     Add object to the fMap container.
     If obj is not 0 add object to the map (in read mode also add 0 objects to
     the map). This method may only be called outside this class just before
     calling obj->Streamer() to prevent self reference of obj, in case obj
     contains (via via) a pointer to itself. In that case offset must be 1
     (default value for offset).

void SetReadParam(Int_t mapsize)

     Set the initial size of the map used to store object and class
     references during reading. The default size is kMapSize=503.
     Increasing the default has the benefit that when reading many
     small objects the map does not need to be resized too often
     (the system is always dynamic, even with the default everything
     will work, only the initial resizing will cost some time).
     This method can only be called directly after the creation of
     the TBuffer, before any reading is done. Globally this option
     can be changed using SetGlobalReadParam().

void SetWriteParam(Int_t mapsize)

     Set the initial size of the hashtable used to store object and class
     references during writing. The default size is kMapSize=503.
     Increasing the default has the benefit that when writing many
     small objects the hashtable does not get too many collisions
     (the system is always dynamic, even with the default everything
     will work, only a large number of collisions will cost performance).
     For optimal performance hashsize should always be a prime.
     This method can only be called directly after the creation of
     the TBuffer, before any writing is done. Globally this option
     can be changed using SetGlobalWriteParam().

void InitMap()

     Create the fMap container and initialize them
     with the null object.

void IncrementLevel(TStreamerInfo* info)

void DecrementLevel(TStreamerInfo* /*info*/)

void ResetMap()

     Delete existing fMap and reset map counter.

void SetByteCount(UInt_t cntpos, Bool_t packInVersion)

     Set byte count at position cntpos in the buffer. Generate warning if
     count larger than kMaxMapCount. The count is excluded its own size.

Int_t CheckByteCount(UInt_t startpos, UInt_t bcnt, const TClass *clss, const char *classname)

     Check byte count with current buffer position. They should
     match. If not print warning and position buffer in correct
     place determined by the byte count. Startpos is position of
     first byte where the byte count is written in buffer.
     Returns 0 if everything is ok, otherwise the bytecount offset
     (< 0 when read too little, >0 when read too much).

Int_t CheckByteCount(UInt_t startpos, UInt_t bcnt, const TClass *clss)

     Check byte count with current buffer position. They should
     match. If not print warning and position buffer in correct
     place determined by the byte count. Startpos is position of
     first byte where the byte count is written in buffer.
     Returns 0 if everything is ok, otherwise the bytecount offset
     (< 0 when read too little, >0 when read too much).

Int_t CheckByteCount(UInt_t startpos, UInt_t bcnt, const char *classname)

     Check byte count with current buffer position. They should
     match. If not print warning and position buffer in correct
     place determined by the byte count. Startpos is position of
     first byte where the byte count is written in buffer.
     Returns 0 if everything is ok, otherwise the bytecount offset
     (< 0 when read too little, >0 when read too much).

Int_t ReadBuf(void *buf, Int_t max)

     Read max bytes from the I/O buffer into buf. The function returns
     the actual number of bytes read.

void WriteBuf(const void *buf, Int_t max)

     Write max bytes from buf into the I/O buffer.

Text_t* ReadString(Text_t *s, Int_t max)

     Read string from I/O buffer. String is read till 0 character is
     found or till max-1 characters are read (i.e. string s has max
     bytes allocated). If max = -1 no check on number of character is
     made, reading continues till 0 character is found.

void WriteString(const Text_t *s)

     Write string to I/O buffer. Writes string upto and including the
     terminating 0.

void ReadDouble32 (Double_t *d, TStreamerElement *ele)

     read a Double32_t from the buffer
     see comments about Double32_t encoding at TBuffer::WriteDouble32

void WriteDouble32 (Double_t *d, TStreamerElement *ele)

     write a Double32_t to the buffer
     The following cases are supported for streaming a Double32_t type
     depending on the range declaration in the comment field of the data member:
      A-    Double32_t     fNormal;
      B-    Double32_t     fTemperature; //[0,100]
      C-    Double32_t     fCharge;      //[-1,1,2]
      D-    Double32_t     fVertex[3];   //[-30,30,10]
      E     Int_t          fNsp;
            Double32_t*    fPointValue;   //[fNsp][0,3]

     In case A fNormal is converted from a Double_t to a Float_t
     In case B fTemperature is converted to a 32 bit unsigned integer
     In case C fCharge is converted to a 2 bits unsigned integer
     In case D the array elements of fVertex are converted to an unsigned 10 bits integer
     In case E the fNsp elements of array fPointvalue are converted to an unsigned 32 bit integer
               Note that the range specifier must follow the dimension specifier.
     the case B has more precision (9 to 10 significative digits than case A (6 to 7 digits).

     The range specifier has the general format: [xmin,xmax] or [xmin,xmax,nbits]
      [0,1]
      [-10,100];
      [-pi,pi], [-pi/2,pi/4],[-2pi,2*pi]
      [-10,100,16]
     if nbits is not specified, or nbits <2 or nbits>32 it is set to 32

      see example of use of the Double32_t data type in tutorial double32.C

/* */

Int_t ReadArray(Bool_t *&b)

     Read array of bools from the I/O buffer. Returns the number of
     bools read. If argument is a 0 pointer then space will be
     allocated for the array.

Int_t ReadArray(Char_t *&c)

     Read array of characters from the I/O buffer. Returns the number of
     characters read. If argument is a 0 pointer then space will be
     allocated for the array.

Int_t ReadArray(Short_t *&h)

     Read array of shorts from the I/O buffer. Returns the number of shorts
     read. If argument is a 0 pointer then space will be allocated for the
     array.

Int_t ReadArray(Int_t *&ii)

     Read array of ints from the I/O buffer. Returns the number of ints
     read. If argument is a 0 pointer then space will be allocated for the
     array.

Int_t ReadArray(Long_t *&ll)

     Read array of longs from the I/O buffer. Returns the number of longs
     read. If argument is a 0 pointer then space will be allocated for the
     array.

Int_t ReadArray(Long64_t *&ll)

     Read array of long longs from the I/O buffer. Returns the number of
     long longs read. If argument is a 0 pointer then space will be
     allocated for the array.

Int_t ReadArray(Float_t *&f)

     Read array of floats from the I/O buffer. Returns the number of floats
     read. If argument is a 0 pointer then space will be allocated for the
     array.

Int_t ReadArray(Double_t *&d)

     Read array of doubles from the I/O buffer. Returns the number of doubles
     read. If argument is a 0 pointer then space will be allocated for the
     array.

Int_t ReadArrayDouble32(Double_t *&d, TStreamerElement *ele)

     Read array of doubles (written as float) from the I/O buffer.
     Returns the number of doubles read.
     If argument is a 0 pointer then space will be allocated for the array.
     see comments about Double32_t encoding at TBuffer::WriteDouble32

Int_t ReadStaticArray(Bool_t *b)

     Read array of bools from the I/O buffer. Returns the number of bools
     read.

Int_t ReadStaticArray(Char_t *c)

     Read array of characters from the I/O buffer. Returns the number of
     characters read.

Int_t ReadStaticArray(Short_t *h)

     Read array of shorts from the I/O buffer. Returns the number of shorts
     read.

Int_t ReadStaticArray(Int_t *ii)

     Read array of ints from the I/O buffer. Returns the number of ints
     read.

Int_t ReadStaticArray(Long_t *ll)

     Read array of longs from the I/O buffer. Returns the number of longs
     read.

Int_t ReadStaticArray(Long64_t *ll)

     Read array of long longs from the I/O buffer. Returns the number of
     long longs read.

Int_t ReadStaticArray(Float_t *f)

     Read array of floats from the I/O buffer. Returns the number of floats
     read.

Int_t ReadStaticArray(Double_t *d)

     Read array of doubles from the I/O buffer. Returns the number of doubles
     read.

Int_t ReadStaticArrayDouble32(Double_t *d, TStreamerElement *ele)

     Read array of doubles (written as float) from the I/O buffer.
     Returns the number of doubles read.
     see comments about Double32_t encoding at TBuffer::WriteDouble32

void ReadFastArray(Bool_t *b, Int_t n)

     Read array of n bools from the I/O buffer.

void ReadFastArray(Char_t *c, Int_t n)

     Read array of n characters from the I/O buffer.

void ReadFastArray(Short_t *h, Int_t n)

     Read array of n shorts from the I/O buffer.

void ReadFastArray(Int_t *ii, Int_t n)

     Read array of n ints from the I/O buffer.

void ReadFastArray(Long_t *ll, Int_t n)

     Read array of n longs from the I/O buffer.

void ReadFastArray(Long64_t *ll, Int_t n)

     Read array of n long longs from the I/O buffer.

void ReadFastArray(Float_t *f, Int_t n)

     Read array of n floats from the I/O buffer.

void ReadFastArray(Double_t *d, Int_t n)

     Read array of n doubles from the I/O buffer.

void ReadFastArrayDouble32(Double_t *d, Int_t n, TStreamerElement *ele)

     Read array of n doubles (written as float) from the I/O buffer.
     see comments about Double32_t encoding at TBuffer::WriteDouble32

void ReadFastArray(void *start, const TClass *cl, Int_t n, TMemberStreamer *streamer)

     Read an array of 'n' objects from the I/O buffer.
     Stores the objects read starting at the address 'start'.
     The objects in the array are assume to be of class 'cl'.

void ReadFastArray(void **start, const TClass *cl, Int_t n, Bool_t isPreAlloc, TMemberStreamer *streamer)

     Read an array of 'n' objects from the I/O buffer.
     The objects read are stores starting at the address '*start'
     The objects in the array are assume to be of class 'cl' or a derived class.
     'mode' indicates whether the data member is marked with '->'

void WriteArray(const Bool_t *b, Int_t n)

     Write array of n bools into the I/O buffer.

void WriteArray(const Char_t *c, Int_t n)

     Write array of n characters into the I/O buffer.

void WriteArray(const Short_t *h, Int_t n)

     Write array of n shorts into the I/O buffer.

void WriteArray(const Int_t *ii, Int_t n)

     Write array of n ints into the I/O buffer.

void WriteArray(const Long_t *ll, Int_t n)

     Write array of n longs into the I/O buffer.

void WriteArray(const ULong_t *ll, Int_t n)

     Write array of n unsigned longs into the I/O buffer.
     This is an explicit case for unsigned longs since signed longs
     have a special tobuf().

void WriteArray(const Long64_t *ll, Int_t n)

     Write array of n long longs into the I/O buffer.

void WriteArray(const Float_t *f, Int_t n)

     Write array of n floats into the I/O buffer.

void WriteArray(const Double_t *d, Int_t n)

     Write array of n doubles into the I/O buffer.

void WriteArrayDouble32(const Double_t *d, Int_t n, TStreamerElement *ele)

     Write array of n doubles (as float) into the I/O buffer.
     see comments about Double32_t encoding at TBuffer::WriteDouble32

void WriteFastArray(const Bool_t *b, Int_t n)

     Write array of n bools into the I/O buffer.

void WriteFastArray(const Char_t *c, Int_t n)

     Write array of n characters into the I/O buffer.

void WriteFastArray(const Short_t *h, Int_t n)

     Write array of n shorts into the I/O buffer.

void WriteFastArray(const Int_t *ii, Int_t n)

     Write array of n ints into the I/O buffer.

void WriteFastArray(const Long_t *ll, Int_t n)

     Write array of n longs into the I/O buffer.

void WriteFastArray(const ULong_t *ll, Int_t n)

     Write array of n unsigned longs into the I/O buffer.
     This is an explicit case for unsigned longs since signed longs
     have a special tobuf().

void WriteFastArray(const Long64_t *ll, Int_t n)

     Write array of n long longs into the I/O buffer.

void WriteFastArray(const Float_t *f, Int_t n)

     Write array of n floats into the I/O buffer.

void WriteFastArray(const Double_t *d, Int_t n)

     Write array of n doubles into the I/O buffer.

void WriteFastArrayDouble32(const Double_t *d, Int_t n, TStreamerElement *ele)

     Write array of n doubles (as float) into the I/O buffer.
     see comments about Double32_t encoding at TBuffer::WriteDouble32

void WriteFastArray(void *start, const TClass *cl, Int_t n, TMemberStreamer *streamer)

     Write an array of object starting at the address 'start' and of length 'n'
     the objects in the array are assumed to be of class 'cl'

Int_t WriteFastArray(void **start, const TClass *cl, Int_t n, Bool_t isPreAlloc, TMemberStreamer *streamer)

     Write an array of object starting at the address '*start' and of length 'n'
     the objects in the array are of class 'cl'
     'isPreAlloc' indicates whether the data member is marked with '->'
     Return:
      0: success
      2: truncated success (i.e actual class is missing. Only ptrClass saved.)

TObject* ReadObject(const TClass * /*clReq*/)

     Read object from I/O buffer. clReq is NOT used.
     The value returned is the address of the actual start in memory of
     the object. Note that if the actual class of the object does not
     inherit first from TObject, the type of the pointer is NOT 'TObject*'.
     [More accurately, the class needs to start with the TObject part, for
     the pointer to be a real TOject*].
     We recommend using ReadObjectAny instead of ReadObject

void SkipObjectAny()

     Skip any kind of object from buffer

void* ReadObjectAny(const TClass *clCast)

     Read object from I/O buffer.
     A typical use for this function is:
        MyClass *ptr = (MyClass*)b.ReadObjectAny(MyClass::Class());
     I.e. clCast should point to a TClass object describing the class pointed
     to by your pointer.
     In case of multiple inheritance, the return value might not be the
     real beginning of the object in memory.  You will need to use a
     dynamic_cast later if you need to retrieve it.

void WriteObject(const TObject *obj)

     Write object to I/O buffer.

void WriteObject(const void *actualObjectStart, const TClass *actualClass)

     Write object to I/O buffer.
     This function assumes that the value of 'actualObjectStart' is the actual start of
     the object of class 'actualClass'

Int_t WriteObjectAny(const void *obj, const TClass *ptrClass)

     Write object to I/O buffer.
     This function assumes that the value in 'obj' is the value stored in
     a pointer to a "ptrClass". The actual type of the object pointed to
     can be any class derived from "ptrClass".
     Return:
      0: failure
      1: success
      2: truncated success (i.e actual class is missing. Only ptrClass saved.)

TClass* ReadClass(const TClass *clReq, UInt_t *objTag)

     Read class definition from I/O buffer. clReq can be used to cross check
     if the actually read object is of the requested class. objTag is
     set in case the object is a reference to an already read object.

void WriteClass(const TClass *cl)

     Write class description to I/O buffer.

Version_t ReadVersion(UInt_t *startpos, UInt_t *bcnt, const TClass *cl)

     Read class version from I/O buffer.

UInt_t WriteVersion(const TClass *cl, Bool_t useBcnt)

     Write class version to I/O buffer.

UInt_t WriteVersionMemberWise(const TClass *cl, Bool_t useBcnt)

     Write class version to I/O buffer after setting the kStreamedMemberWise
     bit in the version number.

void SetReadMode()

     Set buffer in read mode.

void SetWriteMode()

     Set buffer in write mode.

void StreamObject(void *obj, const type_info &typeinfo)

     Stream an object given its C++ typeinfo information.

void StreamObject(void *obj, const char *className)

     Stream an object given the name of its actual class.

void StreamObject(void *obj, const TClass *cl)

     Stream an object given a pointer to its actual class.

TClass* GetClass(const type_info &typeinfo)

     Forward to TROOT::GetClass

TClass* GetClass(const char *className)

     Forward to TROOT::GetClass

void SetGlobalReadParam(Int_t mapsize)

     Set the initial size of the map used to store object and class
     references during reading. The default size is kMapSize=503.
     Increasing the default has the benefit that when reading many
     small objects the array does not need to be resized too often
     (the system is always dynamic, even with the default everything
     will work, only the initial resizing will cost some time).
     Per TBuffer object this option can be changed using SetReadParam().

void SetGlobalWriteParam(Int_t mapsize)

     Set the initial size of the hashtable used to store object and class
     references during writing. The default size is kMapSize=503.
     Increasing the default has the benefit that when writing many
     small objects the hashtable does not get too many collisions
     (the system is always dynamic, even with the default everything
     will work, only a large number of collisions will cost performance).
     For optimal performance hashsize should always be a prime.
     Per TBuffer object this option can be changed using SetWriteParam().

Int_t GetGlobalReadParam()

     Get default read map size.

Int_t GetGlobalWriteParam()

     Get default write map size.

### Inline Functions

                      void operator=(const TBuffer&)
                     Int_t Read(const char* name)
                     Int_t Write(const char* name, Int_t opt, Int_t bufs)
                     Int_t Write(const char* name, Int_t opt, Int_t bufs) const
                   TBuffer TBuffer(TBuffer::EMode mode, Int_t bufsiz)
                   TBuffer TBuffer(TBuffer::EMode mode, Int_t bufsiz, void* buf, Bool_t adopt = kTRUE)
                     Int_t GetMapCount() const
                     Int_t GetBufferVersion() const
                      void Reset()
                      void SetBufferOffset(Int_t offset = 0)
                     char* Buffer() const
                     Int_t BufferSize() const
                      void DetachBuffer()
                     Int_t Length() const
                      void SetStreamerElementNumber(Int_t)
            TStreamerInfo* GetInfo()
                    Bool_t IsReading() const
                    Bool_t IsWriting() const
                      void SetBufferDisplacement(Int_t skipped)
                      void SetBufferDisplacement()
                     Int_t GetBufferDisplacement() const
                     Int_t ReadArray(ULong_t*& l)
                     Int_t ReadArray(Long64_t*& l)
                     Int_t ReadArray(ULong64_t*& l)
                     Int_t ReadArray(Float_t*& f)
                     Int_t ReadArray(Double_t*& d)
                     Int_t ReadStaticArray(ULong_t* l)
                     Int_t ReadStaticArray(Long64_t* l)
                     Int_t ReadStaticArray(ULong64_t* l)
                     Int_t ReadStaticArray(Float_t* f)
                     Int_t ReadStaticArray(Double_t* d)
                      void ReadFastArray(ULong64_t* l, Int_t n)
                      void ReadFastArray(Float_t* f, Int_t n)
                      void ReadFastArray(Double_t* d, Int_t n)
                      void ReadFastArray(void* start, const TClass* cl, Int_t n = 1, TMemberStreamer* s = 0)
                      void ReadFastArray(void** startp, const TClass* cl, Int_t n = 1, Bool_t isPreAlloc = kFALSE, TMemberStreamer* s = 0)
                      void WriteArray(const Long64_t* l, Int_t n)
                      void WriteArray(const ULong64_t* l, Int_t n)
                      void WriteArray(const Float_t* f, Int_t n)
                      void WriteArray(const Double_t* d, Int_t n)
                      void WriteFastArray(const Float_t* f, Int_t n)
                      void WriteFastArray(const Double_t* d, Int_t n)
                      void WriteFastArray(void* start, const TClass* cl, Int_t n = 1, TMemberStreamer* s = 0)
                     Int_t WriteFastArray(void** startp, const TClass* cl, Int_t n = 1, Bool_t isPreAlloc = kFALSE, TMemberStreamer* s = 0)
                  TBuffer& operator>>(Bool_t& b)
                  TBuffer& operator>>(Char_t& c)
                  TBuffer& operator>>(UChar_t& c)
                  TBuffer& operator>>(Short_t& h)
                  TBuffer& operator>>(UShort_t& h)
                  TBuffer& operator>>(Int_t& i)
                  TBuffer& operator>>(UInt_t& i)
                  TBuffer& operator>>(Long_t& l)
                  TBuffer& operator>>(ULong_t& l)
                  TBuffer& operator>>(Long64_t& l)
                  TBuffer& operator>>(ULong64_t& l)
                  TBuffer& operator>>(Float_t& f)
                  TBuffer& operator>>(Double_t& d)
                  TBuffer& operator>>(Char_t* c)
                  TBuffer& operator<<(Bool_t b)
                  TBuffer& operator<<(Char_t c)
                  TBuffer& operator<<(UChar_t c)
                  TBuffer& operator<<(Short_t h)
                  TBuffer& operator<<(UShort_t h)
                  TBuffer& operator<<(Int_t i)
                  TBuffer& operator<<(UInt_t i)
                  TBuffer& operator<<(Long_t l)
                  TBuffer& operator<<(ULong_t l)
                  TBuffer& operator<<(Long64_t l)
                  TBuffer& operator<<(ULong64_t l)
                  TBuffer& operator<<(Float_t f)
                  TBuffer& operator<<(Double_t d)
                  TBuffer& operator<<(const Char_t* c)
                   TClass* Class()
                   TClass* IsA() const
                      void ShowMembers(TMemberInspector& insp, char* parent)
                      void Streamer(TBuffer& b)
                      void StreamerNVirtual(TBuffer& b)

Author: Fons Rademakers 04/05/96
Last update: root/base:$Name: $:$Id: TBuffer.cxx,v 1.81 2005/04/20 07:17:28 brun Exp $
Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *