Loading [MathJax]/extensions/tex2jax.js
The Gaudi Framework  v36r7 (7f57a304)
All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
FunctionalDetails.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 #ifndef FUNCTIONAL_DETAILS_H
12 #define FUNCTIONAL_DETAILS_H
13 
14 #include <cassert>
15 #include <sstream>
16 #include <stdexcept>
17 #include <type_traits>
18 
19 // TODO: fwd declare instead?
21 #include "GaudiKernel/Algorithm.h"
24 #include "GaudiKernel/IBinder.h"
26 #include "GaudiKernel/detected.h"
27 
28 // Range V3
29 #include <range/v3/version.hpp>
30 #include <range/v3/view/const.hpp>
31 #include <range/v3/view/zip.hpp>
32 // upstream has renamed namespace ranges::view ranges::views
33 #if RANGE_V3_VERSION < 900
34 namespace ranges::views {
35  using namespace ranges::view;
36 }
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  return ranges::views::zip( std::forward<Args>( args )... );
107  }
108 
110  template <typename... Args>
111  inline decltype( auto ) const_range( Args&&... args ) {
112 #ifndef NDEBUG
113  verifySizes( args... );
114 #endif
115  return ranges::views::const_( ranges::views::zip( std::forward<Args>( args )... ) );
116  }
117  } // namespace zip
118 
121  out.reserve( in.size() );
123  []( const std::string& i ) { return DataObjID{ i }; } );
124  return out;
125  }
126 
128  namespace details2 {
129  template <typename T>
130  using is_optional_ = decltype( std::declval<T>().has_value(), std::declval<T>().value() );
131 
132  template <typename T>
133  using value_type_of_t = typename T::value_type;
134 
135  } // namespace details2
136  template <typename Arg>
137  constexpr bool is_optional_v = Gaudi::cpp17::is_detected_v<details2::is_optional_, Arg>;
138 
139  template <typename Arg>
140  using require_is_optional = std::enable_if_t<is_optional_v<Arg>>;
141 
142  template <typename Arg>
143  using require_is_not_optional = std::enable_if_t<!is_optional_v<Arg>>;
144 
145  template <typename T>
147  std::conditional_t<is_optional_v<T>, Gaudi::cpp17::detected_t<details2::value_type_of_t, T>, T>;
148 
149  constexpr struct invoke_optionally_t {
150  template <typename F, typename Arg, typename = require_is_not_optional<Arg>>
151  decltype( auto ) operator()( F&& f, Arg&& arg ) const {
152  return std::invoke( std::forward<F>( f ), std::forward<Arg>( arg ) );
153  }
154  template <typename F, typename Arg, typename = require_is_optional<Arg>>
155  void operator()( F&& f, Arg&& arg ) const {
156  if ( arg ) std::invoke( std::forward<F>( f ), *std::forward<Arg>( arg ) );
157  }
160 
161  template <typename Value, std::size_t... I>
162  auto get_values_helper( std::index_sequence<I...> ) {
163  return std::make_tuple( ( (void)I, Value{} )... );
164  }
165 
166  template <typename Value, auto N>
167  using RepeatValues_ = decltype( get_values_helper<Value>( std::make_index_sequence<N>() ) );
168 
170 
171  template <typename Out1, typename Out2,
172  typename = std::enable_if_t<std::is_constructible_v<Out1, Out2> && std::is_base_of_v<DataObject, Out1>>>
173  auto put( const DataObjectHandle<Out1>& out_handle, Out2&& out ) {
174  return out_handle.put( std::make_unique<Out1>( std::forward<Out2>( out ) ) );
175  }
176 
177  template <typename Out1, typename Out2, typename = std::enable_if_t<std::is_constructible_v<Out1, Out2>>>
178  auto put( const DataObjectHandle<AnyDataWrapper<Out1>>& out_handle, Out2&& out ) {
179  return out_handle.put( std::forward<Out2>( out ) );
180  }
181 
182  // optional put
183  template <typename OutHandle, typename OptOut, typename = require_is_optional<OptOut>>
184  void put( const OutHandle& out_handle, OptOut&& out ) {
185  if ( out ) put( out_handle, *std::forward<OptOut>( out ) );
186  }
187 
189  // adapt to differences between eg. std::vector (which has push_back) and KeyedContainer (which has insert)
190  // adapt to getting a T, and a container wanting T* by doing new T{ std::move(out) }
191  // adapt to getting a optional<T>
192 
193  constexpr struct insert_t {
194  // for Container<T*>, return T
195  template <typename Container>
196  using c_remove_ptr_t = std::remove_pointer_t<typename Container::value_type>;
197 
198  template <typename Container, typename Value>
199  auto operator()( Container& c, Value&& v ) const -> decltype( c.push_back( v ) ) {
200  return c.push_back( std::forward<Value>( v ) );
201  }
202 
203  template <typename Container, typename Value>
204  auto operator()( Container& c, Value&& v ) const -> decltype( c.insert( v ) ) {
205  return c.insert( std::forward<Value>( v ) );
206  }
207 
208  // Container<T*> with T&& as argument
209  template <typename Container, typename Value,
210  typename = std::enable_if_t<std::is_pointer_v<typename Container::value_type>>,
211  typename = std::enable_if_t<std::is_convertible_v<Value, c_remove_ptr_t<Container>>>>
212  auto operator()( Container& c, Value&& v ) const {
213  return operator()( c, new c_remove_ptr_t<Container>{ std::forward<Value>( v ) } );
214  }
215 
216  } insert{};
217 
219 
220  constexpr struct deref_t {
221  template <typename In, typename = std::enable_if_t<!std::is_pointer_v<In>>>
222  const In& operator()( const In& in ) const {
223  return in;
224  }
225 
226  template <typename In, typename = std::enable_if_t<!std::is_pointer_v<std::decay_t<In>>>>
227  In operator()( In&& in ) const {
228  return std::forward<In>( in );
229  }
230 
231  template <typename In>
232  const In& operator()( const In* in ) const {
233  assert( in != nullptr );
234  return *in;
235  }
236  } deref{};
237 
239  // if Container is a pointer, then we're optional items
240  namespace details2 {
241  template <typename T>
243 
244  template <typename T, typename IT>
246 
247  template <typename T, typename IT>
249 
250  template <typename T>
251  constexpr static bool is_gaudi_range_v = is_gaudi_range<T>::value;
252 
253  template <typename Container, typename Value>
254  void push_back( Container& c, const Value& v, std::true_type ) {
255  c.push_back( v );
256  }
257  template <typename Container, typename Value>
258  void push_back( Container& c, const Value& v, std::false_type ) {
259  c.push_back( &v );
260  }
261 
262  template <typename In>
264  template <template <typename> class Handle, typename I, typename = std::enable_if_t<std::is_convertible_v<I, In>>>
265  auto operator()( const Handle<I>& h ) -> const In& {
266  return *h.get();
267  }
268  template <template <typename> class Handle, typename I, typename IT>
269  auto operator()( const Handle<Gaudi::Range_<I, IT>>& h ) -> const In {
270  return h.get();
271  }
272  template <template <typename> class Handle, typename I, typename IT>
273  auto operator()( const Handle<Gaudi::NamedRange_<I, IT>>& h ) -> const In {
274  return h.get();
275  }
276  template <template <typename> class Handle, typename I,
277  typename = std::enable_if_t<std::is_convertible_v<I*, In>>>
278  auto operator()( const Handle<I>& h ) -> const In {
279  return h.getIfExists();
280  } // In is-a pointer
281  };
282 
283  template <typename T>
284  T* deref_if( T* const t, std::false_type ) {
285  return t;
286  }
287  template <typename T>
288  T& deref_if( T* const t, std::true_type ) {
289  return *t;
290  }
291  } // namespace details2
292 
293  template <typename Container>
295  static constexpr bool is_pointer = std::is_pointer_v<Container>;
296  static constexpr bool is_range = details2::is_gaudi_range_v<Container>;
297  using val_t = std::add_const_t<std::remove_pointer_t<Container>>;
298  using ptr_t = std::add_pointer_t<val_t>;
299  using ref_t = std::add_lvalue_reference_t<val_t>;
302 
303  public:
304  using value_type = std::conditional_t<is_pointer, ptr_t, val_t>;
305  using size_type = typename ContainerVector::size_type;
306  class iterator {
307  using it_t = typename ContainerVector::const_iterator;
309  friend class vector_of_const_;
310  iterator( it_t iter ) : m_i( iter ) {}
311  using ret_t = std::conditional_t<is_pointer, ptr_t, ref_t>;
312 
313  public:
314  using iterator_category = typename it_t::iterator_category;
315  using value_type = typename it_t::iterator_category;
316  using reference = typename it_t::reference;
317  using pointer = typename it_t::pointer;
318  using difference_type = typename it_t::difference_type;
319 
320  friend bool operator!=( const iterator& lhs, const iterator& rhs ) { return lhs.m_i != rhs.m_i; }
321  friend bool operator==( const iterator& lhs, const iterator& rhs ) { return lhs.m_i == rhs.m_i; }
322  friend auto operator-( const iterator& lhs, const iterator& rhs ) { return lhs.m_i - rhs.m_i; }
323  ret_t operator*() const {
324  if constexpr ( is_range ) {
325  return *m_i;
326  } else {
327  return details2::deref_if( *m_i, std::bool_constant<!is_pointer>{} );
328  }
329  }
331  ++m_i;
332  return *this;
333  }
335  --m_i;
336  return *this;
337  }
338  bool is_null() const { return !*m_i; }
339  explicit operator bool() const { return !is_null(); }
340  };
341  vector_of_const_() = default;
342  void reserve( size_type size ) { m_containers.reserve( size ); }
343  template <typename T> // , typename = std::is_convertible<T,std::conditional_t<is_pointer,ptr_t,val_t>>
344  void push_back( T&& container ) {
345  details2::push_back( m_containers, std::forward<T>( container ),
346  std::bool_constant < is_pointer || is_range > {} );
347  } // note: does not copy its argument, so we're not really a container...
348  iterator begin() const { return m_containers.begin(); }
349  iterator end() const { return m_containers.end(); }
350  size_type size() const { return m_containers.size(); }
351 
352  template <typename X = Container>
353  std::enable_if_t<!std::is_pointer_v<X>, ref_t> front() const {
354  return *m_containers.front();
355  }
356  template <typename X = Container>
357  std::enable_if_t<std::is_pointer_v<X>, ptr_t> front() const {
358  return m_containers.front();
359  }
360 
361  template <typename X = Container>
362  std::enable_if_t<!std::is_pointer_v<X>, ref_t> back() const {
363  return *m_containers.back();
364  }
365  template <typename X = Container>
366  std::enable_if_t<std::is_pointer_v<X>, ptr_t> back() const {
367  return m_containers.back();
368  }
369 
370  template <typename X = Container>
371  std::enable_if_t<!std::is_pointer_v<X>, ref_t> operator[]( size_type i ) const {
372  return *m_containers[i];
373  }
374  template <typename X = Container>
375  std::enable_if_t<std::is_pointer_v<X>, ptr_t> operator[]( size_type i ) const {
376  return m_containers[i];
377  }
378 
379  template <typename X = Container>
380  std::enable_if_t<!std::is_pointer_v<X>, ref_t> at( size_type i ) const {
381  return *m_containers[i];
382  }
383  template <typename X = Container>
384  std::enable_if_t<std::is_pointer_v<X>, ptr_t> at( size_type i ) const {
385  return m_containers[i];
386  }
387 
388  bool is_null( size_type i ) const { return !m_containers[i]; }
389  };
390 
392  namespace detail2 { // utilities for detected_or_t{,_} usage
393  template <typename Tr>
394  using BaseClass_t = typename Tr::BaseClass;
395  template <typename Tr, typename T>
396  using OutputHandle_t = typename Tr::template OutputHandle<T>;
397  template <typename Tr, typename T>
398  using InputHandle_t = typename Tr::template InputHandle<T>;
399 
400  template <typename T>
401  constexpr auto is_tool_v = std::is_base_of_v<IAlgTool, std::decay_t<T>>;
402 
403  template <typename T>
405 
406  template <typename T>
407  using DefaultInputHandle = std::conditional_t<is_tool_v<T>, ToolHandle_t<T>, DataObjectReadHandle<T>>;
408  } // namespace detail2
409 
410  // check whether Traits::BaseClass is a valid type,
411  // if so, define BaseClass_t<Traits> as being Traits::BaseClass
412  // else define as being GaudiAlgorithm
413  template <typename Tr, typename Base = GaudiAlgorithm>
415 
416  // check whether Traits::{Input,Output}Handle<T> is a valid type,
417  // if so, define {Input,Output}Handle_t<Traits,T> as being Traits::{Input,Output}Handle<T>
418  // else define as being DataObject{Read,,Write}Handle<T>
419 
420  template <typename Tr, typename T>
422  template <typename Tr, typename T>
424 
425  template <typename Traits>
426  inline constexpr bool isLegacy =
427  std::is_base_of_v<Gaudi::details::LegacyAlgorithmAdapter, details::BaseClass_t<Traits>>;
428 
430 #define GAUDI_FUNCTIONAL_MAKE_VECTOR_OF_HANDLES_USES_DATAOBJID
431 
432  template <typename Handles>
434  Handles handles;
435  handles.reserve( init.size() );
436  std::transform( init.begin(), init.end(), std::back_inserter( handles ),
437  [&]( const auto& loc ) -> typename Handles::value_type {
438  return { loc, owner };
439  } );
440  return handles;
441  }
442 
443  template <typename Handle, typename Algo>
444  auto get( const Handle& handle, const Algo&, const EventContext& )
445  -> decltype( details::deref( handle.get() ) ) // make it SFINAE friendly...
446  {
447  return details::deref( handle.get() );
448  }
449 
450  template <typename IFace, typename Algo>
451  auto get( const ToolHandle<Gaudi::Interface::Bind::IBinder<IFace>>& handle, const Algo&, const EventContext& ctx ) {
452  return handle.bind( ctx );
453  }
454 
455  template <typename Handle>
456  auto getKey( const Handle& h ) -> decltype( h.objKey() ) {
457  return h.objKey();
458  }
459 
461  // given a pack, return a corresponding tuple
462  template <typename... In>
464  using type = std::tuple<In...>;
465 
466  static_assert( !std::disjunction_v<std::is_same<EventContext, In>...>,
467  "EventContext can only appear as first argument" );
468 
469  template <typename Algorithm, typename Handles>
470  static auto apply( const Algorithm& algo, Handles& handles ) {
471  return std::apply(
472  [&]( const auto&... handle ) { return algo( get( handle, algo, Gaudi::Hive::currentContext() )... ); },
473  handles );
474  }
475  template <typename Algorithm, typename Handles>
476  static auto apply( const Algorithm& algo, const EventContext& ctx, Handles& handles ) {
477  return std::apply( [&]( const auto&... handle ) { return algo( get( handle, algo, ctx )... ); }, handles );
478  }
479  };
480 
481  // except when it starts with EventContext, then drop it
482  template <typename... In>
484  using type = std::tuple<In...>;
485 
486  static_assert( !std::disjunction_v<std::is_same<EventContext, In>...>,
487  "EventContext can only appear as first argument" );
488 
489  template <typename Algorithm, typename Handles>
490  static auto apply( const Algorithm& algo, const EventContext& ctx, Handles& handles ) {
491  return std::apply( [&]( const auto&... handle ) { return algo( ctx, get( handle, algo, ctx )... ); }, handles );
492  }
493 
494  template <typename Algorithm, typename Handles>
495  static auto apply( const Algorithm& algo, Handles& handles ) {
496  return apply( algo, Gaudi::Hive::currentContext(), handles );
497  }
498  };
499 
500  template <typename... In>
502 
503  template <typename OutputSpec, typename InputSpec, typename Traits_>
505 
506  template <typename Out, typename In, typename Tr>
508  const std::string& newLoc ) {
509  auto sc = parent.setProperty( prop, newLoc );
510  if ( sc.isFailure() ) throw GaudiException( "Could not set Property", prop + " -> " + newLoc, sc );
511  }
512 
513  template <typename Out, typename In, typename Tr>
515  const std::vector<std::string>& newLocs ) {
518  ss << '[', newLocs, ", ", []( std::ostream & os, const auto& i ) -> auto& { return os << "'" << i << "'"; } )
519  << ']';
520  auto sc = parent.setProperty( prop, ss.str() );
521  if ( sc.isFailure() ) throw GaudiException( "Could not set Property", prop + " -> " + ss.str(), sc );
522  }
523 
524  template <typename... Out, typename... In, typename Traits_>
525  class DataHandleMixin<std::tuple<Out...>, std::tuple<In...>, Traits_> : public BaseClass_t<Traits_> {
526  static_assert( std::is_base_of_v<Algorithm, BaseClass_t<Traits_>>, "BaseClass must inherit from Algorithm" );
527 
528  template <typename IArgs, typename OArgs, std::size_t... I, std::size_t... J>
529  DataHandleMixin( std::string name, ISvcLocator* pSvcLocator, const IArgs& inputs, std::index_sequence<I...>,
530  const OArgs& outputs, std::index_sequence<J...> )
531  : BaseClass_t<Traits_>( std::move( name ), pSvcLocator )
532  , m_inputs( std::tuple_cat( std::forward_as_tuple( this ), std::get<I>( inputs ) )... )
533  , m_outputs( std::tuple_cat( std::forward_as_tuple( this ), std::get<J>( outputs ) )... ) {
534  // make sure this algorithm is seen as reentrant by Gaudi
535  this->setProperty( "Cardinality", 0 ).ignore();
536  }
537 
538  public:
539  constexpr static std::size_t N_in = sizeof...( In );
540  constexpr static std::size_t N_out = sizeof...( Out );
541 
544 
545  // generic constructor: N -> M
547  RepeatValues_<KeyValue, N_out> const& outputs )
548  : DataHandleMixin( std::move( name ), pSvcLocator, inputs, std::index_sequence_for<In...>{}, outputs,
549  std::index_sequence_for<Out...>{} ) {}
550 
551  // special cases: forward to the generic case...
552  // 1 -> 1
554  : DataHandleMixin( std::move( name ), locator, std::forward_as_tuple( input ),
555  std::forward_as_tuple( output ) ) {}
556  // 1 -> N
558  RepeatValues_<KeyValue, N_out> const& outputs )
559  : DataHandleMixin( std::move( name ), locator, std::forward_as_tuple( input ), outputs ) {}
560  // N -> 1
562  const KeyValue& output )
563  : DataHandleMixin( std::move( name ), locator, inputs, std::forward_as_tuple( output ) ) {}
564 
565  template <std::size_t N = 0>
566  decltype( auto ) inputLocation() const {
567  return getKey( std::get<N>( m_inputs ) );
568  }
569  template <typename T>
570  decltype( auto ) inputLocation() const {
571  return getKey( std::get<details::InputHandle_t<Traits_, std::decay_t<T>>>( m_inputs ) );
572  }
573  constexpr unsigned int inputLocationSize() const { return N_in; }
574 
575  template <std::size_t N = 0>
576  decltype( auto ) outputLocation() const {
577  return getKey( std::get<N>( m_outputs ) );
578  }
579  template <typename T>
580  decltype( auto ) outputLocation() const {
581  return getKey( std::get<details::OutputHandle_t<Traits_, std::decay_t<T>>>( m_outputs ) );
582  }
583  constexpr unsigned int outputLocationSize() const { return N_out; }
584 
585  protected:
586  bool isReEntrant() const override { return true; }
587 
590  };
591 
592  template <typename Traits_>
593  class DataHandleMixin<std::tuple<>, std::tuple<>, Traits_> : public BaseClass_t<Traits_> {
594  static_assert( std::is_base_of_v<Algorithm, BaseClass_t<Traits_>>, "BaseClass must inherit from Algorithm" );
595 
596  public:
600  : BaseClass_t<Traits_>( std::move( name ), pSvcLocator ) {
601  // make sure this algorithm is seen as reentrant by Gaudi
602  this->setProperty( "Cardinality", 0 ).ignore();
603  }
604 
605  protected:
606  bool isReEntrant() const override { return true; }
607 
609  };
610 
611  template <typename... In, typename Traits_>
612  class DataHandleMixin<std::tuple<>, std::tuple<In...>, Traits_> : public BaseClass_t<Traits_> {
613  static_assert( std::is_base_of_v<Algorithm, BaseClass_t<Traits_>>, "BaseClass must inherit from Algorithm" );
614 
615  template <typename IArgs, std::size_t... I>
616  DataHandleMixin( std::string name, ISvcLocator* pSvcLocator, const IArgs& inputs, std::index_sequence<I...> )
617  : BaseClass_t<Traits_>( std::move( name ), pSvcLocator )
618  , m_inputs( std::tuple_cat( std::forward_as_tuple( this ), std::get<I>( inputs ) )... ) {
619  // make sure this algorithm is seen as reentrant by Gaudi
620  this->setProperty( "Cardinality", 0 ).ignore();
621  }
622 
623  public:
626  constexpr static std::size_t N_in = sizeof...( In );
627 
628  // generic constructor: N -> 0
630  : DataHandleMixin( std::move( name ), pSvcLocator, inputs, std::index_sequence_for<In...>{} ) {}
631 
632  // special cases: forward to the generic case...
633  // 1 -> 0
635  : DataHandleMixin( std::move( name ), locator, std::forward_as_tuple( input ) ) {}
636 
637  template <std::size_t N = 0>
638  decltype( auto ) inputLocation() const {
639  return getKey( std::get<N>( m_inputs ) );
640  }
641  template <typename T>
642  decltype( auto ) inputLocation() const {
643  return getKey( std::get<details::InputHandle_t<Traits_, std::decay_t<T>>>( m_inputs ) );
644  }
645  constexpr unsigned int inputLocationSize() const { return N_in; }
646 
647  protected:
648  bool isReEntrant() const override { return true; }
649 
651  };
652 
653  template <typename Traits_>
654  class DataHandleMixin<std::tuple<void>, std::tuple<>, Traits_>
655  : public DataHandleMixin<std::tuple<>, std::tuple<>, Traits_> {
656  public:
658  };
659 
660  template <typename... Out, typename Traits_>
661  class DataHandleMixin<std::tuple<Out...>, std::tuple<>, Traits_> : public BaseClass_t<Traits_> {
662  static_assert( std::is_base_of_v<Algorithm, BaseClass_t<Traits_>>, "BaseClass must inherit from Algorithm" );
663 
664  template <typename OArgs, std::size_t... J>
665  DataHandleMixin( std::string name, ISvcLocator* pSvcLocator, const OArgs& outputs, std::index_sequence<J...> )
666  : BaseClass_t<Traits_>( std::move( name ), pSvcLocator )
667  , m_outputs( std::tuple_cat( std::forward_as_tuple( this ), std::get<J>( outputs ) )... ) {
668  // make sure this algorithm is seen as reentrant by Gaudi
669  this->setProperty( "Cardinality", 0 ).ignore();
670  }
671 
672  public:
673  constexpr static std::size_t N_out = sizeof...( Out );
676 
677  // generic constructor: 0 -> N
679  : DataHandleMixin( std::move( name ), pSvcLocator, outputs, std::index_sequence_for<Out...>{} ) {}
680 
681  // 0 -> 1
683  : DataHandleMixin( std::move( name ), locator, std::forward_as_tuple( output ) ) {}
684 
685  template <std::size_t N = 0>
686  decltype( auto ) outputLocation() const {
687  return getKey( std::get<N>( m_outputs ) );
688  }
689  constexpr unsigned int outputLocationSize() const { return N_out; }
690 
691  protected:
692  bool isReEntrant() const override { return true; }
693 
695  };
696 
698  template <typename Fun, typename Container, typename... Args>
699  constexpr void applyPostProcessing( const Fun&, Container&, Args... ) {
700  static_assert( sizeof...( Args ) == 0, "Args should not be used!" );
701  }
702 
703  template <typename Fun, typename Container>
704  auto applyPostProcessing( const Fun& fun, Container& c ) -> decltype( fun.postprocess( c ), void() ) {
705  fun.postprocess( c );
706  }
707 
708 } // namespace Gaudi::Functional::details
709 
710 #endif
IDataHandleHolder
Definition: IDataHandleHolder.h:24
Gaudi::Functional::details::detail2::BaseClass_t
typename Tr::BaseClass BaseClass_t
Definition: FunctionalDetails.h:394
Gaudi::Functional::details::insert_t::operator()
auto operator()(Container &c, Value &&v) const
Definition: FunctionalDetails.h:212
Gaudi::Functional::details::invoke_optionally_t
Definition: FunctionalDetails.h:149
Gaudi::Functional::details::vector_of_const_::operator[]
std::enable_if_t< std::is_pointer_v< X >, ptr_t > operator[](size_type i) const
Definition: FunctionalDetails.h:375
Gaudi::Functional::details::vector_of_const_::front
std::enable_if_t< std::is_pointer_v< X >, ptr_t > front() const
Definition: FunctionalDetails.h:357
Gaudi::Functional::details::vector_of_const_::val_t
std::add_const_t< std::remove_pointer_t< Container > > val_t
Definition: FunctionalDetails.h:297
Gaudi::Functional::details::vector_of_const_::iterator::is_null
bool is_null() const
Definition: FunctionalDetails.h:338
Gaudi::Functional::details::vector_of_const_::iterator
Definition: FunctionalDetails.h:306
Gaudi::Functional::details::deref_t::operator()
const In & operator()(const In *in) const
Definition: FunctionalDetails.h:232
std::is_same
Gaudi::Functional::details::vector_of_const_::iterator::operator*
ret_t operator*() const
Definition: FunctionalDetails.h:323
std::make_tuple
T make_tuple(T... args)
std::false_type
std::string
STL class.
details::size
constexpr auto size(const T &, Args &&...) noexcept
Definition: AnyDataWrapper.h:22
setProperty
bool PyHelper() setProperty(IInterface *p, char *name, char *value)
Definition: Bootstrap.cpp:242
Gaudi::Functional::details::DataHandleMixin< std::tuple<>, std::tuple< In... >, Traits_ >::m_inputs
std::tuple< details::InputHandle_t< Traits_, In >... > m_inputs
Definition: FunctionalDetails.h:650
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: FunctionalDetails.h:553
Gaudi::Functional::details::get
auto get(const ToolHandle< Gaudi::Interface::Bind::IBinder< IFace >> &handle, const Algo &, const EventContext &ctx)
Definition: FunctionalDetails.h:451
Gaudi::Functional::details
Definition: Consumer.h:21
Gaudi::NamedRange_
Definition: NamedRange.h:52
std::move
T move(T... args)
Gaudi::Functional::details::require_is_not_optional
std::enable_if_t<!is_optional_v< Arg > > require_is_not_optional
Definition: FunctionalDetails.h:143
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: FunctionalDetails.h:586
Gaudi::Functional::details::DataHandleMixin< std::tuple< Out... >, std::tuple<>, Traits_ >::DataHandleMixin
DataHandleMixin(std::string name, ISvcLocator *locator, const KeyValue &output)
Definition: FunctionalDetails.h:682
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::DataHandleMixin< std::tuple< Out... >, std::tuple<>, Traits_ >::DataHandleMixin
DataHandleMixin(std::string name, ISvcLocator *pSvcLocator, RepeatValues_< KeyValue, N_out > const &outputs)
Definition: FunctionalDetails.h:678
Gaudi::Functional::details::invoke_optionally
constexpr struct Gaudi::Functional::details::invoke_optionally_t invoke_optionally
Gaudi::Functional::details::vector_of_const_::front
std::enable_if_t<!std::is_pointer_v< X >, ref_t > front() const
Definition: FunctionalDetails.h:353
Gaudi::Functional::details::vector_of_const_::iterator::operator--
iterator & operator--()
Definition: FunctionalDetails.h:334
Gaudi::Functional::details::DataHandleMixin< std::tuple< Out... >, std::tuple<>, Traits_ >::isReEntrant
bool isReEntrant() const override
Definition: FunctionalDetails.h:692
std::pair< std::string, std::string >
std::vector::reserve
T reserve(T... args)
GaudiException.h
Gaudi::Functional::details::insert_t::operator()
auto operator()(Container &c, Value &&v) const -> decltype(c.push_back(v))
Definition: FunctionalDetails.h:199
Gaudi::Functional::details::isLegacy
constexpr bool isLegacy
Definition: FunctionalDetails.h:426
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: FunctionalDetails.h:616
std::vector< DataObjID >
std::string::size
T size(T... args)
Gaudi::Functional::details::deref_t
Definition: FunctionalDetails.h:220
ISvcLocator
Definition: ISvcLocator.h:46
std::back_inserter
T back_inserter(T... args)
GaudiException
Definition: GaudiException.h:31
Gaudi::Functional::details::vector_of_const_::m_containers
ContainerVector m_containers
Definition: FunctionalDetails.h:301
Algorithm.h
Gaudi::Functional::details::details2::get_from_handle::operator()
auto operator()(const Handle< I > &h) -> const In &
Definition: FunctionalDetails.h:265
Gaudi::Functional::details::vector_of_const_::iterator::iterator_category
typename it_t::iterator_category iterator_category
Definition: FunctionalDetails.h:314
Gaudi::Functional::details::DataHandleMixin< std::tuple< Out... >, std::tuple< In... >, Traits_ >::m_inputs
std::tuple< details::InputHandle_t< Traits_, In >... > m_inputs
Definition: FunctionalDetails.h:588
Gaudi::Functional::details::vector_of_const_::reserve
void reserve(size_type size)
Definition: FunctionalDetails.h:342
Gaudi::Functional::details::DataHandleMixin< std::tuple< Out... >, std::tuple<>, Traits_ >::outputLocationSize
constexpr unsigned int outputLocationSize() const
Definition: FunctionalDetails.h:689
Gaudi::Functional::details::DataHandleMixin< std::tuple<>, std::tuple<>, Traits_ >::isReEntrant
bool isReEntrant() const override
Definition: FunctionalDetails.h:606
Gaudi::Functional::details::vector_of_const_::size_type
typename ContainerVector::size_type size_type
Definition: FunctionalDetails.h:305
std::tuple
Gaudi::Functional::details::zip::const_range
decltype(auto) const_range(Args &&... args)
Zips multiple containers together to form a single const range.
Definition: FunctionalDetails.h:111
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: FunctionalDetails.h:561
gaudirun.c
c
Definition: gaudirun.py:525
std::vector::back
T back(T... args)
ranges::views
Definition: FunctionalDetails.h:34
System::typeinfoName
GAUDI_API const std::string typeinfoName(const std::type_info &)
Get platform independent information about the class type.
Definition: System.cpp:308
Gaudi::Functional::details::vector_of_const_
Definition: FunctionalDetails.h:294
Gaudi::Functional::details::vector_of_const_::operator[]
std::enable_if_t<!std::is_pointer_v< X >, ref_t > operator[](size_type i) const
Definition: FunctionalDetails.h:371
gaudirun.output
output
Definition: gaudirun.py:521
Gaudi::Functional::details::vector_of_const_::iterator::operator-
friend auto operator-(const iterator &lhs, const iterator &rhs)
Definition: FunctionalDetails.h:322
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: FunctionalDetails.h:529
Gaudi::Functional::details::get_values_helper
auto get_values_helper(std::index_sequence< I... >)
Definition: FunctionalDetails.h:162
Gaudi::Functional::details::to_DataObjID
std::vector< DataObjID > to_DataObjID(const std::vector< std::string > &in)
Definition: FunctionalDetails.h:119
std::vector::front
T front(T... args)
Gaudi::Functional::details::deref_t::operator()
In operator()(In &&in) const
Definition: FunctionalDetails.h:227
Gaudi::Functional::details::details2::get_from_handle::operator()
auto operator()(const Handle< Gaudi::Range_< I, IT >> &h) -> const In
Definition: FunctionalDetails.h:269
DataObjectHandle
DataObjectHandle.h GaudiKernel/DataObjectHandle.h.
Definition: AlgTool.h:36
Gaudi::Functional::details::vector_of_const_::iterator::iterator
iterator(it_t iter)
Definition: FunctionalDetails.h:310
Gaudi::Functional::details::filter_evtcontext_t< EventContext, In... >::apply
static auto apply(const Algorithm &algo, Handles &handles)
Definition: FunctionalDetails.h:495
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::insert_t
Definition: FunctionalDetails.h:193
Gaudi::Functional::details::insert_t::c_remove_ptr_t
std::remove_pointer_t< typename Container::value_type > c_remove_ptr_t
Definition: FunctionalDetails.h:196
bug_34121.t
t
Definition: bug_34121.py:30
ToolHandle
Definition: ToolHandle.h:132
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: FunctionalDetails.h:546
Gaudi::Functional::details::vector_of_const_::at
std::enable_if_t<!std::is_pointer_v< X >, ref_t > at(size_type i) const
Definition: FunctionalDetails.h:380
Gaudi::Functional::details::DataHandleMixin< std::tuple< Out... >, std::tuple< In... >, Traits_ >::inputLocationSize
constexpr unsigned int inputLocationSize() const
Definition: FunctionalDetails.h:573
TimingHistograms.name
name
Definition: TimingHistograms.py:25
GaudiPython.Pythonizations.ctx
ctx
Definition: Pythonizations.py:588
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: FunctionalDetails.h:85
Gaudi::Functional::details::invoke_optionally_t::operator()
void operator()(F &&f, Arg &&arg) const
Definition: FunctionalDetails.h:155
Gaudi::Functional::details::filter_evtcontext_t< EventContext, In... >::apply
static auto apply(const Algorithm &algo, const EventContext &ctx, Handles &handles)
Definition: FunctionalDetails.h:490
Gaudi::Functional::details::vector_of_const_::iterator::m_i
it_t m_i
Definition: FunctionalDetails.h:308
std::ostream
STL class.
Gaudi::Functional::details::detail2::InputHandle_t
typename Tr::template InputHandle< T > InputHandle_t
Definition: FunctionalDetails.h:398
Gaudi::Functional::details::detail2::DefaultInputHandle
std::conditional_t< is_tool_v< T >, ToolHandle_t< T >, DataObjectReadHandle< T > > DefaultInputHandle
Definition: FunctionalDetails.h:407
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: FunctionalDetails.h:665
Gaudi::Functional::details::vector_of_const_::value_type
std::conditional_t< is_pointer, ptr_t, val_t > value_type
Definition: FunctionalDetails.h:304
Gaudi::Functional::details::vector_of_const_::back
std::enable_if_t< std::is_pointer_v< X >, ptr_t > back() const
Definition: FunctionalDetails.h:366
Gaudi::cpp17::detected_or_t
typename details::detector< Default, void, Op, Args... >::type detected_or_t
Definition: detected.h:50
Gaudi::Algorithm
Base class from which all concrete algorithm classes should be derived.
Definition: Algorithm.h:90
DataObjectReadHandle
Definition: DataObjectHandle.h:405
AlgSequencer.h
h
Definition: AlgSequencer.py:32
Gaudi::Functional::details::applyPostProcessing
auto applyPostProcessing(const Fun &fun, Container &c) -> decltype(fun.postprocess(c), void())
Definition: FunctionalDetails.h:704
Gaudi::Functional::details::DataHandleMixin< std::tuple<>, std::tuple< In... >, Traits_ >::inputLocationSize
constexpr unsigned int inputLocationSize() const
Definition: FunctionalDetails.h:645
Gaudi::Functional::details::put
void put(const OutHandle &out_handle, OptOut &&out)
Definition: FunctionalDetails.h:184
Gaudi::Functional::details::filter_evtcontext_t::apply
static auto apply(const Algorithm &algo, Handles &handles)
Definition: FunctionalDetails.h:470
Gaudi::Functional::details::details2::is_optional_
decltype(std::declval< T >().has_value(), std::declval< T >().value()) is_optional_
Definition: FunctionalDetails.h:130
Gaudi::Functional::details::detail2::OutputHandle_t
typename Tr::template OutputHandle< T > OutputHandle_t
Definition: FunctionalDetails.h:396
Gaudi::Functional::details::deref
constexpr struct Gaudi::Functional::details::deref_t deref
Gaudi::Functional::details::DataHandleMixin< std::tuple< Out... >, std::tuple<>, Traits_ >::m_outputs
std::tuple< details::OutputHandle_t< Traits_, Out >... > m_outputs
Definition: FunctionalDetails.h:694
Gaudi::Functional::details::vector_of_const_::iterator::operator++
iterator & operator++()
Definition: FunctionalDetails.h:330
Gaudi::Functional::details::vector_of_const_::at
std::enable_if_t< std::is_pointer_v< X >, ptr_t > at(size_type i) const
Definition: FunctionalDetails.h:384
Gaudi::Functional::details::require_is_optional
std::enable_if_t< is_optional_v< Arg > > require_is_optional
Definition: FunctionalDetails.h:140
AnyDataWrapper
Definition: AnyDataWrapper.h:34
Gaudi::Functional::details::vector_of_const_::push_back
void push_back(T &&container)
Definition: FunctionalDetails.h:344
std::transform
T transform(T... args)
Gaudi::Functional::details::updateHandleLocation
void updateHandleLocation(DataHandleMixin< Out, In, Tr > &parent, const std::string &prop, const std::string &newLoc)
Definition: FunctionalDetails.h:507
Gaudi
Header file for std:chrono::duration-based Counters.
Definition: __init__.py:1
Gaudi::Functional::details::vector_of_const_::iterator::operator==
friend bool operator==(const iterator &lhs, const iterator &rhs)
Definition: FunctionalDetails.h:321
Gaudi::Functional::details::DataHandleMixin< std::tuple< Out... >, std::tuple< In... >, Traits_ >::m_outputs
std::tuple< details::OutputHandle_t< Traits_, Out >... > m_outputs
Definition: FunctionalDetails.h:589
Gaudi::Functional::details::vector_of_const_::back
std::enable_if_t<!std::is_pointer_v< X >, ref_t > back() const
Definition: FunctionalDetails.h:362
IBinder.h
HistoDumpEx.v
v
Definition: HistoDumpEx.py:27
Gaudi::Functional::details::filter_evtcontext_t
Definition: FunctionalDetails.h:463
Gaudi::Functional::details::details2::is_gaudi_range
Definition: FunctionalDetails.h:242
Gaudi::Range_
Definition: Range.h:95
std::ostringstream
STL class.
Gaudi::Functional::details::DataHandleMixin< std::tuple<>, std::tuple< In... >, Traits_ >::isReEntrant
bool isReEntrant() const override
Definition: FunctionalDetails.h:648
Gaudi::Functional::details::DataHandleMixin< std::tuple<>, std::tuple<>, Traits_ >::m_inputs
std::tuple m_inputs
Definition: FunctionalDetails.h:608
gaudirun.type
type
Definition: gaudirun.py:160
ThreadLocalContext.h
Gaudi::Functional::details::deref_t::operator()
const In & operator()(const In &in) const
Definition: FunctionalDetails.h:222
Gaudi::cpp17::detected_t
typename is_detected< Op, Args... >::type detected_t
Definition: detected.h:46
DataObjectHandle::put
T * put(std::unique_ptr< T > object) const
Register object in transient store.
Definition: DataObjectHandle.h:176
Gaudi::Functional::details::zip::verifySizes
decltype(auto) verifySizes(Args &... args)
Verify the data container sizes have the same sizes.
Definition: FunctionalDetails.h:91
Gaudi::Functional::details::filter_evtcontext_t::apply
static auto apply(const Algorithm &algo, const EventContext &ctx, Handles &handles)
Definition: FunctionalDetails.h:476
Gaudi::Functional::details::details2::get_from_handle
Definition: FunctionalDetails.h:263
Gaudi::Functional::details::vector_of_const_::iterator::operator!=
friend bool operator!=(const iterator &lhs, const iterator &rhs)
Definition: FunctionalDetails.h:320
gaudirun.args
args
Definition: gaudirun.py:336
Gaudi::Functional::details::vector_of_const_::begin
iterator begin() const
Definition: FunctionalDetails.h:348
std::vector::begin
T begin(T... args)
GaudiAlgorithm.h
std
STL namespace.
Gaudi::Functional::details::vector_of_const_::iterator::difference_type
typename it_t::difference_type difference_type
Definition: FunctionalDetails.h:318
Gaudi::Functional::details::is_optional_v
constexpr bool is_optional_v
Definition: FunctionalDetails.h:137
Gaudi::Functional::details::details2::push_back
void push_back(Container &c, const Value &v, std::false_type)
Definition: FunctionalDetails.h:258
Gaudi::Functional::details::detail2::is_tool_v
constexpr auto is_tool_v
Definition: FunctionalDetails.h:401
Gaudi::Functional::details::details2::deref_if
T & deref_if(T *const t, std::true_type)
Definition: FunctionalDetails.h:288
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::details::DataHandleMixin< std::tuple< Out... >, std::tuple< In... >, Traits_ >::outputLocationSize
constexpr unsigned int outputLocationSize() const
Definition: FunctionalDetails.h:583
Gaudi::Functional::Traits::BaseClass_t
Definition: FunctionalUtilities.h:72
Gaudi::Functional::details::vector_of_const_::iterator::value_type
typename it_t::iterator_category value_type
Definition: FunctionalDetails.h:315
detected.h
Gaudi::Functional::details::vector_of_const_::iterator::pointer
typename it_t::pointer pointer
Definition: FunctionalDetails.h:317
Gaudi::Functional::details::vector_of_const_::iterator::it_t
typename ContainerVector::const_iterator it_t
Definition: FunctionalDetails.h:307
Gaudi::Functional::details::updateHandleLocations
void updateHandleLocations(DataHandleMixin< Out, In, Tr > &parent, const std::string &prop, const std::vector< std::string > &newLocs)
Definition: FunctionalDetails.h:514
Gaudi::Functional::details::insert_t::operator()
auto operator()(Container &c, Value &&v) const -> decltype(c.insert(v))
Definition: FunctionalDetails.h:204
Gaudi::Functional::details::vector_of_const_::ref_t
std::add_lvalue_reference_t< val_t > ref_t
Definition: FunctionalDetails.h:299
Gaudi::Functional::details::vector_of_const_::iterator::reference
typename it_t::reference reference
Definition: FunctionalDetails.h:316
Gaudi::Functional::details::DataHandleMixin
Definition: FunctionalDetails.h:504
Gaudi::Functional::details::details2::get_from_handle::operator()
auto operator()(const Handle< Gaudi::NamedRange_< I, IT >> &h) -> const In
Definition: FunctionalDetails.h:273
Gaudi::Functional::details::vector_of_const_::end
iterator end() const
Definition: FunctionalDetails.h:349
std::ostringstream::str
T str(T... args)
std::size_t
std::vector::end
T end(T... args)
Gaudi::Functional::details::BaseClass_t
Gaudi::cpp17::detected_or_t< Base, detail2::BaseClass_t, Tr > BaseClass_t
Definition: FunctionalDetails.h:414
Gaudi::Functional::details::zip::printSizes
void printSizes(OS &out, Arg &&arg, Args &&... args)
Print the parameters.
Definition: FunctionalDetails.h:65
Gaudi::Functional::details::details2::value_type_of_t
typename T::value_type value_type_of_t
Definition: FunctionalDetails.h:133
StatusCode::FAILURE
constexpr static const auto FAILURE
Definition: StatusCode.h:101
Gaudi::Functional::details::DataHandleMixin< std::tuple<>, std::tuple<>, Traits_ >::DataHandleMixin
DataHandleMixin(std::string name, ISvcLocator *pSvcLocator, std::tuple<>={}, std::tuple<>={})
Definition: FunctionalDetails.h:599
Gaudi::Functional::details::vector_of_const_::iterator::ret_t
std::conditional_t< is_pointer, ptr_t, ref_t > ret_t
Definition: FunctionalDetails.h:311
Gaudi::Functional::details::insert
constexpr struct Gaudi::Functional::details::insert_t insert
Gaudi::Interface::Bind::IBinder
Definition: IBinder.h:56
DataObjectHandle.h
Gaudi::Functional::details::details2::get_from_handle::operator()
auto operator()(const Handle< I > &h) -> const In
Definition: FunctionalDetails.h:278
Gaudi::Functional::details::OutputHandle_t
Gaudi::cpp17::detected_or_t< DataObjectWriteHandle< T >, detail2::OutputHandle_t, Tr, T > OutputHandle_t
Definition: FunctionalDetails.h:421
Gaudi::Functional::details::filter_evtcontext
typename filter_evtcontext_t< In... >::type filter_evtcontext
Definition: FunctionalDetails.h:501
Gaudi::Functional::details::DataHandleMixin< std::tuple<>, std::tuple< In... >, Traits_ >::DataHandleMixin
DataHandleMixin(std::string name, ISvcLocator *pSvcLocator, RepeatValues_< KeyValue, N_in > const &inputs)
Definition: FunctionalDetails.h:629
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: FunctionalDetails.h:298
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: FunctionalDetails.h:557
Gaudi::Functional::details::zip::range
decltype(auto) range(Args &&... args)
Zips multiple containers together to form a single range.
Definition: FunctionalDetails.h:102
GaudiUtils::details::ostream_joiner
Stream & ostream_joiner(Stream &os, Iterator first, Iterator last, Separator sep, OutputElement output=OutputElement{})
Definition: SerializeSTL.h:73
Gaudi::Functional::details::DataHandleMixin< std::tuple<>, std::tuple< In... >, Traits_ >::DataHandleMixin
DataHandleMixin(std::string name, ISvcLocator *locator, const KeyValue &input)
Definition: FunctionalDetails.h:634
PrepareBase.out
out
Definition: PrepareBase.py:20
Gaudi::Functional::details::getKey
auto getKey(const Handle &h) -> decltype(h.objKey())
Definition: FunctionalDetails.h:456
Gaudi::Functional::details::remove_optional_t
std::conditional_t< is_optional_v< T >, Gaudi::cpp17::detected_t< details2::value_type_of_t, T >, T > remove_optional_t
Definition: FunctionalDetails.h:147
Gaudi::Functional::details::vector_of_const_::is_null
bool is_null(size_type i) const
Definition: FunctionalDetails.h:388
Gaudi::Functional::details::vector_of_const_::size
size_type size() const
Definition: FunctionalDetails.h:350