A++ » INCLUDE » TBufferXML

class TBufferXML: public TBufferFile, public TXMLSetup

Function Members (Methods)

public:
virtual~TBufferXML()
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_tTBufferFile::CheckObject(const TObject* obj)
virtual Bool_tTBufferFile::CheckObject(const void* obj, const TClass* ptrClass)
static TClass*Class()
virtual voidClassBegin(const TClass*, Version_t = -1)
virtual voidClassEnd(const TClass*)
virtual voidClassMember(const char* name, const char* typeName = 0, Int_t arrsize1 = -1, Int_t arrsize2 = -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
static TObject*ConvertFromXML(const char* str, Bool_t GenericLayout = kFALSE, Bool_t UseNamespaces = kFALSE)
static void*ConvertFromXMLAny(const char* str, TClass** cl = 0, Bool_t GenericLayout = kFALSE, Bool_t UseNamespaces = kFALSE)
static TStringConvertToXML(const TObject* obj, Bool_t GenericLayout = kFALSE, Bool_t UseNamespaces = kFALSE)
static TStringConvertToXML(const void* obj, const TClass* cl, Bool_t GenericLayout = kFALSE, Bool_t UseNamespaces = kFALSE)
virtual voidTObject::Copy(TObject& object) const
virtual voidDecrementLevel(TVirtualStreamerInfo*)
static TStringTXMLSetup::DefaultXmlSetup()
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 voidTBufferFile::ForceWriteInfo(TVirtualStreamerInfo* info, Bool_t force)
virtual voidTBufferFile::ForceWriteInfoClones(TClonesArray* a)
virtual Int_tTBufferFile::GetBufferDisplacement() 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 const char*GetFloatFormat()
static Int_tTBufferFile::GetGlobalReadParam()
static Int_tTBufferFile::GetGlobalWriteParam()
virtual const char*TObject::GetIconName() const
virtual TVirtualStreamerInfo*TBufferFile::GetInfo()
Int_tGetIOVersion() const
virtual TProcessID*TBufferFile::GetLastProcessID(TRefTable* reftable) const
virtual Int_tTBufferFile::GetMapCount() const
virtual voidTBufferFile::GetMappedObject(UInt_t tag, void*& ptr, TClass*& ClassPtr) const
virtual const char*TObject::GetName() const
Int_tTXMLSetup::GetNextRefCounter()
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_tTBufferFile::GetPidOffset() const
ReAllocCharFun_tTBuffer::GetReAllocFunc() const
TStringTXMLSetup::GetSetupAsString()
virtual const char*TObject::GetTitle() const
virtual UInt_tTBufferFile::GetTRefExecId()
virtual UInt_tTObject::GetUniqueID() const
virtual Int_tTBufferFile::GetVersionOwner() const
TXMLSetup::EXMLLayoutTXMLSetup::GetXmlLayout() const
virtual Bool_tTObject::HandleTimer(TTimer* timer)
virtual ULong_tTObject::Hash() const
virtual voidIncrementLevel(TVirtualStreamerInfo*)
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 voidTBufferFile::InitMap()
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_tTXMLSetup::IsStoreStreamerInfos() const
Bool_tTXMLSetup::IsUseDtd() const
Bool_tTXMLSetup::IsUseNamespaces() const
Bool_tTBuffer::IsWriting() const
Bool_tTObject::IsZombie() const
Int_tTBuffer::Length() const
virtual voidTObject::ls(Option_t* option = "") const
virtual voidTBufferFile::MapObject(const TObject* obj, UInt_t offset = 1)
virtual voidTBufferFile::MapObject(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)
TBufferXML&operator=(const TBufferXML&)
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
voidTXMLSetup::PrintSetup()
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_tTBufferFile::ReadBuf(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_tTBufferFile::ReadClassBuffer(const TClass* cl, void* pointer, const TClass* onfile_class)
virtual Int_tTBufferFile::ReadClassBuffer(const TClass* cl, void* pointer, Int_t version, UInt_t start, UInt_t count, const TClass* onfile_class)
virtual Int_tTBufferFile::ReadClassEmulated(const TClass* cl, void* object, const TClass* onfile_class)
virtual Int_tTBufferFile::ReadClones(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 voidTBufferFile::ReadFastArrayString(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*TBufferFile::ReadObject(const TClass* cl)
virtual void*ReadObjectAny(const TClass* clCast)
virtual TProcessID*TBufferFile::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*TBufferFile::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_tTBufferFile::ReadVersionForMemberWise(const TClass* cl = 0)
virtual Version_tTBufferFile::ReadVersionNoCheckSum(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 voidTBufferFile::Reset()
voidTObject::ResetBit(UInt_t f)
virtual voidTBufferFile::ResetMap()
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 voidTBufferFile::SetBufferDisplacement()
virtual voidTBufferFile::SetBufferDisplacement(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 voidSetFloatFormat(const char* fmt = "%e")
static voidTBufferFile::SetGlobalReadParam(Int_t mapsize)
static voidTBufferFile::SetGlobalWriteParam(Int_t mapsize)
voidSetIOVersion(Int_t v)
static voidTXMLSetup::SetNameSpaceBase(const char* namespacebase)
static voidTObject::SetObjectStat(Bool_t stat)
voidTBuffer::SetParent(TObject* parent)
virtual voidTBufferFile::SetPidOffset(UShort_t offset)
voidTBuffer::SetReadMode()
virtual voidTBufferFile::SetReadParam(Int_t mapsize)
voidTBuffer::SetReAllocFunc(ReAllocCharFun_t reallocfunc = 0)
virtual voidTXMLSetup::SetStoreStreamerInfos(Bool_t iConvert = kTRUE)
virtual voidSetStreamerElementNumber(TStreamerElement* elem, Int_t comp_type)
virtual voidTObject::SetUniqueID(UInt_t uid)
virtual voidTXMLSetup::SetUsedDtd(Bool_t use = kTRUE)
virtual voidTXMLSetup::SetUseNamespaces(Bool_t iUseNamespaces = kTRUE)
voidTBuffer::SetWriteMode()
virtual voidTBufferFile::SetWriteParam(Int_t mapsize)
virtual voidTXMLSetup::SetXmlLayout(TXMLSetup::EXMLLayout layout)
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 voidTBufferFile::TagStreamerInfo(TVirtualStreamerInfo* info)
TBufferXML(TBuffer::EMode mode)
TBufferXML(const TBufferXML&)
TBufferXML(TBuffer::EMode mode, TXMLFile* file)
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 voidTBufferFile::WriteBuf(const void* buf, Int_t max)
virtual voidWriteChar(Char_t c)
virtual voidWriteCharP(const Char_t* c)
virtual voidWriteClass(const TClass* cl)
virtual Int_tTBufferFile::WriteClassBuffer(const TClass* cl, void* pointer)
virtual Int_tTBufferFile::WriteClones(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* d, Int_t n, TStreamerElement* ele = 0)
virtual voidTBufferFile::WriteFastArrayString(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_tTBufferFile::WriteObjectAny(const void* obj, const TClass* ptrClass)
virtual UShort_tTBufferFile::WriteProcessID(TProcessID* pid)
virtual voidWriteShort(Short_t s)
virtual voidWriteStdString(const string* s)
virtual voidTBufferFile::WriteString(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_tTBufferFile::WriteVersionMemberWise(const TClass* cl, Bool_t useBcnt = kFALSE)
const char*TXMLSetup::XmlClassNameSpaceRef(const TClass* cl)
const char*TXMLSetup::XmlConvertClassName(const char* name)
const char*TXMLSetup::XmlGetElementName(const TStreamerElement* el)
protected:
Int_tTXMLSetup::AtoI(const char* sbuf, Int_t def = 0, const char* errinfo = 0)
voidBeforeIOoperation()
voidTBufferFile::CheckCount(UInt_t offset)
UInt_tTBufferFile::CheckObject(UInt_t offset, const TClass* cl, Bool_t readClass = kFALSE)
voidCheckVersionBuf()
voidCreateElemNode(const TStreamerElement* elem)
XMLNodePointer_tCreateItemNode(const char* name)
virtual voidTObject::DoError(int level, const char* location, const char* fmt, va_list va) const
Bool_tExtractPointer(XMLNodePointer_t node, void*& ptr, TClass*& cl)
voidExtractReference(XMLNodePointer_t node, const void* ptr, const TClass* cl)
Int_tGetCompressionAlgorithm() const
Int_tGetCompressionLevel() const
Int_tGetCompressionSettings() const
const char*TXMLSetup::GetElItemName(TStreamerElement* el)
Bool_tTXMLSetup::IsValidXmlSetup(const char* setupstr)
voidTObject::MakeZombie()
voidPerformPostProcessing()
voidPerformPreProcessing(const TStreamerElement* elem, XMLNodePointer_t elemnode)
TXMLStackObj*PopStack()
Bool_tProcessPointer(const void* ptr, XMLNodePointer_t node)
TXMLStackObj*PushStack(XMLNodePointer_t current, Bool_t simple = kFALSE)
virtual Int_tTBuffer::Read(const char* name)
Bool_tTXMLSetup::ReadSetupFromStr(const char* setupstr)
voidRegisterPointer(const void* ptr, XMLNodePointer_t node)
voidSetCompressionAlgorithm(Int_t algorithm = 0)
voidSetCompressionLevel(Int_t level = 1)
voidSetCompressionSettings(Int_t settings = 1)
voidSetXML(TXMLEngine* xml)
voidShiftStack(const char* info = 0)
TXMLStackObj*Stack(Int_t depth = 0)
XMLNodePointer_tStackNode()
TBufferXML()
Bool_tVerifyAttr(XMLNodePointer_t node, const char* name, const char* value, const char* errinfo = 0)
Bool_tVerifyElemNode(const TStreamerElement* elem)
Bool_tVerifyItemNode(const char* name, const char* errinfo = 0)
Bool_tVerifyNode(XMLNodePointer_t node, const char* name, const char* errinfo = 0)
Bool_tVerifyStackAttr(const char* name, const char* value, const char* errinfo = 0)
Bool_tVerifyStackNode(const char* name, const char* errinfo = 0)
voidWorkWithClass(TStreamerInfo* info, const TClass* cl = 0)
voidWorkWithElement(TStreamerElement* elem, Int_t comp_type)
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)
TClass*TXMLSetup::XmlDefineClass(const char* xmlClassName)
TXMLFile*XmlFile()
void*XmlReadAny(XMLNodePointer_t node, void* obj, TClass** cl)
voidXmlReadBasic(Char_t& value)
voidXmlReadBasic(Short_t& value)
voidXmlReadBasic(Int_t& value)
voidXmlReadBasic(Long_t& value)
voidXmlReadBasic(Long64_t& value)
voidXmlReadBasic(Float_t& value)
voidXmlReadBasic(Double_t& value)
voidXmlReadBasic(Bool_t& value)
voidXmlReadBasic(UChar_t& value)
voidXmlReadBasic(UShort_t& value)
voidXmlReadBasic(UInt_t& value)
voidXmlReadBasic(ULong_t& value)
voidXmlReadBasic(ULong64_t& value)
voidXmlReadBlock(XMLNodePointer_t node)
void*XmlReadObject(void* obj, TClass** cl = 0)
const char*XmlReadValue(const char* name)
XMLNodePointer_tXmlWriteAny(const void* obj, const TClass* cl)
XMLNodePointer_tXmlWriteBasic(Char_t value)
XMLNodePointer_tXmlWriteBasic(Short_t value)
XMLNodePointer_tXmlWriteBasic(Int_t value)
XMLNodePointer_tXmlWriteBasic(Long_t value)
XMLNodePointer_tXmlWriteBasic(Long64_t value)
XMLNodePointer_tXmlWriteBasic(Float_t value)
XMLNodePointer_tXmlWriteBasic(Double_t value)
XMLNodePointer_tXmlWriteBasic(Bool_t value)
XMLNodePointer_tXmlWriteBasic(UChar_t value)
XMLNodePointer_tXmlWriteBasic(UShort_t value)
XMLNodePointer_tXmlWriteBasic(UInt_t value)
XMLNodePointer_tXmlWriteBasic(ULong_t value)
XMLNodePointer_tXmlWriteBasic(ULong64_t value)
voidXmlWriteBlock(XMLNodePointer_t node)
XMLNodePointer_tXmlWriteObject(const void* obj, const TClass* objClass)
XMLNodePointer_tXmlWriteValue(const char* value, const char* name)

Data Members

public:
static TObject::(anonymous)TObject::kBitMask
static TObject::EStatusBitsTObject::kCanDelete
static TBuffer::(anonymous)TBuffer::kCannotHandleMemberWiseStreaming
static TObject::EStatusBitsTObject::kCannotPick
static TXMLSetup::EXMLLayoutTXMLSetup::kGeneralized
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)TBufferFile::kMapSize
static TBuffer::(anonymous)TBuffer::kMinimalSize
static TObject::EStatusBitsTObject::kMustCleanup
static TObject::EStatusBitsTObject::kNoContextMenu
static TBufferFile::(anonymous)TBufferFile::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 TXMLSetup::EXMLLayoutTXMLSetup::kSpecialized
static TBufferFile::(anonymous)TBufferFile::kStreamedMemberWise
static TBufferFile::(anonymous)TBufferFile::kTextBasedStreaming
static TBufferFile::(anonymous)TBufferFile::kUser1
static TBufferFile::(anonymous)TBufferFile::kUser2
static TBufferFile::(anonymous)TBufferFile::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
Bool_tfCanUseCompact! Flag indicate that basic type (like Int_t) can be placed in the same tag
TExMap*TBufferFile::fClassMapMap containing object,class pairs for reading
Int_tfCompressLevel! Compression level and algorithm
Int_tTBufferFile::fDisplacementValue to be added to the map offsets
Int_tfErrorFlag!
TClass*fExpectedBaseClass! Pointer to class, which should be stored as parent of current
Bool_tfExpectedChain! Flag to resolve situation when several elements of same basic type stored as FastArray
Int_tfIOVersion! Indicates format of ROOT xml file
TObjArray*fIdArray!
TStreamerInfo*TBufferFile::fInfoPointer to TStreamerInfo object writing/reading the buffer
TBufferFile::InfoList_tTBufferFile::fInfoStackStack of pointers to the TStreamerInfos
TExMap*TBufferFile::fMapMap containing object,offset pairs for reading/writing
Int_tTBufferFile::fMapCountNumber of objects or classes in map
Int_tTBufferFile::fMapSizeDefault size of map
Bool_tTBuffer::fModeRead or write mode
TExMap*fObjMap!
TObject*TBuffer::fParentPointer to parent object owning this buffer
UShort_tTBufferFile::fPidOffsetOffset to be added to the pid index in this key/buffer.
ReAllocCharFun_tTBuffer::fReAllocFunc! Realloc function to be used when extending the buffer.
Int_tTXMLSetup::fRefCounter! counter , used to build id of xml references
TObjArrayfStack!
Bool_tTXMLSetup::fStoreStreamerInfos
TStringTXMLSetup::fStrBuf! buffer, used in XmlDefineClass() function
Bool_tTXMLSetup::fUseDtd
Bool_tTXMLSetup::fUseNamespaces
TStringfValueBuf!
Int_tTBuffer::fVersionBuffer format version
Version_tfVersionBuf!
TXMLEngine*fXML!
TXMLSetup::EXMLLayoutTXMLSetup::fXmlLayout
static stringfgFloatFmt! Printf argument for floats and doubles, either "%f" or "%e" or "%10f" and so on
static Int_tTBufferFile::fgMapSizeDefault map size for all TBuffer objects
static TStringTXMLSetup::fgNameSpaceBase

Class Charts

Inheritance Chart:
TObject
←
TBuffer
←
TBufferFile
TXMLSetup
←
TBufferXML

Function documentation

Int_t GetCompressionAlgorithm() const




Int_t GetCompressionLevel() const






Int_t GetCompressionSettings() const






 TBufferXML(TBuffer::EMode mode)




 TBufferXML(TBuffer::EMode mode, TXMLFile* file)




virtual ~TBufferXML()




TString ConvertToXML(const TObject* obj, Bool_t GenericLayout = kFALSE, Bool_t UseNamespaces = kFALSE)




TString ConvertToXML(const void* obj, const TClass* cl, Bool_t GenericLayout = kFALSE, Bool_t UseNamespaces = kFALSE)




TObject* ConvertFromXML(const char* str, Bool_t GenericLayout = kFALSE, Bool_t UseNamespaces = kFALSE)




void* ConvertFromXMLAny(const char* str, TClass** cl = 0, Bool_t GenericLayout = kFALSE, Bool_t UseNamespaces = kFALSE)




Int_t GetIOVersion() const



{ return fIOVersion; }






void SetIOVersion(Int_t v)



{ fIOVersion = v; }






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


 suppress class writing/reading





void WriteClass(const TClass* cl)




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


 redefined virtual functions of TBuffer





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)




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




void* ReadObjectAny(const TClass* clCast)




void SkipObjectAny()




void IncrementLevel(TVirtualStreamerInfo* )




void SetStreamerElementNumber(TStreamerElement* elem, Int_t comp_type)




void DecrementLevel(TVirtualStreamerInfo* )




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




void ClassEnd(const TClass* )




void ClassMember(const char* name, const char* typeName = 0, Int_t arrsize1 = -1, Int_t arrsize2 = -1)




void WriteObject(const TObject* obj)




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




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




Int_t ReadArray(Long64_t*& l)




Int_t ReadArray(ULong64_t*& l)




Int_t ReadArray(Float_t*& f)




Int_t ReadArray(Double_t*& d)




Int_t 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 ReadStaticArray(ULong_t* l)




Int_t ReadStaticArray(Long64_t* l)




Int_t ReadStaticArray(ULong64_t* l)




Int_t ReadStaticArray(Float_t* f)




Int_t ReadStaticArray(Double_t* d)




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 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 ReadFastArray(ULong64_t* l, Int_t n)




void ReadFastArray(Float_t* f, Int_t n)




void ReadFastArray(Double_t* d, 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 WriteArray(const Long64_t* l, Int_t n)




void WriteArray(const ULong64_t* l, Int_t n)




void WriteArray(const Float_t* f, Int_t n)




void WriteArray(const Double_t* d, Int_t n)




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




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




void ReadFastArray(void* start, const TClass* cl, Int_t n = 1, TMemberStreamer* s = 0, const TClass* onFileClass = 0)




void ReadFastArray(void** startp, const TClass* cl, Int_t n = 1, Bool_t isPreAlloc = kFALSE, TMemberStreamer* s = 0, const TClass* onFileClass = 0)




void WriteFastArray(const Bool_t* b, Int_t n)




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




void WriteFastArray(const ULong64_t* l, Int_t n)




void WriteFastArray(const Float_t* f, Int_t n)




void WriteFastArray(const Double_t* d, Int_t n)




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




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




void WriteFastArray(void* start, const TClass* cl, Int_t n = 1, TMemberStreamer* s = 0)




Int_t WriteFastArray(void** startp, const TClass* cl, Int_t n = 1, Bool_t isPreAlloc = kFALSE, TMemberStreamer* s = 0)




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 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 ReadLong(Long_t& l)




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)




void ReadTString(TString& s)




void ReadStdString(string* s)




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 WriteTString(const TString& s)




void WriteStdString(const string* s)




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




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 SetFloatFormat(const char* fmt = "%e")


 end of redefined virtual functions





const char* GetFloatFormat()




 TBufferXML()




void WriteObjectClass(const void* actualObjStart, const TClass* actualClass)


 redefined protected virtual functions





TXMLFile* XmlFile()


 end redefined protected virtual functions





void SetCompressionAlgorithm(Int_t algorithm = 0)




void SetCompressionLevel(Int_t level = 1)




void SetCompressionSettings(Int_t settings = 1)




void SetXML(TXMLEngine* xml)



{ fXML = xml; }






void XmlWriteBlock(XMLNodePointer_t node)




XMLNodePointer_t XmlWriteAny(const void* obj, const TClass* cl)




void XmlReadBlock(XMLNodePointer_t node)




void* XmlReadAny(XMLNodePointer_t node, void* obj, TClass** cl)




TXMLStackObj* PushStack(XMLNodePointer_t current, Bool_t simple = kFALSE)




TXMLStackObj* PopStack()




void ShiftStack(const char* info = 0)




XMLNodePointer_t StackNode()




void WorkWithClass(TStreamerInfo* info, const TClass* cl = 0)




void WorkWithElement(TStreamerElement* elem, Int_t comp_type)




Bool_t VerifyNode(XMLNodePointer_t node, const char* name, const char* errinfo = 0)




Bool_t VerifyStackNode(const char* name, const char* errinfo = 0)




Bool_t VerifyAttr(XMLNodePointer_t node, const char* name, const char* value, const char* errinfo = 0)




Bool_t VerifyStackAttr(const char* name, const char* value, const char* errinfo = 0)




Bool_t ProcessPointer(const void* ptr, XMLNodePointer_t node)




void RegisterPointer(const void* ptr, XMLNodePointer_t node)




Bool_t ExtractPointer(XMLNodePointer_t node, void*& ptr, TClass*& cl)




void ExtractReference(XMLNodePointer_t node, const void* ptr, const TClass* cl)




XMLNodePointer_t CreateItemNode(const char* name)




Bool_t VerifyItemNode(const char* name, const char* errinfo = 0)




void CreateElemNode(const TStreamerElement* elem)




Bool_t VerifyElemNode(const TStreamerElement* elem)




void PerformPreProcessing(const TStreamerElement* elem, XMLNodePointer_t elemnode)




void PerformPostProcessing()




XMLNodePointer_t XmlWriteBasic(Char_t value)




XMLNodePointer_t XmlWriteBasic(Short_t value)




XMLNodePointer_t XmlWriteBasic(Int_t value)




XMLNodePointer_t XmlWriteBasic(Long_t value)




XMLNodePointer_t XmlWriteBasic(Long64_t value)




XMLNodePointer_t XmlWriteBasic(Float_t value)




XMLNodePointer_t XmlWriteBasic(Double_t value)




XMLNodePointer_t XmlWriteBasic(Bool_t value)




XMLNodePointer_t XmlWriteBasic(UChar_t value)




XMLNodePointer_t XmlWriteBasic(UShort_t value)




XMLNodePointer_t XmlWriteBasic(UInt_t value)




XMLNodePointer_t XmlWriteBasic(ULong_t value)




XMLNodePointer_t XmlWriteBasic(ULong64_t value)




XMLNodePointer_t XmlWriteValue(const char* value, const char* name)




void XmlReadBasic(Char_t& value)




void XmlReadBasic(Short_t& value)




void XmlReadBasic(Int_t& value)




void XmlReadBasic(Long_t& value)




void XmlReadBasic(Long64_t& value)




void XmlReadBasic(Float_t& value)




void XmlReadBasic(Double_t& value)




void XmlReadBasic(Bool_t& value)




void XmlReadBasic(UChar_t& value)




void XmlReadBasic(UShort_t& value)




void XmlReadBasic(UInt_t& value)




void XmlReadBasic(ULong_t& value)




void XmlReadBasic(ULong64_t& value)




const char* XmlReadValue(const char* name)




XMLNodePointer_t XmlWriteObject(const void* obj, const TClass* objClass)




void* XmlReadObject(void* obj, TClass** cl = 0)




void BeforeIOoperation()




void CheckVersionBuf()