Logo ROOT  
Reference Guide
TStreamerInfoActions.h
Go to the documentation of this file.
1 // @(#)root/io:$Id$
2 // Author: Philippe Canal 05/2010
3 
4 /*************************************************************************
5  * Copyright (C) 1995-2004, Rene Brun and Fons Rademakers. *
6  * All rights reserved. *
7  * *
8  * For the licensing terms see $ROOTSYS/LICENSE. *
9  * For the list of contributors see $ROOTSYS/README/CREDITS. *
10  *************************************************************************/
11 
12 #ifndef ROOT_TStreamerInfoActions
13 #define ROOT_TStreamerInfoActions
14 
15 #include <vector>
16 #include <ROOT/RMakeUnique.hxx>
17 
18 #include "TStreamerInfo.h"
19 #include "TVirtualArray.h"
20 
21 /**
22 \class TStreamerInfoActions::TConfiguration
23 \ingroup IO
24 */
25 
26 namespace TStreamerInfoActions {
27 
28  /// Base class of the Configurations.
30  protected:
31  public:
33  TVirtualStreamerInfo *fInfo; ///< TStreamerInfo form which the action is derived
34  UInt_t fElemId; ///< Identifier of the TStreamerElement
35  TCompInfo_t *fCompInfo;///< Access to compiled information (for legacy code)
36  Int_t fOffset; ///< Offset within the object
37  UInt_t fLength; ///< Number of element in a fixed length array.
38  public:
39  TConfiguration(TVirtualStreamerInfo *info, UInt_t id, TCompInfo_t *compinfo, Int_t offset) : fInfo(info), fElemId(id), fCompInfo(compinfo), fOffset(offset),fLength(1) {};
40  TConfiguration(TVirtualStreamerInfo *info, UInt_t id, TCompInfo_t *compinfo, Int_t offset, UInt_t length) : fInfo(info), fElemId(id), fCompInfo(compinfo), fOffset(offset),fLength(length) {};
41  virtual ~TConfiguration() {};
42 
43  virtual void AddToOffset(Int_t delta);
44  virtual void SetMissing();
45 
46  virtual TConfiguration *Copy() { return new TConfiguration(*this); }
47 
48  virtual void Print() const;
49  virtual void PrintDebug(TBuffer &buffer, void *object) const;
50  };
51 
52  /// Base class of the Configurations for the member wise looping routines.
54  public:
56  public:
57  TLoopConfiguration() = default;
59 
60  // virtual void PrintDebug(TBuffer &buffer, void *object) const;
61  virtual ~TLoopConfiguration() {};
62  virtual void Print() const;
63  virtual void *GetFirstAddress(void *start, const void *end) const = 0;
64  virtual TLoopConfiguration* Copy() const = 0; // { return new TLoopConfiguration(*this); }
65  virtual TVirtualCollectionProxy* GetCollectionProxy() const { return fProxy; }
66  };
67 
69 
70  typedef Int_t (*TStreamerInfoAction_t)(TBuffer &buf, void *obj, const TConfiguration *conf);
71  typedef Int_t (*TStreamerInfoVecPtrLoopAction_t)(TBuffer &buf, void *iter, const void *end, const TConfiguration *conf);
72  typedef Int_t (*TStreamerInfoLoopAction_t)(TBuffer &buf, void *iter, const void *end, const TLoopConfiguration *loopconf, const TConfiguration *conf);
73 
74  class TConfiguredAction : public TObject {
75  public:
76  union {
80  };
82  private:
83  // assignment operator must be the default because the 'copy' constructor is actually a move constructor and must be used.
84  public:
87  {
88  // WARNING: Technically this is a move constructor ...
89  const_cast<TConfiguredAction&>(rval).fConfiguration = 0;
90  }
92  {
93  // WARNING: Technically this is a move assignment!.
94 
95  TConfiguredAction tmp(rval); // this does a move.
96  TObject::operator=(tmp); // we are missing TObject::Swap
99  return *this;
100  };
101 
103  {
104  // Usual constructor.
105  }
107  {
108  // Usual constructor.
109  }
111  {
112  // Usual constructor.
113  }
115  // Usual destructor.
116  // Idea: the configuration ownership might be moved to a single list so that
117  // we can shared them between the optimized and non-optimized list of actions.
118  delete fConfiguration;
119  }
120  void PrintDebug(TBuffer &buffer, void *object) const;
121 
122  inline Int_t operator()(TBuffer &buffer, void *object) const {
123  return fAction(buffer, object, fConfiguration);
124  }
125 
126  inline Int_t operator()(TBuffer &buffer, void *start_collection, const void *end_collection) const {
127  return fVecPtrLoopAction(buffer, start_collection, end_collection, fConfiguration);
128  }
129 
130  inline Int_t operator()(TBuffer &buffer, void *start_collection, const void *end_collection, const TLoopConfiguration *loopconf) const {
131  return fLoopAction(buffer, start_collection, end_collection, loopconf, fConfiguration);
132  }
133 
134  ClassDef(TConfiguredAction,0); // A configured action
135  };
136 
137  struct TIDNode;
138  using TIDs = std::vector<TIDNode>;
139 
140  // Hold information about unfolded/extracted StreamerElement for
141  // a sub-object
142  struct TNestedIDs {
143  TNestedIDs() = default;
144  TNestedIDs(TStreamerInfo *info, Int_t offset) : fInfo(info), fOffset(offset) {}
146  if (fOwnOnfileObject)
147  delete fOnfileObject;
148  }
149  TStreamerInfo *fInfo = nullptr; ///< Not owned.
154  };
155 
156  // A 'node' in the list of StreamerElement ID, either
157  // the index of the element in the current streamerInfo
158  // or a set of unfolded/extracted StreamerElement for a sub-object.
159  struct TIDNode {
160  TIDNode() = default;
161  TIDNode(Int_t id) : fElemID(id), fElement(nullptr), fInfo(nullptr) {}
162  TIDNode(TStreamerInfo *info, Int_t offset) : fElemID(-1), fElement(nullptr), fInfo(nullptr) {
163  fNestedIDs = std::make_unique<TNestedIDs>(info, offset);
164  }
167  TStreamerInfo *fInfo = nullptr;
168  std::unique_ptr<TNestedIDs> fNestedIDs;
169  };
170 
171  typedef std::vector<TConfiguredAction> ActionContainer_t;
172  class TActionSequence : public TObject {
174  public:
175  struct SequencePtr;
176  using SequenceGetter_t = SequencePtr(*)(TStreamerInfo *info, TVirtualCollectionProxy *collectionProxy, TClass *originalClass);
177 
178  TActionSequence(TVirtualStreamerInfo *info, UInt_t maxdata) : fStreamerInfo(info), fLoopConfig(0) { fActions.reserve(maxdata); };
180  delete fLoopConfig;
181  }
182 
183  template <typename action_t>
184  void AddAction( action_t action, TConfiguration *conf ) {
185  fActions.push_back( TConfiguredAction(action, conf) );
186  }
187  void AddAction(const TConfiguredAction &action ) {
188  fActions.push_back( action );
189  }
190 
191  TVirtualStreamerInfo *fStreamerInfo; ///< StreamerInfo used to derive these actions.
192  TLoopConfiguration *fLoopConfig; ///< If this is a bundle of memberwise streaming action, this configures the looping
194 
195  void AddToOffset(Int_t delta);
196  void SetMissing();
197 
201  TActionSequence *CreateSubSequence(const std::vector<Int_t> &element_ids, size_t offset);
202 
203  TActionSequence *CreateSubSequence(const TIDs &element_ids, size_t offset, SequenceGetter_t create);
204  void AddToSubSequence(TActionSequence *sequence, const TIDs &element_ids, Int_t offset, SequenceGetter_t create);
205 
206  void Print(Option_t * = "") const;
207 
208  // Maybe owner unique_ptr
209  struct SequencePtr {
212 
213  SequencePtr() = default;
214 
216  from.fOwner = false;
217  }
218 
220 
222  if (fOwner) delete fSequence;
223  }
224 
225  // Accessor to the pointee.
227  return *fSequence;
228  }
229 
230  // Accessor to the pointee
232  return fSequence;
233  }
234 
235  // Return true is the pointee is not nullptr.
236  operator bool() {
237  return fSequence != nullptr;
238  }
239  };
240 
241  // SequenceGetter_t implementations
242 
243  static SequencePtr ReadMemberWiseActionsCollectionGetter(TStreamerInfo *info, TVirtualCollectionProxy * /* collectionProxy */, TClass * /* originalClass */) {
244  auto seq = info->GetReadMemberWiseActions(kTRUE);
245  return {seq, kFALSE};
246  }
248  auto seq = collectionProxy->GetConversionReadMemberWiseActions(originalClass, info->GetClassVersion());
249  return {seq, kFALSE};
250  }
251  static SequencePtr ReadMemberWiseActionsViaProxyGetter(TStreamerInfo *info, TVirtualCollectionProxy *collectionProxy, TClass * /* originalClass */) {
252  auto seq = collectionProxy->GetReadMemberWiseActions(info->GetClassVersion());
253  return {seq, kFALSE};
254  }
255  static SequencePtr ReadMemberWiseActionsCollectionCreator(TStreamerInfo *info, TVirtualCollectionProxy *collectionProxy, TClass * /* originalClass */) {
257  return {seq, kTRUE};
258  }
259  // Creator5() = Creator1;
260  static SequencePtr ReadMemberWiseActionsGetter(TStreamerInfo *info, TVirtualCollectionProxy * /* collectionProxy */, TClass * /* originalClass */) {
261  auto seq = info->GetReadMemberWiseActions(kFALSE);
262  return {seq, kFALSE};
263  }
264 
265  static SequencePtr WriteMemberWiseActionsCollectionGetter(TStreamerInfo *info, TVirtualCollectionProxy * /* collectionProxy */, TClass * /* originalClass */) {
266  auto seq = info->GetWriteMemberWiseActions(kTRUE);
267  return {seq, kFALSE};
268  }
270  auto seq = collectionProxy->GetWriteMemberWiseActions();
271  return {seq, kFALSE};
272  }
273  static SequencePtr WriteMemberWiseActionsCollectionCreator(TStreamerInfo *info, TVirtualCollectionProxy *collectionProxy, TClass * /* originalClass */) {
275  return {seq, kTRUE};
276  }
277  // Creator5() = Creator1;
278  static SequencePtr WriteMemberWiseActionsGetter(TStreamerInfo *info, TVirtualCollectionProxy * /* collectionProxy */, TClass * /* originalClass */) {
279  auto seq = info->GetWriteMemberWiseActions(kFALSE);
280  return {seq, kFALSE};
281  }
283  };
284 
285 }
286 
287 #endif // ROOT_TStreamerInfoActions
288 
289 
TStreamerInfoActions::TActionSequence::AddToSubSequence
void AddToSubSequence(TActionSequence *sequence, const TIDs &element_ids, Int_t offset, SequenceGetter_t create)
Definition: TStreamerInfoActions.cxx:4218
TStreamerInfoActions::TLoopConfiguration::GetCollectionProxy
virtual TVirtualCollectionProxy * GetCollectionProxy() const
Definition: TStreamerInfoActions.h:65
TStreamerInfoActions::TActionSequence::SequenceGetter_t
SequencePtr(*)(TStreamerInfo *info, TVirtualCollectionProxy *collectionProxy, TClass *originalClass) SequenceGetter_t
Definition: TStreamerInfoActions.h:176
TStreamerInfoActions::TConfiguration::Print
virtual void Print() const
Definition: TStreamerInfoActions.cxx:96
TStreamerInfoActions::TIDNode::fNestedIDs
std::unique_ptr< TNestedIDs > fNestedIDs
Definition: TStreamerInfoActions.h:168
TVirtualCollectionProxy::GetReadMemberWiseActions
virtual TStreamerInfoActions::TActionSequence * GetReadMemberWiseActions(Int_t version)=0
TStreamerInfoActions::TStreamerInfoAction_t
Int_t(* TStreamerInfoAction_t)(TBuffer &buf, void *obj, const TConfiguration *conf)
Definition: TStreamerInfoActions.h:70
TStreamerInfoActions::TActionSequence::CreateSubSequence
TActionSequence * CreateSubSequence(const std::vector< Int_t > &element_ids, size_t offset)
Definition: TStreamerInfoActions.cxx:4295
TStreamerInfoActions::TConfiguredAction
Definition: TStreamerInfoActions.h:74
TStreamerInfoActions::TLoopConfiguration::~TLoopConfiguration
virtual ~TLoopConfiguration()
Definition: TStreamerInfoActions.h:61
TStreamerInfoActions::TConfiguration::Copy
virtual TConfiguration * Copy()
Definition: TStreamerInfoActions.h:46
TStreamerInfoActions::TConfiguredAction::TConfiguredAction
TConfiguredAction(TStreamerInfoAction_t action, TConfiguration *conf)
Definition: TStreamerInfoActions.h:102
TStreamerInfoActions::TActionSequence::TActionSequence
TActionSequence()
Definition: TStreamerInfoActions.h:173
kTRUE
const Bool_t kTRUE
Definition: RtypesCore.h:91
TStreamerInfoActions::TConfiguredAction::~TConfiguredAction
~TConfiguredAction()
Definition: TStreamerInfoActions.h:114
TStreamerInfoActions::TActionSequence::TActionSequence
TActionSequence(TVirtualStreamerInfo *info, UInt_t maxdata)
Definition: TStreamerInfoActions.h:178
Option_t
const char Option_t
Definition: RtypesCore.h:66
TStreamerInfoActions::TNestedIDs::fOwnOnfileObject
Bool_t fOwnOnfileObject
Definition: TStreamerInfoActions.h:151
TStreamerInfo.h
TStreamerInfoActions::TActionSequence::SequencePtr
Definition: TStreamerInfoActions.h:209
TStreamerInfoActions::TActionSequence::ReadMemberWiseActionsCollectionCreator
static SequencePtr ReadMemberWiseActionsCollectionCreator(TStreamerInfo *info, TVirtualCollectionProxy *collectionProxy, TClass *)
Definition: TStreamerInfoActions.h:255
TStreamerInfoActions::TConfiguration::fElemId
UInt_t fElemId
Identifier of the TStreamerElement.
Definition: TStreamerInfoActions.h:34
TStreamerInfoActions::TNestedIDs::TNestedIDs
TNestedIDs(TStreamerInfo *info, Int_t offset)
Definition: TStreamerInfoActions.h:144
TStreamerInfoActions::TConfiguredAction::PrintDebug
void PrintDebug(TBuffer &buffer, void *object) const
Definition: TStreamerInfoActions.cxx:88
TStreamerInfoActions::TActionSequence::SetMissing
void SetMissing()
Definition: TStreamerInfoActions.cxx:4184
TStreamerInfoActions::TActionSequence::SequencePtr::SequencePtr
SequencePtr()=default
TStreamerInfoActions::TConfiguration::TConfiguration
TConfiguration(TVirtualStreamerInfo *info, UInt_t id, TCompInfo_t *compinfo, Int_t offset)
Definition: TStreamerInfoActions.h:39
TStreamerInfoActions::TConfiguredAction::fConfiguration
TConfiguration * fConfiguration
Definition: TStreamerInfoActions.h:81
TStreamerInfoActions::TConfiguration::fCompInfo
TCompInfo_t * fCompInfo
Access to compiled information (for legacy code)
Definition: TStreamerInfoActions.h:35
TStreamerInfoActions::TActionSequence::ReadMemberWiseActionsGetter
static SequencePtr ReadMemberWiseActionsGetter(TStreamerInfo *info, TVirtualCollectionProxy *, TClass *)
Definition: TStreamerInfoActions.h:260
TStreamerInfoActions::TConfiguration::PrintDebug
virtual void PrintDebug(TBuffer &buffer, void *object) const
Definition: TStreamerInfoActions.cxx:111
TStreamerInfoActions::TActionSequence::fActions
ActionContainer_t fActions
Definition: TStreamerInfoActions.h:193
TStreamerInfoActions::TConfiguredAction::operator()
Int_t operator()(TBuffer &buffer, void *object) const
Definition: TStreamerInfoActions.h:122
Int_t
int Int_t
Definition: RtypesCore.h:45
TStreamerInfoActions::TActionSequence::AddAction
void AddAction(action_t action, TConfiguration *conf)
Definition: TStreamerInfoActions.h:184
TStreamerInfoActions::TIDNode::fElemID
Int_t fElemID
Definition: TStreamerInfoActions.h:165
TStreamerInfo::GetWriteMemberWiseActions
TStreamerInfoActions::TActionSequence * GetWriteMemberWiseActions(Bool_t forCollection)
Definition: TStreamerInfo.h:217
TVirtualCollectionProxy::GetConversionReadMemberWiseActions
virtual TStreamerInfoActions::TActionSequence * GetConversionReadMemberWiseActions(TClass *oldClass, Int_t version)=0
TStreamerInfoActions::TConfiguration::fInfo
TVirtualStreamerInfo * fInfo
TStreamerInfo form which the action is derived.
Definition: TStreamerInfoActions.h:33
TStreamerInfoActions::TActionSequence::SequencePtr::SequencePtr
SequencePtr(SequencePtr &&from)
Definition: TStreamerInfoActions.h:215
TVirtualArray
Wrapper around an object and giving indirect access to its content even if the object is not of a cla...
Definition: TVirtualArray.h:26
TStreamerInfoActions::TConfiguredAction::fVecPtrLoopAction
TStreamerInfoVecPtrLoopAction_t fVecPtrLoopAction
Definition: TStreamerInfoActions.h:78
TBuffer
Buffer base class used for serializing objects.
Definition: TBuffer.h:43
TStreamerInfoActions::TActionSequence::WriteMemberWiseActionsCollectionGetter
static SequencePtr WriteMemberWiseActionsCollectionGetter(TStreamerInfo *info, TVirtualCollectionProxy *, TClass *)
Definition: TStreamerInfoActions.h:265
TStreamerInfoActions::TIDNode::TIDNode
TIDNode()=default
TStreamerInfoActions::TActionSequence::ReadMemberWiseActionsCollectionGetter
static SequencePtr ReadMemberWiseActionsCollectionGetter(TStreamerInfo *info, TVirtualCollectionProxy *, TClass *)
Definition: TStreamerInfoActions.h:243
TStreamerInfoActions::TActionSequence::ConversionReadMemberWiseActionsViaProxyGetter
static SequencePtr ConversionReadMemberWiseActionsViaProxyGetter(TStreamerInfo *info, TVirtualCollectionProxy *collectionProxy, TClass *originalClass)
Definition: TStreamerInfoActions.h:247
TStreamerInfoActions::TConfiguration::fOffset
Int_t fOffset
Offset within the object.
Definition: TStreamerInfoActions.h:36
TStreamerInfoActions::TActionSequence::SequencePtr::fOwner
Bool_t fOwner
Definition: TStreamerInfoActions.h:211
TStreamerInfoActions::TNestedIDs::fOffset
Int_t fOffset
Definition: TStreamerInfoActions.h:152
TStreamerInfoActions::TActionSequence::WriteMemberWiseActionsGetter
static SequencePtr WriteMemberWiseActionsGetter(TStreamerInfo *info, TVirtualCollectionProxy *, TClass *)
Definition: TStreamerInfoActions.h:278
TVirtualStreamerInfo
Abstract Interface class describing Streamer information for one class.
Definition: TVirtualStreamerInfo.h:37
bool
TStreamerInfoActions::TNestedIDs::fOnfileObject
TVirtualArray * fOnfileObject
Definition: TStreamerInfoActions.h:150
id
XFontStruct * id
Definition: TGX11.cxx:109
TStreamerInfoActions::TConfiguration
Base class of the Configurations.
Definition: TStreamerInfoActions.h:29
TStreamerInfoActions::TActionSequence::CreateWriteMemberWiseActions
static TActionSequence * CreateWriteMemberWiseActions(TVirtualStreamerInfo *info, TVirtualCollectionProxy &proxy)
Create the bundle of the actions necessary for the streaming memberwise of the content described by '...
Definition: TStreamerInfoActions.cxx:4006
TStreamerInfoActions::TActionSequence::SequencePtr::SequencePtr
SequencePtr(TStreamerInfoActions::TActionSequence *sequence, Bool_t owner)
Definition: TStreamerInfoActions.h:219
TStreamerInfoActions::TConfiguration::~TConfiguration
virtual ~TConfiguration()
Definition: TStreamerInfoActions.h:41
TStreamerInfoActions::TActionSequence::fLoopConfig
TLoopConfiguration * fLoopConfig
If this is a bundle of memberwise streaming action, this configures the looping.
Definition: TStreamerInfoActions.h:192
TStreamerInfoActions::TNestedIDs
Definition: TStreamerInfoActions.h:142
TStreamerInfoActions::TActionSequence::SequencePtr::fSequence
TStreamerInfoActions::TActionSequence * fSequence
Definition: TStreamerInfoActions.h:210
TStreamerInfoActions::TActionSequence::AddToOffset
void AddToOffset(Int_t delta)
Definition: TStreamerInfoActions.cxx:4169
TStreamerInfoActions::TLoopConfiguration::GetFirstAddress
virtual void * GetFirstAddress(void *start, const void *end) const =0
TStreamerInfo
Describe Streamer information for one class version.
Definition: TStreamerInfo.h:44
TStreamerInfoActions::TLoopConfiguration::Print
virtual void Print() const
Definition: TStreamerInfoActions.cxx:129
TStreamerInfo::GetReadMemberWiseActions
TStreamerInfoActions::TActionSequence * GetReadMemberWiseActions(Bool_t forCollection)
Definition: TStreamerInfo.h:214
TStreamerInfoActions
Definition: TBuffer.h:39
TVirtualCollectionProxy::GetWriteMemberWiseActions
virtual TStreamerInfoActions::TActionSequence * GetWriteMemberWiseActions()=0
kFALSE
const Bool_t kFALSE
Definition: RtypesCore.h:92
TStreamerInfoActions::TNestedIDs::~TNestedIDs
~TNestedIDs()
Definition: TStreamerInfoActions.h:145
TStreamerInfoActions::TActionSequence::SequencePtr::operator*
TStreamerInfoActions::TActionSequence & operator*() const
Definition: TStreamerInfoActions.h:226
TStreamerInfoActions::TIDNode::fInfo
TStreamerInfo * fInfo
Definition: TStreamerInfoActions.h:167
TStreamerInfoActions::TNestedIDs::TNestedIDs
TNestedIDs()=default
TStreamerInfoActions::TConfiguration::TConfiguration
TConfiguration(TVirtualStreamerInfo *info, UInt_t id, TCompInfo_t *compinfo, Int_t offset, UInt_t length)
Definition: TStreamerInfoActions.h:40
TStreamerInfoActions::TLoopConfiguration::Copy
virtual TLoopConfiguration * Copy() const =0
TStreamerInfoActions::TConfiguredAction::TConfiguredAction
TConfiguredAction()
Definition: TStreamerInfoActions.h:85
TStreamerInfoActions::TActionSequence::WriteMemberWiseActionsViaProxyGetter
static SequencePtr WriteMemberWiseActionsViaProxyGetter(TStreamerInfo *, TVirtualCollectionProxy *collectionProxy, TClass *)
Definition: TStreamerInfoActions.h:269
TStreamerInfoActions::TNestedIDs::fInfo
TStreamerInfo * fInfo
Not owned.
Definition: TStreamerInfoActions.h:149
TStreamerInfoActions::TNestedIDs::fIDs
TIDs fIDs
Definition: TStreamerInfoActions.h:153
TVirtualArray.h
TStreamerInfoActions::TLoopConfiguration::TLoopConfiguration
TLoopConfiguration(TVirtualCollectionProxy *proxy)
Definition: TStreamerInfoActions.h:58
TStreamerInfoActions::TConfiguration::SetMissing
virtual void SetMissing()
Definition: TStreamerInfoActions.cxx:80
TStreamerInfoActions::TConfiguredAction::TConfiguredAction
TConfiguredAction(const TConfiguredAction &rval)
Definition: TStreamerInfoActions.h:86
TStreamerInfoActions::TLoopConfiguration::TLoopConfiguration
TLoopConfiguration()=default
TStreamerInfoActions::TActionSequence::CreateReadMemberWiseActions
static TActionSequence * CreateReadMemberWiseActions(TVirtualStreamerInfo *info, TVirtualCollectionProxy &proxy)
Create the bundle of the actions necessary for the streaming memberwise of the content described by '...
Definition: TStreamerInfoActions.cxx:3889
unsigned int
TStreamerInfo::GetClassVersion
Int_t GetClassVersion() const
Definition: TStreamerInfo.h:208
TStreamerInfo::TCompInfo
Definition: TStreamerInfo.h:46
TStreamerInfoActions::TActionSequence::ReadMemberWiseActionsViaProxyGetter
static SequencePtr ReadMemberWiseActionsViaProxyGetter(TStreamerInfo *info, TVirtualCollectionProxy *collectionProxy, TClass *)
Definition: TStreamerInfoActions.h:251
TStreamerInfoActions::TStreamerInfoLoopAction_t
Int_t(* TStreamerInfoLoopAction_t)(TBuffer &buf, void *iter, const void *end, const TLoopConfiguration *loopconf, const TConfiguration *conf)
Definition: TStreamerInfoActions.h:72
TStreamerInfoActions::Next_t
TVirtualCollectionProxy::Next_t Next_t
Definition: TStreamerInfoActions.h:68
TStreamerInfoActions::TIDNode
Definition: TStreamerInfoActions.h:159
TStreamerInfoActions::TConfiguredAction::fLoopAction
TStreamerInfoLoopAction_t fLoopAction
Definition: TStreamerInfoActions.h:79
TStreamerInfoActions::TActionSequence::SequencePtr::operator->
TStreamerInfoActions::TActionSequence * operator->() const
Definition: TStreamerInfoActions.h:231
TStreamerInfoActions::TActionSequence::WriteMemberWiseActionsCollectionCreator
static SequencePtr WriteMemberWiseActionsCollectionCreator(TStreamerInfo *info, TVirtualCollectionProxy *collectionProxy, TClass *)
Definition: TStreamerInfoActions.h:273
TStreamerInfoActions::TConfiguration::fLength
UInt_t fLength
Number of element in a fixed length array.
Definition: TStreamerInfoActions.h:37
TStreamerInfoActions::TActionSequence::fStreamerInfo
TVirtualStreamerInfo * fStreamerInfo
StreamerInfo used to derive these actions.
Definition: TStreamerInfoActions.h:191
TObject::operator=
TObject & operator=(const TObject &rhs)
TObject assignment operator.
Definition: TObject.h:268
TStreamerInfoActions::TActionSequence::CreateCopy
TActionSequence * CreateCopy()
Definition: TStreamerInfoActions.cxx:4199
TStreamerInfoActions::TIDNode::TIDNode
TIDNode(TStreamerInfo *info, Int_t offset)
Definition: TStreamerInfoActions.h:162
TClass
TClass instances represent classes, structs and namespaces in the ROOT type system.
Definition: TClass.h:80
TStreamerInfoActions::TLoopConfiguration::fProxy
TVirtualCollectionProxy * fProxy
Definition: TStreamerInfoActions.h:55
TStreamerInfoActions::TActionSequence::~TActionSequence
~TActionSequence()
Definition: TStreamerInfoActions.h:179
TStreamerInfoActions::TIDs
std::vector< TIDNode > TIDs
Definition: TStreamerInfoActions.h:138
TObject
Mother of all ROOT objects.
Definition: TObject.h:37
ClassDef
#define ClassDef(name, id)
Definition: Rtypes.h:325
TStreamerInfoActions::TIDNode::TIDNode
TIDNode(Int_t id)
Definition: TStreamerInfoActions.h:161
ROOT::Experimental::Internal::swap
void swap(RDirectoryEntry &e1, RDirectoryEntry &e2) noexcept
Definition: RDirectoryEntry.hxx:94
TVirtualCollectionProxy::Next_t
void *(* Next_t)(void *iter, const void *end)
Definition: TVirtualCollectionProxy.h:177
TStreamerInfoActions::TConfiguration::TCompInfo_t
TStreamerInfo::TCompInfo_t TCompInfo_t
Definition: TStreamerInfoActions.h:32
TStreamerInfoActions::TConfiguration::AddToOffset
virtual void AddToOffset(Int_t delta)
Definition: TStreamerInfoActions.cxx:71
TStreamerInfoActions::TActionSequence::AddAction
void AddAction(const TConfiguredAction &action)
Definition: TStreamerInfoActions.h:187
RMakeUnique.hxx
TStreamerInfoActions::TActionSequence::SequencePtr::~SequencePtr
~SequencePtr()
Definition: TStreamerInfoActions.h:221
TStreamerInfoActions::ActionContainer_t
std::vector< TConfiguredAction > ActionContainer_t
Definition: TStreamerInfoActions.h:171
TStreamerInfoActions::TConfiguredAction::operator()
Int_t operator()(TBuffer &buffer, void *start_collection, const void *end_collection) const
Definition: TStreamerInfoActions.h:126
TStreamerInfoActions::TConfiguredAction::operator()
Int_t operator()(TBuffer &buffer, void *start_collection, const void *end_collection, const TLoopConfiguration *loopconf) const
Definition: TStreamerInfoActions.h:130
TStreamerInfoActions::TActionSequence
Definition: TStreamerInfoActions.h:172
TStreamerInfoActions::TConfiguredAction::fAction
TStreamerInfoAction_t fAction
Definition: TStreamerInfoActions.h:77
TStreamerInfoActions::TConfiguredAction::TConfiguredAction
TConfiguredAction(TStreamerInfoVecPtrLoopAction_t action, TConfiguration *conf)
Definition: TStreamerInfoActions.h:106
TStreamerInfoActions::TStreamerInfoVecPtrLoopAction_t
Int_t(* TStreamerInfoVecPtrLoopAction_t)(TBuffer &buf, void *iter, const void *end, const TConfiguration *conf)
Definition: TStreamerInfoActions.h:71
TStreamerInfoActions::TConfiguredAction::TConfiguredAction
TConfiguredAction(TStreamerInfoLoopAction_t action, TConfiguration *conf)
Definition: TStreamerInfoActions.h:110
TStreamerInfoActions::TConfiguredAction::operator=
TConfiguredAction & operator=(const TConfiguredAction &rval)
Definition: TStreamerInfoActions.h:91
TStreamerInfoActions::TLoopConfiguration
Base class of the Configurations for the member wise looping routines.
Definition: TStreamerInfoActions.h:53
TStreamerElement
Definition: TStreamerElement.h:33
TVirtualCollectionProxy
Definition: TVirtualCollectionProxy.h:38
TStreamerInfoActions::TIDNode::fElement
TStreamerElement * fElement
Definition: TStreamerInfoActions.h:166
int
TStreamerInfoActions::TActionSequence::Print
void Print(Option_t *="") const
This method must be overridden when a class wants to print itself.
Definition: TStreamerInfoActions.cxx:4372