// Created: 11/07/98
// RCS-ID: $Id$
// Copyright: (c) Guilhem Lavaux
-// Licence: wxWindows license
+// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
// ============================================================================
// headers
// ----------------------------------------------------------------------------
-#ifdef __GNUG__
- #pragma implementation "stream.h"
-#endif
-
// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"
#ifdef __BORLANDC__
- #pragma hdrstop
+ #pragma hdrstop
#endif
+#if wxUSE_STREAMS
+
+#include "wx/stream.h"
+
#ifndef WX_PRECOMP
- #include "wx/defs.h"
+ #include "wx/log.h"
#endif
-#if wxUSE_STREAMS
-
#include <ctype.h>
-#include "wx/stream.h"
#include "wx/datstrm.h"
#include "wx/textfile.h"
-#include "wx/log.h"
// ----------------------------------------------------------------------------
// constants
// ----------------------------------------------------------------------------
// the temporary buffer size used when copying from stream to stream
-#define BUF_TEMP_SIZE 10000
+#define BUF_TEMP_SIZE 4096
// ============================================================================
// implementation
void wxStreamBuffer::SetError(wxStreamError err)
{
- if ( m_stream->m_lasterror == wxStream_NOERROR )
+ if ( m_stream && m_stream->m_lasterror == wxSTREAM_NO_ERROR )
m_stream->m_lasterror = err;
}
m_buffer_start =
m_buffer_end =
m_buffer_pos = NULL;
- m_buffer_size = 0;
// if we are going to allocate the buffer, we should free it later as well
- m_destroybuf = TRUE;
+ m_destroybuf = true;
}
void wxStreamBuffer::Init()
{
InitBuffer();
- m_fixed = TRUE;
+ m_fixed = true;
}
-wxStreamBuffer::wxStreamBuffer(wxStreamBase& stream, BufMode mode)
+void wxStreamBuffer::InitWithStream(wxStreamBase& stream, BufMode mode)
{
Init();
m_stream = &stream;
m_mode = mode;
- m_flushable = TRUE;
- m_destroystream = FALSE;
+ m_flushable = true;
}
wxStreamBuffer::wxStreamBuffer(BufMode mode)
{
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_stream = NULL;
m_mode = mode;
- m_flushable = FALSE;
- m_destroystream = TRUE;
+ m_flushable = false;
}
wxStreamBuffer::wxStreamBuffer(const wxStreamBuffer& buffer)
{
- // doing this has big chances to lead to a crashwhen the source buffer is
+ // doing this has big chances to lead to a crash when the source buffer is
// destroyed (otherwise assume the caller knows what he does)
- wxASSERT_MSG( !buffer.m_destroybuf && !buffer.m_destroystream,
+ wxASSERT_MSG( !buffer.m_destroybuf,
_T("it's a bad idea to copy this buffer") );
m_buffer_start = buffer.m_buffer_start;
m_buffer_end = buffer.m_buffer_end;
m_buffer_pos = buffer.m_buffer_pos;
- m_buffer_size = buffer.m_buffer_size;
m_fixed = buffer.m_fixed;
m_flushable = buffer.m_flushable;
m_stream = buffer.m_stream;
m_mode = buffer.m_mode;
- m_destroybuf = FALSE;
- m_destroystream = FALSE;
+ m_destroybuf = false;
}
void wxStreamBuffer::FreeBuffer()
{
if ( m_destroybuf )
+ {
free(m_buffer_start);
+ m_buffer_start = NULL;
+ }
}
wxStreamBuffer::~wxStreamBuffer()
{
FreeBuffer();
-
- if ( m_destroystream )
- delete m_stream;
}
wxInputStream *wxStreamBuffer::GetInputStream() const
m_buffer_start = (char *)start;
m_buffer_end = m_buffer_start + len;
- m_buffer_size = len;
-
// if we own it, we free it
m_destroybuf = takeOwnership;
void wxStreamBuffer::SetBufferIO(size_t bufsize)
{
- // start by freeing the old buffer
- FreeBuffer();
-
if ( bufsize )
{
- SetBufferIO(malloc(bufsize), bufsize, TRUE /* take ownership */);
+ // this will free the old buffer and allocate the new one
+ SetBufferIO(malloc(bufsize), bufsize, true /* take ownership */);
}
else // no buffer size => no buffer
{
+ // still free the old one
+ FreeBuffer();
InitBuffer();
}
}
void wxStreamBuffer::ResetBuffer()
{
- wxCHECK_RET( m_stream, _T("should have a stream in wxStreamBuffer") );
+ if ( m_stream )
+ {
+ m_stream->Reset();
+ m_stream->m_lastcount = 0;
+ }
- m_stream->m_lasterror = wxStream_NOERROR;
- m_stream->m_lastcount = 0;
- if (m_mode == read && m_flushable)
- m_buffer_pos = m_buffer_end;
- else
- m_buffer_pos = m_buffer_start;
+ m_buffer_pos = m_mode == read && m_flushable
+ ? m_buffer_end
+ : m_buffer_start;
+}
+
+void wxStreamBuffer::Truncate()
+{
+ size_t new_size = m_buffer_pos - m_buffer_start;
+ if ( m_buffer_pos == m_buffer_end )
+ return;
+
+ if ( !new_size )
+ {
+ FreeBuffer();
+ InitBuffer();
+ return;
+ }
+
+ char *new_start = (char *)realloc(m_buffer_start, new_size);
+ wxCHECK_RET( new_size, _T("shrinking buffer shouldn't fail") );
+
+ m_buffer_start = new_start;
+ m_buffer_end = m_buffer_start + new_size;
+ m_buffer_pos = m_buffer_end;
}
// fill the buffer with as much data as possible (only for read buffers)
{
wxInputStream *inStream = GetInputStream();
- wxCHECK_MSG( inStream, FALSE, _T("should have a stream in wxStreamBuffer") );
+ // It's legal to have no stream, so we don't complain about it just return false
+ if ( !inStream )
+ return false;
- size_t count = inStream->OnSysRead(m_buffer_start, m_buffer_size);
+ size_t count = inStream->OnSysRead(GetBufferStart(), GetBufferSize());
if ( !count )
- return FALSE;
+ return false;
m_buffer_end = m_buffer_start + count;
m_buffer_pos = m_buffer_start;
- return TRUE;
+ return true;
}
// write the buffer contents to the stream (only for write buffers)
bool wxStreamBuffer::FlushBuffer()
{
- wxCHECK_MSG( m_flushable, FALSE, _T("can't flush this buffer") );
+ wxCHECK_MSG( m_flushable, false, _T("can't flush this buffer") );
// FIXME: what is this check for? (VZ)
if ( m_buffer_pos == m_buffer_start )
- return FALSE;
+ return false;
wxOutputStream *outStream = GetOutputStream();
- wxCHECK_MSG( outStream, FALSE, _T("should have a stream in wxStreamBuffer") );
+ wxCHECK_MSG( outStream, false, _T("should have a stream in wxStreamBuffer") );
size_t current = m_buffer_pos - m_buffer_start;
size_t count = outStream->OnSysWrite(m_buffer_start, current);
if ( count != current )
- return FALSE;
+ return false;
m_buffer_pos = m_buffer_start;
- return TRUE;
+ return true;
}
size_t wxStreamBuffer::GetDataLeft()
void wxStreamBuffer::PutToBuffer(const void *buffer, size_t size)
{
size_t left = GetBytesLeft();
+
if ( size > left )
{
if ( m_fixed )
else // !m_fixed
{
// realloc the buffer to have enough space for the data
- size_t delta = m_buffer_pos - m_buffer_start;
-
- char *startOld = m_buffer_start;
- m_buffer_size += size;
- m_buffer_start = (char *)realloc(m_buffer_start, m_buffer_size);
- if ( !m_buffer_start )
+ if ( m_buffer_pos + size > m_buffer_end )
{
- // don't leak memory if realloc() failed
- m_buffer_start = startOld;
- m_buffer_size -= size;
+ size_t delta = m_buffer_pos - m_buffer_start;
+ size_t new_size = delta + size;
- // what else can we do?
- return;
- }
+ char *startOld = m_buffer_start;
+ m_buffer_start = (char *)realloc(m_buffer_start, new_size);
+ if ( !m_buffer_start )
+ {
+ // don't leak memory if realloc() failed
+ m_buffer_start = startOld;
- // adjust the pointers invalidated by realloc()
- m_buffer_pos = m_buffer_start + delta;
- m_buffer_end = m_buffer_start + m_buffer_size;
+ // what else can we do?
+ return;
+ }
+
+ // adjust the pointers invalidated by realloc()
+ m_buffer_pos = m_buffer_start + delta;
+ m_buffer_end = m_buffer_start + new_size;
+ } // else: the buffer is big enough
}
}
// if we don't have buffer at all, just forward this call to the stream,
if ( !HasBuffer() )
{
- outStream->OnSysWrite(&c, 1);
+ outStream->OnSysWrite(&c, sizeof(c));
}
else
{
if ( !GetDataLeft() && !FlushBuffer() )
{
// we don't
- SetError(wxStream_WRITE_ERR);
+ SetError(wxSTREAM_WRITE_ERROR);
}
else
{
- PutToBuffer(&c, 1);
+ PutToBuffer(&c, sizeof(c));
m_stream->m_lastcount = 1;
}
}
if ( !GetDataLeft() )
{
- SetError(wxStream_READ_ERR);
+ SetError(wxSTREAM_READ_ERROR);
return 0;
}
char c;
- GetFromBuffer(&c, 1);
+ GetFromBuffer(&c, sizeof(c));
m_buffer_pos--;
return c;
char c;
if ( !HasBuffer() )
{
- inStream->OnSysRead(&c, 1);
+ inStream->OnSysRead(&c, sizeof(c));
}
else
{
if ( !GetDataLeft() )
{
- SetError(wxStream_READ_ERR);
+ SetError(wxSTREAM_READ_ERROR);
c = 0;
}
else
{
- GetFromBuffer(&c, 1);
+ GetFromBuffer(&c, sizeof(c));
m_stream->m_lastcount = 1;
}
}
size_t wxStreamBuffer::Read(void *buffer, size_t size)
{
- wxInputStream *inStream = GetInputStream();
+ wxASSERT_MSG( buffer, _T("Warning: Null pointer is about to be used") );
- wxCHECK_MSG( inStream, 0, _T("should have a stream in wxStreamBuffer") );
+ /* Clear buffer first */
+ memset(buffer, 0x00, size);
// lasterror is reset before all new IO calls
- m_stream->m_lasterror = wxStream_NOERROR;
+ if ( m_stream )
+ m_stream->Reset();
+ size_t readBytes;
if ( !HasBuffer() )
{
- m_stream->m_lastcount = inStream->OnSysRead(buffer, size);
+ wxInputStream *inStream = GetInputStream();
+
+ wxCHECK_MSG( inStream, 0, _T("should have a stream in wxStreamBuffer") );
+
+ readBytes = inStream->OnSysRead(buffer, size);
}
else // we have a buffer, use it
{
if ( !FillBuffer() )
{
- SetError(wxStream_EOF);
+ SetError(wxSTREAM_EOF);
break;
}
}
}
}
- m_stream->m_lastcount = orig_size - size;
+ readBytes = orig_size - size;
}
- return m_stream->m_lastcount;
+ if ( m_stream )
+ m_stream->m_lastcount = readBytes;
+
+ return readBytes;
}
// this should really be called "Copy()"
do
{
- nRead = Read(dbuf, WXSIZEOF(buf));
+ nRead = Read(buf, WXSIZEOF(buf));
if ( nRead )
{
nRead = dbuf->Write(buf, nRead);
size_t wxStreamBuffer::Write(const void *buffer, size_t size)
{
- wxOutputStream *outStream = GetOutputStream();
+ wxASSERT_MSG( buffer, _T("Warning: Null pointer is about to be send") );
- wxCHECK_MSG( outStream, 0, _T("should have a stream in wxStreamBuffer") );
+ if (m_stream)
+ {
+ // lasterror is reset before all new IO calls
+ m_stream->Reset();
+ }
- // lasterror is reset before all new IO calls
- m_stream->m_lasterror = wxStream_NOERROR;
+ size_t ret;
if ( !HasBuffer() && m_fixed )
{
+ wxOutputStream *outStream = GetOutputStream();
+
+ wxCHECK_MSG( outStream, 0, _T("should have a stream in wxStreamBuffer") );
+
// no buffer, just forward the call to the stream
- m_stream->m_lastcount = outStream->OnSysWrite(buffer, size);
+ ret = outStream->OnSysWrite(buffer, size);
}
else // we [may] have a buffer, use it
{
//
// FIXME: fine, but if it fails we should (re)try writing it by
// chunks as this will (hopefully) always work (VZ)
+
if ( size > left && m_fixed )
{
PutToBuffer(buffer, left);
if ( !FlushBuffer() )
{
- SetError(wxStream_WRITE_ERR);
+ SetError(wxSTREAM_WRITE_ERROR);
break;
}
}
}
- m_stream->m_lastcount = orig_size - size;
+ ret = orig_size - size;
+ }
+
+ if (m_stream)
+ {
+ // i am not entirely sure what we do this for
+ m_stream->m_lastcount = ret;
}
- return m_stream->m_lastcount;
+ return ret;
}
size_t wxStreamBuffer::Write(wxStreamBuffer *sbuf)
return total;
}
-off_t wxStreamBuffer::Seek(off_t pos, wxSeekMode mode)
+wxFileOffset wxStreamBuffer::Seek(wxFileOffset pos, wxSeekMode mode)
{
- off_t ret_off, diff;
+ wxFileOffset ret_off, diff;
- off_t last_access = GetLastAccess();
+ wxFileOffset last_access = GetLastAccess();
if ( !m_flushable )
{
}
if (diff < 0 || diff > last_access)
return wxInvalidOffset;
- SetIntPosition(diff);
+ size_t int_diff = wx_truncate_cast(size_t, diff);
+ wxCHECK_MSG( (wxFileOffset)int_diff == diff, wxInvalidOffset, wxT("huge file not supported") );
+ SetIntPosition(int_diff);
return diff;
}
}
else
{
- SetIntPosition(diff);
+ size_t int_diff = wx_truncate_cast(size_t, diff);
+ wxCHECK_MSG( (wxFileOffset)int_diff == diff, wxInvalidOffset, wxT("huge file not supported") );
+ SetIntPosition(int_diff);
return pos;
}
return wxInvalidOffset;
}
-off_t wxStreamBuffer::Tell() const
+wxFileOffset wxStreamBuffer::Tell() const
{
- off_t pos;
+ wxFileOffset pos;
- // only ask the stream for position if we have a real stream and not a
- // dummy one which we created ourselves, otherwise we'd call
- // wxStream::OnSysTell() which would always return wxInvalidOffset
- if ( !m_destroystream )
+ // ask the stream for position if we have a real one
+ if ( m_stream )
{
pos = m_stream->OnSysTell();
if ( pos == wxInvalidOffset )
// wxStreamBase
// ----------------------------------------------------------------------------
+IMPLEMENT_ABSTRACT_CLASS(wxStreamBase, wxObject)
+
wxStreamBase::wxStreamBase()
{
- m_lasterror = wxStream_NOERROR;
+ m_lasterror = wxSTREAM_NO_ERROR;
m_lastcount = 0;
}
{
}
-off_t wxStreamBase::OnSysSeek(off_t WXUNUSED(seek), wxSeekMode WXUNUSED(mode))
+size_t wxStreamBase::GetSize() const
+{
+ wxFileOffset length = GetLength();
+ if ( length == (wxFileOffset)wxInvalidOffset )
+ return 0;
+
+ const size_t len = wx_truncate_cast(size_t, length);
+ wxASSERT_MSG( len == length + size_t(0), _T("large files not supported") );
+
+ return len;
+}
+
+wxFileOffset wxStreamBase::OnSysSeek(wxFileOffset WXUNUSED(seek), wxSeekMode WXUNUSED(mode))
{
return wxInvalidOffset;
}
-off_t wxStreamBase::OnSysTell() const
+wxFileOffset wxStreamBase::OnSysTell() const
{
return wxInvalidOffset;
}
// wxInputStream
// ----------------------------------------------------------------------------
+IMPLEMENT_ABSTRACT_CLASS(wxInputStream, wxStreamBase)
+
wxInputStream::wxInputStream()
{
m_wback = NULL;
free(m_wback);
}
-size_t wxInputStream::OnSysRead(void * WXUNUSED(buffer),
- size_t WXUNUSED(bufsize))
+bool wxInputStream::CanRead() const
{
- return 0;
+ // we don't know if there is anything to read or not and by default we
+ // prefer to be optimistic and try to read data unless we know for sure
+ // there is no more of it
+ return m_lasterror != wxSTREAM_EOF;
}
bool wxInputStream::Eof() const
{
- wxInputStream *self = wxConstCast(this, wxInputStream);
-
- char c;
- self->Read(&c, 1);
-
- // 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;
- }
-
- self->Ungetch(c);
-
- return FALSE;
+ // the only way the base class can know we're at EOF is when we'd already
+ // tried to read beyond it in which case last error is set accordingly
+ return GetLastError() == wxSTREAM_EOF;
}
char *wxInputStream::AllocSpaceWBack(size_t needed_size)
return m_wback;
}
-size_t wxInputStream::GetWBack(void *buf, size_t bsize)
+size_t wxInputStream::GetWBack(void *buf, size_t size)
{
+ wxASSERT_MSG( buf, _T("Warning: Null pointer is about to be used") );
+
+ /* Clear buffer first */
+ memset(buf, 0x00, size);
+
if (!m_wback)
return 0;
// how many bytes do we have in the buffer?
size_t toget = m_wbacksize - m_wbackcur;
- if ( bsize < toget )
+ if ( size < toget )
{
// we won't read everything
- toget = bsize;
+ toget = size;
}
- // copy the data from the cache
+ // copy the data from the cache
memcpy(buf, m_wback + m_wbackcur, toget);
m_wbackcur += toget;
size_t wxInputStream::Ungetch(const void *buf, size_t bufsize)
{
+ wxASSERT_MSG( buf, _T("Warning: Null pointer is about to be used in Ungetch()") );
+
if ( m_lasterror != wxSTREAM_NO_ERROR && m_lasterror != wxSTREAM_EOF )
{
// can't operate on this stream until the error is cleared
if (!ptrback)
return 0;
- // Eof() shouldn't return TRUE any longer
+ // Eof() shouldn't return true any longer
if ( m_lasterror == wxSTREAM_EOF )
m_lasterror = wxSTREAM_NO_ERROR;
bool wxInputStream::Ungetch(char c)
{
- return Ungetch(&c, sizeof(char)) != 0;
+ return Ungetch(&c, sizeof(c)) != 0;
}
-char wxInputStream::GetC()
+int wxInputStream::GetC()
{
- char c;
- Read(&c, 1);
- return c;
+ unsigned char c;
+ Read(&c, sizeof(c));
+ return LastRead() ? c : wxEOF;
}
wxInputStream& wxInputStream::Read(void *buf, size_t size)
{
+ wxASSERT_MSG( buf, _T("Warning: Null pointer is about to be read") );
+
char *p = (char *)buf;
m_lastcount = 0;
break;
}
- read = OnSysRead(buf, size);
+ if ( p != buf && !CanRead() )
+ {
+ // we have already read something and we would block in OnSysRead()
+ // now: don't do it but return immediately
+ break;
+ }
+
+ read = OnSysRead(p, size);
if ( !read )
{
// no more data available
char wxInputStream::Peek()
{
char c;
- Read(&c, 1);
- if (m_lasterror == wxStream_NOERROR)
+ Read(&c, sizeof(c));
+ if (m_lasterror == wxSTREAM_NO_ERROR)
{
Ungetch(c);
return c;
wxInputStream& wxInputStream::Read(wxOutputStream& stream_out)
{
+ size_t lastcount = 0;
char buf[BUF_TEMP_SIZE];
- size_t bytes_read = BUF_TEMP_SIZE;
- while (bytes_read == BUF_TEMP_SIZE)
+ for ( ;; )
{
- bytes_read = Read(buf, bytes_read).LastRead();
- bytes_read = stream_out.Write(buf, bytes_read).LastWrite();
+ size_t bytes_read = Read(buf, WXSIZEOF(buf)).LastRead();
+ if ( !bytes_read )
+ break;
+
+ if ( stream_out.Write(buf, bytes_read).LastWrite() != bytes_read )
+ break;
+
+ lastcount += bytes_read;
}
+
+ m_lastcount = lastcount;
+
return *this;
}
-off_t wxInputStream::SeekI(off_t pos, wxSeekMode mode)
+wxFileOffset wxInputStream::SeekI(wxFileOffset pos, wxSeekMode mode)
{
// RR: This code is duplicated in wxBufferedInputStream. This is
// not really a good design, but buffered stream are different
// I don't know whether it should be put as well in wxFileInputStream::OnSysSeek
if (m_lasterror==wxSTREAM_EOF)
- m_lasterror=wxSTREAM_NOERROR;
+ m_lasterror=wxSTREAM_NO_ERROR;
/* RR: A call to SeekI() will automatically invalidate any previous
call to Ungetch(), otherwise it would be possible to SeekI() to
buffer if possible, but is it really needed? It would only work
when seeking in wxFromCurrent mode, else it would invalidate
anyway... */
-
+
if (m_wback)
{
wxLogDebug( wxT("Seeking in stream which has data written back to it.") );
-
+
free(m_wback);
m_wback = NULL;
m_wbacksize = 0;
return OnSysSeek(pos, mode);
}
-off_t wxInputStream::TellI() const
+wxFileOffset wxInputStream::TellI() const
{
- off_t pos = OnSysTell();
+ wxFileOffset pos = OnSysTell();
if (pos != wxInvalidOffset)
pos -= (m_wbacksize - m_wbackcur);
// wxOutputStream
// ----------------------------------------------------------------------------
+IMPLEMENT_ABSTRACT_CLASS(wxOutputStream, wxStreamBase)
+
wxOutputStream::wxOutputStream()
{
}
void wxOutputStream::PutC(char c)
{
- Write(&c, 1);
+ Write(&c, sizeof(c));
}
wxOutputStream& wxOutputStream::Write(const void *buffer, size_t size)
return *this;
}
-off_t wxOutputStream::TellO() const
+wxFileOffset wxOutputStream::TellO() const
{
return OnSysTell();
}
-off_t wxOutputStream::SeekO(off_t pos, wxSeekMode mode)
+wxFileOffset wxOutputStream::SeekO(wxFileOffset pos, wxSeekMode mode)
{
return OnSysSeek(pos, mode);
}
// wxCountingOutputStream
// ----------------------------------------------------------------------------
+IMPLEMENT_DYNAMIC_CLASS(wxCountingOutputStream, wxOutputStream)
+
wxCountingOutputStream::wxCountingOutputStream ()
{
m_currentPos = 0;
}
-size_t wxCountingOutputStream::GetSize() const
+wxFileOffset wxCountingOutputStream::GetLength() const
{
return m_lastcount;
}
return m_currentPos;
}
-off_t wxCountingOutputStream::OnSysSeek(off_t pos, wxSeekMode mode)
+wxFileOffset wxCountingOutputStream::OnSysSeek(wxFileOffset pos, wxSeekMode mode)
{
+ ssize_t new_pos = wx_truncate_cast(ssize_t, pos);
+
switch ( mode )
{
case wxFromStart:
- m_currentPos = pos;
+ wxCHECK_MSG( (wxFileOffset)new_pos == pos, wxInvalidOffset, wxT("huge position not supported") );
break;
case wxFromEnd:
- m_currentPos = m_lastcount + pos;
+ new_pos = m_lastcount + new_pos;
+ wxCHECK_MSG( (wxFileOffset)new_pos == (wxFileOffset)(m_lastcount + pos), wxInvalidOffset, wxT("huge position not supported") );
break;
case wxFromCurrent:
- m_currentPos += pos;
+ new_pos = m_currentPos + new_pos;
+ wxCHECK_MSG( (wxFileOffset)new_pos == (wxFileOffset)(m_currentPos + pos), wxInvalidOffset, wxT("huge position not supported") );
break;
default:
return wxInvalidOffset;
}
+ m_currentPos = new_pos;
+
if (m_currentPos > m_lastcount)
m_lastcount = m_currentPos;
return m_currentPos;
}
-off_t wxCountingOutputStream::OnSysTell() const
+wxFileOffset wxCountingOutputStream::OnSysTell() const
{
return m_currentPos;
}
// wxFilterInputStream
// ----------------------------------------------------------------------------
+IMPLEMENT_ABSTRACT_CLASS(wxFilterInputStream, wxInputStream)
+
wxFilterInputStream::wxFilterInputStream()
+ : m_parent_i_stream(NULL),
+ m_owns(false)
{
- m_parent_i_stream = NULL;
}
wxFilterInputStream::wxFilterInputStream(wxInputStream& stream)
+ : m_parent_i_stream(&stream),
+ m_owns(false)
+{
+}
+
+wxFilterInputStream::wxFilterInputStream(wxInputStream *stream)
+ : m_parent_i_stream(stream),
+ m_owns(true)
{
- m_parent_i_stream = &stream;
}
wxFilterInputStream::~wxFilterInputStream()
{
+ if (m_owns)
+ delete m_parent_i_stream;
}
// ----------------------------------------------------------------------------
// wxFilterOutputStream
// ----------------------------------------------------------------------------
+IMPLEMENT_ABSTRACT_CLASS(wxFilterOutputStream, wxOutputStream)
+
wxFilterOutputStream::wxFilterOutputStream()
+ : m_parent_o_stream(NULL),
+ m_owns(false)
{
- m_parent_o_stream = NULL;
}
wxFilterOutputStream::wxFilterOutputStream(wxOutputStream& stream)
+ : m_parent_o_stream(&stream),
+ m_owns(false)
+{
+}
+
+wxFilterOutputStream::wxFilterOutputStream(wxOutputStream *stream)
+ : m_parent_o_stream(stream),
+ m_owns(true)
{
- m_parent_o_stream = &stream;
+}
+
+bool wxFilterOutputStream::Close()
+{
+ if (m_parent_o_stream && m_owns)
+ return m_parent_o_stream->Close();
+ else
+ return true;
}
wxFilterOutputStream::~wxFilterOutputStream()
{
+ if (m_owns)
+ delete m_parent_o_stream;
}
// ----------------------------------------------------------------------------
-// wxBufferedInputStream
+// wxFilterClassFactoryBase
// ----------------------------------------------------------------------------
-wxBufferedInputStream::wxBufferedInputStream(wxInputStream& s,
- wxStreamBuffer *buffer)
- : wxFilterInputStream(s)
+IMPLEMENT_ABSTRACT_CLASS(wxFilterClassFactoryBase, wxObject)
+
+wxString wxFilterClassFactoryBase::PopExtension(const wxString& location) const
+{
+ return location.substr(0, FindExtension(location));
+}
+
+wxString::size_type wxFilterClassFactoryBase::FindExtension(
+ const wxString& location) const
{
- if ( buffer )
+ for (const wxChar *const *p = GetProtocols(wxSTREAM_FILEEXT); *p; p++)
{
- // use the buffer provided by the user
- m_i_streambuf = buffer;
+ if ( location.EndsWith(*p) )
+ return location.length() - wxStrlen(*p);
}
- else // create a default buffer
+
+ return wxString::npos;
+}
+
+bool wxFilterClassFactoryBase::CanHandle(const wxString& protocol,
+ wxStreamProtocolType type) const
+{
+ if (type == wxSTREAM_FILEEXT)
+ return FindExtension(protocol) != wxString::npos;
+ else
+ for (const wxChar *const *p = GetProtocols(type); *p; p++)
+ if (protocol == *p)
+ return true;
+
+ return false;
+}
+
+// ----------------------------------------------------------------------------
+// wxFilterClassFactory
+// ----------------------------------------------------------------------------
+
+IMPLEMENT_ABSTRACT_CLASS(wxFilterClassFactory, wxFilterClassFactoryBase)
+
+wxFilterClassFactory *wxFilterClassFactory::sm_first = NULL;
+
+void wxFilterClassFactory::Remove()
+{
+ if (m_next != this)
{
- m_i_streambuf = new wxStreamBuffer(*this, wxStreamBuffer::read);
+ wxFilterClassFactory **pp = &sm_first;
- m_i_streambuf->SetBufferIO(1024);
+ while (*pp != this)
+ pp = &(*pp)->m_next;
+
+ *pp = m_next;
+
+ m_next = this;
}
}
+// ----------------------------------------------------------------------------
+// wxBufferedInputStream
+// ----------------------------------------------------------------------------
+
+namespace
+{
+
+// helper function used for initializing the buffer used by
+// wxBufferedInput/OutputStream: it simply returns the provided buffer if it's
+// not NULL or creates a buffer of the given size otherwise
+template <typename T>
+wxStreamBuffer *
+CreateBufferIfNeeded(T& stream, wxStreamBuffer *buffer, size_t bufsize = 1024)
+{
+ return buffer ? buffer : new wxStreamBuffer(stream, bufsize);
+}
+
+} // anonymous namespace
+
+wxBufferedInputStream::wxBufferedInputStream(wxInputStream& stream,
+ wxStreamBuffer *buffer)
+ : wxFilterInputStream(stream)
+{
+ m_i_streambuf = CreateBufferIfNeeded(*this, buffer);
+}
+
+wxBufferedInputStream::wxBufferedInputStream(wxInputStream& stream,
+ size_t bufsize)
+ : wxFilterInputStream(stream)
+{
+ m_i_streambuf = CreateBufferIfNeeded(*this, NULL, bufsize);
+}
+
wxBufferedInputStream::~wxBufferedInputStream()
{
- m_parent_i_stream->SeekI(-(off_t)m_i_streambuf->GetBytesLeft(),
+ m_parent_i_stream->SeekI(-(wxFileOffset)m_i_streambuf->GetBytesLeft(),
wxFromCurrent);
delete m_i_streambuf;
wxInputStream& wxBufferedInputStream::Read(void *buf, size_t size)
{
// reset the error flag
- m_lasterror = wxStream_NOERROR;
+ Reset();
// first read from the already cached data
m_lastcount = GetWBack(buf, size);
size -= m_lastcount;
buf = (char *)buf + m_lastcount;
- // the call to wxStreamBuffer::Read() below will reset our m_lastcount,
- // so save it
+ // the call to wxStreamBuffer::Read() below may reset our m_lastcount
+ // (but it also may not do it if the buffer is associated to another
+ // existing stream and wasn't created by us), so save it
size_t countOld = m_lastcount;
- m_i_streambuf->Read(buf, size);
+ // the new count of the bytes read is the count of bytes read this time
+ m_lastcount = m_i_streambuf->Read(buf, size);
+ // plus those we had read before
m_lastcount += countOld;
}
return *this;
}
-off_t wxBufferedInputStream::SeekI(off_t pos, wxSeekMode mode)
+wxFileOffset wxBufferedInputStream::SeekI(wxFileOffset pos, wxSeekMode mode)
{
// RR: Look at wxInputStream for comments.
if (m_lasterror==wxSTREAM_EOF)
- m_lasterror=wxSTREAM_NOERROR;
+ Reset();
if (m_wback)
{
wxLogDebug( wxT("Seeking in stream which has data written back to it.") );
-
+
free(m_wback);
m_wback = NULL;
m_wbacksize = 0;
m_wbackcur = 0;
}
-
+
return m_i_streambuf->Seek(pos, mode);
}
-off_t wxBufferedInputStream::TellI() const
+wxFileOffset wxBufferedInputStream::TellI() const
{
- off_t pos = m_i_streambuf->Tell();
+ wxFileOffset pos = m_i_streambuf->Tell();
if (pos != wxInvalidOffset)
pos -= (m_wbacksize - m_wbackcur);
-
+
return pos;
}
return m_parent_i_stream->Read(buffer, bufsize).LastRead();
}
-off_t wxBufferedInputStream::OnSysSeek(off_t seek, wxSeekMode mode)
+wxFileOffset wxBufferedInputStream::OnSysSeek(wxFileOffset seek, wxSeekMode mode)
{
return m_parent_i_stream->SeekI(seek, mode);
}
-off_t wxBufferedInputStream::OnSysTell() const
+wxFileOffset wxBufferedInputStream::OnSysTell() const
{
return m_parent_i_stream->TellI();
}
// wxBufferedOutputStream
// ----------------------------------------------------------------------------
-wxBufferedOutputStream::wxBufferedOutputStream(wxOutputStream& s,
+wxBufferedOutputStream::wxBufferedOutputStream(wxOutputStream& stream,
wxStreamBuffer *buffer)
- : wxFilterOutputStream(s)
+ : wxFilterOutputStream(stream)
{
- if ( buffer )
- {
- m_o_streambuf = buffer;
- }
- else // create a default one
- {
- m_o_streambuf = new wxStreamBuffer(*this, wxStreamBuffer::write);
+ m_o_streambuf = CreateBufferIfNeeded(*this, buffer);
+}
- m_o_streambuf->SetBufferIO(1024);
- }
+wxBufferedOutputStream::wxBufferedOutputStream(wxOutputStream& stream,
+ size_t bufsize)
+ : wxFilterOutputStream(stream)
+{
+ m_o_streambuf = CreateBufferIfNeeded(*this, NULL, bufsize);
}
wxBufferedOutputStream::~wxBufferedOutputStream()
delete m_o_streambuf;
}
+bool wxBufferedOutputStream::Close()
+{
+ Sync();
+ return IsOk();
+}
+
+
wxOutputStream& wxBufferedOutputStream::Write(const void *buffer, size_t size)
{
m_lastcount = 0;
return *this;
}
-off_t wxBufferedOutputStream::SeekO(off_t pos, wxSeekMode mode)
+wxFileOffset wxBufferedOutputStream::SeekO(wxFileOffset pos, wxSeekMode mode)
{
Sync();
return m_o_streambuf->Seek(pos, mode);
}
-off_t wxBufferedOutputStream::TellO() const
+wxFileOffset wxBufferedOutputStream::TellO() const
{
return m_o_streambuf->Tell();
}
return m_parent_o_stream->Write(buffer, bufsize).LastWrite();
}
-off_t wxBufferedOutputStream::OnSysSeek(off_t seek, wxSeekMode mode)
+wxFileOffset wxBufferedOutputStream::OnSysSeek(wxFileOffset seek, wxSeekMode mode)
{
return m_parent_o_stream->SeekO(seek, mode);
}
-off_t wxBufferedOutputStream::OnSysTell() const
+wxFileOffset wxBufferedOutputStream::OnSysTell() const
{
return m_parent_o_stream->TellO();
}
-size_t wxBufferedOutputStream::GetSize() const
+wxFileOffset wxBufferedOutputStream::GetLength() const
{
- return m_parent_o_stream->GetSize() + m_o_streambuf->GetIntPosition();
+ return m_parent_o_stream->GetLength() + m_o_streambuf->GetIntPosition();
}
void wxBufferedOutputStream::SetOutputStreamBuffer(wxStreamBuffer *buffer)
return stream.Write(eol, wxStrlen(eol));
}
-#endif
- // wxUSE_STREAMS
+#endif // wxUSE_STREAMS
projects / wxWidgets.git / blobdiff