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 license
/////////////////////////////////////////////////////////////////////////////

#ifdef __GNUG__
#pragma implementation "txtstrm.h"
#endif

// 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)
{
}
#else
wxTextInputStream::wxTextInputStream(wxInputStream &s, const wxString &sep)
  : m_input(s), m_separators(sep)
{
}
#endif

wxTextInputStream::~wxTextInputStream()
{
}

wxChar wxTextInputStream::NextNonSeparators()
{
    wxChar c = (wxChar) 0;
    for (;;)
    {
        if (!m_input) return (wxChar) 0;
        c = m_input.GetC();

        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
    {
        if (!m_input) return TRUE;
        wxChar c2 = m_input.GetC();

        if (c2 != wxT('\n'))  m_input.Ungetch( c2 ); // Don't eat on Mac
        return TRUE;
    }

    return FALSE;
}

void wxTextInputStream::SkipIfEndOfLine( wxChar c )
{
    if (EatEOL(c)) return;
    else m_input.Ungetch( c );  // no line terminator
}

wxUint32 wxTextInputStream::Read32()
{
    /* I only implemented a simple integer parser */
    // VZ: what about using strtol()?? (TODO)

    int sign;
    wxInt32 i;

    if (!m_input) return 0;
    int c = NextNonSeparators();
    if (c==(wxChar)0) return 0;

    i = 0;
    if (! (c == wxT('-') || c == wxT('+') || isdigit(c)) )
    {
        m_input.Ungetch(c);
        return 0;
    }

    if (c == wxT('-'))
    {
        sign = -1;
        c = m_input.GetC();
    } else
    if (c == wxT('+'))
    {
        sign = 1;
        c = m_input.GetC();
    } else
    {
        sign = 1;
    }

    while (isdigit(c))
    {
        i = i*10 + (c - (int)wxT('0'));
        c = m_input.GetC();
    }

    SkipIfEndOfLine( c );

    i *= sign;

    return (wxUint32)i;
}

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

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

double wxTextInputStream::ReadDouble()
{
    /* I only implemented a simple float parser
     * VZ: what about using strtod()?? (TODO)
     */

    double f;
    int theSign;

    if (!m_input)
        return 0;

    int c = NextNonSeparators();
    if (c==(wxChar)0) return 0;

    f = 0.0;
    if (! (c == wxT('.') || c == wxT(',') || c == wxT('-') || c == wxT('+') || isdigit(c)) )
    {
        m_input.Ungetch(c);
        return 0;
    }

    if (c == wxT('-'))
    {
        theSign = -1;
        c = m_input.GetC();
    } else
    if (c == wxT('+'))
    {
        theSign = 1;
        c = m_input.GetC();
    }
    else
    {
        theSign = 1;
    }

    while (isdigit(c))
    {
        f = f*10 + (c - wxT('0'));
        c = m_input.GetC();
    }

    if (c == wxT('.') || c == wxT(','))
    {
        double f_multiplicator = (double) 0.1;

        c = m_input.GetC();

        while (isdigit(c))
        {
            f += (c-wxT('0'))*f_multiplicator;
            f_multiplicator /= 10;
            c = m_input.GetC();
        }

        if (c == wxT('e'))
        {
            double f_multiplicator = 0.0;
            int i, e;

            c = m_input.GetC();

            switch (c)
            {
                case wxT('-'): f_multiplicator = 0.1;  break;
                case wxT('+'): f_multiplicator = 10.0; break;
            }

            e = Read8();  // why only max 256 ?

            for (i=0;i<e;i++)
                f *= f_multiplicator;
        }
        else
            SkipIfEndOfLine( c );
    }
    else
    {
        m_input.Ungetch(c);
    }

    f *= theSign;
    return f;
}

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

wxString wxTextInputStream::ReadLine()
{
    wxString line;

    while ( !m_input.Eof() )
    {
#if wxUSE_UNICODE
        // FIXME: this is only works for single byte encodings
        // How-to read a single char in an unkown encoding???
        char buf[10];
        buf[0] = m_input.GetC();
        buf[1] = 0;

        wxChar wbuf[2];
        m_conv.MB2WC( wbuf, buf, 2 );
        wxChar c = wbuf[0];
#else
        char c = m_input.GetC();
#endif

        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 = m_input.GetC();

        if (!m_input)
            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)
{
    if (!m_input)
    {
        c = 0;
        return *this;
    }

    c = m_input.GetC();

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

    return *this;
}

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"), i);

    WriteString(str);
}

void wxTextOutputStream::Write8(wxUint8 i)
{
    wxString str;
    str.Printf(wxT("%u"), 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::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;
}

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