Loading [MathJax]/extensions/tex2jax.js
The Gaudi Framework  master (d98a2936)
All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
DataObjectHandle.h
Go to the documentation of this file.
1 /***********************************************************************************\
2 * (c) Copyright 1998-2025 CERN for the benefit of the LHCb and ATLAS collaborations *
3 * *
4 * This software is distributed under the terms of the Apache version 2 licence, *
5 * copied verbatim in the file "LICENSE". *
6 * *
7 * In applying this licence, CERN does not waive the privileges and immunities *
8 * granted to it by virtue of its status as an Intergovernmental Organization *
9 * or submit itself to any jurisdiction. *
10 \***********************************************************************************/
11 #pragma once
12 
17 #include <GaudiKernel/IProperty.h>
18 #include <GaudiKernel/IRegistry.h>
19 #include <GaudiKernel/NamedRange.h>
20 #include <type_traits>
21 
22 //---------------------------------------------------------------------------
23 //
24 namespace details {
25  template <typename T>
26  using Converter_t = T ( * )( const DataObject* );
27 
28  template <typename Range, typename StorageType>
29  Range make_range( const DataObject* obj ) {
30  auto c = static_cast<const StorageType*>( obj );
31  if ( !c ) return Range();
32  using std::begin;
33  using std::end;
34  auto first = begin( *c );
35  auto last = end( *c );
36  auto _first = reinterpret_cast<typename Range::const_iterator*>( &first );
37  auto _last = reinterpret_cast<typename Range::const_iterator*>( &last );
38  return Range( *_first, *_last );
39  }
40 
41  template <typename ValueType, typename Range = Gaudi::Range_<typename ValueType::ConstVector>>
43  using Selection = typename ValueType::Selection;
44  auto sel = dynamic_cast<const Selection*>( obj );
45  if ( sel ) return &make_range<Range, typename ValueType::Selection>;
46  auto con = dynamic_cast<std::add_const_t<typename ValueType::Container>*>( obj );
47  if ( con ) return &make_range<Range, typename ValueType::Container>;
48  return nullptr;
49  }
50 
51  template <typename T>
52  bool verifyType( const DataObject* dataObj ) {
53  using Type = std::add_const_t<T>;
54  assert( dataObj != nullptr );
55  auto obj = dynamic_cast<Type*>( dataObj );
56  bool ok = ( obj != nullptr );
57  if ( !ok ) {
58  const auto* registry = dataObj->registry();
59  throw GaudiException( "The type expected for " + registry->identifier() + " is " +
60  System::typeinfoName( typeid( Type ) ) +
61  " and is different from the one of the object in the store which is " +
62  System::typeinfoName( typeid( *dataObj ) ) + ".",
63  "Wrong DataObjectType", StatusCode::FAILURE );
64  }
65  assert( obj == static_cast<Type*>( dataObj ) );
66  return ok;
67  }
68 
69  template <Gaudi::DataHandle::Mode, typename T, typename U>
70  struct Payload_helper {
71  using type =
72  std::conditional_t<std::is_base_of_v<DataObject, T> && std::is_same_v<T, U>, T,
73  std::conditional_t<std::is_same_v<T, U>, AnyDataWrapper<std::remove_const_t<T>>,
74  AnyDataWithViewWrapper<std::remove_const_t<T>, std::remove_const_t<U>>>>;
75  };
76  template <typename T, typename U>
79  };
80  template <typename T, typename U>
83  };
84  template <typename T, typename U>
85  struct Payload_helper<Gaudi::DataHandle::Reader, std::optional<Gaudi::NamedRange_<T>>, U> {
86  using type = std::optional<Gaudi::NamedRange_<T>>;
87  };
88 
89  template <Gaudi::DataHandle::Mode mode, typename T, typename U = T>
91 
92  std::string replace_all( std::string str, std::string_view from, std::string_view to );
93 } // namespace details
94 
95 //---------------------------------------------------------------------------
96 
107 //---------------------------------------------------------------------------
108 
109 template <typename T>
110 class DataObjectHandle : public DataObjectHandleBase {
111 public:
113 
117  T* get() const { return get( true ); }
118 
123  T* getIfExists() const { return get( false ); }
124 
128  bool exist() const { return get( false ) != nullptr; }
129 
133  T* getOrCreate() const;
134 
138  T* put( std::unique_ptr<T> object ) const;
139 
140  std::string pythonRepr() const override {
142  System::typeinfoName( typeid( T ) ) );
143  }
144 
145 private:
146  T* get( bool mustExist ) const;
147  mutable bool m_goodType = false;
148 };
149 
150 //---------------------------------------------------------------------------
151 //
159 template <typename T>
160 T* DataObjectHandle<T>::get( bool mustExist ) const {
161  auto dataObj = fetch();
162  if ( !dataObj ) {
163  if ( mustExist ) { // Problems in getting from the store
164  throw GaudiException( "Cannot retrieve \'" + objKey() + "\' from transient store.",
165  m_owner ? owner()->name() : "no owner", StatusCode::FAILURE );
166  }
167  return nullptr;
168  }
169  if ( !m_goodType ) m_goodType = ::details::verifyType<T>( dataObj );
170  return static_cast<T*>( dataObj );
171 }
172 
173 //---------------------------------------------------------------------------
174 template <typename T>
175 T* DataObjectHandle<T>::put( std::unique_ptr<T> objectp ) const {
176  assert( m_init );
177  StatusCode sc = m_EDS->registerObject( objKey(), objectp.get() );
178  if ( !sc.isSuccess() ) { throw GaudiException( "Error in put of " + objKey(), "DataObjectHandle<T>::put", sc ); }
179  return objectp.release();
180 }
181 
182 //---------------------------------------------------------------------------
183 template <typename T>
185  T* obj = get( false );
186  return obj ? obj : put( std::make_unique<T>() );
187 }
188 
189 //---------------------------------------------------------------------------
191 
192 template <typename T>
193 class DataObjectHandle<Gaudi::Range_<T>> : public DataObjectHandleBase {
194 public:
195  using ValueType = std::remove_cv_t<std::remove_pointer_t<typename T::value_type>>;
197 
199 
203  Range get() const;
204 
205  std::string pythonRepr() const override {
207  System::typeinfoName( typeid( Gaudi::Range_<T> ) ) );
208  }
209 
210 private:
211  mutable ::details::Converter_t<Range> m_converter = nullptr;
212 };
213 
214 template <typename ValueType>
215 auto DataObjectHandle<Gaudi::Range_<ValueType>>::get() const -> Range {
216  auto dataObj = fetch();
217  if ( !dataObj ) {
218  throw GaudiException( "Cannot retrieve \'" + objKey() + "\' from transient store.",
219  m_owner ? owner()->name() : "no owner", StatusCode::FAILURE );
220  }
221  if ( !m_converter ) {
222  m_converter = ::details::select_range_converter<ValueType>( dataObj );
223  if ( !m_converter ) {
224  throw GaudiException( "The type requested for " + objKey() + " (" + System::typeinfoName( typeid( ValueType ) ) +
225  ")" + " cannot be obtained from object in event store" + " (" +
226  System::typeinfoName( typeid( *dataObj ) ) + ").",
227  "Wrong DataObjectType", StatusCode::FAILURE );
228  }
229  }
230  return ( *m_converter )( dataObj );
231 }
232 
233 //---------------------------------------------------------------------------
235 
236 template <typename T>
237 class DataObjectHandle<Gaudi::NamedRange_<T>> : public DataObjectHandleBase {
238 public:
239  using ValueType = std::remove_cv_t<std::remove_pointer_t<typename T::value_type>>;
241 
243 
247  Range get() const;
248 
249  std::string pythonRepr() const override {
252  }
253 
254 private:
255  mutable ::details::Converter_t<Range> m_converter = nullptr;
256 };
257 
258 template <typename ValueType>
260  auto dataObj = fetch();
261  if ( !dataObj ) {
262  throw GaudiException( "Cannot retrieve \'" + objKey() + "\' from transient store.",
263  m_owner ? owner()->name() : "no owner", StatusCode::FAILURE );
264  }
265  if ( !m_converter ) {
266  m_converter = ::details::select_range_converter<ValueType, Range>( dataObj );
267  if ( !m_converter ) {
268  throw GaudiException( "The type requested for " + objKey() + " (" + System::typeinfoName( typeid( ValueType ) ) +
269  ")" + " cannot be obtained from object in event store" + " (" +
270  System::typeinfoName( typeid( *dataObj ) ) + ").",
271  "Wrong DataObjectType", StatusCode::FAILURE );
272  }
273  }
274  return ( *m_converter )( dataObj );
275 }
276 
277 //
278 //---------------------------------------------------------------------------
280 
281 template <typename T>
282 class DataObjectHandle<std::optional<Gaudi::NamedRange_<T>>> : public DataObjectHandleBase {
283 public:
284  using ValueType = std::remove_cv_t<std::remove_pointer_t<typename T::value_type>>;
286 
288 
292  std::optional<Range> get() const;
293 
294  std::string pythonRepr() const override {
296  System::typeinfoName( typeid( std::optional<Gaudi::NamedRange_<T>> ) ) );
297  }
298 
299 private:
300  mutable ::details::Converter_t<Range> m_converter = nullptr;
301 };
302 
303 template <typename ValueType>
305  auto dataObj = fetch();
306  if ( !dataObj ) return std::nullopt;
307  if ( !m_converter ) {
308  m_converter = ::details::select_range_converter<ValueType, Range>( dataObj );
309  if ( !m_converter ) {
310  throw GaudiException( "The type requested for " + objKey() + " (" + System::typeinfoName( typeid( ValueType ) ) +
311  ")" + " cannot be obtained from object in event store" + " (" +
312  System::typeinfoName( typeid( *dataObj ) ) + ").",
313  "Wrong DataObjectType", StatusCode::FAILURE );
314  }
315  }
316  return ( *m_converter )( dataObj );
317 }
318 
319 //---------------------------------------------------------------------------
321 template <typename T>
323 public:
325 
329  T* get() const { return &_get( true )->getData(); }
330  T* getIfExists() const {
331  auto data = _get( false );
332  return data ? &data->getData() : nullptr;
333  }
334 
338  const T* put( T&& obj ) const {
339  assert( m_init );
340  auto objectp = std::make_unique<AnyDataWrapper<T>>( std::move( obj ) );
341  if ( auto sc = m_EDS->registerObject( objKey(), objectp.get() ); sc.isFailure() ) {
342  throw GaudiException( "Error in put of " + objKey(), "DataObjectHandle<AnyDataWrapper<T>>::put", sc );
343  }
344  return &objectp.release()->getData();
345  }
346 
350  std::optional<std::size_t> size() const { return _get()->size(); }
351 
352  std::string pythonRepr() const override {
354  System::typeinfoName( typeid( T ) ) );
355  }
356 
357 private:
358  AnyDataWrapper<T>* _get( bool mustExist ) const {
359  auto obj = fetch();
360  if ( !obj ) {
361  if ( mustExist ) {
362  throw GaudiException( "Cannot retrieve \'" + objKey() + "\' from transient store.",
363  m_owner ? owner()->name() : "no owner", StatusCode::FAILURE );
364 
365  } else {
366  return nullptr;
367  }
368  }
369  if ( !m_goodType ) m_goodType = ::details::verifyType<AnyDataWrapper<T>>( obj );
370  return static_cast<AnyDataWrapper<T>*>( obj );
371  }
372  mutable bool m_goodType = false;
373 };
374 
375 //---------------------------------------------------------------------------
377 template <typename View, typename Owned>
379 public:
381 
385  View* get() const { return &_get( true )->getData(); }
386  View* getIfExists() const {
387  auto data = _get( false );
388  return data ? &data->getData() : nullptr;
389  }
390 
394  const View* put( std::unique_ptr<AnyDataWithViewWrapper<View, Owned>> objectp ) const {
395  assert( m_init );
396  if ( auto sc = m_EDS->registerObject( objKey(), objectp.get() ); sc.isFailure() ) {
397  throw GaudiException( "Error in put of " + objKey(), "DataObjectHandle<AnyDataWithViewWrapper<T>::put", sc );
398  }
399  return &objectp.release()->getData();
400  }
401  const View* put( Owned&& obj ) const {
402  return put( std::make_unique<AnyDataWithViewWrapper<View, Owned>>( std::move( obj ) ) );
403  }
404 
408  std::optional<std::size_t> size() const { return _get()->size(); }
409 
410  std::string pythonRepr() const override {
412  System::typeinfoName( typeid( View ) ) );
413  }
414 
415 private:
416  AnyDataWithViewWrapper<View, Owned>* _get( bool mustExist ) const {
417  auto obj = fetch();
418  if ( !obj ) {
419  if ( mustExist ) {
420  throw GaudiException( "Cannot retrieve \'" + objKey() + "\' from transient store.",
421  m_owner ? owner()->name() : "no owner", StatusCode::FAILURE );
422 
423  } else {
424  return nullptr;
425  }
426  }
427  if ( !m_goodType ) m_goodType = ::details::verifyType<AnyDataWithViewWrapper<View, Owned>>( obj );
428  return static_cast<AnyDataWithViewWrapper<View, Owned>*>( obj );
429  }
430  mutable bool m_goodType = false;
431 };
432 
433 //---------------------------- user-facing interface ----------
434 namespace details {
435  template <typename T, typename U = T>
437  template <typename T, typename U = T>
439 } // namespace details
440 
441 template <typename T>
443  template <typename... Args, std::size_t... Is>
444  DataObjectReadHandle( std::tuple<Args...>&& args, std::index_sequence<Is...> )
445  : DataObjectReadHandle( std::get<Is>( std::move( args ) )... ) {}
446 
447 public:
449  : ::details::ReadHandle<T>{ k, Gaudi::DataHandle::Reader, owner } {}
450 
453  template <std::derived_from<IProperty> OWNER, typename K>
454  DataObjectReadHandle( OWNER* owner, std::string propertyName, K key = {}, std::string doc = "" )
455  : ::details::ReadHandle<T>( owner, Gaudi::DataHandle::Reader, std::move( propertyName ), std::move( key ),
456  std::move( doc ) ) {}
457 
458  template <typename... Args>
459  DataObjectReadHandle( std::tuple<Args...>&& args )
460  : DataObjectReadHandle( std::move( args ), std::index_sequence_for<Args...>{} ) {}
461 };
462 
463 template <typename T, typename U = T>
465  template <typename... Args, std::size_t... Is>
466  DataObjectWriteHandle( std::tuple<Args...>&& args, std::index_sequence<Is...> )
467  : DataObjectWriteHandle( std::get<Is>( std::move( args ) )... ) {}
468 
469 public:
471  : ::details::WriteHandle<T, U>{ k, Gaudi::DataHandle::Writer, owner } {}
472 
475  template <std::derived_from<IProperty> OWNER, typename K>
476  DataObjectWriteHandle( OWNER* owner, std::string propertyName, K key = {}, std::string doc = "" )
477  : ::details::WriteHandle<T, U>( owner, Gaudi::DataHandle::Writer, std::move( propertyName ), std::move( key ),
478  std::move( doc ) ) {}
479 
480  template <typename... Args>
481  DataObjectWriteHandle( std::tuple<Args...>&& args )
482  : DataObjectWriteHandle( std::move( args ), std::index_sequence_for<Args...>{} ) {}
483 };
IDataHandleHolder
Definition: IDataHandleHolder.h:23
details::WriteHandle
DataObjectHandle< Payload_t< Gaudi::DataHandle::Writer, T, U > > WriteHandle
Definition: DataObjectHandle.h:436
DataObjectHandle< Gaudi::NamedRange_< T > >::get
Range get() const
Retrieve object from transient data store.
DataObjectHandle< AnyDataWithViewWrapper< View, Owned > >::pythonRepr
std::string pythonRepr() const override
Definition: DataObjectHandle.h:410
DataObjectWriteHandle
Definition: DataObjectHandle.h:464
DataObjectHandle< std::optional< Gaudi::NamedRange_< T > > >::get
std::optional< Range > get() const
Retrieve object from transient data store.
DataObjectHandle< Gaudi::Range_< T > >::ValueType
std::remove_cv_t< std::remove_pointer_t< typename T::value_type > > ValueType
Definition: DataObjectHandle.h:195
AnyDataWrapper.h
DataObjectHandle::m_goodType
bool m_goodType
Definition: DataObjectHandle.h:147
DataObjectWriteHandle::DataObjectWriteHandle
DataObjectWriteHandle(std::tuple< Args... > &&args, std::index_sequence< Is... >)
Definition: DataObjectHandle.h:466
cpluginsvc.registry
def registry()
Definition: cpluginsvc.py:83
Gaudi::NamedRange_
Definition: NamedRange.h:42
StatusCode::isSuccess
bool isSuccess() const
Definition: StatusCode.h:314
GaudiPartProp.decorators.std
std
Definition: decorators.py:32
DataObjectHandle::getOrCreate
T * getOrCreate() const
Get object from store or create a new one if it doesn't exist.
Definition: DataObjectHandle.h:184
GaudiException.h
DataObjectHandle< Gaudi::NamedRange_< T > >::ValueType
std::remove_cv_t< std::remove_pointer_t< typename T::value_type > > ValueType
Definition: DataObjectHandle.h:239
GaudiException
Definition: GaudiException.h:29
GaudiPartProp.decorators.get
get
decorate the vector of properties
Definition: decorators.py:283
NamedRange.h
DataObjectHandle< AnyDataWrapper< T > >::put
const T * put(T &&obj) const
Register object in transient store.
Definition: DataObjectHandle.h:338
details::Payload_helper< Gaudi::DataHandle::Reader, std::optional< Gaudi::NamedRange_< T > >, U >::type
std::optional< Gaudi::NamedRange_< T > > type
Definition: DataObjectHandle.h:86
NewInputWrite.fetch
fetch
Definition: NewInputWrite.py:45
details::verifyType
bool verifyType(const DataObject *dataObj)
Definition: DataObjectHandle.h:52
gaudirun.c
c
Definition: gaudirun.py:525
System::typeinfoName
GAUDI_API const std::string typeinfoName(const std::type_info &)
Get platform independent information about the class type.
Definition: System.cpp:260
DataObjectHandle< std::optional< Gaudi::NamedRange_< T > > >::pythonRepr
std::string pythonRepr() const override
Definition: DataObjectHandle.h:294
details::Payload_helper
Definition: DataObjectHandle.h:70
details::replace_all
std::string replace_all(std::string str, std::string_view from, std::string_view to)
Definition: ReplaceAll.cpp:18
DataObjectHandle
DataObjectHandle.h GaudiKernel/DataObjectHandle.h.
Definition: AlgTool.h:36
Gaudi::DataHandle::Writer
@ Writer
Definition: DataHandle.h:39
DataObjectHandle::exist
bool exist() const
Check the existence of the object in the transient store.
Definition: DataObjectHandle.h:128
DataObjectHandle< AnyDataWithViewWrapper< View, Owned > >::getIfExists
View * getIfExists() const
Definition: DataObjectHandle.h:386
DataObjectHandle< AnyDataWrapper< T > >::get
T * get() const
Retrieve object from transient data store.
Definition: DataObjectHandle.h:329
details::Payload_helper::type
std::conditional_t< std::is_base_of_v< DataObject, T > &&std::is_same_v< T, U >, T, std::conditional_t< std::is_same_v< T, U >, AnyDataWrapper< std::remove_const_t< T > >, AnyDataWithViewWrapper< std::remove_const_t< T >, std::remove_const_t< U > >> > type
Definition: DataObjectHandle.h:74
DataObjectWriteHandle::DataObjectWriteHandle
DataObjectWriteHandle(OWNER *owner, std::string propertyName, K key={}, std::string doc="")
Autodeclaring constructor with property name, mode, key and documentation.
Definition: DataObjectHandle.h:476
Gaudi::Utils::begin
AttribStringParser::Iterator begin(const AttribStringParser &parser)
Definition: AttribStringParser.h:135
DataObjectHandle::get
T * get() const
Retrieve object from transient data store.
Definition: DataObjectHandle.h:117
StatusCode
Definition: StatusCode.h:64
details
Definition: AnyDataWrapper.h:19
DataObjectHandle< AnyDataWithViewWrapper< View, Owned > >::_get
AnyDataWithViewWrapper< View, Owned > * _get(bool mustExist) const
Definition: DataObjectHandle.h:416
DataObjectHandleBase
DataObjectHandleBase GaudiKernel/DataObjectHandleBase.h.
Definition: DataObjectHandleBase.h:34
DataObjectReadHandle
Definition: DataObjectHandle.h:442
details::make_range
Range make_range(const DataObject *obj)
Definition: DataObjectHandle.h:29
DataObjectHandle::get
T * get(bool mustExist) const
Try to retrieve from the transient store.
Definition: DataObjectHandle.h:160
GaudiPython.Bindings.nullptr
nullptr
Definition: Bindings.py:87
DataObjectReadHandle::DataObjectReadHandle
DataObjectReadHandle(const DataObjID &k, IDataHandleHolder *owner)
Definition: DataObjectHandle.h:448
AnyDataWrapper
Definition: AnyDataWrapper.h:55
DataObjectReadHandle::DataObjectReadHandle
DataObjectReadHandle(OWNER *owner, std::string propertyName, K key={}, std::string doc="")
Autodeclaring constructor with property name, mode, key and documentation.
Definition: DataObjectHandle.h:454
details::begin
auto begin(reverse_wrapper< T > &w)
Definition: reverse.h:46
IRegistry.h
DataObjectHandle< std::optional< Gaudi::NamedRange_< T > > >::ValueType
std::remove_cv_t< std::remove_pointer_t< typename T::value_type > > ValueType
Definition: DataObjectHandle.h:284
Gaudi
This file provides a Grammar for the type Gaudi::Accumulators::Axis It allows to use that type from p...
Definition: __init__.py:1
IOTest.sel
sel
Definition: IOTest.py:106
AnyDataWithViewWrapper
Definition: AnyDataWrapper.h:78
DataObjID
Definition: DataObjID.h:47
DataObjectWriteHandle::DataObjectWriteHandle
DataObjectWriteHandle(const DataObjID &k, IDataHandleHolder *owner)
Definition: DataObjectHandle.h:470
DataObjectHandle< AnyDataWrapper< T > >::size
std::optional< std::size_t > size() const
Size of boxed item, if boxed item has a 'size' method.
Definition: DataObjectHandle.h:350
details::select_range_converter
Converter_t< Range > select_range_converter(const DataObject *obj)
Definition: DataObjectHandle.h:42
DataObjectHandle< AnyDataWrapper< T > >::pythonRepr
std::string pythonRepr() const override
Definition: DataObjectHandle.h:352
Gaudi::Range_
Definition: Range.h:81
DataObjectWriteHandle::DataObjectWriteHandle
DataObjectWriteHandle(std::tuple< Args... > &&args)
Definition: DataObjectHandle.h:481
DataObjectHandle::put
T * put(std::unique_ptr< T > object) const
Register object in transient store.
Definition: DataObjectHandle.h:175
ConditionsStallTest.name
name
Definition: ConditionsStallTest.py:77
gaudirun.args
args
Definition: gaudirun.py:336
IDataHandleHolder.h
details::Payload_t
typename Payload_helper< mode, T, U >::type Payload_t
Definition: DataObjectHandle.h:90
Gaudi::DataHandle::pythonRepr
virtual std::string pythonRepr() const
Definition: DataHandle.cpp:19
DataObjectHandleBase.h
DataObject
Definition: DataObject.h:37
Gaudi::DataHandle::Reader
@ Reader
Definition: DataHandle.h:39
details::Converter_t
T(*)(const DataObject *) Converter_t
Definition: DataObjectHandle.h:26
DataObjectHandleBase::DataObjectHandleBase
DataObjectHandleBase(DataObjID k, Gaudi::DataHandle::Mode a, IDataHandleHolder *owner)
Definition: DataObjectHandleBase.cpp:47
IProperty.h
DataObjectHandle< AnyDataWithViewWrapper< View, Owned > >::get
View * get() const
Retrieve object from transient data store.
Definition: DataObjectHandle.h:385
DataObjectHandle::pythonRepr
std::string pythonRepr() const override
Definition: DataObjectHandle.h:140
IOTest.end
end
Definition: IOTest.py:125
StatusCode::FAILURE
constexpr static const auto FAILURE
Definition: StatusCode.h:100
DataObjectHandle::getIfExists
T * getIfExists() const
Bypass check of existence of object in transient store Only uses main location of the.
Definition: DataObjectHandle.h:123
Gaudi::Functional::details::put
auto put(const DataObjectHandle< Out1 > &out_handle, Out2 &&out)
Definition: details.h:167
DataObjectHandle< AnyDataWrapper< T > >::getIfExists
T * getIfExists() const
Definition: DataObjectHandle.h:330
DataObjectHandle< AnyDataWrapper< T > >::_get
AnyDataWrapper< T > * _get(bool mustExist) const
Definition: DataObjectHandle.h:358
details::ReadHandle
DataObjectHandle< Payload_t< Gaudi::DataHandle::Reader, T, U > > ReadHandle
Definition: DataObjectHandle.h:438
DataObjectHandle< AnyDataWithViewWrapper< View, Owned > >::put
const View * put(std::unique_ptr< AnyDataWithViewWrapper< View, Owned >> objectp) const
Register object in transient store.
Definition: DataObjectHandle.h:394
DataObjectHandle< Gaudi::Range_< T > >::get
Range get() const
Retrieve object from transient data store.
DataObjectHandle< AnyDataWithViewWrapper< View, Owned > >::put
const View * put(Owned &&obj) const
Definition: DataObjectHandle.h:401
ProduceConsume.key
key
Definition: ProduceConsume.py:84
DataObject::registry
IRegistry * registry() const
Get pointer to Registry.
Definition: DataObject.h:79
DataObjectReadHandle::DataObjectReadHandle
DataObjectReadHandle(std::tuple< Args... > &&args, std::index_sequence< Is... >)
Definition: DataObjectHandle.h:444
DataObjectReadHandle::DataObjectReadHandle
DataObjectReadHandle(std::tuple< Args... > &&args)
Definition: DataObjectHandle.h:459
compareOutputFiles.Reader
Reader
Definition: compareOutputFiles.py:489
DataObjectHandle< Gaudi::NamedRange_< T > >::pythonRepr
std::string pythonRepr() const override
Definition: DataObjectHandle.h:249
DataObjectHandle< AnyDataWithViewWrapper< View, Owned > >::size
std::optional< std::size_t > size() const
Size of boxed item, if boxed item has a 'size' method.
Definition: DataObjectHandle.h:408
details::end
auto end(reverse_wrapper< T > &w)
Definition: reverse.h:51
DataObjectHandle< Gaudi::Range_< T > >::pythonRepr
std::string pythonRepr() const override
Definition: DataObjectHandle.h:205