[wxWidgets.git] / include / wx / unichar.h

///////////////////////////////////////////////////////////////////////////////
// Name:        wx/unichar.h
// Purpose:     wxUniChar and wxUniCharRef classes
// Author:      Vaclav Slavik
// Created:     2007-03-19
// RCS-ID:      $Id$
// Copyright:   (c) 2007 REA Elektronik GmbH
// Licence:     wxWindows licence
///////////////////////////////////////////////////////////////////////////////

#ifndef _WX_UNICHAR_H_
#define _WX_UNICHAR_H_

#include "wx/defs.h"
#include "wx/chartype.h"

class WXDLLIMPEXP_BASE wxUniCharRef;

// This class represents single Unicode character. It can be converted to
// and from char or wchar_t and implements commonly used character operations.
class WXDLLIMPEXP_BASE wxUniChar
{
public:
    // NB: this is not wchar_t on purpose, it needs to represent the entire
    //     Unicode code points range and wchar_t may be too small for that
    //     (e.g. on Win32 where wchar_t* is encoded in UTF-16)
    typedef wxUint32 value_type;

    wxUniChar() : m_value(0) {}

    // Create the character from 8bit character value encoded in the current
    // locale's charset.
    wxUniChar(char c) { m_value = From8bit(c); }
    wxUniChar(unsigned char c) { m_value = From8bit((char)c); }

    // Create the character from a wchar_t character value.
    wxUniChar(wchar_t c) { m_value = c; }

#ifndef wxWINT_T_IS_TYPEDEF
    // Create the character from a wint_t character value.
    wxUniChar(wint_t c) { m_value = c; }
#endif

    wxUniChar(int c) { m_value = c; }

    wxUniChar(const wxUniCharRef& c);

    // Returns Unicode code point value of the character
    value_type GetValue() const { return m_value; }

    // Casts to char and wchar_t types:
    operator char() const { return To8bit(m_value); }
    operator unsigned char() const { return (unsigned char)To8bit(m_value); }
    operator wchar_t() const { return m_value; }
#ifndef wxWINT_T_IS_TYPEDEF
    operator wint_t() const { return m_value; }
#endif
    operator int() const { return m_value; }

    // We need this operator for the "*p" part of expressions like "for (
    // const_iterator p = begin() + nStart; *p; ++p )". In this case,
    // compilation would fail without it because the conversion to bool would
    // be ambiguous (there are all these int types conversions...). (And adding
    // operator unspecified_bool_type() would only makes the ambiguity worse.)
    operator bool() const { return m_value != 0; }
    bool operator!() const { return !((bool)*this); }
#if (defined(__VISUALC__) && __VISUALC__ < 1400) || \
    defined(__DIGITALMARS__) || defined(__BORLANDC__)
    // We need this for VC++ < 8 or DigitalMars and expressions like
    // "str[0] && *p":
    bool operator&&(bool v) const { return (bool)*this && v; }
#endif

    // Assignment operators:
    wxUniChar& operator=(const wxUniChar& c) { m_value = c.m_value; return *this; }
    wxUniChar& operator=(char c) { m_value = From8bit(c); return *this; }
    wxUniChar& operator=(wchar_t c) { m_value = c; return *this; }
#ifndef wxWINT_T_IS_TYPEDEF
    wxUniChar& operator=(wint_t c) { m_value = c; return *this; }
#endif

    // Comparision operators:
    bool operator==(const wxUniChar& c) const { return m_value == c.m_value; }
    bool operator==(char c) const { return m_value == From8bit(c); }
    bool operator==(wchar_t c) const { return m_value == (value_type)c; }
#ifndef wxWINT_T_IS_TYPEDEF
    bool operator==(wint_t c) const { return m_value == (value_type)c; }
#endif

    bool operator!=(const wxUniChar& c) const { return m_value != c.m_value; }
    bool operator!=(char c) const { return m_value != From8bit(c); }
    bool operator!=(wchar_t c) const { return m_value != (value_type)c; }
#ifndef wxWINT_T_IS_TYPEDEF
    bool operator!=(wint_t c) const { return m_value != (value_type)c; }
#endif

    bool operator>(const wxUniChar& c) const { return m_value > c.m_value; }
    bool operator>(char c) const { return m_value > (value_type)c; }
    bool operator>(wchar_t c) const { return m_value > (value_type)c; }
#ifndef wxWINT_T_IS_TYPEDEF
    bool operator>(wint_t c) const { return m_value > (value_type)c; }
#endif

    bool operator<(const wxUniChar& c) const { return m_value < c.m_value; }
    bool operator<(char c) const { return m_value < From8bit(c); }
    bool operator<(wchar_t c) const { return m_value < (value_type)c; }
#ifndef wxWINT_T_IS_TYPEDEF
    bool operator<(wint_t c) const { return m_value < (value_type)c; }
#endif

    bool operator>=(const wxUniChar& c) const { return m_value >= c.m_value; }
    bool operator>=(char c) const { return m_value >= From8bit(c); }
    bool operator>=(wchar_t c) const { return m_value >= (value_type)c; }
#ifndef wxWINT_T_IS_TYPEDEF
    bool operator>=(wint_t c) const { return m_value >= (value_type)c; }
#endif

    bool operator<=(const wxUniChar& c) const { return m_value <= c.m_value; }
    bool operator<=(char c) const { return m_value <= From8bit(c); }
    bool operator<=(wchar_t c) const { return m_value <= (value_type)c; }
#ifndef wxWINT_T_IS_TYPEDEF
    bool operator<=(wint_t c) const { return m_value <= (value_type)c; }
#endif

    int operator-(const wxUniChar& c) const { return m_value - c.m_value; }
    int operator-(char c) const { return m_value - From8bit(c); }
    int operator-(wchar_t c) const { return m_value - (value_type)c; }
#ifndef wxWINT_T_IS_TYPEDEF
    int operator-(wint_t c) const { return m_value - (value_type)c; }
#endif

private:
    static value_type From8bit(char c);
    static char To8bit(value_type c);

private:
    value_type m_value;
};


// Writeable reference to a character in wxString.
//
// This class can be used in the same way wxChar is used, except that changing
// its value updates the underlying string object.
class WXDLLIMPEXP_BASE wxUniCharRef
{
private:
    // create the reference
    // FIXME-UTF8: the interface will need changes for UTF-8 build
    wxUniCharRef(wxChar *pos) : m_pos(pos) {}

public:
    // NB: we have to make this public, because we don't have wxString
    //     declaration available here and so can't declare wxString::iterator
    //     as friend; so at least don't use a ctor but a static function
    //     that must be used explicitly (this is more than using 'explicit'
    //     keyword on ctor!):
    //
    // FIXME-UTF8: the interface will need changes for UTF-8 build
    static wxUniCharRef CreateForString(wxChar *pos)
        { return wxUniCharRef(pos); }

    wxUniChar::value_type GetValue() const { return UniChar().GetValue(); }

    // Assignment operators:
    wxUniCharRef& operator=(const wxUniCharRef& c)
    {
        *m_pos = *c.m_pos;
        return *this;
    };

    wxUniCharRef& operator=(const wxUniChar& c)
    {
        *m_pos = c;
        return *this;
    };

    wxUniCharRef& operator=(char c) { return *this = wxUniChar(c); }
    wxUniCharRef& operator=(wchar_t c) { return *this = wxUniChar(c); }

    // Casts to wxUniChar type:
    operator char() const { return UniChar(); }
    operator unsigned char() const { return UniChar(); }
    operator wchar_t() const { return UniChar(); }
#ifndef wxWINT_T_IS_TYPEDEF
    operator wint_t() const { return UniChar(); }
#endif
    operator int() const { return UniChar(); }

    // see wxUniChar::operator bool etc. for explanation
    operator bool() const { return (bool)UniChar(); }
    bool operator!() const { return !UniChar(); }
#if (defined(__VISUALC__) && __VISUALC__ < 1400) || \
    defined(__DIGITALMARS__) || defined(__BORLANDC__)
    bool operator&&(bool v) const { return UniChar() && v; }
#endif

    // Comparision operators:
    bool operator==(const wxUniCharRef& c) const { return m_pos == c.m_pos; }
    bool operator==(const wxUniChar& c) const { return UniChar() == c; }
    bool operator==(char c) const { return UniChar() == c; }
    bool operator==(wchar_t c) const { return UniChar() == c; }
#ifndef wxWINT_T_IS_TYPEDEF
    bool operator==(wint_t c) const { return UniChar() == c; }
#endif

    bool operator!=(const wxUniCharRef& c) const { return m_pos != c.m_pos; }
    bool operator!=(const wxUniChar& c) const { return UniChar() != c; }
    bool operator!=(char c) const { return UniChar() != c; }
    bool operator!=(wchar_t c) const { return UniChar() != c; }
#ifndef wxWINT_T_IS_TYPEDEF
    bool operator!=(wint_t c) const { return UniChar() != c; }
#endif

    bool operator>(const wxUniCharRef& c) const { return UniChar() > c.UniChar(); }
    bool operator>(const wxUniChar& c) const { return UniChar() > c; }
    bool operator>(char c) const { return UniChar() > c; }
    bool operator>(wchar_t c) const { return UniChar() > c; }
#ifndef wxWINT_T_IS_TYPEDEF
    bool operator>(wint_t c) const { return UniChar() > c; }
#endif

    bool operator<(const wxUniCharRef& c) const { return UniChar() < c.UniChar(); }
    bool operator<(const wxUniChar& c) const { return UniChar() < c; }
    bool operator<(char c) const { return UniChar() < c; }
    bool operator<(wchar_t c) const { return UniChar() < c; }
#ifndef wxWINT_T_IS_TYPEDEF
    bool operator<(wint_t c) const { return UniChar() < c; }
#endif

    bool operator>=(const wxUniCharRef& c) const { return UniChar() >= c.UniChar(); }
    bool operator>=(const wxUniChar& c) const { return UniChar() >= c; }
    bool operator>=(char c) const { return UniChar() >= c; }
    bool operator>=(wchar_t c) const { return UniChar() >= c; }
#ifndef wxWINT_T_IS_TYPEDEF
    bool operator>=(wint_t c) const { return UniChar() >= c; }
#endif

    bool operator<=(const wxUniCharRef& c) const { return UniChar() <= c.UniChar(); }
    bool operator<=(const wxUniChar& c) const { return UniChar() <= c; }
    bool operator<=(char c) const { return UniChar() <= c; }
    bool operator<=(wchar_t c) const { return UniChar() <= c; }
#ifndef wxWINT_T_IS_TYPEDEF
    bool operator<=(wint_t c) const { return UniChar() <= c; }
#endif

    // for expressions like c-'A':
    int operator-(const wxUniCharRef& c) const { return UniChar() - c.UniChar(); }
    int operator-(const wxUniChar& c) const { return UniChar() - c; }
    int operator-(char c) const { return UniChar() - c; }
    int operator-(wchar_t c) const { return UniChar() - c; }
#ifndef wxWINT_T_IS_TYPEDEF
    int operator-(wint_t c) const { return UniChar() - c; }
#endif

private:
    wxUniChar UniChar() const { return *m_pos; }
    friend class WXDLLIMPEXP_BASE wxUniChar;

private:
    // pointer to the character in string
    wxChar *m_pos;
};

inline wxUniChar::wxUniChar(const wxUniCharRef& c)
{
    m_value = c.UniChar().m_value;
}

// Comparision operators for the case when wxUniChar(Ref) is the second operand:
inline bool operator==(char c1, const wxUniChar& c2) { return c2 == c1; }
inline bool operator==(wchar_t c1, const wxUniChar& c2) { return c2 == c1; }
#ifndef wxWINT_T_IS_TYPEDEF
inline bool operator==(wint_t c1, const wxUniChar& c2) { return c2 == c1; }
#endif

inline bool operator!=(char c1, const wxUniChar& c2) { return c2 != c1; }
inline bool operator!=(wchar_t c1, const wxUniChar& c2) { return c2 != c1; }
#ifndef wxWINT_T_IS_TYPEDEF
inline bool operator!=(wint_t c1, const wxUniChar& c2) { return c2 != c1; }
#endif

inline bool operator>(char c1, const wxUniChar& c2) { return c2 < c1; }
inline bool operator>(wchar_t c1, const wxUniChar& c2) { return c2 < c1; }
#ifndef wxWINT_T_IS_TYPEDEF
inline bool operator>(wint_t c1, const wxUniChar& c2) { return c2 < c1; }
#endif

inline bool operator<(char c1, const wxUniChar& c2) { return c2 > c1; }
inline bool operator<(wchar_t c1, const wxUniChar& c2) { return c2 > c1; }
#ifndef wxWINT_T_IS_TYPEDEF
inline bool operator<(wint_t c1, const wxUniChar& c2) { return c2 > c1; }
#endif

inline bool operator>=(char c1, const wxUniChar& c2) { return c2 <= c1; }
inline bool operator>=(wchar_t c1, const wxUniChar& c2) { return c2 <= c1; }
#ifndef wxWINT_T_IS_TYPEDEF
inline bool operator>=(wint_t c1, const wxUniChar& c2) { return c2 <= c1; }
#endif

inline bool operator<=(char c1, const wxUniChar& c2) { return c2 >= c1; }
inline bool operator<=(wchar_t c1, const wxUniChar& c2) { return c2 >= c1; }
#ifndef wxWINT_T_IS_TYPEDEF
inline bool operator<=(wint_t c1, const wxUniChar& c2) { return c2 >= c1; }
#endif


inline bool operator==(char c1, const wxUniCharRef& c2) { return c2 == c1; }
inline bool operator==(wchar_t c1, const wxUniCharRef& c2) { return c2 == c1; }
#ifndef wxWINT_T_IS_TYPEDEF
inline bool operator==(wint_t c1, const wxUniCharRef& c2) { return c2 == c1; }
#endif
inline bool operator==(const wxUniChar& c1, const wxUniCharRef& c2) { return c2 == c1; }

inline bool operator!=(char c1, const wxUniCharRef& c2) { return c2 != c1; }
inline bool operator!=(wchar_t c1, const wxUniCharRef& c2) { return c2 != c1; }
#ifndef wxWINT_T_IS_TYPEDEF
inline bool operator!=(wint_t c1, const wxUniCharRef& c2) { return c2 != c1; }
#endif
inline bool operator!=(const wxUniChar& c1, const wxUniCharRef& c2) { return c2 != c1; }

inline bool operator>(char c1, const wxUniCharRef& c2) { return c2 < c1; }
inline bool operator>(wchar_t c1, const wxUniCharRef& c2) { return c2 < c1; }
#ifndef wxWINT_T_IS_TYPEDEF
inline bool operator>(wint_t c1, const wxUniCharRef& c2) { return c2 < c1; }
#endif
inline bool operator>(const wxUniChar& c1, const wxUniCharRef& c2) { return c2 < c1; }

inline bool operator<(char c1, const wxUniCharRef& c2) { return c2 > c1; }
inline bool operator<(wchar_t c1, const wxUniCharRef& c2) { return c2 > c1; }
#ifndef wxWINT_T_IS_TYPEDEF
inline bool operator<(wint_t c1, const wxUniCharRef& c2) { return c2 > c1; }
#endif
inline bool operator<(const wxUniChar& c1, const wxUniCharRef& c2) { return c2 > c1; }

inline bool operator>=(char c1, const wxUniCharRef& c2) { return c2 <= c1; }
inline bool operator>=(wchar_t c1, const wxUniCharRef& c2) { return c2 <= c1; }
#ifndef wxWINT_T_IS_TYPEDEF
inline bool operator>=(wint_t c1, const wxUniCharRef& c2) { return c2 <= c1; }
#endif
inline bool operator>=(const wxUniChar& c1, const wxUniCharRef& c2) { return c2 <= c1; }

inline bool operator<=(char c1, const wxUniCharRef& c2) { return c2 >= c1; }
inline bool operator<=(wchar_t c1, const wxUniCharRef& c2) { return c2 >= c1; }
#ifndef wxWINT_T_IS_TYPEDEF
inline bool operator<=(wint_t c1, const wxUniCharRef& c2) { return c2 >= c1; }
#endif
inline bool operator<=(const wxUniChar& c1, const wxUniCharRef& c2) { return c2 >= c1; }

// for expressions like c-'A':
inline int operator-(char c1, const wxUniCharRef& c2) { return -(c2 - c1); }
inline int operator-(wchar_t c1, const wxUniCharRef& c2) { return -(c2 - c1); }
#ifndef wxWINT_T_IS_TYPEDEF
inline int operator-(wint_t c1, const wxUniCharRef& c2) { return -(c2 - c1); }
#endif
inline int operator-(const wxUniChar& c1, const wxUniCharRef& c2) { return -(c2 - c1); }

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