yc_string.c

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

            }
            else
            {
                if( false == static_to_dynamic( self, STATIC_NCSTR_LEN + 1,
                                                false ) )
                    return false;
            }
        }

        DYMEMARR_PUSH_BACK( self->strobj.m_dystr, c, char, result );

        if( false == result )
            return false;
    }

    return true;
}
#endif  /* SUPPORT_FILE_SYSTEM */

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

#ifndef __MACRO_C_YOUNG_LIBRARY_COMPILER_SUPPORT_INLINE_FUNCTION__
    size_t ncstr_max_size( void )
    {
        return SIZE_MAX - 1;
    }

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

    size_t ncstr_size( ncstring* self )
    {
        return false == self->m_dynamic ? self->strobj.m_ncstr.len
                        : DYMEMARR_SIZE( self->strobj.m_dystr, char );
    }

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

    size_t ncstr_capacity( ncstring* self )
    {
        return false == self->m_dynamic ? STATIC_NCSTR_LEN
                        : DYMEMARR_CAPACITY( self->strobj.m_dystr, char );
    }

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

    size_t ncstr_space( ncstring* self )
    {
        return false == self->m_dynamic
                        ? STATIC_NCSTR_LEN - self->strobj.m_ncstr.len
                        : DYMEMARR_SPACE( self->strobj.m_dystr, char );
    }

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

    char ncstr_front( ncstring* self )
    {
        return false == self->m_dynamic
                        ? self->strobj.m_ncstr.data[0]
                        : DYMEMARR_FRONT( self->strobj.m_dystr, char );
    }

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

    char ncstr_back( ncstring* self )
    {
        return false == self->m_dynamic
                        ? self->strobj.m_ncstr.data[self->strobj.m_ncstr.len - 1]
                        : DYMEMARR_BACK( self->strobj.m_dystr, char );
    }

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

    char* ncstr_begin( ncstring* self )
    {
        return false == self->m_dynamic
                        ? self->strobj.m_ncstr.data
                        : DYMEMARR_BEGIN( self->strobj.m_dystr, char );
    }

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

    char* ncstr_end( ncstring* self )
    {
        return false == self->m_dynamic
                        ? self->strobj.m_ncstr.data + self->strobj.m_ncstr.len
                        : DYMEMARR_END( self->strobj.m_dystr, char );
    }

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

    char* ncstr_index( ncstring* self, size_t index )
    {
        return true == self->m_dynamic
                       ? &DYMEMARR_INDEX( self->strobj.m_dystr, index, char )
                       : self->strobj.m_ncstr.data + index;
    }

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

    char* ncstr_at( ncstring* self, size_t index )
    {
        return index < ncstr_size(self) ? ncstr_index(self, index) : NULL;
    }

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

    const char* ncstr_to_string( ncstring* self )
    {
        if( false == self->m_dynamic )
            self->strobj.m_ncstr.data[self->strobj.m_ncstr.len] = 0;
        else
            *( (char*)(self->strobj.m_dystr.m_finish) ) = 0;

        return true == self->m_dynamic ? (char*)(self->strobj.m_dystr.m_start)
                                       : self->strobj.m_ncstr.data;
    }

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

    void ncstr_pop_back( ncstring* self )
    {
        if( false == self->m_dynamic && self->strobj.m_ncstr.len > 0 )
            --( self->strobj.m_ncstr.len );
        else
        {
            DYMEMARR_POP_BACK( self->strobj.m_dystr, char );
        }
    }
#endif

/******************************************************************************/
/******************************************************************************/
/* wcstring */
/******************************************************************************/
/******************************************************************************/

#ifdef __MACRO_C_YOUNG_LIBRARY_COMPILER_SUPPORT_C95_WIDE_CHARACTER__
void wcstr_init( wcstring* uninit_self )
{
    dystr_init( uninit_self );
}

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

void wcstr_destroy( wcstring* self )
{
    dystr_destroy( self );
}

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

int wcstr_init_copy( wcstring* uninit_self, const wcstring* src )
{
    return uninit_self == src ? -1 : dystr_init_copy( uninit_self, src );
}

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

int wcstr_assign_copy( wcstring* self, const wcstring* src )
{
    if( self != src )
    {
        if( false == self->m_dynamic )
            return dystr_init_copy( self, src );
        else
        {
            if( false == src->m_dynamic)
                return dymemarr_replace_array( &(self->strobj.m_dystr), 0,
                                               wcstr_size( self ),
                                               src->strobj.m_wcstr.data,
                                               src->strobj.m_wcstr.len );
            else
                return dymemarr_assign_copy( &(self->strobj.m_dystr),
                                             &(src->strobj.m_dystr) );
        }
    }

    return -1;
}

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

void wcstr_init_move( wcstring* uninit_self, wcstring* src )
{
    if( uninit_self != src )
        dystr_init_move( uninit_self, src );
}

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

void wcstr_assign_move( wcstring* self, wcstring* src )
{
    if( self != src )
        dystr_assign_move( self, src );
}

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

bool wcstr_push_back( wcstring* self, const wchar_t value )
{
    bool result = true;

    if( false == self->m_dynamic )
    {
        if( self->strobj.m_wcstr.len < STATIC_WCSTR_LEN )
        {
            self->strobj.m_wcstr.data[self->strobj.m_wcstr.len] = value;
            ++( self->strobj.m_wcstr.len );
            return true;
        }
        else
        {
            if( false == static_to_dynamic(self, STATIC_WCSTR_LEN + 1, true) )
                return false;
        }
    }

    DYMEMARR_PUSH_BACK( self->strobj.m_dystr, value, wchar_t, result );

    return result;
}

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

bool wcstr_reserve( wcstring* self, size_t new_capacity )
{
    if( true == self->m_dynamic )
        return dymemarr_reserve( &(self->strobj.m_dystr), new_capacity );
    else if( STATIC_WCSTR_LEN < new_capacity )
        return static_to_dynamic( self, new_capacity, true );

    return true;
}

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

void wcstr_erase_pos( wcstring* self, size_t index )
{
    if( true == self->m_dynamic )
        dymemarr_erase_pos( &(self->strobj.m_dystr), index );
    else if( index < (size_t)(self->strobj.m_wcstr.len) )
    {
        if( index + 1 < (size_t)(self->strobj.m_wcstr.len) )
            ylib_memcopy( self->strobj.m_wcstr.data + index,
                          self->strobj.m_wcstr.data + index + 1,
                          (self->strobj.m_wcstr.len - index) * sizeof(wchar_t) );
        --( self->strobj.m_wcstr.len );
    }
}

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

void wcstr_erase_range( wcstring* self, size_t first_index, size_t last_index )
{
    if( true == self->m_dynamic )
        dymemarr_erase_range( &(self->strobj.m_dystr), first_index, last_index );
    else if( first_index < (size_t)(self->strobj.m_wcstr.len)
             && first_index < last_index )
    {
        if( last_index > (size_t)(self->strobj.m_wcstr.len) )
            last_index = self->strobj.m_wcstr.len;

        if( last_index < (size_t)(self->strobj.m_wcstr.len) )
            ylib_memcopy( self->strobj.m_wcstr.data + first_index,
                          self->strobj.m_wcstr.data + last_index,
                          (self->strobj.m_wcstr.len - last_index)
                          * sizeof(wchar_t) );

        self->strobj.m_wcstr.len -= (wchar_t)( last_index - first_index );
    }
}

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

bool wcstr_insert_value( wcstring* self, size_t index, const wchar_t value,
                         size_t count )
{
    if( true == self->m_dynamic )
        return dymemarr_insert_value( &(self->strobj.m_dystr), index,
                                      &value, count );
    else
    {
        if( self->strobj.m_wcstr.len + count <= STATIC_WCSTR_LEN )
        {
            ylib_memcopy( self->strobj.m_wcstr.data + index + count,
                          self->strobj.m_wcstr.data + index,
                          (self->strobj.m_wcstr.len - index) * sizeof(wchar_t) );
            ylib_wmemset( self->strobj.m_wcstr.data + index, value, count );
            self->strobj.m_wcstr.len += (wchar_t)count;
        }
        else
        {
            if( false == static_to_dynamic(self, self->strobj.m_wcstr.len
                                           + count, true) )
                return false;
            return dymemarr_insert_value( &(self->strobj.m_dystr), index,
                                          &value, count );
        }
    }

    return true;
}

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

bool wcstr_insert_array( wcstring* self, size_t index, const wchar_t* src,
                         size_t count )
{
    if( true == self->m_dynamic )
        return dymemarr_insert_array( &(self->strobj.m_dystr), index,
                                      src, count );
    else
    {
        if( self->strobj.m_wcstr.len + count <= STATIC_WCSTR_LEN )
        {
            ylib_memcopy( self->strobj.m_wcstr.data + index + count,
                          self->strobj.m_wcstr.data + index,
                          (self->strobj.m_wcstr.len - index) * sizeof(wchar_t) );
            ylib_memcopy( self->strobj.m_wcstr.data + index, src,
                          sizeof(wchar_t) * count );
            self->strobj.m_wcstr.len += (wchar_t)count;
        }
        else
        {
            if( false == static_to_dynamic(self, self->strobj.m_wcstr.len
                                           + count, true) )
                return false;
            return dymemarr_insert_array( &(self->strobj.m_dystr), index,
                                          src, count );
        }
    }

    return true;
}

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

bool wcstr_resize( wcstring* self, size_t new_length, const wchar_t value )
{
    if( true == self->m_dynamic )
        return dymemarr_resize( &(self->strobj.m_dystr), new_length, &value );
    else
    {
        if( new_length < (size_t)(self->strobj.m_wcstr.len) )
            wcstr_erase_range( self, new_length, self->strobj.m_wcstr.len );
        else if( new_length > (size_t)(self->strobj.m_wcstr.len) )
            return wcstr_insert_value( self, self->strobj.m_wcstr.len, value,
                                       new_length - self->strobj.m_wcstr.len );
    }

    return true;
}

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

bool wcstr_replace_fill( wcstring* self, size_t index, size_t old_count,
                         const wchar_t value, size_t new_count )
{
    size_t new_len, old_len = wcstr_size( self );

    if( index > old_len )
        return false;

    if( true == self->m_dynamic )
        return dymemarr_replace_fill( &(self->strobj.m_dystr), index,
                                      old_count, &value, new_count );
    else
    {
        if( old_count > old_len - index )
            old_count = old_len - index;

        if( old_len - old_count > wcstr_max_size() - new_count )
            return false;

        new_len = old_len - old_count + new_count;

        if( new_len <= STATIC_WCSTR_LEN )
        {
            ylib_memmove( self->strobj.m_wcstr.data + index + new_count,
                          self->strobj.m_wcstr.data + index + old_count,
                          (old_len - index - old_count) * sizeof(wchar_t) );
            ylib_wmemset( self->strobj.m_wcstr.data + index, value, new_count );
            self->strobj.m_wcstr.len = (wchar_t)new_len;
        }
        else
        {
            if( false == static_to_dynamic(self, new_len, true) )
                return false;
            return dymemarr_replace_fill( &(self->strobj.m_dystr), index,
                                          old_count, &value, new_count );
        }
    }

    return true;
}

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

bool wcstr_replace_array( wcstring* self, size_t index, size_t old_count,
                          const wchar_t* src, size_t new_count )
{
    size_t new_len, old_len = wcstr_size( self );

    if( index > old_len )
        return false;

    if( true == self->m_dynamic )
        return dymemarr_replace_array( &(self->strobj.m_dystr), index,
                                       old_count, src, new_count );
    else
    {
        if( old_count > old_len - index )
            old_count = old_len - index;

        if( old_len - old_count > wcstr_max_size() - new_count )
            return false;

        new_len = old_len - old_count + new_count;

        if( new_len <= STATIC_WCSTR_LEN )
        {
            ylib_memmove( self->strobj.m_wcstr.data + index + new_count,
                          self->strobj.m_wcstr.data + index + old_count,
                          (old_len - index - old_count) * sizeof(wchar_t) );
            ylib_memcopy( self->strobj.m_wcstr.data + index, src,
                          sizeof(wchar_t) * new_count );
            self->strobj.m_wcstr.len = (wchar_t)new_len;
        }
        else
        {
            if( false == static_to_dynamic(self, new_len, true) )
                return false;
            return dymemarr_replace_array( &(self->strobj.m_dystr), index,
                                           old_count, src, new_count );
        }
    }

    return true;
}

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

bool wcstr_trim( wcstring* self, size_t index,
                 const wchar_t* wchars, size_t count )
{
    size_t len = wcstr_size( self );