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_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)
// 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,
- _T("it's a bad idea to copy this buffer") );
+ wxT("it's a bad idea to copy this buffer") );
m_buffer_start = buffer.m_buffer_start;
m_buffer_end = buffer.m_buffer_end;
m_buffer_pos = buffer.m_buffer_pos;
- m_buffer_size = buffer.m_buffer_size;
m_fixed = buffer.m_fixed;
m_flushable = buffer.m_flushable;
m_stream = buffer.m_stream;
m_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;
: 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, wxT("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()
{
if ( !inStream )
return false;
- size_t count = inStream->OnSysRead(m_buffer_start, m_buffer_size);
+ size_t count = inStream->OnSysRead(GetBufferStart(), GetBufferSize());
if ( !count )
return false;
// 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, wxT("can't flush this buffer") );
// FIXME: what is this check for? (VZ)
if ( m_buffer_pos == m_buffer_start )
wxOutputStream *outStream = GetOutputStream();
- wxCHECK_MSG( outStream, false, _T("should have a stream in wxStreamBuffer") );
+ wxCHECK_MSG( outStream, false, wxT("should have a stream in wxStreamBuffer") );
size_t current = m_buffer_pos - m_buffer_start;
size_t count = outStream->OnSysWrite(m_buffer_start, current);
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
}
}
{
wxOutputStream *outStream = GetOutputStream();
- wxCHECK_RET( outStream, _T("should have a stream in wxStreamBuffer") );
+ wxCHECK_RET( outStream, wxT("should have a stream in wxStreamBuffer") );
// if we don't have buffer at all, just forward this call to the stream,
if ( !HasBuffer() )
char wxStreamBuffer::Peek()
{
wxCHECK_MSG( m_stream && HasBuffer(), 0,
- _T("should have the stream and the buffer in wxStreamBuffer") );
+ wxT("should have the stream and the buffer in wxStreamBuffer") );
if ( !GetDataLeft() )
{
{
wxInputStream *inStream = GetInputStream();
- wxCHECK_MSG( inStream, 0, _T("should have a stream in wxStreamBuffer") );
+ wxCHECK_MSG( inStream, 0, wxT("should have a stream in wxStreamBuffer") );
char c;
if ( !HasBuffer() )
size_t wxStreamBuffer::Read(void *buffer, size_t size)
{
- wxASSERT_MSG( buffer, _T("Warning: Null pointer is about to be used") );
+ wxASSERT_MSG( buffer, wxT("Warning: Null pointer is about to be used") );
/* Clear buffer first */
memset(buffer, 0x00, size);
{
wxInputStream *inStream = GetInputStream();
- wxCHECK_MSG( inStream, 0, _T("should have a stream in wxStreamBuffer") );
+ wxCHECK_MSG( inStream, 0, wxT("should have a stream in wxStreamBuffer") );
readBytes = inStream->OnSysRead(buffer, size);
}
// this should really be called "Copy()"
size_t wxStreamBuffer::Read(wxStreamBuffer *dbuf)
{
- wxCHECK_MSG( m_mode != write, 0, _T("can't read from this buffer") );
+ wxCHECK_MSG( m_mode != write, 0, wxT("can't read from this buffer") );
char buf[BUF_TEMP_SIZE];
size_t nRead,
size_t wxStreamBuffer::Write(const void *buffer, size_t size)
{
- wxASSERT_MSG( buffer, _T("Warning: Null pointer is about to be send") );
+ wxASSERT_MSG( buffer, wxT("Warning: Null pointer is about to be send") );
if (m_stream)
{
{
wxOutputStream *outStream = GetOutputStream();
- wxCHECK_MSG( outStream, 0, _T("should have a stream in wxStreamBuffer") );
+ wxCHECK_MSG( outStream, 0, wxT("should have a stream in wxStreamBuffer") );
// no buffer, just forward the call to the stream
ret = outStream->OnSysWrite(buffer, size);
size_t wxStreamBuffer::Write(wxStreamBuffer *sbuf)
{
- wxCHECK_MSG( m_mode != read, 0, _T("can't write to this buffer") );
- wxCHECK_MSG( sbuf->m_mode != write, 0, _T("can't read from that buffer") );
+ wxCHECK_MSG( m_mode != read, 0, wxT("can't write to this buffer") );
+ wxCHECK_MSG( sbuf->m_mode != write, 0, wxT("can't read from that buffer") );
char buf[BUF_TEMP_SIZE];
size_t nWrite,
break;
default:
- wxFAIL_MSG( _T("invalid seek mode") );
+ wxFAIL_MSG( wxT("invalid seek mode") );
return wxInvalidOffset;
}
size_t int_diff = wx_truncate_cast(size_t, diff);
wxCHECK_MSG( (wxFileOffset)int_diff == diff, wxInvalidOffset, wxT("huge file not supported") );
SetIntPosition(int_diff);
- return pos;
+ return diff;
}
case wxFromEnd:
// wxStreamBase
// ----------------------------------------------------------------------------
+IMPLEMENT_ABSTRACT_CLASS(wxStreamBase, wxObject)
+
wxStreamBase::wxStreamBase()
{
m_lasterror = wxSTREAM_NO_ERROR;
return 0;
const size_t len = wx_truncate_cast(size_t, length);
- wxASSERT_MSG( len == length + size_t(0), _T("large files not supported") );
+ wxASSERT_MSG( len == length + size_t(0), wxT("large files not supported") );
return len;
}
// wxInputStream
// ----------------------------------------------------------------------------
+IMPLEMENT_ABSTRACT_CLASS(wxInputStream, wxStreamBase)
+
wxInputStream::wxInputStream()
{
m_wback = NULL;
size_t wxInputStream::GetWBack(void *buf, size_t size)
{
- wxASSERT_MSG( buf, _T("Warning: Null pointer is about to be used") );
+ wxASSERT_MSG( buf, wxT("Warning: Null pointer is about to be used") );
/* Clear buffer first */
memset(buf, 0x00, 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()") );
+ wxASSERT_MSG( buf, wxT("Warning: Null pointer is about to be used in Ungetch()") );
if ( m_lasterror != wxSTREAM_NO_ERROR && m_lasterror != wxSTREAM_EOF )
{
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") );
+ wxASSERT_MSG( buf, wxT("Warning: Null pointer is about to be read") );
char *p = (char *)buf;
m_lastcount = 0;
wxInputStream& wxInputStream::Read(wxOutputStream& stream_out)
{
+ size_t lastcount = 0;
char buf[BUF_TEMP_SIZE];
for ( ;; )
if ( stream_out.Write(buf, bytes_read).LastWrite() != bytes_read )
break;
+
+ lastcount += bytes_read;
}
+ m_lastcount = lastcount;
+
return *this;
}
{
// RR: This code is duplicated in wxBufferedInputStream. This is
// not really a good design, but buffered stream are different
- // from all other in that they handle two stream-related objects,
+ // from all others in that they handle two stream-related objects:
// the stream buffer and parent stream.
// I don't know whether it should be put as well in wxFileInputStream::OnSysSeek
if (m_lasterror==wxSTREAM_EOF)
m_lasterror=wxSTREAM_NO_ERROR;
+ // avoid unnecessary seek operations (optimization)
+ wxFileOffset currentPos = TellI(), size = GetLength();
+ if ((mode == wxFromStart && currentPos == pos) ||
+ (mode == wxFromCurrent && pos == 0) ||
+ (mode == wxFromEnd && size != wxInvalidOffset && currentPos == size-pos))
+ return currentPos;
+
+ if (!IsSeekable() && mode == wxFromCurrent && pos > 0)
+ {
+ // rather than seeking, we can just read data and discard it;
+ // this allows to forward-seek also non-seekable streams!
+ char buf[BUF_TEMP_SIZE];
+ size_t bytes_read;
+
+ // read chunks of BUF_TEMP_SIZE bytes until we reach the new position
+ for ( ; pos >= BUF_TEMP_SIZE; pos -= bytes_read)
+ {
+ bytes_read = Read(buf, WXSIZEOF(buf)).LastRead();
+ if ( m_lasterror != wxSTREAM_NO_ERROR )
+ return wxInvalidOffset;
+
+ wxASSERT(bytes_read == WXSIZEOF(buf));
+ }
+
+ // read the last 'pos' bytes
+ bytes_read = Read(buf, (size_t)pos).LastRead();
+ if ( m_lasterror != wxSTREAM_NO_ERROR )
+ return wxInvalidOffset;
+
+ wxASSERT(bytes_read == (size_t)pos);
+
+ // we should now have seeked to the right position...
+ return TellI();
+ }
+
/* RR: A call to SeekI() will automatically invalidate any previous
call to Ungetch(), otherwise it would be possible to SeekI() to
one position, unread some bytes there, SeekI() to another position
// wxOutputStream
// ----------------------------------------------------------------------------
+IMPLEMENT_ABSTRACT_CLASS(wxOutputStream, wxStreamBase)
+
wxOutputStream::wxOutputStream()
{
}
// wxCountingOutputStream
// ----------------------------------------------------------------------------
+IMPLEMENT_DYNAMIC_CLASS(wxCountingOutputStream, wxOutputStream)
+
wxCountingOutputStream::wxCountingOutputStream ()
{
m_currentPos = 0;
break;
default:
- wxFAIL_MSG( _T("invalid seek mode") );
+ wxFAIL_MSG( wxT("invalid seek mode") );
return wxInvalidOffset;
}
// wxFilterInputStream
// ----------------------------------------------------------------------------
+IMPLEMENT_ABSTRACT_CLASS(wxFilterInputStream, wxInputStream)
+
wxFilterInputStream::wxFilterInputStream()
: m_parent_i_stream(NULL),
m_owns(false)
// wxFilterOutputStream
// ----------------------------------------------------------------------------
+IMPLEMENT_ABSTRACT_CLASS(wxFilterOutputStream, wxOutputStream)
+
wxFilterOutputStream::wxFilterOutputStream()
: m_parent_o_stream(NULL),
m_owns(false)
}
wxString::size_type wxFilterClassFactoryBase::FindExtension(
- const wxChar *location) const
+ const wxString& location) const
{
- size_t len = wxStrlen(location);
-
- for (const wxChar *const *p = GetProtocols(wxSTREAM_FILEEXTENSION);
- p && *p;
- p++)
+ 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;
+ if ( location.EndsWith(*p) )
+ return location.length() - wxStrlen(*p);
}
return wxString::npos;
}
-bool wxFilterClassFactoryBase::CanHandle(const wxChar *protocol,
+bool wxFilterClassFactoryBase::CanHandle(const wxString& protocol,
wxStreamProtocolType type) const
{
- if (type == wxSTREAM_FILEEXTENSION)
+ if (type == wxSTREAM_FILEEXT)
return FindExtension(protocol) != wxString::npos;
else
- for (const wxChar *const *p = GetProtocols(type); p && *p; p++)
- if (wxStrcmp(*p, protocol) == 0)
+ for (const wxChar *const *p = GetProtocols(type); *p; p++)
+ if (protocol == *p)
return true;
return false;
// wxBufferedInputStream
// ----------------------------------------------------------------------------
-wxBufferedInputStream::wxBufferedInputStream(wxInputStream& s,
+namespace
+{
+
+// helper function used for initializing the buffer used by
+// wxBufferedInput/OutputStream: it simply returns the provided buffer if it's
+// not NULL or creates a buffer of the given size otherwise
+template <typename T>
+wxStreamBuffer *
+CreateBufferIfNeeded(T& stream, wxStreamBuffer *buffer, size_t bufsize = 1024)
+{
+ return buffer ? buffer : new wxStreamBuffer(bufsize, stream);
+}
+
+} // anonymous namespace
+
+wxBufferedInputStream::wxBufferedInputStream(wxInputStream& stream,
wxStreamBuffer *buffer)
- : wxFilterInputStream(s)
+ : wxFilterInputStream(stream)
{
- if ( buffer )
- {
- // use the buffer provided by the user
- m_i_streambuf = buffer;
- }
- else // create a default buffer
- {
- m_i_streambuf = new wxStreamBuffer(*this, wxStreamBuffer::read);
+ m_i_streambuf = CreateBufferIfNeeded(*this, buffer);
+}
- m_i_streambuf->SetBufferIO(1024);
- }
+wxBufferedInputStream::wxBufferedInputStream(wxInputStream& stream,
+ size_t bufsize)
+ : wxFilterInputStream(stream)
+{
+ m_i_streambuf = CreateBufferIfNeeded(*this, NULL, bufsize);
}
wxBufferedInputStream::~wxBufferedInputStream()
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;
}
void wxBufferedInputStream::SetInputStreamBuffer(wxStreamBuffer *buffer)
{
- wxCHECK_RET( buffer, _T("wxBufferedInputStream needs buffer") );
+ wxCHECK_RET( buffer, wxT("wxBufferedInputStream needs buffer") );
delete m_i_streambuf;
m_i_streambuf = 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()
void wxBufferedOutputStream::SetOutputStreamBuffer(wxStreamBuffer *buffer)
{
- wxCHECK_RET( buffer, _T("wxBufferedOutputStream needs buffer") );
+ wxCHECK_RET( buffer, wxT("wxBufferedOutputStream needs buffer") );
delete m_o_streambuf;
m_o_streambuf = buffer;
projects / wxWidgets.git / blobdiff