#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