9) 泛型数学运算符函数mathOperator [原创,泛型编程,自由下载转载，需注明出处]

下面是一些算术操作符，其通常作为一些接口的比较参数传入。泛型的。

#ifndef mathOperator_h__

#define mathOperator_h__

#include "typeConvert.h"

#include "mplmacro.h"

/********************************************************************

Description : general math operator .

Author : Shen.Xiaolong (Shen Tony) (2010-2013)

Mail : xlshen2002@hotmail.com,  xlshen@126.com

verified platform : VS2008

copyright:          : latest Version of The Code Project Open License (CPOL : http://www.codeproject.com/).
*********************************************************************/

namespace MiniMPL

{

/////////////////////////////////////////////////////////////////////////////////////////////////////////
template <typename LeftT,typename RightT>

    bool equal(LeftT p1,RightT p2)
{
return p1==p2;
}

template <typename LeftT,typename RightT>
bool lesser(LeftT p1,RightT p2)
{
return p1 < p2;
}

    template<typename BinaryFunction_T,typename LeftT = typename BinaryFunction_T::TP1,typename RightT = typename BinaryFunction_T::TP2>
class NotBinary 
{
public:
NotBinary(BinaryFunction_T& pCmp) : m_cmp(pCmp){};
bool operator()(LeftT & p1,RightT & p2)
{
return !m_cmp(p1,p2);
}

protected:
BinaryFunction_T&   m_cmp;
};

    template<typename UnaryFunction_T,typename TP=typename UnaryFunction_T::Param_T>

    class NotUnary 

    {

    public:

        NotUnary(UnaryFunction_T& f) : m_f(f){};

        bool operator()(TP & p)

        {

            return !m_f(p);

        }

    protected:

        UnaryFunction_T&       m_f;

    };

template <typename LeftT,typename RightT>
bool notEqual(LeftT p1,RightT p2 )
{
return !equal<LeftT,RightT>(p1,p2);
}

template <typename LeftT,typename RightT>
bool lesserEqual(LeftT p1,RightT p2 )
{
return lesser<LeftT,RightT>(p1,p2) || equal<LeftT,RightT>(p1,p2);
}

template <typename LeftT,typename RightT>
bool greater(LeftT p1,RightT p2 )
{
return lesser<RightT,LeftT>(p2,p1);
}

template <typename LeftT,typename RightT>
bool greaterEqual(LeftT p1,RightT p2 )
{
return greater<LeftT,RightT>(p1,p2) || equal<LeftT,RightT>(p1,p2);
}

/////////////////////////////////////////////////////////////////////////////////////////////////////////
template<typename DataType>

    void swap(DataType& left,DataType& right,SFINAE(logic::Not_T<IsStlContainer<DataType> >::value))
{  

        if (&left == &right) return;  //same element

DataType tmp = left;
left = right;
right = tmp;
}

    template<typename DataType>

    void swap(DataType& left,DataType& right,SFINAE(IsStlContainer<DataType>::value))

    {  

        if (&left == &right) return;  //same element

        left.swap(right);

    }

    template<typename DataType,unsigned int LEN>

    void swap(DataType(&left)[LEN],DataType(&right)[LEN] )

    {  

        if (&left == &right) return;  //same element

        for (unsigned int i=0;i<LEN;i++)

        {

            swap(left[i],right[i]);

        }

    }

template<typename DataType,typename Comparer_T>
bool swapIf(DataType& left,DataType& right,Comparer_T& cmp)
{
if (cmp(left,right))
{
swap(left,right);
return true;
} 
return false;
}

template<typename DataType,typename Comparer_T>
bool swapNotIf(DataType& left,DataType& right,Comparer_T& cmp)
{
if (!cmp(left,right))
{
swap(left,right);
return true;
}
return false;
}

}

#endif // mathOperator_h__