X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/f4a8c29f7a3ffa7eb60d9b7f055565eb2df368d9..d05237ea7ba713f5dd0af8ffb4ac62e3b0cd69c7:/src/common/stream.cpp diff --git a/src/common/stream.cpp b/src/common/stream.cpp index f25f6381fb..4f24cfc97a 100644 --- a/src/common/stream.cpp +++ b/src/common/stream.cpp @@ -24,62 +24,102 @@ #pragma hdrstop #endif +#define BUF_TEMP_SIZE 10000 + // ---------------------------------------------------------------------------- // wxStreamBuffer // ---------------------------------------------------------------------------- -wxStreamBuffer::wxStreamBuffer(wxInputStream& i_stream) +#define CHECK_ERROR(err) \ + if (m_stream->m_lasterror == wxStream_NOERROR) \ + m_stream->m_lasterror = err + +wxStreamBuffer::wxStreamBuffer(wxStreamBase& stream, BufMode mode) : m_buffer_start(NULL), m_buffer_end(NULL), m_buffer_pos(NULL), - m_buffer_size(0), m_istream(&i_stream), m_ostream(NULL) + m_buffer_size(0), m_wback(NULL), m_wbacksize(0), m_wbackcur(0), + m_fixed(TRUE), m_flushable(TRUE), m_stream(&stream), + m_mode(mode), m_destroybuf(FALSE), m_destroystream(FALSE) { } -wxStreamBuffer::wxStreamBuffer(wxOutputStream& o_stream) +wxStreamBuffer::wxStreamBuffer(BufMode mode) : m_buffer_start(NULL), m_buffer_end(NULL), m_buffer_pos(NULL), - m_buffer_size(0), m_istream(NULL), m_ostream(&o_stream) + m_buffer_size(0), m_wback(NULL), m_wbacksize(0), m_wbackcur(0), + m_fixed(TRUE), m_flushable(FALSE), m_stream(NULL), + m_mode(mode), m_destroybuf(FALSE), m_destroystream(TRUE) +{ + m_stream = new wxStreamBase(); +} + +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_destroystream = FALSE; + m_wback = NULL; + m_wbacksize = 0; + m_wbackcur = 0; } wxStreamBuffer::~wxStreamBuffer() { - wxDELETEA(m_buffer_start); + if (m_wback) + free(m_wback); + if (m_destroybuf) + wxDELETEA(m_buffer_start); + if (m_destroystream) + delete m_stream; } -void wxStreamBuffer::WriteBack(char c) +size_t wxStreamBuffer::WriteBack(const char *buf, size_t bufsize) { - if (m_ostream) - return; + char *ptrback; - // Assume that if we write "back" we have read a few bytes: so we have some - // space. - if (m_buffer_pos == m_buffer_start) - return; + ptrback = AllocSpaceWBack(bufsize); + if (!ptrback) + return 0; - m_buffer_pos--; - *m_buffer_pos = c; + memcpy(ptrback, buf, bufsize); + return bufsize; } -void wxStreamBuffer::SetBufferIO(char *buffer_start, char *buffer_end) +bool wxStreamBuffer::WriteBack(char c) { - size_t ret; + char *ptrback; + + ptrback = AllocSpaceWBack(1); + if (!ptrback) + return FALSE; + + *ptrback = c; + return TRUE; +} +void wxStreamBuffer::SetBufferIO(char *buffer_start, char *buffer_end) +{ + if (m_destroybuf) + wxDELETEA(m_buffer_start); m_buffer_start = buffer_start; m_buffer_end = buffer_end; m_buffer_size = m_buffer_end-m_buffer_start; - - if (m_istream) { - ret = m_istream->DoRead(m_buffer_start, m_buffer_size); - m_buffer_end = m_buffer_start + ret; - } - m_buffer_pos = m_buffer_start; + m_destroybuf = FALSE; + ResetBuffer(); } void wxStreamBuffer::SetBufferIO(size_t bufsize) { char *b_start; - wxDELETE(m_buffer_start); + if (m_destroybuf) + wxDELETEA(m_buffer_start); if (!bufsize) { m_buffer_start = NULL; @@ -90,89 +130,229 @@ void wxStreamBuffer::SetBufferIO(size_t bufsize) } b_start = new char[bufsize]; - SetBufferIO(b_start, b_start + bufsize); + m_destroybuf = TRUE; } void wxStreamBuffer::ResetBuffer() { - if (m_istream) + if (m_mode == read) m_buffer_pos = m_buffer_end; else m_buffer_pos = m_buffer_start; } -void wxStreamBuffer::Read(void *buffer, size_t size) +char *wxStreamBuffer::AllocSpaceWBack(size_t needed_size) { - wxASSERT(m_istream != NULL); + char *temp_b; - // ------------------ - // Buffering disabled - // ------------------ + m_wbacksize += needed_size; + + if (!m_wback) + temp_b = (char *)malloc(m_wbacksize); + else + temp_b = (char *)realloc(m_wback, m_wbacksize); + + if (!temp_b) + return NULL; + m_wback = temp_b; + printf("Buffer(0x%x)->Write: 0x%x, %d\n", this, m_wback, m_wbacksize); + return (char *)(m_wback+(m_wbacksize-needed_size)); +} + +size_t wxStreamBuffer::GetWBack(char *buf, size_t bsize) +{ + size_t s_toget = m_wbacksize-m_wbackcur; + + printf("Buffer(0x%x): 0x%x, %d\n", this, m_wback, m_wbacksize); + if (bsize < s_toget) + s_toget = bsize; + + memcpy(buf, (m_wback+m_wbackcur), s_toget); + + m_wbackcur += s_toget; + if (m_wbackcur == m_wbacksize) { + free(m_wback); + m_wback = (char *)NULL; + m_wbacksize = 0; + m_wbackcur = 0; + } + + return s_toget; +} + +bool wxStreamBuffer::FillBuffer() +{ + size_t count; + + count = m_stream->OnSysRead(m_buffer_start, m_buffer_size); + m_buffer_end = m_buffer_start+count; + m_buffer_pos = m_buffer_start; + + if (count == 0) + return FALSE; + return TRUE; +} + +bool wxStreamBuffer::FlushBuffer() +{ + size_t count, current; + + if (m_buffer_pos == m_buffer_start || !m_flushable) + return FALSE; + + current = m_buffer_pos-m_buffer_start; + count = m_stream->OnSysWrite(m_buffer_start, current); + if (count != current) + return FALSE; + m_buffer_pos = m_buffer_start; + + return TRUE; +} + +void wxStreamBuffer::GetFromBuffer(void *buffer, size_t size) +{ + size_t s_toget = m_buffer_end-m_buffer_pos; + + if (size < s_toget) + s_toget = size; + + memcpy(buffer, m_buffer_pos, s_toget); + m_buffer_pos += s_toget; +} + +void wxStreamBuffer::PutToBuffer(const void *buffer, size_t size) +{ + size_t s_toput = m_buffer_end-m_buffer_pos; + + if (s_toput < size && !m_fixed) { + m_buffer_start = (char *)realloc(m_buffer_start, m_buffer_size+size); + // I round a bit + m_buffer_size += size; + m_buffer_end = m_buffer_start+m_buffer_size; + s_toput = size; + } + if (s_toput > size) + s_toput = size; + memcpy(m_buffer_pos, buffer, s_toput); + m_buffer_pos += s_toput; +} + +void wxStreamBuffer::PutChar(char c) +{ + wxASSERT(m_stream != NULL); if (!m_buffer_size) { - m_istream->m_lastread = m_istream->DoRead(buffer, size); + m_stream->OnSysWrite(&c, 1); return; } + if (!GetDataLeft() && !FlushBuffer()) { + CHECK_ERROR(wxStream_READ_ERR); + return; + } + + PutToBuffer(&c, 1); + m_stream->m_lastcount = 1; +} + +char wxStreamBuffer::GetChar() +{ + char c; + + wxASSERT(m_stream != NULL); + + if (!m_buffer_size) { + m_stream->OnSysRead(&c, 1); + return c; + } + + if (!GetDataLeft()) { + CHECK_ERROR(wxStream_READ_ERR); + return 0; + } + + GetFromBuffer(&c, 1); + m_stream->m_lastcount = 1; + return c; +} + +size_t wxStreamBuffer::Read(void *buffer, size_t size) +{ + wxASSERT(m_stream != NULL); + + // ------------------ + // Buffering disabled + // ------------------ + + m_stream->m_lastcount = GetWBack((char *)buffer, size); + size -= m_stream->m_lastcount; + if (size == 0) + return m_stream->m_lastcount; + + buffer = (void *)((char *)buffer+m_stream->m_lastcount); + + if (!m_buffer_size) + return (m_stream->m_lastcount += m_stream->OnSysRead(buffer, size)); + // ----------------- // Buffering enabled // ----------------- size_t buf_left, orig_size = size; - size_t read_ret; while (size > 0) { - buf_left = m_buffer_end - m_buffer_pos; + buf_left = GetDataLeft(); // First case: the requested buffer is larger than the stream buffer, - // we split + // we split it. if (size > buf_left) { - memcpy(buffer, m_buffer_pos, buf_left); - size -= buf_left; + GetFromBuffer(buffer, buf_left); + size -= buf_left; buffer = (char *)buffer + buf_left; // ANSI C++ violation. - read_ret = m_istream->DoRead(m_buffer_start, m_buffer_size); - - // Read failed: EOF - if (read_ret == 0) { - m_istream->m_lastread = orig_size-size; - m_istream->m_eof = TRUE; - m_buffer_pos = m_buffer_end = m_buffer_start; - return; - } else { - m_buffer_end = m_buffer_start+read_ret; - m_buffer_pos = m_buffer_start; + if (!FillBuffer()) { + CHECK_ERROR(wxStream_READ_ERR); + return (m_stream->m_lastcount = orig_size-size); } } else { // Second case: we just copy from the stream buffer. - memcpy(buffer, m_buffer_pos, size); - m_buffer_pos += size; + GetFromBuffer(buffer, size); break; } } - m_istream->m_lastread = orig_size; + return (m_stream->m_lastcount += orig_size); } -void wxStreamBuffer::Write(const void *buffer, size_t size) +size_t wxStreamBuffer::Read(wxStreamBuffer *s_buf) { - wxASSERT(m_ostream != NULL); + char buf[BUF_TEMP_SIZE]; + size_t s = 0, bytes_read = BUF_TEMP_SIZE; + + while (bytes_read == BUF_TEMP_SIZE) { + bytes_read = Read(buf, bytes_read); + bytes_read = s_buf->Write(buf, bytes_read); + s += bytes_read; + } + return s; +} + +size_t wxStreamBuffer::Write(const void *buffer, size_t size) +{ + wxASSERT(m_stream != NULL); // ------------------ // Buffering disabled // ------------------ - if (!m_buffer_size) { - m_ostream->m_lastwrite = m_ostream->DoWrite(buffer, size); - return; - } + if (!m_buffer_size) + return (m_stream->m_lastcount = m_stream->OnSysWrite(buffer, size)); // ------------------ // Buffering enabled // ------------------ size_t buf_left, orig_size = size; - size_t write_ret; while (size > 0) { buf_left = m_buffer_end - m_buffer_pos; @@ -180,29 +360,136 @@ void wxStreamBuffer::Write(const void *buffer, size_t size) // First case: the buffer to write is larger than the stream buffer, // we split it if (size > buf_left) { - memcpy(m_buffer_pos, buffer, buf_left); + PutToBuffer(buffer, buf_left); size -= buf_left; buffer = (char *)buffer + buf_left; // ANSI C++ violation. - write_ret = m_ostream->DoWrite(m_buffer_start, m_buffer_size); - if (write_ret != m_buffer_size) { - m_ostream->m_bad = TRUE; - m_ostream->m_lastwrite = orig_size-size; - m_buffer_pos = m_buffer_end = m_buffer_start; - return; + if (!FlushBuffer()) { + CHECK_ERROR(wxStream_WRITE_ERR); + return (m_stream->m_lastcount = orig_size-size); } + m_buffer_pos = m_buffer_start; } else { // Second case: just copy it in the stream buffer. - - memcpy(m_buffer_pos, buffer, size); - m_buffer_pos += size; + PutToBuffer(buffer, size); break; } } - m_ostream->m_lastwrite = orig_size; + return (m_stream->m_lastcount = orig_size); +} + +size_t wxStreamBuffer::Write(wxStreamBuffer *sbuf) +{ + char buf[BUF_TEMP_SIZE]; + size_t s = 0, bytes_count = BUF_TEMP_SIZE, b_count2; + + while (bytes_count == BUF_TEMP_SIZE) { + b_count2 = sbuf->Read(buf, bytes_count); + bytes_count = Write(buf, b_count2); + if (b_count2 > bytes_count) + sbuf->WriteBack(buf+bytes_count, b_count2-bytes_count); + s += bytes_count; + } + return s; +} + +off_t wxStreamBuffer::Seek(off_t pos, wxSeekMode mode) +{ + off_t ret_off, diff, last_access; + + last_access = GetLastAccess(); + + if (!m_flushable) { + diff = pos + GetIntPosition(); + if (diff < 0 || diff > last_access) + return wxInvalidOffset; + SetIntPosition(diff); + return diff; + } + + switch (mode) { + case wxFromStart: { + // We'll try to compute an internal position later ... + ret_off = m_stream->OnSysSeek(pos, wxFromStart); + ResetBuffer(); + return ret_off; + } + case wxFromCurrent: { + diff = pos + GetIntPosition(); + + if ( (diff > last_access) || (diff < 0) ) { + ret_off = m_stream->OnSysSeek(pos, wxFromCurrent); + ResetBuffer(); + return ret_off; + } else { + SetIntPosition(diff); + return pos; + } + } + case wxFromEnd: + // Hard to compute: always seek to the requested position. + ret_off = m_stream->OnSysSeek(pos, wxFromEnd); + ResetBuffer(); + return ret_off; + } + return wxInvalidOffset; +} + +off_t wxStreamBuffer::Tell() const +{ + off_t pos; + + if (m_flushable) { + pos = m_stream->OnSysTell(); + if (pos == wxInvalidOffset) + return wxInvalidOffset; + return pos - GetLastAccess() + GetIntPosition(); + } else + return GetIntPosition(); +} + +size_t wxStreamBuffer::GetDataLeft() +{ + if (m_buffer_end == m_buffer_pos && m_flushable) + FillBuffer(); + return m_buffer_end-m_buffer_pos; +} + +// ---------------------------------------------------------------------------- +// wxStreamBase +// ---------------------------------------------------------------------------- + +wxStreamBase::wxStreamBase() +{ + m_lasterror = wxStream_NOERROR; + m_lastcount = 0; +} + +wxStreamBase::~wxStreamBase() +{ +} + +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; +} + +off_t wxStreamBase::OnSysTell() const +{ + return wxInvalidOffset; } // ---------------------------------------------------------------------------- @@ -210,19 +497,17 @@ void wxStreamBuffer::Write(const void *buffer, size_t size) // ---------------------------------------------------------------------------- wxInputStream::wxInputStream() + : wxStreamBase() { m_i_destroybuf = TRUE; - m_i_streambuf = new wxStreamBuffer(*this); - m_eof = FALSE; - m_lastread = 0; + m_i_streambuf = new wxStreamBuffer(*this, wxStreamBuffer::read); } wxInputStream::wxInputStream(wxStreamBuffer *buffer) + : wxStreamBase() { m_i_destroybuf = FALSE; m_i_streambuf = buffer; - m_eof = FALSE; - m_lastread = 0; } wxInputStream::~wxInputStream() @@ -245,21 +530,40 @@ wxInputStream& wxInputStream::Read(void *buffer, size_t size) return *this; } -#define BUF_TEMP_SIZE 10000 +char wxInputStream::Peek() +{ + m_i_streambuf->GetDataLeft(); + + return *(m_i_streambuf->GetBufferPos()); +} + wxInputStream& wxInputStream::Read(wxOutputStream& stream_out) { char buf[BUF_TEMP_SIZE]; size_t bytes_read = BUF_TEMP_SIZE; - while (bytes_read == BUF_TEMP_SIZE && !stream_out.Bad()) { + while (bytes_read == BUF_TEMP_SIZE) { bytes_read = Read(buf, bytes_read).LastRead(); - - stream_out.Write(buf, bytes_read); + bytes_read = stream_out.Write(buf, bytes_read).LastWrite(); } return *this; } +off_t wxInputStream::SeekI(off_t pos, wxSeekMode mode) +{ + return m_i_streambuf->Seek(pos, mode); +} + +off_t wxInputStream::TellI() const +{ + return m_i_streambuf->Tell(); +} + +// -------------------- +// Overloaded operators +// -------------------- + wxInputStream& wxInputStream::operator>>(wxString& line) { wxDataInputStream s(*this); @@ -322,7 +626,7 @@ wxInputStream& wxInputStream::operator>>(long& i) return *this; } -wxInputStream& wxInputStream::operator>>(float& f) +wxInputStream& wxInputStream::operator>>(double& f) { /* I only implemented a simple float parser */ int c, sign; @@ -343,16 +647,16 @@ wxInputStream& wxInputStream::operator>>(float& f) sign = 1; while (isdigit(c)) { - f = f*10 + c; + f = f*10 + (c - '0'); c = GetC(); } if (c == '.') { - float f_multiplicator = 0.1; + double f_multiplicator = (double) 0.1; c = GetC(); while (isdigit(c)) { - f += c*f_multiplicator; + f += (c-'0')*f_multiplicator; f_multiplicator /= 10; c = GetC(); } @@ -363,73 +667,31 @@ wxInputStream& wxInputStream::operator>>(float& f) return *this; } +#if wxUSE_SERIAL wxInputStream& wxInputStream::operator>>(wxObject *& obj) { wxObjectInputStream obj_s(*this); obj = obj_s.LoadObject(); return *this; } +#endif -off_t wxInputStream::SeekI(off_t pos, wxSeekMode mode) -{ - off_t ret_off, diff, last_access; - - last_access = m_i_streambuf->GetLastAccess(); - - switch (mode) { - case wxFromStart: - diff = DoTellInput() - pos; - if ( diff < 0 || diff > last_access ) { - ret_off = DoSeekInput(pos, wxFromStart); - m_i_streambuf->ResetBuffer(); - return ret_off; - } else { - m_i_streambuf->SetIntPosition(last_access - diff); - return pos; - } - case wxFromCurrent: - diff = pos + m_i_streambuf->GetIntPosition(); - - if ( (diff > last_access) || (diff < 0) ) { - ret_off = DoSeekInput(pos, wxFromCurrent); - m_i_streambuf->ResetBuffer(); - return ret_off; - } else { - m_i_streambuf->SetIntPosition(diff); - return pos; - } - case wxFromEnd: - // Hard to compute: always seek to the requested position. - ret_off = DoSeekInput(pos, wxFromEnd); - m_i_streambuf->ResetBuffer(); - return ret_off; - } - return wxInvalidOffset; -} - -off_t wxInputStream::TellI() const -{ - return DoTellInput() - m_i_streambuf->GetLastAccess() + - m_i_streambuf->GetIntPosition(); -} // ---------------------------------------------------------------------------- // wxOutputStream // ---------------------------------------------------------------------------- wxOutputStream::wxOutputStream() + : wxStreamBase() { m_o_destroybuf = TRUE; - m_o_streambuf = new wxStreamBuffer(*this); - m_bad = FALSE; - m_lastwrite = 0; + m_o_streambuf = new wxStreamBuffer(*this, wxStreamBuffer::write); } wxOutputStream::wxOutputStream(wxStreamBuffer *buffer) + : wxStreamBase() { m_o_destroybuf = FALSE; m_o_streambuf = buffer; - m_bad = FALSE; - m_lastwrite = 0; } wxOutputStream::~wxOutputStream() @@ -450,49 +712,19 @@ wxOutputStream& wxOutputStream::Write(wxInputStream& stream_in) return *this; } -off_t wxOutputStream::SeekO(off_t pos, wxSeekMode mode) +off_t wxOutputStream::TellO() const { - off_t ret_off; - - switch (mode) { - case wxFromStart: - if ( (unsigned)abs (DoTellOutput()-pos) > m_o_streambuf->GetLastAccess() ) { - ret_off = DoSeekOutput(pos, wxFromStart); - m_o_streambuf->ResetBuffer(); - return ret_off; - } else { - m_o_streambuf->SetIntPosition( DoTellOutput() - pos); - return pos; - } - case wxFromCurrent: - if ( ((unsigned)pos > m_o_streambuf->GetLastAccess()) || (pos < 0) ) { - ret_off = DoSeekOutput(pos, wxFromCurrent); - m_o_streambuf->ResetBuffer(); - return ret_off; - } else { - m_o_streambuf->SetIntPosition(pos); - return pos; - } - case wxFromEnd: - // Hard to compute: always seek to the requested position. - ret_off = DoSeekOutput(pos, wxFromEnd); - m_o_streambuf->ResetBuffer(); - return ret_off; - } - return wxInvalidOffset; + return m_o_streambuf->Tell(); } -off_t wxOutputStream::TellO() const +off_t wxOutputStream::SeekO(off_t pos, wxSeekMode mode) { - return DoTellOutput() - m_o_streambuf->GetLastAccess() - + m_o_streambuf->GetIntPosition(); + return m_o_streambuf->Seek(pos, mode); } void wxOutputStream::Sync() { - DoWrite(m_o_streambuf->GetBufferStart(), m_o_streambuf->GetIntPosition()); - - m_o_streambuf->ResetBuffer(); + m_o_streambuf->FlushBuffer(); } wxOutputStream& wxOutputStream::operator<<(const char *string) @@ -542,70 +774,50 @@ wxOutputStream& wxOutputStream::operator<<(double f) return Write(strfloat, strfloat.Len()); } +#if wxUSE_SERIAL wxOutputStream& wxOutputStream::operator<<(wxObject& obj) { wxObjectOutputStream obj_s(*this); obj_s.SaveObject(obj); return *this; } +#endif // ---------------------------------------------------------------------------- // wxFilterInputStream // ---------------------------------------------------------------------------- -wxFilterInputStream::wxFilterInputStream(wxInputStream& stream) +wxFilterInputStream::wxFilterInputStream() : wxInputStream(NULL) { - m_parent_i_stream = &stream; - m_i_streambuf = stream.InputStreamBuffer(); + // WARNING streambuf set to NULL ! } -wxFilterInputStream::~wxFilterInputStream() -{ -} - -size_t wxFilterInputStream::DoRead(void *buffer, size_t size) -{ - return m_parent_i_stream->Read(buffer, size).LastRead(); -} - -off_t wxFilterInputStream::DoSeekInput(off_t pos, wxSeekMode mode) +wxFilterInputStream::wxFilterInputStream(wxInputStream& stream) + : wxInputStream(stream.InputStreamBuffer()) { - return m_parent_i_stream->SeekI(pos, mode); + m_parent_i_stream = &stream; } -off_t wxFilterInputStream::DoTellInput() const +wxFilterInputStream::~wxFilterInputStream() { - return m_parent_i_stream->TellI(); } - // ---------------------------------------------------------------------------- // wxFilterOutputStream // ---------------------------------------------------------------------------- -wxFilterOutputStream::wxFilterOutputStream(wxOutputStream& stream) +wxFilterOutputStream::wxFilterOutputStream() : wxOutputStream(NULL) { - m_parent_o_stream = &stream; - m_o_streambuf = stream.OutputStreamBuffer(); } -wxFilterOutputStream::~wxFilterOutputStream() -{ -} - -size_t wxFilterOutputStream::DoWrite(const void *buffer, size_t size) -{ - return m_parent_o_stream->Write(buffer, size).LastWrite(); -} - -off_t wxFilterOutputStream::DoSeekOutput(off_t pos, wxSeekMode mode) +wxFilterOutputStream::wxFilterOutputStream(wxOutputStream& stream) + : wxOutputStream(stream.OutputStreamBuffer()) { - return m_parent_o_stream->SeekO(pos, mode); + m_parent_o_stream = &stream; } -off_t wxFilterOutputStream::DoTellOutput() const +wxFilterOutputStream::~wxFilterOutputStream() { - return m_parent_o_stream->TellO(); } // ----------------------------------------------------------------------------