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
00030
00031
00032
00033
00034
00035
00036
00037 #ifndef _POD_CHAR_TRAITS_H
00038 #define _POD_CHAR_TRAITS_H 1
00039
00040 #include <string>
00041
00042 _GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
00043
00044
00045
00046
00047
00048
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 _GLIBCXX_END_NAMESPACE
00088
00089 _GLIBCXX_BEGIN_NAMESPACE(std)
00090
00091
00092 template<typename V, typename I, typename S>
00093 struct char_traits<__gnu_cxx::character<V, I, S> >
00094 {
00095 typedef __gnu_cxx::character<V, I, S> char_type;
00096 typedef typename char_type::int_type int_type;
00097 typedef typename char_type::state_type state_type;
00098 typedef fpos<state_type> pos_type;
00099 typedef streamoff off_type;
00100
00101 static void
00102 assign(char_type& __c1, const char_type& __c2)
00103 { __c1 = __c2; }
00104
00105 static bool
00106 eq(const char_type& __c1, const char_type& __c2)
00107 { return __c1 == __c2; }
00108
00109 static bool
00110 lt(const char_type& __c1, const char_type& __c2)
00111 { return __c1 < __c2; }
00112
00113 static int
00114 compare(const char_type* __s1, const char_type* __s2, size_t __n)
00115 {
00116 for (size_t __i = 0; __i < __n; ++__i)
00117 if (!eq(__s1[__i], __s2[__i]))
00118 return lt(__s1[__i], __s2[__i]) ? -1 : 1;
00119 return 0;
00120 }
00121
00122 static size_t
00123 length(const char_type* __s)
00124 {
00125 const char_type* __p = __s;
00126 while (__p->value)
00127 ++__p;
00128 return (__p - __s);
00129 }
00130
00131 static const char_type*
00132 find(const char_type* __s, size_t __n, const char_type& __a)
00133 {
00134 for (const char_type* __p = __s; size_t(__p - __s) < __n; ++__p)
00135 if (*__p == __a)
00136 return __p;
00137 return 0;
00138 }
00139
00140 static char_type*
00141 move(char_type* __s1, const char_type* __s2, size_t __n)
00142 {
00143 return static_cast<char_type*>(std::memmove(__s1, __s2,
00144 __n * sizeof(char_type)));
00145 }
00146
00147 static char_type*
00148 copy(char_type* __s1, const char_type* __s2, size_t __n)
00149 {
00150 std::copy(__s2, __s2 + __n, __s1);
00151 return __s1;
00152 }
00153
00154 static char_type*
00155 assign(char_type* __s, size_t __n, char_type __a)
00156 {
00157 std::fill_n(__s, __n, __a);
00158 return __s;
00159 }
00160
00161 static char_type
00162 to_char_type(const int_type& __i)
00163 { return char_type::template from(__i); }
00164
00165 static int_type
00166 to_int_type(const char_type& __c)
00167 { return char_type::template to<int_type>(__c); }
00168
00169 static bool
00170 eq_int_type(const int_type& __c1, const int_type& __c2)
00171 { return __c1 == __c2; }
00172
00173 static int_type
00174 eof()
00175 {
00176 int_type __r = { -1 };
00177 return __r;
00178 }
00179
00180 static int_type
00181 not_eof(const int_type& __c)
00182 { return eq_int_type(__c, eof()) ? int_type() : __c; }
00183 };
00184
00185 _GLIBCXX_END_NAMESPACE
00186
00187 #endif