src/common/txtstrm.cpp

///////////////////////////////////////////////////////////////////////////////
// Name:        src/common/txtstrm.cpp
// Purpose:     Text stream classes
// Author:      Guilhem Lavaux
// Modified by:
// Created:     28/06/98
// RCS-ID:      $Id$
// Copyright:   (c) Guilhem Lavaux
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"

#ifdef __BORLANDC__
  #pragma hdrstop
#endif

#if wxUSE_STREAMS

#include "wx/txtstrm.h"
#include <ctype.h>


// ----------------------------------------------------------------------------
// constants
// ----------------------------------------------------------------------------

// Unix: "\n"
// Dos:  "\r\n"
// Mac:  "\r"

// ----------------------------------------------------------------------------
// wxTextInputStream
// ----------------------------------------------------------------------------

#if wxUSE_UNICODE
wxTextInputStream::wxTextInputStream(wxInputStream &s,
                                     const wxString &sep,
                                     const wxMBConv& conv)
  : m_input(s), m_separators(sep), m_conv(conv.Clone())
{
    memset((void*)m_lastBytes, 0, 10);
}
#else
wxTextInputStream::wxTextInputStream(wxInputStream &s, const wxString &sep)
  : m_input(s), m_separators(sep)
{
    memset((void*)m_lastBytes, 0, 10);
}
#endif

wxTextInputStream::~wxTextInputStream()
{
#if wxUSE_UNICODE
    delete m_conv;
#endif // wxUSE_UNICODE
}

void wxTextInputStream::UngetLast()
{
    size_t byteCount = 0;
    while(m_lastBytes[byteCount]) // pseudo ANSI strlen (even for Unicode!)
        byteCount++;
    m_input.Ungetch(m_lastBytes, byteCount);
    memset((void*)m_lastBytes, 0, 10);
}

wxChar wxTextInputStream::NextChar()
{
#if wxUSE_UNICODE
    wxChar wbuf[2];
    memset((void*)m_lastBytes, 0, 10);
    for(size_t inlen = 0; inlen < 9; inlen++)
    {
        // actually read the next character
        m_lastBytes[inlen] = m_input.GetC();

        if(m_input.LastRead() <= 0)
            return wxEOT;

        if ( m_conv->ToWChar(wbuf, WXSIZEOF(wbuf), m_lastBytes, inlen + 1)
                != wxCONV_FAILED )
            return wbuf[0];
    }
    // there should be no encoding which requires more than nine bytes for one character...
    return wxEOT;
#else
    m_lastBytes[0] = m_input.GetC();

    if(m_input.LastRead() <= 0)
        return wxEOT;

    return m_lastBytes[0];
#endif

}

wxChar wxTextInputStream::NextNonSeparators()
{
    for (;;)
    {
        wxChar c = NextChar();
        if (c == wxEOT) return (wxChar) 0;

        if (c != wxT('\n') &&
            c != wxT('\r') &&
            !m_separators.Contains(c))
          return c;
    }

}

bool wxTextInputStream::EatEOL(const wxChar &c)
{
    if (c == wxT('\n')) return true; // eat on UNIX

    if (c == wxT('\r')) // eat on both Mac and DOS
    {
        wxChar c2 = NextChar();
        if(c2 == wxEOT) return true; // end of stream reached, had enough :-)

        if (c2 != wxT('\n')) UngetLast(); // Don't eat on Mac
        return true;
    }

    return false;
}

wxUint32 wxTextInputStream::Read32(int base)
{
    wxASSERT_MSG( !base || (base > 1 && base <= 36), _T("invalid base") );
    if(!m_input) return 0;

    wxString word = ReadWord();
    if(word.empty())
        return 0;
    return wxStrtoul(word.c_str(), 0, base);
}

wxUint16 wxTextInputStream::Read16(int base)
{
    return (wxUint16)Read32(base);
}

wxUint8 wxTextInputStream::Read8(int base)
{
    return (wxUint8)Read32(base);
}

wxInt32 wxTextInputStream::Read32S(int base)
{
    wxASSERT_MSG( !base || (base > 1 && base <= 36), _T("invalid base") );
    if(!m_input) return 0;

    wxString word = ReadWord();
    if(word.empty())
        return 0;
    return wxStrtol(word.c_str(), 0, base);
}

wxInt16 wxTextInputStream::Read16S(int base)
{
    return (wxInt16)Read32S(base);
}

wxInt8 wxTextInputStream::Read8S(int base)
{
    return (wxInt8)Read32S(base);
}

double wxTextInputStream::ReadDouble()
{
    if(!m_input) return 0;
    wxString word = ReadWord();
    if(word.empty())
        return 0;
    return wxStrtod(word.c_str(), 0);
}

#if WXWIN_COMPATIBILITY_2_6

wxString wxTextInputStream::ReadString()
{
    return ReadLine();
}

#endif // WXWIN_COMPATIBILITY_2_6

wxString wxTextInputStream::ReadLine()
{
    wxString line;

    while ( !m_input.Eof() )
    {
        wxChar c = NextChar();
        if(c == wxEOT)
            break;

        if ( !m_input )
            break;

        if (EatEOL(c))
            break;

        line += c;
    }

    return line;
}

wxString wxTextInputStream::ReadWord()
{
    wxString word;

    if ( !m_input )
        return word;

    wxChar c = NextNonSeparators();
    if ( !c )
        return word;

    word += c;

    while ( !m_input.Eof() )
    {
        c = NextChar();
        if(c == wxEOT)
            break;

        if (m_separators.Contains(c))
            break;

        if (EatEOL(c))
            break;

        word += c;
    }

    return word;
}

wxTextInputStream& wxTextInputStream::operator>>(wxString& word)
{
    word = ReadWord();
    return *this;
}

wxTextInputStream& wxTextInputStream::operator>>(char& c)
{
    c = m_input.GetC();
    if(m_input.LastRead() <= 0) c = 0;

    if (EatEOL(c))
        c = '\n';

    return *this;
}

#if wxUSE_UNICODE && wxWCHAR_T_IS_REAL_TYPE

wxTextInputStream& wxTextInputStream::operator>>(wchar_t& wc)
{
    wc = GetChar();

    return *this;
}

#endif // wxUSE_UNICODE

wxTextInputStream& wxTextInputStream::operator>>(wxInt16& i)
{
    i = (wxInt16)Read16();
    return *this;
}

wxTextInputStream& wxTextInputStream::operator>>(wxInt32& i)
{
    i = (wxInt32)Read32();
    return *this;
}

wxTextInputStream& wxTextInputStream::operator>>(wxUint16& i)
{
    i = Read16();
    return *this;
}

wxTextInputStream& wxTextInputStream::operator>>(wxUint32& i)
{
    i = Read32();
    return *this;
}

wxTextInputStream& wxTextInputStream::operator>>(double& i)
{
    i = ReadDouble();
    return *this;
}

wxTextInputStream& wxTextInputStream::operator>>(float& f)
{
    f = (float)ReadDouble();
    return *this;
}


#if wxUSE_UNICODE
wxTextOutputStream::wxTextOutputStream(wxOutputStream& s,
                                       wxEOL mode,
                                       const wxMBConv& conv)
  : m_output(s), m_conv(conv.Clone())
#else
wxTextOutputStream::wxTextOutputStream(wxOutputStream& s, wxEOL mode)
  : m_output(s)
#endif
{
    m_mode = mode;
    if (m_mode == wxEOL_NATIVE)
    {
#if defined(__WXMSW__) || defined(__WXPM__)
        m_mode = wxEOL_DOS;
#elif defined(__WXMAC__) && !defined(__DARWIN__)
        m_mode = wxEOL_MAC;
#else
        m_mode = wxEOL_UNIX;
#endif
    }
}

wxTextOutputStream::~wxTextOutputStream()
{
#if wxUSE_UNICODE
    delete m_conv;
#endif // wxUSE_UNICODE
}

void wxTextOutputStream::SetMode(wxEOL mode)
{
    m_mode = mode;
    if (m_mode == wxEOL_NATIVE)
    {
#if defined(__WXMSW__) || defined(__WXPM__)
        m_mode = wxEOL_DOS;
#elif defined(__WXMAC__) && !defined(__DARWIN__)
        m_mode = wxEOL_MAC;
#else
        m_mode = wxEOL_UNIX;
#endif
    }
}

void wxTextOutputStream::Write32(wxUint32 i)
{
    wxString str;
    str.Printf(wxT("%u"), i);

    WriteString(str);
}

void wxTextOutputStream::Write16(wxUint16 i)
{
    wxString str;
    str.Printf(wxT("%u"), (unsigned)i);

    WriteString(str);
}

void wxTextOutputStream::Write8(wxUint8 i)
{
    wxString str;
    str.Printf(wxT("%u"), (unsigned)i);

    WriteString(str);
}

void wxTextOutputStream::WriteDouble(double d)
{
    wxString str;

    str.Printf(wxT("%f"), d);
    WriteString(str);
}

void wxTextOutputStream::WriteString(const wxString& string)
{
    size_t len = string.length();

    wxString out;
    out.reserve(len);

    for ( size_t i = 0; i < len; i++ )
    {
        const wxChar c = string[i];
        if ( c == wxT('\n') )
        {
            switch ( m_mode )
            {
                case wxEOL_DOS:
                    out << _T("\r\n");
                    continue;

                case wxEOL_MAC:
                    out << _T('\r');
                    continue;

                default:
                    wxFAIL_MSG( _T("unknown EOL mode in wxTextOutputStream") );
                    // fall through

                case wxEOL_UNIX:
                    // don't treat '\n' specially
                    ;
            }
        }

        out << c;
    }

#if wxUSE_UNICODE
    wxCharBuffer buffer = m_conv->cWC2MB(out, out.length(), &len);
    m_output.Write(buffer, len);
#else
    m_output.Write(out.c_str(), out.length() );
#endif
}

wxTextOutputStream& wxTextOutputStream::PutChar(wxChar c)
{
#if wxUSE_UNICODE
    WriteString( wxString(&c, *m_conv, 1) );
#else
    WriteString( wxString(&c, wxConvLocal, 1) );
#endif
    return *this;
}

wxTextOutputStream& wxTextOutputStream::operator<<(const wxChar *string)
{
    WriteString( wxString(string) );
    return *this;
}

wxTextOutputStream& wxTextOutputStream::operator<<(const wxString& string)
{
    WriteString( string );
    return *this;
}

wxTextOutputStream& wxTextOutputStream::operator<<(char c)
{
    WriteString( wxString::FromAscii(c) );

    return *this;
}

#if wxUSE_UNICODE && wxWCHAR_T_IS_REAL_TYPE

wxTextOutputStream& wxTextOutputStream::operator<<(wchar_t wc)
{
    WriteString( wxString(&wc, *m_conv, 1) );

    return *this;
}

#endif // wxUSE_UNICODE

wxTextOutputStream& wxTextOutputStream::operator<<(wxInt16 c)
{
    wxString str;
    str.Printf(wxT("%d"), (signed int)c);
    WriteString(str);

    return *this;
}

wxTextOutputStream& wxTextOutputStream::operator<<(wxInt32 c)
{
    wxString str;
    str.Printf(wxT("%ld"), (signed long)c);
    WriteString(str);

    return *this;
}

wxTextOutputStream& wxTextOutputStream::operator<<(wxUint16 c)
{
    wxString str;
    str.Printf(wxT("%u"), (unsigned int)c);
    WriteString(str);

    return *this;
}

wxTextOutputStream& wxTextOutputStream::operator<<(wxUint32 c)
{
    wxString str;
    str.Printf(wxT("%lu"), (unsigned long)c);
    WriteString(str);

    return *this;
}

wxTextOutputStream &wxTextOutputStream::operator<<(double f)
{
    WriteDouble(f);
    return *this;
}

wxTextOutputStream& wxTextOutputStream::operator<<(float f)
{
    WriteDouble((double)f);
    return *this;
}

wxTextOutputStream &endl( wxTextOutputStream &stream )
{
    return stream.PutChar(wxT('\n'));
}

#endif
  // wxUSE_STREAMS
Commit	Line	Data
	1	///////////////////////////////////////////////////////////////////////////////
	2	// Name: src/common/txtstrm.cpp
	3	// Purpose: Text stream classes
	4	// Author: Guilhem Lavaux
	5	// Modified by:
	6	// Created: 28/06/98
	7	// RCS-ID: $Id$
	8	// Copyright: (c) Guilhem Lavaux
	9	// Licence: wxWindows licence
	10	/////////////////////////////////////////////////////////////////////////////
	11
	12	// For compilers that support precompilation, includes "wx.h".
	13	#include "wx/wxprec.h"
	14
	15	#ifdef __BORLANDC__
	16	#pragma hdrstop
	17	#endif
	18
	19	#if wxUSE_STREAMS
	20
	21	#include "wx/txtstrm.h"
	22	#include <ctype.h>
	23
	24
	25	// ----------------------------------------------------------------------------
	26	// constants
	27	// ----------------------------------------------------------------------------
	28
	29	// Unix: "\n"
	30	// Dos: "\r\n"
	31	// Mac: "\r"
	32
	33	// ----------------------------------------------------------------------------
	34	// wxTextInputStream
	35	// ----------------------------------------------------------------------------
	36
	37	#if wxUSE_UNICODE
	38	wxTextInputStream::wxTextInputStream(wxInputStream &s,
	39	const wxString &sep,
	40	const wxMBConv& conv)
	41	: m_input(s), m_separators(sep), m_conv(conv.Clone())
	42	{
	43	memset((void*)m_lastBytes, 0, 10);
	44	}
	45	#else
	46	wxTextInputStream::wxTextInputStream(wxInputStream &s, const wxString &sep)
	47	: m_input(s), m_separators(sep)
	48	{
	49	memset((void*)m_lastBytes, 0, 10);
	50	}
	51	#endif
	52
	53	wxTextInputStream::~wxTextInputStream()
	54	{
	55	#if wxUSE_UNICODE
	56	delete m_conv;
	57	#endif // wxUSE_UNICODE
	58	}
	59
	60	void wxTextInputStream::UngetLast()
	61	{
	62	size_t byteCount = 0;
	63	while(m_lastBytes[byteCount]) // pseudo ANSI strlen (even for Unicode!)
	64	byteCount++;
	65	m_input.Ungetch(m_lastBytes, byteCount);
	66	memset((void*)m_lastBytes, 0, 10);
	67	}
	68
	69	wxChar wxTextInputStream::NextChar()
	70	{
	71	#if wxUSE_UNICODE
	72	wxChar wbuf[2];
	73	memset((void*)m_lastBytes, 0, 10);
	74	for(size_t inlen = 0; inlen < 9; inlen++)
	75	{
	76	// actually read the next character
	77	m_lastBytes[inlen] = m_input.GetC();
	78
	79	if(m_input.LastRead() <= 0)
	80	return wxEOT;
	81
	82	if ( m_conv->ToWChar(wbuf, WXSIZEOF(wbuf), m_lastBytes, inlen + 1)
	83	!= wxCONV_FAILED )
	84	return wbuf[0];
	85	}
	86	// there should be no encoding which requires more than nine bytes for one character...
	87	return wxEOT;
	88	#else
	89	m_lastBytes[0] = m_input.GetC();
	90
	91	if(m_input.LastRead() <= 0)
	92	return wxEOT;
	93
	94	return m_lastBytes[0];
	95	#endif
	96
	97	}
	98
	99	wxChar wxTextInputStream::NextNonSeparators()
	100	{
	101	for (;;)
	102	{
	103	wxChar c = NextChar();
	104	if (c == wxEOT) return (wxChar) 0;
	105
	106	if (c != wxT('\n') &&
	107	c != wxT('\r') &&
	108	!m_separators.Contains(c))
	109	return c;
	110	}
	111
	112	}
	113
	114	bool wxTextInputStream::EatEOL(const wxChar &c)
	115	{
	116	if (c == wxT('\n')) return true; // eat on UNIX
	117
	118	if (c == wxT('\r')) // eat on both Mac and DOS
	119	{
	120	wxChar c2 = NextChar();
	121	if(c2 == wxEOT) return true; // end of stream reached, had enough :-)
	122
	123	if (c2 != wxT('\n')) UngetLast(); // Don't eat on Mac
	124	return true;
	125	}
	126
	127	return false;
	128	}
	129
	130	wxUint32 wxTextInputStream::Read32(int base)
	131	{
	132	wxASSERT_MSG( !base \|\| (base > 1 && base <= 36), _T("invalid base") );
	133	if(!m_input) return 0;
	134
	135	wxString word = ReadWord();
	136	if(word.empty())
	137	return 0;
	138	return wxStrtoul(word.c_str(), 0, base);
	139	}
	140
	141	wxUint16 wxTextInputStream::Read16(int base)
	142	{
	143	return (wxUint16)Read32(base);
	144	}
	145
	146	wxUint8 wxTextInputStream::Read8(int base)
	147	{
	148	return (wxUint8)Read32(base);
	149	}
	150
	151	wxInt32 wxTextInputStream::Read32S(int base)
	152	{
	153	wxASSERT_MSG( !base \|\| (base > 1 && base <= 36), _T("invalid base") );
	154	if(!m_input) return 0;
	155
	156	wxString word = ReadWord();
	157	if(word.empty())
	158	return 0;
	159	return wxStrtol(word.c_str(), 0, base);
	160	}
	161
	162	wxInt16 wxTextInputStream::Read16S(int base)
	163	{
	164	return (wxInt16)Read32S(base);
	165	}
	166
	167	wxInt8 wxTextInputStream::Read8S(int base)
	168	{
	169	return (wxInt8)Read32S(base);
	170	}
	171
	172	double wxTextInputStream::ReadDouble()
	173	{
	174	if(!m_input) return 0;
	175	wxString word = ReadWord();
	176	if(word.empty())
	177	return 0;
	178	return wxStrtod(word.c_str(), 0);
	179	}
	180
	181	#if WXWIN_COMPATIBILITY_2_6
	182
	183	wxString wxTextInputStream::ReadString()
	184	{
	185	return ReadLine();
	186	}
	187
	188	#endif // WXWIN_COMPATIBILITY_2_6
	189
	190	wxString wxTextInputStream::ReadLine()
	191	{
	192	wxString line;
	193
	194	while ( !m_input.Eof() )
	195	{
	196	wxChar c = NextChar();
	197	if(c == wxEOT)
	198	break;
	199
	200	if ( !m_input )
	201	break;
	202
	203	if (EatEOL(c))
	204	break;
	205
	206	line += c;
	207	}
	208
	209	return line;
	210	}
	211
	212	wxString wxTextInputStream::ReadWord()
	213	{
	214	wxString word;
	215
	216	if ( !m_input )
	217	return word;
	218
	219	wxChar c = NextNonSeparators();
	220	if ( !c )
	221	return word;
	222
	223	word += c;
	224
	225	while ( !m_input.Eof() )
	226	{
	227	c = NextChar();
	228	if(c == wxEOT)
	229	break;
	230
	231	if (m_separators.Contains(c))
	232	break;
	233
	234	if (EatEOL(c))
	235	break;
	236
	237	word += c;
	238	}
	239
	240	return word;
	241	}
	242
	243	wxTextInputStream& wxTextInputStream::operator>>(wxString& word)
	244	{
	245	word = ReadWord();
	246	return *this;
	247	}
	248
	249	wxTextInputStream& wxTextInputStream::operator>>(char& c)
	250	{
	251	c = m_input.GetC();
	252	if(m_input.LastRead() <= 0) c = 0;
	253
	254	if (EatEOL(c))
	255	c = '\n';
	256
	257	return *this;
	258	}
	259
	260	#if wxUSE_UNICODE && wxWCHAR_T_IS_REAL_TYPE
	261
	262	wxTextInputStream& wxTextInputStream::operator>>(wchar_t& wc)
	263	{
	264	wc = GetChar();
	265
	266	return *this;
	267	}
	268
	269	#endif // wxUSE_UNICODE
	270
	271	wxTextInputStream& wxTextInputStream::operator>>(wxInt16& i)
	272	{
	273	i = (wxInt16)Read16();
	274	return *this;
	275	}
	276
	277	wxTextInputStream& wxTextInputStream::operator>>(wxInt32& i)
	278	{
	279	i = (wxInt32)Read32();
	280	return *this;
	281	}
	282
	283	wxTextInputStream& wxTextInputStream::operator>>(wxUint16& i)
	284	{
	285	i = Read16();
	286	return *this;
	287	}
	288
	289	wxTextInputStream& wxTextInputStream::operator>>(wxUint32& i)
	290	{
	291	i = Read32();
	292	return *this;
	293	}
	294
	295	wxTextInputStream& wxTextInputStream::operator>>(double& i)
	296	{
	297	i = ReadDouble();
	298	return *this;
	299	}
	300
	301	wxTextInputStream& wxTextInputStream::operator>>(float& f)
	302	{
	303	f = (float)ReadDouble();
	304	return *this;
	305	}
	306
	307
	308
	309	#if wxUSE_UNICODE
	310	wxTextOutputStream::wxTextOutputStream(wxOutputStream& s,
	311	wxEOL mode,
	312	const wxMBConv& conv)
	313	: m_output(s), m_conv(conv.Clone())
	314	#else
	315	wxTextOutputStream::wxTextOutputStream(wxOutputStream& s, wxEOL mode)
	316	: m_output(s)
	317	#endif
	318	{
	319	m_mode = mode;
	320	if (m_mode == wxEOL_NATIVE)
	321	{
	322	#if defined(__WXMSW__) \|\| defined(__WXPM__)
	323	m_mode = wxEOL_DOS;
	324	#elif defined(__WXMAC__) && !defined(__DARWIN__)
	325	m_mode = wxEOL_MAC;
	326	#else
	327	m_mode = wxEOL_UNIX;
	328	#endif
	329	}
	330	}
	331
	332	wxTextOutputStream::~wxTextOutputStream()
	333	{
	334	#if wxUSE_UNICODE
	335	delete m_conv;
	336	#endif // wxUSE_UNICODE
	337	}
	338
	339	void wxTextOutputStream::SetMode(wxEOL mode)
	340	{
	341	m_mode = mode;
	342	if (m_mode == wxEOL_NATIVE)
	343	{
	344	#if defined(__WXMSW__) \|\| defined(__WXPM__)
	345	m_mode = wxEOL_DOS;
	346	#elif defined(__WXMAC__) && !defined(__DARWIN__)
	347	m_mode = wxEOL_MAC;
	348	#else
	349	m_mode = wxEOL_UNIX;
	350	#endif
	351	}
	352	}
	353
	354	void wxTextOutputStream::Write32(wxUint32 i)
	355	{
	356	wxString str;
	357	str.Printf(wxT("%u"), i);
	358
	359	WriteString(str);
	360	}
	361
	362	void wxTextOutputStream::Write16(wxUint16 i)
	363	{
	364	wxString str;
	365	str.Printf(wxT("%u"), (unsigned)i);
	366
	367	WriteString(str);
	368	}
	369
	370	void wxTextOutputStream::Write8(wxUint8 i)
	371	{
	372	wxString str;
	373	str.Printf(wxT("%u"), (unsigned)i);
	374
	375	WriteString(str);
	376	}
	377
	378	void wxTextOutputStream::WriteDouble(double d)
	379	{
	380	wxString str;
	381
	382	str.Printf(wxT("%f"), d);
	383	WriteString(str);
	384	}
	385
	386	void wxTextOutputStream::WriteString(const wxString& string)
	387	{
	388	size_t len = string.length();
	389
	390	wxString out;
	391	out.reserve(len);
	392
	393	for ( size_t i = 0; i < len; i++ )
	394	{
	395	const wxChar c = string[i];
	396	if ( c == wxT('\n') )
	397	{
	398	switch ( m_mode )
	399	{
	400	case wxEOL_DOS:
	401	out << _T("\r\n");
	402	continue;
	403
	404	case wxEOL_MAC:
	405	out << _T('\r');
	406	continue;
	407
	408	default:
	409	wxFAIL_MSG( _T("unknown EOL mode in wxTextOutputStream") );
	410	// fall through
	411
	412	case wxEOL_UNIX:
	413	// don't treat '\n' specially
	414	;
	415	}
	416	}
	417
	418	out << c;
	419	}
	420
	421	#if wxUSE_UNICODE
	422	wxCharBuffer buffer = m_conv->cWC2MB(out, out.length(), &len);
	423	m_output.Write(buffer, len);
	424	#else
	425	m_output.Write(out.c_str(), out.length() );
	426	#endif
	427	}
	428
	429	wxTextOutputStream& wxTextOutputStream::PutChar(wxChar c)
	430	{
	431	#if wxUSE_UNICODE
	432	WriteString( wxString(&c, *m_conv, 1) );
	433	#else
	434	WriteString( wxString(&c, wxConvLocal, 1) );
	435	#endif
	436	return *this;
	437	}
	438
	439	wxTextOutputStream& wxTextOutputStream::operator<<(const wxChar *string)
	440	{
	441	WriteString( wxString(string) );
	442	return *this;
	443	}
	444
	445	wxTextOutputStream& wxTextOutputStream::operator<<(const wxString& string)
	446	{
	447	WriteString( string );
	448	return *this;
	449	}
	450
	451	wxTextOutputStream& wxTextOutputStream::operator<<(char c)
	452	{
	453	WriteString( wxString::FromAscii(c) );
	454
	455	return *this;
	456	}
	457
	458	#if wxUSE_UNICODE && wxWCHAR_T_IS_REAL_TYPE
	459
	460	wxTextOutputStream& wxTextOutputStream::operator<<(wchar_t wc)
	461	{
	462	WriteString( wxString(&wc, *m_conv, 1) );
	463
	464	return *this;
	465	}
	466
	467	#endif // wxUSE_UNICODE
	468
	469	wxTextOutputStream& wxTextOutputStream::operator<<(wxInt16 c)
	470	{
	471	wxString str;
	472	str.Printf(wxT("%d"), (signed int)c);
	473	WriteString(str);
	474
	475	return *this;
	476	}
	477
	478	wxTextOutputStream& wxTextOutputStream::operator<<(wxInt32 c)
	479	{
	480	wxString str;
	481	str.Printf(wxT("%ld"), (signed long)c);
	482	WriteString(str);
	483
	484	return *this;
	485	}
	486
	487	wxTextOutputStream& wxTextOutputStream::operator<<(wxUint16 c)
	488	{
	489	wxString str;
	490	str.Printf(wxT("%u"), (unsigned int)c);
	491	WriteString(str);
	492
	493	return *this;
	494	}
	495
	496	wxTextOutputStream& wxTextOutputStream::operator<<(wxUint32 c)
	497	{
	498	wxString str;
	499	str.Printf(wxT("%lu"), (unsigned long)c);
	500	WriteString(str);
	501
	502	return *this;
	503	}
	504
	505	wxTextOutputStream &wxTextOutputStream::operator<<(double f)
	506	{
	507	WriteDouble(f);
	508	return *this;
	509	}
	510
	511	wxTextOutputStream& wxTextOutputStream::operator<<(float f)
	512	{
	513	WriteDouble((double)f);
	514	return *this;
	515	}
	516
	517	wxTextOutputStream &endl( wxTextOutputStream &stream )
	518	{
	519	return stream.PutChar(wxT('\n'));
	520	}
	521
	522	#endif
	523	// wxUSE_STREAMS