yc_rscalgo.c

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

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

 * 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.
 */

/******************************************************************************/
/******************************************************************************/
#include "yc_memalgo.h"
#include "yc_rscalgo.h"

#ifdef __cplusplus
    namespace youngc {  extern "C" {
#endif
/******************************************************************************/
/******************************************************************************/

void* rsccopy( void* dst,
               const void* src,
               size_t count,
               size_t dst_element_size,
               size_t src_element_size,
               ylib_fp_copy_t copy_value )
{
    ylib_byte_t* d = (ylib_byte_t*)dst;

    if( !copy_value )
    {
        if( dst_element_size == src_element_size )
            return ylib_memcopy( dst, src, count * src_element_size );
    }
    else
    {
        const ylib_byte_t* s = (const ylib_byte_t*)src;

        for( ; count > 0; --count )
        {
            copy_value( d, s );
            d += dst_element_size;
            s += src_element_size;
        }
    }

    return d;
}

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

void* rscmove( void* dst,
               void* src,
               size_t count,
               size_t dst_element_size,
               size_t src_element_size,
               ylib_fp_move_t move_value )
{
    ylib_byte_t* d = (ylib_byte_t*)dst;

    if( !move_value )
    {
        if( dst_element_size == src_element_size )
            return ylib_memcopy( dst, src, count * src_element_size );
    }
    else
    {
        ylib_byte_t* s = (ylib_byte_t*)src;

        for( ; count > 0; --count )
        {
            move_value( d, s );
            d += dst_element_size;
            s += src_element_size;
        }
    }

    return d;
}

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

void* rscfill( void* dst,
               const void* value,
               size_t count,
               size_t element_size,
               ylib_fp_copy_t copy_value )
{
    if( !copy_value )
        return memfill( dst, value, count, element_size );
    else
    {
        ylib_byte_t* d = (ylib_byte_t*)dst;

        for( ; count > 0; --count )
        {
            copy_value( d, value );
            d += element_size;
        }

        return d;
    }
}

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

void* rrsccopy( void* dst_last,
                const void* src_last,
                size_t count,
                size_t dst_element_size,
                size_t src_element_size,
                ylib_fp_copy_t copy_value )
{
    ylib_byte_t* d_last = (ylib_byte_t*)dst_last;

    if( !copy_value )
    {
        if( dst_element_size == src_element_size )
        {
            size_t count_size = count * src_element_size;
            return ylib_memmove( d_last - count_size,
                                 (ylib_byte_t*)src_last - count_size,
                                 count_size );
        }
    }
    else
    {
        const ylib_byte_t* s_last = (const ylib_byte_t*)src_last;

        for( ; count > 0; --count )
        {
            d_last -= dst_element_size;
            s_last -= src_element_size;
            copy_value( d_last, s_last );
        }
    }

    return d_last;
}

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

void* rrscmove( void* dst_last,
                void* src_last,
                size_t count,
                size_t dst_element_size,
                size_t src_element_size,
                ylib_fp_move_t move_value )
{
    ylib_byte_t* d_last = (ylib_byte_t*)dst_last;

    if( !move_value )
    {
        if( dst_element_size == src_element_size )
        {
            size_t count_size = count * src_element_size;
            return ylib_memmove( d_last - count_size,
                                 (ylib_byte_t*)src_last - count_size,
                                 count_size );
        }
    }
    else
    {
        ylib_byte_t* s_last = (ylib_byte_t*)src_last;

        for( ; count > 0; --count )
        {
            d_last -= dst_element_size;
            s_last -= src_element_size;
            move_value( d_last, s_last );
        }
    }

    return d_last;
}

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

void foreach( void* first,
              size_t count,
              size_t element_size,
              ylib_fp_oper_t oper )
{
    ylib_byte_t* begin = (ylib_byte_t*)first;

    for( ; count > 0; --count )
    {
        oper( begin );
        begin += element_size;
    }
}

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

void rforeach( void* last,
               size_t count,
               size_t element_size,
               ylib_fp_oper_t oper )
{
    ylib_byte_t* end = (ylib_byte_t*)last;

    for( ; count > 0; --count )
    {
        end -= element_size;
        oper( end );
    }
}

/******************************************************************************/
/******************************************************************************/
#ifdef __cplusplus
    }  }
#endif
/******************************************************************************/
/******************************************************************************/