ROOT logo
ROOT » IO » IO » TBufferFile

class TBufferFile: public TBuffer


TBufferFile

The concrete implementation of TBuffer for writing/reading to/from a
ROOT file or socket.


Function Members (Methods)

public:
TBufferFile(TBuffer::EMode mode)
TBufferFile(TBuffer::EMode mode, Int_t bufsiz)
TBufferFile(TBuffer::EMode mode, Int_t bufsiz, void* buf, Bool_t adopt = kTRUE, ReAllocCharFun_t reallocfunc = 0)
virtual~TBufferFile()
voidTObject::AbstractMethod(const char* method) const
virtual voidTObject::AppendPad(Option_t* option = "")
virtual Int_tApplySequence(const TStreamerInfoActions::TActionSequence& sequence, void* object)
virtual Int_tApplySequence(const TStreamerInfoActions::TActionSequence& sequence, void* start_collection, void* end_collection)
virtual Int_tApplySequenceVecPtr(const TStreamerInfoActions::TActionSequence& sequence, void* start_collection, void* end_collection)
voidTBuffer::AutoExpand(Int_t size_needed)
virtual voidTObject::Browse(TBrowser* b)
char*TBuffer::Buffer() const
Int_tTBuffer::BufferSize() const
virtual Int_tCheckByteCount(UInt_t startpos, UInt_t bcnt, const TClass* clss)
virtual Int_tCheckByteCount(UInt_t startpos, UInt_t bcnt, const char* classname)
virtual Bool_tCheckObject(const TObject* obj)
virtual Bool_tCheckObject(const void* obj, const TClass* ptrClass)
static TClass*Class()
virtual voidClassBegin(const TClass*, Version_t = -1)
virtual voidClassEnd(const TClass*)
virtual voidClassMember(const char*, const char* = 0, Int_t = -1, Int_t = -1)
virtual const char*TObject::ClassName() const
virtual voidTObject::Clear(Option_t* = "")
virtual TObject*TObject::Clone(const char* newname = "") const
virtual Int_tTObject::Compare(const TObject* obj) const
virtual voidTObject::Copy(TObject& object) const
virtual voidDecrementLevel(TVirtualStreamerInfo*)
virtual voidTObject::Delete(Option_t* option = "")MENU
voidTBuffer::DetachBuffer()
virtual Int_tTObject::DistancetoPrimitive(Int_t px, Int_t py)
virtual voidTObject::Draw(Option_t* option = "")
virtual voidTObject::DrawClass() constMENU
virtual TObject*TObject::DrawClone(Option_t* option = "") constMENU
virtual voidTObject::Dump() constMENU
virtual voidTObject::Error(const char* method, const char* msgfmt) const
virtual voidTObject::Execute(const char* method, const char* params, Int_t* error = 0)
virtual voidTObject::Execute(TMethod* method, TObjArray* params, Int_t* error = 0)
virtual voidTObject::ExecuteEvent(Int_t event, Int_t px, Int_t py)
voidTBuffer::Expand(Int_t newsize, Bool_t copy = kTRUE)
virtual voidTObject::Fatal(const char* method, const char* msgfmt) const
virtual TObject*TObject::FindObject(const char* name) const
virtual TObject*TObject::FindObject(const TObject* obj) const
virtual voidForceWriteInfo(TVirtualStreamerInfo* info, Bool_t force)
virtual voidForceWriteInfoClones(TClonesArray* a)
virtual Int_tGetBufferDisplacement() const
Int_tTBuffer::GetBufferVersion() const
static TClass*TBuffer::GetClass(const type_info& typeinfo)
static TClass*TBuffer::GetClass(const char* className)
virtual Option_t*TObject::GetDrawOption() const
static Long_tTObject::GetDtorOnly()
static Int_tGetGlobalReadParam()
static Int_tGetGlobalWriteParam()
virtual const char*TObject::GetIconName() const
virtual TVirtualStreamerInfo*GetInfo()
virtual TProcessID*GetLastProcessID(TRefTable* reftable) const
virtual Int_tGetMapCount() const
virtual voidGetMappedObject(UInt_t tag, void*& ptr, TClass*& ClassPtr) const
virtual const char*TObject::GetName() const
virtual char*TObject::GetObjectInfo(Int_t px, Int_t py) const
static Bool_tTObject::GetObjectStat()
virtual Option_t*TObject::GetOption() const
TObject*TBuffer::GetParent() const
virtual UShort_tGetPidOffset() const
ReAllocCharFun_tTBuffer::GetReAllocFunc() const
virtual const char*TObject::GetTitle() const
virtual UInt_tGetTRefExecId()
virtual UInt_tTObject::GetUniqueID() const
virtual Int_tGetVersionOwner() const
virtual Bool_tTObject::HandleTimer(TTimer* timer)
virtual ULong_tTObject::Hash() const
virtual voidIncrementLevel(TVirtualStreamerInfo* info)
virtual voidTObject::Info(const char* method, const char* msgfmt) const
virtual Bool_tTObject::InheritsFrom(const char* classname) const
virtual Bool_tTObject::InheritsFrom(const TClass* cl) const
virtual voidInitMap()
virtual voidTObject::Inspect() constMENU
voidTObject::InvertBit(UInt_t f)
virtual TClass*IsA() const
virtual Bool_tTObject::IsEqual(const TObject* obj) const
virtual Bool_tTObject::IsFolder() const
Bool_tTObject::IsOnHeap() const
Bool_tTBuffer::IsReading() const
virtual Bool_tTObject::IsSortable() const
Bool_tTBuffer::IsWriting() const
Bool_tTObject::IsZombie() const
Int_tTBuffer::Length() const
virtual voidTObject::ls(Option_t* option = "") const
virtual voidMapObject(const TObject* obj, UInt_t offset = 1)
virtual voidMapObject(const void* obj, const TClass* cl, UInt_t offset = 1)
voidTObject::MayNotUse(const char* method) const
virtual Bool_tTObject::Notify()
voidTObject::Obsolete(const char* method, const char* asOfVers, const char* removedFromVers) const
static voidTObject::operator delete(void* ptr)
static voidTObject::operator delete(void* ptr, void* vp)
static voidTObject::operator delete[](void* ptr)
static voidTObject::operator delete[](void* ptr, void* vp)
void*TObject::operator new(size_t sz)
void*TObject::operator new(size_t sz, void* vp)
void*TObject::operator new[](size_t sz)
void*TObject::operator new[](size_t sz, void* vp)
virtual voidTObject::Paint(Option_t* option = "")
virtual TVirtualArray*TBuffer::PeekDataCache() const
virtual voidTObject::Pop()
virtual TVirtualArray*TBuffer::PopDataCache()
virtual voidTObject::Print(Option_t* option = "") const
virtual voidTBuffer::PushDataCache(TVirtualArray*)
virtual Int_tReadArray(Bool_t*& b)
virtual Int_tReadArray(Char_t*& c)
virtual Int_tReadArray(UChar_t*& c)
virtual Int_tReadArray(Short_t*& h)
virtual Int_tReadArray(UShort_t*& h)
virtual Int_tReadArray(Int_t*& i)
virtual Int_tReadArray(UInt_t*& i)
virtual Int_tReadArray(Long_t*& l)
virtual Int_tReadArray(ULong_t*& l)
virtual Int_tReadArray(Long64_t*& l)
virtual Int_tReadArray(ULong64_t*& ll)
virtual Int_tReadArray(Float_t*& f)
virtual Int_tReadArray(Double_t*& d)
virtual Int_tReadArrayDouble32(Double_t*& d, TStreamerElement* ele = 0)
virtual Int_tReadArrayFloat16(Float_t*& f, TStreamerElement* ele = 0)
virtual voidReadBool(Bool_t& b)
virtual Int_tReadBuf(void* buf, Int_t max)
virtual voidReadChar(Char_t& c)
virtual voidReadCharP(Char_t* c)
virtual TClass*ReadClass(const TClass* cl = 0, UInt_t* objTag = 0)
virtual Int_tReadClassBuffer(const TClass* cl, void* pointer, const TClass* onfile_class)
virtual Int_tReadClassBuffer(const TClass* cl, void* pointer, Int_t version, UInt_t start, UInt_t count, const TClass* onfile_class)
virtual Int_tReadClassEmulated(const TClass* cl, void* object, const TClass* onfile_class)
virtual Int_tReadClones(TClonesArray* a, Int_t nobjects, Version_t objvers)
virtual voidReadDouble(Double_t& d)
virtual voidReadDouble32(Double_t* d, TStreamerElement* ele = 0)
virtual voidReadFastArray(Bool_t* b, Int_t n)
virtual voidReadFastArray(Char_t* c, Int_t n)
virtual voidReadFastArray(UChar_t* c, Int_t n)
virtual voidReadFastArray(Short_t* h, Int_t n)
virtual voidReadFastArray(UShort_t* h, Int_t n)
virtual voidReadFastArray(Int_t* i, Int_t n)
virtual voidReadFastArray(UInt_t* i, Int_t n)
virtual voidReadFastArray(Long_t* l, Int_t n)
virtual voidReadFastArray(ULong_t* l, Int_t n)
virtual voidReadFastArray(Long64_t* l, Int_t n)
virtual voidReadFastArray(ULong64_t* ll, Int_t n)
virtual voidReadFastArray(Float_t* f, Int_t n)
virtual voidReadFastArray(Double_t* d, Int_t n)
virtual voidReadFastArray(void* start, const TClass* cl, Int_t n = 1, TMemberStreamer* s = 0, const TClass* onFileClass = 0)
virtual voidReadFastArray(void** startp, const TClass* cl, Int_t n = 1, Bool_t isPreAlloc = kFALSE, TMemberStreamer* s = 0, const TClass* onFileClass = 0)
virtual voidReadFastArrayDouble32(Double_t* d, Int_t n, TStreamerElement* ele = 0)
virtual voidReadFastArrayFloat16(Float_t* f, Int_t n, TStreamerElement* ele = 0)
virtual voidReadFastArrayString(Char_t* c, Int_t n)
virtual voidReadFloat(Float_t& f)
virtual voidReadFloat16(Float_t* f, TStreamerElement* ele = 0)
virtual voidReadInt(Int_t& i)
virtual voidReadLong(Long_t& l)
virtual voidReadLong64(Long64_t& ll)
virtual TObject*ReadObject(const TClass* cl)
virtual void*ReadObjectAny(const TClass* cast)
virtual TProcessID*ReadProcessID(UShort_t pidf)
virtual voidReadShort(Short_t& h)
virtual Int_tReadStaticArray(Bool_t* b)
virtual Int_tReadStaticArray(Char_t* c)
virtual Int_tReadStaticArray(UChar_t* c)
virtual Int_tReadStaticArray(Short_t* h)
virtual Int_tReadStaticArray(UShort_t* h)
virtual Int_tReadStaticArray(Int_t* i)
virtual Int_tReadStaticArray(UInt_t* i)
virtual Int_tReadStaticArray(Long_t* l)
virtual Int_tReadStaticArray(ULong_t* l)
virtual Int_tReadStaticArray(Long64_t* l)
virtual Int_tReadStaticArray(ULong64_t* ll)
virtual Int_tReadStaticArray(Float_t* f)
virtual Int_tReadStaticArray(Double_t* d)
virtual Int_tReadStaticArrayDouble32(Double_t* d, TStreamerElement* ele = 0)
virtual Int_tReadStaticArrayFloat16(Float_t* f, TStreamerElement* ele = 0)
virtual char*ReadString(char* s, Int_t max)
virtual voidReadTString(TString& s)
virtual voidReadUChar(UChar_t& c)
virtual voidReadUInt(UInt_t& i)
virtual voidReadULong(ULong_t& ll)
virtual voidReadULong64(ULong64_t& ll)
virtual voidReadUShort(UShort_t& h)
virtual Version_tReadVersion(UInt_t* start = 0, UInt_t* bcnt = 0, const TClass* cl = 0)
virtual Version_tReadVersionForMemberWise(const TClass* cl = 0)
virtual voidReadWithFactor(Float_t* ptr, Double_t factor, Double_t minvalue)
virtual voidReadWithFactor(Double_t* ptr, Double_t factor, Double_t minvalue)
virtual voidReadWithNbits(Float_t* ptr, Int_t nbits)
virtual voidReadWithNbits(Double_t* ptr, Int_t nbits)
virtual voidTObject::RecursiveRemove(TObject* obj)
virtual voidReset()
voidTObject::ResetBit(UInt_t f)
virtual voidResetMap()
virtual voidTObject::SaveAs(const char* filename = "", Option_t* option = "") constMENU
virtual voidTObject::SavePrimitive(ostream& out, Option_t* option = "")
voidTObject::SetBit(UInt_t f)
voidTObject::SetBit(UInt_t f, Bool_t set)
voidTBuffer::SetBuffer(void* buf, UInt_t bufsiz = 0, Bool_t adopt = kTRUE, ReAllocCharFun_t reallocfunc = 0)
virtual voidSetBufferDisplacement()
virtual voidSetBufferDisplacement(Int_t skipped)
voidTBuffer::SetBufferOffset(Int_t offset = 0)
virtual voidSetByteCount(UInt_t cntpos, Bool_t packInVersion = kFALSE)
virtual voidTObject::SetDrawOption(Option_t* option = "")MENU
static voidTObject::SetDtorOnly(void* obj)
static voidSetGlobalReadParam(Int_t mapsize)
static voidSetGlobalWriteParam(Int_t mapsize)
static voidTObject::SetObjectStat(Bool_t stat)
voidTBuffer::SetParent(TObject* parent)
virtual voidSetPidOffset(UShort_t offset)
voidTBuffer::SetReadMode()
virtual voidSetReadParam(Int_t mapsize)
voidTBuffer::SetReAllocFunc(ReAllocCharFun_t reallocfunc = 0)
virtual voidSetStreamerElementNumber(Int_t)
virtual voidTObject::SetUniqueID(UInt_t uid)
voidTBuffer::SetWriteMode()
virtual voidSetWriteParam(Int_t mapsize)
virtual voidShowMembers(TMemberInspector& insp)
virtual voidSkipObjectAny()
virtual voidSkipVersion(const TClass* cl = 0)
virtual voidStreamer(TBuffer& b)
voidStreamerNVirtual(TBuffer& b)
virtual voidStreamObject(TObject* obj)
virtual voidStreamObject(void* obj, const type_info& typeinfo, const TClass* onFileClass = 0)
virtual voidStreamObject(void* obj, const char* className, const TClass* onFileClass = 0)
virtual voidStreamObject(void* obj, const TClass* cl, const TClass* onFileClass = 0)
virtual voidTObject::SysError(const char* method, const char* msgfmt) const
virtual voidTagStreamerInfo(TVirtualStreamerInfo* info)
Bool_tTObject::TestBit(UInt_t f) const
Int_tTObject::TestBits(UInt_t f) const
virtual voidTObject::UseCurrentStyle()
virtual voidTObject::Warning(const char* method, const char* msgfmt) const
virtual voidWriteArray(const Bool_t* b, Int_t n)
virtual voidWriteArray(const Char_t* c, Int_t n)
virtual voidWriteArray(const UChar_t* c, Int_t n)
virtual voidWriteArray(const Short_t* h, Int_t n)
virtual voidWriteArray(const UShort_t* h, Int_t n)
virtual voidWriteArray(const Int_t* i, Int_t n)
virtual voidWriteArray(const UInt_t* i, Int_t n)
virtual voidWriteArray(const Long_t* l, Int_t n)
virtual voidWriteArray(const ULong_t* l, Int_t n)
virtual voidWriteArray(const Long64_t* l, Int_t n)
virtual voidWriteArray(const ULong64_t* ll, Int_t n)
virtual voidWriteArray(const Float_t* f, Int_t n)
virtual voidWriteArray(const Double_t* d, Int_t n)
virtual voidWriteArrayDouble32(const Double_t* d, Int_t n, TStreamerElement* ele = 0)
virtual voidWriteArrayFloat16(const Float_t* f, Int_t n, TStreamerElement* ele = 0)
virtual voidWriteBool(Bool_t b)
virtual voidWriteBuf(const void* buf, Int_t max)
virtual voidWriteChar(Char_t c)
virtual voidWriteCharP(const Char_t* c)
virtual voidWriteClass(const TClass* cl)
virtual Int_tWriteClassBuffer(const TClass* cl, void* pointer)
virtual Int_tWriteClones(TClonesArray* a, Int_t nobjects)
virtual voidWriteDouble(Double_t d)
virtual voidWriteDouble32(Double_t* d, TStreamerElement* ele = 0)
virtual voidWriteFastArray(const Bool_t* b, Int_t n)
virtual voidWriteFastArray(const Char_t* c, Int_t n)
virtual voidWriteFastArray(const UChar_t* c, Int_t n)
virtual voidWriteFastArray(const Short_t* h, Int_t n)
virtual voidWriteFastArray(const UShort_t* h, Int_t n)
virtual voidWriteFastArray(const Int_t* i, Int_t n)
virtual voidWriteFastArray(const UInt_t* i, Int_t n)
virtual voidWriteFastArray(const Long_t* l, Int_t n)
virtual voidWriteFastArray(const ULong_t* l, Int_t n)
virtual voidWriteFastArray(const Long64_t* l, Int_t n)
virtual voidWriteFastArray(const ULong64_t* ll, Int_t n)
virtual voidWriteFastArray(const Float_t* f, Int_t n)
virtual voidWriteFastArray(const Double_t* d, Int_t n)
virtual voidWriteFastArray(void* start, const TClass* cl, Int_t n = 1, TMemberStreamer* s = 0)
virtual Int_tWriteFastArray(void** startp, const TClass* cl, Int_t n = 1, Bool_t isPreAlloc = kFALSE, TMemberStreamer* s = 0)
virtual voidWriteFastArrayDouble32(const Double_t* d, Int_t n, TStreamerElement* ele = 0)
virtual voidWriteFastArrayFloat16(const Float_t* f, Int_t n, TStreamerElement* ele = 0)
virtual voidWriteFastArrayString(const Char_t* c, Int_t n)
virtual voidWriteFloat(Float_t f)
virtual voidWriteFloat16(Float_t* f, TStreamerElement* ele = 0)
virtual voidWriteInt(Int_t i)
virtual voidWriteLong(Long_t l)
virtual voidWriteLong64(Long64_t ll)
virtual voidWriteObject(const TObject* obj)
virtual Int_tWriteObjectAny(const void* obj, const TClass* ptrClass)
virtual UShort_tWriteProcessID(TProcessID* pid)
virtual voidWriteShort(Short_t h)
virtual voidWriteString(const char* s)
virtual voidWriteTString(const TString& s)
virtual voidWriteUChar(UChar_t c)
virtual voidWriteUInt(UInt_t i)
virtual voidWriteULong(ULong_t l)
virtual voidWriteULong64(ULong64_t ll)
virtual voidWriteUShort(UShort_t h)
virtual UInt_tWriteVersion(const TClass* cl, Bool_t useBcnt = kFALSE)
virtual UInt_tWriteVersionMemberWise(const TClass* cl, Bool_t useBcnt = kFALSE)
protected:
TBufferFile()
TBufferFile(const TBufferFile&)
Int_tCheckByteCount(UInt_t startpos, UInt_t bcnt, const TClass* clss, const char* classname)
voidCheckCount(UInt_t offset)
UInt_tCheckObject(UInt_t offset, const TClass* cl, Bool_t readClass = kFALSE)
virtual voidTObject::DoError(int level, const char* location, const char* fmt, va_list va) const
voidTObject::MakeZombie()
voidoperator=(const TBufferFile&)
virtual Int_tTBuffer::Read(const char* name)
virtual Int_tTBuffer::Write(const char* name, Int_t opt, Int_t bufs)
virtual Int_tTBuffer::Write(const char* name, Int_t opt, Int_t bufs) const
virtual voidWriteObjectClass(const void* actualObjStart, const TClass* actualClass)

Data Members

public:
enum { kMapSize
kStreamedMemberWise
kNotDecompressed
kTextBasedStreaming
kUser1
kUser2
kUser3
};
enum TBuffer::EMode { kRead
kWrite
};
enum TBuffer::[unnamed] { kIsOwner
kCannotHandleMemberWiseStreaming
kInitialSize
kMinimalSize
};
enum TObject::EStatusBits { kCanDelete
kMustCleanup
kObjInCanvas
kIsReferenced
kHasUUID
kCannotPick
kNoContextMenu
kInvalidObject
};
enum TObject::[unnamed] { kIsOnHeap
kNotDeleted
kZombie
kBitMask
kSingleKey
kOverwrite
kWriteDelete
};
protected:
char*TBuffer::fBufCurCurrent position in buffer
char*TBuffer::fBufMaxEnd of buffer
Int_tTBuffer::fBufSizeSize of buffer
char*TBuffer::fBufferBuffer used to store objects
vector<TVirtualArray*>TBuffer::fCacheStackStack of pointers to the cache where to temporarily store the value of 'missing' data members
TExMap*fClassMapMap containing object,class pairs for reading
Int_tfDisplacementValue to be added to the map offsets
TStreamerInfo*fInfoPointer to TStreamerInfo object writing/reading the buffer
vector<TStreamerInfo*>fInfoStackStack of pointers to the TStreamerInfos
TExMap*fMapMap containing object,offset pairs for reading/writing
Int_tfMapCountNumber of objects or classes in map
Int_tfMapSizeDefault size of map
Bool_tTBuffer::fModeRead or write mode
TObject*TBuffer::fParentPointer to parent object owning this buffer
UShort_tfPidOffsetOffset to be added to the pid index in this key/buffer.
ReAllocCharFun_tTBuffer::fReAllocFunc! Realloc function to be used when extending the buffer.
Int_tTBuffer::fVersionBuffer format version
static Int_tfgMapSizeDefault map size for all TBuffer objects

Class Charts

Inheritance Inherited Members Includes Libraries
Class Charts

Function documentation

TBufferFile(TBuffer::EMode mode)
 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.
TBufferFile(TBuffer::EMode mode, Int_t bufsiz)
 Create an I/O buffer object. Mode should be either TBuffer::kRead or
 TBuffer::kWrite.
TBufferFile(TBuffer::EMode mode, Int_t bufsiz, void* buf, Bool_t adopt = kTRUE, ReAllocCharFun_t reallocfunc = 0)
 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.
 If the new buffer is _not_ adopted and no memory allocation routine
 is provided, a Fatal error will be issued if the Buffer attempts to
 expand.
~TBufferFile()
 Delete an I/O buffer object.
Int_t GetVersionOwner() const
 Return the version number of the owner file.
void TagStreamerInfo(TVirtualStreamerInfo* info)
 Mark the classindex of the current file as using this TStreamerInfo
void IncrementLevel(TVirtualStreamerInfo* info)
 Increment level.
void DecrementLevel(TVirtualStreamerInfo* )
 Decrement level.
void ReadLong(Long_t& l)
 Read Long from TBuffer.
void ReadTString(TString& s)
 Read string from TBuffer.
void WriteTString(const TString& s)
 Write string to TBuffer.
void SetByteCount(UInt_t cntpos, Bool_t packInVersion = kFALSE)
 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).
void ReadFloat16(Float_t* f, TStreamerElement* ele = 0)
 Read a Float16_t from the buffer,
 see comments about Float16_t encoding at TBufferFile::WriteFloat16().
void ReadDouble32(Double_t* d, TStreamerElement* ele = 0)
 Read a Double32_t from the buffer,
 see comments about Double32_t encoding at TBufferFile::WriteDouble32().
void ReadWithFactor(Float_t* ptr, Double_t factor, Double_t minvalue)
 Read a Double32_t from the buffer when the factor and minimun value have been specified
 see comments about Double32_t encoding at TBufferFile::WriteDouble32().
void ReadWithNbits(Float_t* ptr, Int_t nbits)
 Read a Float16_t from the buffer when the number of bits is specified (explicitly or not)
 see comments about Float16_t encoding at TBufferFile::WriteFloat16().
void ReadWithFactor(Double_t* ptr, Double_t factor, Double_t minvalue)
 Read a Double32_t from the buffer when the factor and minimun value have been specified
 see comments about Double32_t encoding at TBufferFile::WriteDouble32().
void ReadWithNbits(Double_t* ptr, Int_t nbits)
 Read a Double32_t from the buffer when the number of bits is specified (explicitly or not)
 see comments about Double32_t encoding at TBufferFile::WriteDouble32().
void WriteFloat16(Float_t* f, TStreamerElement* ele = 0)
 write a Float16_t to the buffer.
 The following cases are supported for streaming a Float16_t type
 depending on the range declaration in the comment field of the data member:
  A-    Float16_t     fNormal;
  B-    Float16_t     fTemperature; //[0,100]
  C-    Float16_t     fCharge;      //[-1,1,2]
  D-    Float16_t     fVertex[3];   //[-30,30,10]
  E-    Float16_t     fChi2;        //[0,0,6]
  F-    Int_t          fNsp;
        Float16_t*    fPointValue;   //[fNsp][0,3]

 In case A fNormal is converted from a Float_t to a Float_t with mantissa truncated to 12 bits
 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 fChi2 is converted to a Float_t with truncated precision at 6 bits
 In case F 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]
  [0,0,8]
 if nbits is not specified, or nbits <2 or nbits>16 it is set to 16
 if (xmin==0 and xmax==0 and nbits <=14) the float word will have
 its mantissa truncated to nbits significative bits.

 IMPORTANT NOTE

 --NOTE 1
 Lets assume an original variable float x:
 When using the format [0,0,8] (ie range not specified) you get the best
 relative precision when storing and reading back the truncated x, say xt.
 The variance of (x-xt)/x will be better than when specifying a range
 for the same number of bits. However the precision relative to the
 range (x-xt)/(xmax-xmin) will be worst, and vice-versa.
 The format [0,0,8] is also interesting when the range of x is infinite
 or unknown.

 --NOTE 2
 It is important to understand the difference with the meaning of nbits
  -in case of [-1,1,nbits], nbits is the total number of bits used to make
    the conversion from a float to an integer
  -in case of [0,0,nbits], nbits is the number of bits used for the mantissa

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


/* */
void WriteDouble32(Double_t* d, TStreamerElement* ele = 0)
 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-    Double32_t     fChi2;        //[0,0,6]
  F-    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 fChi2 is converted to a Float_t with mantissa truncated precision at 6 bits
 In case F 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]
  [0,0,8]
 if nbits is not specified, or nbits <2 or nbits>32 it is set to 32
 if (xmin==0 and xmax==0 and nbits <=14) the double word will be converted
 to a float and its mantissa truncated to nbits significative bits.

 IMPORTANT NOTEs

 --NOTE 1
 Lets assume an original variable double x:
 When using the format [0,0,8] (ie range not specified) you get the best
 relative precision when storing and reading back the truncated x, say xt.
 The variance of (x-xt)/x will be better than when specifying a range
 for the same number of bits. However the precision relative to the
 range (x-xt)/(xmax-xmin) will be worst, and vice-versa.
 The format [0,0,8] is also interesting when the range of x is infinite
 or unknown.

 --NOTE 2
 It is important to understand the difference with the meaning of nbits
  -in case of [-1,1,nbits], nbits is the total number of bits used to make
    the conversion from a double to an integer
  -in case of [0,0,nbits], nbits is the number of bits used for the mantissa

  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*& i)
 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*& l)
 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*& l)
 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 ReadArrayFloat16(Float_t*& f, TStreamerElement* ele = 0)
 Read array of floats (written as truncated float) 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.
 see comments about Float16_t encoding at TBufferFile::WriteFloat16
Int_t ReadArrayDouble32(Double_t*& d, TStreamerElement* ele = 0)
 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 TBufferFile::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* i)
 Read array of ints from the I/O buffer. Returns the number of ints
 read.
Int_t ReadStaticArray(Long_t* l)
 Read array of longs from the I/O buffer. Returns the number of longs
 read.
Int_t ReadStaticArray(Long64_t* l)
 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 ReadStaticArrayFloat16(Float_t* f, TStreamerElement* ele = 0)
 Read array of floats (written as truncated float) from the I/O buffer.
 Returns the number of floats read.
 see comments about Float16_t encoding at TBufferFile::WriteFloat16
Int_t ReadStaticArrayDouble32(Double_t* d, TStreamerElement* ele = 0)
 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 TBufferFile::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 ReadFastArrayString(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* i, Int_t n)
 Read array of n ints from the I/O buffer.
void ReadFastArray(Long_t* l, Int_t n)
 Read array of n longs from the I/O buffer.
void ReadFastArray(Long64_t* l, 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 ReadFastArrayFloat16(Float_t* f, Int_t n, TStreamerElement* ele = 0)
 Read array of n floats (written as truncated float) from the I/O buffer.
 see comments about Float16_t encoding at TBufferFile::WriteFloat16
void ReadFastArrayDouble32(Double_t* d, Int_t n, TStreamerElement* ele = 0)
 Read array of n doubles (written as float) from the I/O buffer.
 see comments about Double32_t encoding at TBufferFile::WriteDouble32
void ReadFastArray(void* start, const TClass* cl, Int_t n = 1, TMemberStreamer* s = 0, const TClass* onFileClass = 0)
 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** startp, const TClass* cl, Int_t n = 1, Bool_t isPreAlloc = kFALSE, TMemberStreamer* s = 0, const TClass* onFileClass = 0)
 Read an array of 'n' objects from the I/O buffer.
 The objects read are stored starting at the address '*start'
 The objects in the array are assumed 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* i, Int_t n)
 Write array of n ints into the I/O buffer.
void WriteArray(const Long_t* l, Int_t n)
 Write array of n longs into the I/O buffer.
void WriteArray(const ULong_t* l, 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* l, 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 WriteArrayFloat16(const Float_t* f, Int_t n, TStreamerElement* ele = 0)
 Write array of n floats (as truncated float) into the I/O buffer.
 see comments about Float16_t encoding at TBufferFile::WriteFloat16
void WriteArrayDouble32(const Double_t* d, Int_t n, TStreamerElement* ele = 0)
 Write array of n doubles (as float) into the I/O buffer.
 see comments about Double32_t encoding at TBufferFile::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 WriteFastArrayString(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* i, Int_t n)
 Write array of n ints into the I/O buffer.
void WriteFastArray(const Long_t* l, Int_t n)
 Write array of n longs into the I/O buffer.
void WriteFastArray(const ULong_t* l, 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* l, 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 WriteFastArrayFloat16(const Float_t* f, Int_t n, TStreamerElement* ele = 0)
 Write array of n floats (as truncated float) into the I/O buffer.
 see comments about Float16_t encoding at TBufferFile::WriteFloat16
void WriteFastArrayDouble32(const Double_t* d, Int_t n, TStreamerElement* ele = 0)
 Write array of n doubles (as float) into the I/O buffer.
 see comments about Double32_t encoding at TBufferFile::WriteDouble32
void WriteFastArray(void* start, const TClass* cl, Int_t n = 1, TMemberStreamer* s = 0)
 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** startp, const TClass* cl, Int_t n = 1, Bool_t isPreAlloc = kFALSE, TMemberStreamer* s = 0)
 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* cl)
 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 TObject*].
 We recommend using ReadObjectAny instead of ReadObject
void SkipObjectAny()
 Skip any kind of object from buffer
void * ReadObjectAny(const TClass* cast)
 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 WriteObjectClass(const void* actualObjStart, 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* cl = 0, UInt_t* objTag = 0)
 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.
void SkipVersion(const TClass* cl = 0)
 Skip class version from I/O buffer.
Version_t ReadVersion(UInt_t* start = 0, UInt_t* bcnt = 0, const TClass* cl = 0)
 Read class version from I/O buffer.
Version_t ReadVersionForMemberWise(const TClass* cl = 0)
 Read class version from I/O buffer ; to be used when streaming out
 memberwise streamed collection where we do not care (not save) about
 the byte count and can safely ignore missing streamerInfo (since they
 usually indicate empty collections).
UInt_t WriteVersion(const TClass* cl, Bool_t useBcnt = kFALSE)
 Write class version to I/O buffer.
UInt_t WriteVersionMemberWise(const TClass* cl, Bool_t useBcnt = kFALSE)
 Write class version to I/O buffer after setting the kStreamedMemberWise
 bit in the version number.
void StreamObject(void* obj, const type_info& typeinfo, const TClass* onFileClass = 0)
 Stream an object given its C++ typeinfo information.
void StreamObject(void* obj, const char* className, const TClass* onFileClass = 0)
 Stream an object given the name of its actual class.
void StreamObject(void* obj, const TClass* cl, const TClass* onFileClass = 0)
 Stream an object given a pointer to its actual class.
void StreamObject(TObject* obj)
 Stream an object inheriting from TObject using its streamer.
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 = kFALSE)
 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 ).
void SetPidOffset(UShort_t offset)
 This offset is used when a key (or basket) is transfered from one
 file to the other.  In this case the TRef and TObject might have stored a
 pid index (to retrieve TProcessIDs) which refered to their order on the original
 file, the fPidOffset is to be added to those values to correctly find the
 TProcessID.  This fPidOffset needs to be increment if the key/basket is copied
 and need to be zero for new key/basket.
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 = 1)
 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 = 1)
 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 ResetMap()
 Delete existing fMap and reset map counter.
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.
char * ReadString(char* 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 char* s)
 Write string to I/O buffer. Writes string upto and including the
 terminating 0.
TProcessID * GetLastProcessID(TRefTable* reftable) const
 Return the last TProcessID in the file.
TProcessID * ReadProcessID(UShort_t pidf)
 The TProcessID with number pidf is read from file.
 If the object is not already entered in the gROOT list, it is added.
UInt_t GetTRefExecId()
 Return the exec id stored in the current TStreamerInfo element.
 The execid has been saved in the unique id of the TStreamerElement
 being read by TStreamerElement::Streamer.
 The current element (fgElement) is set as a static global
 by TStreamerInfo::ReadBuffer (Clones) when reading this TRef.
UShort_t WriteProcessID(TProcessID* pid)
 Check if the ProcessID pid is already in the file.
 If not, add it and return the index number in the local file list.
void ForceWriteInfo(TVirtualStreamerInfo* info, Bool_t force)
 force writing the TStreamerInfo to the file
void ForceWriteInfoClones(TClonesArray* a)
 Make sure TStreamerInfo is not optimized, otherwise it will not be
 possible to support schema evolution in read mode.
 In case the StreamerInfo has already been computed and optimized,
 one must disable the option BypassStreamer.
Int_t ReadClones(TClonesArray* a, Int_t nobjects, Version_t objvers)
Int_t WriteClones(TClonesArray* a, Int_t nobjects)
Int_t ReadClassEmulated(const TClass* cl, void* object, const TClass* onfile_class)
 Read emulated class.
Int_t ReadClassBuffer(const TClass* cl, void* pointer, Int_t version, UInt_t start, UInt_t count, const TClass* onfile_class)
 Deserialize information from a buffer into an object.

 Note: This function is called by the xxx::Streamer()
       functions in rootcint-generated dictionaries.
   // This function assumes that the class version and the byte count
 information have been read.

   version  is the version number of the class
   start    is the starting position in the buffer b
   count    is the number of bytes for this object in the buffer

Int_t ReadClassBuffer(const TClass* cl, void* pointer, const TClass* onfile_class)
 Deserialize information from a buffer into an object.

 Note: This function is called by the xxx::Streamer()
       functions in rootcint-generated dictionaries.

Int_t WriteClassBuffer(const TClass* cl, void* pointer)
 Function called by the Streamer functions to serialize object at p
 to buffer b. The optional argument info may be specified to give an
 alternative StreamerInfo instead of using the default StreamerInfo
 automatically built from the class definition.
 For more information, see class TStreamerInfo.
Int_t ApplySequence(const TStreamerInfoActions::TActionSequence& sequence, void* object)
 Read one collection of objects from the buffer using the StreamerInfoLoopAction.
 The collection needs to be a split TClonesArray or a split vector of pointers.
Int_t ApplySequenceVecPtr(const TStreamerInfoActions::TActionSequence& sequence, void* start_collection, void* end_collection)
 Read one collection of objects from the buffer using the StreamerInfoLoopAction.
 The collection needs to be a split TClonesArray or a split vector of pointers.
Int_t ApplySequence(const TStreamerInfoActions::TActionSequence& sequence, void* start_collection, void* end_collection)
 Read one collection of objects from the buffer using the StreamerInfoLoopAction.
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.
void WriteBool(Bool_t b)
void WriteChar(Char_t c)
void WriteUChar(UChar_t c)
void WriteShort(Short_t h)
void WriteUShort(UShort_t h)
void WriteInt(Int_t i)
void WriteUInt(UInt_t i)
void WriteLong(Long_t l)
void WriteULong(ULong_t l)
void WriteLong64(Long64_t ll)
void WriteULong64(ULong64_t ll)
void WriteFloat(Float_t f)
void WriteDouble(Double_t d)
void WriteCharP(const Char_t* c)
void ReadBool(Bool_t& b)
void ReadChar(Char_t& c)
void ReadUChar(UChar_t& c)
void ReadShort(Short_t& h)
void ReadUShort(UShort_t& h)
void ReadInt(Int_t& i)
void ReadUInt(UInt_t& i)
void ReadULong(ULong_t& ll)
void ReadLong64(Long64_t& ll)
void ReadULong64(ULong64_t& ll)
void ReadFloat(Float_t& f)
void ReadDouble(Double_t& d)
void ReadCharP(Char_t* c)
Int_t ReadArray(UChar_t*& c)
{ return TBufferFile::ReadArray((Char_t *&)c); }
Int_t ReadArray(UShort_t*& h)
{ return TBufferFile::ReadArray((Short_t *&)h); }
Int_t ReadArray(UInt_t*& i)
{ return TBufferFile::ReadArray((Int_t *&)i); }
Int_t ReadArray(ULong_t*& l)
{ return TBufferFile::ReadArray((Long_t *&)l); }
Int_t ReadArray(ULong64_t*& ll)
{ return TBufferFile::ReadArray((Long64_t *&)ll); }
Int_t ReadStaticArray(UChar_t* c)
Int_t ReadStaticArray(UShort_t* h)
Int_t ReadStaticArray(UInt_t* i)
{ return TBufferFile::ReadStaticArray((Int_t *)i); }
Int_t ReadStaticArray(ULong_t* l)
Int_t ReadStaticArray(ULong64_t* ll)
void ReadFastArray(UChar_t* c, Int_t n)
void ReadFastArray(UShort_t* h, Int_t n)
void ReadFastArray(UInt_t* i, Int_t n)
void ReadFastArray(ULong_t* l, Int_t n)
void ReadFastArray(ULong64_t* ll, Int_t n)
void WriteArray(const UChar_t* c, Int_t n)
{ TBufferFile::WriteArray((const Char_t *)c, n); }
void WriteArray(const UShort_t* h, Int_t n)
{ TBufferFile::WriteArray((const Short_t *)h, n); }
void WriteArray(const UInt_t* i, Int_t n)
{ TBufferFile::WriteArray((const Int_t *)i, n); }
void WriteArray(const ULong64_t* ll, Int_t n)
{ TBufferFile::WriteArray((const Long64_t *)ll, n); }
void WriteFastArray(const UChar_t* c, Int_t n)
{ TBufferFile::WriteFastArray((const Char_t *)c, n); }
void WriteFastArray(const UShort_t* h, Int_t n)
{ TBufferFile::WriteFastArray((const Short_t *)h, n); }
void WriteFastArray(const UInt_t* i, Int_t n)
{ TBufferFile::WriteFastArray((const Int_t *)i, n); }
void WriteFastArray(const ULong64_t* ll, Int_t n)
{ TBufferFile::WriteFastArray((const Long64_t *)ll, n); }
TBufferFile()
 Default ctor
{}
TBufferFile(const TBufferFile& )
 TBuffer objects cannot be copied or assigned
void operator=(const TBufferFile& )
Int_t GetMapCount() const
{ return fMapCount; }
void Reset()
void SetStreamerElementNumber(Int_t )
{}
TVirtualStreamerInfo * GetInfo()
void ClassBegin(const TClass* , Version_t = -1)
{}
void ClassEnd(const TClass* )
{}
void ClassMember(const char* , const char* = 0, Int_t = -1, Int_t = -1)
{}
UShort_t GetPidOffset() const
 See comment in TBuffer::SetPidOffset
Int_t GetBufferDisplacement() const
{ return fDisplacement; }
void SetBufferDisplacement()
{ fDisplacement = 0; }
void SetBufferDisplacement(Int_t skipped)
{ fDisplacement = (Int_t)(Length() - skipped); }