Loading [MathJax]/extensions/tex2jax.js
The Gaudi Framework  v36r16 (ea80daf8)
All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
MergingTransformer.h
Go to the documentation of this file.
1 /***********************************************************************************\
2 * (c) Copyright 1998-2019 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 #pragma once
13 
14 #include <functional>
15 #include <string>
16 #include <vector>
17 
18 #include "Gaudi/Algorithm.h"
22 
23 namespace Gaudi::Functional {
24 
25  using details::vector_of_const_;
26 
27  namespace details {
28  template <typename F, size_t... Is>
29  auto for_impl( F&& f, std::index_sequence<Is...> ) {
30  if constexpr ( std::disjunction_v<std::is_void<std::invoke_result_t<F, std::integral_constant<int, Is>>>...> ) {
31  ( std::invoke( f, std::integral_constant<int, Is>{} ), ... );
32  } else {
33  return std::array{ std::invoke( f, std::integral_constant<int, Is>{} )... };
34  }
35  }
36 
37  template <auto N, typename F>
38  decltype( auto ) for_( F&& f ) {
39  return for_impl( std::forward<F>( f ), std::make_index_sequence<N>{} );
40  }
41 
42  template <typename Sig>
44  template <typename... Args>
45  struct is_void_fun<void( Args... )> : std::true_type {};
46  template <typename Sig>
47  inline constexpr bool is_void_fun_v = is_void_fun<Sig>::value;
48 
49  template <typename Signature, typename Traits_, bool isLegacy>
51 
53  template <typename Out, typename In, typename Traits_>
54  struct MergingTransformer<Out( const vector_of_const_<In>& ), Traits_, true>
56  private:
58 
59  public:
60  using KeyValue = typename base_class::KeyValue;
61  using KeyValues = typename base_class::KeyValues;
62 
64  : base_class( std::move( name ), locator )
65  , m_inputLocations{ this, inputs.first, details::to_DataObjID( inputs.second ),
66  [this]( Gaudi::Details::PropertyBase& ) {
67  this->m_inputs =
68  make_vector_of_handles<decltype( this->m_inputs )>( this, m_inputLocations );
69  if ( std::is_pointer_v<In> ) { // handle constructor does not (yet) allow to set
70  // optional flag... so do it
71  // explicitly here...
72  std::for_each( this->m_inputs.begin(), this->m_inputs.end(),
73  []( auto& h ) { h.setOptional( true ); } );
74  }
75  },
77  static_assert( std::is_void_v<Out> );
78  }
79 
81  : base_class( std::move( name ), locator, output )
82  , m_inputLocations{ this, inputs.first, details::to_DataObjID( inputs.second ),
83  [this]( Gaudi::Details::PropertyBase& ) {
84  this->m_inputs =
85  make_vector_of_handles<decltype( this->m_inputs )>( this, m_inputLocations );
86  if ( std::is_pointer_v<In> ) { // handle constructor does not (yet) allow to set
87  // optional flag... so do it
88  // explicitly here...
89  std::for_each( this->m_inputs.begin(), this->m_inputs.end(),
90  []( auto& h ) { h.setOptional( true ); } );
91  }
92  },
94  static_assert( !std::is_void_v<Out> );
95  }
96 
97  // accessor to input Locations
98  const std::string& inputLocation( unsigned int n ) const { return m_inputLocations.value()[n].key(); }
99  unsigned int inputLocationSize() const { return m_inputLocations.value().size(); }
100 
101  // derived classes can NOT implement execute
102  StatusCode execute() override final {
104  ins.reserve( m_inputs.size() );
105  std::transform( m_inputs.begin(), m_inputs.end(), std::back_inserter( ins ), details2::get_from_handle<In>{} );
106  try {
107  if constexpr ( std::is_void_v<Out> ) {
108  std::as_const ( *this )( std::as_const( ins ) );
109  } else {
110  put( std::get<0>( this->m_outputs ), std::as_const( *this )( std::as_const( ins ) ) );
111  }
112  return FilterDecision::PASSED;
113  } catch ( GaudiException& e ) {
114  ( e.code() ? this->warning() : this->error() ) << e.tag() << " : " << e.message() << endmsg;
115  return e.code();
116  }
117  }
118 
119  virtual Out operator()( const vector_of_const_<In>& inputs ) const = 0;
120 
121  private:
122  // if In is a pointer, it signals optional (as opposed to mandatory) input
123  template <typename T>
125  std::vector<InputHandle_t<In>> m_inputs; // and make the handles properties instead...
126  Gaudi::Property<std::vector<DataObjID>> m_inputLocations; // TODO/FIXME: remove this duplication...
127  // TODO/FIXME: replace vector of DataObjID property + call-back with a
128  // vector<handle> property ... as soon as declareProperty can deal with that.
129  };
130 
131  template <typename Out, typename... Ins, typename Traits_>
132  struct MergingTransformer<Out( const vector_of_const_<Ins>&... ), Traits_, false>
134 
136  using KeyValue = typename base_class::KeyValue;
137  using KeyValues = typename base_class::KeyValues;
138  using InKeys = details::RepeatValues_<KeyValues, sizeof...( Ins )>;
139 
140  private:
141  auto construct_properties( InKeys inputs ) {
142  return details::for_<sizeof...( Ins )>( [&]( auto I ) {
143  constexpr auto i = decltype( I )::value;
144  auto& ins = std::get<i>( inputs );
146  this, ins.first, details::to_DataObjID( ins.second ),
147  [this]( auto&& ) {
148  auto& handles = std::get<i>( this->m_inputs );
149  auto& ins = std::get<i>( this->m_inputLocations );
150  using Handles = typename std::decay_t<decltype( handles )>;
151  handles = make_vector_of_handles<Handles>( this, ins );
152  if ( std::is_pointer_v<typename Handles::value_type> ) { // handle constructor does not (yet) allow to
153  // set
154  // optional flag... so do it
155  // explicitly here...
156  std::for_each( handles.begin(), handles.end(), []( auto& h ) { h.setOptional( true ); } );
157  }
158  },
160  } );
161  }
162 
163  public:
165  : base_class( std::move( name ), locator ), m_inputLocations{ construct_properties( inputs ) } {
166  static_assert( std::is_void_v<Out> );
167  }
168 
170  : MergingTransformer{ name, locator, InKeys{ inputs } } {
171  static_assert( sizeof...( Ins ) == 1 );
172  }
173 
175  : base_class( std::move( name ), locator, output ), m_inputLocations{ construct_properties( inputs ) } {
176  static_assert( !std::is_void_v<Out> );
177  }
178 
180  : MergingTransformer{ name, locator, InKeys{ inputs }, output } {
181  static_assert( sizeof...( Ins ) == 1 );
182  }
183 
184  // accessor to input Locations
185  const std::string& inputLocation( unsigned int i, unsigned int j ) const {
186  return m_inputLocations.at( i ).value().at( j ).key();
187  }
188  const std::string& inputLocation( unsigned int i ) const {
189  static_assert( sizeof...( Ins ) == 1 );
190  return inputLocation( 0, i );
191  }
192  unsigned int inputLocationSize( int i = 0 ) const { return m_inputLocations.at( i ).value().size(); }
193 
194  // derived classes can NOT implement execute
195  StatusCode execute( const EventContext& ) const override final {
197  details::for_<sizeof...( Ins )>( [&]( auto I ) {
198  constexpr size_t i = decltype( I )::value;
199  auto& ins = std::get<i>( inss );
200  auto& handles = std::get<i>( m_inputs );
201  ins.reserve( handles.size() );
202  std::transform( handles.begin(), handles.end(), std::back_inserter( ins ),
203  details::details2::get_from_handle<typename std::decay_t<decltype( ins )>::value_type>{} );
204  } );
205  try {
206  if constexpr ( std::is_void_v<Out> ) {
207  std::apply( [&]( auto&&... ins ) { return std::as_const( *this )( std::as_const( ins )... ); }, inss );
208  } else {
209  put( std::get<0>( this->m_outputs ),
210  std::apply( [&]( auto&&... ins ) { return std::as_const( *this )( std::as_const( ins )... ); },
211  inss ) );
212  }
213  return FilterDecision::PASSED;
214  } catch ( GaudiException& e ) {
215  ( e.code() ? this->warning() : this->error() ) << e.tag() << " : " << e.message() << endmsg;
216  return e.code();
217  }
218  }
219 
220  virtual Out operator()( const vector_of_const_<Ins>&... inputs ) const = 0;
221 
222  private:
223  // if In is a pointer, it signals optional (as opposed to mandatory) input
224  template <typename T>
226  std::tuple<std::vector<InputHandle_t<Ins>>...> m_inputs; // and make the handles properties instead...
227  std::array<Gaudi::Property<std::vector<DataObjID>>, sizeof...( Ins )> m_inputLocations; // TODO/FIXME: remove
228  // this duplication...
229  // TODO/FIXME: replace vector of string property + call-back with a
230  // vector<handle> property ... as soon as declareProperty can deal with that.
231  };
232 
233  } // namespace details
234 
235  template <typename Signature, typename Traits_ = Traits::useDefaults>
237 
238  // more meaningful alias for cases where the return type in Signature is void
239  template <typename Signature, typename Traits_ = Traits::useDefaults,
240  typename = std::enable_if_t<details::is_void_fun_v<Signature>>>
242 
243  // M vectors of the same -> N
244  template <typename Signature, typename Traits_ = Traits::BaseClass_t<Gaudi::Algorithm>>
246 
247  template <typename... Outs, typename... Ins, typename Traits_>
248  struct MergingMultiTransformer<std::tuple<Outs...>( vector_of_const_<Ins> const&... ), Traits_>
249  : details::DataHandleMixin<std::tuple<Outs...>, std::tuple<>, Traits_> {
250 
251  private:
253 
254  public:
255  using KeyValue = typename base_class::KeyValue;
256  using KeyValues = typename base_class::KeyValues;
257  using InKeys = details::RepeatValues_<KeyValues, sizeof...( Ins )>;
258  using OutKeys = details::RepeatValues_<KeyValue, sizeof...( Outs )>;
259  static constexpr size_t n_args = sizeof...( Ins );
260 
261  MergingMultiTransformer( std::string const& name, ISvcLocator* pSvcLocator, InKeys inputs, OutKeys outputs )
262  : base_class{ name, pSvcLocator, std::move( outputs ) }
263  , m_inputLocations{ details::for_<n_args>( [&]( auto I ) {
264  constexpr auto i = decltype( I )::value;
265  auto& ins = std::get<i>( inputs );
267  this, ins.first, details::to_DataObjID( ins.second ),
268  [this]( auto&& ) {
269  auto& handles = std::get<i>( this->m_inputs );
270  auto& ins = std::get<i>( this->m_inputLocations );
271  using In = typename std::decay_t<decltype( handles )>::value_type;
272  handles = details::make_vector_of_handles<std::decay_t<decltype( handles )>>( this, ins );
273  if ( std::is_pointer_v<In> ) { // handle constructor does not (yet) allow to set
274  // optional flag... so do it
275  // explicitly here...
276  std::for_each( handles.begin(), handles.end(), []( auto& h ) { h.setOptional( true ); } );
277  }
278  },
280  } ) } {}
281 
282  MergingMultiTransformer( std::string const& name, ISvcLocator* pSvcLocator, KeyValues inputs, OutKeys outputs )
283  : MergingMultiTransformer{ name, pSvcLocator, InKeys{ std::move( inputs ) }, std::move( outputs ) } {
284  static_assert( sizeof...( Ins ) == 1 );
285  }
286 
287  // accessor to input Locations
288  std::string const& inputLocation( unsigned int i, unsigned int j ) const {
289  return m_inputLocations.at( i ).value().at( j ).key();
290  }
291  std::string const& inputLocation( unsigned int j ) const {
292  static_assert( n_args == 1 );
293  return inputLocation( 0, j );
294  }
295  unsigned int inputLocationSize( int i = 0 ) const { return m_inputLocations.at( i ).value().size(); }
296 
297  // derived classes can NOT implement execute
298  StatusCode execute( EventContext const& ) const override final {
300  details::for_<sizeof...( Ins )>( [&]( auto I ) {
301  constexpr size_t i = decltype( I )::value;
302  auto& ins = std::get<i>( inss );
303  auto& handles = std::get<i>( m_inputs );
304  ins.reserve( handles.size() );
305  std::transform( handles.begin(), handles.end(), std::back_inserter( ins ),
306  details::details2::get_from_handle<typename std::decay_t<decltype( ins )>::value_type>{} );
307  } );
308  try {
309  std::apply(
310  [&]( auto&... outhandle ) {
312  std::apply(
313  [&outhandle...]( auto&&... data ) {
314  ( details::put( outhandle, std::forward<decltype( data )>( data ) ), ... );
315  },
316  std::apply( [&]( auto&&... ins ) { return std::as_const( *this )( std::as_const( ins )... ); },
317  inss ) );
319  },
320  this->m_outputs );
321  return FilterDecision::PASSED;
322  } catch ( GaudiException& e ) {
323  ( e.code() ? this->warning() : this->error() ) << e.tag() << " : " << e.message() << endmsg;
324  return e.code();
325  }
326  }
327 
328  virtual std::tuple<Outs...> operator()( const vector_of_const_<Ins>&... inputs ) const = 0;
329 
330  private:
331  // if In is a pointer, it signals optional (as opposed to mandatory) input
332  template <typename T>
334  std::tuple<std::vector<InputHandle_t<Ins>>...> m_inputs; // and make the handles properties instead...
335  std::array<Gaudi::Property<std::vector<DataObjID>>, sizeof...( Ins )> m_inputLocations; // TODO/FIXME: remove this
336  // duplication...
337  // TODO/FIXME: replace vector of string property + call-back with a
338  // vector<handle> property ... as soon as declareProperty can deal with that.
339  };
340 
341  // Many of the same -> N with filter functionality
342  template <typename Signature, typename Traits_ = Traits::BaseClass_t<Gaudi::Algorithm>>
344 
345  template <typename... Outs, typename In, typename Traits_>
346  struct MergingMultiTransformerFilter<std::tuple<Outs...>( vector_of_const_<In> const& ), Traits_>
347  : details::DataHandleMixin<std::tuple<Outs...>, std::tuple<>, Traits_> {
348 
349  private:
351 
352  public:
353  using KeyValue = typename base_class::KeyValue;
354  using KeyValues = typename base_class::KeyValues;
355  using OutKeys = details::RepeatValues_<KeyValue, sizeof...( Outs )>;
356 
358  OutKeys const& outputs );
359 
360  // accessor to input Locations
361  std::string const& inputLocation( unsigned int n ) const { return m_inputLocations.value()[n].key(); }
362  unsigned int inputLocationSize() const { return m_inputLocations.value().size(); }
363 
364  // derived classes can NOT implement execute
365  StatusCode execute( EventContext const& ) const override final {
367  ins.reserve( m_inputs.size() );
368  std::transform( m_inputs.begin(), m_inputs.end(), std::back_inserter( ins ),
370  try {
371  return std::apply(
372  [&]( auto&... outhandle ) {
374  return std::apply(
375  [&outhandle...]( bool passed, auto&&... data ) {
376  ( details::put( outhandle, std::forward<decltype( data )>( data ) ), ... );
377  return passed;
378  },
379  ( *this )( std::as_const( ins ) ) );
381  },
382  this->m_outputs )
385  } catch ( GaudiException& e ) {
386  ( e.code() ? this->warning() : this->error() ) << e.tag() << " : " << e.message() << endmsg;
387  return e.code();
388  }
389  }
390 
391  virtual std::tuple<bool, Outs...> operator()( const vector_of_const_<In>& inputs ) const = 0;
392 
393  private:
394  // if In is a pointer, it signals optional (as opposed to mandatory) input
395  template <typename T>
397  std::vector<InputHandle_t<In>> m_inputs; // and make the handles properties instead...
398  Gaudi::Property<std::vector<DataObjID>> m_inputLocations; // TODO/FIXME: remove this duplication...
399  // TODO/FIXME: replace vector of string property + call-back with a
400  // vector<handle> property ... as soon as declareProperty can deal with that.
401  };
402 
403  template <typename... Outs, typename In, typename Traits_>
406  ISvcLocator* pSvcLocator,
407  KeyValues const& inputs,
408  OutKeys const& outputs )
409  : base_class( name, pSvcLocator, outputs )
410  , m_inputLocations{
411  this, inputs.first, details::to_DataObjID( inputs.second ),
412  [this]( Gaudi::Details::PropertyBase& ) {
413  this->m_inputs = details::make_vector_of_handles<decltype( this->m_inputs )>( this, m_inputLocations );
414  if ( std::is_pointer_v<In> ) { // handle constructor does not (yet) allow to set
415  // optional flag... so do it
416  // explicitly here...
417  std::for_each( this->m_inputs.begin(), this->m_inputs.end(), []( auto& h ) { h.setOptional( true ); } );
418  }
419  },
421 
422 } // namespace Gaudi::Functional
Gaudi::Functional::details::MergingTransformer< Out(const vector_of_const_< In > &), Traits_, true >::MergingTransformer
MergingTransformer(std::string name, ISvcLocator *locator, const KeyValues &inputs)
Definition: MergingTransformer.h:63
Gaudi::Functional::MergingMultiTransformer< std::tuple< Outs... >(vector_of_const_< Ins > const &...), Traits_ >::InputHandle_t
details::InputHandle_t< Traits_, typename std::remove_pointer< T >::type > InputHandle_t
Definition: MergingTransformer.h:333
Gaudi::Details::PropertyBase
PropertyBase base class allowing PropertyBase* collections to be "homogeneous".
Definition: PropertyBase.h:35
Gaudi::Functional::details::MergingTransformer< Out(const vector_of_const_< Ins > &...), Traits_, false >::MergingTransformer
MergingTransformer(std::string name, ISvcLocator *locator, const KeyValues &inputs, const KeyValue &output)
Definition: MergingTransformer.h:179
Gaudi::Functional::MergingMultiTransformerFilter< std::tuple< Outs... >(vector_of_const_< In > const &), Traits_ >::MergingMultiTransformerFilter
MergingMultiTransformerFilter(std::string const &name, ISvcLocator *locator, KeyValues const &inputs, OutKeys const &outputs)
std::for_each
T for_each(T... args)
Gaudi::Functional::MergingMultiTransformerFilter< std::tuple< Outs... >(vector_of_const_< In > const &), Traits_ >::OutKeys
details::RepeatValues_< KeyValue, sizeof...(Outs)> OutKeys
Definition: MergingTransformer.h:355
GF_SUPPRESS_SPURIOUS_CLANG_WARNING_BEGIN
#define GF_SUPPRESS_SPURIOUS_CLANG_WARNING_BEGIN
Definition: FunctionalDetails.h:44
std::integral_constant
Gaudi::Functional::MergingMultiTransformer< std::tuple< Outs... >(vector_of_const_< Ins > const &...), Traits_ >::KeyValue
typename base_class::KeyValue KeyValue
Definition: MergingTransformer.h:255
Gaudi::Functional::MergingMultiTransformer< std::tuple< Outs... >(vector_of_const_< Ins > const &...), Traits_ >::InKeys
details::RepeatValues_< KeyValues, sizeof...(Ins)> InKeys
Definition: MergingTransformer.h:257
std::string
STL class.
Gaudi::Functional::MergingMultiTransformerFilter< std::tuple< Outs... >(vector_of_const_< In > const &), Traits_ >::m_inputs
std::vector< InputHandle_t< In > > m_inputs
Definition: MergingTransformer.h:397
Gaudi::Functional::details::MergingTransformer< Out(const vector_of_const_< Ins > &...), Traits_, false >::MergingTransformer
MergingTransformer(std::string name, ISvcLocator *locator, InKeys inputs, const KeyValue &output)
Definition: MergingTransformer.h:174
std::move
T move(T... args)
Gaudi::Functional::details::InputHandle_t
Gaudi::cpp17::detected_or_t< detail2::DefaultInputHandle< T >, detail2::InputHandle_t, Tr, T > InputHandle_t
Definition: FunctionalDetails.h:423
Gaudi::Functional::details::MergingTransformer< Out(const vector_of_const_< Ins > &...), Traits_, false >::MergingTransformer
MergingTransformer(std::string name, ISvcLocator *locator, const KeyValues &inputs)
Definition: MergingTransformer.h:169
std::is_void
Gaudi::Functional::MergingMultiTransformer< std::tuple< Outs... >(vector_of_const_< Ins > const &...), Traits_ >::execute
StatusCode execute(EventContext const &) const override final
Definition: MergingTransformer.h:298
std::vector
STL class.
ISvcLocator
Definition: ISvcLocator.h:46
std::back_inserter
T back_inserter(T... args)
Gaudi::Functional::MergingMultiTransformer
Definition: MergingTransformer.h:245
GaudiException
Definition: GaudiException.h:31
Gaudi::Functional::MergingMultiTransformer< std::tuple< Outs... >(vector_of_const_< Ins > const &...), Traits_ >::m_inputs
std::tuple< std::vector< InputHandle_t< Ins > >... > m_inputs
Definition: MergingTransformer.h:334
Gaudi::Functional::details::MergingTransformer< Out(const vector_of_const_< Ins > &...), Traits_, false >::inputLocation
const std::string & inputLocation(unsigned int i) const
Definition: MergingTransformer.h:188
Gaudi::Functional::details::MergingTransformer< Out(const vector_of_const_< Ins > &...), Traits_, false >::construct_properties
auto construct_properties(InKeys inputs)
Definition: MergingTransformer.h:141
Gaudi::Functional::MergingMultiTransformerFilter< std::tuple< Outs... >(vector_of_const_< In > const &), Traits_ >::KeyValues
typename base_class::KeyValues KeyValues
Definition: MergingTransformer.h:354
Gaudi::Functional::details::MergingTransformer< Out(const vector_of_const_< Ins > &...), Traits_, false >::MergingTransformer
MergingTransformer(std::string name, ISvcLocator *locator, InKeys inputs)
Definition: MergingTransformer.h:164
Gaudi::Functional::details::MergingTransformer< Out(const vector_of_const_< Ins > &...), Traits_, false >::inputLocation
const std::string & inputLocation(unsigned int i, unsigned int j) const
Definition: MergingTransformer.h:185
Gaudi::Functional::details::vector_of_const_::reserve
void reserve(size_type size)
Definition: FunctionalDetails.h:342
Gaudi::Functional::MergingMultiTransformerFilter< std::tuple< Outs... >(vector_of_const_< In > const &), Traits_ >::KeyValue
typename base_class::KeyValue KeyValue
Definition: MergingTransformer.h:353
Gaudi::Functional::FilterDecision::FAILED
@ FAILED
std::tuple
Gaudi::Functional::details::MergingTransformer< Out(const vector_of_const_< Ins > &...), Traits_, false >::inputLocationSize
unsigned int inputLocationSize(int i=0) const
Definition: MergingTransformer.h:192
Gaudi::Functional::details::vector_of_const_
Definition: FunctionalDetails.h:294
Gaudi::Functional::details::MergingTransformer< Out(const vector_of_const_< In > &), Traits_, true >::KeyValues
typename base_class::KeyValues KeyValues
Definition: MergingTransformer.h:61
gaudirun.output
output
Definition: gaudirun.py:523
Gaudi::Functional::details::MergingTransformer< Out(const vector_of_const_< In > &), Traits_, true >::inputLocation
const std::string & inputLocation(unsigned int n) const
Definition: MergingTransformer.h:98
Gaudi::Functional::details::to_DataObjID
std::vector< DataObjID > to_DataObjID(const std::vector< std::string > &in)
Definition: FunctionalDetails.h:119
Gaudi::Functional::MergingMultiTransformer< std::tuple< Outs... >(vector_of_const_< Ins > const &...), Traits_ >::inputLocationSize
unsigned int inputLocationSize(int i=0) const
Definition: MergingTransformer.h:295
Gaudi::Functional::MergingMultiTransformer< std::tuple< Outs... >(vector_of_const_< Ins > const &...), Traits_ >::inputLocation
std::string const & inputLocation(unsigned int j) const
Definition: MergingTransformer.h:291
Gaudi::Functional::details::MergingTransformer< Out(const vector_of_const_< Ins > &...), Traits_, false >::execute
StatusCode execute(const EventContext &) const override final
Definition: MergingTransformer.h:195
GaudiException::message
virtual const std::string & message() const
error message to be printed
Definition: GaudiException.h:68
Gaudi::Functional::details::make_vector_of_handles
Handles make_vector_of_handles(IDataHandleHolder *owner, const std::vector< DataObjID > &init)
Definition: FunctionalDetails.h:433
Gaudi::Functional::details::MergingTransformer< Out(const vector_of_const_< In > &), Traits_, true >::execute
StatusCode execute() override final
Definition: MergingTransformer.h:102
Gaudi::Functional::details::MergingTransformer< Out(const vector_of_const_< Ins > &...), Traits_, false >::KeyValue
typename base_class::KeyValue KeyValue
Definition: MergingTransformer.h:136
Gaudi::Functional::details::MergingTransformer< Out(const vector_of_const_< Ins > &...), Traits_, false >::InKeys
details::RepeatValues_< KeyValues, sizeof...(Ins)> InKeys
Definition: MergingTransformer.h:138
Gaudi::Functional::details::MergingTransformer< Out(const vector_of_const_< Ins > &...), Traits_, false >::KeyValues
typename base_class::KeyValues KeyValues
Definition: MergingTransformer.h:137
TimingHistograms.name
name
Definition: TimingHistograms.py:25
StatusCode
Definition: StatusCode.h:65
Gaudi::tagged_bool_ns::tagged_bool
Definition: TaggedBool.h:16
details
Definition: AnyDataWrapper.h:18
Gaudi::Functional::details::MergingTransformer
Definition: MergingTransformer.h:50
std::string::at
T at(T... args)
Gaudi::Functional::details::is_void_fun
Definition: MergingTransformer.h:43
Gaudi::Functional::details::MergingTransformer< Out(const vector_of_const_< Ins > &...), Traits_, false >::m_inputs
std::tuple< std::vector< InputHandle_t< Ins > >... > m_inputs
Definition: MergingTransformer.h:226
Gaudi::Functional::details::MergingTransformer< Out(const vector_of_const_< In > &), Traits_, true >::InputHandle_t
InputHandle_t< Traits_, std::remove_pointer_t< T > > InputHandle_t
Definition: MergingTransformer.h:124
ProduceConsume.j
j
Definition: ProduceConsume.py:101
Gaudi::Functional::MergingMultiTransformerFilter< std::tuple< Outs... >(vector_of_const_< In > const &), Traits_ >::inputLocationSize
unsigned int inputLocationSize() const
Definition: MergingTransformer.h:362
Gaudi::Functional::details::MergingTransformer< Out(const vector_of_const_< In > &), Traits_, true >::m_inputLocations
Gaudi::Property< std::vector< DataObjID > > m_inputLocations
Definition: MergingTransformer.h:126
Gaudi::Functional::MergingMultiTransformer< std::tuple< Outs... >(vector_of_const_< Ins > const &...), Traits_ >::inputLocation
std::string const & inputLocation(unsigned int i, unsigned int j) const
Definition: MergingTransformer.h:288
Gaudi::Functional::details::MergingTransformer< Out(const vector_of_const_< In > &), Traits_, true >::inputLocationSize
unsigned int inputLocationSize() const
Definition: MergingTransformer.h:99
AlgSequencer.h
h
Definition: AlgSequencer.py:32
std::array
STL class.
Gaudi::Functional::details::for_impl
auto for_impl(F &&f, std::index_sequence< Is... >)
Definition: MergingTransformer.h:29
Gaudi::Functional::MergingMultiTransformerFilter< std::tuple< Outs... >(vector_of_const_< In > const &), Traits_ >::inputLocation
std::string const & inputLocation(unsigned int n) const
Definition: MergingTransformer.h:361
Gaudi::Functional::FilterDecision::PASSED
@ PASSED
Algorithm.h
Gaudi::Functional
Definition: Consumer.h:19
endmsg
MsgStream & endmsg(MsgStream &s)
MsgStream Modifier: endmsg. Calls the output method of the MsgStream.
Definition: MsgStream.h:203
GaudiException::tag
virtual const std::string & tag() const
name tag for the exception, or exception type
Definition: GaudiException.h:77
Gaudi::Functional::MergingMultiTransformer< std::tuple< Outs... >(vector_of_const_< Ins > const &...), Traits_ >::MergingMultiTransformer
MergingMultiTransformer(std::string const &name, ISvcLocator *pSvcLocator, KeyValues inputs, OutKeys outputs)
Definition: MergingTransformer.h:282
std::transform
T transform(T... args)
Gaudi::Functional::MergingMultiTransformer< std::tuple< Outs... >(vector_of_const_< Ins > const &...), Traits_ >::operator()
virtual std::tuple< Outs... > operator()(const vector_of_const_< Ins > &... inputs) const =0
GaudiPluginService.cpluginsvc.n
n
Definition: cpluginsvc.py:235
Gaudi::Functional::details::MergingTransformer< Out(const vector_of_const_< Ins > &...), Traits_, false >::InputHandle_t
InputHandle_t< Traits_, std::remove_pointer_t< T > > InputHandle_t
Definition: MergingTransformer.h:225
FunctionalUtilities.h
Gaudi::Functional::details::for_
decltype(auto) for_(F &&f)
Definition: MergingTransformer.h:38
GaudiException::code
virtual const StatusCode & code() const
StatusCode for Exception.
Definition: GaudiException.h:86
Gaudi::Functional::MergingMultiTransformerFilter
Definition: MergingTransformer.h:343
Gaudi::Functional::details::MergingTransformer< Out(const vector_of_const_< In > &), Traits_, true >::KeyValue
typename base_class::KeyValue KeyValue
Definition: MergingTransformer.h:60
Gaudi::Functional::details::details2::get_from_handle
Definition: FunctionalDetails.h:263
std
STL namespace.
EventContext
Definition: EventContext.h:34
Gaudi::Functional::details::RepeatValues_
decltype(get_values_helper< Value >(std::make_index_sequence< N >())) RepeatValues_
Definition: FunctionalDetails.h:167
Gaudi::Functional::Traits::useDefaults
use_<> useDefaults
Definition: FunctionalUtilities.h:109
Gaudi::Functional::details::MergingTransformer< Out(const vector_of_const_< In > &), Traits_, true >::m_inputs
std::vector< InputHandle_t< In > > m_inputs
Definition: MergingTransformer.h:125
Gaudi::Functional::MergingMultiTransformerFilter< std::tuple< Outs... >(vector_of_const_< In > const &), Traits_ >::operator()
virtual std::tuple< bool, Outs... > operator()(const vector_of_const_< In > &inputs) const =0
GF_SUPPRESS_SPURIOUS_CLANG_WARNING_END
#define GF_SUPPRESS_SPURIOUS_CLANG_WARNING_END
Definition: FunctionalDetails.h:45
Gaudi::Functional::MergingMultiTransformer< std::tuple< Outs... >(vector_of_const_< Ins > const &...), Traits_ >::KeyValues
typename base_class::KeyValues KeyValues
Definition: MergingTransformer.h:256
Gaudi::Functional::MergingMultiTransformer< std::tuple< Outs... >(vector_of_const_< Ins > const &...), Traits_ >::MergingMultiTransformer
MergingMultiTransformer(std::string const &name, ISvcLocator *pSvcLocator, InKeys inputs, OutKeys outputs)
Definition: MergingTransformer.h:261
Gaudi::Functional::details::DataHandleMixin
Definition: FunctionalDetails.h:504
Gaudi::Functional::details::MergingTransformer< Out(const vector_of_const_< In > &), Traits_, true >::operator()
virtual Out operator()(const vector_of_const_< In > &inputs) const =0
Gaudi::Functional::MergingMultiTransformerFilter< std::tuple< Outs... >(vector_of_const_< In > const &), Traits_ >::m_inputLocations
Gaudi::Property< std::vector< DataObjID > > m_inputLocations
Definition: MergingTransformer.h:398
Gaudi::Functional::details::is_void_fun_v
constexpr bool is_void_fun_v
Definition: MergingTransformer.h:47
FunctionalDetails.h
Gaudi::Functional::details::MergingTransformer< Out(const vector_of_const_< Ins > &...), Traits_, false >::operator()
virtual Out operator()(const vector_of_const_< Ins > &... inputs) const =0
Gaudi::Functional::MergingMultiTransformerFilter< std::tuple< Outs... >(vector_of_const_< In > const &), Traits_ >::execute
StatusCode execute(EventContext const &) const override final
Definition: MergingTransformer.h:365
Gaudi::Functional::MergingMultiTransformer< std::tuple< Outs... >(vector_of_const_< Ins > const &...), Traits_ >::OutKeys
details::RepeatValues_< KeyValue, sizeof...(Outs)> OutKeys
Definition: MergingTransformer.h:258
FunctionalFilterDecision.h
Gaudi::Property
Implementation of property with value of concrete type.
Definition: Property.h:39
Gaudi::Functional::MergingMultiTransformerFilter< std::tuple< Outs... >(vector_of_const_< In > const &), Traits_ >::InputHandle_t
details::InputHandle_t< Traits_, typename std::remove_pointer< T >::type > InputHandle_t
Definition: MergingTransformer.h:396
Gaudi::Functional::details::MergingTransformer< Out(const vector_of_const_< In > &), Traits_, true >::MergingTransformer
MergingTransformer(std::string name, ISvcLocator *locator, const KeyValues &inputs, const KeyValue &output)
Definition: MergingTransformer.h:80
Gaudi::Functional::details::put
auto put(const DataObjectHandle< Out1 > &out_handle, Out2 &&out)
Definition: FunctionalDetails.h:173