X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/df875e593f9ec4b2eb08d632e17caddf10b61ac8..7e99520bd3fc092bbbcbc38bb699a0236618ea40:/src/common/stream.cpp diff --git a/src/common/stream.cpp b/src/common/stream.cpp index d81531d89c..310f1ee7e0 100644 --- a/src/common/stream.cpp +++ b/src/common/stream.cpp @@ -15,31 +15,45 @@ // For compilers that support precompilation, includes "wx.h". #include "wx/wxprec.h" -#include -#include -#include -#include #ifdef __BORLANDC__ -#pragma hdrstop + #pragma hdrstop +#endif + +#ifndef WX_PRECOMP + #include "wx/defs.h" #endif +#if wxUSE_STREAMS + +#include +#include "wx/stream.h" +#include "wx/datstrm.h" +#include "wx/objstrm.h" + +#define BUF_TEMP_SIZE 10000 + // ---------------------------------------------------------------------------- // wxStreamBuffer // ---------------------------------------------------------------------------- +#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_fixed(TRUE), m_flushable(TRUE), m_stream(&stream), - m_mode(mode), m_destroybuf(FALSE) + m_mode(mode), m_destroybuf(FALSE), m_destroystream(FALSE) { } wxStreamBuffer::wxStreamBuffer(BufMode mode) : m_buffer_start(NULL), m_buffer_end(NULL), m_buffer_pos(NULL), m_buffer_size(0), m_fixed(TRUE), m_flushable(FALSE), m_stream(NULL), - m_mode(mode), m_destroybuf(FALSE) + m_mode(mode), m_destroybuf(FALSE), m_destroystream(TRUE) { + m_stream = new wxStreamBase(); } wxStreamBuffer::wxStreamBuffer(const wxStreamBuffer& buffer) @@ -53,36 +67,15 @@ wxStreamBuffer::wxStreamBuffer(const wxStreamBuffer& buffer) m_stream = buffer.m_stream; m_mode = buffer.m_mode; m_destroybuf = FALSE; + m_destroystream = FALSE; } wxStreamBuffer::~wxStreamBuffer() { if (m_destroybuf) wxDELETEA(m_buffer_start); -} - -bool wxStreamBuffer::WriteBack(const char *buf, size_t bufsize) -{ - char *ptrback; - - ptrback = AllocSpaceWBack(bufsize); - if (!ptrback) - return FALSE; - - memcpy(ptrback, buf, bufsize); - return TRUE; -} - -bool wxStreamBuffer::WriteBack(char c) -{ - char *ptrback; - - ptrback = AllocSpaceWBack(1); - if (!ptrback) - return FALSE; - - *ptrback = c; - return TRUE; + if (m_destroystream) + delete m_stream; } void wxStreamBuffer::SetBufferIO(char *buffer_start, char *buffer_end) @@ -101,12 +94,13 @@ 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; - m_buffer_end = NULL; - m_buffer_pos = NULL; + m_buffer_start = (char*)NULL; + m_buffer_end = (char*)NULL; + m_buffer_pos = (char*)NULL; m_buffer_size = 0; return; } @@ -118,48 +112,14 @@ void wxStreamBuffer::SetBufferIO(size_t bufsize) void wxStreamBuffer::ResetBuffer() { - if (m_mode == read) + 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; } -char *wxStreamBuffer::AllocSpaceWBack(size_t needed_size) -{ - char *temp_b; - - 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; - return (char *)((size_t)m_wback+(m_wbacksize-needed_size)); -} - -size_t wxStreamBuffer::GetWBack(char *buf, size_t bsize) -{ - size_t s_toget = m_wbacksize-m_wbackcur; - - 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; @@ -205,10 +165,17 @@ 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; + if (!m_buffer_start) + SetBufferIO(size); + else { + size_t delta = m_buffer_pos-m_buffer_start; + + m_buffer_start = (char *)realloc(m_buffer_start, m_buffer_size+size); + m_buffer_pos = m_buffer_start + delta; + // I round a bit + m_buffer_size += size; + m_buffer_end = m_buffer_start+m_buffer_size; + } s_toput = size; } if (s_toput > size) @@ -226,13 +193,32 @@ void wxStreamBuffer::PutChar(char c) return; } - if (!GetDataLeft() && !FlushBuffer()) + if (GetDataLeft() == 0 && !FlushBuffer()) { + CHECK_ERROR(wxStream_WRITE_ERR); return; + } PutToBuffer(&c, 1); m_stream->m_lastcount = 1; } +char wxStreamBuffer::Peek() +{ + char c; + + wxASSERT(m_stream != NULL && m_buffer_size != 0); + + if (!GetDataLeft()) { + CHECK_ERROR(wxStream_READ_ERR); + return 0; + } + + GetFromBuffer(&c, 1); + m_buffer_pos--; + + return c; +} + char wxStreamBuffer::GetChar() { char c; @@ -244,33 +230,31 @@ char wxStreamBuffer::GetChar() return c; } - if (!GetDataLeft() && !FillBuffer()) + if (!GetDataLeft()) { + CHECK_ERROR(wxStream_READ_ERR); return 0; + } GetFromBuffer(&c, 1); + m_stream->m_lastcount = 1; return c; } -void wxStreamBuffer::Read(void *buffer, size_t size) +size_t wxStreamBuffer::Read(void *buffer, size_t size) { wxASSERT(m_stream != NULL); + if (m_mode == write) + return 0; + // ------------------ // Buffering disabled // ------------------ - m_stream->m_lastcount = GetWBack((char *)buffer, size); - size -= m_stream->m_lastcount; - if (size == 0) - return; - - buffer = (void *)((char *)buffer+m_stream->m_lastcount); - - if (!m_buffer_size) { - m_stream->m_lastcount += m_stream->OnSysRead(buffer, size); - return; - } + m_stream->m_lasterror = wxStream_NOERROR; + if (!m_buffer_size) + return (m_stream->m_lastcount += m_stream->OnSysRead(buffer, size)); // ----------------- // Buffering enabled @@ -278,7 +262,7 @@ void wxStreamBuffer::Read(void *buffer, size_t size) size_t buf_left, orig_size = size; while (size > 0) { - buf_left = GetDataLeft(); + buf_left = GetDataLeft(); // First case: the requested buffer is larger than the stream buffer, // we split it. @@ -288,8 +272,8 @@ void wxStreamBuffer::Read(void *buffer, size_t size) buffer = (char *)buffer + buf_left; // ANSI C++ violation. if (!FillBuffer()) { - m_stream->m_lastcount = orig_size-size; - return; + CHECK_ERROR(wxStream_EOF); + return (m_stream->m_lastcount = orig_size-size); } } else { @@ -298,21 +282,39 @@ void wxStreamBuffer::Read(void *buffer, size_t size) break; } } - m_stream->m_lastcount += orig_size; + return (m_stream->m_lastcount += orig_size); +} + +size_t wxStreamBuffer::Read(wxStreamBuffer *s_buf) +{ + char buf[BUF_TEMP_SIZE]; + size_t s = 0, bytes_read = BUF_TEMP_SIZE; + + if (m_mode == write) + return 0; + + while (bytes_read != 0) { + bytes_read = Read(buf, bytes_read); + bytes_read = s_buf->Write(buf, bytes_read); + s += bytes_read; + } + return s; } -void wxStreamBuffer::Write(const void *buffer, size_t size) +size_t wxStreamBuffer::Write(const void *buffer, size_t size) { wxASSERT(m_stream != NULL); + if (m_mode == read) + return 0; + // ------------------ // Buffering disabled // ------------------ - if (!m_buffer_size) { - m_stream->m_lastcount = m_stream->OnSysWrite(buffer, size); - return; - } + m_stream->m_lasterror = wxStream_NOERROR; + if (!m_buffer_size && m_fixed) + return (m_stream->m_lastcount = m_stream->OnSysWrite(buffer, size)); // ------------------ // Buffering enabled @@ -325,15 +327,18 @@ 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) { + // NB: If stream buffer isn't fixed (as for wxMemoryOutputStream), + // we always go to the second case. + if (size > buf_left && m_fixed) { PutToBuffer(buffer, buf_left); size -= buf_left; buffer = (char *)buffer + buf_left; // ANSI C++ violation. if (!FlushBuffer()) { - m_stream->m_lastcount = orig_size-size; - return; + CHECK_ERROR(wxStream_WRITE_ERR); + return (m_stream->m_lastcount = orig_size-size); } + m_buffer_pos = m_buffer_start; } else { @@ -343,7 +348,28 @@ void wxStreamBuffer::Write(const void *buffer, size_t size) break; } } - m_stream->m_lastcount = 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; + wxInputStream *in_stream; + + if (m_mode == read) + return 0; + + in_stream = (wxInputStream *)sbuf->Stream(); + + while (bytes_count == BUF_TEMP_SIZE) { + b_count2 = sbuf->Read(buf, bytes_count); + bytes_count = Write(buf, b_count2); + if (b_count2 > bytes_count) + in_stream->Ungetch(buf+bytes_count, b_count2-bytes_count); + s += bytes_count; + } + return s; } off_t wxStreamBuffer::Seek(off_t pos, wxSeekMode mode) @@ -352,8 +378,13 @@ off_t wxStreamBuffer::Seek(off_t pos, wxSeekMode mode) last_access = GetLastAccess(); - if (m_fixed) { - diff = pos + GetIntPosition(); + if (!m_flushable) { + switch (mode) { + case wxFromStart: diff = pos; break; + case wxFromCurrent: diff = pos + GetIntPosition(); break; + case wxFromEnd: diff = pos + last_access; break; + default: return wxInvalidOffset; + } if (diff < 0 || diff > last_access) return wxInvalidOffset; SetIntPosition(diff); @@ -371,7 +402,9 @@ off_t wxStreamBuffer::Seek(off_t pos, wxSeekMode mode) diff = pos + GetIntPosition(); if ( (diff > last_access) || (diff < 0) ) { - ret_off = m_stream->OnSysSeek(pos, wxFromCurrent); + // We must take into account the fact that we have read something + // previously. + ret_off = m_stream->OnSysSeek(diff-last_access, wxFromCurrent); ResetBuffer(); return ret_off; } else { @@ -390,20 +423,25 @@ off_t wxStreamBuffer::Seek(off_t pos, wxSeekMode mode) off_t wxStreamBuffer::Tell() const { - off_t pos; - - if (!m_fixed) { - pos = m_stream->OnSysTell(); + off_t pos = m_stream->OnSysTell(); if (pos == wxInvalidOffset) - return wxInvalidOffset; - return pos - GetLastAccess() + GetIntPosition(); - } else - return GetIntPosition(); + return wxInvalidOffset; + + pos += GetIntPosition(); + + if (m_mode == read && m_flushable) + pos -= GetLastAccess(); + + return pos; } -size_t wxStreamBuffer::GetDataLeft() const +size_t wxStreamBuffer::GetDataLeft() { - return m_buffer_end-m_buffer_pos; + /* Why is this done? RR. */ + if (m_buffer_end == m_buffer_pos && m_flushable) + FillBuffer(); + + return m_buffer_end-m_buffer_pos; } // ---------------------------------------------------------------------------- @@ -412,8 +450,8 @@ size_t wxStreamBuffer::GetDataLeft() const wxStreamBase::wxStreamBase() { - m_lasterror = wxStream_NOERROR; - m_lastcount = 0; + m_lasterror = wxStream_NOERROR; + m_lastcount = 0; } wxStreamBase::~wxStreamBase() @@ -422,22 +460,22 @@ wxStreamBase::~wxStreamBase() size_t wxStreamBase::OnSysRead(void *WXUNUSED(buffer), size_t WXUNUSED(size)) { - return 0; + return 0; } size_t wxStreamBase::OnSysWrite(const void *WXUNUSED(buffer), size_t WXUNUSED(bufsize)) { - return 0; + return 0; } off_t wxStreamBase::OnSysSeek(off_t WXUNUSED(seek), wxSeekMode WXUNUSED(mode)) { - return wxInvalidOffset; + return wxInvalidOffset; } off_t wxStreamBase::OnSysTell() const { - return wxInvalidOffset; + return wxInvalidOffset; } // ---------------------------------------------------------------------------- @@ -445,185 +483,203 @@ off_t wxStreamBase::OnSysTell() const // ---------------------------------------------------------------------------- wxInputStream::wxInputStream() - : wxStreamBase() -{ - m_i_destroybuf = TRUE; - m_i_streambuf = new wxStreamBuffer(*this, wxStreamBuffer::read); -} - -wxInputStream::wxInputStream(wxStreamBuffer *buffer) - : wxStreamBase() + : wxStreamBase(), + m_wback(NULL), m_wbacksize(0), m_wbackcur(0) { - m_i_destroybuf = FALSE; - m_i_streambuf = buffer; } wxInputStream::~wxInputStream() { - if (m_i_destroybuf) - delete m_i_streambuf; + if (m_wback) + free(m_wback); } -char wxInputStream::GetC() +bool wxInputStream::Eof() const { - char c; - m_i_streambuf->Read(&c, 1); - return c; -} + wxInputStream *self = (wxInputStream *)this; // const_cast -wxInputStream& wxInputStream::Read(void *buffer, size_t size) -{ - m_i_streambuf->Read(buffer, size); - // wxStreamBuffer sets all variables for us - return *this; + char c; + self->Read(&c, 1); + if ( GetLastError() == wxSTREAM_EOF ) + { + return TRUE; + } + + self->Ungetch(c); + + return FALSE; } -char wxInputStream::Peek() +char *wxInputStream::AllocSpaceWBack(size_t needed_size) { - if (!m_i_streambuf->GetDataLeft()) - m_i_streambuf->FillBuffer(); + /* get number of bytes left from previous wback buffer */ + size_t toget = m_wbacksize - m_wbackcur; - return *(m_i_streambuf->GetBufferPos()); -} + /* allocate a buffer large enough to hold prev + new data */ + char *temp_b = (char *) malloc(needed_size + toget); -#define BUF_TEMP_SIZE 10000 + if (!temp_b) + return NULL; -wxInputStream& wxInputStream::Read(wxOutputStream& stream_out) -{ - char buf[BUF_TEMP_SIZE]; - size_t bytes_read = BUF_TEMP_SIZE; + /* copy previous data (and free old buffer) if needed */ + if (m_wback) + { + memmove(temp_b + needed_size, m_wback + m_wbackcur, toget); + free(m_wback); + } - while (bytes_read == BUF_TEMP_SIZE && stream_out.LastError() != wxStream_NOERROR) { - bytes_read = Read(buf, bytes_read).LastRead(); + /* done */ + m_wback = temp_b; + m_wbackcur = 0; + m_wbacksize = needed_size + toget; - stream_out.Write(buf, bytes_read); - } - return *this; + return (char *) m_wback; } -off_t wxInputStream::SeekI(off_t pos, wxSeekMode mode) +size_t wxInputStream::GetWBack(char *buf, size_t bsize) { - return m_i_streambuf->Seek(pos, mode); -} + size_t s_toget = m_wbacksize-m_wbackcur; -off_t wxInputStream::TellI() const -{ - return m_i_streambuf->Tell(); -} + if (!m_wback) + return 0; -// -------------------- -// Overloaded operators -// -------------------- + if (bsize < s_toget) + s_toget = bsize; -wxInputStream& wxInputStream::operator>>(wxString& line) -{ - wxDataInputStream s(*this); + memcpy(buf, (m_wback+m_wbackcur), s_toget); - line = s.ReadLine(); - return *this; + 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; } -wxInputStream& wxInputStream::operator>>(char& c) +size_t wxInputStream::Ungetch(const void *buf, size_t bufsize) { - c = GetC(); - return *this; + char *ptrback = AllocSpaceWBack(bufsize); + if (!ptrback) + return 0; + + memcpy(ptrback, buf, bufsize); + return bufsize; } -wxInputStream& wxInputStream::operator>>(short& i) +bool wxInputStream::Ungetch(char c) { - long l; + char * ptrback = AllocSpaceWBack(1); + if (!ptrback) + return FALSE; - *this >> l; - i = (short)l; - return *this; + *ptrback = c; + return TRUE; } -wxInputStream& wxInputStream::operator>>(int& i) +char wxInputStream::GetC() { - long l; - - *this >> l; - i = (short)l; - return *this; + char c; + Read(&c, 1); + return c; } -wxInputStream& wxInputStream::operator>>(long& i) +wxInputStream& wxInputStream::Read(void *buffer, size_t size) { - /* I only implemented a simple integer parser */ - int c, sign; + char *buf = (char *)buffer; - while (isspace( c = GetC() ) ) - /* Do nothing */ ; + size_t retsize = GetWBack(buf, size); + if (retsize == size) + { + m_lastcount = size; + m_lasterror = wxStream_NOERROR; + return *this; + } + size -= retsize; + buf += retsize; - i = 0; - if (! (c == '-' || isdigit(c)) ) { - InputStreamBuffer()->WriteBack(c); + m_lastcount = OnSysRead(buf, size) + retsize; return *this; - } - - if (c == '-') { - sign = -1; - c = GetC(); - } else - sign = 1; - - while (isdigit(c)) { - i = i*10 + c; - c = GetC(); - } +} - i *= sign; +char wxInputStream::Peek() +{ + char c; + Read(&c, 1); + if (m_lasterror == wxStream_NOERROR) + { + Ungetch(c); + return c; + } - return *this; + return 0; } -wxInputStream& wxInputStream::operator>>(double& f) +wxInputStream& wxInputStream::Read(wxOutputStream& stream_out) { - /* I only implemented a simple float parser */ - int c, sign; - - while (isspace( c = GetC() ) ) - /* Do nothing */ ; + char buf[BUF_TEMP_SIZE]; + size_t bytes_read = BUF_TEMP_SIZE; - f = 0.0; - if (! (c == '-' || isdigit(c)) ) { - InputStreamBuffer()->WriteBack(c); + while (bytes_read == BUF_TEMP_SIZE) + { + bytes_read = Read(buf, bytes_read).LastRead(); + bytes_read = stream_out.Write(buf, bytes_read).LastWrite(); + } return *this; - } - - if (c == '-') { - sign = -1; - c = GetC(); - } else - sign = 1; +} - while (isdigit(c)) { - f = f*10 + (c - '0'); - c = GetC(); - } +off_t wxInputStream::SeekI(off_t pos, wxSeekMode mode) +{ + /* Should be check and improve, just to remove a slight bug ! + I don't know whether it should be put as well in wxFileInputStream::OnSysSeek ? */ + if (m_lasterror==wxSTREAM_EOF) + m_lasterror=wxSTREAM_NOERROR; + + /* A call to SeekI() will automatically invalidate any previous call + to Ungetch(), otherwise it would be possible to SeekI() to one + one position, unread some bytes there, SeekI() to another position + and the data would be corrupted. + + GRG: Could add code here to try to navigate within the wback + 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) + { + free(m_wback); + m_wback = (char*) NULL; + m_wbacksize = 0; + m_wbackcur = 0; + } - if (c == '.') { - double f_multiplicator = (double) 0.1; - c = GetC(); + return OnSysSeek(pos, mode); +} - while (isdigit(c)) { - f += (c-'0')*f_multiplicator; - f_multiplicator /= 10; - c = GetC(); - } - } +off_t wxInputStream::TellI() const +{ + /* GRG: Changed to make it compatible with the wback buffer */ + off_t pos = OnSysTell(); - f *= sign; + if (pos != wxInvalidOffset) + pos -= (m_wbacksize - m_wbackcur); - return *this; + return pos; } +// -------------------- +// Overloaded operators +// -------------------- + #if wxUSE_SERIAL wxInputStream& wxInputStream::operator>>(wxObject *& obj) { - wxObjectInputStream obj_s(*this); - obj = obj_s.LoadObject(); - return *this; + wxObjectInputStream obj_s(*this); + obj = obj_s.LoadObject(); + return *this; } #endif @@ -634,119 +690,106 @@ wxInputStream& wxInputStream::operator>>(wxObject *& obj) wxOutputStream::wxOutputStream() : wxStreamBase() { - m_o_destroybuf = TRUE; - m_o_streambuf = new wxStreamBuffer(*this, wxStreamBuffer::write); } -wxOutputStream::wxOutputStream(wxStreamBuffer *buffer) - : wxStreamBase() +wxOutputStream::~wxOutputStream() { - m_o_destroybuf = FALSE; - m_o_streambuf = buffer; } -wxOutputStream::~wxOutputStream() +void wxOutputStream::PutC(char c) { - if (m_o_destroybuf) - delete m_o_streambuf; + Write((void *) &c, 1); } wxOutputStream& wxOutputStream::Write(const void *buffer, size_t size) { - m_o_streambuf->Write(buffer, size); - return *this; + m_lastcount = OnSysWrite(buffer, size); + return *this; } wxOutputStream& wxOutputStream::Write(wxInputStream& stream_in) { - stream_in.Read(*this); - return *this; + stream_in.Read(*this); + return *this; } off_t wxOutputStream::TellO() const { - return m_o_streambuf->Tell(); + return OnSysTell(); } off_t wxOutputStream::SeekO(off_t pos, wxSeekMode mode) { - return m_o_streambuf->Seek(pos, mode); + return OnSysSeek(pos, mode); } void wxOutputStream::Sync() { - m_o_streambuf->FlushBuffer(); } -wxOutputStream& wxOutputStream::operator<<(const char *string) +#if wxUSE_SERIAL +wxOutputStream& wxOutputStream::operator<<(wxObject& obj) { - return Write(string, strlen(string)); + wxObjectOutputStream obj_s(*this); + obj_s.SaveObject(obj); + return *this; } +#endif -wxOutputStream& wxOutputStream::operator<<(wxString& string) -{ - return Write(string, string.Len()); -} +// ---------------------------------------------------------------------------- +// wxCountingOutputStream +// ---------------------------------------------------------------------------- -wxOutputStream& wxOutputStream::operator<<(char c) +wxCountingOutputStream::wxCountingOutputStream () + : wxOutputStream() { - return Write(&c, 1); + m_currentPos = 0; } -wxOutputStream& wxOutputStream::operator<<(short i) +size_t wxCountingOutputStream::GetSize() const { - wxString strint; - - strint.Printf("%i", i); - return Write(strint, strint.Len()); + return m_lastcount; } -wxOutputStream& wxOutputStream::operator<<(int i) +size_t wxCountingOutputStream::OnSysWrite(const void *WXUNUSED(buffer), size_t size) { - wxString strint; - - strint.Printf("%i", i); - return Write(strint, strint.Len()); + m_currentPos += size; + if (m_currentPos > m_lastcount) m_lastcount = m_currentPos; + return m_currentPos; } -wxOutputStream& wxOutputStream::operator<<(long i) +off_t wxCountingOutputStream::OnSysSeek(off_t pos, wxSeekMode mode) { - wxString strlong; + if (mode == wxFromStart) + m_currentPos = pos; + if (mode == wxFromEnd) + m_currentPos = m_lastcount + pos; + else + m_currentPos += pos; - strlong.Printf("%i", i); - return Write((const char *)strlong, strlong.Len()); -} - -wxOutputStream& wxOutputStream::operator<<(double f) -{ - wxString strfloat; + if (m_currentPos > m_lastcount) m_lastcount = m_currentPos; - strfloat.Printf("%f", f); - return Write(strfloat, strfloat.Len()); + return m_currentPos; } -#if wxUSE_SERIAL -wxOutputStream& wxOutputStream::operator<<(wxObject& obj) +off_t wxCountingOutputStream::OnSysTell() const { - wxObjectOutputStream obj_s(*this); - obj_s.SaveObject(obj); - return *this; + return m_currentPos; } -#endif // ---------------------------------------------------------------------------- // wxFilterInputStream // ---------------------------------------------------------------------------- + wxFilterInputStream::wxFilterInputStream() - : wxInputStream(NULL) + : wxInputStream() { - // WARNING streambuf set to NULL ! } wxFilterInputStream::wxFilterInputStream(wxInputStream& stream) - : wxInputStream(stream.InputStreamBuffer()) + : wxInputStream() { - m_parent_i_stream = &stream; + m_parent_i_stream = &stream; } wxFilterInputStream::~wxFilterInputStream() @@ -757,20 +800,150 @@ wxFilterInputStream::~wxFilterInputStream() // wxFilterOutputStream // ---------------------------------------------------------------------------- wxFilterOutputStream::wxFilterOutputStream() - : wxOutputStream(NULL) + : wxOutputStream() { } wxFilterOutputStream::wxFilterOutputStream(wxOutputStream& stream) - : wxOutputStream(stream.OutputStreamBuffer()) + : wxOutputStream() { - m_parent_o_stream = &stream; + m_parent_o_stream = &stream; } wxFilterOutputStream::~wxFilterOutputStream() { } +// ---------------------------------------------------------------------------- +// wxBufferedInputStream +// ---------------------------------------------------------------------------- +wxBufferedInputStream::wxBufferedInputStream(wxInputStream& s) + : wxFilterInputStream(s) +{ + m_i_streambuf = new wxStreamBuffer(*this, wxStreamBuffer::read); + m_i_streambuf->SetBufferIO(1024); +} + +wxBufferedInputStream::~wxBufferedInputStream() +{ + off_t unused_bytes=m_i_streambuf->GetBufferPos()-m_i_streambuf->GetBufferEnd(); + m_parent_i_stream->SeekI(unused_bytes,wxFromCurrent); + + delete m_i_streambuf; +} + +char wxBufferedInputStream::Peek() +{ + return m_i_streambuf->Peek(); +} + +wxInputStream& wxBufferedInputStream::Read(void *buffer, size_t size) +{ + size_t retsize; + char *buf = (char *)buffer; + + retsize = GetWBack(buf, size); + m_lastcount = retsize; + if (retsize == size) + { + m_lasterror = wxStream_NOERROR; + return *this; + } + size -= retsize; + buf += retsize; + + m_i_streambuf->Read(buf, size); + + return *this; +} + +off_t wxBufferedInputStream::SeekI(off_t pos, wxSeekMode mode) +{ + return m_i_streambuf->Seek(pos, mode); +} + +off_t wxBufferedInputStream::TellI() const +{ + return m_i_streambuf->Tell(); +} + +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) +{ + return m_parent_i_stream->SeekI(seek, mode); +} + +off_t wxBufferedInputStream::OnSysTell() const +{ + return m_parent_i_stream->TellI(); +} + + +// ---------------------------------------------------------------------------- +// wxBufferedOutputStream +// ---------------------------------------------------------------------------- + +wxBufferedOutputStream::wxBufferedOutputStream(wxOutputStream& s) + : wxFilterOutputStream(s) +{ + m_o_streambuf = new wxStreamBuffer(*this, wxStreamBuffer::write); + m_o_streambuf->SetBufferIO(1024); +} + +wxBufferedOutputStream::~wxBufferedOutputStream() +{ + Sync(); + delete m_o_streambuf; +} + +wxOutputStream& wxBufferedOutputStream::Write(const void *buffer, size_t size) +{ + m_lastcount = 0; + m_o_streambuf->Write(buffer, size); + return *this; +} + +off_t wxBufferedOutputStream::SeekO(off_t pos, wxSeekMode mode) +{ + Sync(); + return m_o_streambuf->Seek(pos, mode); +} + +off_t wxBufferedOutputStream::TellO() const +{ + return m_o_streambuf->Tell(); +} + +void wxBufferedOutputStream::Sync() +{ + m_o_streambuf->FlushBuffer(); + m_parent_o_stream->Sync(); +} + +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) +{ + return m_parent_o_stream->SeekO(seek, mode); +} + +off_t wxBufferedOutputStream::OnSysTell() const +{ + return m_parent_o_stream->TellO(); +} + +size_t wxBufferedOutputStream::GetSize() const +{ + return m_parent_o_stream->GetSize() + m_o_streambuf->GetIntPosition(); +} + // ---------------------------------------------------------------------------- // Some IOManip function // ---------------------------------------------------------------------------- @@ -779,7 +952,14 @@ wxOutputStream& wxEndL(wxOutputStream& stream) { #ifdef __MSW__ return stream.Write("\r\n", 2); +#else +#ifdef __WXMAC__ + return stream.Write("\r", 1); #else return stream.Write("\n", 1); #endif +#endif } + +#endif + // wxUSE_STREAMS