include/wx/unichar.h

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Name:        wx/unichar.h
   3 // Purpose:     wxUniChar and wxUniCharRef classes
   4 // Author:      Vaclav Slavik
   5 // Created:     2007-03-19
   6 // RCS-ID:      $Id$
   7 // Copyright:   (c) 2007 REA Elektronik GmbH
   8 // Licence:     wxWindows licence
   9 ///////////////////////////////////////////////////////////////////////////////
  10
  11 #ifndef _WX_UNICHAR_H_
  12 #define _WX_UNICHAR_H_
  13
  14 #include "wx/defs.h"
  15 #include "wx/chartype.h"
  16
  17 class WXDLLIMPEXP_BASE wxUniCharRef;
  18
  19 // This class represents single Unicode character. It can be converted to
  20 // and from char or wchar_t and implements commonly used character operations.
  21 class WXDLLIMPEXP_BASE wxUniChar
  22 {
  23 public:
  24     // NB: this is not wchar_t on purpose, it needs to represent the entire
  25     //     Unicode code points range and wchar_t may be too small for that
  26     //     (e.g. on Win32 where wchar_t* is encoded in UTF-16)
  27     typedef wxUint32 value_type;
  28
  29     wxUniChar() : m_value(0) {}
  30
  31     // Create the character from 8bit character value encoded in the current
  32     // locale's charset.
  33     wxUniChar(char c) { m_value = From8bit(c); }
  34     wxUniChar(unsigned char c) { m_value = From8bit((char)c); }
  35
  36     // Create the character from a wchar_t character value.
  37     wxUniChar(wchar_t c) { m_value = c; }
  38
  39 #ifndef wxWINT_T_IS_TYPEDEF
  40     // Create the character from a wint_t character value.
  41     wxUniChar(wint_t c) { m_value = c; }
  42 #endif
  43
  44     wxUniChar(int c) { m_value = c; }
  45
  46     wxUniChar(const wxUniCharRef& c);
  47
  48     // Returns Unicode code point value of the character
  49     value_type GetValue() const { return m_value; }
  50
  51     // Casts to char and wchar_t types:
  52     operator char() const { return To8bit(m_value); }
  53     operator unsigned char() const { return (unsigned char)To8bit(m_value); }
  54     operator wchar_t() const { return m_value; }
  55 #ifndef wxWINT_T_IS_TYPEDEF
  56     operator wint_t() const { return m_value; }
  57 #endif
  58     operator int() const { return m_value; }
  59     operator unsigned int() const { return m_value; }
  60
  61     // We need this operator for the "*p" part of expressions like "for (
  62     // const_iterator p = begin() + nStart; *p; ++p )". In this case,
  63     // compilation would fail without it because the conversion to bool would
  64     // be ambiguous (there are all these int types conversions...). (And adding
  65     // operator unspecified_bool_type() would only makes the ambiguity worse.)
  66     operator bool() const { return m_value != 0; }
  67     bool operator!() const { return !((bool)*this); }
  68 #if (defined(__VISUALC__) && __VISUALC__ < 1400) || \
  69     defined(__DIGITALMARS__) || defined(__BORLANDC__)
  70     // We need this for VC++ < 8 or DigitalMars and expressions like
  71     // "str[0] && *p":
  72     bool operator&&(bool v) const { return (bool)*this && v; }
  73 #endif
  74
  75     // Assignment operators:
  76     wxUniChar& operator=(const wxUniChar& c) { m_value = c.m_value; return *this; }
  77     wxUniChar& operator=(char c) { m_value = From8bit(c); return *this; }
  78     wxUniChar& operator=(wchar_t c) { m_value = c; return *this; }
  79 #ifndef wxWINT_T_IS_TYPEDEF
  80     wxUniChar& operator=(wint_t c) { m_value = c; return *this; }
  81 #endif
  82
  83     // Comparision operators:
  84     bool operator==(const wxUniChar& c) const { return m_value == c.m_value; }
  85     bool operator==(char c) const { return m_value == From8bit(c); }
  86     bool operator==(wchar_t c) const { return m_value == (value_type)c; }
  87 #ifndef wxWINT_T_IS_TYPEDEF
  88     bool operator==(wint_t c) const { return m_value == (value_type)c; }
  89 #endif
  90
  91     bool operator!=(const wxUniChar& c) const { return m_value != c.m_value; }
  92     bool operator!=(char c) const { return m_value != From8bit(c); }
  93     bool operator!=(wchar_t c) const { return m_value != (value_type)c; }
  94 #ifndef wxWINT_T_IS_TYPEDEF
  95     bool operator!=(wint_t c) const { return m_value != (value_type)c; }
  96 #endif
  97
  98     bool operator>(const wxUniChar& c) const { return m_value > c.m_value; }
  99     bool operator>(char c) const { return m_value > (value_type)c; }
 100     bool operator>(wchar_t c) const { return m_value > (value_type)c; }
 101 #ifndef wxWINT_T_IS_TYPEDEF
 102     bool operator>(wint_t c) const { return m_value > (value_type)c; }
 103 #endif
 104
 105     bool operator<(const wxUniChar& c) const { return m_value < c.m_value; }
 106     bool operator<(char c) const { return m_value < From8bit(c); }
 107     bool operator<(wchar_t c) const { return m_value < (value_type)c; }
 108 #ifndef wxWINT_T_IS_TYPEDEF
 109     bool operator<(wint_t c) const { return m_value < (value_type)c; }
 110 #endif
 111
 112     bool operator>=(const wxUniChar& c) const { return m_value >= c.m_value; }
 113     bool operator>=(char c) const { return m_value >= From8bit(c); }
 114     bool operator>=(wchar_t c) const { return m_value >= (value_type)c; }
 115 #ifndef wxWINT_T_IS_TYPEDEF
 116     bool operator>=(wint_t c) const { return m_value >= (value_type)c; }
 117 #endif
 118
 119     bool operator<=(const wxUniChar& c) const { return m_value <= c.m_value; }
 120     bool operator<=(char c) const { return m_value <= From8bit(c); }
 121     bool operator<=(wchar_t c) const { return m_value <= (value_type)c; }
 122 #ifndef wxWINT_T_IS_TYPEDEF
 123     bool operator<=(wint_t c) const { return m_value <= (value_type)c; }
 124 #endif
 125
 126     int operator-(const wxUniChar& c) const { return m_value - c.m_value; }
 127     int operator-(char c) const { return m_value - From8bit(c); }
 128     int operator-(wchar_t c) const { return m_value - (value_type)c; }
 129 #ifndef wxWINT_T_IS_TYPEDEF
 130     int operator-(wint_t c) const { return m_value - (value_type)c; }
 131 #endif
 132
 133 private:
 134     static value_type From8bit(char c);
 135     static char To8bit(value_type c);
 136
 137 private:
 138     value_type m_value;
 139 };
 140
 141
 142 // Writeable reference to a character in wxString.
 143 //
 144 // This class can be used in the same way wxChar is used, except that changing
 145 // its value updates the underlying string object.
 146 class WXDLLIMPEXP_BASE wxUniCharRef
 147 {
 148 private:
 149     // create the reference
 150     // FIXME-UTF8: the interface will need changes for UTF-8 build
 151     wxUniCharRef(wxChar *pos) : m_pos(pos) {}
 152
 153 public:
 154     // NB: we have to make this public, because we don't have wxString
 155     //     declaration available here and so can't declare wxString::iterator
 156     //     as friend; so at least don't use a ctor but a static function
 157     //     that must be used explicitly (this is more than using 'explicit'
 158     //     keyword on ctor!):
 159     //
 160     // FIXME-UTF8: the interface will need changes for UTF-8 build
 161     static wxUniCharRef CreateForString(wxChar *pos)
 162         { return wxUniCharRef(pos); }
 163
 164     wxUniChar::value_type GetValue() const { return UniChar().GetValue(); }
 165
 166     // Assignment operators:
 167     wxUniCharRef& operator=(const wxUniCharRef& c)
 168     {
 169         *m_pos = *c.m_pos;
 170         return *this;
 171     };
 172
 173     wxUniCharRef& operator=(const wxUniChar& c)
 174     {
 175         *m_pos = c;
 176         return *this;
 177     };
 178
 179     wxUniCharRef& operator=(char c) { return *this = wxUniChar(c); }
 180     wxUniCharRef& operator=(wchar_t c) { return *this = wxUniChar(c); }
 181
 182     // Casts to wxUniChar type:
 183     operator char() const { return UniChar(); }
 184     operator unsigned char() const { return UniChar(); }
 185     operator wchar_t() const { return UniChar(); }
 186 #ifndef wxWINT_T_IS_TYPEDEF
 187     operator wint_t() const { return UniChar(); }
 188 #endif
 189     operator int() const { return UniChar(); }
 190     operator unsigned int() const { return UniChar(); }
 191
 192     // see wxUniChar::operator bool etc. for explanation
 193     operator bool() const { return (bool)UniChar(); }
 194     bool operator!() const { return !UniChar(); }
 195 #if (defined(__VISUALC__) && __VISUALC__ < 1400) || \
 196     defined(__DIGITALMARS__) || defined(__BORLANDC__)
 197     bool operator&&(bool v) const { return UniChar() && v; }
 198 #endif
 199
 200     // Comparision operators:
 201     bool operator==(const wxUniCharRef& c) const { return m_pos == c.m_pos; }
 202     bool operator==(const wxUniChar& c) const { return UniChar() == c; }
 203     bool operator==(char c) const { return UniChar() == c; }
 204     bool operator==(wchar_t c) const { return UniChar() == c; }
 205 #ifndef wxWINT_T_IS_TYPEDEF
 206     bool operator==(wint_t c) const { return UniChar() == c; }
 207 #endif
 208
 209     bool operator!=(const wxUniCharRef& c) const { return m_pos != c.m_pos; }
 210     bool operator!=(const wxUniChar& c) const { return UniChar() != c; }
 211     bool operator!=(char c) const { return UniChar() != c; }
 212     bool operator!=(wchar_t c) const { return UniChar() != c; }
 213 #ifndef wxWINT_T_IS_TYPEDEF
 214     bool operator!=(wint_t c) const { return UniChar() != c; }
 215 #endif
 216
 217     bool operator>(const wxUniCharRef& c) const { return UniChar() > c.UniChar(); }
 218     bool operator>(const wxUniChar& c) const { return UniChar() > c; }
 219     bool operator>(char c) const { return UniChar() > c; }
 220     bool operator>(wchar_t c) const { return UniChar() > c; }
 221 #ifndef wxWINT_T_IS_TYPEDEF
 222     bool operator>(wint_t c) const { return UniChar() > c; }
 223 #endif
 224
 225     bool operator<(const wxUniCharRef& c) const { return UniChar() < c.UniChar(); }
 226     bool operator<(const wxUniChar& c) const { return UniChar() < c; }
 227     bool operator<(char c) const { return UniChar() < c; }
 228     bool operator<(wchar_t c) const { return UniChar() < c; }
 229 #ifndef wxWINT_T_IS_TYPEDEF
 230     bool operator<(wint_t c) const { return UniChar() < c; }
 231 #endif
 232
 233     bool operator>=(const wxUniCharRef& c) const { return UniChar() >= c.UniChar(); }
 234     bool operator>=(const wxUniChar& c) const { return UniChar() >= c; }
 235     bool operator>=(char c) const { return UniChar() >= c; }
 236     bool operator>=(wchar_t c) const { return UniChar() >= c; }
 237 #ifndef wxWINT_T_IS_TYPEDEF
 238     bool operator>=(wint_t c) const { return UniChar() >= c; }
 239 #endif
 240
 241     bool operator<=(const wxUniCharRef& c) const { return UniChar() <= c.UniChar(); }
 242     bool operator<=(const wxUniChar& c) const { return UniChar() <= c; }
 243     bool operator<=(char c) const { return UniChar() <= c; }
 244     bool operator<=(wchar_t c) const { return UniChar() <= c; }
 245 #ifndef wxWINT_T_IS_TYPEDEF
 246     bool operator<=(wint_t c) const { return UniChar() <= c; }
 247 #endif
 248
 249     // for expressions like c-'A':
 250     int operator-(const wxUniCharRef& c) const { return UniChar() - c.UniChar(); }
 251     int operator-(const wxUniChar& c) const { return UniChar() - c; }
 252     int operator-(char c) const { return UniChar() - c; }
 253     int operator-(wchar_t c) const { return UniChar() - c; }
 254 #ifndef wxWINT_T_IS_TYPEDEF
 255     int operator-(wint_t c) const { return UniChar() - c; }
 256 #endif
 257
 258 private:
 259     wxUniChar UniChar() const { return *m_pos; }
 260     friend class WXDLLIMPEXP_BASE wxUniChar;
 261
 262 private:
 263     // pointer to the character in string
 264     wxChar *m_pos;
 265 };
 266
 267 inline wxUniChar::wxUniChar(const wxUniCharRef& c)
 268 {
 269     m_value = c.UniChar().m_value;
 270 }
 271
 272 // Comparision operators for the case when wxUniChar(Ref) is the second operand:
 273 inline bool operator==(char c1, const wxUniChar& c2) { return c2 == c1; }
 274 inline bool operator==(wchar_t c1, const wxUniChar& c2) { return c2 == c1; }
 275 #ifndef wxWINT_T_IS_TYPEDEF
 276 inline bool operator==(wint_t c1, const wxUniChar& c2) { return c2 == c1; }
 277 #endif
 278
 279 inline bool operator!=(char c1, const wxUniChar& c2) { return c2 != c1; }
 280 inline bool operator!=(wchar_t c1, const wxUniChar& c2) { return c2 != c1; }
 281 #ifndef wxWINT_T_IS_TYPEDEF
 282 inline bool operator!=(wint_t c1, const wxUniChar& c2) { return c2 != c1; }
 283 #endif
 284
 285 inline bool operator>(char c1, const wxUniChar& c2) { return c2 < c1; }
 286 inline bool operator>(wchar_t c1, const wxUniChar& c2) { return c2 < c1; }
 287 #ifndef wxWINT_T_IS_TYPEDEF
 288 inline bool operator>(wint_t c1, const wxUniChar& c2) { return c2 < c1; }
 289 #endif
 290
 291 inline bool operator<(char c1, const wxUniChar& c2) { return c2 > c1; }
 292 inline bool operator<(wchar_t c1, const wxUniChar& c2) { return c2 > c1; }
 293 #ifndef wxWINT_T_IS_TYPEDEF
 294 inline bool operator<(wint_t c1, const wxUniChar& c2) { return c2 > c1; }
 295 #endif
 296
 297 inline bool operator>=(char c1, const wxUniChar& c2) { return c2 <= c1; }
 298 inline bool operator>=(wchar_t c1, const wxUniChar& c2) { return c2 <= c1; }
 299 #ifndef wxWINT_T_IS_TYPEDEF
 300 inline bool operator>=(wint_t c1, const wxUniChar& c2) { return c2 <= c1; }
 301 #endif
 302
 303 inline bool operator<=(char c1, const wxUniChar& c2) { return c2 >= c1; }
 304 inline bool operator<=(wchar_t c1, const wxUniChar& c2) { return c2 >= c1; }
 305 #ifndef wxWINT_T_IS_TYPEDEF
 306 inline bool operator<=(wint_t c1, const wxUniChar& c2) { return c2 >= c1; }
 307 #endif
 308
 309
 310 inline bool operator==(char c1, const wxUniCharRef& c2) { return c2 == c1; }
 311 inline bool operator==(wchar_t c1, const wxUniCharRef& c2) { return c2 == c1; }
 312 #ifndef wxWINT_T_IS_TYPEDEF
 313 inline bool operator==(wint_t c1, const wxUniCharRef& c2) { return c2 == c1; }
 314 #endif
 315 inline bool operator==(const wxUniChar& c1, const wxUniCharRef& c2) { return c2 == c1; }
 316
 317 inline bool operator!=(char c1, const wxUniCharRef& c2) { return c2 != c1; }
 318 inline bool operator!=(wchar_t c1, const wxUniCharRef& c2) { return c2 != c1; }
 319 #ifndef wxWINT_T_IS_TYPEDEF
 320 inline bool operator!=(wint_t c1, const wxUniCharRef& c2) { return c2 != c1; }
 321 #endif
 322 inline bool operator!=(const wxUniChar& c1, const wxUniCharRef& c2) { return c2 != c1; }
 323
 324 inline bool operator>(char c1, const wxUniCharRef& c2) { return c2 < c1; }
 325 inline bool operator>(wchar_t c1, const wxUniCharRef& c2) { return c2 < c1; }
 326 #ifndef wxWINT_T_IS_TYPEDEF
 327 inline bool operator>(wint_t c1, const wxUniCharRef& c2) { return c2 < c1; }
 328 #endif
 329 inline bool operator>(const wxUniChar& c1, const wxUniCharRef& c2) { return c2 < c1; }
 330
 331 inline bool operator<(char c1, const wxUniCharRef& c2) { return c2 > c1; }
 332 inline bool operator<(wchar_t c1, const wxUniCharRef& c2) { return c2 > c1; }
 333 #ifndef wxWINT_T_IS_TYPEDEF
 334 inline bool operator<(wint_t c1, const wxUniCharRef& c2) { return c2 > c1; }
 335 #endif
 336 inline bool operator<(const wxUniChar& c1, const wxUniCharRef& c2) { return c2 > c1; }
 337
 338 inline bool operator>=(char c1, const wxUniCharRef& c2) { return c2 <= c1; }
 339 inline bool operator>=(wchar_t c1, const wxUniCharRef& c2) { return c2 <= c1; }
 340 #ifndef wxWINT_T_IS_TYPEDEF
 341 inline bool operator>=(wint_t c1, const wxUniCharRef& c2) { return c2 <= c1; }
 342 #endif
 343 inline bool operator>=(const wxUniChar& c1, const wxUniCharRef& c2) { return c2 <= c1; }
 344
 345 inline bool operator<=(char c1, const wxUniCharRef& c2) { return c2 >= c1; }
 346 inline bool operator<=(wchar_t c1, const wxUniCharRef& c2) { return c2 >= c1; }
 347 #ifndef wxWINT_T_IS_TYPEDEF
 348 inline bool operator<=(wint_t c1, const wxUniCharRef& c2) { return c2 >= c1; }
 349 #endif
 350 inline bool operator<=(const wxUniChar& c1, const wxUniCharRef& c2) { return c2 >= c1; }
 351
 352 // for expressions like c-'A':
 353 inline int operator-(char c1, const wxUniCharRef& c2) { return -(c2 - c1); }
 354 inline int operator-(wchar_t c1, const wxUniCharRef& c2) { return -(c2 - c1); }
 355 #ifndef wxWINT_T_IS_TYPEDEF
 356 inline int operator-(wint_t c1, const wxUniCharRef& c2) { return -(c2 - c1); }
 357 #endif
 358 inline int operator-(const wxUniChar& c1, const wxUniCharRef& c2) { return -(c2 - c1); }
 359
 360 #endif /* _WX_UNICHAR_H_ */