include/root/TStreamerElement.h

0001 // @(#)root/meta:$Id: e0eac11e63ad37390c9467c97c5c6849c4ab7d39 $
0002 // Author: Rene Brun   12/10/2000
0003
0004 /*************************************************************************
0005  * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
0006  * All rights reserved.                                                  *
0007  *                                                                       *
0008  * For the licensing terms see $ROOTSYS/LICENSE.                         *
0009  * For the list of contributors see $ROOTSYS/README/CREDITS.             *
0010  *************************************************************************/
0011
0012 #ifndef ROOT_TStreamerElement
0013 #define ROOT_TStreamerElement
0014
0015 #include "TNamed.h"
0016
0017 #include "ESTLType.h"
0018
0019 class TMethodCall;
0020 class TClass;
0021 class TStreamerBasicType;
0022 class TVirtualStreamerInfo;
0023
0024 /// Describe one element (data member) to be Streamed
0025 class TStreamerElement : public TNamed {
0026
0027 private:
0028    TStreamerElement(const TStreamerElement &) = delete;
0029    TStreamerElement&operator=(const TStreamerElement&) = delete;
0030
0031 protected:
0032    Int_t            fType;            //element type
0033    Int_t            fSize;            //sizeof element
0034    Int_t            fArrayLength;     //cumulative size of all array dims
0035    Int_t            fArrayDim;        //number of array dimensions
0036    Int_t            fMaxIndex[5];     //Maximum array index for array dimension "dim"
0037    Int_t            fOffset;          //!element offset in class
0038    Int_t            fTObjectOffset;   //!base offset for TObject if the element inherits from it
0039    Int_t            fNewType;         //!new element type when reading
0040    TString          fTypeName;        //Data type name of data member
0041    TClass          *fClassObject;     //!pointer to class of object
0042    TClass          *fNewClass;        //!new element class when reading
0043    TMemberStreamer *fStreamer;        //!pointer to element Streamer
0044    Double_t         fXmin;            //!Minimum of data member if a range is specified  [xmin,xmax,nbits]
0045    Double_t         fXmax;            //!Maximum of data member if a range is specified  [xmin,xmax,nbits]
0046    Double_t         fFactor;          //!Conversion factor if a range is specified fFactor = (1<<nbits/(xmax-xmin)
0047
0048    friend class TStreamerSTL;
0049
0050 public:
0051
0052    enum ESTLtype {
0053       kSTL                  = ROOT::kSTLany,
0054       kSTLstring            = ROOT::kSTLstring,
0055       kSTLvector            = ROOT::kSTLvector,
0056       kSTLlist              = ROOT::kSTLlist,
0057       kSTLforwardlist       = ROOT::kSTLforwardlist,
0058       kSTLdeque             = ROOT::kSTLdeque,
0059       kSTLmap               = ROOT::kSTLmap,
0060       kSTLmultimap          = ROOT::kSTLmultimap,
0061       kSTLset               = ROOT::kSTLset,
0062       kSTLmultiset          = ROOT::kSTLmultiset,
0063       kSTLunorderedset      = ROOT::kSTLunorderedset,
0064       kSTLunorderedmultiset = ROOT::kSTLunorderedmultiset,
0065       kSTLunorderedmap      = ROOT::kSTLunorderedmap,
0066       kSTLunorderedmultimap = ROOT::kSTLunorderedmultimap,
0067       kSTLbitset            = ROOT::kSTLbitset
0068    };
0069    // TStreamerElement status bits
0070    enum EStatusBits {
0071       kHasRange     = BIT(6),
0072       kCache        = BIT(9),
0073       kRepeat       = BIT(10),
0074       kRead         = BIT(11),
0075       kWrite        = BIT(12),
0076       kDoNotDelete  = BIT(13),
0077       kWholeObject  = BIT(14),
0078       kWarned       = BIT(21)
0079    };
0080
0081    enum class EStatusBitsDupExceptions {
0082       // This bit duplicates TObject::kInvalidObject. As the semantic of kDoNotDelete is a persistent,
0083       // we can not change its value without breaking forward compatibility.
0084       // Furthermore, TObject::kInvalidObject and its semantic is not (and should not be)
0085       // used in TStreamerElement
0086       kDoNotDelete = TStreamerElement::kDoNotDelete,
0087
0088       // This bit duplicates TObject::kCannotPick. As the semantic of kHasRange is a persistent,
0089       // we can not change its value without breaking forward compatibility.
0090       // Furthermore, TObject::kCannotPick and its semantic is not (and should not be)
0091       // used in TStreamerElement
0092       kHasRange = TStreamerElement::kHasRange
0093    };
0094
0095
0096    TStreamerElement();
0097    TStreamerElement(const char *name, const char *title, Int_t offset, Int_t dtype, const char *typeName);
0098    virtual         ~TStreamerElement();
0099    virtual Bool_t   CannotSplit() const;
0100    Int_t            GetArrayDim() const {return fArrayDim;}
0101    Int_t            GetArrayLength() const {return fArrayLength;}
0102    virtual TClass  *GetClassPointer() const;
0103            TClass  *GetClass()        const {return GetClassPointer();}
0104    virtual Int_t    GetExecID() const;
0105    virtual const char *GetFullName() const;
0106    virtual const char *GetInclude() const {return "";}
0107    Int_t            GetMaxIndex(Int_t i) const {return fMaxIndex[i];}
0108    virtual ULongptr_t GetMethod() const {return ULongptr_t(fStreamer);}
0109    TMemberStreamer *GetStreamer() const;
0110    virtual Int_t    GetSize() const;
0111    Int_t            GetNewType() const {return fNewType;}
0112    TClass*          GetNewClass() const { return fNewClass; }
0113    Int_t            GetType() const {return fType;}
0114    Int_t            GetOffset() const {return fOffset;}
0115    void             GetSequenceType(TString &type) const;
0116    Int_t            GetTObjectOffset() const { return fTObjectOffset; }
0117    const char      *GetTypeName() const {return fTypeName.Data();}
0118    const char      *GetTypeNameBasic() const;
0119    Double_t         GetFactor() const {return fFactor;}
0120    Double_t         GetXmin()   const {return fXmin;}
0121    Double_t         GetXmax()   const {return fXmax;}
0122    virtual void     Init(TVirtualStreamerInfo *obj = nullptr);
0123    virtual Bool_t   IsaPointer() const {return kFALSE;}
0124    virtual Bool_t   HasCounter() const {return kFALSE;}
0125    virtual Bool_t   IsOldFormat(const char *newTypeName);
0126    virtual Bool_t   IsBase() const;
0127    virtual Bool_t   IsTransient() const;
0128    void             ls(Option_t *option="") const override;
0129    virtual void     SetArrayDim(Int_t dim);
0130    virtual void     SetMaxIndex(Int_t dim, Int_t max);
0131    virtual void     SetOffset(Int_t offset) {fOffset=offset;}
0132    virtual void     SetTObjectOffset(Int_t tobjoffset) {fTObjectOffset=tobjoffset;}
0133    virtual void     SetStreamer(TMemberStreamer *streamer);
0134    virtual void     SetSize(Int_t dsize) {fSize = dsize;}
0135    virtual void     SetNewType(Int_t dtype) {fNewType = dtype;}
0136    virtual void     SetNewClass( TClass* cl ) { fNewClass= cl; }
0137    virtual void     SetType(Int_t dtype) {fType = dtype;}
0138    virtual void     SetTypeName(const char *name) {fTypeName = name; fClassObject = (TClass*)-1; }
0139    virtual void     Update(const TClass *oldClass, TClass *newClass);
0140
0141    ClassDefOverride(TStreamerElement,4)  //Base class for one element (data member) to be Streamed
0142 };
0143
0144 //________________________________________________________________________
0145 class TStreamerBase : public TStreamerElement {
0146
0147 private:
0148    TStreamerBase(const TStreamerBase &) = delete;
0149    TStreamerBase&operator=(const TStreamerBase&) = delete;
0150
0151 protected:
0152    Int_t             fBaseVersion;    //version number of the base class (used during memberwise streaming)
0153    UInt_t           &fBaseCheckSum;   //!checksum of the base class (used during memberwise streaming)
0154    TClass           *fBaseClass;      //!pointer to base class
0155    TClass           *fNewBaseClass;   //!pointer to new base class if renamed
0156    ClassStreamerFunc_t     fStreamerFunc;     //!Pointer to a wrapper around a custom streamer member function.
0157    ClassConvStreamerFunc_t fConvStreamerFunc; //!Pointer to a wrapper around a custom convertion streamer member function.
0158    TVirtualStreamerInfo *fStreamerInfo; //!Pointer to the current StreamerInfo for the baset class.
0159    TString               fErrorMsg;     //!Error message in case of checksum/version mismatch.
0160
0161    void InitStreaming(Bool_t isTransient);
0162
0163 public:
0164
0165    TStreamerBase();
0166    TStreamerBase(const char *name, const char *title, Int_t offset, Bool_t isTransient = kFALSE);
0167    virtual         ~TStreamerBase();
0168    Int_t            GetBaseVersion() {return fBaseVersion;}
0169    UInt_t           GetBaseCheckSum() {return fBaseCheckSum;}
0170    TClass          *GetClassPointer() const override;
0171    const char      *GetErrorMessage() const { return fErrorMsg; }
0172    const char      *GetInclude() const override;
0173    TClass          *GetNewBaseClass() { return fNewBaseClass; }
0174    ULongptr_t       GetMethod() const override {return 0;}
0175    Int_t            GetSize() const override;
0176    TVirtualStreamerInfo *GetBaseStreamerInfo() const { return fStreamerInfo; }
0177    void             Init(TVirtualStreamerInfo *obj = nullptr) override;
0178    void             Init(Bool_t isTransient = kFALSE);
0179    Bool_t           IsBase() const override;
0180    void             ls(Option_t *option="") const override;
0181    Int_t            ReadBuffer (TBuffer &b, char *pointer);
0182    void             SetNewBaseClass( TClass* cl ) { fNewBaseClass = cl; InitStreaming(kFALSE); }
0183    void             SetBaseVersion(Int_t v) {fBaseVersion = v;}
0184    void             SetBaseCheckSum(UInt_t cs) {fBaseCheckSum = cs;}
0185    void             SetErrorMessage(const char *msg) { fErrorMsg = msg; }
0186    void             Update(const TClass *oldClass, TClass *newClass) override;
0187    Int_t            WriteBuffer(TBuffer &b, char *pointer);
0188
0189    ClassDefOverride(TStreamerBase,3)  //Streamer element of type base class
0190 };
0191
0192 //________________________________________________________________________
0193 class TStreamerBasicPointer : public TStreamerElement {
0194
0195 private:
0196    TStreamerBasicPointer(const TStreamerBasicPointer &) = delete;
0197    TStreamerBasicPointer&operator=(const TStreamerBasicPointer&) = delete;
0198
0199 protected:
0200    Int_t               fCountVersion;   //version number of the class with the counter
0201    TString             fCountName;      //name of data member holding the array count
0202    TString             fCountClass;     //name of the class with the counter
0203    TStreamerBasicType *fCounter;        //!pointer to basic type counter
0204
0205 public:
0206
0207    TStreamerBasicPointer();
0208    TStreamerBasicPointer(const char *name, const char *title, Int_t offset, Int_t dtype,
0209                          const char *countName, const char *countClass, Int_t version, const char *typeName);
0210    virtual       ~TStreamerBasicPointer();
0211    TClass        *GetClassPointer() const override { return nullptr; }
0212    const char    *GetCountClass()   const {return fCountClass.Data();}
0213    const char    *GetCountName()    const {return fCountName.Data();}
0214    Int_t          GetCountVersion() const {return fCountVersion;}
0215    ULongptr_t     GetMethod() const override;
0216    Int_t          GetSize() const override;
0217    void           Init(TVirtualStreamerInfo *obj = nullptr) override;
0218    Bool_t         HasCounter() const override { return fCounter != nullptr; }
0219    Bool_t         IsaPointer() const override { return kTRUE; }
0220    void           SetArrayDim(Int_t dim) override;
0221    void           SetCountClass(const char *clname) { fCountClass = clname; }
0222    void           SetCountName(const char *name)    { fCountName = name; }
0223    void           SetCountVersion(Int_t count)      { fCountVersion = count; }
0224    void           Update(const TClass * /* oldClass */, TClass * /*newClass*/ ) override {}
0225
0226    ClassDefOverride(TStreamerBasicPointer,2)  //Streamer element for a pointer to a basic type
0227 };
0228
0229 //________________________________________________________________________
0230 class TStreamerLoop : public TStreamerElement {
0231
0232 private:
0233    TStreamerLoop(const TStreamerLoop&) = delete;
0234    TStreamerLoop&operator=(const TStreamerLoop&) = delete;
0235
0236 protected:
0237    Int_t               fCountVersion;   //version number of the class with the counter
0238    TString             fCountName;      //name of data member holding the array count
0239    TString             fCountClass;     //name of the class with the counter
0240    TStreamerBasicType *fCounter;        //!pointer to basic type counter
0241
0242 public:
0243
0244    TStreamerLoop();
0245    TStreamerLoop(const char *name, const char *title, Int_t offset, const char *countName, const char *countClass, Int_t version, const char *typeName);
0246    virtual       ~TStreamerLoop();
0247    const char    *GetCountClass()   const {return fCountClass.Data();}
0248    const char    *GetCountName()    const {return fCountName.Data();}
0249    Int_t          GetCountVersion() const {return fCountVersion;}
0250    const char    *GetInclude() const override;
0251    ULongptr_t     GetMethod() const override;
0252    Int_t          GetSize() const override;
0253    void           Init(TVirtualStreamerInfo *obj = nullptr) override;
0254    Bool_t         IsaPointer() const override {return kTRUE; }
0255    Bool_t         HasCounter() const  override { return fCounter != nullptr; }
0256    void           SetCountClass(const char *clname) { fCountClass = clname; }
0257    void           SetCountName(const char *name) { fCountName = name; }
0258    void           SetCountVersion(Int_t count) { fCountVersion = count; }
0259
0260    ClassDefOverride(TStreamerLoop,2)  //Streamer element for a pointer to an array of objects
0261 };
0262
0263 //________________________________________________________________________
0264 class TStreamerBasicType : public TStreamerElement {
0265
0266 private:
0267    TStreamerBasicType(const TStreamerBasicType&) = delete;
0268    TStreamerBasicType&operator=(const TStreamerBasicType&) = delete;
0269
0270 protected:
0271    Int_t             fCounter;     //!value of data member when referenced by an array
0272
0273 public:
0274
0275    TStreamerBasicType();
0276    TStreamerBasicType(const char *name, const char *title, Int_t offset, Int_t dtype, const char *typeName);
0277    virtual       ~TStreamerBasicType();
0278    TClass        *GetClassPointer() const override { return nullptr; }
0279    Int_t          GetCounter() const { return fCounter; }
0280    ULongptr_t     GetMethod() const override;
0281    Int_t          GetSize() const override;
0282    void           Update(const TClass * /* oldClass */, TClass * /* newClass */) override {}
0283
0284    ClassDefOverride(TStreamerBasicType,2)  //Streamer element for a basic type
0285 };
0286
0287 //________________________________________________________________________
0288 class TStreamerObject : public TStreamerElement {
0289
0290 private:
0291    TStreamerObject(const TStreamerObject&) = delete;
0292    TStreamerObject&operator=(const TStreamerObject&) = delete;
0293
0294 public:
0295
0296    TStreamerObject();
0297    TStreamerObject(const char *name, const char *title, Int_t offset, const char *typeName);
0298    virtual       ~TStreamerObject();
0299    const char    *GetInclude() const override;
0300    Int_t          GetSize() const override;
0301    void           Init(TVirtualStreamerInfo *obj = nullptr) override;
0302
0303    ClassDefOverride(TStreamerObject,2)  //Streamer element of type object
0304 };
0305
0306 //________________________________________________________________________
0307 class TStreamerObjectAny : public TStreamerElement {
0308
0309 private:
0310    TStreamerObjectAny(const TStreamerObjectAny&) = delete;
0311    TStreamerObjectAny&operator=(const TStreamerObjectAny&) = delete;
0312
0313 public:
0314
0315    TStreamerObjectAny();
0316    TStreamerObjectAny(const char *name, const char *title, Int_t offset, const char *typeName);
0317    virtual       ~TStreamerObjectAny();
0318    const char    *GetInclude() const override;
0319    Int_t          GetSize() const override;
0320    void           Init(TVirtualStreamerInfo *obj = nullptr) override;
0321
0322    ClassDefOverride(TStreamerObjectAny,2)  //Streamer element of type object other than TObject
0323 };
0324
0325 //________________________________________________________________________
0326 class TStreamerObjectPointer : public TStreamerElement {
0327
0328 private:
0329    TStreamerObjectPointer(const TStreamerObjectPointer&) = delete;
0330    TStreamerObjectPointer&operator=(const TStreamerObjectPointer&) = delete;
0331
0332 public:
0333
0334    TStreamerObjectPointer();
0335    TStreamerObjectPointer(const char *name, const char *title, Int_t offset, const char *typeName);
0336    virtual       ~TStreamerObjectPointer();
0337    const char    *GetInclude() const override;
0338    Int_t          GetSize() const override;
0339    void           Init(TVirtualStreamerInfo *obj = nullptr) override;
0340    Bool_t         IsaPointer() const override {return kTRUE;}
0341    void           SetArrayDim(Int_t dim) override;
0342
0343    ClassDefOverride(TStreamerObjectPointer,2)  //Streamer element of type pointer to a TObject
0344 };
0345
0346 //________________________________________________________________________
0347 class TStreamerObjectAnyPointer : public TStreamerElement {
0348
0349 private:
0350    TStreamerObjectAnyPointer(const TStreamerObjectAnyPointer&) = delete;
0351    TStreamerObjectAnyPointer&operator=(const TStreamerObjectAnyPointer&) = delete;
0352
0353 public:
0354
0355    TStreamerObjectAnyPointer();
0356    TStreamerObjectAnyPointer(const char *name, const char *title, Int_t offset, const char *typeName);
0357    virtual       ~TStreamerObjectAnyPointer();
0358    const char    *GetInclude() const override;
0359    Int_t          GetSize() const override;
0360    void           Init(TVirtualStreamerInfo *obj = nullptr) override;
0361    Bool_t         IsaPointer() const override { return kTRUE; }
0362    void           SetArrayDim(Int_t dim) override;
0363
0364    ClassDefOverride(TStreamerObjectAnyPointer,1)  //Streamer element of type pointer to a non TObject
0365 };
0366
0367 //________________________________________________________________________
0368 class TStreamerString : public TStreamerElement {
0369
0370 private:
0371    TStreamerString(const TStreamerString&) = delete;
0372    TStreamerString&operator=(const TStreamerString&) = delete;
0373
0374 public:
0375
0376    TStreamerString();
0377    TStreamerString(const char *name, const char *title, Int_t offset);
0378    virtual       ~TStreamerString();
0379    const char    *GetInclude() const override;
0380    Int_t          GetSize() const override;
0381
0382    ClassDefOverride(TStreamerString,2)  //Streamer element of type TString
0383 };
0384
0385 //________________________________________________________________________
0386 class TStreamerSTL : public TStreamerElement {
0387
0388 private:
0389    TStreamerSTL(const TStreamerSTL&) = delete;
0390    TStreamerSTL&operator=(const TStreamerSTL&) = delete;
0391
0392 protected:
0393    Int_t       fSTLtype;       //type of STL vector
0394    Int_t       fCtype;         //STL contained type
0395
0396 public:
0397
0398    TStreamerSTL();
0399    TStreamerSTL(const char *name, const char *title, Int_t offset,
0400                 const char *typeName, const char *trueType, Bool_t dmPointer);
0401    TStreamerSTL(const char *name, const char *title, Int_t offset,
0402                 const char *typeName, const TVirtualCollectionProxy &proxy , Bool_t dmPointer);
0403    virtual       ~TStreamerSTL();
0404    Bool_t         CannotSplit() const override;
0405    Bool_t         IsaPointer() const override;
0406    Bool_t         IsBase() const override;
0407    TClass        *GetClassPointer() const override;
0408    Int_t          GetSTLtype() const {return fSTLtype;}
0409    Int_t          GetCtype()   const {return fCtype;}
0410    const char    *GetInclude() const override;
0411    Int_t          GetSize() const override;
0412    void           ls(Option_t *option="") const override;
0413    void           SetSTLtype(Int_t t) {fSTLtype = t;}
0414    void           SetCtype(Int_t t) {fCtype = t;}
0415    void           SetStreamer(TMemberStreamer *streamer) override;
0416
0417    ClassDefOverride(TStreamerSTL,3)  //Streamer element of type STL container
0418 };
0419
0420 //________________________________________________________________________
0421 class TStreamerSTLstring : public TStreamerSTL {
0422
0423 private:
0424    TStreamerSTLstring(const TStreamerSTLstring&) = delete;
0425    TStreamerSTLstring&operator=(const TStreamerSTLstring&) = delete;
0426
0427 public:
0428
0429    TStreamerSTLstring();
0430    TStreamerSTLstring(const char *name, const char *title, Int_t offset,
0431                       const char *typeName, Bool_t dmPointer);
0432    virtual       ~TStreamerSTLstring();
0433    const char    *GetInclude() const override;
0434    Int_t          GetSize() const override;
0435
0436    ClassDefOverride(TStreamerSTLstring,2)  //Streamer element of type  C++ string
0437 };
0438
0439 class TVirtualObject;
0440 class TBuffer;
0441
0442 #include "TSchemaRule.h"
0443
0444 //________________________________________________________________________
0445 class TStreamerArtificial : public TStreamerElement {
0446 private:
0447    TStreamerArtificial(const TStreamerArtificial&) = delete;
0448    TStreamerArtificial&operator=(const TStreamerArtificial&) = delete;
0449
0450 protected:
0451    ROOT::TSchemaRule::ReadFuncPtr_t     fReadFunc;    //!
0452    ROOT::TSchemaRule::ReadRawFuncPtr_t  fReadRawFunc; //!
0453
0454 public:
0455
0456    // TStreamerArtificial() : fReadFunc(0),fReadRawFunc(0) {}
0457
0458    TStreamerArtificial(const char *name, const char *title, Int_t offset, Int_t dtype, const char *typeName) : TStreamerElement(name,title,offset,dtype,typeName), fReadFunc(nullptr), fReadRawFunc(nullptr) {}
0459
0460    void SetReadFunc( ROOT::TSchemaRule::ReadFuncPtr_t val ) { fReadFunc = val; };
0461    void SetReadRawFunc( ROOT::TSchemaRule::ReadRawFuncPtr_t val ) { fReadRawFunc = val; };
0462
0463    ROOT::TSchemaRule::ReadFuncPtr_t     GetReadFunc();
0464    ROOT::TSchemaRule::ReadRawFuncPtr_t  GetReadRawFunc();
0465
0466    ClassDefOverride(TStreamerArtificial, 0); // StreamerElement injected by a TSchemaRule. Transient only to preserve forward compatibility.
0467 };
0468
0469 #endif