The Gaudi Framework  master (37c0b60a)
CollectionCloneAlg.cpp
Go to the documentation of this file.
1 /***********************************************************************************\
2 * (c) Copyright 1998-2024 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 // ====================================================================
12 // CollectionCloneAlg.cpp
13 // --------------------------------------------------------------------
14 //
15 // Author : Markus Frank
16 //
17 // ====================================================================
18 #include <GaudiKernel/Algorithm.h>
19 #include <GaudiKernel/AttribStringParser.h>
20 #include <GaudiKernel/GenericAddress.h>
21 #include <GaudiKernel/IDataManagerSvc.h>
22 #include <GaudiKernel/IDataProviderSvc.h>
23 #include <GaudiKernel/IRegistry.h>
24 #include <GaudiKernel/ISelectStatement.h>
25 #include <GaudiKernel/MsgStream.h>
26 #include <GaudiKernel/NTuple.h>
27 #include <GaudiKernel/ObjectFactory.h>
28 #include <GaudiKernel/SmartDataPtr.h>
29 #include <GaudiKernel/SmartIF.h>
30 #include <vector>
31 
32 namespace {
33 
34  template <class T>
35  static long upper( const INTupleItem* item ) {
36 #pragma GCC diagnostic push
37 #pragma GCC diagnostic ignored "-Wnull-dereference"
38  const NTuple::_Data<T>* it = dynamic_cast<const NTuple::_Data<T>*>( item );
39  assert( it != nullptr );
40  return it->range().upper();
41 #pragma GCC diagnostic pop
42  }
43 
44  template <class TYP>
45  static StatusCode createItem( MsgStream& log, INTuple* tuple, INTupleItem* src, const TYP& null ) {
46  NTuple::_Data<TYP>* source = dynamic_cast<NTuple::_Data<TYP>*>( src );
47  if ( !source ) return StatusCode::FAILURE;
48  TYP low = source->range().lower();
49  TYP high = source->range().upper();
50  long hasIdx = source->hasIndex();
51  long ndim = source->ndim();
52  const std::string& name = source->name();
53  std::string idxName;
54  long dim[4], idxLen = 0;
55  long dim1 = 1, dim2 = 1;
56  INTupleItem* it = nullptr;
57  for ( int i = 0; i < ndim; i++ ) dim[i] = source->dim( i );
59  if ( hasIdx ) {
60  const INTupleItem* index = source->indexItem();
61  idxName = index->name();
62  switch ( index->type() ) {
63  case DataTypeInfo::UCHAR:
64  idxLen = upper<unsigned char>( index );
65  break;
66  case DataTypeInfo::USHORT:
67  idxLen = upper<unsigned short>( index );
68  break;
69  case DataTypeInfo::UINT:
70  idxLen = upper<unsigned int>( index );
71  break;
72  case DataTypeInfo::ULONG:
73  idxLen = upper<unsigned long>( index );
74  break;
75  case DataTypeInfo::CHAR:
76  idxLen = upper<char>( index );
77  break;
78  case DataTypeInfo::SHORT:
79  idxLen = upper<short>( index );
80  break;
81  case DataTypeInfo::INT:
82  idxLen = upper<int>( index );
83  break;
84  case DataTypeInfo::LONG:
85  idxLen = upper<long>( index );
86  break;
87  default:
88  log << MSG::ERROR << "Column " << idxName << " is not a valid index column!" << endmsg;
89  return StatusCode::FAILURE;
90  }
91  }
92  switch ( ndim ) {
93  case 0:
94  it = NTuple::_Item<TYP>::create( tuple, name, typeid( TYP ), low, high, null );
95  break;
96  case 1:
97  dim1 = ( hasIdx ) ? idxLen : dim[0];
98  it = NTuple::_Array<TYP>::create( tuple, name, typeid( TYP ), idxName, dim1, low, high, null );
99  break;
100  case 2:
101  dim1 = ( hasIdx ) ? idxLen : dim[0];
102  dim2 = ( hasIdx ) ? dim[0] : dim[1];
103  it = NTuple::_Matrix<TYP>::create( tuple, name, typeid( TYP ), idxName, dim1, dim2, low, high, null );
104  break;
105  default:
106  return StatusCode::FAILURE;
107  }
108  return tuple->add( it );
109  }
110 } // namespace
111 
122 class CollectionCloneAlg : public Algorithm {
123 
124  Gaudi::Property<std::string> m_tupleSvc{ this, "EvtTupleSvc", "EvtTupleSvc", "name of the data provider service" };
125  Gaudi::Property<std::vector<std::string>> m_inputs{ this, "Input", {}, "input specifications" };
126  Gaudi::Property<std::string> m_output{ this, "Output", {}, "output specification" };
127 
129  SmartIF<INTupleSvc> m_dataSvc;
131  std::string m_rootName;
133  std::string m_outName;
135  std::string m_criteria;
137  std::string m_selectorName;
138 
139 public:
141  using Algorithm::Algorithm;
142 
144  StatusCode initialize() override {
145  MsgStream log( msgSvc(), name() );
146  m_rootName = "";
147  m_outName = "";
148  m_criteria = "";
149  m_selectorName = "";
150  m_dataSvc = service( m_tupleSvc, true );
151  if ( !m_dataSvc ) {
152  log << MSG::ERROR << "Failed to access service \"" << m_tupleSvc << "\"." << endmsg;
153  return StatusCode::FAILURE;
154  }
155  std::string fun;
156  using Parser = Gaudi::Utils::AttribStringParser;
157  for ( auto attrib : Parser( m_output ) ) {
158  switch ( ::toupper( attrib.tag[0] ) ) {
159  case 'D':
160  m_outName = std::move( attrib.value );
161  break;
162  case 'S':
163  m_criteria = std::move( attrib.value );
164  break;
165  case 'F':
166  fun = std::move( attrib.value );
167  break;
168  default:
169  break;
170  }
171  }
172  if ( m_outName.empty() ) {
173  log << MSG::ERROR << "Failed to analyze output specs:" << m_output << endmsg;
174  return StatusCode::FAILURE;
175  }
176  if ( !fun.empty() || !m_criteria.empty() ) {
177  if ( !m_criteria.empty() && fun.empty() ) fun = "NTuple::Selector";
178  m_selectorName = fun;
179  }
180  return StatusCode::SUCCESS;
181  }
182 
184  StatusCode finalize() override {
185  m_dataSvc.reset();
186  return StatusCode::SUCCESS;
187  }
188 
190  StatusCode execute() override {
191  StatusCode status = connect();
192  return status.isSuccess() ? mergeInputTuples() : status;
193  }
194 
196  virtual StatusCode book( const NTuple::Tuple* nt ) {
197  MsgStream log( msgSvc(), name() );
198  StatusCode status = StatusCode::SUCCESS;
199  NTuple::Tuple* tuple = m_dataSvc->book( m_outName, nt->clID(), nt->title() );
200  for ( const auto& i : nt->items() ) {
201  switch ( i->type() ) {
202  case DataTypeInfo::UCHAR:
203  status = createItem<unsigned char>( log, tuple, i, 0 );
204  break;
205  case DataTypeInfo::USHORT:
206  status = createItem<unsigned short>( log, tuple, i, 0 );
207  break;
208  case DataTypeInfo::UINT:
209  status = createItem<unsigned int>( log, tuple, i, 0 );
210  break;
211  case DataTypeInfo::ULONG:
212  status = createItem<unsigned long>( log, tuple, i, 0 );
213  break;
214  case DataTypeInfo::CHAR:
215  status = createItem<char>( log, tuple, i, 0 );
216  break;
217  case DataTypeInfo::SHORT:
218  status = createItem<short>( log, tuple, i, 0 );
219  break;
220  case DataTypeInfo::INT:
221  status = createItem<int>( log, tuple, i, 0 );
222  break;
223  case DataTypeInfo::LONG:
224  status = createItem<long>( log, tuple, i, 0 );
225  break;
226  case DataTypeInfo::BOOL:
227  status = createItem( log, tuple, i, false );
228  break;
229  case DataTypeInfo::FLOAT:
230  status = createItem<float>( log, tuple, i, 0 );
231  break;
232  case DataTypeInfo::DOUBLE:
233  status = createItem<double>( log, tuple, i, 0 );
234  break;
235  case DataTypeInfo::OBJECT_ADDR:
236  status = createItem<IOpaqueAddress*>( log, tuple, i, nullptr );
237  break;
238  case DataTypeInfo::POINTER:
239  status = createItem<void*>( log, tuple, i, nullptr );
240  break;
241  case DataTypeInfo::STRING:
242  // status = createItem(log, tuple, i, (std::string*)0);
243  // break;
244  case DataTypeInfo::NTCHAR:
245  // status = createItem(log, tuple, i, (char*)0);
246  // break;
247  case DataTypeInfo::UNKNOWN:
248  default:
249  status = StatusCode::FAILURE;
250  break;
251  }
252  }
253  return status;
254  }
255 
256  // Perform some basic checks
257  virtual StatusCode checkInput( const NTuple::Tuple* clone, const NTuple::Tuple* src ) {
258  MsgStream log( msgSvc(), name() );
259  if ( clone && src ) {
260  const INTuple::ItemContainer& clone_items = clone->items();
261  const std::string clone_id = clone->registry()->identifier();
262  const std::string src_id = src->registry()->identifier();
263 
264  log << MSG::ERROR;
265  for ( auto i = clone_items.begin(); i != clone_items.end(); ++i ) {
266  const INTupleItem* itm = *i;
267  const std::string& nam = itm->name();
268  const INTupleItem* src_itm = src->find( nam );
269  if ( !src_itm ) {
270  log << "Tuple item " << nam << " not present in " << src_id << endmsg;
271  return StatusCode::FAILURE;
272  }
273  if ( itm->type() != src_itm->type() ) {
274  log << "Tuple item " << nam << " are of different types in " << src_id << ":" << src_itm->typeName()
275  << " <-> " << clone_id << ":" << itm->typeName() << endmsg;
276  return StatusCode::FAILURE;
277  }
278  if ( itm->ndim() != src_itm->ndim() ) {
279  log << "Tuple item " << nam << " have different dimensions in " << src_id << ":" << src_itm->ndim() << " <-> "
280  << clone_id << ":" << itm->ndim() << endmsg;
281  return StatusCode::FAILURE;
282  }
283  for ( int j = 0; j < itm->ndim(); ++j ) {
284  if ( src_itm->dim( j ) != itm->dim( j ) ) {
285  log << "Tuple item " << nam << " have different dimensions in " << src_id << "[" << j
286  << "]:" << src_itm->dim( j ) << " <-> " << clone_id << "[" << j << "]:" << itm->dim( j ) << endmsg;
287  return StatusCode::FAILURE;
288  }
289  }
290  if ( itm->hasIndex() != src_itm->hasIndex() ) {
291  log << "Tuple item " << nam << " has different index colums " << src_id << ":" << src_itm->hasIndex()
292  << " <-> " << clone_id << ":" << itm->hasIndex() << endmsg;
293  return StatusCode::FAILURE;
294  }
295  if ( itm->hasIndex() ) {
296  if ( itm->index() != src_itm->index() ) {
297  log << "Tuple item " << nam << " has different index colums " << src_id << ":" << src_itm->index()
298  << " <-> " << clone_id << ":" << itm->index() << endmsg;
299  return StatusCode::FAILURE;
300  }
301  }
302  }
303  return StatusCode::SUCCESS;
304  }
305  return StatusCode::FAILURE;
306  }
307 
309  StatusCode mergeEntries( const std::string& input ) {
310  MsgStream log( msgSvc(), name() );
311  NTuplePtr out( m_dataSvc.get(), m_outName );
312  if ( 0 != out ) {
313  const INTuple::ItemContainer& clone_items = out->items();
314  std::vector<GenericAddress> addrVector( clone_items.size() );
315  StatusCode status = StatusCode::SUCCESS;
316  NTuplePtr nt( m_dataSvc.get(), input );
317  size_t k = 0, nentry = 0;
318  if ( 0 != nt ) {
319  const INTuple::ItemContainer& source_items = nt->items();
320  for ( k = 0; k < source_items.size(); ++k ) {
321  if ( source_items[k]->type() == DataTypeInfo::OBJECT_ADDR ) {
322  *(IOpaqueAddress**)source_items[k]->buffer() = &addrVector[k];
323  }
324  }
325  while ( status.isSuccess() ) {
326  status = m_dataSvc->readRecord( nt.ptr() );
327  if ( status.isSuccess() ) {
328  INTuple::ItemContainer::const_iterator i;
329  nentry++;
330  for ( k = 0, i = source_items.begin(); i != source_items.end(); ++i, ++k ) {
331  const INTupleItem* src_itm = *i;
332  const INTupleItem* out_itm = out->find( src_itm->name() );
333  size_t size = 0;
334  switch ( ( *i )->type() ) {
335  case DataTypeInfo::UCHAR:
336  size = sizeof( unsigned char );
337  break;
338  case DataTypeInfo::USHORT:
339  size = sizeof( unsigned short );
340  break;
341  case DataTypeInfo::UINT:
342  size = sizeof( unsigned int );
343  break;
344  case DataTypeInfo::ULONG:
345  size = sizeof( unsigned long );
346  break;
347  case DataTypeInfo::CHAR:
348  size = sizeof( char );
349  break;
350  case DataTypeInfo::SHORT:
351  size = sizeof( short );
352  break;
353  case DataTypeInfo::INT:
354  size = sizeof( int );
355  break;
356  case DataTypeInfo::LONG:
357  size = sizeof( long );
358  break;
359  case DataTypeInfo::BOOL:
360  size = sizeof( bool );
361  break;
362  case DataTypeInfo::FLOAT:
363  size = sizeof( float );
364  break;
365  case DataTypeInfo::DOUBLE:
366  size = sizeof( double );
367  break;
368  case DataTypeInfo::STRING:
369  *(std::string*)out_itm->buffer() = *(std::string*)src_itm->buffer();
370  size = 0;
371  break;
372  case DataTypeInfo::NTCHAR:
373  size = ::strlen( (const char*)src_itm->buffer() ) + 1;
374  break;
375  case DataTypeInfo::POINTER: {
376  *(void**)out_itm->buffer() = *(void**)src_itm->buffer();
377  size = 0;
378  } break;
379  case DataTypeInfo::OBJECT_ADDR: {
380  IOpaqueAddress* ppA1 = &addrVector[k];
381  IOpaqueAddress** ppA2 = (IOpaqueAddress**)( out_itm->buffer() );
382  *ppA2 = ppA1;
383  size = 0;
384  } break;
385  case DataTypeInfo::UNKNOWN:
386  default:
387  size = 0;
388  break;
389  }
390  if ( size > 0 ) {
391  ::memcpy( const_cast<void*>( out_itm->buffer() ), src_itm->buffer(), size * src_itm->length() );
392  }
393  }
394  status = m_dataSvc->writeRecord( out.ptr() );
395  if ( !status.isSuccess() ) {
396  log << MSG::ERROR << "Failed to write record " << nentry << " from " << input << " to " << m_outName
397  << endmsg;
398  }
399  }
400  }
401  log << MSG::INFO << "End of reading tuple " << input << " after " << nentry << " entries." << endmsg;
402 
403  if ( nentry > 0 || m_selectorName != "" ) { return StatusCode::SUCCESS; }
404  return StatusCode::FAILURE;
405  }
406  log << MSG::ERROR << "Failed to access input: " << input << endmsg;
407  }
408  return StatusCode::FAILURE;
409  }
410 
412  StatusCode connect() {
413  StatusCode status = StatusCode::SUCCESS;
414  for ( size_t i = 0; i < m_inputs.size(); ++i ) {
415  NTuplePtr nt( m_dataSvc.get(), m_inputs[i] );
416  if ( !( 0 == nt ) ) {
417  NTuplePtr out( m_dataSvc.get(), m_outName );
418  if ( 0 == out ) {
419  status = book( nt );
420  } else {
421  status = checkInput( out, nt );
422  }
423  if ( !status.isSuccess() ) {
424  return status;
425  } else if ( m_selectorName != "" ) {
426  SmartIF<ISelectStatement> stmt( ObjFactory::create( m_selectorName, serviceLocator() ).release() );
427  if ( stmt ) {
428  if ( !m_criteria.empty() ) stmt->setCriteria( m_criteria );
429  nt->attachSelector( stmt ).ignore( /* AUTOMATICALLY ADDED FOR gaudi/Gaudi!763 */ );
430  } else {
431  MsgStream log( msgSvc(), name() );
432  log << MSG::ERROR << "Failed to attach tuple selector to " << m_inputs[i] << endmsg;
433  return StatusCode::FAILURE;
434  }
435  }
436  } else {
437  MsgStream log( msgSvc(), name() );
438  log << MSG::ERROR << "Failed to access tuple: " << m_inputs[i] << endmsg;
439  return StatusCode::FAILURE;
440  }
441  }
442  return StatusCode::SUCCESS;
443  }
444 
446  StatusCode mergeInputTuples() {
447  MsgStream log( msgSvc(), name() );
448  for ( const auto& input : m_inputs ) {
449  StatusCode sc = mergeEntries( input );
450  if ( !sc.isSuccess() ) {
451  log << MSG::ERROR << "Failed to merge tuple:" << input << endmsg;
452  return sc;
453  }
454  }
455  return StatusCode::SUCCESS;
456  }
457 };
458 DECLARE_COMPONENT( CollectionCloneAlg )
CollectionCloneAlg::book
virtual StatusCode book(const NTuple::Tuple *nt)
Book the N-tuple according to the specification.
Definition: CollectionCloneAlg.cpp:196
NTuple::_Data::range
virtual const ItemRange & range() const =0
Access the range if specified.
CollectionCloneAlg::finalize
StatusCode finalize() override
Finalize.
Definition: CollectionCloneAlg.cpp:184
INTupleItem::type
virtual long type() const =0
Type information of the item.
toupper
void toupper(std::string &s)
Definition: ExceptionSvc.cpp:36
CollectionCloneAlg::m_output
Gaudi::Property< std::string > m_output
Definition: CollectionCloneAlg.cpp:126
std::string
STL class.
INTupleItem::index
virtual const std::string & index() const =0
Access the index _Item.
details::size
constexpr auto size(const T &, Args &&...) noexcept
Definition: AnyDataWrapper.h:23
DataTypeInfo::STRING
@ STRING
Definition: DataTypeInfo.h:46
Gaudi.Configuration.log
log
Definition: Configuration.py:28
INTupleItem::length
virtual long length() const =0
Access the buffer length.
CollectionCloneAlg::m_criteria
std::string m_criteria
Selection criteria (if any)
Definition: CollectionCloneAlg.cpp:135
std::move
T move(T... args)
Gaudi::Algorithm::name
const std::string & name() const override
The identifying name of the algorithm object.
Definition: Algorithm.cpp:526
StatusCode::isSuccess
bool isSuccess() const
Definition: StatusCode.h:314
MSG::INFO
@ INFO
Definition: IMessageSvc.h:25
Gaudi::Algorithm::type
const std::string & type() const override
The type of the algorithm object.
Definition: Algorithm.h:165
IOpaqueAddress
Definition: IOpaqueAddress.h:33
CollectionCloneAlg::m_outName
std::string m_outName
Output tuple name.
Definition: CollectionCloneAlg.cpp:133
std::vector
STL class.
SmartIF::reset
void reset(TYPE *ptr=nullptr)
Set the internal pointer to the passed one disposing of the old one.
Definition: SmartIF.h:96
std::vector::size
T size(T... args)
DataTypeInfo::NTCHAR
@ NTCHAR
Definition: DataTypeInfo.h:47
CollectionCloneAlg::execute
StatusCode execute() override
Execute procedure.
Definition: CollectionCloneAlg.cpp:190
Algorithm
Alias for backward compatibility.
Definition: Algorithm.h:58
Algorithm.h
Gaudi::Algorithm::serviceLocator
SmartIF< ISvcLocator > & serviceLocator() const override
The standard service locator.
Definition: Algorithm.cpp:570
DataTypeInfo::POINTER
@ POINTER
Definition: DataTypeInfo.h:50
INTupleItem::ndim
virtual long ndim() const =0
Dimension.
conf.release
string release
Definition: conf.py:27
CollectionCloneAlg::m_inputs
Gaudi::Property< std::vector< std::string > > m_inputs
Definition: CollectionCloneAlg.cpp:125
ObjectFactory.h
DataTypeInfo::USHORT
@ USHORT
Definition: DataTypeInfo.h:36
INTuple::find
virtual const INTupleItem * find(const std::string &name) const =0
Find an item row of the Ntuple (CONST)
CollectionCloneAlg::m_dataSvc
SmartIF< INTupleSvc > m_dataSvc
Reference to data provider service.
Definition: CollectionCloneAlg.cpp:129
IDataProviderSvc.h
CollectionCloneAlg::m_selectorName
std::string m_selectorName
Selector factory.
Definition: CollectionCloneAlg.cpp:137
AvalancheSchedulerErrorTest.msgSvc
msgSvc
Definition: AvalancheSchedulerErrorTest.py:80
GenericAddress.h
DataTypeInfo::ULONG
@ ULONG
Definition: DataTypeInfo.h:38
DataTypeInfo::LONG
@ LONG
Definition: DataTypeInfo.h:42
NTuple::_Data
Abstract class describing basic data in an Ntuple.
Definition: NTuple.h:48
DataTypeInfo::DOUBLE
@ DOUBLE
Definition: DataTypeInfo.h:45
INTuple::items
virtual ItemContainer & items()=0
Access item container.
INTupleItem::hasIndex
virtual bool hasIndex() const =0
Is the tuple have an index item?
SmartIF.h
CollectionCloneAlg::initialize
StatusCode initialize() override
Initialize.
Definition: CollectionCloneAlg.cpp:144
NTuple::_Item::create
static _Item * create(INTuple *tup, const std::string &name, const std::type_info &info, TYP min, TYP max, TYP def)
Create instance.
Definition: NTupleItems.cpp:36
StatusCode
Definition: StatusCode.h:65
DataTypeInfo::SHORT
@ SHORT
Definition: DataTypeInfo.h:40
DataTypeInfo::UNKNOWN
@ UNKNOWN
Definition: DataTypeInfo.h:34
CollectionCloneAlg::mergeInputTuples
StatusCode mergeInputTuples()
Merge all N-tuple entries.
Definition: CollectionCloneAlg.cpp:446
ProduceConsume.j
j
Definition: ProduceConsume.py:104
INTupleItem::buffer
virtual const void * buffer() const =0
Access data buffer (CONST)
CollectionCloneAlg::m_rootName
std::string m_rootName
Name of the root leaf (obtained at initialize)
Definition: CollectionCloneAlg.cpp:131
SmartDataPtr.h
NTuple.h
INTupleItem::typeName
virtual std::string typeName() const =0
Proper type name of the object.
INTuple
Definition: INTuple.h:91
AttribStringParser.h
ISelectStatement.h
SmartIF< INTupleSvc >
INTuple::add
virtual StatusCode add(INTupleItem *item)=0
Add an item row to the N tuple.
endmsg
MsgStream & endmsg(MsgStream &s)
MsgStream Modifier: endmsg. Calls the output method of the MsgStream.
Definition: MsgStream.h:202
NTuple::_Matrix::create
static _Matrix * create(INTuple *tup, const std::string &name, const std::type_info &info, const std::string &index, long ncol, long nrow, TYP min, TYP max, TYP def)
Create instance.
Definition: NTupleItems.cpp:50
INTupleItem
Definition: INTuple.h:37
IRegistry.h
MsgStream
Definition: MsgStream.h:33
INTupleItem::dim
virtual long dim(long i) const =0
Access individual dimensions.
DataTypeInfo::FLOAT
@ FLOAT
Definition: DataTypeInfo.h:44
CollectionCloneAlg::checkInput
virtual StatusCode checkInput(const NTuple::Tuple *clone, const NTuple::Tuple *src)
Definition: CollectionCloneAlg.cpp:257
DataTypeInfo::UCHAR
@ UCHAR
Definition: DataTypeInfo.h:35
SmartDataStorePtr::ptr
TYPE * ptr()
Automatic conversion to data type.
Definition: SmartDataStorePtr.h:94
DataTypeInfo::UINT
@ UINT
Definition: DataTypeInfo.h:37
StatusCode::SUCCESS
constexpr static const auto SUCCESS
Definition: StatusCode.h:100
ConditionsStallTest.name
name
Definition: ConditionsStallTest.py:77
SmartIF::get
TYPE * get() const
Get interface pointer.
Definition: SmartIF.h:86
DataTypeInfo::BOOL
@ BOOL
Definition: DataTypeInfo.h:43
SmartDataPtr
A small class used to access easily (and efficiently) data items residing in data stores.
Definition: SmartDataPtr.h:57
NTuple::Tuple
Abstract base class which allows the user to interact with the actual N tuple implementation.
Definition: NTuple.h:388
std::vector::begin
T begin(T... args)
DECLARE_COMPONENT
#define DECLARE_COMPONENT(type)
Definition: PluginServiceV1.h:46
Gaudi::Algorithm::service
StatusCode service(std::string_view name, T *&psvc, bool createIf=true) const
Access a service by name, creating it if it doesn't already exist.
Definition: Algorithm.h:206
MSG::ERROR
@ ERROR
Definition: IMessageSvc.h:25
INTuple::title
virtual const std::string & title() const =0
Object title.
IRegistry::identifier
virtual const id_type & identifier() const =0
Full identifier (or key)
NTuple::_Array::create
static _Array * create(INTuple *tup, const std::string &name, const std::type_info &info, const std::string &index, long len, TYP min, TYP max, TYP def)
Create instance.
Definition: NTupleItems.cpp:43
std::string::empty
T empty(T... args)
DataTypeInfo::OBJECT_ADDR
@ OBJECT_ADDR
Definition: DataTypeInfo.h:51
std::vector::end
T end(T... args)
CollectionCloneAlg::m_tupleSvc
Gaudi::Property< std::string > m_tupleSvc
Definition: CollectionCloneAlg.cpp:124
Gaudi::Algorithm::Algorithm
Algorithm(std::string name, ISvcLocator *svcloc, std::string version=PACKAGE_VERSION)
Constructor.
Definition: Algorithm.h:101
INTupleItem::name
virtual const std::string & name() const =0
Access _Item name.
StatusCode::FAILURE
constexpr static const auto FAILURE
Definition: StatusCode.h:101
CollectionCloneAlg::mergeEntries
StatusCode mergeEntries(const std::string &input)
Merge the entries of a single input tuple into the output.
Definition: CollectionCloneAlg.cpp:309
DataObject::clID
virtual const CLID & clID() const
Retrieve reference to class definition structure.
Definition: DataObject.cpp:66
Gaudi::Utils::AttribStringParser
Parse attribute strings allowing iteration over the various attributes.
Definition: AttribStringParser.h:40
CollectionCloneAlg
Definition: CollectionCloneAlg.cpp:122
DataObject::registry
IRegistry * registry() const
Get pointer to Registry.
Definition: DataObject.h:78
Gaudi::Property< std::string >
IDataManagerSvc.h
DataTypeInfo::INT
@ INT
Definition: DataTypeInfo.h:41
DataTypeInfo::CHAR
@ CHAR
Definition: DataTypeInfo.h:39
MsgStream.h
Gaudi::ParticleProperties::index
size_t index(const Gaudi::ParticleProperty *property, const Gaudi::Interfaces::IParticlePropertySvc *service)
helper utility for mapping of Gaudi::ParticleProperty object into non-negative integral sequential id...
Definition: IParticlePropertySvc.cpp:39
PrepareBase.out
out
Definition: PrepareBase.py:20
CollectionCloneAlg::connect
StatusCode connect()
Connect input and output N-tuples.
Definition: CollectionCloneAlg.cpp:412