// @(#)root/xml:$Id: d90d66e8fd2aa9daa4b05bcba9166aee1e2b2e7f $
// Author: Sergey Linev  10.05.2004

/*************************************************************************
 * Copyright (C) 1995-2004, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/

#ifndef ROOT_TBufferXML
#define ROOT_TBufferXML

#ifndef ROOT_TBufferFile
#include "TBufferFile.h"
#endif
#ifndef ROOT_TXMLSetup
#include "TXMLSetup.h"
#endif
#ifndef ROOT_TXMLEngine
#include "TXMLEngine.h"
#endif
#ifndef ROOT_TString
#include "TString.h"
#endif
#ifndef ROOT_TObjArray
#include "TObjArray.h"
#endif

#include <string>


class TExMap;
class TVirtualStreamerInfo;
class TStreamerInfo;
class TStreamerElement;
class TObjArray;
class TMemberStreamer;
class TXMLFile;
class TXMLStackObj;


class TBufferXML : public TBufferFile, public TXMLSetup {

friend class TKeyXML;

public:

   TBufferXML(TBuffer::EMode mode);
   TBufferXML(TBuffer::EMode mode, TXMLFile* file);
   virtual ~TBufferXML();

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

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

   virtual TClass*  ReadClass(const TClass* cl = 0, UInt_t* objTag = 0);
   virtual void     WriteClass(const TClass* cl);

   // redefined virtual functions of TBuffer

   virtual Int_t    CheckByteCount(UInt_t startpos, UInt_t bcnt, const TClass *clss); // SL
   virtual Int_t    CheckByteCount(UInt_t startpos, UInt_t bcnt, const char *classname); // SL
   virtual void     SetByteCount(UInt_t cntpos, Bool_t packInVersion = kFALSE);  // SL

   virtual void      SkipVersion(const TClass *cl = 0);
   virtual Version_t ReadVersion(UInt_t *start = 0, UInt_t *bcnt = 0, const TClass *cl = 0);  // SL
   virtual UInt_t    WriteVersion(const TClass *cl, Bool_t useBcnt = kFALSE);  // SL

   virtual void*    ReadObjectAny(const TClass* clCast);
   virtual void     SkipObjectAny();

   virtual void     IncrementLevel(TVirtualStreamerInfo*);
   virtual void     SetStreamerElementNumber(TStreamerElement *elem, Int_t comp_type);
   virtual void     DecrementLevel(TVirtualStreamerInfo*);

   virtual void     ClassBegin(const TClass*, Version_t = -1);
   virtual void     ClassEnd(const TClass*);
   virtual void     ClassMember(const char* name, const char* typeName = 0, Int_t arrsize1 = -1, Int_t arrsize2 = -1);

   virtual void     WriteObject(const TObject *obj);

   virtual void     ReadFloat16 (Float_t *f, TStreamerElement *ele=0);
   virtual void     WriteFloat16(Float_t *f, TStreamerElement *ele=0);
   virtual void     ReadDouble32 (Double_t *d, TStreamerElement *ele=0);
   virtual void     WriteDouble32(Double_t *d, TStreamerElement *ele=0);
   virtual void     ReadWithFactor(Float_t *ptr, Double_t factor, Double_t minvalue);
   virtual void     ReadWithNbits(Float_t *ptr, Int_t nbits);
   virtual void     ReadWithFactor(Double_t *ptr, Double_t factor, Double_t minvalue);
   virtual void     ReadWithNbits(Double_t *ptr, Int_t nbits);

   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    ReadArrayFloat16(Float_t  *&f, TStreamerElement *ele=0);
   virtual Int_t    ReadArrayDouble32(Double_t  *&d, TStreamerElement *ele=0);

   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    ReadStaticArrayFloat16(Float_t  *f, TStreamerElement *ele=0);
   virtual Int_t    ReadStaticArrayDouble32(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     ReadFastArrayFloat16(Float_t  *f, Int_t n, TStreamerElement *ele=0);
   virtual void     ReadFastArrayDouble32(Double_t  *d, Int_t n, TStreamerElement *ele=0);
   virtual void     ReadFastArrayWithFactor(Float_t *ptr, Int_t n, Double_t factor, Double_t minvalue) ;
   virtual void     ReadFastArrayWithNbits(Float_t *ptr, Int_t n, Int_t nbits);
   virtual void     ReadFastArrayWithFactor(Double_t *ptr, Int_t n, Double_t factor, Double_t minvalue);
   virtual void     ReadFastArrayWithNbits(Double_t *ptr, Int_t n, Int_t nbits) ;

   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     WriteArrayFloat16(const Float_t  *f, Int_t n, TStreamerElement *ele=0);
   virtual void     WriteArrayDouble32(const Double_t  *d, Int_t n, TStreamerElement *ele=0);
   virtual void     ReadFastArray(void  *start , const TClass *cl, Int_t n=1, TMemberStreamer *s=0, const TClass* onFileClass = 0);
   virtual void     ReadFastArray(void **startp, const TClass *cl, Int_t n=1, Bool_t isPreAlloc=kFALSE, TMemberStreamer *s=0, const TClass* onFileClass = 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     WriteFastArrayFloat16(const Float_t  *d, Int_t n, TStreamerElement *ele=0);
   virtual void     WriteFastArrayDouble32(const Double_t  *d, Int_t n, TStreamerElement *ele=0);
   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     StreamObject(void *obj, const type_info &typeinfo, const TClass* onFileClass = 0);
   virtual void     StreamObject(void *obj, const char *className, const TClass* onFileClass = 0 );
   virtual void     StreamObject(void *obj, const TClass *cl, const TClass* onFileClass = 0 );
   virtual void     StreamObject(TObject *obj);

   virtual   void     ReadBool(Bool_t       &b);
   virtual   void     ReadChar(Char_t       &c);
   virtual   void     ReadUChar(UChar_t     &c);
   virtual   void     ReadShort(Short_t     &s);
   virtual   void     ReadUShort(UShort_t   &s);
   virtual   void     ReadInt(Int_t         &i);
   virtual   void     ReadUInt(UInt_t       &i);
   virtual   void     ReadLong(Long_t       &l);
   virtual   void     ReadULong(ULong_t     &l);
   virtual   void     ReadLong64(Long64_t   &l);
   virtual   void     ReadULong64(ULong64_t &l);
   virtual   void     ReadFloat(Float_t     &f);
   virtual   void     ReadDouble(Double_t   &d);
   virtual   void     ReadCharP(Char_t      *c);
   virtual   void     ReadTString(TString   &s);

   virtual   void     WriteBool(Bool_t       b);
   virtual   void     WriteChar(Char_t       c);
   virtual   void     WriteUChar(UChar_t     c);
   virtual   void     WriteShort(Short_t     s);
   virtual   void     WriteUShort(UShort_t   s);
   virtual   void     WriteInt(Int_t         i);
   virtual   void     WriteUInt(UInt_t       i);
   virtual   void     WriteLong(Long_t       l);
   virtual   void     WriteULong(ULong_t     l);
   virtual   void     WriteLong64(Long64_t   l);
   virtual   void     WriteULong64(ULong64_t l);
   virtual   void     WriteFloat(Float_t     f);
   virtual   void     WriteDouble(Double_t   d);
   virtual   void     WriteCharP(const Char_t *c);
   virtual   void     WriteTString(const TString  &s);

   virtual Int_t ApplySequence(const TStreamerInfoActions::TActionSequence &sequence, void *object);
   virtual Int_t ApplySequenceVecPtr(const TStreamerInfoActions::TActionSequence &sequence, void *start_collection, void *end_collection);
   virtual Int_t ApplySequence(const TStreamerInfoActions::TActionSequence &sequence, void *start_collection, void *end_collection);

   // end of redefined virtual functions

   static    void     SetFloatFormat(const char* fmt = "%e");
   static const char* GetFloatFormat();


protected:
   TBufferXML();

   // redefined protected virtual functions

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

   // end redefined protected virtual functions

   TXMLFile*        XmlFile();

   Int_t            GetCompressionAlgorithm() const;
   Int_t            GetCompressionLevel() const;
   Int_t            GetCompressionSettings() const;
   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();
   TXMLStackObj*    Stack(Int_t depth = 0);

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

   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;        //!   compression level and algorithm

   static std::string fgFloatFmt;          //!  printf argument for floats and doubles, either "%f" or "%e" or "%10f" and so on

ClassDef(TBufferXML,1) //a specialized TBuffer to read/write to XML files
};

//______________________________________________________________________________
inline Int_t TBufferXML::GetCompressionAlgorithm() const
{
   return (fCompressLevel < 0) ? -1 : fCompressLevel / 100;
}

//______________________________________________________________________________
inline Int_t TBufferXML::GetCompressionLevel() const
{
   return (fCompressLevel < 0) ? -1 : fCompressLevel % 100;
}

//______________________________________________________________________________
inline Int_t TBufferXML::GetCompressionSettings() const
{
   return (fCompressLevel < 0) ? -1 : fCompressLevel;
}

#endif


 TBufferXML.h:1
 TBufferXML.h:2
 TBufferXML.h:3
 TBufferXML.h:4
 TBufferXML.h:5
 TBufferXML.h:6
 TBufferXML.h:7
 TBufferXML.h:8
 TBufferXML.h:9
 TBufferXML.h:10
 TBufferXML.h:11
 TBufferXML.h:12
 TBufferXML.h:13
 TBufferXML.h:14
 TBufferXML.h:15
 TBufferXML.h:16
 TBufferXML.h:17
 TBufferXML.h:18
 TBufferXML.h:19
 TBufferXML.h:20
 TBufferXML.h:21
 TBufferXML.h:22
 TBufferXML.h:23
 TBufferXML.h:24
 TBufferXML.h:25
 TBufferXML.h:26
 TBufferXML.h:27
 TBufferXML.h:28
 TBufferXML.h:29
 TBufferXML.h:30
 TBufferXML.h:31
 TBufferXML.h:32
 TBufferXML.h:33
 TBufferXML.h:34
 TBufferXML.h:35
 TBufferXML.h:36
 TBufferXML.h:37
 TBufferXML.h:38
 TBufferXML.h:39
 TBufferXML.h:40
 TBufferXML.h:41
 TBufferXML.h:42
 TBufferXML.h:43
 TBufferXML.h:44
 TBufferXML.h:45
 TBufferXML.h:46
 TBufferXML.h:47
 TBufferXML.h:48
 TBufferXML.h:49
 TBufferXML.h:50
 TBufferXML.h:51
 TBufferXML.h:52
 TBufferXML.h:53
 TBufferXML.h:54
 TBufferXML.h:55
 TBufferXML.h:56
 TBufferXML.h:57
 TBufferXML.h:58
 TBufferXML.h:59
 TBufferXML.h:60
 TBufferXML.h:61
 TBufferXML.h:62
 TBufferXML.h:63
 TBufferXML.h:64
 TBufferXML.h:65
 TBufferXML.h:66
 TBufferXML.h:67
 TBufferXML.h:68
 TBufferXML.h:69
 TBufferXML.h:70
 TBufferXML.h:71
 TBufferXML.h:72
 TBufferXML.h:73
 TBufferXML.h:74
 TBufferXML.h:75
 TBufferXML.h:76
 TBufferXML.h:77
 TBufferXML.h:78
 TBufferXML.h:79
 TBufferXML.h:80
 TBufferXML.h:81
 TBufferXML.h:82
 TBufferXML.h:83
 TBufferXML.h:84
 TBufferXML.h:85
 TBufferXML.h:86
 TBufferXML.h:87
 TBufferXML.h:88
 TBufferXML.h:89
 TBufferXML.h:90
 TBufferXML.h:91
 TBufferXML.h:92
 TBufferXML.h:93
 TBufferXML.h:94
 TBufferXML.h:95
 TBufferXML.h:96
 TBufferXML.h:97
 TBufferXML.h:98
 TBufferXML.h:99
 TBufferXML.h:100
 TBufferXML.h:101
 TBufferXML.h:102
 TBufferXML.h:103
 TBufferXML.h:104
 TBufferXML.h:105
 TBufferXML.h:106
 TBufferXML.h:107
 TBufferXML.h:108
 TBufferXML.h:109
 TBufferXML.h:110
 TBufferXML.h:111
 TBufferXML.h:112
 TBufferXML.h:113
 TBufferXML.h:114
 TBufferXML.h:115
 TBufferXML.h:116
 TBufferXML.h:117
 TBufferXML.h:118
 TBufferXML.h:119
 TBufferXML.h:120
 TBufferXML.h:121
 TBufferXML.h:122
 TBufferXML.h:123
 TBufferXML.h:124
 TBufferXML.h:125
 TBufferXML.h:126
 TBufferXML.h:127
 TBufferXML.h:128
 TBufferXML.h:129
 TBufferXML.h:130
 TBufferXML.h:131
 TBufferXML.h:132
 TBufferXML.h:133
 TBufferXML.h:134
 TBufferXML.h:135
 TBufferXML.h:136
 TBufferXML.h:137
 TBufferXML.h:138
 TBufferXML.h:139
 TBufferXML.h:140
 TBufferXML.h:141
 TBufferXML.h:142
 TBufferXML.h:143
 TBufferXML.h:144
 TBufferXML.h:145
 TBufferXML.h:146
 TBufferXML.h:147
 TBufferXML.h:148
 TBufferXML.h:149
 TBufferXML.h:150
 TBufferXML.h:151
 TBufferXML.h:152
 TBufferXML.h:153
 TBufferXML.h:154
 TBufferXML.h:155
 TBufferXML.h:156
 TBufferXML.h:157
 TBufferXML.h:158
 TBufferXML.h:159
 TBufferXML.h:160
 TBufferXML.h:161
 TBufferXML.h:162
 TBufferXML.h:163
 TBufferXML.h:164
 TBufferXML.h:165
 TBufferXML.h:166
 TBufferXML.h:167
 TBufferXML.h:168
 TBufferXML.h:169
 TBufferXML.h:170
 TBufferXML.h:171
 TBufferXML.h:172
 TBufferXML.h:173
 TBufferXML.h:174
 TBufferXML.h:175
 TBufferXML.h:176
 TBufferXML.h:177
 TBufferXML.h:178
 TBufferXML.h:179
 TBufferXML.h:180
 TBufferXML.h:181
 TBufferXML.h:182
 TBufferXML.h:183
 TBufferXML.h:184
 TBufferXML.h:185
 TBufferXML.h:186
 TBufferXML.h:187
 TBufferXML.h:188
 TBufferXML.h:189
 TBufferXML.h:190
 TBufferXML.h:191
 TBufferXML.h:192
 TBufferXML.h:193
 TBufferXML.h:194
 TBufferXML.h:195
 TBufferXML.h:196
 TBufferXML.h:197
 TBufferXML.h:198
 TBufferXML.h:199
 TBufferXML.h:200
 TBufferXML.h:201
 TBufferXML.h:202
 TBufferXML.h:203
 TBufferXML.h:204
 TBufferXML.h:205
 TBufferXML.h:206
 TBufferXML.h:207
 TBufferXML.h:208
 TBufferXML.h:209
 TBufferXML.h:210
 TBufferXML.h:211
 TBufferXML.h:212
 TBufferXML.h:213
 TBufferXML.h:214
 TBufferXML.h:215
 TBufferXML.h:216
 TBufferXML.h:217
 TBufferXML.h:218
 TBufferXML.h:219
 TBufferXML.h:220
 TBufferXML.h:221
 TBufferXML.h:222
 TBufferXML.h:223
 TBufferXML.h:224
 TBufferXML.h:225
 TBufferXML.h:226
 TBufferXML.h:227
 TBufferXML.h:228
 TBufferXML.h:229
 TBufferXML.h:230
 TBufferXML.h:231
 TBufferXML.h:232
 TBufferXML.h:233
 TBufferXML.h:234
 TBufferXML.h:235
 TBufferXML.h:236
 TBufferXML.h:237
 TBufferXML.h:238
 TBufferXML.h:239
 TBufferXML.h:240
 TBufferXML.h:241
 TBufferXML.h:242
 TBufferXML.h:243
 TBufferXML.h:244
 TBufferXML.h:245
 TBufferXML.h:246
 TBufferXML.h:247
 TBufferXML.h:248
 TBufferXML.h:249
 TBufferXML.h:250
 TBufferXML.h:251
 TBufferXML.h:252
 TBufferXML.h:253
 TBufferXML.h:254
 TBufferXML.h:255
 TBufferXML.h:256
 TBufferXML.h:257
 TBufferXML.h:258
 TBufferXML.h:259
 TBufferXML.h:260
 TBufferXML.h:261
 TBufferXML.h:262
 TBufferXML.h:263
 TBufferXML.h:264
 TBufferXML.h:265
 TBufferXML.h:266
 TBufferXML.h:267
 TBufferXML.h:268
 TBufferXML.h:269
 TBufferXML.h:270
 TBufferXML.h:271
 TBufferXML.h:272
 TBufferXML.h:273
 TBufferXML.h:274
 TBufferXML.h:275
 TBufferXML.h:276
 TBufferXML.h:277
 TBufferXML.h:278
 TBufferXML.h:279
 TBufferXML.h:280
 TBufferXML.h:281
 TBufferXML.h:282
 TBufferXML.h:283
 TBufferXML.h:284
 TBufferXML.h:285
 TBufferXML.h:286
 TBufferXML.h:287
 TBufferXML.h:288
 TBufferXML.h:289
 TBufferXML.h:290
 TBufferXML.h:291
 TBufferXML.h:292
 TBufferXML.h:293
 TBufferXML.h:294
 TBufferXML.h:295
 TBufferXML.h:296
 TBufferXML.h:297
 TBufferXML.h:298
 TBufferXML.h:299
 TBufferXML.h:300
 TBufferXML.h:301
 TBufferXML.h:302
 TBufferXML.h:303
 TBufferXML.h:304
 TBufferXML.h:305
 TBufferXML.h:306
 TBufferXML.h:307
 TBufferXML.h:308
 TBufferXML.h:309
 TBufferXML.h:310
 TBufferXML.h:311
 TBufferXML.h:312
 TBufferXML.h:313
 TBufferXML.h:314
 TBufferXML.h:315
 TBufferXML.h:316
 TBufferXML.h:317
 TBufferXML.h:318
 TBufferXML.h:319
 TBufferXML.h:320
 TBufferXML.h:321
 TBufferXML.h:322
 TBufferXML.h:323
 TBufferXML.h:324
 TBufferXML.h:325
 TBufferXML.h:326
 TBufferXML.h:327
 TBufferXML.h:328
 TBufferXML.h:329
 TBufferXML.h:330
 TBufferXML.h:331
 TBufferXML.h:332
 TBufferXML.h:333
 TBufferXML.h:334
 TBufferXML.h:335
 TBufferXML.h:336
 TBufferXML.h:337
 TBufferXML.h:338
 TBufferXML.h:339
 TBufferXML.h:340
 TBufferXML.h:341
 TBufferXML.h:342
 TBufferXML.h:343
 TBufferXML.h:344
 TBufferXML.h:345
 TBufferXML.h:346
 TBufferXML.h:347
 TBufferXML.h:348
 TBufferXML.h:349
 TBufferXML.h:350
 TBufferXML.h:351
 TBufferXML.h:352
 TBufferXML.h:353
 TBufferXML.h:354
 TBufferXML.h:355
 TBufferXML.h:356
 TBufferXML.h:357
 TBufferXML.h:358
 TBufferXML.h:359
 TBufferXML.h:360
 TBufferXML.h:361
 TBufferXML.h:362
 TBufferXML.h:363