14) 常用的遍历/(条件)查找/收集数据/(拷贝2比较优先)排序算法algorithm [原创,泛型编程,自由下载转载，需注明出处]

下面的一套算法，配合前面提供的泛型库的支持部件，能够提供下列基于概念的功能：

1.遍历处理

3.查找

5.收集　：　收集的结果可以是任何形式的：数组/容器，T/T*，并且调用接口是完全相同的(减轻用户负担)，代码内部会自动进行类型识别。

7.排序

7.1)  用户可以指定执行方式是比较优先/拷贝优先/缺省自动  

7.2) 按参照顺序排序　：即不是按从大到小，也不是按从小到大，而是按用户指定的参考顺序。比如有一个结构数据流是无顺序的，经过一个处理后，其按照结构中某个成员的大小进行了排序。但是在下一步处理中，用户要求查看原序－－没有排序过的原始数据。这时就可以使用算法提供的按参照排序：先记录原始数据流的每个unique值到一个数组/容器中，在按参考排序时传入这个参数数据。

除了排序外，其它的6种功能基于概念，都会经过一个关键路径throughoutImpl：基于finder的throughoutImpl和基于遍历的throughoutImpl. (finder找到后会返回，而遍历的会处理所有数据)。

并且每个基于概念的功能都提供一个实现体入口XXXImpl (类似于MS的原始API)，如果库提供封装的接口(类似于MS的MFC封装)不能满足用户的需求，用户可以直接调用XXXImpl接口并且传入用户按需求组装的参数--这些参数通常使用使用functionobject中提供的接口来生成。

代码：

#ifndef globalFunc_h__
#define globalFunc_h__
#include "mplconfig.h"
#include "mplMacro.h"
#include "typeTraits.h"
#include "functionObject.h"
#include "dataSet.h"
#include "functionTraits.h"
/********************************************************************
Description : provide algorithm for no STL algorithm supported library .
                      features : Finder and Non-Finder. 
                      Finer is depended on Tester function object
                      Non_Finder is depended on UnaryFunction function object.
                      All function object can be got in "functionobject.h"                      
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/)
*********************************************************************/


declartion//
namespace MiniMPL
{
Implement//
    template<typename T,typename S=typename T::Param_T> struct IsFinder : public IsSerialClass<Finder<S>,T> {};
    
    template<typename iteratorT,typename Finder_T>
Finder_T& throughoutImpl(iteratorT pHead,iteratorT pGuard,Finder_T& rFinder,SFINAE((IsFinder<Finder_T>::value)))
{
for (;pHead != pGuard;pHead++)
{
if(rFinder(*pHead))
{
return rFinder;
}
}
return rFinder;
}


template<typename iteratorT,typename Processer_T>
    Processer_T& throughoutImpl(iteratorT pHead,iteratorT pGuard,Processer_T& rProcesser,SFINAE((!IsFinder<Processer_T>::value)))
{
for (;pHead != pGuard;pHead++)
{
rProcesser(*pHead);
}
return rProcesser;
}


template< typename C , typename HandlerType>
HandlerType& throughout(DataSet<C>& arr,HandlerType& rHandler)
{
return throughoutImpl(arr.head(),arr.end(),rHandler);
}


//      [Processor]call specified function to process every object     ///
    template<typename C,typename UnaryFunction_T>
typename DataSet<C>::size_type forEach(DataSet<C>& rDataSet,UnaryFunction_T& rProcesser)
{
throughout(rDataSet,rProcesser);
return rDataSet.size();
}


    ///search function///
template<typename C,typename Tester_T>
SC(ET(C)*,C) find(DataSet<C>& arr,Tester_T& tester)
  {
Static_Assert((IsSameRawType<ET(C),typename Tester_T::Param_T>::value==true));
        return removeConst(throughout(arr,makeFinder(tester)).getLastMatchedData());
}


    ///min/max function///
template<typename C,typename Comparer_T>
SC(ET(C)*,C) findMaxminElement(DataSet<C>& arr,MaxMinFinder<Comparer_T>& finder)
{
return throughout(arr,finder).getResult();
}


/collect function///
template<typename C,typename Tester_T,typename ResultCollector_T>
unsigned int collect(DataSet<C>& rDataSet,Collector<Tester_T,ResultCollector_T>& rCollector)
{
return throughout(rDataSet,rCollector).size();
}


/sort function///
//this algorithm more compare and less copy,   it is suitable for big object instance
    template<typename PointerType,typename Comparer_T>
    bool sortImplPriorCmp(PointerType pHead, PointerType pTail,Comparer_T& cmp)
    {  
        if (pHead == pTail)
        {
            return true;
        }


        PointerType pNewHead = pHead;
        pNewHead++;
PointerType pGuard = pTail;
pGuard++;
swapIf(*pHead,*throughoutImpl(pNewHead,pGuard,MaxMinFinder<VT(PointerType)>(NotComparor<VT(PointerType)>(cmp))).getResult(),cmp);
        return sortImplPriorCmp(++pHead,pTail,cmp);
    } ;


//this algorithm less compare and more copy,  it is suitable for small object instance
    template<typename PointerType,typename Comparer_T>
    bool sortImplPriorCopy(PointerType head, PointerType tail,Comparer_T& cmp)
    {
        if (head == tail)
        {
            return true;
        }


        PointerType pNewHead = head;
        pNewHead++;


        if (pNewHead == tail)
        {
            swapIf(*head,*pNewHead,cmp);
            return true;
        }


        sortImplPriorCopy(pNewHead,tail,cmp);


        if (cmp(*head,*pNewHead))
        {
            GetValueType<PointerType>::type TmpObj(*head);


            if (cmp(*head,*tail))
            { //case : *pNewHead < *tail < *head
                while(head != tail) 
                {
                    *head++ = *pNewHead++ ;
                };
                *head = TmpObj;
            }
            else
            { //case : *pNewHead < *head < *pTail  
                *head++ = *pNewHead++;
                while(cmp(TmpObj,*pNewHead)) 
                {
                    *head++ = *pNewHead++;
                };
                *head = TmpObj ;
            }
        }


        return true;
    }


 ///


template<typename C,typename Compare_T>
bool sortImpl(DataSet<C>& arr,Compare_T& rCmp,bool bCmpPrior)
{
return bCmpPrior ? sortImplPriorCmp(arr.head(),arr.tail(),rCmp) : sortImplPriorCopy(arr.head(),arr.tail(),rCmp); 
}


    template<typename C1,typename M1,typename C2,typename M2>
    bool sortByRefOrder(DataSet<C1>& rArr,MemberPtr<ET(C1),M1>& rMemberPtr1,DataSet<C2>& rArrRef,MemberPtr<ET(C2),M2>& rMemberPtr2)
    {
        typedef ET(C1)                            Struct_T1;
        typedef typename  DataSet<C1>::size_type    SizeType;


        Assertb(rArrRef.size() == rArr.size());
        SizeType iSize = rArr.size();
        for (SizeType i=0;i<iSize;i++)
        {
            Struct_T1* ptr = find(rArr,makeTester(rMemberPtr2(rArrRef[i]),rMemberPtr1,equal<M1,M2>));
            Assertb(NULL != ptr);
            MiniMPL::swap(rArr[i],*ptr);
        }


        return true;
    }
}


#endif // globalFunc_h__