yc_dymemarr.c

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

    ylib_byte_t* erase = POS( self, index );

    if( erase < (ylib_byte_t*)(self->m_finish) )
    {
        ylib_byte_t* next = erase + self->m_element_size;

        if( next != self->m_finish )
            ylib_memcopy( erase, next, (ylib_byte_t*)(self->m_finish) - next );

        self->m_finish = (ylib_byte_t*)(self->m_finish) - self->m_element_size;
    }
}

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

void dymemarr_erase_range( dymemarray* self,
                           size_t first_index,
                           size_t last_index )
{
    size_t len = LENGTH( self );

    if( first_index < last_index && first_index < len )
    {
        ylib_byte_t* first_pos;
        ylib_byte_t* last_pos;

        if( last_index > len )
            last_index = len;

        first_pos = POS( self, first_index );
        last_pos = POS( self, last_index );

        if( last_pos < (ylib_byte_t*)(self->m_finish) )
            ylib_memcopy( first_pos, last_pos,
                          (ylib_byte_t*)(self->m_finish) - last_pos );

        self->m_finish = (ylib_byte_t*)(self->m_finish)
                         - (last_pos - first_pos);
    }
}

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

bool dymemarr_insert_value( dymemarray* self,
                            size_t index,
                            const void* value,
                            size_t count )
{
    size_t old_len = LENGTH( self );

    if( index > old_len || old_len > dymemarr_max_size(self) - count )
        return false;

    if( false == dymemarr_memory_reserve(self, index, 0, count) )
        return false;
    else
    {
        if( value )
            memfill( POS(self, index), value, count, self->m_element_size );
    }

    return true;
}

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

bool dymemarr_insert_array( dymemarray* self,
                            size_t index,
                            const void* src,
                            size_t count )
{
    size_t old_len = LENGTH( self );

    if( index > old_len || old_len > dymemarr_max_size(self) - count )
        return false;

    if( false == dymemarr_memory_reserve(self, index, 0, count) )
        return false;
    else
    {
        if( src )
            ylib_memcopy( POS(self, index), src, count * self->m_element_size );
    }

    return true;
}

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

bool dymemarr_replace_fill( dymemarray* self,
                            size_t index,
                            size_t old_count,
                            const void* value,
                            size_t new_count )
{
    size_t old_len = LENGTH( self );

    if( index > old_len )
        return false;

    if( old_count > old_len - index )
        old_count = old_len - index;

    /* old_len + new_count - old_counr > max_size */
    if( old_len - old_count > dymemarr_max_size(self) - new_count )
        return false;

    if( false == dymemarr_memory_reserve(self, index, old_count, new_count) )
        return false;
    else
    {
        if( value )
            memfill( POS(self, index), value, new_count, self->m_element_size );
    }

    return true;
}

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

bool dymemarr_replace_array( dymemarray* self,
                             size_t index,
                             size_t old_count,
                             const void* src,
                             size_t new_count )
{
    size_t old_len = LENGTH( self );

    if( index > old_len )
        return false;

    if( old_count > old_len - index )
        old_count = old_len - index;

    /* old_len + new_count - old_counr > max_size */
    if( old_len - old_count > dymemarr_max_size(self) - new_count )
        return false;

    if( false == dymemarr_memory_reserve(self, index, old_count, new_count) )
        return false;
    else
    {
        if( src )
            ylib_memcopy( POS(self, index), src,
                          new_count * self->m_element_size );
    }

    return true;
}

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

bool dymemarr_push_back( dymemarray* self, const void* value )
{
    void* new_finish = (ylib_byte_t*)(self->m_finish) + self->m_element_size;

    if( new_finish > self->m_utmost )
        return dymemarr_insert_value( self, LENGTH(self), value, 1 );

    if( sizeof(int) == self->m_element_size )
        *((int*)(self->m_finish)) = *((int*)value);
    else if( sizeof(double) == self->m_element_size )
        *((double*)(self->m_finish)) = *((double*)value);
    else if( sizeof(char) == self->m_element_size )
        *((char*)(self->m_finish)) = *((char*)value);
    else if( sizeof(short) == self->m_element_size )
        *((short*)(self->m_finish)) = *((short*)value);
    else
        ylib_memcopy( self->m_finish, value, self->m_element_size );

    self->m_finish = new_finish;
    return true;
}

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

bool dymemarr_resize( dymemarray* self, size_t new_length, const void* value )
{
    size_t old_len = LENGTH( self );

    if( new_length < old_len )
        self->m_finish = POS( self, new_length );
    else if( new_length > old_len )
        return dymemarr_insert_value( self, old_len, value,
                                      new_length - old_len );

    return true;
}

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

#ifndef __MACRO_C_YOUNG_LIBRARY_COMPILER_SUPPORT_INLINE_FUNCTION__
    bool dymemarr_empty( dymemarray* self )
    {
        return self->m_start == self->m_finish ? true : false;
    }

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

    size_t dymemarr_max_size( dymemarray* self )
    {
        size_t max = SIZE_MAX / self->m_element_size;
        return self->m_element_size > CHARACTER_SIZE_MAX ? max : --max;
    }

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

    size_t dymemarr_size( dymemarray* self )
    {
        return ((ylib_byte_t*)(self->m_finish) - (ylib_byte_t*)(self->m_start))
               / self->m_element_size;
    }

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

    size_t dymemarr_capacity( dymemarray* self )
    {
        return ((ylib_byte_t*)(self->m_utmost) - (ylib_byte_t*)(self->m_start))
               / self->m_element_size;
    }

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

    size_t dymemarr_space( dymemarray* self )
    {
        return ((ylib_byte_t*)(self->m_utmost) - (ylib_byte_t*)(self->m_finish))
               / self->m_element_size;
    }

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

    void* dymemarr_begin( dymemarray* self )
    {
        return self->m_start;
    }

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

    void* dymemarr_end( dymemarray* self )
    {
        return self->m_finish;
    }

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

    void* dymemarr_front( dymemarray* self )
    {
        return self->m_start;
    }

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

    void* dymemarr_back( dymemarray* self )
    {
        return (ylib_byte_t*)(self->m_finish) - self->m_element_size;
    }

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

    void* dymemarr_index( dymemarray* self, size_t index )
    {
        return (ylib_byte_t*)(self->m_start) + index * self->m_element_size;
    }

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

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

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

    void dymemarr_pop_back( dymemarray* self )
    {
        if( self->m_finish > self->m_start )
            self->m_finish = (ylib_byte_t*)(self->m_finish)
                             - self->m_element_size;
    }
#endif

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