// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------
+
#ifdef __GNUG__
-#pragma implementation "stream.h"
+ #pragma implementation "stream.h"
#endif
// For compilers that support precompilation, includes "wx.h".
#include <ctype.h>
#include "wx/stream.h"
#include "wx/datstrm.h"
-#include "wx/objstrm.h"
+#include "wx/textfile.h"
// ----------------------------------------------------------------------------
// constants
wxStreamBuffer::wxStreamBuffer(wxStreamBase& stream, BufMode mode)
{
+ Init();
+
m_stream = &stream;
m_mode = mode;
wxStreamBuffer::wxStreamBuffer(BufMode mode)
{
- m_stream = new wxStreamBase;
+ Init();
+
+ wxASSERT_MSG(mode != read_write, wxT("you have to use the other ctor for read_write mode") );
+ if ( mode == read )
+ m_stream = new wxInputStream;
+ else if ( mode == write)
+ m_stream = new wxOutputStream;
+ else
+ m_stream = NULL;
+
m_mode = mode;
m_flushable = FALSE;
delete m_stream;
}
+wxInputStream *wxStreamBuffer::GetInputStream() const
+{
+ return m_mode == write ? NULL : (wxInputStream *)m_stream;
+}
+
+wxOutputStream *wxStreamBuffer::GetOutputStream() const
+{
+ return m_mode == read ? NULL : (wxOutputStream *)m_stream;
+}
+
void wxStreamBuffer::SetBufferIO(void *buffer_start,
void *buffer_end,
bool takeOwnership)
m_buffer_size = len;
// if we own it, we free it
- m_destroybuf = !takeOwnership;
+ m_destroybuf = takeOwnership;
ResetBuffer();
}
// fill the buffer with as much data as possible (only for read buffers)
bool wxStreamBuffer::FillBuffer()
{
- wxCHECK_MSG( m_stream, FALSE, _T("should have a stream in wxStreamBuffer") );
+ wxInputStream *inStream = GetInputStream();
- size_t count = m_stream->OnSysRead(m_buffer_start, m_buffer_size);
+ wxCHECK_MSG( inStream, FALSE, _T("should have a stream in wxStreamBuffer") );
+
+ size_t count = inStream->OnSysRead(m_buffer_start, m_buffer_size);
if ( !count )
return FALSE;
if ( m_buffer_pos == m_buffer_start )
return FALSE;
- wxCHECK_MSG( m_stream, FALSE, _T("should have a stream in wxStreamBuffer") );
+ wxOutputStream *outStream = GetOutputStream();
+
+ wxCHECK_MSG( outStream, FALSE, _T("should have a stream in wxStreamBuffer") );
size_t current = m_buffer_pos - m_buffer_start;
- size_t count = m_stream->OnSysWrite(m_buffer_start, current);
+ size_t count = outStream->OnSysWrite(m_buffer_start, current);
if ( count != current )
return FALSE;
void wxStreamBuffer::PutChar(char c)
{
- wxCHECK_RET( m_stream, _T("should have a stream in wxStreamBuffer") );
+ wxOutputStream *outStream = GetOutputStream();
+
+ wxCHECK_RET( outStream, _T("should have a stream in wxStreamBuffer") );
// if we don't have buffer at all, just forward this call to the stream,
if ( !HasBuffer() )
{
- m_stream->OnSysWrite(&c, 1);
+ outStream->OnSysWrite(&c, 1);
}
else
{
char wxStreamBuffer::GetChar()
{
- wxCHECK_MSG( m_stream, 0, _T("should have a stream in wxStreamBuffer") );
+ wxInputStream *inStream = GetInputStream();
+
+ wxCHECK_MSG( inStream, 0, _T("should have a stream in wxStreamBuffer") );
char c;
if ( !HasBuffer() )
{
- m_stream->OnSysRead(&c, 1);
+ inStream->OnSysRead(&c, 1);
}
else
{
size_t wxStreamBuffer::Read(void *buffer, size_t size)
{
- wxCHECK_MSG( m_stream, 0, _T("should have a stream in wxStreamBuffer") );
+ wxInputStream *inStream = GetInputStream();
- wxCHECK_MSG( m_mode != write, 0, _T("can't read from this buffer") );
+ wxCHECK_MSG( inStream, 0, _T("should have a stream in wxStreamBuffer") );
// lasterror is reset before all new IO calls
m_stream->m_lasterror = wxStream_NOERROR;
if ( !HasBuffer() )
{
- m_stream->m_lastcount = m_stream->OnSysRead(buffer, size);
+ m_stream->m_lastcount = inStream->OnSysRead(buffer, size);
}
else // we have a buffer, use it
{
size_t wxStreamBuffer::Write(const void *buffer, size_t size)
{
- wxCHECK_MSG( m_stream, 0, _T("should have a stream in wxStreamBuffer") );
- wxCHECK_MSG( m_mode != read, 0, _T("can't write to this buffer") );
+ wxOutputStream *outStream = GetOutputStream();
+
+ wxCHECK_MSG( outStream, 0, _T("should have a stream in wxStreamBuffer") );
// lasterror is reset before all new IO calls
m_stream->m_lasterror = wxStream_NOERROR;
if ( !HasBuffer() && m_fixed )
{
// no buffer, just forward the call to the stream
- m_stream->m_lastcount = m_stream->OnSysWrite(buffer, size);
+ m_stream->m_lastcount = outStream->OnSysWrite(buffer, size);
}
else // we [may] have a buffer, use it
{
{
}
-size_t wxStreamBase::OnSysRead(void *WXUNUSED(buffer), size_t WXUNUSED(size))
-{
- return 0;
-}
-
-size_t wxStreamBase::OnSysWrite(const void *WXUNUSED(buffer), size_t WXUNUSED(bufsize))
-{
- return 0;
-}
-
off_t wxStreamBase::OnSysSeek(off_t WXUNUSED(seek), wxSeekMode WXUNUSED(mode))
{
return wxInvalidOffset;
free(m_wback);
}
+size_t wxInputStream::OnSysRead(void * WXUNUSED(buffer),
+ size_t WXUNUSED(bufsize))
+{
+ return 0;
+}
+
bool wxInputStream::Eof() const
{
wxInputStream *self = wxConstCast(this, wxInputStream);
char c;
self->Read(&c, 1);
- if ( GetLastError() == wxSTREAM_EOF )
+
+ // some streams can know that they're at EOF before actually trying to
+ // read beyond the end of stream (e.g. files) while others have no way of
+ // knowing it, so to provide the same behaviour in all cases we only
+ // return TRUE from here if the character really couldn't be read
+ if ( !self->LastRead() && GetLastError() == wxSTREAM_EOF )
{
return TRUE;
}
return pos;
}
-// --------------------
-// Overloaded operators
-// --------------------
-
-#if wxUSE_SERIAL
-wxInputStream& wxInputStream::operator>>(wxObject *& obj)
-{
- wxObjectInputStream obj_s(*this);
- obj = obj_s.LoadObject();
- return *this;
-}
-#endif // wxUSE_SERIAL
-
// ----------------------------------------------------------------------------
// wxOutputStream
{
}
+size_t wxOutputStream::OnSysWrite(const void * WXUNUSED(buffer),
+ size_t WXUNUSED(bufsize))
+{
+ return 0;
+}
+
void wxOutputStream::PutC(char c)
{
Write(&c, 1);
{
}
-#if wxUSE_SERIAL
-wxOutputStream& wxOutputStream::operator<<(wxObject& obj)
-{
- wxObjectOutputStream obj_s(*this);
- obj_s.SaveObject(obj);
- return *this;
-}
-#endif // wxUSE_SERIAL
// ----------------------------------------------------------------------------
// wxCountingOutputStream
wxFilterInputStream::wxFilterInputStream()
{
+ m_parent_i_stream = NULL;
}
wxFilterInputStream::wxFilterInputStream(wxInputStream& stream)
wxFilterOutputStream::wxFilterOutputStream()
{
+ m_parent_o_stream = NULL;
}
wxFilterOutputStream::wxFilterOutputStream(wxOutputStream& stream)
// wxBufferedInputStream
// ----------------------------------------------------------------------------
-wxBufferedInputStream::wxBufferedInputStream(wxInputStream& s)
+wxBufferedInputStream::wxBufferedInputStream(wxInputStream& s,
+ wxStreamBuffer *buffer)
: wxFilterInputStream(s)
{
- m_i_streambuf = new wxStreamBuffer(*this, wxStreamBuffer::read);
+ if ( buffer )
+ {
+ // use the buffer provided by the user
+ m_i_streambuf = buffer;
+ }
+ else // create a default buffer
+ {
+ m_i_streambuf = new wxStreamBuffer(*this, wxStreamBuffer::read);
- m_i_streambuf->SetBufferIO(1024);
+ m_i_streambuf->SetBufferIO(1024);
+ }
}
wxBufferedInputStream::~wxBufferedInputStream()
{
- m_parent_i_stream->SeekI(-m_i_streambuf->GetBytesLeft(), wxFromCurrent);
+ m_parent_i_stream->SeekI(-(off_t)m_i_streambuf->GetBytesLeft(),
+ wxFromCurrent);
delete m_i_streambuf;
}
retsize = GetWBack(buf, size);
m_lastcount = retsize;
- if (retsize == size)
+ if ( retsize == size )
{
m_lasterror = wxStream_NOERROR;
return *this;
return m_parent_i_stream->TellI();
}
+void wxBufferedInputStream::SetInputStreamBuffer(wxStreamBuffer *buffer)
+{
+ wxCHECK_RET( buffer, _T("wxBufferedInputStream needs buffer") );
+
+ delete m_i_streambuf;
+ m_i_streambuf = buffer;
+}
+
// ----------------------------------------------------------------------------
// wxBufferedOutputStream
// ----------------------------------------------------------------------------
-wxBufferedOutputStream::wxBufferedOutputStream(wxOutputStream& s)
+wxBufferedOutputStream::wxBufferedOutputStream(wxOutputStream& s,
+ wxStreamBuffer *buffer)
: wxFilterOutputStream(s)
{
- m_o_streambuf = new wxStreamBuffer(*this, wxStreamBuffer::write);
- m_o_streambuf->SetBufferIO(1024);
+ if ( buffer )
+ {
+ m_o_streambuf = buffer;
+ }
+ else // create a default one
+ {
+ m_o_streambuf = new wxStreamBuffer(*this, wxStreamBuffer::write);
+
+ m_o_streambuf->SetBufferIO(1024);
+ }
}
wxBufferedOutputStream::~wxBufferedOutputStream()
return m_parent_o_stream->GetSize() + m_o_streambuf->GetIntPosition();
}
+void wxBufferedOutputStream::SetOutputStreamBuffer(wxStreamBuffer *buffer)
+{
+ wxCHECK_RET( buffer, _T("wxBufferedOutputStream needs buffer") );
+
+ delete m_o_streambuf;
+ m_o_streambuf = buffer;
+}
+
// ----------------------------------------------------------------------------
// Some IOManip function
// ----------------------------------------------------------------------------
wxOutputStream& wxEndL(wxOutputStream& stream)
{
-#ifdef __MSW__
- return stream.Write("\r\n", 2);
-#else
-#ifdef __WXMAC__
- return stream.Write("\r", 1);
-#else
- return stream.Write("\n", 1);
-#endif
-#endif
+ static const wxChar *eol = wxTextFile::GetEOL();
+
+ return stream.Write(eol, wxStrlen(eol));
}
#endif
projects / wxWidgets.git / blobdiff