mstl_algorithm_compare.hpp

一个类STL的多平台可移植的算法容器库,主要用于嵌入式系统编程时的内存管理等方面

                InputIterator2 first2, InputIterator2 last2,
                StrictWeakOrdering comp,
                random_access_iterator_tag, random_access_iterator_tag )
{
    typedef  typename iterator_traits<InputIterator1>::difference_type  diff_t1;
    typedef  typename iterator_traits<InputIterator2>::difference_type  diff_t2;

    diff_t1 len1 = last1 - first1;
    diff_t2 len2 = last2 - first2;
    def_ptrdiff_t len = len1 < len2 ? len1 : len2;

    for( ; len > 0; --len,++first1,++first2 )
    {
    	if( comp(*first1, *first2) )
    	    return true;
    	if( comp(*first2, *first1) )
    	    return false;
    }
    return ( len1 < len2 );
}



inline bool lexicographical_compare( const char* first1, const char* last1,
                                     const char* first2, const char* last2 )
{
    size_t len1 = last1 - first1;
    size_t len2 = last2 - first2;
    size_t len = len1 < len2 ? len1 : len2;
    int result = memcmp( first1, first2, len );
    return ( result != 0 ? result < 0 : len1 < len2 );
}

inline bool lexicographical_compare( const unsigned char* first1,
                                     const unsigned char* last1,
                                     const unsigned char* first2,
                                     const unsigned char* last2 )
{
    size_t len1 = last1 - first1;
    size_t len2 = last2 - first2;
    size_t len = len1 < len2 ? len1 : len2;
    int result = memcmp( first1, first2, len );
    return ( result != 0 ? result < 0 : len1 < len2 );
}

inline bool lexicographical_compare( const wchar_t* first1,
                                     const wchar_t* last1,
                                     const wchar_t* first2,
                                     const wchar_t* last2 )
{
    size_t len1 = last1 - first1;
    size_t len2 = last2 - first2;
    size_t len = len1 < len2 ? len1 : len2;
    int result = wmemcmp( first1, first2, len );
    return ( result != 0 ? result < 0 : len1 < len2 );
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

template< typename InputIterator1, typename InputIterator2 >
pair<InputIterator1, InputIterator2> mismatch( InputIterator1 first1,
                                               InputIterator1 last1,
                                               InputIterator2 first2 )
{
    while( first1 != last1 && *first1 == *first2 )
    {
        ++first1;
        ++first2;
    }
    return pair<InputIterator1, InputIterator2>( first1, first2 );
}



template< typename InputIterator1, typename InputIterator2,
          typename BinaryPredicate >
pair<InputIterator1, InputIterator2> mismatch( InputIterator1 first1,
                                               InputIterator1 last1,
                                               InputIterator2 first2,
                                               BinaryPredicate bin_pred )
{
    while( first1 != last1 && bin_pred(*first1, *first2) )
    {
        ++first1;
        ++first2;
    }
    return pair<InputIterator1, InputIterator2>( first1, first2 );
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

template< typename InputIterator1, typename InputIterator2 >
inline bool matching( InputIterator1 first1, InputIterator1 last1,
                      InputIterator2 first2, InputIterator2 last2 )
{
    typedef  typename iterator_traits<InputIterator1>::iterator_category  cate1;
    typedef  typename iterator_traits<InputIterator2>::iterator_category  cate2;
    return matching_aux( first1, last1, first2, last2, cate1(), cate2() );
}

template< typename InputIterator1, typename InputIterator2 >
bool matching_aux( InputIterator1 first1, InputIterator1 last1,
                   InputIterator2 first2, InputIterator2 last2,
                   input_iterator_tag, input_iterator_tag )
{
    for( ; (first1 != last1) && (first2 != last2); ++first1,++first2 )
    {
        if( !(*first1 == *first2) )
            return false;
    }
    return ( first1 == last1 && first2 == last2 );
}

template< typename InputIterator1, typename InputIterator2 >
bool matching_aux( InputIterator1 first1, InputIterator1 last1,
                   InputIterator2 first2, InputIterator2 last2,
                   random_access_iterator_tag, random_access_iterator_tag )
{
    typedef  typename iterator_traits<InputIterator1>::difference_type  diff_t1;
    typedef  typename iterator_traits<InputIterator2>::difference_type  diff_t2;

    diff_t1 len1 = last1 - first1;
    diff_t2 len2 = last2 - first2;

    if( len1 != len2 )
        return false;

    for( ; len1 > 0; --len1,++first1,++first2 )
    {
        if( !(*first1 == *first2) )
            return false;
    }
    return true;
}



template< typename InputIterator1, typename InputIterator2,
          typename BinaryPredicate >
inline bool matching( InputIterator1 first1, InputIterator1 last1,
                      InputIterator2 first2, InputIterator2 last2,
                      BinaryPredicate bin_pred )
{
    typedef  typename iterator_traits<InputIterator1>::iterator_category  cate1;
    typedef  typename iterator_traits<InputIterator2>::iterator_category  cate2;
    return matching_aux( first1, last1, first2, last2, bin_pred,
                         cate1(), cate2() );
}

template< typename InputIterator1, typename InputIterator2,
          typename BinaryPredicate >
bool matching_aux( InputIterator1 first1, InputIterator1 last1,
                   InputIterator2 first2, InputIterator2 last2,
                   BinaryPredicate bin_pred,
                   input_iterator_tag, input_iterator_tag )
{
    for( ; (first1 != last1) && (first2 != last2); ++first1,++first2 )
    {
        if( !bin_pred(*first1, *first2) )
            return false;
    }
    return ( first1 == last1 && first2 == last2 );
}

template< typename InputIterator1, typename InputIterator2,
          typename BinaryPredicate >
bool matching_aux( InputIterator1 first1, InputIterator1 last1,
                   InputIterator2 first2, InputIterator2 last2,
                   BinaryPredicate bin_pred,
                   random_access_iterator_tag, random_access_iterator_tag )
{
    typedef  typename iterator_traits<InputIterator1>::difference_type  diff_t1;
    typedef  typename iterator_traits<InputIterator2>::difference_type  diff_t2;

    diff_t1 len1 = last1 - first1;
    diff_t2 len2 = last2 - first2;

    if( len1 != len2 )
        return false;

    for( ; len1 > 0; --len1,++first1,++first2 )
    {
        if( !bin_pred(*first1, *first2) )
            return false;
    }
    return true;
}



inline bool matching( const char* first1, const char* last1,
                      const char* first2, const char* last2 )
{
    size_t len1 = last1 - first1;
    size_t len2 = last2 - first2;
    if( len1 != len2 )
        return false;
    return ( memcmp(first1, first2, len1) == 0 );
}

inline bool matching( const unsigned char* first1, const unsigned char* last1,
                      const unsigned char* first2, const unsigned char* last2 )
{
    size_t len1 = last1 - first1;
    size_t len2 = last2 - first2;
    if( len1 != len2 )
        return false;
    return ( memcmp(first1, first2, len1) == 0 );
}

inline bool matching( const wchar_t* first1, const wchar_t* last1,
                      const wchar_t* first2, const wchar_t* last2 )
{
    size_t len1 = last1 - first1;
    size_t len2 = last2 - first2;
    if( len1 != len2 )
        return false;
    return ( wmemcmp(first1, first2, len1) == 0 );
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
__MACRO_CPLUSPLUS_MINI_STL_END_NAMESPACE__
#endif
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------