TBuffer

class TBuffer : public TObject

    protected:

            TBuffer TBuffer()
            TBuffer TBuffer(const TBuffer&)
               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)

    public:

              TBuffer TBuffer(TBuffer::EMode mode, Int_t bufsiz = kInitialSize, void* buf = 0)
         virtual void ~TBuffer()
                char* Buffer() const
                Int_t BufferSize() const
                Int_t CheckByteCount(UInt_t startpos, UInt_t bcnt, const TClass* clss)
       static TClass* Class()
                 void DetachBuffer()
                Int_t GetBufferDisplacement()
         static Int_t GetGlobalReadParam()
         static Int_t GetGlobalWriteParam()
                 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)
             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<<(Float_t f)
             TBuffer& operator<<(Double_t d)
             TBuffer& operator<<(const Char_t* c)
             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>>(Float_t& f)
             TBuffer& operator>>(Double_t& d)
             TBuffer& operator>>(Char_t* c)
                Int_t ReadArray(Char_t*& c)
                Int_t ReadArray(UChar_t*& c)
                Int_t ReadArray(Short_t*& h)
                Int_t ReadArray(UShort_t*& h)
                Int_t ReadArray(Int_t*& i)
                Int_t ReadArray(UInt_t*& i)
                Int_t ReadArray(Long_t*& l)
                Int_t ReadArray(ULong_t*& l)
                Int_t ReadArray(Float_t*& f)
                Int_t ReadArray(Double_t*& d)
                Int_t ReadBuf(void* buf, Int_t max)
              TClass* ReadClass(const TClass* cl = 0, UInt_t* objTag = 0)
                 void ReadFastArray(Char_t* c, Int_t n)
                 void ReadFastArray(UChar_t* c, Int_t n)
                 void ReadFastArray(Short_t* h, Int_t n)
                 void ReadFastArray(UShort_t* h, Int_t n)
                 void ReadFastArray(Int_t* i, Int_t n)
                 void ReadFastArray(UInt_t* i, Int_t n)
                 void ReadFastArray(Long_t* l, Int_t n)
                 void ReadFastArray(ULong_t* l, Int_t n)
                 void ReadFastArray(Float_t* f, Int_t n)
                 void ReadFastArray(Double_t* d, Int_t n)
             TObject* ReadObject(const TClass* cl)
                Int_t ReadStaticArray(Char_t* c)
                Int_t ReadStaticArray(UChar_t* c)
                Int_t ReadStaticArray(Short_t* h)
                Int_t ReadStaticArray(UShort_t* h)
                Int_t ReadStaticArray(Int_t* i)
                Int_t ReadStaticArray(UInt_t* i)
                Int_t ReadStaticArray(Long_t* l)
                Int_t ReadStaticArray(ULong_t* l)
                Int_t ReadStaticArray(Float_t* f)
                Int_t ReadStaticArray(Double_t* d)
                char* ReadString(char* s, Int_t max)
            Version_t ReadVersion(UInt_t* start = 0, UInt_t* bcnt = 0)
         virtual void Reset()
                 void ResetMap()
                 void SetBuffer(void* buf, UInt_t bufsiz = 0)
                 void SetBufferDisplacement(Int_t skipped)
                 void SetBufferDisplacement()
                 void SetBufferOffset(Int_t offset = 0)
                 void SetByteCount(UInt_t cntpos, Bool_t packInVersion = kFALSE)
          static void SetGlobalReadParam(Int_t mapsize)
          static void SetGlobalWriteParam(Int_t mapsize)
                 void SetReadMode()
                 void SetReadParam(Int_t mapsize)
                 void SetWriteMode()
                 void SetWriteParam(Int_t mapsize)
         virtual void ShowMembers(TMemberInspector& insp, char* parent)
         virtual void Streamer(TBuffer& b)
                 void StreamerNVirtual(TBuffer& b)
                 void WriteArray(const Char_t* c, Int_t n)
                 void WriteArray(const UChar_t* c, Int_t n)
                 void WriteArray(const Short_t* h, Int_t n)
                 void WriteArray(const UShort_t* h, Int_t n)
                 void WriteArray(const Int_t* i, Int_t n)
                 void WriteArray(const UInt_t* i, Int_t n)
                 void WriteArray(const Long_t* l, Int_t n)
                 void WriteArray(const ULong_t* l, Int_t n)
                 void WriteArray(const Float_t* f, Int_t n)
                 void WriteArray(const Double_t* d, Int_t n)
                 void WriteBuf(const void* buf, Int_t max)
                 void WriteClass(const TClass* cl)
                 void WriteFastArray(const Char_t* c, Int_t n)
                 void WriteFastArray(const UChar_t* c, Int_t n)
                 void WriteFastArray(const Short_t* h, Int_t n)
                 void WriteFastArray(const UShort_t* h, Int_t n)
                 void WriteFastArray(const Int_t* i, Int_t n)
                 void WriteFastArray(const UInt_t* i, Int_t n)
                 void WriteFastArray(const Long_t* l, Int_t n)
                 void WriteFastArray(const ULong_t* l, Int_t n)
                 void WriteFastArray(const Float_t* f, Int_t n)
                 void WriteFastArray(const Double_t* d, Int_t n)
                 void WriteObject(const TObject* obj)
                 void WriteString(const char* s)
               UInt_t WriteVersion(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* fReadMap       Map containing id,object references during reading
           TExMap* fWriteMap      Map containing object,id pairs during writing
      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 TObject:: kInitialSize  
      static const enum TObject:: kMinimalSize  
      static const enum TObject:: kMapSize      

See also

TMessage

Class Description

                                                                      
 TBuffer                                                              
                                                                      
 Buffer base class used for serializing objects.                      
                                                                      

 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.

 Delete an I/O buffer object.

 Set buffer address

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

 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.

 Expand the I/O buffer to newsize bytes.

 Add object to the fWriteMap or fReadMap containers (depending on the mode).
 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).

 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().

 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().

 Create the fWriteMap or fReadMap containers and initialize them
 with the null object.

 Delete existing fWriteMap or fReadMap and reset map counter.

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

 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).

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

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

 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.

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

 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.

 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.

 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.

 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.

 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.

 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.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

 Read object from I/O buffer. clReq can be used to cross check
 if the actually read object is of the requested class.

 Write object to I/O buffer.

 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.

 Write class description to I/O buffer.

 Read class version from I/O buffer.

 Write class version to I/O buffer.

 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().

 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().

 Get default read map size.

 Get default write map size.

 Set buffer in read mode.

 Set buffer in write mode.

Inline Functions

            TBuffer TBuffer(const TBuffer&)
               void operator=(const TBuffer&)
              Int_t Read(const char* name)
              Int_t Write(const char* name, Int_t opt, Int_t bufs)
            TBuffer TBuffer(TBuffer::EMode mode, Int_t bufsiz = kInitialSize, void* buf = 0)
               void Reset()
               void SetBufferOffset(Int_t offset = 0)
              char* Buffer() const
              Int_t BufferSize() const
               void DetachBuffer()
              Int_t Length() const
             Bool_t IsReading() const
             Bool_t IsWriting() const
               void SetBufferDisplacement(Int_t skipped)
               void SetBufferDisplacement()
              Int_t GetBufferDisplacement()
              Int_t ReadArray(Long_t*& l)
              Int_t ReadArray(ULong_t*& l)
              Int_t ReadArray(Float_t*& f)
              Int_t ReadArray(Double_t*& d)
              Int_t ReadStaticArray(Long_t* l)
              Int_t ReadStaticArray(ULong_t* l)
              Int_t ReadStaticArray(Float_t* f)
              Int_t ReadStaticArray(Double_t* d)
               void WriteArray(const Long_t* l, Int_t n)
               void WriteArray(const ULong_t* l, Int_t n)
               void WriteArray(const Float_t* f, Int_t n)
               void WriteArray(const Double_t* d, Int_t n)
               void ReadFastArray(Long_t* l, Int_t n)
               void ReadFastArray(ULong_t* l, Int_t n)
               void ReadFastArray(Float_t* f, Int_t n)
               void ReadFastArray(Double_t* d, Int_t n)
               void WriteFastArray(const Long_t* l, Int_t n)
               void WriteFastArray(const ULong_t* l, Int_t n)
               void WriteFastArray(const Float_t* f, Int_t n)
               void WriteFastArray(const Double_t* d, Int_t n)
           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>>(Float_t& f)
           TBuffer& operator>>(Double_t& d)
           TBuffer& operator>>(Char_t* c)
           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<<(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)