mstl_algorithm_copy.hpp

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

/*
The young Library
Copyright (c) 2005 by 杨桓

Permission to use, copy, modify, distribute and sell this software for any
purpose is hereby granted without fee, provided that the above copyright
notice appear in all copies and that both that copyright notice and this
permission notice appear in supporting documentation.
The author make no representations about the suitability of this software
for any purpose. It is provided "as is" without express or implied warranty.
*/

/*
 * This file is derived from software bearing the following
 * restrictions:
 *
 * Copyright (c) 1994
 * Hewlett-Packard Company
 *
 * Permission to use, copy, modify, distribute and sell this
 * software and its documentation for any purpose is hereby
 * granted without fee, provided that the above copyright notice
 * appear in all copies and that both that copyright notice and
 * this permission notice appear in supporting documentation.
 * Hewlett-Packard Company makes no representations about the
 * suitability of this software for any purpose. It is provided
 * "as is" without express or implied warranty.
 */

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
#ifndef __MACRO_CPLUSPLUS_MINI_STL_ALGORITHM_COPY_HEADER_FILE__
#define __MACRO_CPLUSPLUS_MINI_STL_ALGORITHM_COPY_HEADER_FILE__
//-----------------------------------------------------------------------------
#include "../mstl_iterator.hpp"
#include "../mstl_type_traits.hpp"
#include "../string/mstl_char_function.hpp"
//-----------------------------------------------------------------------------
__MACRO_CPLUSPLUS_MINI_STL_BEGIN_NAMESPACE__
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

//*****************************************************************************
//*****************************************************************************
//                               复制算法
//
//      copy  copy_n  copy_backward  copy_backward_n  copy_if  copy_range
//*****************************************************************************
//*****************************************************************************

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

template< typename InputIterator, typename Integer, typename OutputIterator >
inline OutputIterator copy_n( InputIterator first, Integer count,
                              OutputIterator result )
{
    return copy_n_aux( first, count, result );
}

template< typename InputIterator, typename Integer, typename OutputIterator >
OutputIterator copy_n_aux( InputIterator first, Integer count,
                           OutputIterator result )
{
    typedef  typename primal_type<Integer>::primal_t  primal_int;

    for( primal_int i = 0; i < count; ++i,++first,++result )
        *result = *first;
    return result;
}



template< typename T1, typename Integer, typename T2 >
inline T2* copy_n( T1* first, Integer count, T2* result )
{
    typedef  double_types_traits<T1, T2>  double_traits;
    typedef  typename double_traits::matching_result  matching;
    typedef  typename double_traits::has_trivial_assignment_operator_t2  assign;

    return ptr_copy_n( first, count, result, matching(), assign() );
}

template< typename T1, typename Integer, typename T2 >
inline T2* ptr_copy_n( T1* first, Integer count, T2* result,
                       same_type, true_type )
{
    memmove( result, first, count * sizeof(T2) );
    return ( result + count );
}

template< typename T1, typename Integer, typename T2 >
inline T2* ptr_copy_n( T1* first, Integer count, T2* result,
                       same_type, false_type )
{
    return copy_n_aux( first, count, result );
}

template< typename T1, typename Integer, typename T2 >
inline T2* ptr_copy_n( T1* first, Integer count, T2* result,
                       different_type, true_type )
{
    return copy_n_aux( first, count, result );
}

template< typename T1, typename Integer, typename T2 >
inline T2* ptr_copy_n( T1* first, Integer count, T2* result,
                       different_type, false_type )
{
    return copy_n_aux( first, count, result );
}

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

template< typename InputIterator, typename OutputIterator >
inline OutputIterator copy( InputIterator first, InputIterator last,
                            OutputIterator result )
{
    typedef  typename iterator_traits<InputIterator>::iterator_category  cate;

    if( first == last )
        return result;
    else
        return copy_aux( first, last, result, cate() );
}

template< typename InputIterator, typename OutputIterator >
OutputIterator copy_aux( InputIterator first, InputIterator last,
                         OutputIterator result, input_iterator_tag )
{
    for( ; first != last; ++first,++result )
        *result = *first;
    return result;
}

template< typename InputIterator, typename OutputIterator >
OutputIterator copy_aux( InputIterator first, InputIterator last,
                         OutputIterator result, random_access_iterator_tag )
{
    typedef  typename iterator_traits<InputIterator>::difference_type  diff_t;

    for( diff_t n = last - first; n > 0; --n,++first,++result )
        *result = *first;
    return result;
}



template< typename T1, typename T2 >
inline T2* copy( T1* first, T1* last, T2* result )
{
    typedef  double_types_traits<T1, T2>  double_traits;
    typedef  typename double_traits::matching_result  matching;
    typedef  typename double_traits::has_trivial_assignment_operator_t2  assign;

    return ptr_copy_n( first, last - first, result, matching(), assign() );
}

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

template< typename BidirectionalIterator1, typename BidirectionalIterator2 >
inline
BidirectionalIterator2 copy_backward( BidirectionalIterator1 first,
                                      BidirectionalIterator1 last,
                                      BidirectionalIterator2 result_last )
{
    typedef  typename iterator_traits<BidirectionalIterator1>::iterator_category
             cate;

    if( first == last )
        return result_last;
    else
        return copy_b_aux( first, last, result_last, cate() );
}

template< typename BidirectionalIterator1, typename BidirectionalIterator2 >
BidirectionalIterator2 copy_b_aux( BidirectionalIterator1 first,
                                   BidirectionalIterator1 last,
                                   BidirectionalIterator2 result_last,
                                   bidirectional_iterator_tag )
{
    while( first != last )
        *(--result_last) = *(--last);
    return result_last;
}

template< typename BidirectionalIterator1, typename BidirectionalIterator2 >
BidirectionalIterator2 copy_b_aux( BidirectionalIterator1 first,
                                   BidirectionalIterator1 last,
                                   BidirectionalIterator2 result_last,
                                   random_access_iterator_tag )
{
    typedef  typename iterator_traits<BidirectionalIterator1>::difference_type
             diff_t1;

    for( diff_t1 n = last - first; n > 0; --n )
        *(--result_last) = *(--last);
    return result_last;
}



template< typename T1, typename T2 >
inline T2* copy_backward( T1* first, T1* last, T2* result_last )
{
    typedef  double_types_traits<T1, T2>  double_traits;
    typedef  typename double_traits::matching_result  matching;
    typedef  typename double_traits::has_trivial_assignment_operator_t2  assign;

    return ptr_copy_n( first, last - first, result_last - (last - first),
                       matching(), assign() );
}

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

template< typename BidirectionalIterator1, typename Integer,
          typename BidirectionalIterator2 >
BidirectionalIterator2 copy_backward_n( BidirectionalIterator1 last,
                                        Integer count,
                                        BidirectionalIterator2 result_last )
{
    typedef  typename primal_type<Integer>::primal_t  primal_int;

    for( primal_int i = 0; i < count; ++i )
        *(--result_last) = *(--last);
    return result_last;
}



template< typename T1, typename Integer, typename T2 >
inline T2* copy_backward_n( T1* last, Integer count, T2* result_last )
{
    typedef  double_types_traits<T1, T2>  double_traits;
    typedef  typename double_traits::matching_result  matching;
    typedef  typename double_traits::has_trivial_assignment_operator_t2  assign;

    return ptr_copy_n( last - count, count, result_last - count,
                       matching(), assign() );
}

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

template< typename InputIterator, typename UnaryPredicate,
          typename OutputIterator >
inline OutputIterator copy_if( InputIterator first, InputIterator last,
                               OutputIterator result, UnaryPredicate pred )
{
    typedef  typename iterator_traits<InputIterator>::iterator_category  cate;

    if( first == last )
        return result;
    else
        return copy_if_aux( first, last, result, cate() );
}

template< typename InputIterator, typename UnaryPredicate,
          typename OutputIterator >
OutputIterator copy_if_aux( InputIterator first, InputIterator last,
                            OutputIterator result, UnaryPredicate pred,
                            input_iterator_tag )
{
    for( ; first != last; ++first )
    {
        if( pred(*first) )
        {
            *result = *first;
            ++result;
        }
    }
    return result;
}

template< typename InputIterator, typename UnaryPredicate,
          typename OutputIterator >
OutputIterator copy_if_aux( InputIterator first, InputIterator last,
                            OutputIterator result, UnaryPredicate pred,
                            random_access_iterator_tag )
{
    typedef  typename iterator_traits<InputIterator>::difference_type  diff_t;

    for( diff_t n = last - first; n > 0; --n,++first )
    {
        if( pred(*first) )
        {
            *result = *first;
            ++result;
        }
    }
    return result;
}

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

template< typename InputIterator, typename OutputIterator >
OutputIterator copy_range( InputIterator first,
                           InputIterator last,
                           OutputIterator result_first,
                           OutputIterator result_last )
{
    while( first != last && result_first != result_last )
    {
        *result_first = *first;
        ++first;
        ++result_first;
    }
    return result_first;
}



template< typename T1, typename T2 >
inline T2* copy_range( T1* first, T1* last,
                       T2* result_first, T2* result_last )
{
    typedef  double_types_traits<T1, T2>  double_traits;
    typedef  typename double_traits::matching_result  matching;
    typedef  typename double_traits::has_trivial_assignment_operator_t2  assign;

    ptrdiff_t len1 = last - first;
    ptrdiff_t len2 = result_last - result_first;
    ptrdiff_t len = len1 < len2 ? len1 : len2;

    return ptr_copy_n( first, len, result_first, matching(), assign() );
}

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