ATLAS Offline Software
Loading...
Searching...
No Matches
Classes | Namespaces | Macros
IRingerProcedure.h File Reference
#include <vector>
#include <utility>
#include <TDirectory.h>
#include "RingerSelectorTools/tools/VariableDependency.h"
#include "RingerSelectorTools/tools/IRedirectMsgStream.h"
#include <type_traits>
#include "RingerSelectorTools/procedures/Types.h"
Include dependency graph for IRingerProcedure.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes

class  Ringer::IRingerProcedure
 The base interface for all Ringer procedures. More...
class  Ringer::RingerProcedureType< procedure_t >
 Check Ringer Procedure type. More...
struct  Ringer::RingerProcedureType< procedure_t * >
 RingerProcedureType specialization to ensure that procedure_t is not a pointer. More...
class  Ringer::PreProcessing::IPreProcessor
 PreProcessing interface to be inherited by PreProcessing procedures. More...
class  Ringer::PreProcessing::IPreProcessorVarDep
 PreProcessor interface to be used by Ringer Wrapper. More...
class  Ringer::Discrimination::IDiscriminator
 Discriminator interface to be inherited by discrimination procedures. More...
class  Ringer::Discrimination::IDiscriminatorVarDep
 Discriminator interface to be used by Ringer Wrapper. More...
class  Ringer::Discrimination::IThreshold
 Threshold interface to be inherited by thresholding procedures. More...
class  Ringer::Discrimination::IThresholdVarDep
 Threshold interface to be used by Ringer Wrapper. More...

Namespaces

namespace  Ringer
 Namespace dedicated for Ringer utilities.
namespace  Ringer::PreProcessing
 Namespace dedicated for Ringer pre-processing utilities.
namespace  Ringer::Discrimination
 Namespace dedicated for Ringer Discrimination utilities.

Macros

#define INCLUDE_HEADER_ONLY
#define RINGER_PROCEDURE_BASE_METHODS(self)
 Define ringer interface default methods.
#define RINGER_DEFINE_INTERFACE_DEFAULT_METHODS(self)
 Define Ringer interface procedure type methods.
#define __RINGER_DEFINE_PROCEDURE_STANDARD_METHODS__(self)
#define RINGER_DEFINE_PROCEDURE(self)
 Use this macro when procedure has member properties.
#define RINGER_DEFINE_NOMEMBER_PROCEDURE(self)
 Use this macro when procedure hasn't member properties.
#define RINGER_DEFINE_PROCEDURE_DEFAULT_METHODS(self)
 This macro should be defined for every Ringer Procedure defined after the class is defined, within same scope and translation unit where it is defined.

Macro Definition Documentation

◆ __RINGER_DEFINE_PROCEDURE_STANDARD_METHODS__

#define __RINGER_DEFINE_PROCEDURE_STANDARD_METHODS__ ( self)
Value:
\
virtual std::string name() const \
override; \
template <typename T = const char*> \
static T procType(); \
\
const

Definition at line 69 of file IRingerProcedure.h.

69#define __RINGER_DEFINE_PROCEDURE_STANDARD_METHODS__(self) \
70 \
71 virtual std::string name() const \
72 override; \
73 template <typename T = const char*> \
74 static T procType(); \
75 \
76

◆ INCLUDE_HEADER_ONLY

#define INCLUDE_HEADER_ONLY

Definition at line 22 of file IRingerProcedure.h.

◆ RINGER_DEFINE_INTERFACE_DEFAULT_METHODS

#define RINGER_DEFINE_INTERFACE_DEFAULT_METHODS ( self)
Value:
\
template<> \
inline \
const char* self::procType() \
{ \
return #self; \
} \
\
template<> \
inline \
Ringer::RingerProcedureType<self>::procEnum_t self::procType() \
{ \
return Ringer::getType< \
Ringer::RingerProcedureType<self>::procEnum_t>(#self); \
}
Ringer::getType
T getType(const char *cStr)
Return Ringer enumeration of type T identifying string type:
Ringer::RingerProcedureType::procEnum_t
std::conditional< is_pre_processor, preProcEnum_t, typenamestd::conditional< is_discriminator, discrEnum_t, thresEnum_t >::type >::type procEnum_t
Definition IRingerProcedure.h:211

Define Ringer interface procedure type methods.

Definition at line 52 of file IRingerProcedure.h.

52#define RINGER_DEFINE_INTERFACE_DEFAULT_METHODS(self) \
53 \
54 template<> \
55 inline \
56 const char* self::procType() \
57 { \
58 return #self; \
59 } \
60 \
61 template<> \
62 inline \
63 Ringer::RingerProcedureType<self>::procEnum_t self::procType() \
64 { \
65 return Ringer::getType< \
66 Ringer::RingerProcedureType<self>::procEnum_t>(#self); \
67 }

◆ RINGER_DEFINE_NOMEMBER_PROCEDURE

#define RINGER_DEFINE_NOMEMBER_PROCEDURE ( self)
Value:
\
public: \
__RINGER_DEFINE_PROCEDURE_STANDARD_METHODS__(self) \
\
virtual void print(MSG::Level lvl) const \
override \
{ \
if ( !this->isStreamAvailable() ) { \
std::cerr << "Cannot print " << this->name() << ", stream unavailable" \
<< std::endl; \
} \
if ( this->level() > lvl ) { \
return; \
} \
ATH_MSG_LVL(lvl, "Procedure hasn't any property."); \
}
print
void print(char *figname, TCanvas *c1)
Definition TRTCalib_StrawStatusPlots.cxx:26

Use this macro when procedure hasn't member properties.

Definition at line 91 of file IRingerProcedure.h.

91#define RINGER_DEFINE_NOMEMBER_PROCEDURE(self) \
92 \
93 public: \
94 __RINGER_DEFINE_PROCEDURE_STANDARD_METHODS__(self) \
95 \
96 virtual void print(MSG::Level lvl) const \
97 override \
98 { \
99 if ( !this->isStreamAvailable() ) { \
100 std::cerr << "Cannot print " << this->name() << ", stream unavailable" \
101 << std::endl; \
102 } \
103 if ( this->level() > lvl ) { \
104 return; \
105 } \
106 ATH_MSG_LVL(lvl, "Procedure hasn't any property."); \
107 }

◆ RINGER_DEFINE_PROCEDURE

#define RINGER_DEFINE_PROCEDURE ( self)
Value:
\
public: \
__RINGER_DEFINE_PROCEDURE_STANDARD_METHODS__(self) \
\
virtual void print(MSG::Level lvl) const \
override;

Use this macro when procedure has member properties.

Definition at line 80 of file IRingerProcedure.h.

80#define RINGER_DEFINE_PROCEDURE(self) \
81 \
82 public: \
83 __RINGER_DEFINE_PROCEDURE_STANDARD_METHODS__(self) \
84 \
85 virtual void print(MSG::Level lvl) const \
86 override;

◆ RINGER_DEFINE_PROCEDURE_DEFAULT_METHODS

#define RINGER_DEFINE_PROCEDURE_DEFAULT_METHODS ( self)
Value:
\
RINGER_DEFINE_INTERFACE_DEFAULT_METHODS(self) \
\
inline \
std::string self::name() const \
{ \
return this->procType<const char*>(); \
}

This macro should be defined for every Ringer Procedure defined after the class is defined, within same scope and translation unit where it is defined.

You will have to define the procedure print method yourself.

Definition at line 117 of file IRingerProcedure.h.

117#define RINGER_DEFINE_PROCEDURE_DEFAULT_METHODS(self) \
118 \
119 RINGER_DEFINE_INTERFACE_DEFAULT_METHODS(self) \
120 \
121 inline \
122 std::string self::name() const \
123 { \
124 return this->procType<const char*>(); \
125 }

◆ RINGER_PROCEDURE_BASE_METHODS

#define RINGER_PROCEDURE_BASE_METHODS ( self)
Value:
\
public: \
\
template <typename T = const char*> \
static T procType(); \
\
virtual std::string name() const = 0; \
\
virtual void print(MSG::Level lvl) const = 0;

Define ringer interface default methods.

It defines static template member type, that can be used to retrieve procedure type as an enumeration type. In order for this to work, make sure to add the enumeration value on Types.h file and add it properly to the conversion string<->enumeration function in the Types.cxx file.

Beware that it changes scope inside class to public.

Definition at line 38 of file IRingerProcedure.h.

38#define RINGER_PROCEDURE_BASE_METHODS(self) \
39 \
40 public: \
41 \
42 template <typename T = const char*> \
43 static T procType(); \
44 \
45 virtual std::string name() const = 0; \
46 \
47 virtual void print(MSG::Level lvl) const = 0;
Generated on for ATLAS Offline Software by doxygen 1.14.0