ATLAS Offline Software
TEventProxyDict.cxx
Go to the documentation of this file.
1 // Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
2 //
3 // File holding the implementation of the xAOD::TEvent functions that implement
4 // the IProxyDict interface. Just to make TEvent.cxx a little smaller.
5 //
6 
7 // System include(s):
8 #include <stdexcept>
9 #include <set>
10 
11 // ROOT include(s):
12 #include <TClass.h>
13 #include <TString.h>
14 #include <TBranch.h>
15 
16 // Offline include(s):
17 #ifndef XAOD_STANDALONE
18 # include "SGTools/DataProxy.h"
21 # include "GaudiKernel/Converter.h"
22 # include "GaudiKernel/GenericAddress.h"
23 #endif // NOT XAOD_STANDALONE
24 
27 #include "xAODRootAccess/TEvent.h"
31 
32 
33 
34 namespace {
36  typedef AthContainers_detail::mutex mutex_t;
38  typedef AthContainers_detail::lock_guard< mutex_t > guard_t;
39 }
40 
41 
42 #ifndef XAOD_STANDALONE
43 namespace xAODPrivate {
44 
46  class THolderBucket : public DataBucketBase {
47 
48  public:
50  THolderBucket( const std::string& key,
51  const std::type_info& ti,
53  : m_key( key ), m_ti( ti ), m_event( event ) {}
54 
56  void* object() override {
57 
58  // Look among the output objects first:
59  const void* result = m_event.getOutputObject( m_key, m_ti );
60  // Check if it succeeded:
61  if( ! result ) {
62  // Try the input then:
64  } else {
65  // Even if there is an output object with this key, it may
66  // be an input object that was copied to the output. So let's
67  // try to silently retrieve an input object as well. This makes
68  // sure that the input/output object is updated for the current
69  // event.
70  m_event.getInputObject( m_key, m_ti, kTRUE );
71  }
72 
73  // Return the pointer:
74  void* nc_result ATLAS_THREAD_SAFE = const_cast< void* >( result ); //DataBucketBase interface
75  return nc_result;
76  }
77 
79  const std::type_info& tinfo() const override {
80 
81  return m_ti;
82  }
83 
86  bool ) override {
87 
88  throw std::runtime_error( "THolderBucket::cast not implemented" );
89  return 0;
90  }
91 
93  void* cast( const std::type_info& tinfo,
95  bool isConst ) override {
96 
97  // Do the cast:
98  static const bool QUIET = true;
99  const void* result = 0;
100  if( isConst ) {
101  // Just look among the inputs:
102  result = m_event.getInputObject( m_key, tinfo, QUIET );
103  } else {
104  // Look among the output objects first:
106  // Check if it succeeded:
107  if( ! result ) {
108  // Try the input then:
109  result = m_event.getInputObject( m_key, tinfo, QUIET );
110  } else {
111  // Even if there is an output object with this key, it may
112  // be an input object that was copied to the output. So let's
113  // try to silently retrieve an input object as well. This makes
114  // sure that the input/output object is updated for the current
115  // event.
116  m_event.getInputObject( m_key, tinfo, QUIET );
117  }
118  }
119 
120  // Return the pointer:
121  void* nc_result ATLAS_THREAD_SAFE = const_cast< void* >( result ); //DataBucketBase interface
122  return nc_result;
123  }
124 
126  void* cast( CLID,
127  const std::type_info& tinfo,
129  bool isConst) override
130  {
131  return THolderBucket::cast (tinfo, irt, isConst);
132  }
133 
135  void relinquish() override {}
137  void lock() override {}
138 
139  private:
141  const std::string m_key;
143  const std::type_info& m_ti;
146 
147  }; // class THolderBucket
148 
149  class TLoader
150  : public Converter
151  {
152  public:
154  const std::string& name,
155  const std::type_info& ti)
156  : Converter (0, CLID_NULL),
157  m_event (event),
158  m_name (name),
159  m_ti (ti),
160  m_proxy (nullptr)
161  {
162  }
163 
164 
166  {
167  m_proxy = &proxy;
168  }
169 
170 
171  virtual StatusCode createObj(IOpaqueAddress*, DataObject*&) override;
172  virtual long repSvcType() const override { return 0; }
173 
174 
175  private:
177  std::string m_name;
178  const std::type_info& m_ti;
180  };
181 
182 
183  StatusCode TLoader::createObj(IOpaqueAddress* /*addr*/, DataObject*& obj)
184  {
185  static const bool SILENT = true;
186  static const bool METADATA = false;
187 
188  // Try to find the object amongst the output objects first:
189  if( m_event.getOutputObject( m_name, m_ti, METADATA ) ) {
191  }
192  // If it's not on the output, try the input:
193  else if( m_event.getInputObject( m_name, m_ti, SILENT, METADATA ) ) {
195  m_proxy->setConst();
196  }
197 
198  return StatusCode::SUCCESS;
199  }
200 
201 } // xAODPrivate namespace
202 #endif // not XAOD_STANDALONE
203 
204 namespace xAOD {
205 
206  SG::DataProxy* TEvent::proxy( const void* const pTransient ) const {
207 
208  // Look up the name of this object
209  std::string name = getName( pTransient );
210  if( name.empty() ) {
211  // Apparently the object is not known...
212  return nullptr;
213  }
214 
215  // Get the metadata object for it:
216  const xAOD::EventFormatElement* efe = 0;
217  static const bool QUIET = true;
218  if( m_outputEventFormat ) {
219  efe = m_outputEventFormat->get( name, QUIET );
220  }
221  if( ! efe ) {
222  efe = m_inputEventFormat.get( name, QUIET );
223  }
224  if( ! efe ) {
225  // No metadata found...
226  return nullptr;
227  }
228 
229  // Return the proxy:
230  const BranchInfo* bi = getBranchInfo( efe->hash() );
231  return bi->m_proxy.get();
232  }
233 
235  const std::string& key ) const {
236 
237  const SG::sgkey_t sgkey = getHash( key );
238  if( ! sgkey ) {
239  return 0;
240  }
241  return proxy_exact( sgkey );
242  }
243 
245 
246  // Get the object describing this branch/object:
247  const BranchInfo* bi = getBranchInfo( sgkey );
248  if( ! bi ) {
249  static SG::SGKeySet missingSGKeys ATLAS_THREAD_SAFE;
250  static mutex_t mutex;
251  guard_t lock(mutex);
252  if( missingSGKeys.emplace( sgkey ).second &&
254  ::Warning( "xAOD::TEvent::proxy_exact",
255  "Can't find BranchInfo for %d.",
256  sgkey );
257  }
258  return 0;
259  }
260 
261  // Access its data proxy:
262  SG::DataProxy* proxy = bi->m_proxy.get();
263 
264  // Return the proxy:
265  return proxy;
266  }
267 
269 
270  {
271  // We can only hold the lock (even though it's a shared lock) for
272  // this limited scope because the call to getInputObject below
273  // leads to a recursion and dead-lock if not released immediately.
275 
276  // If the object already exists, return it:
277  auto it = m_branches.find( sgkey );
278  if( it != m_branches.end() ) {
279  return &( it->second );
280  }
281  }
282 
283  // If not, construct it now:
284  BranchInfo bi;
286  if( ! efe ) {
287  // Apparently this key is not known:
288  return nullptr;
289  }
290 
291  // Helper variable(s).
292  static const bool SILENT = true;
293  static const bool METADATA = false;
294 
295  // The name of the requested object.
296  const std::string& name = getName( sgkey );
297  // This is a bit perverse... In order to let the "base class" figure
298  // out the exact type of this object, we ask for it with a TEvent
299  // pointer. I use that type because I need something that has a
300  // dictionary, and which should always be available when this code
301  // runs. In the end it doesn't matter that the object can't be
302  // retrieved as that type (of course...), it only matters that it gets
303  // "set up" following these calls.
304  TEvent* nc_this = const_cast< TEvent* >( this );
305  static const std::type_info& dummy = typeid( TEvent );
306  nc_this->getInputObject( name, dummy, SILENT, METADATA );
307  auto itr = m_outputObjects.find( name );
308  if( itr == m_outputObjects.end() ) {
309  itr = m_inputObjects.find( name );
310  if( itr == m_inputObjects.end() ) {
311  // We didn't find this object in the store...
312  return nullptr;
313  }
314  }
315  const TObjectManager* mgr =
316  dynamic_cast< const TObjectManager* >( itr->second );
317  if( ! mgr ) {
318  ::Error( "xAOD::TEvent::getBranchInfo",
319  XAOD_MESSAGE( "Internal logic error found" ) );
320  return nullptr;
321  }
322  bi.m_class = mgr->holder()->getClass();
323  // There's no need to check whether this is a "proper" dictionary
324  // at this point, since if TEvent is holding on to it, the type
325  // must have a proper compiled dictionary.
326 
327 #ifndef XAOD_STANDALONE
328  // Create a proper proxy for the input branch:
329  SG::TransientAddress* taddr =
330  new SG::TransientAddress( CLID_NULL, efe->branchName(),
331  new GenericAddress() );
332  taddr->setSGKey( sgkey );
333  xAODPrivate::TLoader* loader =
334  new xAODPrivate::TLoader (*nc_this,
335  getName( sgkey ),
336  *bi.m_class->GetTypeInfo());
337  bi.m_proxy.reset( new SG::DataProxy( taddr, loader ) );
338  loader->setProxy (*bi.m_proxy.get());
339 #endif // not XAOD_STANDALONE
340 
341  // Add the branch info to our list:
343  lock.upgrade();
344  auto ret = m_branches.insert( std::make_pair( sgkey, std::move( bi ) ) );
345 
346  // Return a pointer to the branch info:
347  return &( ret.first->second );
348  }
349 
352 
353  const xAOD::EventFormatElement* efe = 0;
354  static const bool QUIET = true;
355  if( m_outputEventFormat ) {
356  efe = m_outputEventFormat->get( sgkey, QUIET );
357  }
358  if( ! efe ) {
359  efe = m_inputEventFormat.get( sgkey, QUIET );
360  }
361  if ( ! efe ) {
362  static SG::SGKeySet missingSGKeys ATLAS_THREAD_SAFE;
363  static mutex_t mutex;
364  guard_t lock(mutex);
365  if( missingSGKeys.emplace( sgkey ).second ) {
367  ::Warning( "xAOD::TEvent::getEventFormatElement",
368  "Can't find EventFormatElement for hashed "
369  "SG key %d", sgkey );
370  }
371  return 0;
372  }
373  }
374  return efe;
375  }
376 
386 
388 
389  // Warn the user that the function got called:
390  static std::atomic_flag warningPrinted ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT;
391  if ( ! warningPrinted.test_and_set() && m_printEventProxyWarnings) {
392  ::Warning( "xAOD::TEvent::addToStore",
393  "Function should only be called through an invalid "
394  "ElementLink" );
395  }
396 
397  // Hold on to the proxy with some non-existent, hopefully unique key:
398  const ::TString uniqueKey = ::TString::Format( "NonExistentKey_%lu",
399  m_branches.size() );
400  BranchInfo bi;
401  bi.m_proxy.reset( proxy );
402  lock.upgrade();
403  m_branches.insert( std::make_pair( stringToKey( uniqueKey.Data(),
404  clid ),
405  std::move( bi ) ) );
406 
407  // Return gracefully:
408  return StatusCode::SUCCESS;
409  }
410 
411  std::vector< const SG::DataProxy* > TEvent::proxies() const {
412 
414 
415  std::vector< const SG::DataProxy* > ret;
416  for( const auto& p : m_branches ) {
417  const SG::DataProxy* proxy = p.second.m_proxy.get();
418  if( proxy ) {
419  ret.push_back( proxy );
420  }
421  }
422  return ret;
423  }
424 
425  SG::sgkey_t TEvent::stringToKey( const std::string& str, CLID ) {
426 
427  return getHash( str );
428  }
429 
430  const std::string* TEvent::keyToString( SG::sgkey_t key ) const {
431 
432  return &( getName( key ) );
433  }
434 
435  const std::string* TEvent::keyToString( SG::sgkey_t key, CLID& ) const {
436 
437  return &( getName( key ) );
438  }
439 
440  void TEvent::registerKey( SG::sgkey_t, const std::string&, CLID ) {
441 
442  return;
443  }
444 
446  const std::string&, bool, bool ) {
447 
448  throw std::runtime_error( "xAOD::TEvent::recordObject is not "
449  "implemented" );
450  }
451 
452  const std::string& TEvent::name() const {
453 
454  static const std::string NAME = "xAOD::TEvent";
455  return NAME;
456  }
457 
458 } // namespace xAOD
SG::IRegisterTransient
Interface for registering a transient object in t2p map.
Definition: IRegisterTransient.h:28
common.sgkey
def sgkey(tool)
Definition: common.py:1028
xAOD::EventFormat_v1::get
const EventFormatElement * get(const std::string &key, bool quiet=false) const
Get the description of a given branch.
Definition: EventFormat_v1.cxx:91
xAODPrivate::THolderBucket::lock
void lock() override
Lock the held object. A no-op.
Definition: TEventProxyDict.cxx:137
xAOD::TEvent::proxy_exact
SG::DataProxy * proxy_exact(SG::sgkey_t sgkey) const override
Get proxy given a hashed key+clid.
Definition: TEventProxyDict.cxx:244
xAOD::TEvent::name
const std::string & name() const override
Get the name of the instance.
Definition: TEventProxyDict.cxx:452
get_generator_info.result
result
Definition: get_generator_info.py:21
StateLessPT_NewConfig.proxy
proxy
Definition: StateLessPT_NewConfig.py:392
xAOD::TEvent::getInputObject
const void * getInputObject(SG::sgkey_t key, const std::type_info &ti, bool silent=false) override
Function for retrieving an input object in a non-template way.
Definition: Control/xAODRootAccess/Root/TEvent.cxx:1939
DataBucketBase
A non-templated base class for DataBucket, allows to access the transient object address as a void*.
Definition: DataBucketBase.h:24
xAODPrivate::TLoader::m_event
xAOD::TEvent & m_event
Definition: TEventProxyDict.cxx:176
DataBucketBase.h
BeamSpot::mutex
std::mutex mutex
Definition: InDetBeamSpotVertex.cxx:18
xAOD::TEvent::getOutputObject
void * getOutputObject(SG::sgkey_t key, const std::type_info &ti) override
Function for retrieving an output object in a non-template way.
Definition: Control/xAODRootAccess/Root/TEvent.cxx:1915
StateLessPT_NewConfig.Format
Format
Definition: StateLessPT_NewConfig.py:146
xAODPrivate::THolderBucket::tinfo
const std::type_info & tinfo() const override
Return the type_info of the stored object.
Definition: TEventProxyDict.cxx:79
xAODPrivate::THolderBucket::cast
void * cast(CLID, SG::IRegisterTransient *, bool) override
Return the object, cast to a CLID's type.
Definition: TEventProxyDict.cxx:85
skel.it
it
Definition: skel.GENtoEVGEN.py:396
xAOD::TEvent::keyToString
const std::string * keyToString(SG::sgkey_t key) const override
Find the string corresponding to a given key.
Definition: TEventProxyDict.cxx:430
SG::TransientAddress
Definition: TransientAddress.h:32
xAOD::TEvent::m_inputObjects
Object_t m_inputObjects
Collection of all the managed input objects.
Definition: Control/xAODRootAccess/xAODRootAccess/TEvent.h:441
xAOD
ICaloAffectedTool is abstract interface for tools checking if 4 mom is in calo affected region.
Definition: ICaloAffectedTool.h:24
xAOD::EventFormatElement
Class describing one branch of the ROOT file.
Definition: EventFormatElement.h:39
XAOD_MESSAGE
#define XAOD_MESSAGE(MESSAGE)
Simple macro for printing error/verbose messages.
Definition: Control/xAODRootAccess/xAODRootAccess/tools/Message.h:19
xAOD::EventFormatElement::branchName
const std::string & branchName() const
Get the branch/key name.
Definition: EventFormatElement.cxx:30
xAOD::TEvent::stringToKey
SG::sgkey_t stringToKey(const std::string &str, CLID clid) override
Find the string corresponding to a given key.
Definition: TEventProxyDict.cxx:425
xAOD::TEvent::registerKey
void registerKey(SG::sgkey_t key, const std::string &str, CLID clid) override
Remember an additional mapping from key to string/CLID.
Definition: TEventProxyDict.cxx:440
xAOD::TEvent::BranchInfo::m_class
const ::TClass * m_class
Dictionary describing this branch/object.
Definition: Control/xAODRootAccess/xAODRootAccess/TEvent.h:478
xAODPrivate::THolderBucket::cast
void * cast(const std::type_info &tinfo, SG::IRegisterTransient *, bool isConst) override
Return the object, cast to a certain type.
Definition: TEventProxyDict.cxx:93
xAOD::EventFormatElement::hash
sgkey_t hash() const
Get the hash belonging to this branch/key.
Definition: EventFormatElement.cxx:48
xAOD::TEvent::BranchInfo
Helper struct used by the IProxyDict code.
Definition: Control/xAODRootAccess/xAODRootAccess/TEvent.h:474
xAODPrivate::THolderBucket::object
void * object() override
Return the object held.
Definition: TEventProxyDict.cxx:56
BchCleanup.mgr
mgr
Definition: BchCleanup.py:294
xAODPrivate::THolderBucket::m_key
const std::string m_key
The key of the object.
Definition: TEventProxyDict.cxx:141
xAODPrivate::THolderBucket::cast
void * cast(CLID, const std::type_info &tinfo, SG::IRegisterTransient *irt, bool isConst) override
Return the object, cast to type.
Definition: TEventProxyDict.cxx:126
xAOD::TEvent::m_printEventProxyWarnings
Bool_t m_printEventProxyWarnings
Option to silence common warnings that seem to be harmless.
Definition: Control/xAODRootAccess/xAODRootAccess/TEvent.h:468
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
xAOD::TEvent::proxies
std::vector< const SG::DataProxy * > proxies() const override
return the list of all current proxies in store
Definition: TEventProxyDict.cxx:411
xAOD::TEvent::getBranchInfo
const BranchInfo * getBranchInfo(SG::sgkey_t sgkey) const
Get the object describing one object/branch.
Definition: TEventProxyDict.cxx:268
event
POOL::TEvent event(POOL::TEvent::kClassAccess)
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
Message.h
TEvent.h
python.xAODType.dummy
dummy
Definition: xAODType.py:4
xAOD::TEvent::m_inputEventFormat
EventFormat m_inputEventFormat
Format of the current input file.
Definition: Control/xAODRootAccess/xAODRootAccess/TEvent.h:454
xAOD::TEvent::proxy
SG::DataProxy * proxy(const void *const pTransient) const override
get proxy for a given data object address in memory
Definition: TEventProxyDict.cxx:206
xAOD::TEvent::getEventFormatElement
const xAOD::EventFormatElement * getEventFormatElement(SG::sgkey_t sgkey) const
Get the metadata object for a given "SG key".
Definition: TEventProxyDict.cxx:351
xAODPrivate::TLoader::m_ti
const std::type_info & m_ti
Definition: TEventProxyDict.cxx:178
CLID
uint32_t CLID
The Class ID type.
Definition: Event/xAOD/xAODCore/xAODCore/ClassID_traits.h:47
xAODPrivate::TLoader::repSvcType
virtual long repSvcType() const override
Definition: TEventProxyDict.cxx:172
xAOD::TEvent::m_outputObjects
Object_t m_outputObjects
Collection of all the managed output object.
Definition: Control/xAODRootAccess/xAODRootAccess/TEvent.h:446
TObjectManager.h
AthContainers_detail::upgrading_lock::upgrade
void upgrade()
Convert the lock from upgrade to exclusive.
xAODPrivate::TLoader::setProxy
void setProxy(SG::DataProxy &proxy)
Definition: TEventProxyDict.cxx:165
xAOD::TEvent::m_branchesMutex
upgrade_mutex_t m_branchesMutex
Definition: Control/xAODRootAccess/xAODRootAccess/TEvent.h:484
xAODPrivate::TLoader::TLoader
TLoader(xAOD::TEvent &event, const std::string &name, const std::type_info &ti)
Definition: TEventProxyDict.cxx:153
xAODPrivate::THolderBucket
Helper object for holding something through a THolder.
Definition: TEventProxyDict.cxx:46
SG::SGKeySet
std::unordered_set< sgkey_t > SGKeySet
A set of sgkey_t values.
Definition: CxxUtils/CxxUtils/sgkey_t.h:97
Converter
Definition: Converter.h:27
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:228
xAOD::TEvent::TEvent
TEvent(EAuxMode mode=kUndefinedAccess)
Default constructor.
Definition: Control/xAODRootAccess/Root/TEvent.cxx:132
xAODPrivate::THolderBucket::relinquish
void relinquish() override
Give up ownership of the bucket's contents. A no-op.
Definition: TEventProxyDict.cxx:135
xAOD::TObjectManager
Manager for EDM objects created by ROOT.
Definition: TObjectManager.h:29
xAODPrivate::TLoader::createObj
virtual StatusCode createObj(IOpaqueAddress *, DataObject *&) override
Definition: TEventProxyDict.cxx:183
SG::sgkey_t
uint32_t sgkey_t
Type used for hashed StoreGate key+CLID pairs.
Definition: CxxUtils/CxxUtils/sgkey_t.h:32
threading.h
Threading definitions.
xAOD::TEvent::m_outputEventFormat
EventFormat * m_outputEventFormat
Format of the current output file.
Definition: Control/xAODRootAccess/xAODRootAccess/TEvent.h:456
xAODPrivate::TLoader::m_name
std::string m_name
Definition: TEventProxyDict.cxx:177
xAOD::TEvent::ATLAS_THREAD_SAFE
SG::SGKeyMap< BranchInfo > m_branches ATLAS_THREAD_SAFE
Map from hashed sgkey to BranchInfo.
Definition: Control/xAODRootAccess/xAODRootAccess/TEvent.h:487
xAOD::TEvent::recordObject
SG::DataProxy * recordObject(SG::DataObjectSharedPtr< DataObject > obj, const std::string &key, bool allowMods, bool returnExisting) override
Record an object in the store.
Definition: TEventProxyDict.cxx:445
xAOD::TEvent::getHash
SG::sgkey_t getHash(const std::string &key) const override
Function returning the hash describing an object name.
Definition: Control/xAODRootAccess/Root/TEvent.cxx:1650
TransientAddress.h
xAODPrivate::THolderBucket::m_ti
const std::type_info & m_ti
The type info of the object.
Definition: TEventProxyDict.cxx:143
xAODPrivate::THolderBucket::m_event
xAOD::TEvent & m_event
The original TEvent object.
Definition: TEventProxyDict.cxx:145
SG::TransientAddress::setSGKey
void setSGKey(sgkey_t sgkey)
check if it is a transient ID (primary or symLinked):
Definition: TransientAddress.h:229
SG::DataProxy::setConst
void setConst()
Mark this object as const.
Definition: DataProxy.cxx:204
xAODPrivate
Definition: TEventProxyDict.cxx:43
THolder.h
xAOD::TEvent::addToStore
StatusCode addToStore(CLID id, SG::DataProxy *proxy) override
Add a new proxy to the store.
Definition: TEventProxyDict.cxx:385
AthContainers_detail::upgrading_lock
Lock object for taking out upgradable locks.
Definition: threading.h:229
str
Definition: BTagTrackIpAccessor.cxx:11
ATLAS_THREAD_SAFE
#define ATLAS_THREAD_SAFE
Definition: checker_macros.h:211
SG::DataObjectSharedPtr
Smart pointer to manage DataObject reference counts.
Definition: DataObjectSharedPtr.h:45
xAODPrivate::TLoader::m_proxy
SG::DataProxy * m_proxy
Definition: TEventProxyDict.cxx:179
xAOD::TEvent::getName
const std::string & getName(const void *obj) const override
Function returning the key describing a known object.
Definition: Control/xAODRootAccess/Root/TEvent.cxx:1685
checker_macros.h
Define macros for attributes used to control the static checker.
python.PyAthena.obj
obj
Definition: PyAthena.py:132
SG::DataProxy
Definition: DataProxy.h:45
xAOD::TEvent::BranchInfo::m_proxy
std::unique_ptr< SG::DataProxy > m_proxy
Data proxy describing this branch/object.
Definition: Control/xAODRootAccess/xAODRootAccess/TEvent.h:476
xAODPrivate::THolderBucket::THolderBucket
THolderBucket(const std::string &key, const std::type_info &ti, xAOD::TEvent &event)
Constructor with an existing holder.
Definition: TEventProxyDict.cxx:50
xAOD::TEvent
Tool for accessing xAOD files outside of Athena.
Definition: Control/xAODRootAccess/xAODRootAccess/TEvent.h:84
xAODPrivate::TLoader
Definition: TEventProxyDict.cxx:151
mapkey::key
key
Definition: TElectronEfficiencyCorrectionTool.cxx:37
DataProxy.h