basic_stringstream with unsigned short

[wolverine]

Hi,
Given below is a traits with unsigned short. If i create a
stringstream with this traits will there be any problem.

//typedef unsigned short XMLCh;
//The XMLCh_traits is defined below

typedef std::basic_stri ng<unsigned short, XMLCh_traitsuSt ring;
typedef std::basic_stri ngstream<unsign ed short, XMLCh_traits>
uStringStream;

unsigned short result;
//the _U is macro which uses XMLString::tran scode
//to get a XMLCh* out of char*
uString str(_U("123"));
uStringStream stream(str);
stream>>result; // debugger showes this line causes aborting
cout<<result<<e ndl;

The program is getting ABORTED. Could any one tell me why ? The triats
used is as given below.

struct XMLCh_traits
{
typedef unsigned short char_type;

typedef unsigned int int_type;

typedef streampos pos_type;
typedef streamoff off_type;
typedef mbstate_t state_type;

static void assign(char_typ e& __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_typ e)); }

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

static char_type* assign(char_typ e* __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(co nst int_type& __c)
{ return char_type(__c); }

static int_type to_int_type(con st char_type& __c)
{ return int_type(__c); }

static bool eq_int_type(con st 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; }

};


Thanks in Advance
Kiran Pradeep.