yc_dyrscarr.c

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

void dyrscarr_erase_pos( dyrscarray* self, size_t index )
{
    size_t len = LENGTH( self );

    if( index < len )
    {
        ylib_byte_t* erase = POS( self, index );

        if( index != len - 1 )
        {
            if( self->m_elmt_assign_move )
                rscmove( erase, erase + self->m_element_size, len - index - 1,
                         self->m_element_size, self->m_element_size,
                         self->m_elmt_assign_move );
            else
                rsccopy( erase, erase + self->m_element_size, len - index - 1,
                         self->m_element_size, self->m_element_size,
                         self->m_elmt_assign_copy );
        }

        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 );
    }
}

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

void dyrscarr_erase_range( dyrscarray* 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) )
        {
            /* [last_index, len) to [first_index, new_len) */
            if( self->m_elmt_assign_move )
                rscmove( first_pos, last_pos, len - last_index,
                         self->m_element_size, self->m_element_size,
                         self->m_elmt_assign_move );
            else
                rsccopy( first_pos, last_pos, len - last_index,
                         self->m_element_size, self->m_element_size,
                         self->m_elmt_assign_copy );
        }

        if( self->m_elmt_destroy )
            rforeach( self->m_finish, last_index - first_index,
                      self->m_element_size, self->m_elmt_destroy );

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

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

bool dyrscarr_insert_value( dyrscarray* self,
                            size_t index,
                            const void* value,
                            size_t count )
{
    append_info result;
    size_t old_len = LENGTH( self );

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

    result = dymemarr_memory_reserve( self, index, 0, count );

    if( FAILURE == result)
        return false;

    if( !value )
    {
        if( self->m_elmt_init && (REALLOC == result || LESS == result) )
        {
            foreach( LESS == result ? POS(self, old_len) : POS(self, index),
                     LESS == result ? index + count - old_len : count,
                     self->m_element_size, self->m_elmt_init );
        }
    }
    else
    {
        if( MORE == result )
        {
            rscfill( POS(self, index), value, count, self->m_element_size,
                     self->m_elmt_assign_copy );
        }
        else if( REALLOC == result )
        {
            rscfill( POS(self, index), value, count, self->m_element_size,
                     self->m_elmt_init_copy );
        }
        else if( LESS == result )
        {
            rscfill( POS(self, index), value, old_len - index,
                     self->m_element_size, self->m_elmt_assign_copy );

            rscfill( POS(self, old_len), value, index + count - old_len,
                     self->m_element_size, self->m_elmt_init_copy );
        }
    }

    return true;
}

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

bool dyrscarr_insert_array( dyrscarray* self,
                            size_t index,
                            const void* src,
                            size_t count )
{
    append_info result;
    size_t old_len = LENGTH( self );

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

    result = dymemarr_memory_reserve( self, index, 0, count );

    if( FAILURE == result)
        return false;

    if( !src )
    {
        if( self->m_elmt_init && (REALLOC == result || LESS == result) )
        {
            foreach( LESS == result ? POS(self, old_len) : POS(self, index),
                     LESS == result ? index + count - old_len : count,
                     self->m_element_size, self->m_elmt_init );
        }
    }
    else
    {
        if( MORE == result )
        {
            rsccopy( POS(self, index), src, count, self->m_element_size,
                     self->m_element_size, self->m_elmt_assign_copy );
        }
        else if( REALLOC == result )
        {
            rsccopy( POS(self, index), src, count, self->m_element_size,
                     self->m_element_size, self->m_elmt_init_copy );
        }
        else if( LESS == result )
        {
            rsccopy( POS(self, index), src, old_len - index,
                     self->m_element_size, self->m_element_size,
                     self->m_elmt_assign_copy );

            rsccopy( POS(self, old_len),
                     (ylib_byte_t*)src + self->m_element_size
                     * (old_len - index),
                     index + count - old_len, self->m_element_size,
                     self->m_element_size, self->m_elmt_init_copy );
        }
    }

    return true;
}

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

bool dyrscarr_replace_fill( dyrscarray* self,
                            size_t index,
                            size_t old_count,
                            const void* value,
                            size_t new_count )
{
    append_info result;
    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 > dyrscarr_max_size(self) - new_count )
        return false;

    result = dymemarr_memory_reserve( self, index, old_count, new_count );

    if( FAILURE == result )
        return false;

    if( !value )
    {
        if( self->m_elmt_init && (REALLOC == result || LESS == result) )
        {
            foreach( LESS == result ? POS(self, old_len) : POS(self, index),
                     LESS == result ? new_count - old_count : new_count,
                     self->m_element_size, self->m_elmt_init );
        }
    }
    else
    {
        if( MORE == result )
        {
            rscfill( POS(self, index), value, new_count, self->m_element_size,
                     self->m_elmt_assign_copy );
        }
        else if( REALLOC == result )
        {
            rscfill( POS(self, index), value, new_count, self->m_element_size,
                     self->m_elmt_init_copy );
        }
        else if( LESS == result )
        {
            rscfill( POS(self, index), value, old_len - index,
                     self->m_element_size, self->m_elmt_assign_copy );

            rscfill( POS(self, old_len), value, new_count - old_count,
                     self->m_element_size, self->m_elmt_init_copy );
        }
    }

    return true;
}

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

bool dyrscarr_replace_array( dyrscarray* self,
                             size_t index,
                             size_t old_count,
                             const void* src,
                             size_t new_count )
{
    append_info result;
    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 > dyrscarr_max_size(self) - new_count )
        return false;

    result = dymemarr_memory_reserve( self, index, old_count, new_count );

    if( FAILURE == result )
        return false;

    if( !src )
    {
        if( self->m_elmt_init && (REALLOC == result || LESS == result) )
        {
            foreach( LESS == result ? POS(self, old_len) : POS(self, index),
                     LESS == result ? new_count - old_count : new_count,
                     self->m_element_size, self->m_elmt_init );
        }
    }
    else
    {
        if( MORE == result )
        {
            rsccopy( POS(self, index), src, new_count, self->m_element_size,
                     self->m_element_size, self->m_elmt_assign_copy );
        }
        else if( REALLOC == result )
        {
            rsccopy( POS(self, index), src, new_count, self->m_element_size,
                     self->m_element_size, self->m_elmt_init_copy );
        }
        else if( LESS == result )
        {
            rsccopy( POS(self, index), src, old_len - index,
                     self->m_element_size, self->m_element_size,
                     self->m_elmt_assign_copy );

            rsccopy( POS(self, old_len),
                     (ylib_byte_t*)src + (old_len - index)
                     * self->m_element_size,
                     new_count - old_count, self->m_element_size,
                     self->m_element_size, self->m_elmt_init_copy );
        }
    }

    return true;
}

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

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

    if( new_finish < self->m_utmost )
    {
        if( self->m_elmt_init_copy )
            self->m_elmt_init_copy( self->m_finish, value );
        else
            ylib_memcopy( self->m_finish, value, self->m_element_size );

        self->m_finish = new_finish;
    }
    else
        return dyrscarr_insert_value( self, LENGTH(self), value, 1 );

    return true;
}

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

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

    if( old_len < new_length )
        return dyrscarr_insert_value( self, old_len, value,
                                      new_length - old_len );
    else if( old_len > new_length )
        dyrscarr_erase_range( self, new_length, old_len );

    return true;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    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;
    }

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

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