A++ » INCLUDE » 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:
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
voidTObject::operator delete(void* ptr)
voidTObject::operator delete(void* ptr, void* vp)
voidTObject::operator delete[](void* ptr)
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*& l)
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* l, 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 voidReadFastArrayWithFactor(Float_t* ptr, Int_t n, Double_t factor, Double_t minvalue)
virtual voidReadFastArrayWithFactor(Double_t* ptr, Int_t n, Double_t factor, Double_t minvalue)
virtual voidReadFastArrayWithNbits(Float_t* ptr, Int_t n, Int_t nbits)
virtual voidReadFastArrayWithNbits(Double_t* ptr, Int_t n, Int_t nbits)
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& l)
virtual TObject*ReadObject(const TClass* cl)
virtual void*ReadObjectAny(const TClass* cast)
virtual TProcessID*ReadProcessID(UShort_t pidf)
virtual voidReadShort(Short_t& s)
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* l)
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 voidReadStdString(string* s)
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& l)
virtual voidReadULong64(ULong64_t& l)
virtual voidReadUShort(UShort_t& s)
virtual Version_tReadVersion(UInt_t* start = 0, UInt_t* bcnt = 0, const TClass* cl = 0)
virtual Version_tReadVersionForMemberWise(const TClass* cl = 0)
virtual Version_tReadVersionNoCheckSum(UInt_t* start = 0, UInt_t* bcnt = 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(TStreamerElement*, Int_t)
virtual voidTObject::SetUniqueID(UInt_t uid)
voidTBuffer::SetWriteMode()
virtual voidSetWriteParam(Int_t mapsize)
virtual voidShowMembers(TMemberInspector& insp) const
virtual voidSkipObjectAny()
virtual voidSkipVersion(const TClass* cl = 0)
virtual voidStreamer(TBuffer&)
voidStreamerNVirtual(TBuffer& ClassDef_StreamerNVirtual_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)
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)
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* l, 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* l, 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 l)
virtual voidWriteObject(const TObject* obj)
virtual Int_tWriteObjectAny(const void* obj, const TClass* ptrClass)
virtual UShort_tWriteProcessID(TProcessID* pid)
virtual voidWriteShort(Short_t s)
virtual voidWriteStdString(const string* s)
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 l)
virtual voidWriteUShort(UShort_t s)
virtual UInt_tWriteVersion(const TClass* cl, Bool_t useBcnt = kFALSE)
virtual UInt_tWriteVersionMemberWise(const TClass* cl, Bool_t useBcnt = kFALSE)
protected:
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)
TBufferFile()
TBufferFile(const TBufferFile&)
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:
static TObject::(anonymous)TObject::kBitMask
static TObject::EStatusBitsTObject::kCanDelete
static TBuffer::(anonymous)TBuffer::kCannotHandleMemberWiseStreaming
static TObject::EStatusBitsTObject::kCannotPick
static TObject::EStatusBitsTObject::kHasUUID
static TBuffer::(anonymous)TBuffer::kInitialSize
static TObject::EStatusBitsTObject::kInvalidObject
static TObject::(anonymous)TObject::kIsOnHeap
static TBuffer::(anonymous)TBuffer::kIsOwner
static TObject::EStatusBitsTObject::kIsReferenced
static TBufferFile::(anonymous)kMapSize
static TBuffer::(anonymous)TBuffer::kMinimalSize
static TObject::EStatusBitsTObject::kMustCleanup
static TObject::EStatusBitsTObject::kNoContextMenu
static TBufferFile::(anonymous)kNotDecompressed
static TObject::(anonymous)TObject::kNotDeleted
static TObject::EStatusBitsTObject::kObjInCanvas
static TObject::(anonymous)TObject::kOverwrite
static TBuffer::EModeTBuffer::kRead
static TObject::(anonymous)TObject::kSingleKey
static TBufferFile::(anonymous)kStreamedMemberWise
static TBufferFile::(anonymous)kTextBasedStreaming
static TBufferFile::(anonymous)kUser1
static TBufferFile::(anonymous)kUser2
static TBufferFile::(anonymous)kUser3
static TBuffer::EModeTBuffer::kWrite
static TObject::(anonymous)TObject::kWriteDelete
static TObject::(anonymous)TObject::kZombie
protected:
char*TBuffer::fBufCurCurrent position in buffer
char*TBuffer::fBufMaxEnd of buffer
Int_tTBuffer::fBufSizeSize of buffer
char*TBuffer::fBufferBuffer used to store objects
TBuffer::CacheList_tTBuffer::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
TBufferFile::InfoList_tfInfoStackStack 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 Chart:
TObject
←
TBuffer
←
TBufferFile
←
TBufferSQL
TBufferXML
TMessage

Function documentation

void WriteBool(Bool_t b)




void WriteChar(Char_t c)






void WriteUChar(UChar_t c)






void WriteShort(Short_t s)






void WriteUShort(UShort_t s)






void WriteInt(Int_t i)






void WriteUInt(UInt_t i)






void WriteLong(Long_t l)






void WriteULong(ULong_t l)






void WriteLong64(Long64_t l)






void WriteULong64(ULong64_t l)






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& s)






void ReadUShort(UShort_t& s)






void ReadInt(Int_t& i)






void ReadUInt(UInt_t& i)






void ReadULong(ULong_t& l)






void ReadLong64(Long64_t& l)






void ReadULong64(ULong64_t& l)






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*& l)





{  return TBufferFile::ReadArray((Long64_t *&)ll); }






Int_t ReadStaticArray(UChar_t* c)





{  return TBufferFile::ReadStaticArray((Char_t *)c); }






Int_t ReadStaticArray(UShort_t* h)





{  return TBufferFile::ReadStaticArray((Short_t *)h); }






Int_t ReadStaticArray(UInt_t* i)





{  return TBufferFile::ReadStaticArray((Int_t *)i); }






Int_t ReadStaticArray(ULong_t* l)





{  return TBufferFile::ReadStaticArray((Long_t *)l); }






Int_t ReadStaticArray(ULong64_t* l)





{  return TBufferFile::ReadStaticArray((Long64_t *)ll); }






void ReadFastArray(UChar_t* c, Int_t n)





{        TBufferFile::ReadFastArray((Char_t *)c, n); }






void ReadFastArray(UShort_t* h, Int_t n)





{        TBufferFile::ReadFastArray((Short_t *)h, n); }






void ReadFastArray(UInt_t* i, Int_t n)





{        TBufferFile::ReadFastArray((Int_t *)i, n); }






void ReadFastArray(ULong_t* l, Int_t n)





{        TBufferFile::ReadFastArray((Long_t *)l, n); }






void ReadFastArray(ULong64_t* l, Int_t n)





{        TBufferFile::ReadFastArray((Long64_t *)ll, 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* l, 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* l, 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 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 WriteObjectClass(const void* actualObjStart, const TClass* actualClass)




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




Int_t GetMapCount() const



{ return fMapCount; }






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




void MapObject(const TObject* obj, UInt_t offset = 1)




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




void Reset()



{ SetBufferOffset(); ResetMap(); }






void InitMap()




void ResetMap()




void SetReadParam(Int_t mapsize)




void SetWriteParam(Int_t mapsize)




Bool_t CheckObject(const TObject* obj)




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




Int_t GetVersionOwner() const




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




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




void SetByteCount(UInt_t cntpos, Bool_t packInVersion = kFALSE)




void SkipVersion(const TClass* cl = 0)




Version_t ReadVersion(UInt_t* start = 0, UInt_t* bcnt = 0, const TClass* cl = 0)




Version_t ReadVersionNoCheckSum(UInt_t* start = 0, UInt_t* bcnt = 0)




Version_t ReadVersionForMemberWise(const TClass* cl = 0)




UInt_t WriteVersion(const TClass* cl, Bool_t useBcnt = kFALSE)




UInt_t WriteVersionMemberWise(const TClass* cl, Bool_t useBcnt = kFALSE)




void      * ReadObjectAny(const TClass* cast)




void SkipObjectAny()




void TagStreamerInfo(TVirtualStreamerInfo* info)




void IncrementLevel(TVirtualStreamerInfo* info)




void SetStreamerElementNumber(TStreamerElement* , Int_t )



{}






void DecrementLevel(TVirtualStreamerInfo* )




TVirtualStreamerInfo  * GetInfo()



{return (TVirtualStreamerInfo*)fInfo;}






void ClassBegin(const TClass* , Version_t  = -1)



{}






void ClassEnd(const TClass* )



{}






void ClassMember(const char* , const char*  = 0, Int_t  = -1, Int_t  = -1)



{}






Int_t ReadBuf(void* buf, Int_t max)




void WriteBuf(const void* buf, Int_t max)




char      * ReadString(char* s, Int_t max)




void WriteString(const char* s)




TClass    * ReadClass(const TClass* cl = 0, UInt_t* objTag = 0)




void WriteClass(const TClass* cl)




TObject   * ReadObject(const TClass* cl)




void WriteObject(const TObject* obj)




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




UShort_t GetPidOffset() const


 See comment in TBuffer::SetPidOffset





void SetPidOffset(UShort_t offset)




Int_t GetBufferDisplacement() const



{ return fDisplacement; }






void SetBufferDisplacement()



{ fDisplacement = 0; }






void SetBufferDisplacement(Int_t skipped)



{ fDisplacement =  (Int_t)(Length() - skipped); }






void ReadFloat16(Float_t* f, TStreamerElement* ele = 0)


 basic types and arrays of basic types





void WriteFloat16(Float_t* f, TStreamerElement* ele = 0)




void ReadDouble32(Double_t* d, TStreamerElement* ele = 0)




void WriteDouble32(Double_t* d, TStreamerElement* ele = 0)




void ReadWithFactor(Float_t* ptr, Double_t factor, Double_t minvalue)




void ReadWithNbits(Float_t* ptr, Int_t nbits)




void ReadWithFactor(Double_t* ptr, Double_t factor, Double_t minvalue)




void ReadWithNbits(Double_t* ptr, Int_t nbits)




Int_t ReadArray(Bool_t*& b)




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 ReadArrayFloat16(Float_t*& f, TStreamerElement* ele = 0)




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




Int_t ReadStaticArray(Bool_t* b)




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 ReadStaticArrayFloat16(Float_t* f, TStreamerElement* ele = 0)




Int_t ReadStaticArrayDouble32(Double_t* d, TStreamerElement* ele = 0)




void ReadFastArray(Bool_t* b, Int_t n)




void ReadFastArray(Char_t* c, Int_t n)




void ReadFastArrayString(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(Long64_t* l, Int_t n)




void ReadFastArrayFloat16(Float_t* f, Int_t n, TStreamerElement* ele = 0)




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




void ReadFastArrayWithFactor(Float_t* ptr, Int_t n, Double_t factor, Double_t minvalue)




void ReadFastArrayWithNbits(Float_t* ptr, Int_t n, Int_t nbits)




void ReadFastArrayWithFactor(Double_t* ptr, Int_t n, Double_t factor, Double_t minvalue)




void ReadFastArrayWithNbits(Double_t* ptr, Int_t n, Int_t nbits)




void WriteArray(const Bool_t* b, Int_t n)




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 WriteArrayFloat16(const Float_t* f, Int_t n, TStreamerElement* ele = 0)




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




void WriteFastArray(const Bool_t* b, Int_t n)




void WriteFastArray(const Char_t* c, Int_t n)




void WriteFastArrayString(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 Long64_t* l, Int_t n)




void WriteFastArray(const ULong64_t* l, Int_t n)




void WriteFastArrayFloat16(const Float_t* f, Int_t n, TStreamerElement* ele = 0)




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




void StreamObject(void *obj, const std::type_info &typeinfo, const TClass* onFileClass = 0 )




void StreamObject(void* obj, const char* className, const TClass* onFileClass = 0)




void StreamObject(void* obj, const TClass* cl, const TClass* onFileClass = 0)




void StreamObject(TObject* obj)




void ReadLong(Long_t& l)




void ReadTString(TString& s)




void ReadStdString(string* s)




void WriteTString(const TString& s)




void WriteStdString(const string* s)




TProcessID * GetLastProcessID(TRefTable* reftable) const


 Special basic ROOT objects and collections





UInt_t GetTRefExecId()




TProcessID * ReadProcessID(UShort_t pidf)




UShort_t WriteProcessID(TProcessID* pid)




void ForceWriteInfo(TVirtualStreamerInfo* info, Bool_t force)


 Utilities for TStreamerInfo





void ForceWriteInfoClones(TClonesArray* a)




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)


 Utilities for TClass





Int_t ReadClassBuffer(const TClass* cl, void* pointer, const TClass* onfile_class)




Int_t ReadClassBuffer(const TClass* cl, void* pointer, Int_t version, UInt_t start, UInt_t count, const TClass* onfile_class)




Int_t WriteClassBuffer(const TClass* cl, void* pointer)




Int_t ApplySequence(const TStreamerInfoActions::TActionSequence& sequence, void* object)


 Utilites to streamer using sequences.





Int_t ApplySequenceVecPtr(const TStreamerInfoActions::TActionSequence& sequence, void* start_collection, void* end_collection)




Int_t ApplySequence(const TStreamerInfoActions::TActionSequence& sequence, void* start_collection, void* end_collection)




void SetGlobalReadParam(Int_t mapsize)




void SetGlobalWriteParam(Int_t mapsize)




Int_t GetGlobalReadParam()




Int_t GetGlobalWriteParam()