#include <tuple>
#include <iostream>
#include <string>
#include <type_traits>
#include "AthenaBaseComps/AthAlgTool.h"
#include "GaudiKernel/StatusCode.h"
#include <Gaudi/Parsers/Factory.h>
#include "MacroHelpers.h"

Include dependency graph for CaloGPUClusterAndCellDataMonitorOptions.h:

This graph shows which files directly or indirectly include this file:

Classes
struct	impl::class_can_be_tuple< Check >
struct	impl::struct_tuple_conversion< n >
struct	impl::simple_tuple_conversion< T, Elems >
struct	Gaudi::Parsers::Grammar_< Iterator, T, Skipper, typename std::enable_if_t< impl::class_can_be_tuple_v< T > > >
struct	MatchingOptions
struct	SimpleSingleTool
struct	SimpleToolPair

Namespaces
namespace	impl
namespace	Gaudi
	=============================================================================
namespace	Gaudi::Parsers

Macros
#define	CALORECGPU_VARSB_APPENDER(THIS, PREFIX, IGNORE)
#define	CALORECGPU_VARSB_ASSIGNER(THIS, IGNORE1, IGNORE2)
#define	CALORECGPU_VARSB_ENCAPSULATOR_A(...)
#define	CALORECGPU_VARSB_ENCAPSULATOR_B(...)
#define	CALORECGPU_VARSB_ENCAPSULATOR_ASSIGN(...)
#define	CALORECGPU_VARSB_EXPANDER(THIS_NUM, IGNORE, SMALLER_NUMS)
#define	CALORECGPU_OPTIONCLASS_CONSTRUCTORS(CLASSNAME)

Typedefs
template<class T>
using	impl::to_tuple_type = decltype(to_tuple_type_helper(std::declval<T>()))

Functions
template<class T>
void	impl::tuple_safe_copy (T &dest, const T &source)
template<class T, std::enable_if_t< impl::class_can_be_tuple_v< T > > * = nullptr>
void	impl::tuple_safe_copy (T &s, const typename T::TupleType &tuple)
template<class T, std::enable_if_t< impl::class_can_be_tuple_v< T > > * = nullptr>
void	impl::tuple_safe_copy (typename T::TupleType &tuple, const T &s)
template<class T, std::enable_if_t< impl::class_can_be_tuple_v< T > > * = nullptr>
void	impl::tuple_safe_copy (std::vector< typename T::TupleType > &t_v, const std::vector< T > &s_v)
template<class T, std::enable_if_t< impl::class_can_be_tuple_v< T > > * = nullptr>
void	impl::tuple_safe_copy (std::vector< T > &s_v, const std::vector< typename T::TupleType > &t_v)
template<class T>
auto	impl::to_tuple_type_helper (const T &)
template<class T, std::enable_if_t< impl::class_can_be_tuple_v< T > > * = nullptr>
auto	impl::to_tuple_type_helper (const std::vector< T > &)
template<class Stream, class T>
void	impl::output_helper (Stream &s, const T &t, const std::string &after)
template<class Stream, class T>
void	impl::output_helper (Stream &s, const std::vector< T > &v, const std::string &after)
template<class ... Tup>
StatusCode	Gaudi::Parsers::parse (std::tuple< Tup... > &tup, const Gaudi::Parsers::InputData &input)
template<class T>
StatusCode	Gaudi::Parsers::parse (std::vector< T > &v, const Gaudi::Parsers::InputData &input)
template<class ... Tup>
std::ostream &	operator<< (std::ostream &s, const std::tuple< Tup... > &tup)
template<class T, std::enable_if_t< impl::class_can_be_tuple_v< T > > * = nullptr>
std::ostream &	operator<< (std::ostream &s, const T &t)

Variables
template<class T>
static constexpr bool	impl::class_can_be_tuple_v = class_can_be_tuple<T>::value

Macro Definition Documentation

◆ CALORECGPU_OPTIONCLASS_CONSTRUCTORS

#define CALORECGPU_OPTIONCLASS_CONSTRUCTORS ( CLASSNAME )

Value:

  CLASSNAME() = default;                                \
  CLASSNAME(const TupleType & t)                        \
  {                                                     \
    (*this) = from_tuple(t);                            \
  }                                                     \

Definition at line 346 of file CaloGPUClusterAndCellDataMonitorOptions.h.

#define CALORECGPU_OPTIONCLASS_CONSTRUCTORS(CLASSNAME)  \
  CLASSNAME() = default;                                \
  CLASSNAME(const TupleType & t)                        \
  {                                                     \
    (*this) = from_tuple(t);                            \
  }                                                     \
 

◆ CALORECGPU_VARSB_APPENDER

#define CALORECGPU_VARSB_APPENDER	(	THIS,
		PREFIX,
		IGNORE )

Value:

, CRGPU_CONCAT(PREFIX, THIS)

CRGPU_CONCAT

#define CRGPU_CONCAT(X, Y)

Helper macro, concatenates two arguments.

Definition MacroHelpers.h:29

PREFIX

static const string PREFIX

Definition TMsgLogger.cxx:36

Definition at line 96 of file CaloGPUClusterAndCellDataMonitorOptions.h.

◆ CALORECGPU_VARSB_ASSIGNER

#define CALORECGPU_VARSB_ASSIGNER	(	THIS,
		IGNORE1,
		IGNORE2 )

Value:

tuple_safe_copy(CRGPU_CONCAT(b, THIS), CRGPU_CONCAT(a, THIS));

a

static Double_t a

Definition LArPhysWaveHECTool.cxx:38

Definition at line 97 of file CaloGPUClusterAndCellDataMonitorOptions.h.

◆ CALORECGPU_VARSB_ENCAPSULATOR_A

#define CALORECGPU_VARSB_ENCAPSULATOR_A ( ... )

Value:

CRGPU_MACRO_EXPANSION(CALORECGPU_VARSB_APPENDER, a, __VA_ARGS__ )

CALORECGPU_VARSB_APPENDER

#define CALORECGPU_VARSB_APPENDER(THIS, PREFIX, IGNORE)

Definition CaloGPUClusterAndCellDataMonitorOptions.h:96

CRGPU_MACRO_EXPANSION

#define CRGPU_MACRO_EXPANSION(MACRO, EXTRA_ARG,...)

Helper macro to apply a macro to all elements of the variadic list, with EXTRA_ARG and the parenthesi...

Definition MacroHelpers.h:96

Definition at line 99 of file CaloGPUClusterAndCellDataMonitorOptions.h.

◆ CALORECGPU_VARSB_ENCAPSULATOR_ASSIGN

#define CALORECGPU_VARSB_ENCAPSULATOR_ASSIGN ( ... )

Value:

CRGPU_MACRO_EXPANSION(CALORECGPU_VARSB_ASSIGNER, _ , __VA_ARGS__, )

CALORECGPU_VARSB_ASSIGNER

#define CALORECGPU_VARSB_ASSIGNER(THIS, IGNORE1, IGNORE2)

Definition CaloGPUClusterAndCellDataMonitorOptions.h:97

Definition at line 102 of file CaloGPUClusterAndCellDataMonitorOptions.h.

◆ CALORECGPU_VARSB_ENCAPSULATOR_B

#define CALORECGPU_VARSB_ENCAPSULATOR_B ( ... )

Value:

CRGPU_MACRO_EXPANSION(CALORECGPU_VARSB_APPENDER, b, __VA_ARGS__ )

Definition at line 100 of file CaloGPUClusterAndCellDataMonitorOptions.h.

◆ CALORECGPU_VARSB_EXPANDER

#define CALORECGPU_VARSB_EXPANDER	(	THIS_NUM,
		IGNORE,
		SMALLER_NUMS )

Value:

  template <> struct struct_tuple_conversion<THIS_NUM>                                             \
  {                                                                                                \
    template <class T, class TupleT>                                                               \
    static void s2t(const T & t, TupleT & tup)                                                     \
    {                                                                                              \
      const auto & [CRGPU_CONCAT(a, THIS_NUM) CALORECGPU_VARSB_ENCAPSULATOR_A SMALLER_NUMS] = t;   \
      auto & [CRGPU_CONCAT(b, THIS_NUM) CALORECGPU_VARSB_ENCAPSULATOR_B SMALLER_NUMS] = tup;       \
      tuple_safe_copy(CRGPU_CONCAT(b, THIS_NUM), CRGPU_CONCAT(a, THIS_NUM));                       \
      CALORECGPU_VARSB_ENCAPSULATOR_ASSIGN SMALLER_NUMS                                            \
    }                                                                                              \
    template <class TupleT, class T>                                                               \
    static void t2s(const TupleT & tup, T & t)                                                     \
    {                                                                                              \
      const auto & [CRGPU_CONCAT(a, THIS_NUM) CALORECGPU_VARSB_ENCAPSULATOR_A SMALLER_NUMS] = tup; \
      auto & [CRGPU_CONCAT(b, THIS_NUM) CALORECGPU_VARSB_ENCAPSULATOR_B SMALLER_NUMS] = t;         \
      tuple_safe_copy(CRGPU_CONCAT(b, THIS_NUM), CRGPU_CONCAT(a, THIS_NUM));                       \
      CALORECGPU_VARSB_ENCAPSULATOR_ASSIGN SMALLER_NUMS                                            \
    }                                                                                              \
  };                                                                                               \

Definition at line 105 of file CaloGPUClusterAndCellDataMonitorOptions.h.

#define CALORECGPU_VARSB_EXPANDER(THIS_NUM, IGNORE, SMALLER_NUMS)                                  \
  template <> struct struct_tuple_conversion<THIS_NUM>                                             \
  {                                                                                                \
    template <class T, class TupleT>                                                               \
    static void s2t(const T & t, TupleT & tup)                                                     \
    {                                                                                              \
      const auto & [CRGPU_CONCAT(a, THIS_NUM) CALORECGPU_VARSB_ENCAPSULATOR_A SMALLER_NUMS] = t;   \
      auto & [CRGPU_CONCAT(b, THIS_NUM) CALORECGPU_VARSB_ENCAPSULATOR_B SMALLER_NUMS] = tup;       \
      tuple_safe_copy(CRGPU_CONCAT(b, THIS_NUM), CRGPU_CONCAT(a, THIS_NUM));                       \
      CALORECGPU_VARSB_ENCAPSULATOR_ASSIGN SMALLER_NUMS                                            \
    }                                                                                              \
    template <class TupleT, class T>                                                               \
    static void t2s(const TupleT & tup, T & t)                                                     \
    {                                                                                              \
      const auto & [CRGPU_CONCAT(a, THIS_NUM) CALORECGPU_VARSB_ENCAPSULATOR_A SMALLER_NUMS] = tup; \
      auto & [CRGPU_CONCAT(b, THIS_NUM) CALORECGPU_VARSB_ENCAPSULATOR_B SMALLER_NUMS] = t;         \
      tuple_safe_copy(CRGPU_CONCAT(b, THIS_NUM), CRGPU_CONCAT(a, THIS_NUM));                       \
      CALORECGPU_VARSB_ENCAPSULATOR_ASSIGN SMALLER_NUMS                                            \
    }                                                                                              \
  };                                                                                               \
 

Function Documentation

◆ operator<<() [1/2]

template<class ... Tup>

std::ostream & operator<<	(	std::ostream &	s,
		const std::tuple< Tup... > &	tup )

Definition at line 299 of file CaloGPUClusterAndCellDataMonitorOptions.h.

{
  std::apply( [&] (const Tup & ... arg)
  {
    s << "(";
 
    size_t num = 0;
 
    (void) ( (void) impl::output_helper(s, arg, (++num < sizeof...(Tup) ? ", " : "")), ... );
 
    s << ")";
 
  }, tup );
 
  return s;
}

◆ operator<<() [2/2]

template<class T, std::enable_if_t< impl::class_can_be_tuple_v< T > > * = nullptr>

std::ostream & operator<<	(	std::ostream &	s,
		const T &	t )

Definition at line 318 of file CaloGPUClusterAndCellDataMonitorOptions.h.

{
  return s << T::to_tuple(t);
}

Classes

Namespaces

Macros

Typedefs

Functions

Variables

Macro Definition Documentation

◆ CALORECGPU_OPTIONCLASS_CONSTRUCTORS

◆ CALORECGPU_VARSB_APPENDER

◆ CALORECGPU_VARSB_ASSIGNER

◆ CALORECGPU_VARSB_ENCAPSULATOR_A

◆ CALORECGPU_VARSB_ENCAPSULATOR_ASSIGN

◆ CALORECGPU_VARSB_ENCAPSULATOR_B

◆ CALORECGPU_VARSB_EXPANDER

Function Documentation

◆ operator<<() [1/2]

◆ operator<<() [2/2]