文件位置：young/string/y_char_function.hpp
/*
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_YOUNG_LIBRARY_CHAR_FUNCTION_HEADER_FILE__
#define __MACRO_CPLUSPLUS_YOUNG_LIBRARY_CHAR_FUNCTION_HEADER_FILE__
//-----------------------------------------------------------------------------
#include <cctype>
#include <cstring>
//#include <wctype.h>
//#include <wchar.h>
#include "../y_define.hpp"
//-----------------------------------------------------------------------------
__MACRO_CPLUSPLUS_YOUNG_LIBRARY_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 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 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_YOUNG_LIBRARY_END_NAMESPACE__
#endif
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
文件位置：young/y_char_traits.hpp
/*
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_YOUNG_LIBRARY_CHAR_TRAITS_HEADER_FILE__
#define __MACRO_CPLUSPLUS_YOUNG_LIBRARY_CHAR_TRAITS_HEADER_FILE__
//-----------------------------------------------------------------------------
#include "string/y_char_function.hpp"
//-----------------------------------------------------------------------------
__MACRO_CPLUSPLUS_YOUNG_LIBRARY_BEGIN_NAMESPACE__
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
typedef std::streampos streampos;
typedef std::streamoff streamoff;
typedef std::streampos wstreampos;
typedef std::streamoff wstreamoff;
//typedef std::wstreampos wstreampos;
//typedef std::wstreamoff wstreamoff;
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
template< typename CharType >
class char_traits
{
public:
typedef CharType char_type;
typedef long int_type;
typedef streampos pos_type;
typedef streamoff off_type;
typedef mbstate_t state_type;
typedef def_size_t size_type;
static char_type eos() { return char_type(); }
static bool is_del( char_type c ) { return false; }
static void assign( char_type& d, const char_type& s )
{ d = s; }
static bool eq( const char_type& c1, const char_type& c2 )
{ return ( c1 == c2 ); }
static bool lt( const char_type& c1, const char_type& c2 )
{ return ( c1 < c2 ); }
static char_type to_char_type( const int_type& i )
{ return static_cast<char_type>( i ); }
static int_type to_int_type( const char_type& c )
{ return static_cast<int_type>( c ); }
static bool eq_int_type( const int_type& i1, const int_type& i2 )
{ return ( i1 == i2 ); }
static int_type eof()
{ return static_cast<int_type>( EOF ); }
static int_type not_eof( const int_type& i )
{ return ( i == eof() ? 0 : i ); }
static size_type length( const char_type* s )
{
size_type i = 0;
while( !eq( *s++, eos() ) )
++i;
return i;
}
// (1) < 0 : s1 < s2; (2) = 0 : s1 = s2; (3) > 0 : s1 > s2
static int compare( const char_type* s1, const char_type* s2, size_type count )
{
for( size_type i = 0; i < count; ++i )
{
if( !eq( s1[i], s2[i] ) )
return ( lt(s1[i], s2[i]) ? -1 : 1 );
}
return 0;
}
static char_type* copy( char_type* d, const char_type* s, size_type count )
{
for( size_type i = 0; i < count ; ++i )
assign( d[i], s[i] );
return ( d + count );
}
static char_type* move( char_type* d, const char_type* s, size_type count )
{
char_type* temp = new char_type[count];
copy( temp, s, count );
copy( d, temp, count );
delete[] temp;
return ( d + count );
}
static char_type* assign( char_type* d, size_type count, const char_type& c )
{
for( size_type i = 0; i < count ; ++i )
assign( d[i], c );
return ( d + count );
}
static const char_type*
find( const char_type* buf, size_type count, const char_type& c )
{
for( size_type i = 0; i < count; ++i,++buf )
{
if( eq( *buf, c ) )
return buf;
}
return NULL_POINTER;
}
}; //end char_traits
//-----------------------------------------------------------------------------
template<>
class char_traits<char>
{
public:
typedef char char_type;
typedef int int_type;
typedef streampos pos_type;
typedef streamoff off_type;
typedef mbstate_t state_type;
typedef def_size_t size_type;
static char_type eos() { return 0; }
static bool is_del( char_type c ) { return isspace(c); }
static void assign( char_type& d, const char_type& s )
{ d = s; }
static bool eq( const char_type& c1, const char_type& c2 )
{ return ( c1 == c2 ); }
static bool lt( const char_type& c1, const char_type& c2 )
{ return ( c1 < c2 ); }
static char_type to_char_type( const int_type& i )
{ return static_cast<char_type>( i ); }
static int_type to_int_type( const char_type& c )
{ return static_cast<int_type>( static_cast<unsigned char>(c) ); }
static bool eq_int_type( const int_type& i1, const int_type& i2 )
{ return ( i1 == i2 ); }
static int_type eof()
{ return static_cast<int_type>( EOF ); }
static int_type not_eof( const int_type& i )
{ return ( i == eof() ? 0 : i ); }
static size_type length( const char_type* s )
{ return strlen(s); }
static int compare( const char_type* s1, const char_type* s2, size_type count )
{
int result = memcmp( s1, s2, count );
if( result == 0 )
return 0;
else
return ( result < 0 ? -1 : 1 );
}
static char_type* copy( char_type* d, const char_type* s, size_type count )
{ return (char_type*)memcpy( d, s, count ); }
static char_type* move( char_type* d, const char_type* s, size_type count )
{ return (char_type*)memmove( d, s, count ); }
static char_type* assign( char_type* d, size_type count, const char_type& c )
{ return (char_type*)memset( d, c, count ); }
static const char_type*
find( const char_type* buf, size_type count, const char_type& c )
{ return (char_type*)memchr( buf, c, count ); }
}; //end char_traits<char>
//-----------------------------------------------------------------------------
template<>
class char_traits<wchar_t>
{
public:
typedef wchar_t char_type;
typedef wint_t int_type;
typedef wstreamoff pos_type;
typedef wstreampos off_type;
typedef mbstate_t state_type;
typedef def_size_t size_type;
static char_type eos() { return 0; }
static bool is_del( char_type c ) { return iswspace(c); }
static void assign( char_type& d, const char_type& s )
{ d = s; }
static bool eq( const char_type& c1, const char_type& c2 )
{ return ( c1 == c2 ); }
static bool lt( const char_type& c1, const char_type& c2 )
{ return ( c1 < c2 ); }
static char_type to_char_type( const int_type& i )
{ return static_cast<char_type>( i ); }
static int_type to_int_type( const char_type& c )
{ return static_cast<int_type>( c ); }
static bool eq_int_type( const int_type& i1, const int_type& i2 )
{ return ( i1 == i2 ); }
static int_type eof()
{ return static_cast<int_type>( WEOF ); }
static int_type not_eof( const int_type& i )
{ return ( i == eof() ? 0 : i ); }
static size_type length( const char_type* s )
{ return wcslen(s); }
static int compare( const char_type* s1, const char_type* s2, size_type count )
{
int result = wmemcmp( s1, s2, count );
if( result == 0 )
return 0;
else
return ( result < 0 ? -1 : 1 );
}
static char_type* copy( char_type* d, const char_type* s, size_type count )
{ return wmemcpy( d, s, count ); }
static char_type* move( char_type* d, const char_type* s, size_type count )
{ return wmemmove( d, s, count ); }
static char_type* assign( char_type* d, size_type count, const char_type& c )
{ return wmemset( d, c, count ); }
static const char_type*
find( const char_type* buf, size_type count, const char_type& c )
{ return wmemchr( buf, c, count ); }
}; //end char_traits<wchar_t>
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
class cmp_no_case_char_traits //比较时不区分大小写char的traits
{
public:
typedef char char_type;
typedef int int_type;
typedef streampos pos_type;
typedef streamoff off_type;
typedef mbstate_t state_type;
typedef def_size_t size_type;
static char_type eos() { return 0; }
static bool is_del( char_type c ) { return isspace(c); }
static void assign( char_type& d, const char_type& s )
{ d = s; }
static bool eq( const char_type& c1, const char_type& c2 )
{ return ( tolower(c1) == tolower(c2) ); }
static bool lt( const char_type& c1, const char_type& c2 )
{ return ( tolower(c1) < tolower(c2) ); }
static char_type to_char_type( const int_type& i )
{ return static_cast<char_type>( i ); }
static int_type to_int_type( const char_type& c )
{ return static_cast<int_type>( static_cast<unsigned char>(c) ); }
static bool eq_int_type( const int_type& i1, const int_type& i2 )
{ return ( i1 == i2 ); }
static int_type eof()
{ return static_cast<int_type>( EOF ); }
static int_type not_eof( const int_type& i )
{ return ( i == eof() ? 0 : i ); }
static size_type length( const char_type* s )
{ return strlen(s); }
static int compare( const char_type* s1, const char_type* s2, size_type count )
{ return charcmp_lower( s1, s2, count ); }
static char_type* copy( char_type* d, const char_type* s, size_type count )
{ return (char_type*)memcpy( d, s, count ); }
static char_type* move( char_type* d, const char_type* s, size_type count )
{ return (char_type*)memmove( d, s, count ); }
static char_type* assign( char_type* d, size_type count, const char_type& c )
{ return (char_type*)memset( d, c, count ); }
static const char_type*
find( const char_type* buf, size_type count, const char_type& c )
{ return (char_type*)memchr( buf, c, count ); }
}; //end cmp_no_case_char_traits
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
class lower_char_traits //全部是小写char的traits
{
public:
typedef char char_type;
typedef int int_type;
typedef streampos pos_type;
typedef streamoff off_type;
typedef mbstate_t state_type;
typedef def_size_t size_type;
static char_type eos() { return 0; }
static bool is_del( char_type c ) { return isspace(c); }
static void assign( char_type& d, const char_type& s )
{ d = tolower(s); }
static bool eq( const char_type& c1, const char_type& c2 )
{ return ( c1 == c2 ); }
static bool lt( const char_type& c1, const char_type& c2 )
{ return ( c1 < c2 ); }
static char_type to_char_type( const int_type& i )
{ return static_cast<char_type>( i ); }
static int_type to_int_type( const char_type& c )
{ return static_cast<int_type>( static_cast<unsigned char>(c) ); }
static bool eq_int_type( const int_type& i1, const int_type& i2 )
{ return ( i1 == i2 ); }
static int_type eof()
{ return static_cast<int_type>( EOF ); }
static int_type not_eof( const int_type& i )
{ return ( i == eof() ? 0 : i ); }
static size_type length( const char_type* s )
{ return strlen(s); }
static int compare( const char_type* s1, const char_type* s2, size_type count )
{
int result = memcmp( s1, s2, count );
if( result == 0 )
return 0;
else
return ( result < 0 ? -1 : 1 );
}
static char_type* copy( char_type* d, const char_type* s, size_type count )
{ return charcopy_lower( d, s, count ); }
static char_type* move( char_type* d, const char_type* s, size_type count )
{ return charmove_lower( d, s, count ); }
static char_type* assign( char_type* d, size_type count, const char_type& c )
{ return charset_lower( d, c, count ); }
static const char_type*
find( const char_type* buf, size_type count, const char_type& c )
{ return (char_type*)memchr( buf, c, count ); }
}; //end lower_char_traits
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
class upper_char_traits //全部是大写char的traits
{
public:
typedef char char_type;
typedef int int_type;
typedef streampos pos_type;
typedef streamoff off_type;
typedef mbstate_t state_type;
typedef def_size_t size_type;
static char_type eos() { return 0; }
static bool is_del( char_type c ) { return isspace(c); }
static void assign( char_type& d, const char_type& s )
{ d = toupper(s); }
static bool eq( const char_type& c1, const char_type& c2 )
{ return ( c1 == c2 ); }
static bool lt( const char_type& c1, const char_type& c2 )
{ return ( c1 < c2 ); }
static char_type to_char_type( const int_type& i )
{ return static_cast<char_type>( i ); }
static int_type to_int_type( const char_type& c )
{ return static_cast<int_type>( static_cast<unsigned char>(c) ); }
static bool eq_int_type( const int_type& i1, const int_type& i2 )
{ return ( i1 == i2 ); }
static int_type eof()
{ return static_cast<int_type>( EOF ); }
static int_type not_eof( const int_type& i )
{ return ( i == eof() ? 0 : i ); }
static size_type length( const char_type* s )
{ return strlen(s); }
static int compare( const char_type* s1, const char_type* s2, size_type count )
{
int result = memcmp( s1, s2, count );
if( result == 0 )
return 0;
else
return ( result < 0 ? -1 : 1 );
}
static char_type* copy( char_type* d, const char_type* s, size_type count )
{ return charcopy_upper( d, s, count ); }
static char_type* move( char_type* d, const char_type* s, size_type count )
{ return charmove_upper( d, s, count ); }
static char_type* assign( char_type* d, size_type count, const char_type& c )
{ return charset_upper( d, c, count ); }
static const char_type*
find( const char_type* buf, size_type count, const char_type& c )
{ return (char_type*)memchr( buf, c, count ); }
}; //end upper_char_traits
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
//字符串内全部是小写char并且和其他字符串进行比较时不区分大小写的traits
class cmp_no_case_lower_char_traits
{
public:
typedef char char_type;
typedef int int_type;
typedef streampos pos_type;
typedef streamoff off_type;
typedef mbstate_t state_type;
typedef def_size_t size_type;
static char_type eos() { return 0; }
static bool is_del( char_type c ) { return isspace(c); }
static void assign( char_type& d, const char_type& s )
{ d = tolower(s); }
static bool eq( const char_type& c1, const char_type& c2 )
{ return ( tolower(c1) == tolower(c2) ); }
static bool lt( const char_type& c1, const char_type& c2 )
{ return ( tolower(c1) < tolower(c2) ); }
static char_type to_char_type( const int_type& i )
{ return static_cast<char_type>( i ); }
static int_type to_int_type( const char_type& c )
{ return static_cast<int_type>( static_cast<unsigned char>(c) ); }
static bool eq_int_type( const int_type& i1, const int_type& i2 )
{ return ( i1 == i2 ); }
static int_type eof()
{ return static_cast<int_type>( EOF ); }
static int_type not_eof( const int_type& i )
{ return ( i == eof() ? 0 : i ); }
static size_type length( const char_type* s )
{ return strlen(s); }
static int compare( const char_type* s1, const char_type* s2, size_type count )
{ return charcmp_lower( s1, s2, count ); }
static char_type* copy( char_type* d, const char_type* s, size_type count )
{ return charcopy_lower( d, s, count ); }
static char_type* move( char_type* d, const char_type* s, size_type count )
{ return charmove_lower( d, s, count ); }
static char_type* assign( char_type* d, size_type count, const char_type& c )
{ return charset_lower( d, c, count ); }
static const char_type*
find( const char_type* buf, size_type count, const char_type& c )
{ return (char_type*)memchr( buf, c, count ); }
}; //end cmp_no_case_lower_char_traits
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
//字符串内全部是大写char并且和其他字符串进行比较时不区分大小写的traits
class cmp_no_case_upper_char_traits
{
public:
typedef char char_type;
typedef int int_type;
typedef streampos pos_type;
typedef streamoff off_type;
typedef mbstate_t state_type;
typedef def_size_t size_type;
static char_type eos() { return 0; }
static bool is_del( char_type c ) { return isspace(c); }
static void assign( char_type& d, const char_type& s )
{ d = toupper(s); }
static bool eq( const char_type& c1, const char_type& c2 )
{ return ( toupper(c1) == toupper(c2) ); }
static bool lt( const char_type& c1, const char_type& c2 )
{ return ( toupper(c1) < toupper(c2) ); }
static char_type to_char_type( const int_type& i )
{ return static_cast<char_type>( i ); }
static int_type to_int_type( const char_type& c )
{ return static_cast<int_type>( static_cast<unsigned char>(c) ); }
static bool eq_int_type( const int_type& i1, const int_type& i2 )
{ return ( i1 == i2 ); }
static int_type eof()
{ return static_cast<int_type>( EOF ); }
static int_type not_eof( const int_type& i )
{ return ( i == eof() ? 0 : i ); }
static size_type length( const char_type* s )
{ return strlen(s); }
static int compare( const char_type* s1, const char_type* s2, size_type count )
{ return charcmp_upper( s1, s2, count ); }
static char_type* copy( char_type* d, const char_type* s, size_type count )
{ return charcopy_upper( d, s, count ); }
static char_type* move( char_type* d, const char_type* s, size_type count )
{ return charmove_upper( d, s, count ); }
static char_type* assign( char_type* d, size_type count, const char_type& c )
{ return charset_upper( d, c, count ); }
static const char_type*
find( const char_type* buf, size_type count, const char_type& c )
{ return (char_type*)memchr( buf, c, count ); }
}; //end cmp_no_case_upper_char_traits
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
class cmp_no_case_wchar_traits //比较时不区分大小写wchar_t的traits
{
public:
typedef wchar_t char_type;
typedef wint_t int_type;
typedef wstreamoff pos_type;
typedef wstreampos off_type;
typedef mbstate_t state_type;
typedef def_size_t size_type;
static char_type eos() { return 0; }
static bool is_del( char_type c ) { return iswspace(c); }
static void assign( char_type& d, const char_type& s )
{ d = s; }
static bool eq( const char_type& c1, const char_type& c2 )
{ return ( towlower(c1) == towlower(c2) ); }
static bool lt( const char_type& c1, const char_type& c2 )
{ return ( towlower(c1) < towlower(c2) ); }
static char_type to_char_type( const int_type& i )
{ return static_cast<char_type>( i ); }
static int_type to_int_type( const char_type& c )
{ return static_cast<int_type>( c ); }
static bool eq_int_type( const int_type& i1, const int_type& i2 )
{ return ( i1 == i2 ); }
static int_type eof()
{ return static_cast<int_type>( WEOF ); }
static int_type not_eof( const int_type& i )
{ return ( i == eof() ? 0 : i ); }
static size_type length( const char_type* s )
{ return wcslen(s); }
static int compare( const char_type* s1, const char_type* s2, size_type count )
{ return wcharcmp_lower( s1, s2, count ); }
static char_type* copy( char_type* d, const char_type* s, size_type count )
{ return wmemcpy( d, s, count ); }
static char_type* move( char_type* d, const char_type* s, size_type count )
{ return wmemmove( d, s, count ); }
static char_type* assign( char_type* d, size_type count, const char_type& c )
{ return wmemset( d, c, count ); }
static const char_type*
find( const char_type* buf, size_type count, const char_type& c )
{ return wmemchr( buf, c, count ); }
}; //end cmp_no_case_wchar_traits
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
class lower_wchar_traits //全部是小写wchar_t的traits
{
public:
typedef wchar_t char_type;
typedef wint_t int_type;
typedef wstreamoff pos_type;
typedef wstreampos off_type;
typedef mbstate_t state_type;
typedef def_size_t size_type;
static char_type eos() { return 0; }
static bool is_del( char_type c ) { return iswspace(c); }
static void assign( char_type& d, const char_type& s )
{ d = towlower(s); }
static bool eq( const char_type& c1, const char_type& c2 )
{ return ( c1 == c2 ); }
static bool lt( const char_type& c1, const char_type& c2 )
{ return ( c1 < c2 ); }
static char_type to_char_type( const int_type& i )
{ return static_cast<char_type>( i ); }
static int_type to_int_type( const char_type& c )
{ return static_cast<int_type>( c ); }
static bool eq_int_type( const int_type& i1, const int_type& i2 )
{ return ( i1 == i2 ); }
static int_type eof()
{ return static_cast<int_type>( WEOF ); }
static int_type not_eof( const int_type& i )
{ return ( i == eof() ? 0 : i ); }
static size_type length( const char_type* s )
{ return wcslen(s); }
static int compare( const char_type* s1, const char_type* s2, size_type count )
{
int result = wmemcmp( s1, s2, count );
if( result == 0 )
return 0;
else
return ( result < 0 ? -1 : 1 );
}
static char_type* copy( char_type* d, const char_type* s, size_type count )
{ return wcharcopy_lower( d, s, count ); }
static char_type* move( char_type* d, const char_type* s, size_type count )
{ return wcharmove_lower( d, s, count ); }
static char_type* assign( char_type* d, size_type count, const char_type& c )
{ return wcharset_lower( d, c, count ); }
static const char_type*
find( const char_type* buf, size_type count, const char_type& c )
{ return wmemchr( buf, c, count ); }
}; //end lower_wchar_traits
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
class upper_wchar_traits //全部是大写wchar_t的traits
{
public:
typedef wchar_t char_type;
typedef wint_t int_type;
typedef wstreamoff pos_type;
typedef wstreampos off_type;
typedef mbstate_t state_type;
typedef def_size_t size_type;
static char_type eos() { return 0; }
static bool is_del( char_type c ) { return iswspace(c); }
static void assign( char_type& d, const char_type& s )
{ d = towupper(s); }
static bool eq( const char_type& c1, const char_type& c2 )
{ return ( c1 == c2 ); }
static bool lt( const char_type& c1, const char_type& c2 )
{ return ( c1 < c2 ); }
static char_type to_char_type( const int_type& i )
{ return static_cast<char_type>( i ); }
static int_type to_int_type( const char_type& c )
{ return static_cast<int_type>( c ); }
static bool eq_int_type( const int_type& i1, const int_type& i2 )
{ return ( i1 == i2 ); }
static int_type eof()
{ return static_cast<int_type>( WEOF ); }
static int_type not_eof( const int_type& i )
{ return ( i == eof() ? 0 : i ); }
static size_type length( const char_type* s )
{ return wcslen(s); }
static int compare( const char_type* s1, const char_type* s2, size_type count )
{
int result = wmemcmp( s1, s2, count );
if( result == 0 )
return 0;
else
return ( result < 0 ? -1 : 1 );
}
static char_type* copy( char_type* d, const char_type* s, size_type count )
{ return wcharcopy_upper( d, s, count ); }
static char_type* move( char_type* d, const char_type* s, size_type count )
{ return wcharmove_upper( d, s, count ); }
static char_type* assign( char_type* d, size_type count, const char_type& c )
{ return wcharset_upper( d, c, count ); }
static const char_type*
find( const char_type* buf, size_type count, const char_type& c )
{ return wmemchr( buf, c, count ); }
}; //end upper_wchar_traits
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
//字符串内全部是小写wchar_t并且和其他字符串进行比较时不区分大小写的traits
class cmp_no_case_lower_wchar_traits
{
public:
typedef wchar_t char_type;
typedef wint_t int_type;
typedef wstreamoff pos_type;
typedef wstreampos off_type;
typedef mbstate_t state_type;
typedef def_size_t size_type;
static char_type eos() { return 0; }
static bool is_del( char_type c ) { return iswspace(c); }
static void assign( char_type& d, const char_type& s )
{ d = towlower(s); }
static bool eq( const char_type& c1, const char_type& c2 )
{ return ( towlower(c1) == towlower(c2) ); }
static bool lt( const char_type& c1, const char_type& c2 )
{ return ( towlower(c1) < towlower(c2) ); }
static char_type to_char_type( const int_type& i )
{ return static_cast<char_type>( i ); }
static int_type to_int_type( const char_type& c )
{ return static_cast<int_type>( c ); }
static bool eq_int_type( const int_type& i1, const int_type& i2 )
{ return ( i1 == i2 ); }
static int_type eof()
{ return static_cast<int_type>( WEOF ); }
static int_type not_eof( const int_type& i )
{ return ( i == eof() ? 0 : i ); }
static size_type length( const char_type* s )
{ return wcslen(s); }
static int compare( const char_type* s1, const char_type* s2, size_type count )
{ return wcharcmp_lower( s1, s2, count ); }
static char_type* copy( char_type* d, const char_type* s, size_type count )
{ return wcharcopy_lower( d, s, count ); }
static char_type* move( char_type* d, const char_type* s, size_type count )
{ return wcharmove_lower( d, s, count ); }
static char_type* assign( char_type* d, size_type count, const char_type& c )
{ return wcharset_lower( d, c, count ); }
static const char_type*
find( const char_type* buf, size_type count, const char_type& c )
{ return wmemchr( buf, c, count ); }
}; //end cmp_no_case_lower_wchar_traits
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
//字符串内全部是大写wchar_t并且和其他字符串进行比较时不区分大小写的traits
class cmp_no_case_upper_wchar_traits
{
public:
typedef wchar_t char_type;
typedef wint_t int_type;
typedef wstreamoff pos_type;
typedef wstreampos off_type;
typedef mbstate_t state_type;
typedef def_size_t size_type;
static char_type eos() { return 0; }
static bool is_del( char_type c ) { return iswspace(c); }
static void assign( char_type& d, const char_type& s )
{ d = towupper(s); }
static bool eq( const char_type& c1, const char_type& c2 )
{ return ( towupper(c1) == towupper(c2) ); }
static bool lt( const char_type& c1, const char_type& c2 )
{ return ( towupper(c1) < towupper(c2) ); }
static char_type to_char_type( const int_type& i )
{ return static_cast<char_type>( i ); }
static int_type to_int_type( const char_type& c )
{ return static_cast<int_type>( c ); }
static bool eq_int_type( const int_type& i1, const int_type& i2 )
{ return ( i1 == i2 ); }
static int_type eof()
{ return static_cast<int_type>( WEOF ); }
static int_type not_eof( const int_type& i )
{ return ( i == eof() ? 0 : i ); }
static size_type length( const char_type* s )
{ return wcslen(s); }
static int compare( const char_type* s1, const char_type* s2, size_type count )
{ return wcharcmp_upper( s1, s2, count ); }
static char_type* copy( char_type* d, const char_type* s, size_type count )
{ return wcharcopy_upper( d, s, count ); }
static char_type* move( char_type* d, const char_type* s, size_type count )
{ return wcharmove_upper( d, s, count ); }
static char_type* assign( char_type* d, size_type count, const char_type& c )
{ return wcharset_upper( d, c, count ); }
static const char_type*
find( const char_type* buf, size_type count, const char_type& c )
{ return wmemchr( buf, c, count ); }
}; //end cmp_no_case_upper_wchar_traits
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
__MACRO_CPLUSPLUS_YOUNG_LIBRARY_END_NAMESPACE__
#endif
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
