← Back to branch summary

~ubuntu-branches/ubuntu/hardy/libterralib/hardy

« back to all changes in this revision

Viewing changes to src/STLport/stl/char_traits.h

  • Committer: Bazaar Package Importer
  • Author(s): Daniel T Chen
  • Date: 2005-11-25 22:32:59 UTC
  • Revision ID: james.westby@ubuntu.com-20051125223259-3zubal8ux4ki4fjg
Tags: upstream-3.0.3b2
Import upstream version 3.0.3b2

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/STLport/stl/char_traits.h
 
1
/*
 
2
 * Copyright (c) 1996,1997
 
3
 * Silicon Graphics Computer Systems, Inc.
 
4
 *
 
5
 * Copyright (c) 1999 
 
6
 * Boris Fomitchev
 
7
 *
 
8
 * This material is provided "as is", with absolutely no warranty expressed
 
9
 * or implied. Any use is at your own risk.
 
10
 *
 
11
 * Permission to use or copy this software for any purpose is hereby granted 
 
12
 * without fee, provided the above notices are retained on all copies.
 
13
 * Permission to modify the code and to distribute modified code is granted,
 
14
 * provided the above notices are retained, and a notice that the code was
 
15
 * modified is included with the above copyright notice.
 
16
 *
 
17
 */
 
18
 
 
19
#ifndef _STLP_CHAR_TRAITS_H
 
20
#define _STLP_CHAR_TRAITS_H
 
21
 
 
22
// Define char_traits
 
23
 
 
24
# if defined (_STLP_OWN_IOSTREAMS) || ! defined (_STLP_USE_NEW_IOSTREAMS)
 
25
 
 
26
# if ! defined (_STLP_CSTDDEF)
 
27
#  include <cstddef>
 
28
# endif
 
29
 
 
30
#if ! defined (_STLP_CSTRING)
 
31
#  include <cstring>
 
32
#endif
 
33
 
 
34
#if defined (_STLP_UNIX) && defined (_STLP_HAS_NO_NEW_C_HEADERS)
 
35
#include <sys/types.h>          // For off_t
 
36
#endif /* __unix */
 
37
 
 
38
#ifdef __BORLANDC__
 
39
# include <mem.h>
 
40
# include <string.h>
 
41
# include <_stddef.h>
 
42
// class mbstate_t;
 
43
#endif
 
44
 
 
45
#ifndef __TYPE_TRAITS_H
 
46
# include <stl/type_traits.h>
 
47
#endif
 
48
 
 
49
# if !defined (_STLP_CWCHAR)
 
50
#  include <stl/_cwchar.h>
 
51
# endif                 
 
52
 
 
53
_STLP_BEGIN_NAMESPACE
 
54
 
 
55
# ifdef _STLP_OWN_IOSTREAMS
 
56
 
 
57
template <class _Tp> class allocator;
 
58
 
 
59
#define _STLP_NULL_CHAR_INIT(_ChT) _STLP_DEFAULT_CONSTRUCTED(_ChT)
 
60
 
 
61
#if defined (__sgi) && defined (_STLP_HAS_NO_NEW_C_HEADERS) /* IRIX */
 
62
typedef off64_t   streamoff;
 
63
// #elif defined (__unix) && defined (_STLP_HAS_NO_NEW_C_HEADERS) /* Other version of UNIX */
 
64
// typedef off_t     streamoff;
 
65
#else /* __unix */
 
66
// boris : here, it's not ptrdiff_t as some Solaris systems have confusing definitions of these.
 
67
typedef long streamoff;
 
68
#endif /* _STLP_HAS_NO_NEW_C_HEADERS */
 
69
 
 
70
typedef ptrdiff_t streamsize;
 
71
 
 
72
// Class fpos, which represents a position within a file.  (The C++
 
73
// standard calls for it to be defined in <ios>.  This implementation
 
74
// moves it to <iosfwd>, which is included by <ios>.)
 
75
template <class _StateT> class fpos
 
76
{
 
77
public:                         // From table 88 of the C++ standard.
 
78
  fpos(streamoff __pos) : _M_pos(__pos), _M_st(_STLP_NULL_CHAR_INIT(_StateT)) {}
 
79
  fpos() : _M_pos(0), _M_st(_STLP_NULL_CHAR_INIT(_StateT)) {}
 
80
 
 
81
  operator streamoff() const { return _M_pos; }
 
82
 
 
83
  bool  _STLP_CALL operator==(const fpos<_StateT>& __y) const
 
84
    { return _M_pos == __y._M_pos; }
 
85
  bool _STLP_CALL operator!=(const fpos<_StateT>& __y) const
 
86
    { return _M_pos != __y._M_pos; }
 
87
 
 
88
  fpos<_StateT>& operator+=(streamoff __off) {
 
89
    _M_pos += __off;
 
90
    return *this;
 
91
  }
 
92
  fpos<_StateT>& operator-=(streamoff __off) {
 
93
    _M_pos -= __off;
 
94
    return *this;
 
95
  }
 
96
 
 
97
  fpos<_StateT> operator+(streamoff __off) {
 
98
    fpos<_StateT> __tmp(*this);
 
99
    __tmp += __off;
 
100
    return __tmp;
 
101
  }
 
102
  fpos<_StateT> operator-(streamoff __off) {
 
103
    fpos<_StateT> __tmp(*this);
 
104
    __tmp -= __off;
 
105
    return __tmp;
 
106
  }
 
107
 
 
108
public:                         // Manipulation of the state member.
 
109
  _StateT state() const { return _M_st; }
 
110
  void state(_StateT __st) { _M_st = __st; }
 
111
private:
 
112
  streamoff _M_pos;
 
113
  _StateT _M_st;
 
114
};
 
115
 
 
116
typedef fpos<mbstate_t> streampos;
 
117
typedef fpos<mbstate_t> wstreampos;
 
118
# endif
 
119
 
 
120
// Class __char_traits_base.
 
121
 
 
122
template <class _CharT, class _IntT> class __char_traits_base {
 
123
public:
 
124
  typedef _CharT char_type;
 
125
  typedef _IntT int_type;
 
126
#ifdef _STLP_USE_NEW_IOSTREAMS
 
127
  typedef streamoff off_type;
 
128
  typedef streampos pos_type;
 
129
# ifdef _STLP_NO_MBSTATE_T
 
130
  typedef char      state_type;
 
131
# else
 
132
  typedef mbstate_t state_type;
 
133
# endif
 
134
#endif /* _STLP_USE_NEW_IOSTREAMS */
 
135
 
 
136
  static void _STLP_CALL assign(char_type& __c1, const char_type& __c2) { __c1 = __c2; }
 
137
  static bool _STLP_CALL eq(const _CharT& __c1, const _CharT& __c2) 
 
138
    { return __c1 == __c2; }
 
139
  static bool _STLP_CALL lt(const _CharT& __c1, const _CharT& __c2) 
 
140
    { return __c1 < __c2; }
 
141
 
 
142
  static int _STLP_CALL compare(const _CharT* __s1, const _CharT* __s2, size_t __n) {
 
143
    for (size_t __i = 0; __i < __n; ++__i)
 
144
      if (!eq(__s1[__i], __s2[__i]))
 
145
        return __s1[__i] < __s2[__i] ? -1 : 1;
 
146
    return 0;
 
147
  }
 
148
 
 
149
  static size_t _STLP_CALL length(const _CharT* __s) {
 
150
    const _CharT _NullChar = _STLP_DEFAULT_CONSTRUCTED(_CharT);
 
151
    size_t __i;
 
152
    for (__i = 0; !eq(__s[__i], _NullChar); ++__i)
 
153
      {}
 
154
    return __i;
 
155
  }
 
156
 
 
157
  static const _CharT* _STLP_CALL find(const _CharT* __s, size_t __n, const _CharT& __c) {
 
158
    for ( ; __n > 0 ; ++__s, --__n)
 
159
      if (eq(*__s, __c))
 
160
        return __s;
 
161
    return 0;
 
162
  }
 
163
 
 
164
 
 
165
  static _CharT* _STLP_CALL move(_CharT* __s1, const _CharT* __s2, size_t _Sz) {    
 
166
    return (_Sz == 0 ? __s1 : (_CharT*)memmove(__s1, __s2, _Sz * sizeof(_CharT)));
 
167
  }
 
168
  
 
169
  static _CharT* _STLP_CALL copy(_CharT* __s1, const _CharT* __s2, size_t __n) {
 
170
    return (__n == 0 ? __s1 :
 
171
            (_CharT*)memcpy(__s1, __s2, __n * sizeof(_CharT)));
 
172
    } 
 
173
 
 
174
  static _CharT* _STLP_CALL assign(_CharT* __s, size_t __n, _CharT __c) {
 
175
    for (size_t __i = 0; __i < __n; ++__i)
 
176
      __s[__i] = __c;
 
177
    return __s;
 
178
  }
 
179
 
 
180
  static int_type _STLP_CALL not_eof(const int_type& __c) {
 
181
    return !eq_int_type(__c, eof()) ? __c : __STATIC_CAST(int_type, 0);
 
182
  }
 
183
 
 
184
  static char_type _STLP_CALL to_char_type(const int_type& __c) {
 
185
    return (char_type)__c;
 
186
  }
 
187
 
 
188
  static int_type _STLP_CALL to_int_type(const char_type& __c) {
 
189
    return (int_type)__c;
 
190
  }
 
191
 
 
192
  static bool _STLP_CALL eq_int_type(const int_type& __c1, const int_type& __c2) {
 
193
    return __c1 == __c2;
 
194
  }
 
195
 
 
196
  static int_type _STLP_CALL eof() {
 
197
    return (int_type)-1;
 
198
    //    return __STATIC_CAST(int_type,-1);
 
199
  }
 
200
};
 
201
 
 
202
// Generic char_traits class.  Note that this class is provided only
 
203
//  as a base for explicit specialization; it is unlikely to be useful
 
204
//  as is for any particular user-defined type.  In particular, it 
 
205
//  *will not work* for a non-POD type.
 
206
 
 
207
template <class _CharT> class char_traits
 
208
  : public __char_traits_base<_CharT, _CharT>
 
209
{};
 
210
 
 
211
// Specialization for char.
 
212
 
 
213
_STLP_TEMPLATE_NULL class _STLP_CLASS_DECLSPEC char_traits<char> 
 
214
  : public __char_traits_base<char, int>
 
215
{
 
216
public:
 
217
  typedef char char_type;
 
218
  typedef int int_type;
 
219
#ifdef _STLP_USE_NEW_IOSTREAMS
 
220
  typedef streamoff off_type;
 
221
# ifndef _STLP_NO_MBSTATE_T
 
222
  typedef streampos pos_type;
 
223
  typedef mbstate_t state_type;
 
224
# endif
 
225
#endif /* _STLP_USE_NEW_IOSTREAMS */
 
226
 
 
227
  static char _STLP_CALL to_char_type(const int& __c) {
 
228
    return (char)(unsigned char)__c;
 
229
  }
 
230
 
 
231
  static int _STLP_CALL to_int_type(const char& __c) {
 
232
    return (unsigned char)__c;
 
233
  }
 
234
 
 
235
  static int _STLP_CALL compare(const char* __s1, const char* __s2, size_t __n) 
 
236
    { return memcmp(__s1, __s2, __n); }
 
237
  
 
238
  static size_t _STLP_CALL length(const char* __s) { return strlen(__s); }
 
239
 
 
240
  static void _STLP_CALL assign(char& __c1, const char& __c2) { __c1 = __c2; }
 
241
 
 
242
  static char* _STLP_CALL assign(char* __s, size_t __n, char __c)
 
243
    { memset(__s, __c, __n); return __s; }
 
244
};
 
245
 
 
246
# if defined (_STLP_HAS_WCHAR_T)
 
247
// Specialization for wchar_t.
 
248
_STLP_TEMPLATE_NULL class _STLP_CLASS_DECLSPEC char_traits<wchar_t>
 
249
  : public __char_traits_base<wchar_t, wint_t>
 
250
{};
 
251
# endif
 
252
 
 
253
_STLP_END_NAMESPACE
 
254
 
 
255
# else /* OWN_IOSTREAMS */
 
256
 
 
257
#  include <wrap_std/iosfwd>
 
258
 
 
259
# endif /* OWN_IOSTREAMS */
 
260
 
 
261
#endif /* _STLP_CHAR_TRAITS_H */
 
262
 
 
263
// Local Variables:
 
264
// mode:C++
 
265
// End:
 
266