include/c++/stl/stl/_string_operators.h

   1 /*
   2  * Copyright (c) 2003
   3  * Francois Dumont
   4  *
   5  * This material is provided "as is", with absolutely no warranty expressed
   6  * or implied. Any use is at your own risk.
   7  *
   8  * Permission to use or copy this software for any purpose is hereby granted
   9  * without fee, provided the above notices are retained on all copies.
  10  * Permission to modify the code and to distribute modified code is granted,
  11  * provided the above notices are retained, and a notice that the code was
  12  * modified is included with the above copyright notice.
  13  *
  14  */
  15
  16 #ifndef _STLP_STRING_OPERATORS_H
  17 #define _STLP_STRING_OPERATORS_H
  18
  19 _STLP_BEGIN_NAMESPACE
  20
  21 #if !defined (_STLP_USE_TEMPLATE_EXPRESSION)
  22
  23 #  if defined (__GNUC__) || defined (__MLCCPP__)
  24 #    define _STLP_INIT_AMBIGUITY 1
  25 #  endif
  26
  27 template <class _CharT, class _Traits, class _Alloc>
  28 inline basic_string<_CharT,_Traits,_Alloc> _STLP_CALL
  29 operator+(const basic_string<_CharT,_Traits,_Alloc>& __s,
  30           const basic_string<_CharT,_Traits,_Alloc>& __y) {
  31   typedef basic_string<_CharT,_Traits,_Alloc> _Str;
  32   typedef typename _Str::_Reserve_t _Reserve_t;
  33 #  if defined (_STLP_INIT_AMBIGUITY)
  34   // gcc counts this as a function
  35   _Str __result  = _Str(_Reserve_t(), __s.size() + __y.size(), __s.get_allocator());
  36 #  else
  37   _Str __result(_Reserve_t(), __s.size() + __y.size(), __s.get_allocator());
  38 #  endif
  39   __result.append(__s);
  40   __result.append(__y);
  41   return __result;
  42 }
  43
  44 template <class _CharT, class _Traits, class _Alloc>
  45 inline basic_string<_CharT,_Traits,_Alloc> _STLP_CALL
  46 operator+(const _CharT* __s,
  47           const basic_string<_CharT,_Traits,_Alloc>& __y) {
  48   _STLP_FIX_LITERAL_BUG(__s)
  49   typedef basic_string<_CharT,_Traits,_Alloc> _Str;
  50   typedef typename _Str::_Reserve_t _Reserve_t;
  51   const size_t __n = _Traits::length(__s);
  52 #  if defined (_STLP_INIT_AMBIGUITY)
  53   _Str __result = _Str(_Reserve_t(), __n + __y.size(), __y.get_allocator());
  54 #  else
  55   _Str __result(_Reserve_t(), __n + __y.size(), __y.get_allocator());
  56 #  endif
  57   __result.append(__s, __s + __n);
  58   __result.append(__y);
  59   return __result;
  60 }
  61
  62 template <class _CharT, class _Traits, class _Alloc>
  63 inline basic_string<_CharT,_Traits,_Alloc> _STLP_CALL
  64 operator+(_CharT __c,
  65           const basic_string<_CharT,_Traits,_Alloc>& __y) {
  66   typedef basic_string<_CharT,_Traits,_Alloc> _Str;
  67   typedef typename _Str::_Reserve_t _Reserve_t;
  68 #  if defined (_STLP_INIT_AMBIGUITY)
  69   _Str __result = _Str(_Reserve_t(), 1 + __y.size(), __y.get_allocator());
  70 #  else
  71   _Str __result(_Reserve_t(), 1 + __y.size(), __y.get_allocator());
  72 #  endif
  73   __result.push_back(__c);
  74   __result.append(__y);
  75   return __result;
  76 }
  77
  78 template <class _CharT, class _Traits, class _Alloc>
  79 inline basic_string<_CharT,_Traits,_Alloc> _STLP_CALL
  80 operator+(const basic_string<_CharT,_Traits,_Alloc>& __x,
  81           const _CharT* __s) {
  82   _STLP_FIX_LITERAL_BUG(__s)
  83   typedef basic_string<_CharT,_Traits,_Alloc> _Str;
  84   typedef typename _Str::_Reserve_t _Reserve_t;
  85   const size_t __n = _Traits::length(__s);
  86 #  if defined (_STLP_INIT_AMBIGUITY)
  87   _Str __result = _Str(_Reserve_t(), __x.size() + __n, __x.get_allocator());
  88 #  else
  89   _Str __result(_Reserve_t(), __x.size() + __n, __x.get_allocator());
  90 #  endif
  91   __result.append(__x);
  92   __result.append(__s, __s + __n);
  93   return __result;
  94 }
  95
  96 template <class _CharT, class _Traits, class _Alloc>
  97 inline basic_string<_CharT,_Traits,_Alloc> _STLP_CALL
  98 operator+(const basic_string<_CharT,_Traits,_Alloc>& __x,
  99           const _CharT __c) {
 100   typedef basic_string<_CharT,_Traits,_Alloc> _Str;
 101   typedef typename _Str::_Reserve_t _Reserve_t;
 102 #  if defined (_STLP_INIT_AMBIGUITY)
 103   _Str __result = _Str(_Reserve_t(), __x.size() + 1, __x.get_allocator());
 104 #  else
 105   _Str __result(_Reserve_t(), __x.size() + 1, __x.get_allocator());
 106 #  endif
 107   __result.append(__x);
 108   __result.push_back(__c);
 109   return __result;
 110 }
 111
 112 #  undef _STLP_INIT_AMBIGUITY
 113
 114 #else /* _STLP_USE_TEMPLATE_EXPRESSION */
 115
 116 // addition with basic_string
 117 template <class _CharT, class _Traits, class _Alloc>
 118 inline _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc,
 119                              _STLP_PRIV __bstr_wrapper<_CharT,_Traits,_Alloc>,
 120                              _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc,
 121                                                    _STLP_PRIV __bstr_wrapper<_CharT,_Traits,_Alloc>,
 122                                                    _STLP_PRIV __sum_storage_elem<_CharT, _Traits, _Alloc>,
 123                                                    _STLP_PRIV __on_right>,
 124                              _STLP_PRIV __on_right> _STLP_CALL
 125 operator+(const basic_string<_CharT,_Traits,_Alloc>& __lhs,
 126           const basic_string<_CharT,_Traits,_Alloc>& __rhs) {
 127   typedef _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _STLP_PRIV __bstr_wrapper<_CharT,_Traits,_Alloc>,
 128                                                          _STLP_PRIV __sum_storage_elem<_CharT, _Traits, _Alloc>,
 129                                                          _STLP_PRIV __on_right> __root_type;
 130   __root_type __root(__rhs, _STLP_PRIV __sum_storage_elem<_CharT, _Traits, _Alloc>(__lhs.get_allocator()));
 131   return _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _STLP_PRIV __bstr_wrapper<_CharT,_Traits,_Alloc>,
 132                                                         __root_type,
 133                                                         _STLP_PRIV __on_right>(__lhs, __root);
 134 }
 135
 136 template <class _CharT, class _Traits, class _Alloc, class _Left, class _Right, class _StorageDir>
 137 inline _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc,
 138                              _STLP_PRIV __bstr_wrapper<_CharT,_Traits,_Alloc>,
 139                              _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _Left, _Right, _StorageDir>,
 140                              _STLP_PRIV __on_right> _STLP_CALL
 141 operator+(const basic_string<_CharT,_Traits,_Alloc>& __lhs,
 142           const _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _Left, _Right, _StorageDir>& __rhs) {
 143   return _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _STLP_PRIV __bstr_wrapper<_CharT,_Traits,_Alloc>,
 144                                                         _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _Left, _Right, _StorageDir>,
 145                                                         _STLP_PRIV __on_right>(__lhs, __rhs);
 146 }
 147
 148 template <class _CharT, class _Traits, class _Alloc, class _Left, class _Right, class _StorageDir>
 149 inline _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc,
 150                              _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _Left, _Right, _StorageDir>,
 151                              _STLP_PRIV __bstr_wrapper<_CharT,_Traits,_Alloc>,
 152                              _STLP_PRIV __on_left> _STLP_CALL
 153 operator+(const _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _Left, _Right, _StorageDir>& __lhs,
 154           const basic_string<_CharT,_Traits,_Alloc>& __rhs) {
 155   return _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _Left, _Right, _StorageDir>,
 156                                                         _STLP_PRIV __bstr_wrapper<_CharT,_Traits,_Alloc>,
 157                                                         _STLP_PRIV __on_left>(__lhs, __rhs);
 158 }
 159
 160 // addition with C string
 161 template <class _CharT, class _Traits, class _Alloc>
 162 inline _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc,
 163                              _STLP_PRIV __bstr_wrapper<_CharT,_Traits,_Alloc>,
 164                              _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc,
 165                                                    _STLP_PRIV __cstr_wrapper<_CharT>,
 166                                                    _STLP_PRIV __sum_storage_elem<_CharT, _Traits, _Alloc>,
 167                                                    _STLP_PRIV __on_right>,
 168                              _STLP_PRIV __on_right> _STLP_CALL
 169 operator+(const basic_string<_CharT,_Traits,_Alloc>& __x,
 170           const _CharT* __s) {
 171   const size_t __n = _Traits::length(__s);
 172   typedef _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _STLP_PRIV __cstr_wrapper<_CharT>,
 173                                                          _STLP_PRIV __sum_storage_elem<_CharT, _Traits, _Alloc>,
 174                                                          _STLP_PRIV __on_right> __root_type;
 175   __root_type __root(_STLP_PRIV __cstr_wrapper<_CharT>(__s, __n), _STLP_PRIV __sum_storage_elem<_CharT, _Traits, _Alloc>(__x.get_allocator()));
 176   return _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _STLP_PRIV __bstr_wrapper<_CharT,_Traits,_Alloc>,
 177                                                         __root_type, _STLP_PRIV __on_right>(__x, __root);
 178 }
 179
 180 template <class _CharT, class _Traits, class _Alloc>
 181 inline _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc,
 182                              _STLP_PRIV __cstr_wrapper<_CharT>,
 183                              _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc,
 184                                                    _STLP_PRIV __bstr_wrapper<_CharT,_Traits,_Alloc>,
 185                                                    _STLP_PRIV __sum_storage_elem<_CharT, _Traits, _Alloc>,
 186                                                    _STLP_PRIV __on_right>,
 187                              _STLP_PRIV __on_right> _STLP_CALL
 188 operator+(const _CharT* __s,
 189           const basic_string<_CharT,_Traits,_Alloc>& __y) {
 190   const size_t __n = _Traits::length(__s);
 191   typedef _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _STLP_PRIV __bstr_wrapper<_CharT,_Traits,_Alloc>,
 192                                                          _STLP_PRIV __sum_storage_elem<_CharT, _Traits, _Alloc>,
 193                                                          _STLP_PRIV __on_right> __root_type;
 194   __root_type __root(__y, _STLP_PRIV __sum_storage_elem<_CharT, _Traits, _Alloc>(__y.get_allocator()));
 195   return _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _STLP_PRIV __cstr_wrapper<_CharT>,
 196                                                         __root_type,
 197                                                         _STLP_PRIV __on_right>(_STLP_PRIV __cstr_wrapper<_CharT>(__s, __n), __root);
 198 }
 199
 200 template <class _CharT, class _Traits, class _Alloc, class _Left, class _Right, class _StorageDir>
 201 inline _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc,
 202                              _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _Left, _Right, _StorageDir>,
 203                              _STLP_PRIV __cstr_wrapper<_CharT>,
 204                              _STLP_PRIV __on_left> _STLP_CALL
 205 operator+(const _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _Left, _Right, _StorageDir>& __x,
 206           const _CharT* __s) {
 207   const size_t __n = _Traits::length(__s);
 208   return _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _Left, _Right, _StorageDir>,
 209                                                         _STLP_PRIV __cstr_wrapper<_CharT>,
 210                                                         _STLP_PRIV __on_left>(__x, _STLP_PRIV __cstr_wrapper<_CharT>(__s, __n));
 211 }
 212
 213 template <class _CharT, class _Traits, class _Alloc, class _Left, class _Right, class _StorageDir>
 214 inline _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc,
 215                              _STLP_PRIV __cstr_wrapper<_CharT>,
 216                              _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _Left, _Right, _StorageDir>,
 217                              _STLP_PRIV __on_right> _STLP_CALL
 218 operator+(const _CharT* __s,
 219           const _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _Left, _Right, _StorageDir>& __y) {
 220   const size_t __n = _Traits::length(__s);
 221   return _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _STLP_PRIV __cstr_wrapper<_CharT>,
 222                                                         _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _Left, _Right, _StorageDir>,
 223                                                         _STLP_PRIV __on_right>(_STLP_PRIV __cstr_wrapper<_CharT>(__s, __n), __y);
 224 }
 225
 226 // addition with char
 227 template <class _CharT, class _Traits, class _Alloc>
 228 inline _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc,
 229                              _STLP_PRIV __bstr_wrapper<_CharT,_Traits,_Alloc>,
 230                              _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc,
 231                                                    _STLP_PRIV __char_wrapper<_CharT>,
 232                                                    _STLP_PRIV __sum_storage_elem<_CharT, _Traits, _Alloc>,
 233                                                    _STLP_PRIV __on_right>,
 234                              _STLP_PRIV __on_right> _STLP_CALL
 235 operator+(const basic_string<_CharT,_Traits,_Alloc>& __x, const _CharT __c) {
 236   typedef _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _STLP_PRIV __char_wrapper<_CharT>,
 237                                                          _STLP_PRIV __sum_storage_elem<_CharT, _Traits, _Alloc>,
 238                                                          _STLP_PRIV __on_right> __root_type;
 239   __root_type __root(__c, _STLP_PRIV __sum_storage_elem<_CharT, _Traits, _Alloc>(__x.get_allocator()));
 240   return _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _STLP_PRIV __bstr_wrapper<_CharT,_Traits,_Alloc>,
 241                                                         __root_type, _STLP_PRIV __on_right>(__x, __root);
 242 }
 243
 244 template <class _CharT, class _Traits, class _Alloc>
 245 inline _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc,
 246                              _STLP_PRIV __char_wrapper<_CharT>,
 247                              _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc,
 248                                                    _STLP_PRIV __bstr_wrapper<_CharT,_Traits,_Alloc>,
 249                                                    _STLP_PRIV __sum_storage_elem<_CharT, _Traits, _Alloc>,
 250                                                    _STLP_PRIV __on_right>,
 251                              _STLP_PRIV __on_right> _STLP_CALL
 252 operator+(const _CharT __c, const basic_string<_CharT,_Traits,_Alloc>& __x) {
 253   typedef _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _STLP_PRIV __bstr_wrapper<_CharT,_Traits,_Alloc>,
 254                                                          _STLP_PRIV __sum_storage_elem<_CharT, _Traits, _Alloc>,
 255                                                          _STLP_PRIV __on_right> __root_type;
 256   __root_type __root(__x, _STLP_PRIV __sum_storage_elem<_CharT, _Traits, _Alloc>(__x.get_allocator()));
 257   return _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _STLP_PRIV __char_wrapper<_CharT>,
 258                                                         __root_type, _STLP_PRIV __on_right>(__c, __root);
 259 }
 260
 261 template <class _CharT, class _Traits, class _Alloc, class _Left, class _Right, class _StorageDir>
 262 inline _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc,
 263                              _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _Left, _Right, _StorageDir>,
 264                              _STLP_PRIV __char_wrapper<_CharT>,
 265                              _STLP_PRIV __on_left> _STLP_CALL
 266 operator+(const _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _Left, _Right, _StorageDir>& __x, const _CharT __c) {
 267   return _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _Left, _Right, _StorageDir>,
 268                                                         _STLP_PRIV __char_wrapper<_CharT>, _STLP_PRIV __on_left>(__x, __c);
 269 }
 270
 271 template <class _CharT, class _Traits, class _Alloc, class _Left, class _Right, class _StorageDir>
 272 inline _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _STLP_PRIV __char_wrapper<_CharT>,
 273                                                       _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _Left, _Right, _StorageDir>,
 274                                                       _STLP_PRIV __on_right> _STLP_CALL
 275 operator+(const _CharT __c, const _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _Left, _Right, _StorageDir>& __x) {
 276   return _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _STLP_PRIV __char_wrapper<_CharT>,
 277                                                         _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _Left, _Right, _StorageDir>,
 278                                                         _STLP_PRIV __on_right>(__c, __x);
 279 }
 280
 281 #endif /* _STLP_USE_TEMPLATE_EXPRESSION */
 282
 283 // Operator== and operator!=
 284
 285 template <class _CharT, class _Traits, class _Alloc>
 286 inline bool _STLP_CALL
 287 operator==(const basic_string<_CharT,_Traits,_Alloc>& __x,
 288            const basic_string<_CharT,_Traits,_Alloc>& __y) {
 289   return __x.size() == __y.size() && _Traits::compare(__x.data(), __y.data(), __x.size()) == 0;
 290 }
 291
 292 #if defined (_STLP_USE_TEMPLATE_EXPRESSION)
 293 template <class _CharT, class _Traits, class _Alloc, class _Lhs, class _Rhs, class _StoreDir>
 294 inline bool _STLP_CALL
 295 operator==(const _STLP_PRIV __bstr_sum<_CharT,_Traits,_Alloc,_Lhs,_Rhs,_StoreDir>& __x,
 296            const basic_string<_CharT,_Traits,_Alloc>& __y) {
 297   return __x.size() == __y.size() && _Traits::compare(__x.data(), __y.data(), __x.size()) == 0;
 298 }
 299
 300 template <class _CharT, class _Traits, class _Alloc, class _Lhs, class _Rhs, class _StoreDir>
 301 inline bool _STLP_CALL
 302 operator==(const basic_string<_CharT,_Traits,_Alloc>& __x,
 303            const _STLP_PRIV __bstr_sum<_CharT,_Traits,_Alloc,_Lhs,_Rhs,_StoreDir>& __y) {
 304   return __x.size() == __y.size() && _Traits::compare(__x.data(), __y.data(), __x.size()) == 0;
 305 }
 306 #endif /* _STLP_USE_TEMPLATE_EXPRESSION */
 307
 308
 309 template <class _CharT, class _Traits, class _Alloc>
 310 inline bool _STLP_CALL
 311 operator==(const _CharT* __s,
 312            const basic_string<_CharT,_Traits,_Alloc>& __y) {
 313   _STLP_FIX_LITERAL_BUG(__s)
 314   size_t __n = _Traits::length(__s);
 315   return __n == __y.size() && _Traits::compare(__s, __y.data(), __n) == 0;
 316 }
 317
 318 template <class _CharT, class _Traits, class _Alloc>
 319 inline bool _STLP_CALL
 320 operator==(const basic_string<_CharT,_Traits,_Alloc>& __x,
 321            const _CharT* __s) {
 322   _STLP_FIX_LITERAL_BUG(__s)
 323   size_t __n = _Traits::length(__s);
 324   return __x.size() == __n && _Traits::compare(__x.data(), __s, __n) == 0;
 325 }
 326
 327 #if defined (_STLP_USE_TEMPLATE_EXPRESSION)
 328 template <class _CharT, class _Traits, class _Alloc, class _Lhs, class _Rhs, class _StoreDir>
 329 inline bool _STLP_CALL
 330 operator==(const _CharT* __s,
 331            const _STLP_PRIV __bstr_sum<_CharT,_Traits,_Alloc,_Lhs,_Rhs,_StoreDir>& __y) {
 332   _STLP_FIX_LITERAL_BUG(__s)
 333   size_t __n = _Traits::length(__s);
 334   return __n == __y.size() && _Traits::compare(__s, __y.data(), __n) == 0;
 335 }
 336
 337 template <class _CharT, class _Traits, class _Alloc, class _Lhs, class _Rhs, class _StoreDir>
 338 inline bool _STLP_CALL
 339 operator==(const _STLP_PRIV __bstr_sum<_CharT,_Traits,_Alloc,_Lhs,_Rhs,_StoreDir>& __x,
 340            const _CharT* __s) {
 341   _STLP_FIX_LITERAL_BUG(__s)
 342   size_t __n = _Traits::length(__s);
 343   return __x.size() == __n && _Traits::compare(__x.data(), __s, __n) == 0;
 344 }
 345 #endif /* _STLP_USE_TEMPLATE_EXPRESSION */
 346
 347 // Operator< (and also >, <=, and >=).
 348
 349 template <class _CharT, class _Traits, class _Alloc>
 350 inline bool _STLP_CALL
 351 operator<(const basic_string<_CharT,_Traits,_Alloc>& __x,
 352           const basic_string<_CharT,_Traits,_Alloc>& __y) {
 353   return basic_string<_CharT,_Traits,_Alloc> ::_M_compare(__x.begin(), __x.end(),
 354                                                           __y.begin(), __y.end()) < 0;
 355 }
 356
 357 #if defined (_STLP_USE_TEMPLATE_EXPRESSION)
 358 template <class _CharT, class _Traits, class _Alloc, class _Lhs, class _Rhs, class _StoreDir>
 359 inline bool _STLP_CALL
 360 operator<(const _STLP_PRIV __bstr_sum<_CharT,_Traits,_Alloc,_Lhs,_Rhs,_StoreDir>& __x,
 361           const basic_string<_CharT,_Traits,_Alloc>& __y) {
 362   return basic_string<_CharT,_Traits,_Alloc> ::_M_compare(__x.begin(), __x.end(),
 363                                                           __y.begin(), __y.end()) < 0;
 364 }
 365
 366 template <class _CharT, class _Traits, class _Alloc, class _Lhs, class _Rhs, class _StoreDir>
 367 inline bool _STLP_CALL
 368 operator<(const basic_string<_CharT,_Traits,_Alloc>& __x,
 369           const _STLP_PRIV __bstr_sum<_CharT,_Traits,_Alloc,_Lhs,_Rhs,_StoreDir>& __y) {
 370   return basic_string<_CharT,_Traits,_Alloc> ::_M_compare(__x.begin(), __x.end(),
 371                                                           __y.begin(), __y.end()) < 0;
 372 }
 373 #endif /* _STLP_USE_TEMPLATE_EXPRESSION */
 374
 375 template <class _CharT, class _Traits, class _Alloc>
 376 inline bool _STLP_CALL
 377 operator<(const _CharT* __s,
 378           const basic_string<_CharT,_Traits,_Alloc>& __y) {
 379   _STLP_FIX_LITERAL_BUG(__s)
 380   size_t __n = _Traits::length(__s);
 381   return basic_string<_CharT,_Traits,_Alloc> ::_M_compare(__s, __s + __n,
 382                                                           __y.begin(), __y.end()) < 0;
 383 }
 384
 385 template <class _CharT, class _Traits, class _Alloc>
 386 inline bool _STLP_CALL
 387 operator<(const basic_string<_CharT,_Traits,_Alloc>& __x,
 388           const _CharT* __s) {
 389   _STLP_FIX_LITERAL_BUG(__s)
 390   size_t __n = _Traits::length(__s);
 391   return basic_string<_CharT,_Traits,_Alloc> ::_M_compare(__x.begin(), __x.end(),
 392                                                           __s, __s + __n) < 0;
 393 }
 394
 395 #if defined (_STLP_USE_TEMPLATE_EXPRESSION)
 396 template <class _CharT, class _Traits, class _Alloc, class _Lhs, class _Rhs, class _StoreDir>
 397 inline bool _STLP_CALL
 398 operator<(const _CharT* __s,
 399           const _STLP_PRIV __bstr_sum<_CharT,_Traits,_Alloc,_Lhs,_Rhs,_StoreDir>& __y) {
 400   _STLP_FIX_LITERAL_BUG(__s)
 401   size_t __n = _Traits::length(__s);
 402   return basic_string<_CharT,_Traits,_Alloc> ::_M_compare(__s, __s + __n,
 403                                                           __y.begin(), __y.end()) < 0;
 404 }
 405
 406 template <class _CharT, class _Traits, class _Alloc, class _Lhs, class _Rhs, class _StoreDir>
 407 inline bool _STLP_CALL
 408 operator<(const _STLP_PRIV __bstr_sum<_CharT,_Traits,_Alloc,_Lhs,_Rhs,_StoreDir>& __x,
 409           const _CharT* __s) {
 410   _STLP_FIX_LITERAL_BUG(__s)
 411   size_t __n = _Traits::length(__s);
 412   return basic_string<_CharT,_Traits,_Alloc> ::_M_compare(__x.begin(), __x.end(),
 413                                                           __s, __s + __n) < 0;
 414 }
 415 #endif /* _STLP_USE_TEMPLATE_EXPRESSION */
 416
 417 #if defined (_STLP_USE_SEPARATE_RELOPS_NAMESPACE)
 418
 419 /* Only defined if _STLP_USE_SEPARATE_RELOPS_NAMESPACE is defined otherwise
 420  * it might introduce ambiguity with pure template relational operators
 421  * from rel_ops namespace.
 422  */
 423 template <class _CharT, class _Traits, class _Alloc>
 424 inline bool _STLP_CALL
 425 operator!=(const basic_string<_CharT,_Traits,_Alloc>& __x,
 426            const basic_string<_CharT,_Traits,_Alloc>& __y)
 427 { return !(__x == __y); }
 428
 429 template <class _CharT, class _Traits, class _Alloc>
 430 inline bool _STLP_CALL
 431 operator>(const basic_string<_CharT,_Traits,_Alloc>& __x,
 432           const basic_string<_CharT,_Traits,_Alloc>& __y)
 433 { return __y < __x; }
 434
 435 template <class _CharT, class _Traits, class _Alloc>
 436 inline bool _STLP_CALL
 437 operator<=(const basic_string<_CharT,_Traits,_Alloc>& __x,
 438            const basic_string<_CharT,_Traits,_Alloc>& __y)
 439 { return !(__y < __x); }
 440
 441 template <class _CharT, class _Traits, class _Alloc>
 442 inline bool _STLP_CALL
 443 operator>=(const basic_string<_CharT,_Traits,_Alloc>& __x,
 444            const basic_string<_CharT,_Traits,_Alloc>& __y)
 445 { return !(__x < __y); }
 446
 447 #  if defined (_STLP_USE_TEMPLATE_EXPRESSION)
 448 template <class _CharT, class _Traits, class _Alloc, class _Lhs, class _Rhs, class _StoreDir>
 449 inline bool _STLP_CALL
 450 operator!=(const _STLP_PRIV __bstr_sum<_CharT,_Traits,_Alloc,_Lhs,_Rhs,_StoreDir>& __x,
 451            const basic_string<_CharT,_Traits,_Alloc>& __y)
 452 { return !(__x==__y); }
 453
 454 template <class _CharT, class _Traits, class _Alloc, class _Lhs, class _Rhs, class _StoreDir>
 455 inline bool _STLP_CALL
 456 operator!=(const basic_string<_CharT,_Traits,_Alloc>& __x,
 457            const _STLP_PRIV __bstr_sum<_CharT,_Traits,_Alloc,_Lhs,_Rhs,_StoreDir>& __y)
 458 { return !(__x==__y); }
 459 #  endif
 460
 461 #endif /* _STLP_USE_SEPARATE_RELOPS_NAMESPACE */
 462
 463 template <class _CharT, class _Traits, class _Alloc>
 464 inline bool _STLP_CALL
 465 operator!=(const _CharT* __s,
 466            const basic_string<_CharT,_Traits,_Alloc>& __y) {
 467   _STLP_FIX_LITERAL_BUG(__s)
 468   return !(__s == __y);
 469 }
 470
 471 template <class _CharT, class _Traits, class _Alloc>
 472 inline bool _STLP_CALL
 473 operator!=(const basic_string<_CharT,_Traits,_Alloc>& __x,
 474            const _CharT* __s) {
 475   _STLP_FIX_LITERAL_BUG(__s)
 476   return !(__x == __s);
 477 }
 478
 479 #if defined (_STLP_USE_TEMPLATE_EXPRESSION)
 480 template <class _CharT, class _Traits, class _Alloc, class _Lhs, class _Rhs, class _StoreDir>
 481 inline bool _STLP_CALL
 482 operator!=(const _CharT* __s,
 483            const _STLP_PRIV __bstr_sum<_CharT,_Traits,_Alloc,_Lhs,_Rhs,_StoreDir>& __y) {
 484   _STLP_FIX_LITERAL_BUG(__s)
 485   return !(__s == __y);
 486 }
 487
 488 template <class _CharT, class _Traits, class _Alloc, class _Lhs, class _Rhs, class _StoreDir>
 489 inline bool _STLP_CALL
 490 operator!=(const _STLP_PRIV __bstr_sum<_CharT,_Traits,_Alloc,_Lhs,_Rhs,_StoreDir>& __x,
 491            const _CharT* __s) {
 492   _STLP_FIX_LITERAL_BUG(__s)
 493   return !(__x == __s);
 494 }
 495 #endif /* _STLP_USE_TEMPLATE_EXPRESSION */
 496
 497 template <class _CharT, class _Traits, class _Alloc>
 498 inline bool _STLP_CALL
 499 operator>(const _CharT* __s,
 500           const basic_string<_CharT,_Traits,_Alloc>& __y) {
 501   _STLP_FIX_LITERAL_BUG(__s)
 502   return __y < __s;
 503 }
 504
 505 template <class _CharT, class _Traits, class _Alloc>
 506 inline bool _STLP_CALL
 507 operator>(const basic_string<_CharT,_Traits,_Alloc>& __x,
 508           const _CharT* __s) {
 509   _STLP_FIX_LITERAL_BUG(__s)
 510   return __s < __x;
 511 }
 512
 513 #if defined (_STLP_USE_TEMPLATE_EXPRESSION)
 514 template <class _CharT, class _Traits, class _Alloc, class _Lhs, class _Rhs, class _StoreDir>
 515 inline bool _STLP_CALL
 516 operator>(const _CharT* __s,
 517           const _STLP_PRIV __bstr_sum<_CharT,_Traits,_Alloc,_Lhs,_Rhs,_StoreDir>& __y) {
 518   _STLP_FIX_LITERAL_BUG(__s)
 519   return __y < __s;
 520 }
 521
 522 template <class _CharT, class _Traits, class _Alloc, class _Lhs, class _Rhs, class _StoreDir>
 523 inline bool _STLP_CALL
 524 operator>(const _STLP_PRIV __bstr_sum<_CharT,_Traits,_Alloc,_Lhs,_Rhs,_StoreDir>& __x,
 525           const _CharT* __s) {
 526   _STLP_FIX_LITERAL_BUG(__s)
 527   return __s < __x;
 528 }
 529 #endif /* _STLP_USE_TEMPLATE_EXPRESSION */
 530
 531 template <class _CharT, class _Traits, class _Alloc>
 532 inline bool _STLP_CALL
 533 operator<=(const _CharT* __s,
 534            const basic_string<_CharT,_Traits,_Alloc>& __y) {
 535   _STLP_FIX_LITERAL_BUG(__s)
 536   return !(__y < __s);
 537 }
 538
 539 template <class _CharT, class _Traits, class _Alloc>
 540 inline bool _STLP_CALL
 541 operator<=(const basic_string<_CharT,_Traits,_Alloc>& __x,
 542            const _CharT* __s) {
 543   _STLP_FIX_LITERAL_BUG(__s)
 544   return !(__s < __x);
 545 }
 546
 547 #if defined (_STLP_USE_TEMPLATE_EXPRESSION)
 548 template <class _CharT, class _Traits, class _Alloc, class _Lhs, class _Rhs, class _StoreDir>
 549 inline bool _STLP_CALL
 550 operator<=(const _CharT* __s,
 551            const _STLP_PRIV __bstr_sum<_CharT,_Traits,_Alloc,_Lhs,_Rhs,_StoreDir>& __y) {
 552   _STLP_FIX_LITERAL_BUG(__s)
 553   return !(__y < __s);
 554 }
 555
 556 template <class _CharT, class _Traits, class _Alloc, class _Lhs, class _Rhs, class _StoreDir>
 557 inline bool _STLP_CALL
 558 operator<=(const _STLP_PRIV __bstr_sum<_CharT,_Traits,_Alloc,_Lhs,_Rhs,_StoreDir>& __x,
 559            const _CharT* __s) {
 560   _STLP_FIX_LITERAL_BUG(__s)
 561   return !(__s < __x);
 562 }
 563 #endif /* _STLP_USE_TEMPLATE_EXPRESSION */
 564
 565 template <class _CharT, class _Traits, class _Alloc>
 566 inline bool _STLP_CALL
 567 operator>=(const _CharT* __s,
 568            const basic_string<_CharT,_Traits,_Alloc>& __y) {
 569   _STLP_FIX_LITERAL_BUG(__s)
 570   return !(__s < __y);
 571 }
 572
 573 template <class _CharT, class _Traits, class _Alloc>
 574 inline bool _STLP_CALL
 575 operator>=(const basic_string<_CharT,_Traits,_Alloc>& __x,
 576            const _CharT* __s) {
 577   _STLP_FIX_LITERAL_BUG(__s)
 578   return !(__x < __s);
 579 }
 580
 581 #if defined (_STLP_USE_TEMPLATE_EXPRESSION)
 582 template <class _CharT, class _Traits, class _Alloc, class _Lhs, class _Rhs, class _StoreDir>
 583 inline bool _STLP_CALL
 584 operator>=(const _CharT* __s,
 585            const _STLP_PRIV __bstr_sum<_CharT,_Traits,_Alloc,_Lhs,_Rhs,_StoreDir>& __y) {
 586   _STLP_FIX_LITERAL_BUG(__s)
 587   return !(__s < __y);
 588 }
 589
 590 template <class _CharT, class _Traits, class _Alloc, class _Lhs, class _Rhs, class _StoreDir>
 591 inline bool _STLP_CALL
 592 operator>=(const _STLP_PRIV __bstr_sum<_CharT,_Traits,_Alloc,_Lhs,_Rhs,_StoreDir>& __x,
 593            const _CharT* __s) {
 594   _STLP_FIX_LITERAL_BUG(__s)
 595   return !(__x < __s);
 596 }
 597 #endif /* _STLP_USE_TEMPLATE_EXPRESSION */
 598
 599 _STLP_END_NAMESPACE
 600
 601 #endif /* _STLP_STRING_OPERATORS_H */
 602