00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00034
00035
00036
00037 #ifndef _POD_CHAR_TRAITS_H
00038 #define _POD_CHAR_TRAITS_H 1
00039
00040 #include <string>
00041
00042 namespace __gnu_cxx
00043 {
00044
00045
00046
00047
00049 template<typename V, typename I, typename S = mbstate_t>
00050 struct character
00051 {
00052 typedef V value_type;
00053 typedef I int_type;
00054 typedef S state_type;
00055 typedef character<V, I, S> char_type;
00056
00057 value_type value;
00058
00059 template<typename V2>
00060 static char_type
00061 from(const V2& v)
00062 {
00063 char_type ret = { static_cast<value_type>(v) };
00064 return ret;
00065 }
00066
00067 template<typename V2>
00068 static V2
00069 to(const char_type& c)
00070 {
00071 V2 ret = { static_cast<V2>(c.value) };
00072 return ret;
00073 }
00074
00075 };
00076
00077 template<typename V, typename I, typename S>
00078 inline bool
00079 operator==(const character<V, I, S>& lhs, const character<V, I, S>& rhs)
00080 { return lhs.value == rhs.value; }
00081
00082 template<typename V, typename I, typename S>
00083 inline bool
00084 operator<(const character<V, I, S>& lhs, const character<V, I, S>& rhs)
00085 { return lhs.value < rhs.value; }
00086 }
00087
00088 namespace std
00089 {
00091 template<typename V, typename I, typename S>
00092 struct char_traits<__gnu_cxx::character<V, I, S> >
00093 {
00094 typedef __gnu_cxx::character<V, I, S> char_type;
00095 typedef typename char_type::int_type int_type;
00096 typedef typename char_type::state_type state_type;
00097 typedef fpos<state_type> pos_type;
00098 typedef streamoff off_type;
00099
00100 static void
00101 assign(char_type& __c1, const char_type& __c2)
00102 { __c1 = __c2; }
00103
00104 static bool
00105 eq(const char_type& __c1, const char_type& __c2)
00106 { return __c1 == __c2; }
00107
00108 static bool
00109 lt(const char_type& __c1, const char_type& __c2)
00110 { return __c1 < __c2; }
00111
00112 static int
00113 compare(const char_type* __s1, const char_type* __s2, size_t __n)
00114 {
00115 for (size_t __i = 0; __i < __n; ++__i)
00116 if (!eq(__s1[__i], __s2[__i]))
00117 return lt(__s1[__i], __s2[__i]) ? -1 : 1;
00118 return 0;
00119 }
00120
00121 static size_t
00122 length(const char_type* __s)
00123 {
00124 const char_type* __p = __s;
00125 while (__p->value)
00126 ++__p;
00127 return (__p - __s);
00128 }
00129
00130 static const char_type*
00131 find(const char_type* __s, size_t __n, const char_type& __a)
00132 {
00133 for (const char_type* __p = __s; size_t(__p - __s) < __n; ++__p)
00134 if (*__p == __a)
00135 return __p;
00136 return 0;
00137 }
00138
00139 static char_type*
00140 move(char_type* __s1, const char_type* __s2, size_t __n)
00141 {
00142 return static_cast<char_type*>(std::memmove(__s1, __s2,
00143 __n * sizeof(char_type)));
00144 }
00145
00146 static char_type*
00147 copy(char_type* __s1, const char_type* __s2, size_t __n)
00148 {
00149 std::copy(__s2, __s2 + __n, __s1);
00150 return __s1;
00151 }
00152
00153 static char_type*
00154 assign(char_type* __s, size_t __n, char_type __a)
00155 {
00156 std::fill_n(__s, __n, __a);
00157 return __s;
00158 }
00159
00160 static char_type
00161 to_char_type(const int_type& __i)
00162 { return char_type::template from(__i); }
00163
00164 static int_type
00165 to_int_type(const char_type& __c)
00166 { return char_type::template to<int_type>(__c); }
00167
00168 static bool
00169 eq_int_type(const int_type& __c1, const int_type& __c2)
00170 { return __c1 == __c2; }
00171
00172 static int_type
00173 eof()
00174 {
00175 int_type __r = { -1 };
00176 return __r;
00177 }
00178
00179 static int_type
00180 not_eof(const int_type& __c)
00181 { return eq_int_type(__c, eof()) ? int_type() : __c; }
00182 };
00183 }
00184
00185 #endif