mstl_char_function.hpp

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

/*
The young Library
Copyright (c) 2005 by 杨桓

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_CPLUSPLUS_MINI_STL_CHAR_FUNCTION_HEADER_FILE__
#define __MACRO_CPLUSPLUS_MINI_STL_CHAR_FUNCTION_HEADER_FILE__
//-----------------------------------------------------------------------------
#include <cctype>
#include <cstring>
//#include <wctype.h>
//#include <wchar.h>

#include "../mstl_define.hpp"
//-----------------------------------------------------------------------------
__MACRO_CPLUSPLUS_MINI_STL_BEGIN_NAMESPACE__
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

inline int isspace( int c )
{
    return std::isspace(c);
}

inline size_t strlen( const char* string )
{
    return std::strlen(string);
}

inline int tolower( int c )
{
    return std::tolower(c);
}

inline int toupper( int c )
{
    return std::toupper(c);
}

inline int memcmp( const void* buf1, const void* buf2, size_t count_bytes )
{
    return std::memcmp( buf1, buf2, count_bytes );
}

inline void* memcpy( void* dest, const void* src, size_t count_bytes )
{
    return std::memcpy( dest, src, count_bytes );
}

inline void* memmove( void* dest, const void* src, size_t count_bytes )
{
    return std::memmove( dest, src, count_bytes );
}

inline void* memset( void* dest, int c, size_t count )
{
    return std::memset( dest, c, count );
}

inline const void* memchr( const void* buf, int c, size_t count )
{
    return std::memchr( buf, c, count );
}

//-----------------------------------------------------------------------------

inline int iswspace( wint_t c )
{
//    return std::iswspace(c);
    return iswspace(c);
}

inline size_t wcslen( const wchar_t* string )
{
//    return std::wcslen(string);
    return wcslen(string);
}

inline int towlower( wint_t c )
{
//    return std::towlower(c);
    return towlower(c);
}

inline int towupper( wint_t c )
{
//    return std::towupper(c);
    return towupper(c);
}

inline int wmemcmp( const wchar_t* buf1, const wchar_t* buf2, size_t count )
{
//    return std::wmemcmp( buf1, buf2, count );
    return wmemcmp( buf1, buf2, count );
}

inline wchar_t* wmemcpy( wchar_t* dest, const wchar_t* src, size_t count )
{
//    return std::wmemcpy( dest, src, count );
    return wmemcpy( dest, src, count );
}

inline wchar_t* wmemmove( wchar_t* dest, const wchar_t* src, size_t count )
{
//    return std::wmemmove( dest, src, count );
    return wmemmove( dest, src, count );
}

inline wchar_t* wmemset( wchar_t* dest, wchar_t c, size_t count )
{
//    return std::wmemset( dest, c, count );
    return wmemset( dest, c, count );
}

inline const wchar_t* wmemchr( const wchar_t* buf, wchar_t c, size_t count )
{
//    return std::wmemchr( buf, c, count );
    return wmemchr( buf, c, count );
}

//-----------------------------------------------------------------------------

int charcmp_lower( const char* s1, const char* s2, size_t count )
{
    for( size_t i = 0; i < count; ++i,++s1,++s2 )
    {
        int value1 = tolower( *s1 );
        int value2 = tolower( *s2 );
        if( value1 != value2 )
            return ( value1 < value2 ? -1 : 1 );
    }
    return 0;
}

int charcmp_upper( const char* s1, const char* s2, size_t count )
{
    for( size_t i = 0; i < count; ++i,++s1,++s2 )
    {
        int value1 = toupper( *s1 );
        int value2 = toupper( *s2 );
        if( value1 != value2 )
            return ( value1 < value2 ? -1 : 1 );
    }
    return 0;
}

char* charcopy_lower( char* dest, const char* src, size_t count )
{
    for( size_t i = 0; i < count ; ++i,++dest,++src )
        *dest = tolower( *src );
    return dest;
}

char* charcopy_upper( char* dest, const char* src, size_t count )
{
    for( size_t i = 0; i < count ; ++i,++dest,++src )
        *dest = toupper( *src );
    return dest;
}

char* charmove_lower( char* dest, const char* src, size_t count )
{
    char* temp = new char[count];
    charcopy_lower( temp, src, count );
    memcpy( dest, temp, count );
    delete[] temp;
    return ( dest + count );
}

char* charmove_upper( char* dest, const char* src, size_t count )
{
    char* temp = new char[count];
    charcopy_upper( temp, src, count );
    memcpy( dest, temp, count );
    delete[] temp;
    return ( dest + count );
}

char* charset_lower( char* dest, char c, size_t count )
{
    char value = tolower(c);
    for( size_t i = 0; i < count; ++i,++dest )
        *dest = value;
    return dest;
}

char* charset_upper( char* dest, char c, size_t count )
{
    char value = toupper(c);
    for( size_t i = 0; i < count; ++i,++dest )
        *dest = value;
    return dest;
}

//-----------------------------------------------------------------------------

int wcharcmp_lower( const wchar_t* s1, const wchar_t* s2, size_t count )
{
    for( size_t i = 0; i < count; ++i,++s1,++s2 )
    {
        int value1 = towlower( *s1 );
        int value2 = towlower( *s2 );
        if( value1 != value2 )
            return ( value1 < value2 ? -1 : 1 );
    }
    return 0;
}

int wcharcmp_upper( const wchar_t* s1, const wchar_t* s2, size_t count )
{
    for( size_t i = 0; i < count; ++i,++s1,++s2 )
    {
        int value1 = towupper( *s1 );
        int value2 = towupper( *s2 );
        if( value1 != value2 )
            return ( value1 < value2 ? -1 : 1 );
    }
    return 0;
}

wchar_t* wcharcopy_lower( wchar_t* dest, const wchar_t* src, size_t count )
{
    for( size_t i = 0; i < count ; ++i,++dest,++src )
        *dest = towlower( *src );
    return dest;
}

wchar_t* wcharcopy_upper( wchar_t* dest, const wchar_t* src, size_t count )
{
    for( size_t i = 0; i < count ; ++i,++dest,++src )
        *dest = towupper( *src );
    return dest;
}

wchar_t* wcharmove_lower( wchar_t* dest, const wchar_t* src, size_t count )
{
    wchar_t* temp = new wchar_t[count];
    wcharcopy_lower( temp, src, count );
    memcpy( dest, temp, sizeof(wchar_t) * count );
    delete[] temp;
    return ( dest + count );
}

wchar_t* wcharmove_upper( wchar_t* dest, const wchar_t* src, size_t count )
{
    wchar_t* temp = new wchar_t[count];
    wcharcopy_upper( temp, src, count );
    memcpy( dest, temp, sizeof(wchar_t) * count );
    delete[] temp;
    return ( dest + count );
}

wchar_t* wcharset_lower( wchar_t* dest, wchar_t c, size_t count )
{
    int value = towlower(c);
    for( size_t i = 0; i < count; ++i,++dest )
        *dest = value;
    return dest;
}

wchar_t* wcharset_upper( wchar_t* dest, wchar_t c, size_t count )
{
    int value = towupper(c);
    for( size_t i = 0; i < count; ++i,++dest )
        *dest = value;
    return dest;
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
__MACRO_CPLUSPLUS_MINI_STL_END_NAMESPACE__
#endif
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------