yc_dyrscarr.h

一个类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.
 */

/******************************************************************************/
/******************************************************************************/
#ifndef __MACRO_C_YOUNG_LIBRARY_DYNAMIC_RESOURCE_ARRAY_HEADER_FILE__
#define __MACRO_C_YOUNG_LIBRARY_DYNAMIC_RESOURCE_ARRAY_HEADER_FILE__
/******************************************************************************/
#include "yc_definition.h"

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

typedef  struct dynamic_resource_array_object
{
    void*              m_start;
    void*              m_finish;
    void*              m_utmost;
    size_t             m_element_size;
    ylib_fp_oper_t     m_elmt_init;        /* safe function */
    ylib_fp_copy_t     m_elmt_init_copy;   /* safe function */
    ylib_fp_copy_t     m_elmt_assign_copy; /* safe function */
    ylib_fp_move_t     m_elmt_init_move;   /* safe function */
    ylib_fp_move_t     m_elmt_assign_move; /* safe function */
    ylib_fp_oper_t     m_elmt_destroy;     /* safe function */
    ylib_fp_alloc_t    m_alloc;            /* safe function */
    ylib_fp_dealloc_t  m_dealloc;          /* safe function */
}  dyrscarray;

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

#define DYRSCARR_BEGIN( ARRAY, TYPE )  ( (TYPE*)((ARRAY).m_start) )

#define DYRSCARR_END( ARRAY, TYPE )    ( (TYPE*)((ARRAY).m_finish) )

#define DYRSCARR_FRONT( ARRAY, TYPE )  ( *((TYPE*)((ARRAY).m_start)) )

#define DYRSCARR_BACK( ARRAY, TYPE )   ( *((TYPE*)((ARRAY).m_finish) - 1) )

#define DYRSCARR_INDEX( ARRAY, INDEX, TYPE ) \
        ( ((TYPE*)((ARRAY).m_start))[INDEX] )

#define DYRSCARR_SIZE( ARRAY, TYPE ) \
        ( ((TYPE*)((ARRAY).m_finish)) - ((TYPE*)((ARRAY).m_start)) )

#define DYRSCARR_CAPACITY( ARRAY, TYPE ) \
        ( ((TYPE*)((ARRAY).m_utmost)) - ((TYPE*)((ARRAY).m_start)) )

#define DYRSCARR_SPACE( ARRAY, TYPE ) \
        ( ((TYPE*)((ARRAY).m_utmost)) - ((TYPE*)((ARRAY).m_finish)) )

#define DYRSCARR_POP_BACK_MEM( ARRAY, TYPE )     \
        if( (ARRAY).m_finish > (ARRAY).m_start ) \
            (ARRAY).m_finish = (TYPE*)((ARRAY).m_finish) - 1

#define DYRSCARR_POP_BACK_FUN( ARRAY, TYPE )                  \
        if( (ARRAY).m_finish > (ARRAY).m_start ) {            \
            (ARRAY).m_finish = (TYPE*)((ARRAY).m_finish) - 1; \
            (ARRAY).m_elmt_destroy( (ARRAY).m_finish ); }

#define DYRSCARR_PUSH_BACK_MEM( ARRAY, VAL, TYPE, BOOLVAL )                \
        if( (TYPE*)((ARRAY).m_finish) + 1 <= (TYPE*)((ARRAY).m_utmost) ) { \
            *( (TYPE*)((ARRAY).m_finish) ) = (VAL);                        \
            (ARRAY).m_finish = (TYPE*)((ARRAY).m_finish) + 1;              \
            (BOOLVAL) = true; }                                            \
        else                                                               \
            (BOOLVAL) = dyrscarr_insert_value( &(ARRAY),                   \
            (TYPE*)((ARRAY).m_finish) - (TYPE*)((ARRAY).m_start), &(VAL), 1 )

#define DYRSCARR_PUSH_BACK_FUN( ARRAY, VAL, TYPE, BOOLVAL )                \
        if( (TYPE*)((ARRAY).m_finish) + 1 <= (TYPE*)((ARRAY).m_utmost) ) { \
            (ARRAY).m_elmt_init_copy( (ARRAY).m_finish, &(VAL) );          \
            (ARRAY).m_finish = (TYPE*)((ARRAY).m_finish) + 1;              \
            (BOOLVAL) = true; }                                            \
        else                                                               \
            (BOOLVAL) = dyrscarr_insert_value( &(ARRAY),                   \
            (TYPE*)((ARRAY).m_finish) - (TYPE*)((ARRAY).m_start), &(VAL), 1 )

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

void dyrscarr_init( dyrscarray* uninit_self,
                    size_t element_size,
                    ylib_fp_oper_t elmt_init,
                    ylib_fp_copy_t elmt_init_copy,
                    ylib_fp_copy_t elmt_assign_copy,
                    ylib_fp_move_t elmt_init_move,
                    ylib_fp_move_t elmt_assign_move,
                    ylib_fp_oper_t elmt_destroy,
                    ylib_fp_alloc_t alloc,
                    ylib_fp_dealloc_t dealloc );

void dyrscarr_reinit( dyrscarray* self,
                      size_t element_size,
                      ylib_fp_oper_t elmt_init,
                      ylib_fp_copy_t elmt_init_copy,
                      ylib_fp_copy_t elmt_assign_copy,
                      ylib_fp_move_t elmt_init_move,
                      ylib_fp_move_t elmt_assign_move,
                      ylib_fp_oper_t elmt_destroy );

void dyrscarr_destroy( dyrscarray* self );

/* (1) < 0: uninit_self = src;  (2) = 0: fail;  (3) > 0: succeed */
int dyrscarr_init_copy( dyrscarray* uninit_self,
                        const dyrscarray* src );

/* (1) < 0: self = src or can't matching;  (2) = 0: fail;  (3) > 0: succeed */
int dyrscarr_assign_copy( dyrscarray* self,
                          const dyrscarray* src );

void dyrscarr_init_move( dyrscarray* uninit_self,
                         dyrscarray* src );

void dyrscarr_assign_move( dyrscarray* self,
                           dyrscarray* src );

void dyrscarr_destroy_adapter( void* self );

int dyrscarr_init_copy_adapter( void* uninit_self,
                                const void* src );

int dyrscarr_assign_copy_adapter( void* self,
                                  const void* src );

void dyrscarr_init_move_adapter( void* uninit_self,
                                 void* src );

void dyrscarr_assign_move_adapter( void* self,
                                   void* src );

/* reserves new_capacity minimum length of storage for a dyrscarray object,
 * if succeeded returns true, otherwise returns false */
bool dyrscarr_reserve( dyrscarray* self,
                       size_t new_capacity );

void dyrscarr_reverse( dyrscarray* self );

/* removes the element of the dyrscarray */
void dyrscarr_erase_pos( dyrscarray* self,
                         size_t index );

/* removes the elements of the dyrscarray in the range [first_index, last_index) */
void dyrscarr_erase_range( dyrscarray* self,
                           size_t first_index,
                           size_t last_index );

/* inserts a repetition of count elements of value before index,
 * if succeeded returns true, otherwise returns false */
bool dyrscarr_insert_value( dyrscarray* self,
                            size_t index,
                            const void* value,
                            size_t count );

/* inserts count elements of src before index, if succeeded returns true,
 * otherwise returns false */
bool dyrscarr_insert_array( dyrscarray* self,
                            size_t index,
                            const void* src,
                            size_t count );

/* replaces a repetition of new_count elements of value from index,
 * if succeeded returns true, otherwise returns false */
bool dyrscarr_replace_fill( dyrscarray* self,
                            size_t index,
                            size_t old_count,
                            const void* value,
                            size_t new_count );

/* replaces new_count elements of src from index, if succeeded returns true,
 * otherwise returns false */
bool dyrscarr_replace_array( dyrscarray* self,
                             size_t index,
                             size_t old_count,
                             const void* src,
                             size_t new_count );

/* inserts a copy of value to the end of self, if succeeded returns true,
 * otherwise returns false */
bool dyrscarr_push_back( dyrscarray* self,
                         const void* value );

/* alters the size of self; if the new_length is greater than the current size,
 * then new_length - dyrscarr_size() instances of the default value are
 * inserted at the end of the dyrscarray; if the new size is smaller than the
 * current capacity, then the dyrscarray is truncated by erasing
 * dyrscarr_size() - new_length elements off the end; if new_length is equal
 * to dyrscarr_size() then no action is taken.
 * If succeeded returns true, otherwise returns false */
bool dyrscarr_resize( dyrscarray* self,
                      size_t new_length,
                      const void* value );

#ifndef __MACRO_C_YOUNG_LIBRARY_COMPILER_SUPPORT_INLINE_FUNCTION__
    bool dyrscarr_empty( dyrscarray* self );

    size_t dyrscarr_max_size( dyrscarray* self );

    size_t dyrscarr_size( dyrscarray* self );

    size_t dyrscarr_capacity( dyrscarray* self );

    size_t dyrscarr_space( dyrscarray* self );

    void* dyrscarr_begin( dyrscarray* self );

    void* dyrscarr_end( dyrscarray* self );

    void* dyrscarr_front( dyrscarray* self );

    void* dyrscarr_back( dyrscarray* self );

    void* dyrscarr_index( dyrscarray* self,
                          size_t index );

    /* if index < dyrscarr_size() returns dyrscarr_index(),
     * otherwise returns NULL */
    void* dyrscarr_at( dyrscarray* self,
                       size_t index );

    void dyrscarr_pop_back( dyrscarray* self );
#else
    inline bool dyrscarr_empty( dyrscarray* self )
    {
        return self->m_start == self->m_finish ? true : false;
    }

    inline size_t dyrscarr_max_size( dyrscarray* self )
    {
        return SIZE_MAX / self->m_element_size;
    }

    inline size_t dyrscarr_size( dyrscarray* self )
    {
        return ((ylib_byte_t*)(self->m_finish) - (ylib_byte_t*)(self->m_start))
               / self->m_element_size;
    }

    inline size_t dyrscarr_capacity( dyrscarray* self )
    {
        return ((ylib_byte_t*)(self->m_utmost) - (ylib_byte_t*)(self->m_start))
               / self->m_element_size;
    }

    inline size_t dyrscarr_space( dyrscarray* self )
    {
        return ((ylib_byte_t*)(self->m_utmost) - (ylib_byte_t*)(self->m_finish))
               / self->m_element_size;
    }

    inline void* dyrscarr_begin( dyrscarray* self )
    {
        return self->m_start;
    }

    inline void* dyrscarr_end( dyrscarray* self )
    {
        return self->m_finish;
    }

    inline void* dyrscarr_front( dyrscarray* self )
    {
        return self->m_start;
    }

    inline void* dyrscarr_back( dyrscarray* self )
    {
        return (ylib_byte_t*)(self->m_finish) - self->m_element_size;
    }

    inline void* dyrscarr_index( dyrscarray* self, size_t index )
    {
        return (ylib_byte_t*)(self->m_start) + index * self->m_element_size;
    }

    inline void* dyrscarr_at( dyrscarray* self, size_t index )
    {
        void* pos = (ylib_byte_t*)(self->m_start)
                    + index * self->m_element_size;
        return pos < self->m_finish ? pos : NULL;
    }

    inline void dyrscarr_pop_back( dyrscarray* self )
    {
        if( self->m_finish > self->m_start )
        {
            self->m_finish = (ylib_byte_t*)(self->m_finish)
                             - self->m_element_size;
            if( self->m_elmt_destroy )
                self->m_elmt_destroy( self->m_finish );
        }
    }
#endif

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