blob: e555092b9645ddc27e24b8bb43c745921dd66f6c (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
|
#ifndef TARG_PREDICATEBASE_H
#define TARG_PREDICATEBASE_H
/**
* @file predicatebase.H
*
* @brief Interface for an abstract targeting predicate which filters a set of
* targets based on the programmed criteria. Concrete predicates must
* provide the interface specified here.
*/
//******************************************************************************
// Includes
//******************************************************************************
// STD
// Other Host Boot Components
// Targeting Component
//******************************************************************************
// Macros
//******************************************************************************
/**
* @brief Disable copy constructor / assignment operators
*/
#undef TARG_DISABLE_COPY_AND_ASSIGNMENT_OPERATORS
#define TARG_DISABLE_COPY_AND_ASSIGNMENT_OPERATORS(Type) \
Type(const Type& i_other); \
Type& operator=(const Type& i_other)
/**
* @brief Ensure trace macros are undefined
*/
#undef TARG_NAMESPACE
#undef TARG_CLASS
#undef TARG_FN
//******************************************************************************
// Interface
//******************************************************************************
namespace TARGETING
{
#define TARG_NAMESPACE "TARGETING::"
#define TARG_CLASS "PredicateBase::"
class Target;
/**
* @brief Abstract predicate class which specifies an interface for all
* concrete predicates. A predicate acts as a filter on a set of targets.
*/
class PredicateBase
{
public:
/**
* @brief Destroys the predicate base class (nothing to do)
*/
virtual ~PredicateBase();
/**
* @brief Predicate function call interface
*
* @par Detailed Description:
* This abstract interface must be declared/implemented by all
* derived predicates. A concrete version of this function accepts
* a target, applies the associated predicate logic, and returns
* whether the target met the predicate criteria or not. Caller
* must always supply a valid Target*, or routine will assert.
*
* @param[in] i_pTarget Pointer to target to apply predicate to
*
* @return Boolean indicating whether target matches criteria specified
* by the concrete predicate
*
* @retval true Target matches the predicate criteria
* @retval false Target does not match the predicate criteria
*/
virtual bool operator()(
const Target* i_pTarget) const = 0;
protected:
/**
* @brief Create the predicate base class (nothing to do)
*
* @note Constructor protected to allow access from the derived class
*/
PredicateBase()
{
#define TARG_FN "PredicateBase()"
#undef TARG_FN
}
private:
TARG_DISABLE_COPY_AND_ASSIGNMENT_OPERATORS(PredicateBase);
};
#undef TARG_CLASS
#undef TARG_NAMESPACE
} // End namespace TARGETING
#endif // TARG_PREDICATEBASE_H
|