mstl_char_traits.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_TRAITS_HEADER_FILE__
#define __MACRO_CPLUSPLUS_MINI_STL_CHAR_TRAITS_HEADER_FILE__
//-----------------------------------------------------------------------------
#include "string/mstl_char_function.hpp"
//-----------------------------------------------------------------------------
__MACRO_CPLUSPLUS_MINI_STL_BEGIN_NAMESPACE__
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

typedef  std::mbstate_t  mbstate_t;
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 (const 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 );  }