TBufferXML.h

Go to the documentation of this file.
00001 // @(#)root/xml:$Id: TBufferXML.h 36061 2010-10-04 16:05:51Z pcanal $
00002 // Author: Sergey Linev  10.05.2004
00003 
00004 /*************************************************************************
00005  * Copyright (C) 1995-2004, Rene Brun and Fons Rademakers.               *
00006  * All rights reserved.                                                  *
00007  *                                                                       *
00008  * For the licensing terms see $ROOTSYS/LICENSE.                         *
00009  * For the list of contributors see $ROOTSYS/README/CREDITS.             *
00010  *************************************************************************/
00011 
00012 #ifndef ROOT_TBufferXML
00013 #define ROOT_TBufferXML
00014 
00015 #ifndef ROOT_TBufferFile
00016 #include "TBufferFile.h"
00017 #endif
00018 #ifndef ROOT_TXMLSetup
00019 #include "TXMLSetup.h"
00020 #endif
00021 #ifndef ROOT_TXMLEngine
00022 #include "TXMLEngine.h"
00023 #endif
00024 #ifndef ROOT_TString
00025 #include "TString.h"
00026 #endif
00027 #ifndef ROOT_TObjArray
00028 #include "TObjArray.h"
00029 #endif
00030 
00031 
00032 class TExMap;
00033 class TVirtualStreamerInfo;
00034 class TStreamerInfo;
00035 class TStreamerElement;
00036 class TObjArray;
00037 class TMemberStreamer;
00038 class TXMLFile;
00039 class TXMLStackObj;
00040 
00041 
00042 class TBufferXML : public TBufferFile, public TXMLSetup {
00043    
00044 friend class TKeyXML;   
00045    
00046 public:
00047 
00048    TBufferXML(TBuffer::EMode mode);
00049    TBufferXML(TBuffer::EMode mode, TXMLFile* file);
00050    virtual ~TBufferXML();
00051 
00052    static TString   ConvertToXML(TObject* obj, Bool_t GenericLayout = kFALSE, Bool_t UseNamespaces = kFALSE);
00053    static TString   ConvertToXML(void* obj, TClass* cl, Bool_t GenericLayout = kFALSE, Bool_t UseNamespaces = kFALSE);
00054    
00055    static TObject*  ConvertFromXML(const char* str, Bool_t GenericLayout = kFALSE, Bool_t UseNamespaces = kFALSE);   
00056    static void*     ConvertFromXMLAny(const char* str, TClass** cl = 0, Bool_t GenericLayout = kFALSE, Bool_t UseNamespaces = kFALSE);
00057    
00058    // suppress class writing/reading
00059 
00060    virtual TClass*  ReadClass(const TClass* cl = 0, UInt_t* objTag = 0);
00061    virtual void     WriteClass(const TClass* cl);
00062 
00063    // redefined virtual functions of TBuffer
00064 
00065    virtual Int_t    CheckByteCount(UInt_t startpos, UInt_t bcnt, const TClass *clss); // SL
00066    virtual Int_t    CheckByteCount(UInt_t startpos, UInt_t bcnt, const char *classname); // SL
00067    virtual void     SetByteCount(UInt_t cntpos, Bool_t packInVersion = kFALSE);  // SL
00068 
00069    virtual void      SkipVersion(const TClass *cl = 0);
00070    virtual Version_t ReadVersion(UInt_t *start = 0, UInt_t *bcnt = 0, const TClass *cl = 0);  // SL
00071    virtual UInt_t    WriteVersion(const TClass *cl, Bool_t useBcnt = kFALSE);  // SL
00072 
00073    virtual void*    ReadObjectAny(const TClass* clCast);
00074    virtual void     SkipObjectAny();
00075 
00076    virtual void     IncrementLevel(TVirtualStreamerInfo*);
00077    virtual void     SetStreamerElementNumber(Int_t);
00078    virtual void     DecrementLevel(TVirtualStreamerInfo*);
00079    
00080    virtual void     ClassBegin(const TClass*, Version_t = -1);
00081    virtual void     ClassEnd(const TClass*);
00082    virtual void     ClassMember(const char* name, const char* typeName = 0, Int_t arrsize1 = -1, Int_t arrsize2 = -1);
00083 
00084    virtual void     WriteObject(const TObject *obj);
00085 
00086    virtual void     ReadFloat16 (Float_t *f, TStreamerElement *ele=0);
00087    virtual void     WriteFloat16(Float_t *f, TStreamerElement *ele=0);
00088    virtual void     ReadDouble32 (Double_t *d, TStreamerElement *ele=0);
00089    virtual void     WriteDouble32(Double_t *d, TStreamerElement *ele=0);
00090    virtual void     ReadWithFactor(Float_t *ptr, Double_t factor, Double_t minvalue);
00091    virtual void     ReadWithNbits(Float_t *ptr, Int_t nbits);
00092    virtual void     ReadWithFactor(Double_t *ptr, Double_t factor, Double_t minvalue);
00093    virtual void     ReadWithNbits(Double_t *ptr, Int_t nbits);
00094    
00095    virtual Int_t    ReadArray(Bool_t    *&b);
00096    virtual Int_t    ReadArray(Char_t    *&c);
00097    virtual Int_t    ReadArray(UChar_t   *&c);
00098    virtual Int_t    ReadArray(Short_t   *&h);
00099    virtual Int_t    ReadArray(UShort_t  *&h);
00100    virtual Int_t    ReadArray(Int_t     *&i);
00101    virtual Int_t    ReadArray(UInt_t    *&i);
00102    virtual Int_t    ReadArray(Long_t    *&l);
00103    virtual Int_t    ReadArray(ULong_t   *&l);
00104    virtual Int_t    ReadArray(Long64_t  *&l);
00105    virtual Int_t    ReadArray(ULong64_t *&l);
00106    virtual Int_t    ReadArray(Float_t   *&f);
00107    virtual Int_t    ReadArray(Double_t  *&d);
00108    virtual Int_t    ReadArrayFloat16(Float_t  *&f, TStreamerElement *ele=0);
00109    virtual Int_t    ReadArrayDouble32(Double_t  *&d, TStreamerElement *ele=0);
00110 
00111    virtual Int_t    ReadStaticArray(Bool_t    *b);
00112    virtual Int_t    ReadStaticArray(Char_t    *c);
00113    virtual Int_t    ReadStaticArray(UChar_t   *c);
00114    virtual Int_t    ReadStaticArray(Short_t   *h);
00115    virtual Int_t    ReadStaticArray(UShort_t  *h);
00116    virtual Int_t    ReadStaticArray(Int_t     *i);
00117    virtual Int_t    ReadStaticArray(UInt_t    *i);
00118    virtual Int_t    ReadStaticArray(Long_t    *l);
00119    virtual Int_t    ReadStaticArray(ULong_t   *l);
00120    virtual Int_t    ReadStaticArray(Long64_t  *l);
00121    virtual Int_t    ReadStaticArray(ULong64_t *l);
00122    virtual Int_t    ReadStaticArray(Float_t   *f);
00123    virtual Int_t    ReadStaticArray(Double_t  *d);
00124    virtual Int_t    ReadStaticArrayFloat16(Float_t  *f, TStreamerElement *ele=0);
00125    virtual Int_t    ReadStaticArrayDouble32(Double_t  *d, TStreamerElement *ele=0);
00126 
00127    virtual void     ReadFastArray(Bool_t    *b, Int_t n);
00128    virtual void     ReadFastArray(Char_t    *c, Int_t n);
00129    virtual void     ReadFastArray(UChar_t   *c, Int_t n);
00130    virtual void     ReadFastArray(Short_t   *h, Int_t n);
00131    virtual void     ReadFastArray(UShort_t  *h, Int_t n);
00132    virtual void     ReadFastArray(Int_t     *i, Int_t n);
00133    virtual void     ReadFastArray(UInt_t    *i, Int_t n);
00134    virtual void     ReadFastArray(Long_t    *l, Int_t n);
00135    virtual void     ReadFastArray(ULong_t   *l, Int_t n);
00136    virtual void     ReadFastArray(Long64_t  *l, Int_t n);
00137    virtual void     ReadFastArray(ULong64_t *l, Int_t n);
00138    virtual void     ReadFastArray(Float_t   *f, Int_t n);
00139    virtual void     ReadFastArray(Double_t  *d, Int_t n);
00140    virtual void     ReadFastArrayFloat16(Float_t  *f, Int_t n, TStreamerElement *ele=0);
00141    virtual void     ReadFastArrayDouble32(Double_t  *d, Int_t n, TStreamerElement *ele=0);
00142 
00143    virtual void     WriteArray(const Bool_t    *b, Int_t n);
00144    virtual void     WriteArray(const Char_t    *c, Int_t n);
00145    virtual void     WriteArray(const UChar_t   *c, Int_t n);
00146    virtual void     WriteArray(const Short_t   *h, Int_t n);
00147    virtual void     WriteArray(const UShort_t  *h, Int_t n);
00148    virtual void     WriteArray(const Int_t     *i, Int_t n);
00149    virtual void     WriteArray(const UInt_t    *i, Int_t n);
00150    virtual void     WriteArray(const Long_t    *l, Int_t n);
00151    virtual void     WriteArray(const ULong_t   *l, Int_t n);
00152    virtual void     WriteArray(const Long64_t  *l, Int_t n);
00153    virtual void     WriteArray(const ULong64_t *l, Int_t n);
00154    virtual void     WriteArray(const Float_t   *f, Int_t n);
00155    virtual void     WriteArray(const Double_t  *d, Int_t n);
00156    virtual void     WriteArrayFloat16(const Float_t  *f, Int_t n, TStreamerElement *ele=0);
00157    virtual void     WriteArrayDouble32(const Double_t  *d, Int_t n, TStreamerElement *ele=0);
00158    virtual void     ReadFastArray(void  *start , const TClass *cl, Int_t n=1, TMemberStreamer *s=0, const TClass* onFileClass = 0);
00159    virtual void     ReadFastArray(void **startp, const TClass *cl, Int_t n=1, Bool_t isPreAlloc=kFALSE, TMemberStreamer *s=0, const TClass* onFileClass = 0);
00160 
00161    virtual void     WriteFastArray(const Bool_t    *b, Int_t n);
00162    virtual void     WriteFastArray(const Char_t    *c, Int_t n);
00163    virtual void     WriteFastArray(const UChar_t   *c, Int_t n);
00164    virtual void     WriteFastArray(const Short_t   *h, Int_t n);
00165    virtual void     WriteFastArray(const UShort_t  *h, Int_t n);
00166    virtual void     WriteFastArray(const Int_t     *i, Int_t n);
00167    virtual void     WriteFastArray(const UInt_t    *i, Int_t n);
00168    virtual void     WriteFastArray(const Long_t    *l, Int_t n);
00169    virtual void     WriteFastArray(const ULong_t   *l, Int_t n);
00170    virtual void     WriteFastArray(const Long64_t  *l, Int_t n);
00171    virtual void     WriteFastArray(const ULong64_t *l, Int_t n);
00172    virtual void     WriteFastArray(const Float_t   *f, Int_t n);
00173    virtual void     WriteFastArray(const Double_t  *d, Int_t n);
00174    virtual void     WriteFastArrayFloat16(const Float_t  *d, Int_t n, TStreamerElement *ele=0);
00175    virtual void     WriteFastArrayDouble32(const Double_t  *d, Int_t n, TStreamerElement *ele=0);
00176    virtual void     WriteFastArray(void  *start,  const TClass *cl, Int_t n=1, TMemberStreamer *s=0);
00177    virtual Int_t    WriteFastArray(void **startp, const TClass *cl, Int_t n=1, Bool_t isPreAlloc=kFALSE, TMemberStreamer *s=0);
00178 
00179    virtual void     StreamObject(void *obj, const type_info &typeinfo, const TClass* onFileClass = 0);
00180    virtual void     StreamObject(void *obj, const char *className, const TClass* onFileClass = 0 );
00181    virtual void     StreamObject(void *obj, const TClass *cl, const TClass* onFileClass = 0 );
00182    virtual void     StreamObject(TObject *obj);
00183 
00184    virtual   void     ReadBool(Bool_t       &b);
00185    virtual   void     ReadChar(Char_t       &c);
00186    virtual   void     ReadUChar(UChar_t     &c);
00187    virtual   void     ReadShort(Short_t     &s);
00188    virtual   void     ReadUShort(UShort_t   &s);
00189    virtual   void     ReadInt(Int_t         &i);
00190    virtual   void     ReadUInt(UInt_t       &i);
00191    virtual   void     ReadLong(Long_t       &l);
00192    virtual   void     ReadULong(ULong_t     &l);
00193    virtual   void     ReadLong64(Long64_t   &l);
00194    virtual   void     ReadULong64(ULong64_t &l);
00195    virtual   void     ReadFloat(Float_t     &f);
00196    virtual   void     ReadDouble(Double_t   &d);
00197    virtual   void     ReadCharP(Char_t      *c);
00198    virtual   void     ReadTString(TString   &s);
00199 
00200    virtual   void     WriteBool(Bool_t       b);
00201    virtual   void     WriteChar(Char_t       c);
00202    virtual   void     WriteUChar(UChar_t     c);
00203    virtual   void     WriteShort(Short_t     s);
00204    virtual   void     WriteUShort(UShort_t   s);
00205    virtual   void     WriteInt(Int_t         i);
00206    virtual   void     WriteUInt(UInt_t       i);
00207    virtual   void     WriteLong(Long_t       l);
00208    virtual   void     WriteULong(ULong_t     l);
00209    virtual   void     WriteLong64(Long64_t   l);
00210    virtual   void     WriteULong64(ULong64_t l);
00211    virtual   void     WriteFloat(Float_t     f);
00212    virtual   void     WriteDouble(Double_t   d);
00213    virtual   void     WriteCharP(const Char_t *c);
00214    virtual   void     WriteTString(const TString  &s);
00215 
00216    virtual Int_t ReadSequence(const TStreamerInfoActions::TActionSequence &sequence, void *object);      
00217    virtual Int_t ReadSequenceVecPtr(const TStreamerInfoActions::TActionSequence &sequence, void *start_collection, void *end_collection);      
00218    virtual Int_t ReadSequence(const TStreamerInfoActions::TActionSequence &sequence, void *start_collection, void *end_collection);
00219 
00220    // end of redefined virtual functions
00221    
00222    static    void     SetFloatFormat(const char* fmt = "%e");
00223    static const char* GetFloatFormat();
00224    
00225 
00226 protected:
00227    TBufferXML();
00228 
00229    // redefined protected virtual functions
00230 
00231    virtual void     WriteObjectClass(const void *actualObjStart, const TClass *actualClass);
00232 
00233    // end redefined protected virtual functions
00234 
00235    TXMLFile*        XmlFile();
00236 
00237    void             SetCompressionLevel(int level) { fCompressLevel = level; }
00238    void             SetXML(TXMLEngine* xml) { fXML = xml; }
00239 
00240    void             XmlWriteBlock(XMLNodePointer_t node);
00241    XMLNodePointer_t XmlWriteAny(const void* obj, const TClass* cl);
00242 
00243    void             XmlReadBlock(XMLNodePointer_t node);
00244    void*            XmlReadAny(XMLNodePointer_t node, void* obj, TClass** cl);
00245 
00246    TXMLStackObj*    PushStack(XMLNodePointer_t current, Bool_t simple = kFALSE);
00247    TXMLStackObj*    PopStack();
00248    void             ShiftStack(const char* info = 0);
00249 
00250    XMLNodePointer_t StackNode();
00251    TXMLStackObj*    Stack(Int_t depth = 0);
00252 
00253    void             WorkWithClass(TStreamerInfo* info, const TClass* cl = 0);
00254    void             WorkWithElement(TStreamerElement* elem, Int_t number);
00255    Bool_t           VerifyNode(XMLNodePointer_t node, const char* name, const char* errinfo = 0);
00256    Bool_t           VerifyStackNode(const char* name, const char* errinfo = 0);
00257    
00258    Bool_t           VerifyAttr(XMLNodePointer_t node, const char* name, const char* value, const char* errinfo = 0);
00259    Bool_t           VerifyStackAttr(const char* name, const char* value, const char* errinfo = 0);
00260 
00261    Bool_t           ProcessPointer(const void* ptr, XMLNodePointer_t node);
00262    void             RegisterPointer(const void* ptr, XMLNodePointer_t node);
00263    Bool_t           ExtractPointer(XMLNodePointer_t node, void* &ptr, TClass* &cl);
00264    void             ExtractReference(XMLNodePointer_t node, const void* ptr, const TClass* cl);
00265 
00266    XMLNodePointer_t CreateItemNode(const char* name);
00267    Bool_t           VerifyItemNode(const char* name, const char* errinfo = 0);
00268 
00269    void             CreateElemNode(const TStreamerElement* elem);
00270    Bool_t           VerifyElemNode(const TStreamerElement* elem);
00271 
00272    void             PerformPreProcessing(const TStreamerElement* elem, XMLNodePointer_t elemnode);
00273    void             PerformPostProcessing();
00274 
00275    XMLNodePointer_t XmlWriteBasic(Char_t value);
00276    XMLNodePointer_t XmlWriteBasic(Short_t value);
00277    XMLNodePointer_t XmlWriteBasic(Int_t value);
00278    XMLNodePointer_t XmlWriteBasic(Long_t value);
00279    XMLNodePointer_t XmlWriteBasic(Long64_t value);
00280    XMLNodePointer_t XmlWriteBasic(Float_t value);
00281    XMLNodePointer_t XmlWriteBasic(Double_t value);
00282    XMLNodePointer_t XmlWriteBasic(Bool_t value);
00283    XMLNodePointer_t XmlWriteBasic(UChar_t value);
00284    XMLNodePointer_t XmlWriteBasic(UShort_t value);
00285    XMLNodePointer_t XmlWriteBasic(UInt_t value);
00286    XMLNodePointer_t XmlWriteBasic(ULong_t value);
00287    XMLNodePointer_t XmlWriteBasic(ULong64_t value);
00288    XMLNodePointer_t XmlWriteValue(const char* value, const char* name);
00289 
00290    void             XmlReadBasic(Char_t& value);
00291    void             XmlReadBasic(Short_t& value);
00292    void             XmlReadBasic(Int_t& value);
00293    void             XmlReadBasic(Long_t& value);
00294    void             XmlReadBasic(Long64_t& value);
00295    void             XmlReadBasic(Float_t& value);
00296    void             XmlReadBasic(Double_t& value);
00297    void             XmlReadBasic(Bool_t& value);
00298    void             XmlReadBasic(UChar_t& value);
00299    void             XmlReadBasic(UShort_t& value);
00300    void             XmlReadBasic(UInt_t& value);
00301    void             XmlReadBasic(ULong_t& value);
00302    void             XmlReadBasic(ULong64_t& value);
00303    const char*      XmlReadValue(const char* name);
00304 
00305    XMLNodePointer_t XmlWriteObject(const void* obj, const TClass* objClass);
00306    void*            XmlReadObject(void* obj, TClass** cl = 0);
00307 
00308    void             BeforeIOoperation();
00309    void             CheckVersionBuf();
00310    
00311    TXMLEngine*      fXML;                 //!
00312 
00313    TObjArray        fStack;                //!
00314 
00315    Version_t        fVersionBuf;           //!
00316 
00317    TExMap*          fObjMap;               //!
00318    TObjArray*       fIdArray;              //!
00319 
00320    TString          fValueBuf;             //!
00321 
00322    Int_t            fErrorFlag;            //!
00323    
00324    Bool_t           fCanUseCompact;        //!   flag indicate that basic type (like Int_t) can be placed in the same tag
00325    Bool_t           fExpectedChain;        //!   flag to resolve situation when several elements of same basic type stored as FastArray
00326    TClass*          fExpectedBaseClass;    //!   pointer to class, which should be stored as parent of current
00327    Int_t            fCompressLevel;        //!   compress level used to minimize size of file 
00328 
00329    static const char* fgFloatFmt;          //!  printf argument for floats and doubles, either "%f" or "%e" or "%10f" and so on
00330 
00331 ClassDef(TBufferXML,1) //a specialized TBuffer to read/write to XML files
00332 };
00333 
00334 #endif
00335 
00336 

Generated on Tue Jul 5 14:26:38 2011 for ROOT_528-00b_version by  doxygen 1.5.1