library: libXMLIO #include "TBufferXML.h"

# TBufferXML

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

## class TBufferXML : public TBuffer, public TXMLSetup

| Inheritance Chart:

`TObject`

<-

`TBuffer`

`TXMLSetup`

<-

`TBufferXML`

        protected:

                         TBufferXML()
                    void BeforeIOoperation()
                    void CheckVersionBuf()
                    void CreateElemNode(const TStreamerElement* elem, Int_t number = -1)
          xmlNodePointer CreateItemNode(const char* name)
                  Bool_t ExtractPointer(xmlNodePointer node, void*& ptr, TClass*& cl)
                    void ExtractReference(xmlNodePointer node, const void* ptr, const TClass* cl)
                    void PerformPostProcessing()
                    void PerformPreProcessing(const TStreamerElement* elem, xmlNodePointer elemnode)
           TXMLStackObj* PopStack()
                  Bool_t ProcessPointer(const void* ptr, xmlNodePointer node)
           TXMLStackObj* PushStack(xmlNodePointer current, Bool_t simple = kFALSE)
                    void RegisterPointer(const void* ptr, xmlNodePointer node)
                    void ShiftStack(const char* info = "0")
           TXMLStackObj* Stack(Int_t depth = 0)
          xmlNodePointer StackNode()
                  Bool_t VerifyAttr(xmlNodePointer node, const char* name, const char* value, const char* errinfo = "0")
                  Bool_t VerifyElemNode(const TStreamerElement* elem, Int_t number = -1)
                  Bool_t VerifyItemNode(const char* name, const char* errinfo = "0")
                  Bool_t VerifyNode(xmlNodePointer node, const char* name, const char* errinfo = "0")
                  Bool_t VerifyStackAttr(const char* name, const char* value, const char* errinfo = "0")
                  Bool_t VerifyStackNode(const char* name, const char* errinfo = "0")
            virtual void WriteObject(const void* actualObjStart, const TClass* actualClass)
               TXMLFile* XmlFile()
                    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)
                   void* XmlReadObject(void* obj, TClass** cl = 0)
             const char* XmlReadValue(const char* name) const
          xmlNodePointer XmlWriteBasic(Char_t value)
          xmlNodePointer XmlWriteBasic(Short_t value)
          xmlNodePointer XmlWriteBasic(Int_t value)
          xmlNodePointer XmlWriteBasic(Long_t value)
          xmlNodePointer XmlWriteBasic(Long64_t value)
          xmlNodePointer XmlWriteBasic(Float_t value)
          xmlNodePointer XmlWriteBasic(Double_t value)
          xmlNodePointer XmlWriteBasic(Bool_t value)
          xmlNodePointer XmlWriteBasic(UChar_t value)
          xmlNodePointer XmlWriteBasic(UShort_t value)
          xmlNodePointer XmlWriteBasic(UInt_t value)
          xmlNodePointer XmlWriteBasic(ULong_t value)
          xmlNodePointer XmlWriteBasic(ULong64_t value)
          xmlNodePointer XmlWriteObject(const void* obj, const TClass* objClass)
          xmlNodePointer XmlWriteValue(const char* value, const char* name)

        public:

                            TBufferXML(TBuffer::EMode mode)
                            TBufferXML(TBuffer::EMode mode, TXMLFile* file)
                    virtual ~TBufferXML()
              virtual Int_t CheckByteCount(UInt_t startpos, UInt_t bcnt, const TClass* clss)
              virtual Int_t CheckByteCount(UInt_t startpos, UInt_t bcnt, const char* classname)
             static TClass* Class()
               virtual void DecrementLevel(TStreamerInfo*)
               virtual void IncrementLevel(TStreamerInfo*)
            virtual TClass* IsA() const
           virtual TBuffer& operator<<(Bool_t b)
           virtual TBuffer& operator<<(Char_t c)
           virtual TBuffer& operator<<(UChar_t c)
           virtual TBuffer& operator<<(Short_t h)
           virtual TBuffer& operator<<(UShort_t h)
           virtual TBuffer& operator<<(Int_t i)
           virtual TBuffer& operator<<(UInt_t i)
           virtual TBuffer& operator<<(Long_t l)
           virtual TBuffer& operator<<(ULong_t l)
           virtual TBuffer& operator<<(Long64_t l)
           virtual TBuffer& operator<<(ULong64_t l)
           virtual TBuffer& operator<<(Float_t f)
           virtual TBuffer& operator<<(Double_t d)
           virtual TBuffer& operator<<(const Char_t* c)
           virtual TBuffer& operator>>(Bool_t& b)
           virtual TBuffer& operator>>(Char_t& c)
           virtual TBuffer& operator>>(UChar_t& c)
           virtual TBuffer& operator>>(Short_t& h)
           virtual TBuffer& operator>>(UShort_t& h)
           virtual TBuffer& operator>>(Int_t& i)
           virtual TBuffer& operator>>(UInt_t& i)
           virtual TBuffer& operator>>(Long_t& l)
           virtual TBuffer& operator>>(ULong_t& l)
           virtual TBuffer& operator>>(Long64_t& l)
           virtual TBuffer& operator>>(ULong64_t& l)
           virtual TBuffer& operator>>(Float_t& f)
           virtual TBuffer& operator>>(Double_t& d)
           virtual TBuffer& operator>>(Char_t* c)
              virtual Int_t ReadArray(Bool_t*& b)
              virtual Int_t ReadArray(Char_t*& c)
              virtual Int_t ReadArray(UChar_t*& c)
              virtual Int_t ReadArray(Short_t*& h)
              virtual Int_t ReadArray(UShort_t*& h)
              virtual Int_t ReadArray(Int_t*& i)
              virtual Int_t ReadArray(UInt_t*& i)
              virtual Int_t ReadArray(Long_t*& l)
              virtual Int_t ReadArray(ULong_t*& l)
              virtual Int_t ReadArray(Long64_t*& l)
              virtual Int_t ReadArray(ULong64_t*& l)
              virtual Int_t ReadArray(Float_t*& f)
              virtual Int_t ReadArray(Double_t*& d)
              virtual Int_t ReadArrayDouble32(Double_t*& d, TStreamerElement* ele = 0)
            virtual TClass* ReadClass(const TClass* cl = 0, UInt_t* objTag = 0)
               virtual void ReadDouble32(Double_t* d, TStreamerElement* ele = 0)
               virtual void ReadFastArray(Bool_t* b, Int_t n)
               virtual void ReadFastArray(Char_t* c, Int_t n)
               virtual void ReadFastArray(UChar_t* c, Int_t n)
               virtual void ReadFastArray(Short_t* h, Int_t n)
               virtual void ReadFastArray(UShort_t* h, Int_t n)
               virtual void ReadFastArray(Int_t* i, Int_t n)
               virtual void ReadFastArray(UInt_t* i, Int_t n)
               virtual void ReadFastArray(Long_t* l, Int_t n)
               virtual void ReadFastArray(ULong_t* l, Int_t n)
               virtual void ReadFastArray(Long64_t* l, Int_t n)
               virtual void ReadFastArray(ULong64_t* l, Int_t n)
               virtual void ReadFastArray(Float_t* f, Int_t n)
               virtual void ReadFastArray(Double_t* d, Int_t n)
               virtual void ReadFastArray(void* start, const TClass* cl, Int_t n = 1, TMemberStreamer* s = 0)
               virtual void ReadFastArray(void** startp, const TClass* cl, Int_t n = 1, Bool_t isPreAlloc = kFALSE, TMemberStreamer* s = 0)
               virtual void ReadFastArrayDouble32(Double_t* d, Int_t n, TStreamerElement* ele = 0)
              virtual void* ReadObjectAny(const TClass* clCast)
              virtual Int_t ReadStaticArray(Bool_t* b)
              virtual Int_t ReadStaticArray(Char_t* c)
              virtual Int_t ReadStaticArray(UChar_t* c)
              virtual Int_t ReadStaticArray(Short_t* h)
              virtual Int_t ReadStaticArray(UShort_t* h)
              virtual Int_t ReadStaticArray(Int_t* i)
              virtual Int_t ReadStaticArray(UInt_t* i)
              virtual Int_t ReadStaticArray(Long_t* l)
              virtual Int_t ReadStaticArray(ULong_t* l)
              virtual Int_t ReadStaticArray(Long64_t* l)
              virtual Int_t ReadStaticArray(ULong64_t* l)
              virtual Int_t ReadStaticArray(Float_t* f)
              virtual Int_t ReadStaticArray(Double_t* d)
              virtual Int_t ReadStaticArrayDouble32(Double_t* d, TStreamerElement* ele = 0)
          virtual Version_t ReadVersion(UInt_t* start = 0, UInt_t* bcnt = 0, const TClass* cl = 0)
               virtual void SetByteCount(UInt_t cntpos, Bool_t packInVersion = kFALSE)
                       void SetCompressionLevel(int level)
               virtual void SetStreamerElementNumber(Int_t)
                       void SetXML(TXMLEngine* xml)
               virtual void ShowMembers(TMemberInspector& insp, char* parent)
               virtual void SkipObjectAny()
               virtual void Streamer(TBuffer& b)
                       void StreamerNVirtual(TBuffer& b)
               virtual void StreamObject(void* obj, const type_info& typeinfo)
               virtual void StreamObject(void* obj, const char* className)
               virtual void StreamObject(void* obj, const TClass* cl)
               virtual void WriteArray(const Bool_t* b, Int_t n)
               virtual void WriteArray(const Char_t* c, Int_t n)
               virtual void WriteArray(const UChar_t* c, Int_t n)
               virtual void WriteArray(const Short_t* h, Int_t n)
               virtual void WriteArray(const UShort_t* h, Int_t n)
               virtual void WriteArray(const Int_t* i, Int_t n)
               virtual void WriteArray(const UInt_t* i, Int_t n)
               virtual void WriteArray(const Long_t* l, Int_t n)
               virtual void WriteArray(const ULong_t* l, Int_t n)
               virtual void WriteArray(const Long64_t* l, Int_t n)
               virtual void WriteArray(const ULong64_t* l, Int_t n)
               virtual void WriteArray(const Float_t* f, Int_t n)
               virtual void WriteArray(const Double_t* d, Int_t n)
               virtual void WriteArrayDouble32(const Double_t* d, Int_t n, TStreamerElement* ele = 0)
               virtual void WriteClass(const TClass* cl)
               virtual void WriteDouble32(Double_t* d, TStreamerElement* ele = 0)
               virtual void WriteFastArray(const Bool_t* b, Int_t n)
               virtual void WriteFastArray(const Char_t* c, Int_t n)
               virtual void WriteFastArray(const UChar_t* c, Int_t n)
               virtual void WriteFastArray(const Short_t* h, Int_t n)
               virtual void WriteFastArray(const UShort_t* h, Int_t n)
               virtual void WriteFastArray(const Int_t* i, Int_t n)
               virtual void WriteFastArray(const UInt_t* i, Int_t n)
               virtual void WriteFastArray(const Long_t* l, Int_t n)
               virtual void WriteFastArray(const ULong_t* l, Int_t n)
               virtual void WriteFastArray(const Long64_t* l, Int_t n)
               virtual void WriteFastArray(const ULong64_t* l, Int_t n)
               virtual void WriteFastArray(const Float_t* f, Int_t n)
               virtual void WriteFastArray(const Double_t* d, Int_t n)
               virtual void WriteFastArray(void* start, const TClass* cl, Int_t n = 1, TMemberStreamer* s = 0)
              virtual Int_t WriteFastArray(void** startp, const TClass* cl, Int_t n = 1, Bool_t isPreAlloc = kFALSE, TMemberStreamer* s = 0)
               virtual void WriteFastArrayDouble32(const Double_t* d, Int_t n, TStreamerElement* ele = 0)
               virtual void WriteObject(const TObject* obj)
             virtual UInt_t WriteVersion(const TClass* cl, Bool_t useBcnt = kFALSE)
                   TObject* XmlRead(xmlNodePointer node)
                      void* XmlReadAny(xmlNodePointer node, TClass** cl)
                       void XmlReadBlock(xmlNodePointer node)
             xmlNodePointer XmlWrite(const TObject* obj)
             xmlNodePointer XmlWrite(const void* obj, const TClass* cl)
                       void XmlWriteBlock(xmlNodePointer node)

### Data Members

        protected:

          TXMLEngine* fXML                !
            TObjArray fStack              !
            Version_t fVersionBuf         !
              TExMap* fObjMap             !
           TObjArray* fIdArray            !
              TString fValueBuf           !
                Int_t fErrorFlag          !
               Bool_t fCanUseCompact      !   flag indicate that basic type (like Int_t) can be placed in the same tag
               Bool_t fExpectedChain      !   flag to resolve situation when several elements of same basic type stored as FastArray
              TClass* fExpectedBaseClass  !   pointer to class, which should be stored as parent of current
                Int_t fCompressLevel      !   compress level used to minimize size of file

## Class Description

     Class for serializing/deserializing object to/from xml.
     It redefines most of TBuffer class function to convert simple types,
     array of simple types and objects to/from xml.
     Instead of writing a binary data it creates a set of xml structures as
     nodes and attributes
     TBufferXML class uses streaming mechanism, provided by ROOT system,
     therefore most of ROOT and user classes can be stored to xml. There are
     limitations for complex objects like TTree, which can not be yet converted to xml.
    ________________________________________________________________________

TBufferXML() : TBuffer(), TXMLSetup(), fXML(0)

     Default constructor

TBufferXML(TBuffer::EMode mode) : TBuffer(mode), TXMLSetup(), fXML(0), fStack(), fVersionBuf(-111), fObjMap(0), fIdArray(0), fErrorFlag(0), fCanUseCompact(kFALSE), fExpectedChain(kFALSE), fExpectedBaseClass(0), fCompressLevel(0)

     Creates buffer object to serailize/deserialize data to/from xml.
     Mode should be either TBuffer::kRead or TBuffer::kWrite.

TBufferXML(TBuffer::EMode mode, TXMLFile* file) : TBuffer(mode), TXMLSetup(*file), fStack(), fVersionBuf(-111), fObjMap(0), fIdArray(0), fErrorFlag(0), fCanUseCompact(kFALSE), fExpectedChain(kFALSE), fExpectedBaseClass(0), fCompressLevel(0)

     Creates buffer object to serailize/deserialize data to/from xml.
     This constructor should be used, if data from buffer supposed to be stored in file.
     Mode should be either TBuffer::kRead or TBuffer::kWrite.

~TBufferXML()

     destroy xml buffer

TXMLFile* XmlFile()

     returns pointer to TXMLFile object
     access to file is necessary to produce unique identifier for object references

xmlNodePointer XmlWrite(const TObject* obj)

     Convert object, derived from TObject class to xml structures
     Return pointer on top xml element

xmlNodePointer XmlWrite(const void* obj, const TClass* cl)

     Convert object of any class to xml structures
     Return pointer on top xml element

TObject* XmlRead(xmlNodePointer node)

     Recreate object from xml structure.
     Return pointer to read object.
     If object class is not inherited from TObject,
     object is deleted and function return 0

void* XmlReadAny(xmlNodePointer node, TClass** cl)

     Recreate object from xml structure.
     Return pointer to read object.
     if (cl!=0) returns pointer to class of object

void WriteObject(const TObject *obj)

     Convert object into xml structures.
     !!! Should be used only by TBufferXML itself.
     Use XmlWrite() functions to convert your object to xml
     Redefined here to avoid gcc 3.x warning

TXMLStackObj* PushStack(xmlNodePointer current, Bool_t simple)

     add new level to xml stack

TXMLStackObj* PopStack()

     remove one level from xml stack

TXMLStackObj* Stack(Int_t depth)

     return xml stack object of specified depth

xmlNodePointer StackNode()

     return pointer on current xml node

void ShiftStack(const char* errinfo)

     shift stack node to next

void XmlWriteBlock(xmlNodePointer node)

     write binary data block from buffer to xml
     this data can be produced only by direct call of TBuffer::WriteBuf() functions

void XmlReadBlock(xmlNodePointer blocknode)

     read binary block of data from xml

Bool_t ProcessPointer(const void* ptr, xmlNodePointer node)

     Add "ptr" attribute to node, if ptr is null or
     if ptr is pointer on object, which is already saved in buffer
     Automatically add "ref" attribute to node, where referenced object is stored

void RegisterPointer(const void* ptr, xmlNodePointer node)

     Register pair of object pointer and node, where this object is saved,
     in object map

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

     Searches for "ptr" attribute and returns pointer to object and class,
     if "ptr" attribute reference to read object

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

     Analyse, if node has "ref" attribute and register it to object map

Bool_t VerifyNode(xmlNodePointer node, const char* name, const char* errinfo)

     check, if node has specified name

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

     check, if stack node has specified name

Bool_t VerifyAttr(xmlNodePointer node, const char* name, const char* value, const char* errinfo)

     checks, that attribute of specified name exists and has specified value

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

     checks stack attribute

xmlNodePointer CreateItemNode(const char* name)

     create item node of specified name

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

     checks, if stack node is item and has specified name

void CreateElemNode(const TStreamerElement* elem, Int_t number)

     create xml node correspondent to TStreamerElement object

Bool_t VerifyElemNode(const TStreamerElement* elem, Int_t number)

     Checks, if stack node correspond to TStreamerElement object

xmlNodePointer XmlWriteObject(const void* obj, const TClass* cl)

     Write object to buffer
     If object was written before, only pointer will be stored
     Return pointer to top xml node, representing object

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

     Read object from the buffer

void IncrementLevel(TStreamerInfo* info)

     Function is called from TStreamerInfo WriteBuffer and Readbuffer functions
     and indent new level in xml structure.
     This call indicates, that TStreamerInfo functions starts streaming
     object data of correspondent class

void DecrementLevel(TStreamerInfo* info)

     Function is called from TStreamerInfo WriteBuffer and Readbuffer functions
     and decrease level in xml structure.

void SetStreamerElementNumber(Int_t number)

void PerformPostProcessing()

     Function is converts TObject and TString structures to more compact representation

void PerformPreProcessing(const TStreamerElement* elem, xmlNodePointer elemnode)

     Function is unpack TObject and TString structures to be able read
     them from custom streamers of this objects

void BeforeIOoperation()

     Function is called before any IO operation of TBuffer
     Now is used to store version value if no proper calls are discovered

TClass* ReadClass(const TClass*, UInt_t*)

     suppressed function of TBuffer

void WriteClass(const TClass*)

     suppressed function of TBuffer

Int_t CheckByteCount(UInt_t /*r_s */, UInt_t /*r_c*/, const TClass* /*cl*/)

     suppressed function of TBuffer

Int_t CheckByteCount(UInt_t, UInt_t, const char*)

     suppressed function of TBuffer

void SetByteCount(UInt_t, Bool_t)

     suppressed function of TBuffer

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

     read version value from buffer

void CheckVersionBuf()

     checks buffer, filled by WriteVersion
     if next data is arriving, version should be stored in buffer

UInt_t WriteVersion(const TClass *cl, Bool_t /* useBcnt */)

     Copies class version to buffer, but not writes it to xml
     Version will be written with next I/O operation or
     will be added as attribute of class tag, created by IncrementLevel call

void* ReadObjectAny(const TClass*)

     Read object from buffer. Only used from TBuffer

void SkipObjectAny()

     Skip any kind of object from buffer

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

     Write object to buffer. Only used from TBuffer

void ReadDouble32 (Double_t * /*d*/, TStreamerElement * /*ele*/)

     read a Double32_t from the buffer
    if (factor != 0) {
       UInt_t aint; b >> aint; d[0] = (Double_t)(aint/factor + xmin);
    } else {
       Float_t afloat; b >> afloat; d[0] = (Double_t)afloat;
    }

void WriteDouble32 (Double_t * /*d*/, TStreamerElement * /*ele*/)

     write a Double32_t to the buffer
    if (factor != 0) {
       UInt_t aint = UInt_t(0.5+factor*(d[0]-xmin)); b << aint;
    } else {
       Float_t afloat = (Float_t)d[0]; b << afloat;
    }

Int_t ReadArray(Bool_t *&b)

     Read array of Bool_t from buffer

Int_t ReadArray(Char_t *&c)

     Read array of Char_t from buffer

Int_t ReadArray(UChar_t *&c)

     Read array of UChar_t from buffer

Int_t ReadArray(Short_t *&h)

     Read array of Short_t from buffer

Int_t ReadArray(UShort_t *&h)

     Read array of UShort_t from buffer

Int_t ReadArray(Int_t *&i)

     Read array of Int_t from buffer

Int_t ReadArray(UInt_t *&i)

     Read array of UInt_t from buffer

Int_t ReadArray(Long_t *&l)

     Read array of Long_t from buffer

Int_t ReadArray(ULong_t *&l)

     Read array of ULong_t from buffer

Int_t ReadArray(Long64_t *&l)

     Read array of Long64_t from buffer

Int_t ReadArray(ULong64_t *&l)

     Read array of ULong64_t from buffer

Int_t ReadArray(Float_t *&f)

     Read array of Float_t from buffer

Int_t ReadArray(Double_t *&d)

     Read array of Double_t from buffer

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

     Read array of Double32_t from buffer

Int_t ReadStaticArray(Bool_t *b)

     Read array of Bool_t from buffer

Int_t ReadStaticArray(Char_t *c)

     Read array of Char_t from buffer

Int_t ReadStaticArray(UChar_t *c)

     Read array of UChar_t from buffer

Int_t ReadStaticArray(Short_t *h)

     Read array of Short_t from buffer

Int_t ReadStaticArray(UShort_t *h)

     Read array of UShort_t from buffer

Int_t ReadStaticArray(Int_t *i)

     Read array of Int_t from buffer

Int_t ReadStaticArray(UInt_t *i)

     Read array of UInt_t from buffer

Int_t ReadStaticArray(Long_t *l)

     Read array of Long_t from buffer

Int_t ReadStaticArray(ULong_t *l)

     Read array of ULong_t from buffer

Int_t ReadStaticArray(Long64_t *l)

     Read array of Long64_t from buffer

Int_t ReadStaticArray(ULong64_t *l)

     Read array of ULong64_t from buffer

Int_t ReadStaticArray(Float_t *f)

     Read array of Float_t from buffer

Int_t ReadStaticArray(Double_t *d)

     Read array of Double_t from buffer

Int_t ReadStaticArrayDouble32(Double_t *d, TStreamerElement * /*ele*/)

     Read array of Double32_t from buffer

void ReadFastArray(Bool_t *b, Int_t n)

     read array of Bool_t from buffer

void ReadFastArray(Char_t *c, Int_t n)

     read array of Char_t from buffer
     if nodename==CharStar, read all array as string

void ReadFastArray(UChar_t *c, Int_t n)

     read array of UChar_t from buffer

void ReadFastArray(Short_t *h, Int_t n)

     read array of Short_t from buffer

void ReadFastArray(UShort_t *h, Int_t n)

     read array of UShort_t from buffer

void ReadFastArray(Int_t *i, Int_t n)

     read array of Int_t from buffer

void ReadFastArray(UInt_t *i, Int_t n)

     read array of UInt_t from buffer

void ReadFastArray(Long_t *l, Int_t n)

     read array of Long_t from buffer

void ReadFastArray(ULong_t *l, Int_t n)

     read array of ULong_t from buffer

void ReadFastArray(Long64_t *l, Int_t n)

     read array of Long64_t from buffer

void ReadFastArray(ULong64_t *l, Int_t n)

     read array of ULong64_t from buffer

void ReadFastArray(Float_t *f, Int_t n)

     read array of Float_t from buffer

void ReadFastArray(Double_t *d, Int_t n)

     read array of Double_t from buffer

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

     read array of Double32_t from buffer

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

     redefined here to avoid warning message from gcc

void ReadFastArray(void **startp, const TClass *cl, Int_t n, Bool_t isPreAlloc, TMemberStreamer *s)

     redefined here to avoid warning message from gcc

void WriteArray(const Bool_t *b, Int_t n)

     Write array of Bool_t to buffer

void WriteArray(const Char_t *c, Int_t n)

     Write array of Char_t to buffer

void WriteArray(const UChar_t *c, Int_t n)

     Write array of UChar_t to buffer

void WriteArray(const Short_t *h, Int_t n)

     Write array of Short_t to buffer

void WriteArray(const UShort_t *h, Int_t n)

     Write array of UShort_t to buffer

void WriteArray(const Int_t *i, Int_t n)

     Write array of Int_ to buffer

void WriteArray(const UInt_t *i, Int_t n)

     Write array of UInt_t to buffer

void WriteArray(const Long_t *l, Int_t n)

     Write array of Long_t to buffer

void WriteArray(const ULong_t *l, Int_t n)

     Write array of ULong_t to buffer

void WriteArray(const Long64_t *l, Int_t n)

     Write array of Long64_t to buffer

void WriteArray(const ULong64_t *l, Int_t n)

     Write array of ULong64_t to buffer

void WriteArray(const Float_t *f, Int_t n)

     Write array of Float_t to buffer

void WriteArray(const Double_t *d, Int_t n)

     Write array of Double_t to buffer

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

     Write array of Double32_t to buffer

void WriteFastArray(const Bool_t *b, Int_t n)

     Write array of Bool_t to buffer

void WriteFastArray(const Char_t *c, Int_t n)

     Write array of Char_t to buffer
     If array does not include any special characters,
     it will be reproduced as CharStar node with string as attribute

void WriteFastArray(const UChar_t *c, Int_t n)

     Write array of UChar_t to buffer

void WriteFastArray(const Short_t *h, Int_t n)

     Write array of Short_t to buffer

void WriteFastArray(const UShort_t *h, Int_t n)

     Write array of UShort_t to buffer

void WriteFastArray(const Int_t *i, Int_t n)

     Write array of Int_t to buffer

void WriteFastArray(const UInt_t *i, Int_t n)

     Write array of UInt_t to buffer

void WriteFastArray(const Long_t *l, Int_t n)

     Write array of Long_t to buffer

void WriteFastArray(const ULong_t *l, Int_t n)

     Write array of ULong_t to buffer

void WriteFastArray(const Long64_t *l, Int_t n)

     Write array of Long64_t to buffer

void WriteFastArray(const ULong64_t *l, Int_t n)

     Write array of ULong64_t to buffer

void WriteFastArray(const Float_t *f, Int_t n)

     Write array of Float_t to buffer

void WriteFastArray(const Double_t *d, Int_t n)

     Write array of Double_t to buffer

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

     Write array of Double32_t to buffer

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

     Recall TBuffer function to avoid gcc warning message

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

     Recall TBuffer function to avoid gcc warning message

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

     steram object to/from buffer

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

     steram object to/from buffer

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

     steram object to/from buffer

xmlNodePointer XmlWriteBasic(Char_t value)

     converts Char_t to string and add xml node to buffer

xmlNodePointer XmlWriteBasic(Short_t value)

     converts Short_t to string and add xml node to buffer

xmlNodePointer XmlWriteBasic(Int_t value)

     converts Int_t to string and add xml node to buffer

xmlNodePointer XmlWriteBasic(Long_t value)

     converts Long_t to string and add xml node to buffer

xmlNodePointer XmlWriteBasic(Long64_t value)

     converts Long64_t to string and add xml node to buffer

xmlNodePointer XmlWriteBasic(Float_t value)

     converts Float_t to string and add xml node to buffer

xmlNodePointer XmlWriteBasic(Double_t value)

     converts Double_t to string and add xml node to buffer

xmlNodePointer XmlWriteBasic(Bool_t value)

     converts Bool_t to string and add xml node to buffer

xmlNodePointer XmlWriteBasic(UChar_t value)

     converts UChar_t to string and add xml node to buffer

xmlNodePointer XmlWriteBasic(UShort_t value)

     converts UShort_t to string and add xml node to buffer

xmlNodePointer XmlWriteBasic(UInt_t value)

     converts UInt_t to string and add xml node to buffer

xmlNodePointer XmlWriteBasic(ULong_t value)

     converts ULong_t to string and add xml node to buffer

xmlNodePointer XmlWriteBasic(ULong64_t value)

     converts ULong64_t to string and add xml node to buffer

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

     create xml node with specified name and adds it to stack node

void XmlReadBasic(Char_t& value)

     reads string from current xml node and convert it to Char_t value

void XmlReadBasic(Short_t& value)

     reads string from current xml node and convert it to Short_t value

void XmlReadBasic(Int_t& value)

     reads string from current xml node and convert it to Int_t value

void XmlReadBasic(Long_t& value)

     reads string from current xml node and convert it to Long_t value

void XmlReadBasic(Long64_t& value)

     reads string from current xml node and convert it to Long64_t value

void XmlReadBasic(Float_t& value)

     reads string from current xml node and convert it to Float_t value

void XmlReadBasic(Double_t& value)

     reads string from current xml node and convert it to Double_t value

void XmlReadBasic(Bool_t& value)

     reads string from current xml node and convert it to Bool_t value

void XmlReadBasic(UChar_t& value)

     reads string from current xml node and convert it to UChar_t value

void XmlReadBasic(UShort_t& value)

     reads string from current xml node and convert it to UShort_t value

void XmlReadBasic(UInt_t& value)

     reads string from current xml node and convert it to UInt_t value

void XmlReadBasic(ULong_t& value)

     reads string from current xml node and convert it to ULong_t value

void XmlReadBasic(ULong64_t& value)

     reads string from current xml node and convert it to ULong64_t value

const char* XmlReadValue(const char* name)

     read string value from current stack node

### Inline Functions

                   void SetCompressionLevel(int level)
                   void SetXML(TXMLEngine* xml)
               TBuffer& operator>>(Bool_t& b)
               TBuffer& operator>>(Char_t& c)
               TBuffer& operator>>(UChar_t& c)
               TBuffer& operator>>(Short_t& h)
               TBuffer& operator>>(UShort_t& h)
               TBuffer& operator>>(Int_t& i)
               TBuffer& operator>>(UInt_t& i)
               TBuffer& operator>>(Long_t& l)
               TBuffer& operator>>(ULong_t& l)
               TBuffer& operator>>(Long64_t& l)
               TBuffer& operator>>(ULong64_t& l)
               TBuffer& operator>>(Float_t& f)
               TBuffer& operator>>(Double_t& d)
               TBuffer& operator>>(Char_t* c)
               TBuffer& operator<<(Bool_t b)
               TBuffer& operator<<(Char_t c)
               TBuffer& operator<<(UChar_t c)
               TBuffer& operator<<(Short_t h)
               TBuffer& operator<<(UShort_t h)
               TBuffer& operator<<(Int_t i)
               TBuffer& operator<<(UInt_t i)
               TBuffer& operator<<(Long_t l)
               TBuffer& operator<<(ULong_t l)
               TBuffer& operator<<(Long64_t l)
               TBuffer& operator<<(ULong64_t l)
               TBuffer& operator<<(Float_t f)
               TBuffer& operator<<(Double_t d)
               TBuffer& operator<<(const Char_t* c)
                TClass* Class()
                TClass* IsA() const
                   void ShowMembers(TMemberInspector& insp, char* parent)
                   void Streamer(TBuffer& b)
                   void StreamerNVirtual(TBuffer& b)

Author: Sergey Linev, Rene Brun 10.05.2004
Last update: root/xml:$Name: $:$Id: TBufferXML.cxx,v 1.1 2005/05/06 14:25:34 brun Exp $
Copyright (C) 1995-2004, Rene Brun and Fons Rademakers. *