doc/v620/TBufferXML_8h_source.html

// @(#)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


#include "Compression.h"

#include "TBufferText.h"

#include "TXMLSetup.h"

#include "TString.h"

#include "TXMLEngine.h"


#include <string>

#include <deque>

#include <memory>


class TExMap;

class TVirtualStreamerInfo;

class TStreamerInfo;

class TStreamerElement;

class TObjArray;

class TMemberStreamer;

class TXMLFile;

class TXMLStackObj;


class TBufferXML final : public TBufferText, 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);


   template <class T>

   static TString ToXML(const T *obj, Bool_t GenericLayout = kFALSE, Bool_t UseNamespaces = kFALSE)

   {

      return ConvertToXML(obj, TClass::GetClass<T>(), GenericLayout, UseNamespaces);

   }


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

   static void *ConvertFromXMLAny(const char *str, TClass **cl = nullptr, Bool_t GenericLayout = kFALSE,

                                  Bool_t UseNamespaces = kFALSE);


   template <class T>

   static Bool_t FromXML(T *&obj, const char *xml, Bool_t GenericLayout = kFALSE, Bool_t UseNamespaces = kFALSE)

   {

      if (obj)

         return kFALSE;

      obj = (T *)ConvertFromXMLChecked(xml, TClass::GetClass<T>(), GenericLayout, UseNamespaces);

      return obj != nullptr;

   }


   Int_t GetIOVersion() const { return fIOVersion; }

   void SetIOVersion(Int_t v) { fIOVersion = v; }


   // suppress class writing/reading


   TClass *ReadClass(const TClass *cl = nullptr, UInt_t *objTag = nullptr) final;

   void WriteClass(const TClass *cl) final;


   // redefined virtual functions of TBuffer


   Version_t ReadVersion(UInt_t *start = nullptr, UInt_t *bcnt = nullptr, const TClass *cl = nullptr) final;

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


   void *ReadObjectAny(const TClass *clCast) final;

   void SkipObjectAny() final;


   void IncrementLevel(TVirtualStreamerInfo *) final;

   void SetStreamerElementNumber(TStreamerElement *elem, Int_t comp_type) final;

   void DecrementLevel(TVirtualStreamerInfo *) final;


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

   void ClassEnd(const TClass *) final;

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


   Int_t ReadArray(Bool_t *&b) final;

   Int_t ReadArray(Char_t *&c) final;

   Int_t ReadArray(UChar_t *&c) final;

   Int_t ReadArray(Short_t *&h) final;

   Int_t ReadArray(UShort_t *&h) final;

   Int_t ReadArray(Int_t *&i) final;

   Int_t ReadArray(UInt_t *&i) final;

   Int_t ReadArray(Long_t *&l) final;

   Int_t ReadArray(ULong_t *&l) final;

   Int_t ReadArray(Long64_t *&l) final;

   Int_t ReadArray(ULong64_t *&l) final;

   Int_t ReadArray(Float_t *&f) final;

   Int_t ReadArray(Double_t *&d) final;


   Int_t ReadStaticArray(Bool_t *b) final;

   Int_t ReadStaticArray(Char_t *c) final;

   Int_t ReadStaticArray(UChar_t *c) final;

   Int_t ReadStaticArray(Short_t *h) final;

   Int_t ReadStaticArray(UShort_t *h) final;

   Int_t ReadStaticArray(Int_t *i) final;

   Int_t ReadStaticArray(UInt_t *i) final;

   Int_t ReadStaticArray(Long_t *l) final;

   Int_t ReadStaticArray(ULong_t *l) final;

   Int_t ReadStaticArray(Long64_t *l) final;

   Int_t ReadStaticArray(ULong64_t *l) final;

   Int_t ReadStaticArray(Float_t *f) final;

   Int_t ReadStaticArray(Double_t *d) final;


   void ReadFastArray(Bool_t *b, Int_t n) final;

   void ReadFastArray(Char_t *c, Int_t n) final;

   void ReadFastArray(UChar_t *c, Int_t n) final;

   void ReadFastArray(Short_t *h, Int_t n) final;

   void ReadFastArray(UShort_t *h, Int_t n) final;

   void ReadFastArray(Int_t *i, Int_t n) final;

   void ReadFastArray(UInt_t *i, Int_t n) final;

   void ReadFastArray(Long_t *l, Int_t n) final;

   void ReadFastArray(ULong_t *l, Int_t n) final;

   void ReadFastArray(Long64_t *l, Int_t n) final;

   void ReadFastArray(ULong64_t *l, Int_t n) final;

   void ReadFastArray(Float_t *f, Int_t n) final;

   void ReadFastArray(Double_t *d, Int_t n) final;

   void ReadFastArrayString(Char_t *c, Int_t n) final;

   void ReadFastArray(void *start, const TClass *cl, Int_t n = 1, TMemberStreamer *s = nullptr,

                      const TClass *onFileClass = nullptr) final;

   void ReadFastArray(void **startp, const TClass *cl, Int_t n = 1, Bool_t isPreAlloc = kFALSE,

                      TMemberStreamer *s = nullptr, const TClass *onFileClass = nullptr) final;


   void WriteArray(const Bool_t *b, Int_t n) final;

   void WriteArray(const Char_t *c, Int_t n) final;

   void WriteArray(const UChar_t *c, Int_t n) final;

   void WriteArray(const Short_t *h, Int_t n) final;

   void WriteArray(const UShort_t *h, Int_t n) final;

   void WriteArray(const Int_t *i, Int_t n) final;

   void WriteArray(const UInt_t *i, Int_t n) final;

   void WriteArray(const Long_t *l, Int_t n) final;

   void WriteArray(const ULong_t *l, Int_t n) final;

   void WriteArray(const Long64_t *l, Int_t n) final;

   void WriteArray(const ULong64_t *l, Int_t n) final;

   void WriteArray(const Float_t *f, Int_t n) final;

   void WriteArray(const Double_t *d, Int_t n) final;


   void WriteFastArray(const Bool_t *b, Int_t n) final;

   void WriteFastArray(const Char_t *c, Int_t n) final;

   void WriteFastArray(const UChar_t *c, Int_t n) final;

   void WriteFastArray(const Short_t *h, Int_t n) final;

   void WriteFastArray(const UShort_t *h, Int_t n) final;

   void WriteFastArray(const Int_t *i, Int_t n) final;

   void WriteFastArray(const UInt_t *i, Int_t n) final;

   void WriteFastArray(const Long_t *l, Int_t n) final;

   void WriteFastArray(const ULong_t *l, Int_t n) final;

   void WriteFastArray(const Long64_t *l, Int_t n) final;

   void WriteFastArray(const ULong64_t *l, Int_t n) final;

   void WriteFastArray(const Float_t *f, Int_t n) final;

   void WriteFastArray(const Double_t *d, Int_t n) final;

   void WriteFastArrayString(const Char_t *c, Int_t n) final;

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

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

                        TMemberStreamer *s = nullptr) final;


   void StreamObject(void *obj, const TClass *cl, const TClass *onFileClass = nullptr) final;

   using TBufferText::StreamObject;


   void ReadBool(Bool_t &b) final;

   void ReadChar(Char_t &c) final;

   void ReadUChar(UChar_t &c) final;

   void ReadShort(Short_t &s) final;

   void ReadUShort(UShort_t &s) final;

   void ReadInt(Int_t &i) final;

   void ReadUInt(UInt_t &i) final;

   void ReadLong(Long_t &l) final;

   void ReadULong(ULong_t &l) final;

   void ReadLong64(Long64_t &l) final;

   void ReadULong64(ULong64_t &l) final;

   void ReadFloat(Float_t &f) final;

   void ReadDouble(Double_t &d) final;

   void ReadCharP(Char_t *c) final;

   void ReadTString(TString &s) final;

   void ReadStdString(std::string *s) final;

   using TBuffer::ReadStdString;

   void ReadCharStar(char *&s) final;


   void WriteBool(Bool_t b) final;

   void WriteChar(Char_t c) final;

   void WriteUChar(UChar_t c) final;

   void WriteShort(Short_t s) final;

   void WriteUShort(UShort_t s) final;

   void WriteInt(Int_t i) final;

   void WriteUInt(UInt_t i) final;

   void WriteLong(Long_t l) final;

   void WriteULong(ULong_t l) final;

   void WriteLong64(Long64_t l) final;

   void WriteULong64(ULong64_t l) final;

   void WriteFloat(Float_t f) final;

   void WriteDouble(Double_t d) final;

   void WriteCharP(const Char_t *c) final;

   void WriteTString(const TString &s) final;

   void WriteStdString(const std::string *s) final;

   using TBuffer::WriteStdString;

   void WriteCharStar(char *s) final;


   TVirtualStreamerInfo *GetInfo() final;


protected:

   // redefined protected virtual functions


   void WriteObjectClass(const void *actualObjStart, const TClass *actualClass, Bool_t cacheReuse) final;


   // end redefined protected virtual functions


   static void *ConvertFromXMLChecked(const char *xml, const TClass *expectedClass, Bool_t GenericLayout = kFALSE,

                                      Bool_t UseNamespaces = kFALSE);


   TXMLFile *XmlFile();


   Int_t GetCompressionAlgorithm() const;

   Int_t GetCompressionLevel() const;

   Int_t GetCompressionSettings() const;

   void SetCompressionAlgorithm(Int_t algorithm = ROOT::RCompressionSetting::EAlgorithm::kUseGlobal);

   void SetCompressionLevel(Int_t level = ROOT::RCompressionSetting::ELevel::kUseMin);

   void SetCompressionSettings(Int_t settings = ROOT::RCompressionSetting::EDefaults::kUseCompiledDefault);

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


   XMLNodePointer_t StackNode();

   TXMLStackObj *Stack(UInt_t depth = 0)

   {

      return (depth < fStack.size()) ? (depth ? fStack[fStack.size() - depth - 1].get() : fStack.back().get()) : nullptr;

   }


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

   void WorkWithElement(TStreamerElement *elem, Int_t comp_type);

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

   Bool_t VerifyStackNode(const char *name, const char *errinfo = nullptr);


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

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


   Bool_t ProcessPointer(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 = nullptr);


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


   template <typename T>

   R__ALWAYS_INLINE void XmlReadArrayContent(T *arr, Int_t arrsize);


   template <typename T>

   R__ALWAYS_INLINE Int_t XmlReadArray(T *&arr, bool is_static = false);


   template <typename T>

   R__ALWAYS_INLINE void XmlReadFastArray(T *arr, Int_t n);


   template <typename T>

   R__ALWAYS_INLINE void XmlWriteArrayContent(const T *arr, Int_t arrsize);


   template <typename T>

   R__ALWAYS_INLINE void XmlWriteArray(const T *arr, Int_t arrsize);


   template <typename T>

   R__ALWAYS_INLINE void XmlWriteFastArray(const T *arr, Int_t n);


   XMLNodePointer_t XmlWriteObject(const void *obj, const TClass *objClass, Bool_t cacheReuse);

   void *XmlReadObject(void *obj, TClass **cl = nullptr);


   void BeforeIOoperation();

   void CheckVersionBuf();


   TXMLEngine *fXML{nullptr};                        ///<! instance of TXMLEngine for working with XML structures

   std::deque<std::unique_ptr<TXMLStackObj>> fStack; ///<! Stack of processed objects

   Version_t fVersionBuf{-111};                      ///<! Current version buffer

   TString fValueBuf;                                ///<! Current value buffer

   Int_t fErrorFlag{0};                              ///<! Error flag

   Bool_t fCanUseCompact{kFALSE};                    ///<! Flag indicate that basic type (like Int_t) can be placed in the same tag

   TClass *fExpectedBaseClass{nullptr};              ///<! Pointer to class, which should be stored as parent of current

   Int_t fCompressLevel{0};                          ///<! Compression level and algorithm

   Int_t fIOVersion{3};                              ///<! Indicates format of ROOT xml file


   ClassDefOverride(TBufferXML, 0); // 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

Compression.h

R__ALWAYS_INLINE
#define R__ALWAYS_INLINE
Definition: RConfig.hxx:577

d
#define d(i)
Definition: RSha256.hxx:102

b
#define b(i)
Definition: RSha256.hxx:100

f
#define f(i)
Definition: RSha256.hxx:104

c
#define c(i)
Definition: RSha256.hxx:101

h
#define h(i)
Definition: RSha256.hxx:106

UShort_t
unsigned short UShort_t
Definition: RtypesCore.h:36

Int_t
int Int_t
Definition: RtypesCore.h:41

Version_t
short Version_t
Definition: RtypesCore.h:61

UChar_t
unsigned char UChar_t
Definition: RtypesCore.h:34

Char_t
char Char_t
Definition: RtypesCore.h:29

UInt_t
unsigned int UInt_t
Definition: RtypesCore.h:42

kFALSE
const Bool_t kFALSE
Definition: RtypesCore.h:88

ULong_t
unsigned long ULong_t
Definition: RtypesCore.h:51

Long_t
long Long_t
Definition: RtypesCore.h:50

Bool_t
bool Bool_t
Definition: RtypesCore.h:59

Short_t
short Short_t
Definition: RtypesCore.h:35

Double_t
double Double_t
Definition: RtypesCore.h:55

Long64_t
long long Long64_t
Definition: RtypesCore.h:69

ULong64_t
unsigned long long ULong64_t
Definition: RtypesCore.h:70

Float_t
float Float_t
Definition: RtypesCore.h:53

TBufferText.h

name
char name[80]
Definition: TGX11.cxx:109

TString.h

TXMLEngine.h

XMLNodePointer_t
void * XMLNodePointer_t
Definition: TXMLEngine.h:17

TXMLSetup.h

TBufferText
Base class for text-based streamers like TBufferJSON or TBufferXML Special actions list will use meth...
Definition: TBufferText.h:21

TBufferXML
Class for serializing/deserializing object to/from xml.
Definition: TBufferXML.h:34

TBufferXML::ProcessPointer
Bool_t ProcessPointer(const void *ptr, XMLNodePointer_t node)
Add "ptr" attribute to node, if ptr is null or if ptr is pointer on object, which is already saved in...
Definition: TBufferXML.cxx:521

TBufferXML::WriteLong
void WriteLong(Long_t l) final
Writes Long_t value to buffer.
Definition: TBufferXML.cxx:2691

TBufferXML::WriteFastArray
void WriteFastArray(const Bool_t *b, Int_t n) final
Write array of Bool_t to buffer.
Definition: TBufferXML.cxx:2172

TBufferXML::SetXML
void SetXML(TXMLEngine *xml)
Definition: TBufferXML.h:230

TBufferXML::GetCompressionSettings
Int_t GetCompressionSettings() const
Definition: TBufferXML.h:349

TBufferXML::PushStack
TXMLStackObj * PushStack(XMLNodePointer_t current, Bool_t simple=kFALSE)
Add new level to xml stack.
Definition: TBufferXML.cxx:297

TBufferXML::VerifyAttr
Bool_t VerifyAttr(XMLNodePointer_t node, const char *name, const char *value, const char *errinfo=nullptr)
Checks, that attribute of specified name exists and has specified value.
Definition: TBufferXML.cxx:646

TBufferXML::WorkWithClass
void WorkWithClass(TStreamerInfo *info, const TClass *cl=nullptr)
Prepares buffer to stream data of specified class.
Definition: TBufferXML.cxx:861

TBufferXML::VerifyStackNode
Bool_t VerifyStackNode(const char *name, const char *errinfo=nullptr)
Check, if stack node has specified name.
Definition: TBufferXML.cxx:638

TBufferXML::GetCompressionAlgorithm
Int_t GetCompressionAlgorithm() const
Definition: TBufferXML.h:337

TBufferXML::ReadUShort
void ReadUShort(UShort_t &s) final
Reads UShort_t value from buffer.
Definition: TBufferXML.cxx:2449

TBufferXML::ReadUInt
void ReadUInt(UInt_t &i) final
Reads UInt_t value from buffer.
Definition: TBufferXML.cxx:2467

TBufferXML::fCompressLevel
Int_t fCompressLevel
! Compression level and algorithm
Definition: TBufferXML.h:330

TBufferXML::SetCompressionSettings
void SetCompressionSettings(Int_t settings=ROOT::RCompressionSetting::EDefaults::kUseCompiledDefault)
Used to specify the compression level and algorithm.
Definition: TBufferXML.cxx:380

TBufferXML::fValueBuf
TString fValueBuf
! Current value buffer
Definition: TBufferXML.h:326

TBufferXML::StreamObject
void StreamObject(void *obj, const TClass *cl, const TClass *onFileClass=nullptr) final
Stream object to/from buffer.
Definition: TBufferXML.cxx:2388

TBufferXML::GetCompressionLevel
Int_t GetCompressionLevel() const
Definition: TBufferXML.h:343

TBufferXML::WriteStdString
void WriteStdString(const std::string *s) final
Writes a std::string.
Definition: TBufferXML.cxx:2779

TBufferXML::ReadDouble
void ReadDouble(Double_t &d) final
Reads Double_t value from buffer.
Definition: TBufferXML.cxx:2521

TBufferXML::TBufferXML
TBufferXML(TBuffer::EMode mode)
Creates buffer object to serialize/deserialize data to/from xml.
Definition: TBufferXML.cxx:58

TBufferXML::VerifyNode
Bool_t VerifyNode(XMLNodePointer_t node, const char *name, const char *errinfo=nullptr)
Check if node has specified name.
Definition: TBufferXML.cxx:620

TBufferXML::ReadFastArrayString
void ReadFastArrayString(Char_t *c, Int_t n) final
Read array of n characters from the I/O buffer.
Definition: TBufferXML.cxx:1823

TBufferXML::WriteLong64
void WriteLong64(Long64_t l) final
Writes Long64_t value to buffer.
Definition: TBufferXML.cxx:2709

TBufferXML::WriteChar
void WriteChar(Char_t c) final
Writes Char_t value to buffer.
Definition: TBufferXML.cxx:2637

TBufferXML::fXML
TXMLEngine * fXML
! instance of TXMLEngine for working with XML structures
Definition: TBufferXML.h:323

TBufferXML::fStack
std::deque< std::unique_ptr< TXMLStackObj > > fStack
! Stack of processed objects
Definition: TBufferXML.h:324

TBufferXML::ConvertToXML
static TString ConvertToXML(const TObject *obj, Bool_t GenericLayout=kFALSE, Bool_t UseNamespaces=kFALSE)
Converts object, inherited from TObject class, to XML string GenericLayout defines layout choice for ...
Definition: TBufferXML.cxx:104

TBufferXML::WriteFloat
void WriteFloat(Float_t f) final
Writes Float_t value to buffer.
Definition: TBufferXML.cxx:2727

TBufferXML::ReadTString
void ReadTString(TString &s) final
Reads a TString.
Definition: TBufferXML.cxx:2541

TBufferXML::WriteTString
void WriteTString(const TString &s) final
Writes a TString.
Definition: TBufferXML.cxx:2754

TBufferXML::IncrementLevel
void IncrementLevel(TVirtualStreamerInfo *) final
Function is called from TStreamerInfo WriteBuffer and ReadBuffer functions and indent new level in xm...
Definition: TBufferXML.cxx:853

TBufferXML::SetIOVersion
void SetIOVersion(Int_t v)
Definition: TBufferXML.h:67

TBufferXML::WriteArray
void WriteArray(const Bool_t *b, Int_t n) final
Write array of Bool_t to buffer.
Definition: TBufferXML.cxx:2051

TBufferXML::XmlWriteAny
XMLNodePointer_t XmlWriteAny(const void *obj, const TClass *cl)
Convert object of any class to xml structures Return pointer on top xml element.
Definition: TBufferXML.cxx:227

TBufferXML::XmlReadBasic
void XmlReadBasic(Char_t &value)
Reads string from current xml node and convert it to Char_t value.
Definition: TBufferXML.cxx:2968

TBufferXML::ReadULong
void ReadULong(ULong_t &l) final
Reads ULong_t value from buffer.
Definition: TBufferXML.cxx:2485

TBufferXML::GetIOVersion
Int_t GetIOVersion() const
Definition: TBufferXML.h:66

TBufferXML::XmlWriteArrayContent
R__ALWAYS_INLINE void XmlWriteArrayContent(const T *arr, Int_t arrsize)
Definition: TBufferXML.cxx:2015

TBufferXML::XmlWriteValue
XMLNodePointer_t XmlWriteValue(const char *value, const char *name)
Create xml node with specified name and adds it to stack node.
Definition: TBufferXML.cxx:2949

TBufferXML::SkipObjectAny
void SkipObjectAny() final
Skip any kind of object from buffer Actually skip only one node on current level of xml structure.
Definition: TBufferXML.cxx:1506

TBufferXML::VerifyStackAttr
Bool_t VerifyStackAttr(const char *name, const char *value, const char *errinfo=nullptr)
Checks stack attribute.
Definition: TBufferXML.cxx:665

TBufferXML::ReadFloat
void ReadFloat(Float_t &f) final
Reads Float_t value from buffer.
Definition: TBufferXML.cxx:2512

TBufferXML::ReadULong64
void ReadULong64(ULong64_t &l) final
Reads ULong64_t value from buffer.
Definition: TBufferXML.cxx:2503

TBufferXML::XmlWriteBasic
XMLNodePointer_t XmlWriteBasic(Char_t value)
Converts Char_t to string and add xml node to buffer.
Definition: TBufferXML.cxx:2823

TBufferXML::ShiftStack
void ShiftStack(const char *info=nullptr)
Shift stack node to next.
Definition: TBufferXML.cxx:330

TBufferXML::PerformPreProcessing
void PerformPreProcessing(const TStreamerElement *elem, XMLNodePointer_t elemnode)
Function is unpack TObject and TString structures to be able read them from custom streamers of this ...
Definition: TBufferXML.cxx:1319

TBufferXML::WriteFastArrayString
void WriteFastArrayString(const Char_t *c, Int_t n) final
Write array of n characters into the I/O buffer.
Definition: TBufferXML.cxx:2297

TBufferXML::ReadShort
void ReadShort(Short_t &s) final
Reads Short_t value from buffer.
Definition: TBufferXML.cxx:2440

TBufferXML::BeforeIOoperation
void BeforeIOoperation()
Function is called before any IO operation of TBuffer Now is used to store version value if no proper...
Definition: TBufferXML.cxx:1393

TBufferXML::ReadClass
TClass * ReadClass(const TClass *cl=nullptr, UInt_t *objTag=nullptr) final
Function to read class from buffer, used in old-style streamers.
Definition: TBufferXML.cxx:1401

TBufferXML::fErrorFlag
Int_t fErrorFlag
! Error flag
Definition: TBufferXML.h:327

TBufferXML::ReadChar
void ReadChar(Char_t &c) final
Reads Char_t value from buffer.
Definition: TBufferXML.cxx:2422

TBufferXML::XmlReadArrayContent
R__ALWAYS_INLINE void XmlReadArrayContent(T *arr, Int_t arrsize)
Template method to read array content.
Definition: TBufferXML.cxx:1526

TBufferXML::ClassEnd
void ClassEnd(const TClass *) final
Should be called at the end of custom streamer See TBufferXML::ClassBegin for more details.
Definition: TBufferXML.cxx:1057

TBufferXML::ReadLong64
void ReadLong64(Long64_t &l) final
Reads Long64_t value from buffer.
Definition: TBufferXML.cxx:2494

TBufferXML::fVersionBuf
Version_t fVersionBuf
! Current version buffer
Definition: TBufferXML.h:325

TBufferXML::ClassBegin
void ClassBegin(const TClass *, Version_t=-1) final
Should be called at the beginning of custom class streamer.
Definition: TBufferXML.cxx:1048

TBufferXML::XmlReadBlock
void XmlReadBlock(XMLNodePointer_t node)
Read binary block of data from xml.
Definition: TBufferXML.cxx:450

TBufferXML::XmlReadObject
void * XmlReadObject(void *obj, TClass **cl=nullptr)
Read object from the buffer.
Definition: TBufferXML.cxx:786

TBufferXML::ReadCharP
void ReadCharP(Char_t *c) final
Reads array of characters from buffer.
Definition: TBufferXML.cxx:2530

TBufferXML::fCanUseCompact
Bool_t fCanUseCompact
! Flag indicate that basic type (like Int_t) can be placed in the same tag
Definition: TBufferXML.h:328

TBufferXML::XmlWriteArray
R__ALWAYS_INLINE void XmlWriteArray(const T *arr, Int_t arrsize)
Write array, including it size Content may be compressed.
Definition: TBufferXML.cxx:2038

TBufferXML::ReadStdString
void ReadStdString(std::string *s) final
Reads a std::string.
Definition: TBufferXML.cxx:2574

TBufferXML::ReadBool
void ReadBool(Bool_t &b) final
Reads Bool_t value from buffer.
Definition: TBufferXML.cxx:2413

TBufferXML::WriteUShort
void WriteUShort(UShort_t s) final
Writes UShort_t value to buffer.
Definition: TBufferXML.cxx:2664

TBufferXML::WriteClass
void WriteClass(const TClass *cl) final
Function to write class into buffer, used in old-style streamers.
Definition: TBufferXML.cxx:1417

TBufferXML::WriteCharStar
void WriteCharStar(char *s) final
Write a char* string.
Definition: TBufferXML.cxx:2808

TBufferXML::XmlReadValue
const char * XmlReadValue(const char *name)
read string value from current stack node
Definition: TBufferXML.cxx:3128

TBufferXML::ExtractPointer
Bool_t ExtractPointer(XMLNodePointer_t node, void *&ptr, TClass *&cl)
Searches for "ptr" attribute and returns pointer to object and class, if "ptr" attribute reference to...
Definition: TBufferXML.cxx:558

TBufferXML::ReadFastArray
void ReadFastArray(Bool_t *b, Int_t n) final
Read array of Bool_t from buffer.
Definition: TBufferXML.cxx:1795

TBufferXML::DecrementLevel
void DecrementLevel(TVirtualStreamerInfo *) final
Function is called from TStreamerInfo WriteBuffer and ReadBuffer functions and decrease level in xml ...
Definition: TBufferXML.cxx:927

TBufferXML::XmlWriteFastArray
R__ALWAYS_INLINE void XmlWriteFastArray(const T *arr, Int_t n)
Write array without size attribute Also treat situation, when instead of one single array chain of se...
Definition: TBufferXML.cxx:2158

TBufferXML::PerformPostProcessing
void PerformPostProcessing()
Function is converts TObject and TString structures to more compact representation.
Definition: TBufferXML.cxx:1201

TBufferXML::SetStreamerElementNumber
void SetStreamerElementNumber(TStreamerElement *elem, Int_t comp_type) final
Function is called from TStreamerInfo WriteBuffer and ReadBuffer functions and add/verify next elemen...
Definition: TBufferXML.cxx:959

TBufferXML::WriteCharP
void WriteCharP(const Char_t *c) final
Writes array of characters to buffer.
Definition: TBufferXML.cxx:2745

TBufferXML::ConvertFromXML
static TObject * ConvertFromXML(const char *str, Bool_t GenericLayout=kFALSE, Bool_t UseNamespaces=kFALSE)
Read object from XML, produced by ConvertToXML() method.
Definition: TBufferXML.cxx:153

TBufferXML::ClassMember
void ClassMember(const char *name, const char *typeName=nullptr, Int_t arrsize1=-1, Int_t arrsize2=-1) final
Method indicates name and typename of class member, which should be now streamed in custom streamer.
Definition: TBufferXML.cxx:1100

TBufferXML::ReadStaticArray
Int_t ReadStaticArray(Bool_t *b) final
Read array of Bool_t from buffer.
Definition: TBufferXML.cxx:1672

TBufferXML::XmlReadAny
void * XmlReadAny(XMLNodePointer_t node, void *obj, TClass **cl)
Recreate object from xml structure.
Definition: TBufferXML.cxx:244

TBufferXML::StackNode
XMLNodePointer_t StackNode()
Return pointer on current xml node.
Definition: TBufferXML.cxx:321

TBufferXML::WriteObjectClass
void WriteObjectClass(const void *actualObjStart, const TClass *actualClass, Bool_t cacheReuse) final
Write object to buffer. Only used from TBuffer.
Definition: TBufferXML.cxx:1514

TBufferXML::fIOVersion
Int_t fIOVersion
! Indicates format of ROOT xml file
Definition: TBufferXML.h:331

TBufferXML::XmlReadFastArray
R__ALWAYS_INLINE void XmlReadFastArray(T *arr, Int_t n)
Template method to read content of array, which not include size of array Also treated situation,...
Definition: TBufferXML.cxx:1779

TBufferXML::VerifyItemNode
Bool_t VerifyItemNode(const char *name, const char *errinfo=nullptr)
Checks, if stack node is item and has specified name.
Definition: TBufferXML.cxx:687

TBufferXML::ConvertFromXMLChecked
static void * ConvertFromXMLChecked(const char *xml, const TClass *expectedClass, Bool_t GenericLayout=kFALSE, Bool_t UseNamespaces=kFALSE)
Convert from XML and check if object derived from specified class When possible, cast to given class.
Definition: TBufferXML.cxx:200

TBufferXML::ReadObjectAny
void * ReadObjectAny(const TClass *clCast) final
Read object from buffer. Only used from TBuffer.
Definition: TBufferXML.cxx:1493

TBufferXML::ReadLong
void ReadLong(Long_t &l) final
Reads Long_t value from buffer.
Definition: TBufferXML.cxx:2476

TBufferXML::ExtractReference
void ExtractReference(XMLNodePointer_t node, const void *ptr, const TClass *cl)
Analyze if node has "ref" attribute and register it to object map.
Definition: TBufferXML.cxx:594

TBufferXML::SetCompressionLevel
void SetCompressionLevel(Int_t level=ROOT::RCompressionSetting::ELevel::kUseMin)
See comments for function SetCompressionSettings.
Definition: TBufferXML.cxx:358

TBufferXML::ReadVersion
Version_t ReadVersion(UInt_t *start=nullptr, UInt_t *bcnt=nullptr, const TClass *cl=nullptr) final
Read version value from buffer.
Definition: TBufferXML.cxx:1428

TBufferXML::ReadInt
void ReadInt(Int_t &i) final
Reads Int_t value from buffer.
Definition: TBufferXML.cxx:2458

TBufferXML::ClassDefOverride
ClassDefOverride(TBufferXML, 0)

TBufferXML::ReadArray
Int_t ReadArray(Bool_t *&b) final
Read array of Bool_t from buffer.
Definition: TBufferXML.cxx:1568

TBufferXML::SetCompressionAlgorithm
void SetCompressionAlgorithm(Int_t algorithm=ROOT::RCompressionSetting::EAlgorithm::kUseGlobal)
See comments for function SetCompressionSettings.
Definition: TBufferXML.cxx:343

TBufferXML::WriteDouble
void WriteDouble(Double_t d) final
Writes Double_t value to buffer.
Definition: TBufferXML.cxx:2736

TBufferXML::CheckVersionBuf
void CheckVersionBuf()
Checks buffer, filled by WriteVersion if next data is arriving, version should be stored in buffer.
Definition: TBufferXML.cxx:1460

TBufferXML::XmlWriteObject
XMLNodePointer_t XmlWriteObject(const void *obj, const TClass *objClass, Bool_t cacheReuse)
Write object to buffer If object was written before, only pointer will be stored Return pointer to to...
Definition: TBufferXML.cxx:754

TBufferXML::XmlFile
TXMLFile * XmlFile()
Returns pointer to TXMLFile object.
Definition: TBufferXML.cxx:93

TBufferXML::GetInfo
TVirtualStreamerInfo * GetInfo() final
Return current streamer info element.
Definition: TBufferXML.cxx:3161

TBufferXML::WriteUInt
void WriteUInt(UInt_t i) final
Writes UInt_t value to buffer.
Definition: TBufferXML.cxx:2682

TBufferXML::WorkWithElement
void WorkWithElement(TStreamerElement *elem, Int_t comp_type)
This function is a part of SetStreamerElementNumber method.
Definition: TBufferXML.cxx:970

TBufferXML::~TBufferXML
virtual ~TBufferXML()
Destroy xml buffer.
Definition: TBufferXML.cxx:85

TBufferXML::WriteBool
void WriteBool(Bool_t b) final
Writes Bool_t value to buffer.
Definition: TBufferXML.cxx:2628

TBufferXML::XmlWriteBlock
void XmlWriteBlock(XMLNodePointer_t node)
Write binary data block from buffer to xml.
Definition: TBufferXML.cxx:389

TBufferXML::fExpectedBaseClass
TClass * fExpectedBaseClass
! Pointer to class, which should be stored as parent of current
Definition: TBufferXML.h:329

TBufferXML::ToXML
static TString ToXML(const T *obj, Bool_t GenericLayout=kFALSE, Bool_t UseNamespaces=kFALSE)
Definition: TBufferXML.h:48

TBufferXML::WriteShort
void WriteShort(Short_t s) final
Writes Short_t value to buffer.
Definition: TBufferXML.cxx:2655

TBufferXML::WriteULong64
void WriteULong64(ULong64_t l) final
Writes ULong64_t value to buffer.
Definition: TBufferXML.cxx:2718

TBufferXML::Stack
TXMLStackObj * Stack(UInt_t depth=0)
Definition: TBufferXML.h:243

TBufferXML::CreateItemNode
XMLNodePointer_t CreateItemNode(const char *name)
Create item node of specified name.
Definition: TBufferXML.cxx:673

TBufferXML::WriteULong
void WriteULong(ULong_t l) final
Writes ULong_t value to buffer.
Definition: TBufferXML.cxx:2700

TBufferXML::PopStack
TXMLStackObj * PopStack()
Remove one level from xml stack.
Definition: TBufferXML.cxx:311

TBufferXML::CreateElemNode
void CreateElemNode(const TStreamerElement *elem)
Create xml node correspondent to TStreamerElement object.
Definition: TBufferXML.cxx:700

TBufferXML::ConvertFromXMLAny
static void * ConvertFromXMLAny(const char *str, TClass **cl=nullptr, Bool_t GenericLayout=kFALSE, Bool_t UseNamespaces=kFALSE)
Read object of any class from XML, produced by ConvertToXML() method.
Definition: TBufferXML.cxx:176

TBufferXML::VerifyElemNode
Bool_t VerifyElemNode(const TStreamerElement *elem)
Checks if stack node correspond to TStreamerElement object.
Definition: TBufferXML.cxx:728

TBufferXML::XmlReadArray
R__ALWAYS_INLINE Int_t XmlReadArray(T *&arr, bool is_static=false)
Template method to read array with size attribute If necessary, array is created.
Definition: TBufferXML.cxx:1545

TBufferXML::ReadCharStar
void ReadCharStar(char *&s) final
Read a char* string.
Definition: TBufferXML.cxx:2611

TBufferXML::ReadUChar
void ReadUChar(UChar_t &c) final
Reads UChar_t value from buffer.
Definition: TBufferXML.cxx:2431

TBufferXML::WriteVersion
UInt_t WriteVersion(const TClass *cl, Bool_t useBcnt=kFALSE) final
Copies class version to buffer, but not writes it to xml Version will be written with next I/O operat...
Definition: TBufferXML.cxx:1475

TBufferXML::WriteUChar
void WriteUChar(UChar_t c) final
Writes UChar_t value to buffer.
Definition: TBufferXML.cxx:2646

TBufferXML::FromXML
static Bool_t FromXML(T *&obj, const char *xml, Bool_t GenericLayout=kFALSE, Bool_t UseNamespaces=kFALSE)
Definition: TBufferXML.h:58

TBufferXML::WriteInt
void WriteInt(Int_t i) final
Writes Int_t value to buffer.
Definition: TBufferXML.cxx:2673

TBuffer
Buffer base class used for serializing objects.
Definition: TBuffer.h:42

TBuffer::EMode
EMode
Definition: TBuffer.h:72

TClass
TClass instances represent classes, structs and namespaces in the ROOT type system.
Definition: TClass.h:75

TExMap
This class stores a (key,value) pair using an external hash.
Definition: TExMap.h:33

TKeyXML
Definition: TKeyXML.h:20

TMemberStreamer
Definition: TMemberStreamer.h:27

TObjArray
An array of TObjects.
Definition: TObjArray.h:37

TObject
Mother of all ROOT objects.
Definition: TObject.h:37

TStreamerElement
Definition: TStreamerElement.h:33

TStreamerInfo
Describe Streamer information for one class version.
Definition: TStreamerInfo.h:43

TString
Basic string class.
Definition: TString.h:131

TVirtualStreamerInfo
Abstract Interface class describing Streamer information for one class.
Definition: TVirtualStreamerInfo.h:37

TXMLEngine
Definition: TXMLEngine.h:26

TXMLFile
Definition: TXMLFile.h:26

TXMLSetup
Definition: TXMLSetup.h:82

n
const Int_t n
Definition: legend1.C:16

ROOT::Math::Chebyshev::T
double T(double x)
Definition: ChebyshevPol.h:34

ROOT
VSD Structures.
Definition: StringConv.hxx:21

TGeant4Unit::s
static constexpr double s
Definition: TGeant4SystemOfUnits.h:162

file
Definition: file.py:1

v
@ v
Definition: rootcling_impl.cxx:3622

l
auto * l
Definition: textangle.C:4