yc_string.h

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

                        ? self->strobj.m_ncstr.data + self->strobj.m_ncstr.len
                        : DYMEMARR_END( self->strobj.m_dystr, char );
    }

    inline char* ncstr_index( ncstring* self, size_t index )
    {
        return ncstr_begin(self) + index;
    }

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

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

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

void wcstr_destroy( wcstring* self );

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

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

void wcstr_init_move( wcstring* uninit_self,
                      wcstring* src );

void wcstr_assign_move( wcstring* self,
                        wcstring* src );

bool wcstr_push_back( wcstring* self,
                      const wchar_t value );

bool wcstr_reserve( wcstring* self,
                    size_t new_capacity );

void wcstr_erase_pos( wcstring* self,
                      size_t index );

void wcstr_erase_range( wcstring* self,
                        size_t first_index,
                        size_t last_index );

bool wcstr_insert_value( wcstring* self,
                         size_t index,
                         const wchar_t value,
                         size_t count );

bool wcstr_insert_array( wcstring* self,
                         size_t index,
                         const wchar_t* src,
                         size_t count );

bool wcstr_resize( wcstring* self,
                   size_t new_length,
                   const wchar_t value );

bool wcstr_replace_fill( wcstring* self,
                         size_t index,
                         size_t old_count,
                         const wchar_t value,
                         size_t new_count );

bool wcstr_replace_array( wcstring* self,
                          size_t index,
                          size_t old_count,
                          const wchar_t* src,
                          size_t new_count );

bool wcstr_trim( wcstring* self,
                 size_t index,
                 const wchar_t* wchars,
                 size_t count );

bool wcstr_format( wcstring* self,
                   const wchar_t* format,
                   ... );

void wcstr_to_ncstr( wcstring* self );

#ifdef __MACRO_C_YOUNG_LIBRARY_COMPILER_SUPPORT_INPUT_OUTPUT_SYSTEM__
    void wcstr_put( wcstring* self );

    bool wcstr_getline( wcstring* self, const wchar_t delimiter );
#endif

#ifdef __MACRO_C_YOUNG_LIBRARY_COMPILER_SUPPORT_FILE_SYSTEM__
    bool wcstr_fgetline( wcstring* self,
                         FILE* fp,
                         const wchar_t delimiter );
#endif

#ifndef __MACRO_C_YOUNG_LIBRARY_COMPILER_SUPPORT_INLINE_FUNCTION__
    size_t wcstr_max_size( void );

    size_t wcstr_size( wcstring* self );

    size_t wcstr_capacity( wcstring* self );

    size_t wcstr_space( wcstring* self );

    wchar_t wcstr_front( wcstring* self );

    wchar_t wcstr_back( wcstring* self );

    wchar_t* wcstr_begin( wcstring* self );

    wchar_t* wcstr_end( wcstring* self );

    wchar_t* wcstr_index( wcstring* self,
                          size_t index );

    wchar_t* wcstr_at( wcstring* self,
                       size_t index );

    const wchar_t* wcstr_to_wstring( wcstring* self );

    void wcstr_pop_back( wcstring* self );
#else
    inline size_t wcstr_max_size( void )
    {
        return SIZE_MAX / sizeof(wchar_t) - 1;
    }

    inline size_t wcstr_size( wcstring* self )
    {
        return false == self->m_dynamic
                        ? self->strobj.m_wcstr.len
                        : DYMEMARR_SIZE( self->strobj.m_dystr, wchar_t );
    }

    inline size_t wcstr_capacity( wcstring* self )
    {
        return false == self->m_dynamic
                        ? STATIC_WCSTR_LEN
                        : DYMEMARR_CAPACITY( self->strobj.m_dystr, wchar_t );
    }

    inline size_t wcstr_space( wcstring* self )
    {
        return false == self->m_dynamic
                        ? STATIC_WCSTR_LEN - self->strobj.m_wcstr.len
                        : DYMEMARR_SPACE( self->strobj.m_dystr, wchar_t );
    }

    inline wchar_t wcstr_front( wcstring* self )
    {
        return false == self->m_dynamic
                        ? self->strobj.m_wcstr.data[0]
                        : DYMEMARR_FRONT( self->strobj.m_dystr, wchar_t );
    }

    inline wchar_t wcstr_back( wcstring* self )
    {
        return false == self->m_dynamic
                        ? self->strobj.m_wcstr.data[self->strobj.m_wcstr.len - 1]
                        : DYMEMARR_BACK( self->strobj.m_dystr, wchar_t );
    }

    inline wchar_t* wcstr_begin( wcstring* self )
    {
        return false == self->m_dynamic
                        ? self->strobj.m_wcstr.data
                        : DYMEMARR_BEGIN( self->strobj.m_dystr, wchar_t );
    }

    inline wchar_t* wcstr_end( wcstring* self )
    {
        return false == self->m_dynamic
                        ? self->strobj.m_wcstr.data + self->strobj.m_wcstr.len
                        : DYMEMARR_END( self->strobj.m_dystr, wchar_t );
    }

    inline wchar_t* wcstr_index( wcstring* self, size_t index )
    {
        return wcstr_begin(self) + index;
    }

    inline wchar_t* wcstr_at( wcstring* self, size_t index )
    {
        return index < wcstr_size(self) ? wcstr_begin(self) + index : NULL;
    }

    inline const wchar_t* wcstr_to_wstring( wcstring* self )
    {
        if( false == self->m_dynamic )
            self->strobj.m_wcstr.data[self->strobj.m_wcstr.len] = 0;
        else
            *( (wchar_t*)(self->strobj.m_dystr.m_finish) ) = 0;

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

    inline void wcstr_pop_back( wcstring* self )
    {
        if( false == self->m_dynamic && self->strobj.m_wcstr.len > 0 )
            --( self->strobj.m_wcstr.len );
        else
        {
            DYMEMARR_POP_BACK( self->strobj.m_dystr, wchar_t );
        }
    }
#endif  /* SUPPORT_INLINE_FUNCTION */
#endif  /* SUPPORT_C95_WIDE_CHARACTER */

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