src/common/txtstrm.cpp

///////////////////////////////////////////////////////////////////////////////
// Name:        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, wxMBConv& conv)
  : m_input(s), m_separators(sep), m_conv(conv)
{
    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()
{
}

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;

        int retlen = (int) m_conv.MB2WC(wbuf, m_lastBytes, 2); // returns -1 for failure
        if(retlen >= 0) // res == 0 could happen for '\0' char
            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);
}

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

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, wxMBConv& conv)
  : m_output(s), m_conv(conv)
#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()
{
}

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;
    }

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