The Gaudi Framework  master (42b00024)
All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
details.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 
13 #include <Gaudi/Algorithm.h>
14 #include <GaudiKernel/Algorithm.h>
17 #include <GaudiKernel/IBinder.h>
19 #include <GaudiKernel/detected.h>
20 #include <cassert>
21 #include <sstream>
22 #include <type_traits>
23 
24 #if defined( __cpp_lib_ranges_zip ) && defined( __cpp_lib_ranges_as_const )
25 # define GAUDI_FUNCTIONAL_USES_STD_RANGES 1
26 # include <ranges>
27 #else
28 # include <range/v3/version.hpp>
29 # include <range/v3/view/const.hpp>
30 # include <range/v3/view/zip.hpp>
31 // upstream has renamed namespace ranges::view ranges::views
32 # if RANGE_V3_VERSION < 900
33 namespace ranges::views {
34  using namespace ranges::view;
35 }
36 # endif
37 #endif
38 
39 #if defined( __clang__ ) && ( __clang_major__ < 11 ) || defined( __APPLE__ ) && ( __clang_major__ < 12 )
40 # define GF_SUPPRESS_SPURIOUS_CLANG_WARNING_BEGIN \
41  _Pragma( "clang diagnostic push" ) _Pragma( "clang diagnostic ignored \"-Wunused-lambda-capture\"" )
42 # define GF_SUPPRESS_SPURIOUS_CLANG_WARNING_END _Pragma( "clang diagnostic pop" )
43 #else
44 # define GF_SUPPRESS_SPURIOUS_CLANG_WARNING_BEGIN
45 # define GF_SUPPRESS_SPURIOUS_CLANG_WARNING_END
46 #endif
47 
48 // temporary hack to help in transition to updated constructor
49 // allows to write code which is forward and backwards compatible
50 #define GAUDI_FUNCTIONAL_CONSTRUCTOR_USES_TUPLE
51 
53 
54  // CRJ : Stuff for zipping
55  namespace zip {
56 
58  template <typename OS, typename Arg>
59  void printSizes( OS& out, Arg&& arg ) {
60  out << "SizeOf'" << System::typeinfoName( typeid( Arg ) ) << "'=" << std::forward<Arg>( arg ).size();
61  }
62 
64  template <typename OS, typename Arg, typename... Args>
65  void printSizes( OS& out, Arg&& arg, Args&&... args ) {
66  printSizes( out, arg );
67  out << ", ";
68  printSizes( out, args... );
69  }
70 
72  template <typename A>
73  inline bool check_sizes( const A& ) noexcept {
74  return true;
75  }
76 
78  template <typename A, typename B>
79  inline bool check_sizes( const A& a, const B& b ) noexcept {
80  return a.size() == b.size();
81  }
82 
84  template <typename A, typename B, typename... C>
85  inline bool check_sizes( const A& a, const B& b, const C&... c ) noexcept {
86  return ( check_sizes( a, b ) && check_sizes( b, c... ) );
87  }
88 
90  template <typename... Args>
91  inline decltype( auto ) verifySizes( Args&... args ) {
92  if ( !check_sizes( args... ) ) {
93  std::ostringstream mess;
94  mess << "Zipped containers have different sizes : ";
95  printSizes( mess, args... );
96  throw GaudiException( mess.str(), "Gaudi::Functional::details::zip::verifySizes", StatusCode::FAILURE );
97  }
98  }
99 
101  template <typename... Args>
102  inline decltype( auto ) range( Args&&... args ) {
103 #ifndef NDEBUG
104  verifySizes( args... );
105 #endif
106 #if defined( GAUDI_FUNCTIONAL_USES_STD_RANGES )
107  return std::ranges::zip_view( std::forward<Args>( args )... );
108 #else
109  return ranges::views::zip( std::forward<Args>( args )... );
110 #endif
111  }
112 
114  template <typename... Args>
115  inline decltype( auto ) const_range( Args&&... args ) {
116 #ifndef NDEBUG
117  verifySizes( args... );
118 #endif
119 #if defined( GAUDI_FUNCTIONAL_USES_STD_RANGES )
120  return std::ranges::as_const_view( std::ranges::zip_view( std::forward<Args>( args )... ) );
121 #else
122  return ranges::views::const_( ranges::views::zip( std::forward<Args>( args )... ) );
123 #endif
124  }
125  } // namespace zip
126 
127  inline std::vector<DataObjID> to_DataObjID( const std::vector<std::string>& in ) {
128  std::vector<DataObjID> out;
129  out.reserve( in.size() );
130  std::transform( in.begin(), in.end(), std::back_inserter( out ),
131  []( const std::string& i ) { return DataObjID{ i }; } );
132  return out;
133  }
134 
136  template <typename T>
137  concept is_optional = requires( T const& t ) {
138  t.has_value();
139  t.value();
140  typename T::value_type;
141  };
142 
143  namespace details2 {
144 
145  template <typename T>
146  struct value_type_of {
147  using type = T;
148  };
149 
150  template <is_optional T>
151  struct value_type_of<T> {
152  using type = T::value_type;
153  };
154 
155  } // namespace details2
156 
157  template <typename T>
159 
160  constexpr struct invoke_optionally_t {
161  template <typename F, typename Arg>
162  requires( !is_optional<Arg> )
163  decltype( auto ) operator()( F&& f, Arg&& arg ) const {
164  return std::invoke( std::forward<F>( f ), std::forward<Arg>( arg ) );
165  }
166  template <typename F, typename Arg>
167  requires( is_optional<Arg> )
168  void operator()( F&& f, Arg&& arg ) const {
169  if ( arg ) std::invoke( std::forward<F>( f ), *std::forward<Arg>( arg ) );
170  }
173 
174  template <typename Value, std::size_t... I>
175  auto get_values_helper( std::index_sequence<I...> ) {
176  return std::make_tuple( ( (void)I, Value{} )... );
177  }
178 
179  template <typename Value, auto N>
180  using RepeatValues_ = decltype( get_values_helper<Value>( std::make_index_sequence<N>() ) );
181 
183  template <std::derived_from<DataObject> Out1, std::convertible_to<Out1> Out2>
184  auto put( const DataObjectHandle<Out1>& out_handle, Out2&& out ) {
185  return out_handle.put( std::make_unique<Out1>( std::forward<Out2>( out ) ) );
186  }
187 
188  template <typename Out1, std::convertible_to<Out1> Out2>
189  auto put( const DataObjectHandle<AnyDataWrapper<Out1>>& out_handle, Out2&& out ) {
190  return out_handle.put( std::forward<Out2>( out ) );
191  }
192 
193  // optional put
194  template <typename OutHandle, typename OptOut>
195  requires( is_optional<OptOut> )
196  void put( const OutHandle& out_handle, OptOut&& out ) {
197  if ( out ) put( out_handle, *std::forward<OptOut>( out ) );
198  }
199 
201  // adapt to differences between eg. std::vector (which has push_back) and KeyedContainer (which has insert)
202  // adapt to getting a T, and a container wanting T* by doing new T{ std::move(out) }
203  // adapt to getting a optional<T>
204 
205  constexpr struct insert_t {
206  // for Container<T*>, return T
207  template <typename Container>
208  using c_remove_ptr_t = std::remove_pointer_t<typename Container::value_type>;
209 
210  template <typename Container, typename Value>
211  auto operator()( Container& c, Value&& v ) const -> decltype( c.push_back( v ) ) {
212  return c.push_back( std::forward<Value>( v ) );
213  }
214 
215  template <typename Container, typename Value>
216  auto operator()( Container& c, Value&& v ) const -> decltype( c.insert( v ) ) {
217  return c.insert( std::forward<Value>( v ) );
218  }
219 
220  // Container<T*> with T&& as argument
221  template <typename Container, typename Value>
222  requires( std::is_pointer_v<typename Container::value_type> &&
223  std::is_convertible_v<Value, c_remove_ptr_t<Container>> )
224  auto operator()( Container& c, Value&& v ) const {
225  return operator()( c, new c_remove_ptr_t<Container>{ std::forward<Value>( v ) } );
226  }
227 
228  } insert{};
229 
231 
232  constexpr struct deref_t {
233  template <typename In>
234  requires( !std::is_pointer_v<In> )
235  const In& operator()( const In& in ) const {
236  return in;
237  }
238 
239  template <typename In>
240  requires( !std::is_pointer_v<std::decay_t<In>> )
241  In operator()( In&& in ) const {
242  return std::forward<In>( in );
243  }
244 
245  template <typename In>
246  const In& operator()( const In* in ) const {
247  assert( in != nullptr );
248  return *in;
249  }
250  } deref{};
251 
253  // if Container is a pointer, then we're optional items
254  namespace details2 {
255  template <typename T>
256  constexpr static bool is_gaudi_range_v = false;
257 
258  template <typename T>
259  constexpr static bool is_gaudi_range_v<Gaudi::Range_<T>> = true;
260 
261  template <typename T>
262  constexpr static bool is_gaudi_range_v<Gaudi::NamedRange_<T>> = true;
263 
264  template <typename T>
265  constexpr static bool is_gaudi_range_v<std::optional<Gaudi::NamedRange_<T>>> = true;
266 
267  template <typename Container, typename Value>
268  void push_back( Container& c, const Value& v, std::true_type ) {
269  c.push_back( v );
270  }
271  template <typename Container, typename Value>
272  void push_back( Container& c, const Value& v, std::false_type ) {
273  c.push_back( &v );
274  }
275 
276  template <typename In>
278  template <template <typename> class Handle, std::convertible_to<In> I>
279  auto operator()( const Handle<I>& h ) -> const In& {
280  return *h.get();
281  }
282  template <template <typename> class Handle, typename I>
283  auto operator()( const Handle<Gaudi::Range_<I>>& h ) -> const In {
284  return h.get();
285  }
286  template <template <typename> class Handle, typename I>
287  auto operator()( const Handle<Gaudi::NamedRange_<I>>& h ) -> const In {
288  return h.get();
289  }
290  template <template <typename> class Handle, typename I>
291  auto operator()( const Handle<std::optional<Gaudi::NamedRange_<I>>>& h ) -> const In {
292  return h.get();
293  }
294  template <template <typename> class Handle, typename I>
295  requires( std::is_convertible_v<I*, In> )
296  auto operator()( const Handle<I>& h ) -> const In {
297  return h.getIfExists();
298  } // In is-a pointer
299  };
300 
301  template <typename T>
302  T* deref_if( T* const t, std::false_type ) {
303  return t;
304  }
305  template <typename T>
306  T& deref_if( T* const t, std::true_type ) {
307  return *t;
308  }
309  } // namespace details2
310 
311  template <typename Container>
313  static constexpr bool is_pointer = std::is_pointer_v<Container>;
314  static constexpr bool is_range = details2::is_gaudi_range_v<Container>;
315  using val_t = std::add_const_t<std::remove_pointer_t<Container>>;
316  using ptr_t = std::add_pointer_t<val_t>;
317  using ref_t = std::add_lvalue_reference_t<val_t>;
318  using ContainerVector = std::vector<std::conditional_t<is_range, std::remove_const_t<val_t>, ptr_t>>;
320 
321  public:
322  using value_type = std::conditional_t<is_pointer, ptr_t, val_t>;
323  using size_type = typename ContainerVector::size_type;
324  class iterator {
325  using it_t = typename ContainerVector::const_iterator;
327  friend class vector_of_const_;
328  iterator( it_t iter ) : m_i( iter ) {}
329  using ret_t = std::conditional_t<is_pointer, ptr_t, ref_t>;
330 
331  public:
332  using iterator_category = typename it_t::iterator_category;
333  using value_type = typename it_t::iterator_category;
334  using reference = typename it_t::reference;
335  using pointer = typename it_t::pointer;
336  using difference_type = typename it_t::difference_type;
337 
338  friend bool operator!=( const iterator& lhs, const iterator& rhs ) { return lhs.m_i != rhs.m_i; }
339  friend bool operator==( const iterator& lhs, const iterator& rhs ) { return lhs.m_i == rhs.m_i; }
340  friend auto operator-( const iterator& lhs, const iterator& rhs ) { return lhs.m_i - rhs.m_i; }
341  ret_t operator*() const {
342  if constexpr ( is_range ) {
343  return *m_i;
344  } else {
345  return details2::deref_if( *m_i, std::bool_constant<!is_pointer>{} );
346  }
347  }
349  ++m_i;
350  return *this;
351  }
353  --m_i;
354  return *this;
355  }
356  bool is_null() const { return !*m_i; }
357  explicit operator bool() const { return !is_null(); }
358  };
359  vector_of_const_() = default;
360  void reserve( size_type size ) { m_containers.reserve( size ); }
361  template <typename T> // , typename = std::is_convertible<T,std::conditional_t<is_pointer,ptr_t,val_t>>
362  void push_back( T&& container ) {
363  details2::push_back( m_containers, std::forward<T>( container ),
364  std::bool_constant < is_pointer || is_range > {} );
365  } // note: does not copy its argument, so we're not really a container...
366  iterator begin() const { return m_containers.begin(); }
367  iterator end() const { return m_containers.end(); }
368  size_type size() const { return m_containers.size(); }
369 
370  template <typename X = Container>
371  requires( !std::is_pointer_v<X> )
372  ref_t front() const {
373  return *m_containers.front();
374  }
375 
376  template <typename X = Container>
377  requires( std::is_pointer_v<X> )
378  ptr_t front() const {
379  return m_containers.front();
380  }
381 
382  template <typename X = Container>
383  requires( !std::is_pointer_v<X> )
384  ref_t back() const {
385  return *m_containers.back();
386  }
387 
388  template <typename X = Container>
389  requires( std::is_pointer_v<X> )
390  ptr_t back() const {
391  return m_containers.back();
392  }
393 
394  template <typename X = Container>
395  requires( !std::is_pointer_v<X> )
396  ref_t operator[]( size_type i ) const {
397  return *m_containers[i];
398  }
399 
400  template <typename X = Container>
401  requires( std::is_pointer_v<X> )
402  ptr_t operator[]( size_type i ) const {
403  return m_containers[i];
404  }
405 
406  template <typename X = Container>
407  requires( !std::is_pointer_v<X> )
408  ref_t at( size_type i ) const {
409  return *m_containers[i];
410  }
411 
412  template <typename X = Container>
413  requires( std::is_pointer_v<X> )
414  ptr_t at( size_type i ) const {
415  return m_containers[i];
416  }
417 
418  bool is_null( size_type i ) const { return !m_containers[i]; }
419  };
420 
422  namespace detail2 { // utilities for detected_or_t{,_} usage
423 
424  // keep only for backwards compatibility... for now.
425  template <typename Tr>
426  using BaseClass_t = typename Tr::BaseClass;
427 
428  template <typename Tr, typename Default>
429  struct BaseClass {
430  using type = Default;
431  };
432  template <typename Tr, typename Default>
433  requires requires { typename Tr::BaseClass; }
434  struct BaseClass<Tr, Default> {
435  using type = Tr::BaseClass;
436  };
437 
438  template <typename T, typename Tr, template <typename...> typename Default>
439  struct OutputHandle {
440  using type = Default<T>;
441  };
442  template <typename T, typename Tr, template <typename...> typename Default>
443  requires requires { typename Tr::template OutputHandle<T>; }
444  struct OutputHandle<T, Tr, Default> {
445  using type = Tr::template OutputHandle<T>;
446  };
447 
448  template <typename T, typename Tr, template <typename...> typename Default>
449  struct InputHandle {
450  using type = Default<T>;
451  };
452  template <typename T, typename Tr, template <typename...> typename Default>
453  requires requires { typename Tr::template InputHandle<T>; }
454  struct InputHandle<T, Tr, Default> {
455  using type = Tr::template InputHandle<T>;
456  };
457 
458  template <typename T>
460  std::conditional_t<std::derived_from<std::decay_t<T>, IAlgTool>,
462  } // namespace detail2
463 
464  // check whether Tr::BaseClass is a valid type,
465  // if so, define BaseClass_t<Tr> as being Tr::BaseClass
466  // else define as being Gaudi::Algorithm
467  template <typename Tr, typename Default = Gaudi::Algorithm>
469 
470  // check whether Traits::{Input,Output}Handle<T> is a valid type,
471  // if so, define {Input,Output}Handle_t<Traits,T> as being Traits::{Input,Output}Handle<T>
472  // else define as being DataObject{Read,,Write}Handle<T>
473  template <typename Tr, typename T>
475 
476  template <typename Tr, typename T>
478 
479  template <typename Traits>
480  inline constexpr bool isLegacy =
481  std::is_base_of_v<Gaudi::details::LegacyAlgorithmAdapter, details::BaseClass_t<Traits>>;
482 
484 #define GAUDI_FUNCTIONAL_MAKE_VECTOR_OF_HANDLES_USES_DATAOBJID
485 
486  template <typename Handles>
487  Handles make_vector_of_handles( IDataHandleHolder* owner, const std::vector<DataObjID>& init ) {
488  Handles handles;
489  handles.reserve( init.size() );
490  std::transform( init.begin(), init.end(), std::back_inserter( handles ),
491  [&]( const auto& loc ) -> typename Handles::value_type {
492  return { loc, owner };
493  } );
494  return handles;
495  }
496 
497  template <typename Handle, typename Algo>
498  auto get( const Handle& handle, const Algo&, const EventContext& )
499  -> decltype( details::deref( handle.get() ) ) // make it SFINAE friendly...
500  {
501  return details::deref( handle.get() );
502  }
503 
504  template <typename IFace, typename Algo>
505  auto get( const ToolHandle<Gaudi::Interface::Bind::IBinder<IFace>>& handle, const Algo&, const EventContext& ctx ) {
506  return handle.bind( ctx );
507  }
508 
509  template <typename Handle>
510  auto getKey( const Handle& h ) -> decltype( h.objKey() ) {
511  return h.objKey();
512  }
513 
515  // given a pack, return a corresponding tuple
516  template <typename... In>
518  using type = std::tuple<In...>;
519 
520  static_assert( !std::disjunction_v<std::is_same<EventContext, In>...>,
521  "EventContext can only appear as first argument" );
522 
523  template <typename Algorithm, typename Handles>
524  static auto apply( const Algorithm& algo, Handles& handles ) {
525  return std::apply(
526  [&]( const auto&... handle ) { return algo( get( handle, algo, Gaudi::Hive::currentContext() )... ); },
527  handles );
528  }
529  template <typename Algorithm, typename Handles>
530  static auto apply( const Algorithm& algo, const EventContext& ctx, Handles& handles ) {
531  return std::apply( [&]( const auto&... handle ) { return algo( get( handle, algo, ctx )... ); }, handles );
532  }
533  };
534 
535  // except when it starts with EventContext, then drop it
536  template <typename... In>
538  using type = std::tuple<In...>;
539 
540  static_assert( !std::disjunction_v<std::is_same<EventContext, In>...>,
541  "EventContext can only appear as first argument" );
542 
543  template <typename Algorithm, typename Handles>
544  static auto apply( const Algorithm& algo, const EventContext& ctx, Handles& handles ) {
545  return std::apply( [&]( const auto&... handle ) { return algo( ctx, get( handle, algo, ctx )... ); }, handles );
546  }
547 
548  template <typename Algorithm, typename Handles>
549  static auto apply( const Algorithm& algo, Handles& handles ) {
550  return apply( algo, Gaudi::Hive::currentContext(), handles );
551  }
552  };
553 
554  template <typename... In>
556 
557  template <typename OutputSpec, typename InputSpec, typename Traits_>
559 
560  template <typename Out, typename In, typename Tr>
561  void updateHandleLocation( DataHandleMixin<Out, In, Tr>& parent, const std::string& prop,
562  const std::string& newLoc ) {
563  auto sc = parent.setProperty( prop, newLoc );
564  if ( sc.isFailure() ) throw GaudiException( "Could not set Property", prop + " -> " + newLoc, sc );
565  }
566 
567  template <typename Out, typename In, typename Tr>
568  void updateHandleLocations( DataHandleMixin<Out, In, Tr>& parent, const std::string& prop,
569  const std::vector<std::string>& newLocs ) {
570  std::ostringstream ss;
571  GaudiUtils::details::ostream_joiner( ss << '[', newLocs, ", ", []( std::ostream& os, const auto& i ) -> auto& {
572  return os << "'" << i << "'";
573  } ) << ']';
574  auto sc = parent.setProperty( prop, ss.str() );
575  if ( sc.isFailure() ) throw GaudiException( "Could not set Property", prop + " -> " + ss.str(), sc );
576  }
577 
578  template <typename... Out, typename... In, typename Traits_>
579  class DataHandleMixin<std::tuple<Out...>, std::tuple<In...>, Traits_> : public BaseClass_t<Traits_> {
580  static_assert( std::is_base_of_v<Algorithm, BaseClass_t<Traits_>>, "BaseClass must inherit from Algorithm" );
581 
582  template <typename IArgs, typename OArgs, std::size_t... I, std::size_t... J>
583  DataHandleMixin( std::string name, ISvcLocator* pSvcLocator, const IArgs& inputs, std::index_sequence<I...>,
584  const OArgs& outputs, std::index_sequence<J...> )
585  : BaseClass_t<Traits_>( std::move( name ), pSvcLocator )
586  , m_inputs( std::tuple_cat( std::forward_as_tuple( this ), std::get<I>( inputs ) )... )
587  , m_outputs( std::tuple_cat( std::forward_as_tuple( this ), std::get<J>( outputs ) )... ) {
588  // make sure this algorithm is seen as reentrant by Gaudi
589  this->setProperty( "Cardinality", 0 ).ignore();
590  }
591 
592  public:
593  constexpr static std::size_t N_in = sizeof...( In );
594  constexpr static std::size_t N_out = sizeof...( Out );
595 
596  using KeyValue = std::pair<std::string, std::string>;
597  using KeyValues = std::pair<std::string, std::vector<std::string>>;
598 
599  // generic constructor: N -> M
600  DataHandleMixin( std::string name, ISvcLocator* pSvcLocator, RepeatValues_<KeyValue, N_in> const& inputs,
601  RepeatValues_<KeyValue, N_out> const& outputs )
602  : DataHandleMixin( std::move( name ), pSvcLocator, inputs, std::index_sequence_for<In...>{}, outputs,
603  std::index_sequence_for<Out...>{} ) {}
604 
605  // special cases: forward to the generic case...
606  // 1 -> 1
607  DataHandleMixin( std::string name, ISvcLocator* locator, const KeyValue& input, const KeyValue& output )
608  : DataHandleMixin( std::move( name ), locator, std::forward_as_tuple( input ),
609  std::forward_as_tuple( output ) ) {}
610  // 1 -> N
611  DataHandleMixin( std::string name, ISvcLocator* locator, const KeyValue& input,
612  RepeatValues_<KeyValue, N_out> const& outputs )
613  : DataHandleMixin( std::move( name ), locator, std::forward_as_tuple( input ), outputs ) {}
614  // N -> 1
615  DataHandleMixin( std::string name, ISvcLocator* locator, RepeatValues_<KeyValue, N_in> const& inputs,
616  const KeyValue& output )
617  : DataHandleMixin( std::move( name ), locator, inputs, std::forward_as_tuple( output ) ) {}
618 
619  template <std::size_t N = 0>
620  decltype( auto ) inputLocation() const {
621  return getKey( std::get<N>( m_inputs ) );
622  }
623  template <typename T>
624  decltype( auto ) inputLocation() const {
625  return getKey( std::get<details::InputHandle_t<Traits_, std::decay_t<T>>>( m_inputs ) );
626  }
627  constexpr unsigned int inputLocationSize() const { return N_in; }
628 
629  template <std::size_t N = 0>
630  decltype( auto ) outputLocation() const {
631  return getKey( std::get<N>( m_outputs ) );
632  }
633  template <typename T>
634  decltype( auto ) outputLocation() const {
635  return getKey( std::get<details::OutputHandle_t<Traits_, std::decay_t<T>>>( m_outputs ) );
636  }
637  constexpr unsigned int outputLocationSize() const { return N_out; }
638 
639  protected:
640  bool isReEntrant() const override { return true; }
641 
642  std::tuple<details::InputHandle_t<Traits_, In>...> m_inputs;
643  std::tuple<details::OutputHandle_t<Traits_, Out>...> m_outputs;
644  };
645 
646  template <typename Traits_>
647  class DataHandleMixin<std::tuple<>, std::tuple<>, Traits_> : public BaseClass_t<Traits_> {
648  static_assert( std::is_base_of_v<Algorithm, BaseClass_t<Traits_>>, "BaseClass must inherit from Algorithm" );
649 
650  public:
651  using KeyValue = std::pair<std::string, std::string>;
652  using KeyValues = std::pair<std::string, std::vector<std::string>>;
653  DataHandleMixin( std::string name, ISvcLocator* pSvcLocator, std::tuple<> = {}, std::tuple<> = {} )
654  : BaseClass_t<Traits_>( std::move( name ), pSvcLocator ) {
655  // make sure this algorithm is seen as reentrant by Gaudi
656  this->setProperty( "Cardinality", 0 ).ignore();
657  }
658 
659  protected:
660  bool isReEntrant() const override { return true; }
661 
662  std::tuple<> m_inputs;
663  };
664 
665  template <typename... In, typename Traits_>
666  class DataHandleMixin<std::tuple<>, std::tuple<In...>, Traits_> : public BaseClass_t<Traits_> {
667  static_assert( std::is_base_of_v<Algorithm, BaseClass_t<Traits_>>, "BaseClass must inherit from Algorithm" );
668 
669  template <typename IArgs, std::size_t... I>
670  DataHandleMixin( std::string name, ISvcLocator* pSvcLocator, const IArgs& inputs, std::index_sequence<I...> )
671  : BaseClass_t<Traits_>( std::move( name ), pSvcLocator )
672  , m_inputs( std::tuple_cat( std::forward_as_tuple( this ), std::get<I>( inputs ) )... ) {
673  // make sure this algorithm is seen as reentrant by Gaudi
674  this->setProperty( "Cardinality", 0 ).ignore();
675  }
676 
677  public:
678  using KeyValue = std::pair<std::string, std::string>;
679  using KeyValues = std::pair<std::string, std::vector<std::string>>;
680  constexpr static std::size_t N_in = sizeof...( In );
681 
682  // generic constructor: N -> 0
683  DataHandleMixin( std::string name, ISvcLocator* pSvcLocator, RepeatValues_<KeyValue, N_in> const& inputs )
684  : DataHandleMixin( std::move( name ), pSvcLocator, inputs, std::index_sequence_for<In...>{} ) {}
685 
686  // special cases: forward to the generic case...
687  // 1 -> 0
688  DataHandleMixin( std::string name, ISvcLocator* locator, const KeyValue& input )
689  : DataHandleMixin( std::move( name ), locator, std::forward_as_tuple( input ) ) {}
690 
691  template <std::size_t N = 0>
692  decltype( auto ) inputLocation() const {
693  return getKey( std::get<N>( m_inputs ) );
694  }
695  template <typename T>
696  decltype( auto ) inputLocation() const {
697  return getKey( std::get<details::InputHandle_t<Traits_, std::decay_t<T>>>( m_inputs ) );
698  }
699  constexpr unsigned int inputLocationSize() const { return N_in; }
700 
701  protected:
702  bool isReEntrant() const override { return true; }
703 
704  std::tuple<details::InputHandle_t<Traits_, In>...> m_inputs;
705  };
706 
707  template <typename Traits_>
708  class DataHandleMixin<std::tuple<void>, std::tuple<>, Traits_>
709  : public DataHandleMixin<std::tuple<>, std::tuple<>, Traits_> {
710  public:
711  using DataHandleMixin<std::tuple<>, std::tuple<>, Traits_>::DataHandleMixin;
712  };
713 
714  template <typename... Out, typename Traits_>
715  class DataHandleMixin<std::tuple<Out...>, std::tuple<>, Traits_> : public BaseClass_t<Traits_> {
716  static_assert( std::is_base_of_v<Algorithm, BaseClass_t<Traits_>>, "BaseClass must inherit from Algorithm" );
717 
718  template <typename OArgs, std::size_t... J>
719  DataHandleMixin( std::string name, ISvcLocator* pSvcLocator, const OArgs& outputs, std::index_sequence<J...> )
720  : BaseClass_t<Traits_>( std::move( name ), pSvcLocator )
721  , m_outputs( std::tuple_cat( std::forward_as_tuple( this ), std::get<J>( outputs ) )... ) {
722  // make sure this algorithm is seen as reentrant by Gaudi
723  this->setProperty( "Cardinality", 0 ).ignore();
724  }
725 
726  public:
727  constexpr static std::size_t N_out = sizeof...( Out );
728  using KeyValue = std::pair<std::string, std::string>;
729  using KeyValues = std::pair<std::string, std::vector<std::string>>;
730 
731  // generic constructor: 0 -> N
732  DataHandleMixin( std::string name, ISvcLocator* pSvcLocator, RepeatValues_<KeyValue, N_out> const& outputs )
733  : DataHandleMixin( std::move( name ), pSvcLocator, outputs, std::index_sequence_for<Out...>{} ) {}
734 
735  // 0 -> 1
736  DataHandleMixin( std::string name, ISvcLocator* locator, const KeyValue& output )
737  : DataHandleMixin( std::move( name ), locator, std::forward_as_tuple( output ) ) {}
738 
739  template <std::size_t N = 0>
740  decltype( auto ) outputLocation() const {
741  return getKey( std::get<N>( m_outputs ) );
742  }
743  constexpr unsigned int outputLocationSize() const { return N_out; }
744 
745  protected:
746  bool isReEntrant() const override { return true; }
747 
748  std::tuple<details::OutputHandle_t<Traits_, Out>...> m_outputs;
749  };
750 
752  template <typename Fun, typename Container, typename... Args>
753  constexpr void applyPostProcessing( const Fun&, Container&, Args... ) {
754  static_assert( sizeof...( Args ) == 0, "Args should not be used!" );
755  }
756 
757  template <typename Fun, typename Container>
758  auto applyPostProcessing( const Fun& fun, Container& c ) -> decltype( fun.postprocess( c ), void() ) {
759  fun.postprocess( c );
760  }
761 
762 } // namespace Gaudi::Functional::details
IDataHandleHolder
Definition: IDataHandleHolder.h:24
Gaudi::Functional::details::detail2::BaseClass_t
typename Tr::BaseClass BaseClass_t
Definition: details.h:426
Gaudi::Functional::details::filter_evtcontext_t< EventContext, In... >::type
std::tuple< In... > type
Definition: details.h:538
Gaudi::Functional::details::detail2::OutputHandle< T, Tr, Default >::type
Tr::template OutputHandle< T > type
Definition: details.h:445
Gaudi::Functional::details::remove_optional_t
typename details2::value_type_of< T >::type remove_optional_t
Definition: details.h:158
Gaudi::Functional::details::details2::value_type_of::type
T type
Definition: details.h:147
Gaudi::Functional::details::DataHandleMixin< std::tuple<>, std::tuple< In... >, Traits_ >::KeyValues
std::pair< std::string, std::vector< std::string > > KeyValues
Definition: details.h:679
Gaudi::Functional::details::invoke_optionally_t
Definition: details.h:160
Gaudi::Functional::details::vector_of_const_::val_t
std::add_const_t< std::remove_pointer_t< Container > > val_t
Definition: details.h:315
Gaudi::Functional::details::vector_of_const_::iterator::is_null
bool is_null() const
Definition: details.h:356
Gaudi::Functional::details::vector_of_const_::iterator
Definition: details.h:324
Gaudi::Functional::details::deref_t::operator()
const In & operator()(const In *in) const
Definition: details.h:246
Gaudi::Functional::details::vector_of_const_::iterator::operator*
ret_t operator*() const
Definition: details.h:341
Gaudi::Functional::details::detail2::OutputHandle
Definition: details.h:439
DataObjectWriteHandle
Definition: DataObjectHandle.h:470
IAlgTool
Definition: IAlgTool.h:33
details::size
constexpr auto size(const T &, Args &&...) noexcept
Definition: AnyDataWrapper.h:23
setProperty
bool PyHelper() setProperty(IInterface *p, char *name, char *value)
Definition: Bootstrap.cpp:215
Gaudi::Functional::details::DataHandleMixin< std::tuple<>, std::tuple< In... >, Traits_ >::m_inputs
std::tuple< details::InputHandle_t< Traits_, In >... > m_inputs
Definition: details.h:704
Gaudi::Functional::details::invoke_optionally_t::requires
requires(!is_optional< Arg >) decltype(auto) operator()(F &&f
Gaudi::Functional::details::DataHandleMixin< std::tuple< Out... >, std::tuple< In... >, Traits_ >::DataHandleMixin
DataHandleMixin(std::string name, ISvcLocator *locator, const KeyValue &input, const KeyValue &output)
Definition: details.h:607
Gaudi::Functional::details::detail2::DefaultInputHandle
std::conditional_t< std::derived_from< std::decay_t< T >, IAlgTool >, ToolHandle< Gaudi::Interface::Bind::IBinder< std::decay_t< T > >>, DataObjectReadHandle< T > > DefaultInputHandle
Definition: details.h:461
Gaudi::Functional::details::get
auto get(const ToolHandle< Gaudi::Interface::Bind::IBinder< IFace >> &handle, const Algo &, const EventContext &ctx)
Definition: details.h:505
Gaudi::Functional::details
Definition: Consumer.h:21
Gaudi::NamedRange_
Definition: NamedRange.h:52
Gaudi::Functional::details::vector_of_const_::requires
requires(std::is_pointer_v< X >) ptr_t at(size_type i) const
Definition: details.h:413
Gaudi::Hive::currentContext
GAUDI_API const EventContext & currentContext()
Definition: ThreadLocalContext.cpp:30
Gaudi::Functional::details::DataHandleMixin< std::tuple< Out... >, std::tuple< In... >, Traits_ >::isReEntrant
bool isReEntrant() const override
Definition: details.h:640
Gaudi::Functional::details::DataHandleMixin< std::tuple< Out... >, std::tuple<>, Traits_ >::DataHandleMixin
DataHandleMixin(std::string name, ISvcLocator *locator, const KeyValue &output)
Definition: details.h:736
Gaudi::Functional::details::details2::get_from_handle::operator()
auto operator()(const Handle< I > &h) -> const In &
Definition: details.h:279
GaudiPartProp.decorators.std
std
Definition: decorators.py:32
Gaudi::Functional::details::DataHandleMixin< std::tuple< Out... >, std::tuple<>, Traits_ >::DataHandleMixin
DataHandleMixin(std::string name, ISvcLocator *pSvcLocator, RepeatValues_< KeyValue, N_out > const &outputs)
Definition: details.h:732
Gaudi::Functional::details::details2::get_from_handle::operator()
auto operator()(const Handle< std::optional< Gaudi::NamedRange_< I >>> &h) -> const In
Definition: details.h:291
Gaudi::Functional::details::invoke_optionally
constexpr struct Gaudi::Functional::details::invoke_optionally_t invoke_optionally
Gaudi::Functional::details::vector_of_const_::iterator::operator--
iterator & operator--()
Definition: details.h:352
Gaudi::Functional::details::DataHandleMixin< std::tuple< Out... >, std::tuple<>, Traits_ >::isReEntrant
bool isReEntrant() const override
Definition: details.h:746
GaudiException.h
Gaudi::Functional::details::insert_t::operator()
auto operator()(Container &c, Value &&v) const -> decltype(c.push_back(v))
Definition: details.h:211
Gaudi::Functional::details::isLegacy
constexpr bool isLegacy
Definition: details.h:480
Gaudi::Functional::details::DataHandleMixin< std::tuple<>, std::tuple< In... >, Traits_ >::DataHandleMixin
DataHandleMixin(std::string name, ISvcLocator *pSvcLocator, const IArgs &inputs, std::index_sequence< I... >)
Definition: details.h:670
Gaudi::Functional::details::deref_t::requires
requires(!std::is_pointer_v< In >) const In &operator()(const In &in) const
Definition: details.h:234
Gaudi::Functional::details::deref_t
Definition: details.h:232
ISvcLocator
Definition: ISvcLocator.h:46
GaudiException
Definition: GaudiException.h:32
Gaudi::Functional::details::detail2::InputHandle< T, Tr, Default >::type
Tr::template InputHandle< T > type
Definition: details.h:455
Gaudi::Functional::details::vector_of_const_::m_containers
ContainerVector m_containers
Definition: details.h:319
Algorithm.h
Gaudi::Functional::details::DataHandleMixin< std::tuple< Out... >, std::tuple< In... >, Traits_ >::KeyValue
std::pair< std::string, std::string > KeyValue
Definition: details.h:596
Gaudi::Functional::details::vector_of_const_::iterator::iterator_category
typename it_t::iterator_category iterator_category
Definition: details.h:332
Gaudi::Functional::details::DataHandleMixin< std::tuple< Out... >, std::tuple< In... >, Traits_ >::m_inputs
std::tuple< details::InputHandle_t< Traits_, In >... > m_inputs
Definition: details.h:642
Gaudi::Functional::details::vector_of_const_::reserve
void reserve(size_type size)
Definition: details.h:360
Gaudi::Functional::details::DataHandleMixin< std::tuple< Out... >, std::tuple<>, Traits_ >::outputLocationSize
constexpr unsigned int outputLocationSize() const
Definition: details.h:743
Gaudi::Functional::details::DataHandleMixin< std::tuple<>, std::tuple<>, Traits_ >::isReEntrant
bool isReEntrant() const override
Definition: details.h:660
Gaudi::Functional::details::vector_of_const_::size_type
typename ContainerVector::size_type size_type
Definition: details.h:323
Gaudi::Functional::details::zip::const_range
decltype(auto) const_range(Args &&... args)
Zips multiple containers together to form a single const range.
Definition: details.h:115
Gaudi::Functional::details::DataHandleMixin< std::tuple< Out... >, std::tuple< In... >, Traits_ >::DataHandleMixin
DataHandleMixin(std::string name, ISvcLocator *locator, RepeatValues_< KeyValue, N_in > const &inputs, const KeyValue &output)
Definition: details.h:615
gaudirun.c
c
Definition: gaudirun.py:525
ranges::views
Definition: details.h:33
System::typeinfoName
GAUDI_API const std::string typeinfoName(const std::type_info &)
Get platform independent information about the class type.
Definition: System.cpp:315
Gaudi::Functional::details::vector_of_const_
Definition: details.h:312
gaudirun.output
output
Definition: gaudirun.py:521
Gaudi::Functional::details::vector_of_const_::requires
requires(std::is_pointer_v< X >) ptr_t operator[](size_type i) const
Definition: details.h:401
Gaudi::Functional::details::vector_of_const_::iterator::operator-
friend auto operator-(const iterator &lhs, const iterator &rhs)
Definition: details.h:340
Gaudi::Functional::details::DataHandleMixin< std::tuple< Out... >, std::tuple< In... >, Traits_ >::DataHandleMixin
DataHandleMixin(std::string name, ISvcLocator *pSvcLocator, const IArgs &inputs, std::index_sequence< I... >, const OArgs &outputs, std::index_sequence< J... >)
Definition: details.h:583
MultiMergers.Value
Value
Definition: MultiMergers.py:15
Gaudi::Functional::details::get_values_helper
auto get_values_helper(std::index_sequence< I... >)
Definition: details.h:175
Gaudi::Functional::details::to_DataObjID
std::vector< DataObjID > to_DataObjID(const std::vector< std::string > &in)
Definition: details.h:127
DataObjectHandle
DataObjectHandle.h GaudiKernel/DataObjectHandle.h.
Definition: AlgTool.h:36
Gaudi::Functional::details::vector_of_const_::requires
requires(std::is_pointer_v< X >) ptr_t front() const
Definition: details.h:377
Gaudi::Functional::details::DataHandleMixin< std::tuple<>, std::tuple< In... >, Traits_ >::KeyValue
std::pair< std::string, std::string > KeyValue
Definition: details.h:678
Gaudi::Functional::details::vector_of_const_::iterator::iterator
iterator(it_t iter)
Definition: details.h:328
Gaudi::Functional::details::filter_evtcontext_t< EventContext, In... >::apply
static auto apply(const Algorithm &algo, Handles &handles)
Definition: details.h:549
Gaudi::Functional::details::make_vector_of_handles
Handles make_vector_of_handles(IDataHandleHolder *owner, const std::vector< DataObjID > &init)
Definition: details.h:487
Gaudi::Functional::details::vector_of_const_::requires
requires(std::is_pointer_v< X >) ptr_t back() const
Definition: details.h:389
Gaudi::Functional::details::insert_t
Definition: details.h:205
Gaudi::Functional::details::insert_t::c_remove_ptr_t
std::remove_pointer_t< typename Container::value_type > c_remove_ptr_t
Definition: details.h:208
Gaudi::Functional::details::requires
requires(is_optional< OptOut >) void put(const OutHandle &out_handle
bug_34121.t
t
Definition: bug_34121.py:31
ToolHandle
Definition: ToolHandle.h:136
Gaudi::Functional::details::deref_t::requires
requires(!std::is_pointer_v< std::decay_t< In >>) In operator()(In &&in) const
Definition: details.h:240
Gaudi::Functional::details::DataHandleMixin< std::tuple< Out... >, std::tuple< In... >, Traits_ >::DataHandleMixin
DataHandleMixin(std::string name, ISvcLocator *pSvcLocator, RepeatValues_< KeyValue, N_in > const &inputs, RepeatValues_< KeyValue, N_out > const &outputs)
Definition: details.h:600
Gaudi::Functional::details::details2::get_from_handle::requires
requires(std::is_convertible_v< I *, In >) auto operator()(const Handle< I > &h) -> const In
Definition: details.h:295
Gaudi::Functional::details::BaseClass_t
detail2::BaseClass< Tr, Default >::type BaseClass_t
Definition: details.h:468
Gaudi::Functional::details::put
auto put(const DataObjectHandle< AnyDataWrapper< Out1 >> &out_handle, Out2 &&out)
Definition: details.h:189
Gaudi::Functional::details::DataHandleMixin< std::tuple< Out... >, std::tuple< In... >, Traits_ >::inputLocationSize
constexpr unsigned int inputLocationSize() const
Definition: details.h:627
GaudiPython.Pythonizations.ctx
ctx
Definition: Pythonizations.py:578
Gaudi::Functional::details::zip::check_sizes
bool check_sizes(const A &a, const B &b, const C &... c) noexcept
Compare sizes of 3 or more containers.
Definition: details.h:85
Gaudi::Functional::details::vector_of_const_::ContainerVector
std::vector< std::conditional_t< is_range, std::remove_const_t< val_t >, ptr_t > > ContainerVector
Definition: details.h:318
Gaudi::Functional::details::filter_evtcontext_t< EventContext, In... >::apply
static auto apply(const Algorithm &algo, const EventContext &ctx, Handles &handles)
Definition: details.h:544
Gaudi::Functional::details::insert_t::requires
requires(std::is_pointer_v< typename Container::value_type > &&std::is_convertible_v< Value, c_remove_ptr_t< Container >>) auto operator()(Container &c
Gaudi::Functional::details::vector_of_const_::iterator::m_i
it_t m_i
Definition: details.h:326
Gaudi::Functional::details::invoke_optionally_t::requires
requires(is_optional< Arg >) void operator()(F &&f
Gaudi::Functional::details::detail2::BaseClass
Definition: details.h:429
Gaudi::Functional::details::DataHandleMixin< std::tuple< Out... >, std::tuple<>, Traits_ >::DataHandleMixin
DataHandleMixin(std::string name, ISvcLocator *pSvcLocator, const OArgs &outputs, std::index_sequence< J... >)
Definition: details.h:719
Gaudi::Functional::details::vector_of_const_::value_type
std::conditional_t< is_pointer, ptr_t, val_t > value_type
Definition: details.h:322
Gaudi::Algorithm
Base class from which all concrete algorithm classes should be derived.
Definition: Algorithm.h:90
DataObjectReadHandle
Definition: DataObjectHandle.h:448
AlgSequencer.h
h
Definition: AlgSequencer.py:31
Gaudi::Functional::details::applyPostProcessing
auto applyPostProcessing(const Fun &fun, Container &c) -> decltype(fun.postprocess(c), void())
Definition: details.h:758
Gaudi::Functional::details::is_optional
concept is_optional
Definition: details.h:137
Gaudi::Functional::details::DataHandleMixin< std::tuple<>, std::tuple< In... >, Traits_ >::inputLocationSize
constexpr unsigned int inputLocationSize() const
Definition: details.h:699
Gaudi::Functional::details::DataHandleMixin< std::tuple<>, std::tuple<>, Traits_ >::KeyValues
std::pair< std::string, std::vector< std::string > > KeyValues
Definition: details.h:652
Gaudi::Functional::details::vector_of_const_::requires
requires(!std::is_pointer_v< X >) ref_t operator[](size_type i) const
Definition: details.h:395
Gaudi::Functional::details::filter_evtcontext_t::apply
static auto apply(const Algorithm &algo, Handles &handles)
Definition: details.h:524
Gaudi::Functional::details::vector_of_const_::requires
requires(!std::is_pointer_v< X >) ref_t back() const
Definition: details.h:383
Gaudi::Functional::details::details2::get_from_handle::operator()
auto operator()(const Handle< Gaudi::NamedRange_< I >> &h) -> const In
Definition: details.h:287
Gaudi::Functional::details::deref
constexpr struct Gaudi::Functional::details::deref_t deref
Algorithm.h
Gaudi::Functional::details::DataHandleMixin< std::tuple< Out... >, std::tuple<>, Traits_ >::m_outputs
std::tuple< details::OutputHandle_t< Traits_, Out >... > m_outputs
Definition: details.h:748
Gaudi::Functional::details::vector_of_const_::iterator::operator++
iterator & operator++()
Definition: details.h:348
Gaudi::Functional::details::detail2::OutputHandle::type
Default< T > type
Definition: details.h:440
AnyDataWrapper
Definition: AnyDataWrapper.h:55
Gaudi::Functional::details::vector_of_const_::push_back
void push_back(T &&container)
Definition: details.h:362
Gaudi::Functional::details::details2::get_from_handle::operator()
auto operator()(const Handle< Gaudi::Range_< I >> &h) -> const In
Definition: details.h:283
Gaudi::Functional::details::updateHandleLocation
void updateHandleLocation(DataHandleMixin< Out, In, Tr > &parent, const std::string &prop, const std::string &newLoc)
Definition: details.h:561
Gaudi::Functional::details::vector_of_const_::iterator::operator==
friend bool operator==(const iterator &lhs, const iterator &rhs)
Definition: details.h:339
Gaudi::Functional::details::DataHandleMixin< std::tuple< Out... >, std::tuple< In... >, Traits_ >::m_outputs
std::tuple< details::OutputHandle_t< Traits_, Out >... > m_outputs
Definition: details.h:643
IBinder.h
Gaudi::Functional::details::detail2::InputHandle
Definition: details.h:449
Gaudi::Functional::details::filter_evtcontext_t
Definition: details.h:517
Gaudi::Range_
Definition: Range.h:93
Gaudi::Functional::details::DataHandleMixin< std::tuple<>, std::tuple< In... >, Traits_ >::isReEntrant
bool isReEntrant() const override
Definition: details.h:702
Gaudi::Functional::details::DataHandleMixin< std::tuple<>, std::tuple<>, Traits_ >::m_inputs
std::tuple m_inputs
Definition: details.h:662
gaudirun.type
type
Definition: gaudirun.py:160
ThreadLocalContext.h
DataObjectHandle::put
T * put(std::unique_ptr< T > object) const
Register object in transient store.
Definition: DataObjectHandle.h:176
ConditionsStallTest.name
name
Definition: ConditionsStallTest.py:77
Gaudi::Functional::details::zip::verifySizes
decltype(auto) verifySizes(Args &... args)
Verify the data container sizes have the same sizes.
Definition: details.h:91
Gaudi::Functional::details::filter_evtcontext_t::apply
static auto apply(const Algorithm &algo, const EventContext &ctx, Handles &handles)
Definition: details.h:530
Gaudi::Functional::details::details2::get_from_handle
Definition: details.h:277
Gaudi::Functional::details::vector_of_const_::iterator::operator!=
friend bool operator!=(const iterator &lhs, const iterator &rhs)
Definition: details.h:338
gaudirun.args
args
Definition: gaudirun.py:336
Gaudi::Functional::details::vector_of_const_::begin
iterator begin() const
Definition: details.h:366
Gaudi::Functional::details::vector_of_const_::iterator::difference_type
typename it_t::difference_type difference_type
Definition: details.h:336
Gaudi::Functional::details::details2::push_back
void push_back(Container &c, const Value &v, std::false_type)
Definition: details.h:272
Gaudi::Functional::details::details2::deref_if
T & deref_if(T *const t, std::true_type)
Definition: details.h:306
EventContext
Definition: EventContext.h:34
Gaudi::Functional::details::RepeatValues_
decltype(get_values_helper< Value >(std::make_index_sequence< N >())) RepeatValues_
Definition: details.h:180
Gaudi::Functional::details::DataHandleMixin< std::tuple< Out... >, std::tuple< In... >, Traits_ >::outputLocationSize
constexpr unsigned int outputLocationSize() const
Definition: details.h:637
Gaudi::Functional::Traits::BaseClass_t
Definition: utilities.h:38
Gaudi::Functional::details::vector_of_const_::iterator::value_type
typename it_t::iterator_category value_type
Definition: details.h:333
detected.h
Gaudi::Functional::details::vector_of_const_::iterator::pointer
typename it_t::pointer pointer
Definition: details.h:335
Gaudi::Functional::details::DataHandleMixin< std::tuple< Out... >, std::tuple<>, Traits_ >::KeyValue
std::pair< std::string, std::string > KeyValue
Definition: details.h:728
fixtures.reference
Generator[dict, None, None] reference(request, Optional[Path] reference_path)
Definition: fixtures.py:211
Gaudi::Functional::details::vector_of_const_::iterator::it_t
typename ContainerVector::const_iterator it_t
Definition: details.h:325
Gaudi::Functional::details::updateHandleLocations
void updateHandleLocations(DataHandleMixin< Out, In, Tr > &parent, const std::string &prop, const std::vector< std::string > &newLocs)
Definition: details.h:568
Gaudi::Functional::details::insert_t::operator()
auto operator()(Container &c, Value &&v) const -> decltype(c.insert(v))
Definition: details.h:216
Gaudi::Functional::details::vector_of_const_::ref_t
std::add_lvalue_reference_t< val_t > ref_t
Definition: details.h:317
Gaudi::Functional::details::vector_of_const_::iterator::reference
typename it_t::reference reference
Definition: details.h:334
Gaudi::Functional::details::detail2::BaseClass::type
Default type
Definition: details.h:430
Properties.v
v
Definition: Properties.py:122
Gaudi::Functional::details::DataHandleMixin
Definition: details.h:558
Gaudi::Functional::details::vector_of_const_::end
iterator end() const
Definition: details.h:367
Gaudi::Functional::details::zip::printSizes
void printSizes(OS &out, Arg &&arg, Args &&... args)
Print the parameters.
Definition: details.h:65
StatusCode::FAILURE
constexpr static const auto FAILURE
Definition: StatusCode.h:101
Gaudi::Functional::details::DataHandleMixin< std::tuple<>, std::tuple<>, Traits_ >::KeyValue
std::pair< std::string, std::string > KeyValue
Definition: details.h:651
Gaudi::Functional::details::DataHandleMixin< std::tuple<>, std::tuple<>, Traits_ >::DataHandleMixin
DataHandleMixin(std::string name, ISvcLocator *pSvcLocator, std::tuple<>={}, std::tuple<>={})
Definition: details.h:653
Gaudi::Functional::details::vector_of_const_::requires
requires(!std::is_pointer_v< X >) ref_t front() const
Definition: details.h:371
Gaudi::Functional::details::details2::value_type_of< T >::type
T::value_type type
Definition: details.h:152
Gaudi::Functional::details::vector_of_const_::iterator::ret_t
std::conditional_t< is_pointer, ptr_t, ref_t > ret_t
Definition: details.h:329
Gaudi::Functional::details::insert
constexpr struct Gaudi::Functional::details::insert_t insert
Gaudi::Functional::details::detail2::InputHandle::type
Default< T > type
Definition: details.h:450
Gaudi::Functional::details::InputHandle_t
typename detail2::InputHandle< T, Tr, detail2::DefaultInputHandle >::type InputHandle_t
Definition: details.h:477
Gaudi::Interface::Bind::IBinder
Definition: IBinder.h:47
DataObjectHandle.h
Gaudi::Functional::details::DataHandleMixin< std::tuple< Out... >, std::tuple<>, Traits_ >::KeyValues
std::pair< std::string, std::vector< std::string > > KeyValues
Definition: details.h:729
Gaudi::Functional::details::details2::value_type_of
Definition: details.h:146
Gaudi::Functional::details::filter_evtcontext_t::type
std::tuple< In... > type
Definition: details.h:518
Gaudi::Functional::details::DataHandleMixin< std::tuple< Out... >, std::tuple< In... >, Traits_ >::KeyValues
std::pair< std::string, std::vector< std::string > > KeyValues
Definition: details.h:597
Gaudi::Utils::Histos::Formats::Default
@ Default
Definition: HistoTableFormat.h:96
Gaudi::Functional::details::filter_evtcontext
typename filter_evtcontext_t< In... >::type filter_evtcontext
Definition: details.h:555
Gaudi::Functional::details::DataHandleMixin< std::tuple<>, std::tuple< In... >, Traits_ >::DataHandleMixin
DataHandleMixin(std::string name, ISvcLocator *pSvcLocator, RepeatValues_< KeyValue, N_in > const &inputs)
Definition: details.h:683
Gaudi::Functional::details::detail2::BaseClass< Tr, Default >::type
Tr::BaseClass type
Definition: details.h:435
Gaudi::Functional::details::vector_of_const_::vector_of_const_
vector_of_const_()=default
Gaudi::Functional::details::vector_of_const_::ptr_t
std::add_pointer_t< val_t > ptr_t
Definition: details.h:316
Gaudi::Functional::details::DataHandleMixin< std::tuple< Out... >, std::tuple< In... >, Traits_ >::DataHandleMixin
DataHandleMixin(std::string name, ISvcLocator *locator, const KeyValue &input, RepeatValues_< KeyValue, N_out > const &outputs)
Definition: details.h:611
Gaudi::Functional::details::vector_of_const_::requires
requires(!std::is_pointer_v< X >) ref_t at(size_type i) const
Definition: details.h:407
Gaudi::Functional::details::zip::range
decltype(auto) range(Args &&... args)
Zips multiple containers together to form a single range.
Definition: details.h:102
GaudiUtils::details::ostream_joiner
Stream & ostream_joiner(Stream &os, Iterator first, Iterator last, Separator sep, OutputElement output=OutputElement{})
Definition: SerializeSTL.h:87
Gaudi::Functional::details::DataHandleMixin< std::tuple<>, std::tuple< In... >, Traits_ >::DataHandleMixin
DataHandleMixin(std::string name, ISvcLocator *locator, const KeyValue &input)
Definition: details.h:688
Gaudi::Functional::details::OutputHandle_t
typename detail2::OutputHandle< T, Tr, DataObjectWriteHandle >::type OutputHandle_t
Definition: details.h:474
Gaudi::Functional::details::out
OptOut && out
Definition: details.h:196
Gaudi::Functional::details::getKey
auto getKey(const Handle &h) -> decltype(h.objKey())
Definition: details.h:510
Gaudi::Functional::details::vector_of_const_::is_null
bool is_null(size_type i) const
Definition: details.h:418
Gaudi::Functional::details::vector_of_const_::size
size_type size() const
Definition: details.h:368