X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/915a955caffbbc0982cc4a1952113bcd09d6d009..ce7208d49d5ce2ca1dc0b3b83f14f1d04f29c4bf:/src/common/stream.cpp diff --git a/src/common/stream.cpp b/src/common/stream.cpp index c3c66e9e50..8ae48e1605 100644 --- a/src/common/stream.cpp +++ b/src/common/stream.cpp @@ -7,7 +7,7 @@ // Created: 11/07/98 // RCS-ID: $Id$ // Copyright: (c) Guilhem Lavaux -// Licence: wxWindows license +// Licence: wxWindows licence ///////////////////////////////////////////////////////////////////////////// // ============================================================================ @@ -18,35 +18,31 @@ // 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 -#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 @@ -58,7 +54,7 @@ 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; } @@ -70,50 +66,41 @@ void wxStreamBuffer::InitBuffer() 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) +wxStreamBuffer::wxStreamBuffer(BufMode mode) { Init(); - m_stream = &stream; + m_stream = NULL; m_mode = mode; - m_flushable = TRUE; - m_destroystream = FALSE; + m_flushable = false; } -wxStreamBuffer::wxStreamBuffer(BufMode mode) +wxStreamBuffer::wxStreamBuffer(wxStreamBase& stream, 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 = &stream; m_mode = mode; - m_flushable = FALSE; - m_destroystream = TRUE; + m_flushable = true; } 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; @@ -124,22 +111,21 @@ wxStreamBuffer::wxStreamBuffer(const wxStreamBuffer& buffer) 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 @@ -180,29 +166,30 @@ void wxStreamBuffer::SetBufferIO(void *start, 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; } // fill the buffer with as much data as possible (only for read buffers) @@ -210,39 +197,41 @@ bool wxStreamBuffer::FillBuffer() { 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); 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() @@ -271,6 +260,7 @@ void wxStreamBuffer::GetFromBuffer(void *buffer, size_t size) void wxStreamBuffer::PutToBuffer(const void *buffer, size_t size) { size_t left = GetBytesLeft(); + if ( size > left ) { if ( m_fixed ) @@ -315,7 +305,7 @@ void wxStreamBuffer::PutChar(char c) // 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 { @@ -323,11 +313,11 @@ void wxStreamBuffer::PutChar(char c) 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; } } @@ -340,12 +330,12 @@ char wxStreamBuffer::Peek() 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; @@ -360,18 +350,18 @@ char wxStreamBuffer::GetChar() 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; } } @@ -381,16 +371,23 @@ char wxStreamBuffer::GetChar() 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 { @@ -410,7 +407,7 @@ size_t wxStreamBuffer::Read(void *buffer, size_t size) if ( !FillBuffer() ) { - SetError(wxStream_EOF); + SetError(wxSTREAM_EOF); break; } } @@ -421,10 +418,13 @@ size_t wxStreamBuffer::Read(void *buffer, size_t size) } } - 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()" @@ -438,7 +438,7 @@ size_t wxStreamBuffer::Read(wxStreamBuffer *dbuf) do { - nRead = Read(dbuf, WXSIZEOF(buf)); + nRead = Read(buf, WXSIZEOF(buf)); if ( nRead ) { nRead = dbuf->Write(buf, nRead); @@ -452,17 +452,24 @@ size_t wxStreamBuffer::Read(wxStreamBuffer *dbuf) 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 { @@ -480,6 +487,7 @@ size_t wxStreamBuffer::Write(const void *buffer, size_t size) // // 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); @@ -488,7 +496,7 @@ size_t wxStreamBuffer::Write(const void *buffer, size_t size) if ( !FlushBuffer() ) { - SetError(wxStream_WRITE_ERR); + SetError(wxSTREAM_WRITE_ERROR); break; } @@ -502,10 +510,16 @@ size_t wxStreamBuffer::Write(const void *buffer, size_t size) } } - m_stream->m_lastcount = orig_size - size; + ret = orig_size - size; } - return m_stream->m_lastcount; + if (m_stream) + { + // i am not entirely sure what we do this for + m_stream->m_lastcount = ret; + } + + return ret; } size_t wxStreamBuffer::Write(wxStreamBuffer *sbuf) @@ -543,11 +557,11 @@ 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 ) { @@ -572,7 +586,9 @@ off_t wxStreamBuffer::Seek(off_t pos, wxSeekMode mode) } 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; } @@ -597,7 +613,9 @@ off_t wxStreamBuffer::Seek(off_t pos, wxSeekMode mode) } 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; } @@ -611,14 +629,12 @@ off_t wxStreamBuffer::Seek(off_t pos, wxSeekMode mode) 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 ) @@ -643,7 +659,7 @@ off_t wxStreamBuffer::Tell() const wxStreamBase::wxStreamBase() { - m_lasterror = wxStream_NOERROR; + m_lasterror = wxSTREAM_NO_ERROR; m_lastcount = 0; } @@ -651,12 +667,24 @@ wxStreamBase::~wxStreamBase() { } -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; } @@ -677,31 +705,19 @@ wxInputStream::~wxInputStream() 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) @@ -730,21 +746,26 @@ 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; @@ -763,52 +784,81 @@ size_t wxInputStream::GetWBack(void *buf, size_t bsize) 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 + return 0; + } + char *ptrback = AllocSpaceWBack(bufsize); if (!ptrback) return 0; + // Eof() shouldn't return true any longer + if ( m_lasterror == wxSTREAM_EOF ) + m_lasterror = wxSTREAM_NO_ERROR; + memcpy(ptrback, buf, bufsize); return bufsize; } bool wxInputStream::Ungetch(char c) { - void *ptrback = AllocSpaceWBack(1); - if (!ptrback) - return FALSE; - - *(char *)ptrback = c; - return TRUE; + 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) { - size_t retsize = GetWBack(buf, size); - if (retsize == size) + wxASSERT_MSG( buf, _T("Warning: Null pointer is about to be read") ); + + char *p = (char *)buf; + m_lastcount = 0; + + size_t read = GetWBack(buf, size); + for ( ;; ) { - m_lastcount = size; - m_lasterror = wxStream_NOERROR; - return *this; + size -= read; + m_lastcount += read; + p += read; + + if ( !size ) + { + // we read the requested amount of data + break; + } + + 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 + break; + } } - size -= retsize; - buf = (char *)buf + retsize; - m_lastcount = OnSysRead(buf, size) + retsize; return *this; } 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; @@ -820,17 +870,21 @@ char wxInputStream::Peek() wxInputStream& wxInputStream::Read(wxOutputStream& stream_out) { 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; } + 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 @@ -839,7 +893,7 @@ off_t wxInputStream::SeekI(off_t pos, wxSeekMode mode) // 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 @@ -850,11 +904,11 @@ off_t wxInputStream::SeekI(off_t pos, wxSeekMode mode) 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; @@ -864,9 +918,9 @@ off_t wxInputStream::SeekI(off_t pos, wxSeekMode mode) 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); @@ -895,7 +949,7 @@ size_t wxOutputStream::OnSysWrite(const void * WXUNUSED(buffer), void wxOutputStream::PutC(char c) { - Write(&c, 1); + Write(&c, sizeof(c)); } wxOutputStream& wxOutputStream::Write(const void *buffer, size_t size) @@ -910,12 +964,12 @@ wxOutputStream& wxOutputStream::Write(wxInputStream& stream_in) 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); } @@ -934,7 +988,7 @@ wxCountingOutputStream::wxCountingOutputStream () m_currentPos = 0; } -size_t wxCountingOutputStream::GetSize() const +wxFileOffset wxCountingOutputStream::GetLength() const { return m_lastcount; } @@ -949,20 +1003,24 @@ size_t wxCountingOutputStream::OnSysWrite(const void *WXUNUSED(buffer), 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: @@ -970,13 +1028,15 @@ off_t wxCountingOutputStream::OnSysSeek(off_t pos, wxSeekMode mode) 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; } @@ -986,17 +1046,27 @@ off_t wxCountingOutputStream::OnSysTell() const // ---------------------------------------------------------------------------- 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; } // ---------------------------------------------------------------------------- @@ -1004,17 +1074,98 @@ wxFilterInputStream::~wxFilterInputStream() // ---------------------------------------------------------------------------- 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) +{ +} + +bool wxFilterOutputStream::Close() { - m_parent_o_stream = &stream; + 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; +} + +// ---------------------------------------------------------------------------- +// wxFilterClassFactoryBase +// ---------------------------------------------------------------------------- + +IMPLEMENT_ABSTRACT_CLASS(wxFilterClassFactoryBase, wxObject) + +wxString wxFilterClassFactoryBase::PopExtension(const wxString& location) const +{ + return location.substr(0, FindExtension(location)); +} + +wxString::size_type wxFilterClassFactoryBase::FindExtension( + const wxChar *location) const +{ + size_t len = wxStrlen(location); + + for (const wxChar *const *p = GetProtocols(wxSTREAM_FILEEXT); *p; p++) + { + size_t l = wxStrlen(*p); + + if (l <= len && wxStrcmp(*p, location + len - l) == 0) + return len - l; + } + + return wxString::npos; +} + +bool wxFilterClassFactoryBase::CanHandle(const wxChar *protocol, + wxStreamProtocolType type) const +{ + if (type == wxSTREAM_FILEEXT) + return FindExtension(protocol) != wxString::npos; + else + for (const wxChar *const *p = GetProtocols(type); *p; p++) + if (wxStrcmp(*p, protocol) == 0) + return true; + + return false; +} + +// ---------------------------------------------------------------------------- +// wxFilterClassFactory +// ---------------------------------------------------------------------------- + +IMPLEMENT_ABSTRACT_CLASS(wxFilterClassFactory, wxFilterClassFactoryBase) + +wxFilterClassFactory *wxFilterClassFactory::sm_first = NULL; + +void wxFilterClassFactory::Remove() +{ + if (m_next != this) + { + wxFilterClassFactory **pp = &sm_first; + + while (*pp != this) + pp = &(*pp)->m_next; + + *pp = m_next; + + m_next = this; + } } // ---------------------------------------------------------------------------- @@ -1040,7 +1191,7 @@ wxBufferedInputStream::wxBufferedInputStream(wxInputStream& s, 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; @@ -1054,7 +1205,7 @@ char wxBufferedInputStream::Peek() 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); @@ -1077,33 +1228,33 @@ wxInputStream& wxBufferedInputStream::Read(void *buf, size_t size) 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; } @@ -1112,12 +1263,12 @@ size_t wxBufferedInputStream::OnSysRead(void *buffer, size_t bufsize) 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(); } @@ -1156,6 +1307,13 @@ wxBufferedOutputStream::~wxBufferedOutputStream() delete m_o_streambuf; } +bool wxBufferedOutputStream::Close() +{ + Sync(); + return IsOk(); +} + + wxOutputStream& wxBufferedOutputStream::Write(const void *buffer, size_t size) { m_lastcount = 0; @@ -1163,13 +1321,13 @@ wxOutputStream& wxBufferedOutputStream::Write(const void *buffer, size_t size) 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(); } @@ -1185,19 +1343,19 @@ size_t wxBufferedOutputStream::OnSysWrite(const void *buffer, size_t bufsize) 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) @@ -1219,5 +1377,4 @@ wxOutputStream& wxEndL(wxOutputStream& stream) return stream.Write(eol, wxStrlen(eol)); } -#endif - // wxUSE_STREAMS +#endif // wxUSE_STREAMS