Benjamin Kosnik - Re: user-defined types and basic_string (original) (raw)

This is the mail archive of the libstdc++@gcc.gnu.orgmailing list for the libstdc++ project.

• From: Benjamin Kosnik
• To: Gabriel Dos Reis
• Cc: libstdc++ at gcc dot gnu dot org
• Date: Mon, 26 Aug 2002 12:00:59 -0700
• Subject: Re: user-defined types and basic_string
• Organization: Red Hat / San Francisco
• References: <200208231731.g7NHV7Q02241@fillmore.constant.com><m37kihv4eq.fsf@soliton.integrable-solutions.net>

For archival purposes.... I find the aggregate syntax pretty awkward, but seemingly there is no way around this, due to limits on specializing namespace std:: types with builtins.

With Gaby's changes:

#include #include

template struct character { typedef T value_type; value_type value; };

template inline bool operator==(character lhs, character rhs) { return lhs.value == rhs.value; }

template inline bool operator<(character lhs, character rhs) { return lhs.value < rhs.value; }

// Provide std::char_traits specialization. namespace std { template struct char_traits<character > { typedef character char_type;

  // NB: this type should be bigger than char_type, so as to
  // properly hold EOF values in addition to the full range of
  // char_type values.
  typedef int  		int_type;

  typedef streampos 	pos_type;
  typedef streamoff 	off_type;
  typedef mbstate_t 	state_type;
  
  static void 
  assign(char_type& __c1, const char_type& __c2)
  { __c1 = __c2; }

  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 int 
  compare(const char_type* __s1, const char_type* __s2, size_t __n)
  { 
for (size_t __i = 0; __i < __n; ++__i)
  if (!eq(__s1[__i], __s2[__i]))
    return lt(__s1[__i], __s2[__i]) ? -1 : 1;
return 0; 
  }

  static size_t
  length(const char_type* __s)
  { 
const char_type* __p = __s; 
while (*__p) ++__p; 
return (__p - __s); 
  }

  static const char_type* 
  find(const char_type* __s, size_t __n, const char_type& __a)
  { 
for (const char_type* __p = __s; size_t(__p - __s) < __n; ++__p)
  if (*__p == __a) return __p;
return 0;
  }

  static char_type* 
  move(char_type* __s1, const char_type* __s2, size_t __n)
  { return (char_type*) memmove(__s1, __s2, __n * sizeof(char_type)); }

  static char_type* 
  copy(char_type* __s1, const char_type* __s2, size_t __n)
  { return (char_type*) memcpy(__s1, __s2, __n * sizeof(char_type)); }

  static char_type* 
  assign(char_type* __s, size_t __n, char_type __a)
  { 
for (char_type* __p = __s; __p < __s + __n; ++__p) 
  assign(*__p, __a);
    return __s; 
  }

  static char_type 
  to_char_type(const int_type& __c)
  {
char_type __r = { __c };
return __r;
  }

  static int_type 
  to_int_type(const char_type& __c) 
  { return int_type(__c.value); }

  static bool 
  eq_int_type(const int_type& __c1, const int_type& __c2)
  { return __c1 == __c2; }

  static int_type 
  eof() { return static_cast<int_type>(-1); }

  static int_type 
  not_eof(const int_type& __c)
  { return eq_int_type(__c, eof()) ? int_type(0) : __c; }
};

};

int main() { using namespace std;

typedef unsigned short value_type; typedef character char_type; typedef char_traits traits_type;

bool test = true;

// 1 char_type <-> value_type conversions value_type uc1 = 'c'; value_type uc2 = 'd'; char_type c1 = { uc1 }; char_type c2 = { uc2 }; test = !(c1 == c2);

// 2 char_traits test = traits_type::eq(c1, c2);

// 3 basic_string typedef basic_string string_type; string_type str; char_type c3 = { value_type('b') }; char_type c4 = { value_type('o') }; char_type c5 = { value_type('r') }; char_type c6 = { value_type('a') }; char_type c7 = { value_type('c') }; char_type c8 = { value_type('a') }; char_type c9 = { value_type('y') }; str += c3; str += c4; str += c5; str += c6; str += c7; str += c8; str += c9; string_type::size_type len = str.size(); const char_type* arr = str.c_str();

return 0; }

• Follow-Ups:
  • Re: user-defined types and basic_string
    * From: Gabriel Dos Reis
• References:
  • user-defined types and basic_string
    * From: Benjamin Kosnik
  • Re: user-defined types and basic_string
    * From: Gabriel Dos Reis