X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/999836aacade840a5d9a0cbb5fad7b1d4de62c93..8cbc59fe84f046685b873cf58f6c56debe59de1c:/src/common/stream.cpp diff --git a/src/common/stream.cpp b/src/common/stream.cpp index 1f72c00bd6..657e6675d4 100644 --- a/src/common/stream.cpp +++ b/src/common/stream.cpp @@ -18,28 +18,24 @@ // headers // ---------------------------------------------------------------------------- -#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA) - #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 @@ -67,37 +63,36 @@ void wxStreamBuffer::InitBuffer() 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(BufMode mode) +void wxStreamBuffer::InitWithStream(wxStreamBase& stream, BufMode mode) { Init(); - m_stream = NULL; + m_stream = &stream; m_mode = mode; - m_flushable = FALSE; + m_flushable = 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_flushable = false; } wxStreamBuffer::wxStreamBuffer(const wxStreamBuffer& buffer) @@ -110,18 +105,20 @@ wxStreamBuffer::wxStreamBuffer(const wxStreamBuffer& 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_destroybuf = false; } void wxStreamBuffer::FreeBuffer() { if ( m_destroybuf ) + { free(m_buffer_start); + m_buffer_start = NULL; + } } wxStreamBuffer::~wxStreamBuffer() @@ -157,8 +154,6 @@ void wxStreamBuffer::SetBufferIO(void *start, 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; @@ -167,15 +162,15 @@ 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(); } } @@ -193,46 +188,67 @@ void wxStreamBuffer::ResetBuffer() : 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) bool wxStreamBuffer::FillBuffer() { wxInputStream *inStream = GetInputStream(); - // It's legal to have no stream, so we don't complain about it just return FALSE + // It's legal to have no stream, so we don't complain about it just return false if ( !inStream ) - return FALSE; + 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() @@ -272,24 +288,26 @@ void wxStreamBuffer::PutToBuffer(const void *buffer, size_t size) 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; + + // 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 + m_buffer_size; + // 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 } } @@ -372,18 +390,23 @@ char wxStreamBuffer::GetChar() size_t wxStreamBuffer::Read(void *buffer, size_t size) { + wxASSERT_MSG( buffer, _T("Warning: Null pointer is about to be used") ); + + /* Clear buffer first */ + memset(buffer, 0x00, size); + // lasterror is reset before all new IO calls if ( m_stream ) m_stream->Reset(); - size_t read; + size_t readBytes; if ( !HasBuffer() ) { wxInputStream *inStream = GetInputStream(); wxCHECK_MSG( inStream, 0, _T("should have a stream in wxStreamBuffer") ); - read = inStream->OnSysRead(buffer, size); + readBytes = inStream->OnSysRead(buffer, size); } else // we have a buffer, use it { @@ -414,13 +437,13 @@ size_t wxStreamBuffer::Read(void *buffer, size_t size) } } - read = orig_size - size; + readBytes = orig_size - size; } if ( m_stream ) - m_stream->m_lastcount = read; + m_stream->m_lastcount = readBytes; - return read; + return readBytes; } // this should really be called "Copy()" @@ -434,7 +457,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); @@ -448,6 +471,8 @@ size_t wxStreamBuffer::Read(wxStreamBuffer *dbuf) size_t wxStreamBuffer::Write(const void *buffer, size_t size) { + wxASSERT_MSG( buffer, _T("Warning: Null pointer is about to be send") ); + if (m_stream) { // lasterror is reset before all new IO calls @@ -551,11 +576,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 ) { @@ -580,7 +605,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; } @@ -605,7 +632,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; } @@ -619,9 +648,9 @@ 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; // ask the stream for position if we have a real one if ( m_stream ) @@ -647,6 +676,8 @@ off_t wxStreamBuffer::Tell() const // wxStreamBase // ---------------------------------------------------------------------------- +IMPLEMENT_ABSTRACT_CLASS(wxStreamBase, wxObject) + wxStreamBase::wxStreamBase() { m_lasterror = wxSTREAM_NO_ERROR; @@ -657,12 +688,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; } @@ -671,6 +714,8 @@ off_t wxStreamBase::OnSysTell() const // wxInputStream // ---------------------------------------------------------------------------- +IMPLEMENT_ABSTRACT_CLASS(wxInputStream, wxStreamBase) + wxInputStream::wxInputStream() { m_wback = NULL; @@ -726,6 +771,11 @@ char *wxInputStream::AllocSpaceWBack(size_t needed_size) 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; @@ -757,6 +807,8 @@ size_t wxInputStream::GetWBack(void *buf, size_t size) 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 @@ -767,7 +819,7 @@ size_t wxInputStream::Ungetch(const void *buf, size_t bufsize) 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; @@ -780,15 +832,17 @@ bool wxInputStream::Ungetch(char c) return Ungetch(&c, sizeof(c)) != 0; } -char wxInputStream::GetC() +int wxInputStream::GetC() { - char c; + unsigned char c; Read(&c, sizeof(c)); - return 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; @@ -838,6 +892,7 @@ char wxInputStream::Peek() wxInputStream& wxInputStream::Read(wxOutputStream& stream_out) { + size_t lastcount = 0; char buf[BUF_TEMP_SIZE]; for ( ;; ) @@ -848,12 +903,16 @@ wxInputStream& wxInputStream::Read(wxOutputStream& stream_out) 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 @@ -887,9 +946,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); @@ -902,6 +961,8 @@ off_t wxInputStream::TellI() const // wxOutputStream // ---------------------------------------------------------------------------- +IMPLEMENT_ABSTRACT_CLASS(wxOutputStream, wxStreamBase) + wxOutputStream::wxOutputStream() { } @@ -933,12 +994,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); } @@ -952,12 +1013,14 @@ void wxOutputStream::Sync() // wxCountingOutputStream // ---------------------------------------------------------------------------- +IMPLEMENT_DYNAMIC_CLASS(wxCountingOutputStream, wxOutputStream) + wxCountingOutputStream::wxCountingOutputStream () { m_currentPos = 0; } -size_t wxCountingOutputStream::GetSize() const +wxFileOffset wxCountingOutputStream::GetLength() const { return m_lastcount; } @@ -972,20 +1035,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: @@ -993,13 +1060,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; } @@ -1008,62 +1077,165 @@ off_t wxCountingOutputStream::OnSysTell() const // 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; + + while (*pp != this) + pp = &(*pp)->m_next; - m_i_streambuf->SetBufferIO(1024); + *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 +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; @@ -1088,19 +1260,22 @@ wxInputStream& wxBufferedInputStream::Read(void *buf, size_t 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. @@ -1120,9 +1295,9 @@ off_t wxBufferedInputStream::SeekI(off_t pos, wxSeekMode mode) 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); @@ -1135,12 +1310,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(); } @@ -1157,20 +1332,18 @@ void wxBufferedInputStream::SetInputStreamBuffer(wxStreamBuffer *buffer) // 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() @@ -1179,6 +1352,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; @@ -1186,13 +1366,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(); } @@ -1208,19 +1388,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) @@ -1242,5 +1422,4 @@ wxOutputStream& wxEndL(wxOutputStream& stream) return stream.Write(eol, wxStrlen(eol)); } -#endif - // wxUSE_STREAMS +#endif // wxUSE_STREAMS