yc_chkarray.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_CHUNK_ARRAY_HEADER_FILE__
#define __MACRO_C_YOUNG_LIBRARY_CHUNK_ARRAY_HEADER_FILE__
/******************************************************************************/
#include "yc_definition.h"

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

typedef  struct chunk_array_iterator
{
    void*   current;
    void*   first;
    void*   last;
    void**  map;
    size_t  element_size;
    size_t  chunk_size;
}  chkarr_iterator;

typedef  struct chunk_array_object
{
    void**             m_chunk_array;
    size_t             m_array_len;
    size_t             m_element_size;
    size_t             m_chunk_size;
    chkarr_iterator    m_start;
    chkarr_iterator    m_finish;
    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 */
}  chkarray;

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

#define CHKARRAY_ITR_EQUAL( LEFT, RIGHT )

#define CHKARRAY_ITR_DEREF( ITR, TYPE )  ( *((TYPE*)((ITR).current)) )

#define CHKARRAY_FRONT( CHKARRAY, TYPE ) \
        ( *((TYPE*)((CHKARRAY).m_start.current)) )

#define CHKARRAY_BACK( CHKARRAY, TYPE ) \
        ( *((TYPE*)(chkarr_itr_sub( (CHKARRAY).m_finish, 1 ).current)) )

#define CHKARRAY_BEGIN( CHKARRAY )  ( (CHKARRAY).m_start )

#define CHKARRAY_END( CHKARRAY )    ( (CHKARRAY).m_finish )

#define CHKARRAY_INDEX( CHKARRAY, INDEX, TYPE ) \
        ( *((TYPE*)(chkarr_itr_add( (CHKARRAY).m_start, index ).current)) )

#define CHKARRAY_PUSH_BACK_MEM( CHKARRAY, VAL, TYPE, BOOLVAL )              \
        if( (CHKARRAY).m_chunk_array && (CHKARRAY).m_finish.current         \
            != (TYPE*)((CHKARRAY).m_finish.last) - 1 ) {                    \
            *( (TYPE*)( (CHKARRAY).m_finish.current ) ) = VAL;              \
            (CHKARRAY).m_finish.current                                     \
                                = (TYPE*)((CHKARRAY).m_finish.current) + 1; \
            (BOOLVAL) = true; }                                             \
        else                                                                \
            (BOOLVAL) = chkarr_push_back( &(CHKARRAY), &(VAL) )

#define CHKARRAY_PUSH_BACK_FUN( CHKARRAY, VAL, TYPE, BOOLVAL )                  \
        if( (CHKARRAY).m_chunk_array && (CHKARRAY).m_finish.current             \
            != (TYPE*)((CHKARRAY).m_finish.last) - 1 ) {                        \
            (CHKARRAY).m_elmt_init_copy( (CHKARRAY).m_finish.current, &(VAL) ); \
            (CHKARRAY).m_finish.current                                         \
                                = (TYPE*)((CHKARRAY).m_finish.current) + 1;     \
            (BOOLVAL) = true; }                                                 \
        else                                                                    \
            (BOOLVAL) = chkarr_push_back( &(CHKARRAY), &(VAL) )

#define CHKARRAY_PUSH_FRONT_MEM( CHKARRAY, VAL, TYPE, BOOLVAL )                \
        if( (CHKARRAY).m_start.current != (CHKARRAY).m_start.first ) {         \
            (CHKARRAY).m_start.current                                         \
                                    = (TYPE*)((CHKARRAY).m_start.current) - 1; \
            *( (TYPE*)((CHKARRAY).m_start.current) ) = VAL;                    \
            (BOOLVAL) = true; }                                                \
        else                                                                   \
            (BOOLVAL) = chkarr_push_front( &(CHKARRAY), &(VAL) )

#define CHKARRAY_PUSH_FRONT_FUN( CHKARRAY, VAL, TYPE, BOOLVAL )                \
        if( (CHKARRAY).m_start.current != (CHKARRAY).m_start.first ) {         \
            (CHKARRAY).m_start.current                                         \
                                    = (TYPE*)((CHKARRAY).m_start.current) - 1; \
            (CHKARRAY).m_elmt_init_copy((CHKARRAY).m_start.current, &(VAL));   \
            (BOOLVAL) = true; }                                                \
        else                                                                   \
            (BOOLVAL) = chkarr_push_front( &(CHKARRAY), &(VAL) )

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

/* minuend - subtrahend */
ptrdiff_t chkarr_itr_diff( const chkarr_iterator* minuend,
                           const chkarr_iterator* subtrahend );

/* ++iterator */
void chkarr_itr_inc( chkarr_iterator* pitr );

/* --iterator */
void chkarr_itr_dec( chkarr_iterator* pitr );

/* iterator += n */
void chkarr_itr_inc_n( chkarr_iterator* pitr,
                       ptrdiff_t n );

#ifndef __MACRO_C_YOUNG_LIBRARY_COMPILER_SUPPORT_INLINE_FUNCTION__
    /* iterator -= n */
    void chkarr_itr_dec_n( chkarr_iterator* pitr,
                           ptrdiff_t n );

    /* iterator + n */
    chkarr_iterator chkarr_itr_add( chkarr_iterator itr,
                                    ptrdiff_t n );

    /* iterator - n */
    chkarr_iterator chkarr_itr_sub( chkarr_iterator itr,
                                    ptrdiff_t n );

    /* *iterator */
    void* chkarr_itr_deref( chkarr_iterator* itr );

    /* left == right */
    bool chkarr_itr_equal( const chkarr_iterator* left,
                           const chkarr_iterator* right );

    /* left < right */
    bool chkarr_itr_less( const chkarr_iterator* left,
                          const chkarr_iterator* right );
#else
    inline void chkarr_itr_dec_n( chkarr_iterator* pitr,
                                  ptrdiff_t n )
    {
        chkarr_itr_inc_n( pitr, -n );
    }

    inline chkarr_iterator chkarr_itr_add( chkarr_iterator itr,
                                           ptrdiff_t n )
    {
        chkarr_itr_inc_n( &itr, n );
        return itr;
    }

    inline chkarr_iterator chkarr_itr_sub( chkarr_iterator itr,
                                           ptrdiff_t n )
    {
        chkarr_itr_inc_n( &itr, -n );
        return itr;
    }

    inline void* chkarr_itr_deref( chkarr_iterator* itr )
    {
        return itr->current;
    }

    inline bool chkarr_itr_equal( const chkarr_iterator* left,
                                  const chkarr_iterator* right )
    {
        return left->current == right->current ? true : false;
    }

    inline bool chkarr_itr_less( const chkarr_iterator* left,
                                 const chkarr_iterator* right )
    {
        if( left->map == right->map )
            return left->current < right->current ? true : false;
        else
            return left->map < right->map ? true : false;
    }
#endif

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

void chkarr_init( chkarray* uninit_self,
                  size_t element_size,
                  size_t chunk_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 chkarr_destroy( chkarray* self );

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

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

void chkarr_init_move( chkarray* uninit_self,
                       chkarray* src );

void chkarr_assign_move( chkarray* self,
                         chkarray* src );

void chkarr_reverse( chkarray* self );

/* removes the element pointed to by index, returns an iterator pointing to
 * the element following the deleted element */
chkarr_iterator chkarr_erase_pos( chkarray* self,
                                  size_t index );

/* deletes the elements in the range [first_index, last_index), returns
 * an iterator pointing to the element following the last deleted element */
chkarr_iterator chkarr_erase_range( chkarray* 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 chkarr_insert_value( chkarray* 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 chkarr_insert_array( chkarray* 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 chkarr_replace_fill( chkarray* 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 chkarr_replace_array( chkarray* self,
                           size_t index,
                           size_t old_count,
                           const void* src,
                           size_t new_count );

void chkarr_pop_back( chkarray* self );

void chkarr_pop_front( chkarray* self );

bool chkarr_push_back( chkarray* self,
                       const void* value );

bool chkarr_push_front( chkarray* self,
                        const void* value );

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

#ifndef __MACRO_C_YOUNG_LIBRARY_COMPILER_SUPPORT_INLINE_FUNCTION__
    bool chkarr_empty( chkarray* self );

    size_t chkarr_size( chkarray* self );

    size_t chkarr_max_size( void );

    size_t chkarr_chunk_size( chkarray* self );

    size_t chkarr_chunk_elements( chkarray* self );

    chkarr_iterator chkarr_begin( chkarray* self );

    chkarr_iterator chkarr_end( chkarray* self );

    void* chkarr_front( chkarray* self );

    void* chkarr_back( chkarray* self );

    void* chkarr_index( chkarray* self,
                        size_t index );

    void* chkarr_at( chkarray* self,
                     size_t index );
#else
    inline bool chkarr_empty( chkarray* self )
    {
        return self->m_start.current == self->m_finish.current ? true : false;
    }

    inline size_t chkarr_size( chkarray* self )
    {
        return chkarr_itr_diff( &(self->m_finish), &(self->m_start) );
    }

    inline size_t chkarr_max_size( void )
    {
        return SIZE_MAX;
    }

    inline size_t chkarr_chunk_size( chkarray* self )
    {
        return self->m_chunk_size;
    }

    inline size_t chkarr_chunk_elements( chkarray* self )
    {
        return self->m_chunk_size / self->m_element_size;
    }

    inline chkarr_iterator chkarr_begin( chkarray* self )
    {
        return self->m_start;
    }

    inline chkarr_iterator chkarr_end( chkarray* self )
    {
        return self->m_finish;
    }

    inline void* chkarr_front( chkarray* self )
    {
        return self->m_start.current;
    }

    inline void* chkarr_back( chkarray* self )
    {
        return chkarr_itr_sub( self->m_finish, 1 ).current;
    }

    inline void* chkarr_index( chkarray* self,
                               size_t index )
    {
        return chkarr_itr_add( self->m_start, index ).current;
    }

    inline void* chkarr_at( chkarray* self,
                            size_t index )
    {
        return index < (size_t)chkarr_itr_diff( &(self->m_finish),
                                                &(self->m_start) )
               ? chkarr_itr_add( self->m_start, index ).current : NULL;
    }
#endif

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