RuleLeafValueComparison.h

// RuleLeafValueComparison.h:
// --------------------------
//

#ifndef __IPSDKBASEPROCESSING_RULELEAFVALUECOMPARISON_H__
#define __IPSDKBASEPROCESSING_RULELEAFVALUECOMPARISON_H__

#include <IPSDKBaseProcessing/Rule/Attribute/DataItem/Leaf/LeafValueComparison/BaseTLeafValueComparisonRule.h>
#include <IPSDKUtil/Tools/EnumMacros.h>

namespace ipsdk {
namespace processor {


template <typename AttributeType,
          typename LeafType,
          eValueComparisonRuleType::domain ValueComparisonRuleType,
          typename Enable=void>
class RuleLeafValueComparison;


template <typename AttributeType,
          typename LeafType,
          eValueComparisonRuleType::domain ValueComparisonRuleType>
class RuleLeafValueComparison<AttributeType, LeafType, ValueComparisonRuleType,
                              typename boost::disable_if<typename boost::is_base_of<boost::detail::enum_base<typename LeafType::ValueType>, typename LeafType::ValueType>::type>::type> :
                              public BaseTLeafValueComparisonRule<typename LeafType::ValueType,
                                                                  ValueComparisonRuleType>
{
// predefined public types
public:
    typedef typename boost::enable_if<typename boost::is_same<boost::mpl::int_<AttributeType::g_attributeType>,
                                                              boost::mpl::int_<eAttributeType::eAT_DataItem> >::type,
                                      typename AttributeType::ValueType>::type DataItemType;

    typedef typename boost::enable_if<typename boost::is_same<boost::mpl::int_<LeafType::g_itemType>,
                                                              boost::mpl::int_<eDataItemType::eDIT_Leaf> >::type,
                                      typename LeafType::ValueType>::type ValueType;

public:
    RuleLeafValueComparison() {}
    ~RuleLeafValueComparison() {}

// methods
public:
    void                init(const boost::weak_ptr<const AttributeType>& pAttribute,
                             const ValueType& value);

protected:
    std::string         getAttributeName() const;

    ValueType           getAttributeValue() const;

// attributes
protected:

};


template <typename AttributeType, typename LeafType, eValueComparisonRuleType::domain ValueComparisonRuleType>
inline void
RuleLeafValueComparison<AttributeType, LeafType, ValueComparisonRuleType,
                        typename boost::disable_if<typename boost::is_base_of<boost::detail::enum_base<typename LeafType::ValueType>, typename LeafType::ValueType>::type>::type>::
    init(const boost::weak_ptr<const AttributeType>& pAttribute,
         const ValueType& value)
{
    // call of base class initialization method
    BaseTLeafValueComparisonRule<ValueType, ValueComparisonRuleType>::initBase(pAttribute, value);
}

template <typename AttributeType, typename LeafType, eValueComparisonRuleType::domain ValueComparisonRuleType>
inline std::string
RuleLeafValueComparison<AttributeType, LeafType, ValueComparisonRuleType,
                        typename boost::disable_if<typename boost::is_base_of<boost::detail::enum_base<typename LeafType::ValueType>, typename LeafType::ValueType>::type>::type>::
    getAttributeName() const
{
    return AttributeType::getObjectNameStr() + "::" +
           DataItemType::template getNodeNameStr<LeafType>();
}

template <typename AttributeType, typename LeafType, eValueComparisonRuleType::domain ValueComparisonRuleType>
inline typename RuleLeafValueComparison<AttributeType, LeafType, ValueComparisonRuleType,
                                        typename boost::disable_if<typename boost::is_base_of<boost::detail::enum_base<typename LeafType::ValueType>, typename LeafType::ValueType>::type>::type>::ValueType
RuleLeafValueComparison<AttributeType, LeafType, ValueComparisonRuleType,
                        typename boost::disable_if<typename boost::is_base_of<boost::detail::enum_base<typename LeafType::ValueType>, typename LeafType::ValueType>::type>::type>::
    getAttributeValue() const
{
    // retrieve associated attribute
    const AttributeType& derivedAttribute = static_cast<const AttributeType&>(this->getAttribute1());

    return derivedAttribute.getNode().template getValue<LeafType>();
}


template <typename AttributeType,
          typename LeafType,
          eValueComparisonRuleType::domain ValueComparisonRuleType>
class RuleLeafValueComparison<AttributeType, LeafType, ValueComparisonRuleType,
                              typename boost::enable_if<typename boost::is_base_of<boost::detail::enum_base<typename LeafType::ValueType>, typename LeafType::ValueType>::type>::type> :
                              public BaseTLeafValueComparisonRule<ipInt32,
                                                                  ValueComparisonRuleType>
{
// predefined public types
public:
    typedef typename boost::enable_if<typename boost::is_same<boost::mpl::int_<AttributeType::g_attributeType>,
                                                              boost::mpl::int_<eAttributeType::eAT_DataItem> >::type,
                                      typename AttributeType::ValueType>::type DataItemType;

    typedef typename boost::enable_if<typename boost::is_same<boost::mpl::int_<LeafType::g_itemType>,
                                                              boost::mpl::int_<eDataItemType::eDIT_Leaf> >::type,
                                      typename LeafType::ValueType>::type ValueType;

    typedef ipInt32 BaseValueType;

public:
    RuleLeafValueComparison() {}
    ~RuleLeafValueComparison() {}

// methods
public:
    void                init(const boost::weak_ptr<const AttributeType>& pAttribute,
                             const ValueType& value);

protected:
    std::string             getAttributeName() const;

    BaseValueType           getAttributeValue() const;

// attributes
protected:

};


template <typename AttributeType, typename LeafType, eValueComparisonRuleType::domain ValueComparisonRuleType>
inline void
RuleLeafValueComparison<AttributeType, LeafType, ValueComparisonRuleType,
                        typename boost::enable_if<typename boost::is_base_of<boost::detail::enum_base<typename LeafType::ValueType>, typename LeafType::ValueType>::type>::type>::
    init(const boost::weak_ptr<const AttributeType>& pAttribute,
                               const ValueType& value)
{
    // call of base class initialization method
    BaseTLeafValueComparisonRule<BaseValueType, ValueComparisonRuleType>::initBase(pAttribute, value.value());
}

template <typename AttributeType, typename LeafType, eValueComparisonRuleType::domain ValueComparisonRuleType>
inline std::string
RuleLeafValueComparison<AttributeType, LeafType, ValueComparisonRuleType,
                        typename boost::enable_if<typename boost::is_base_of<boost::detail::enum_base<typename LeafType::ValueType>, typename LeafType::ValueType>::type>::type>::
    getAttributeName() const
{
    return AttributeType::getObjectNameStr() + "::" +
           DataItemType::template getNodeNameStr<LeafType>();
}

template <typename AttributeType, typename LeafType, eValueComparisonRuleType::domain ValueComparisonRuleType>
inline typename RuleLeafValueComparison<AttributeType, LeafType, ValueComparisonRuleType,
                                        typename boost::enable_if<typename boost::is_base_of<boost::detail::enum_base<typename LeafType::ValueType>, typename LeafType::ValueType>::type>::type>::BaseValueType
RuleLeafValueComparison<AttributeType, LeafType, ValueComparisonRuleType, typename boost::enable_if<typename boost::is_base_of<boost::detail::enum_base<typename LeafType::ValueType>, typename LeafType::ValueType>::type>::type>::
    getAttributeValue() const
{
    // retrieve associated attribute
    const AttributeType& derivedAttribute = static_cast<const AttributeType&>(this->getAttribute1());

    return derivedAttribute.getNode().template getValue<LeafType>().value();
}


} // end of namespace processor
} // end of namespace ipsdk

#endif // __IPSDKBASEPROCESSING_RULELEAFVALUECOMPARISON_H__