osx-cocoa updates

[wxWidgets.git] / src / common / stream.cpp

diff --git a/src/common/stream.cpp b/src/common/stream.cpp
index 4765ea03f60351289947ce3699e34eda8ec7fb5a..d26e30716347c821c025d9add3cc736838d78006 100644 (file)
--- a/src/common/stream.cpp
+++ b/src/common/stream.cpp
@@ -63,7 +63,6 @@ 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;
@@ -106,7 +105,6 @@ 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;
@@ -156,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;
 
@@ -192,6 +188,27 @@ 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()
 {
@@ -201,7 +218,7 @@ 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;
 
@@ -271,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
         }
     }
 
@@ -657,6 +676,8 @@ wxFileOffset wxStreamBuffer::Tell() const
 // wxStreamBase
 // ----------------------------------------------------------------------------
 
+IMPLEMENT_ABSTRACT_CLASS(wxStreamBase, wxObject)
+
 wxStreamBase::wxStreamBase()
 {
     m_lasterror = wxSTREAM_NO_ERROR;
@@ -693,6 +714,8 @@ wxFileOffset wxStreamBase::OnSysTell() const
 // wxInputStream
 // ----------------------------------------------------------------------------
 
+IMPLEMENT_ABSTRACT_CLASS(wxInputStream, wxStreamBase)
+
 wxInputStream::wxInputStream()
 {
     m_wback = NULL;
@@ -938,6 +961,8 @@ wxFileOffset wxInputStream::TellI() const
 // wxOutputStream
 // ----------------------------------------------------------------------------
 
+IMPLEMENT_ABSTRACT_CLASS(wxOutputStream, wxStreamBase)
+
 wxOutputStream::wxOutputStream()
 {
 }
@@ -988,6 +1013,8 @@ void wxOutputStream::Sync()
 // wxCountingOutputStream
 // ----------------------------------------------------------------------------
 
+IMPLEMENT_DYNAMIC_CLASS(wxCountingOutputStream, wxOutputStream)
+
 wxCountingOutputStream::wxCountingOutputStream ()
 {
      m_currentPos = 0;
@@ -1050,6 +1077,8 @@ wxFileOffset wxCountingOutputStream::OnSysTell() const
 // wxFilterInputStream
 // ----------------------------------------------------------------------------
 
+IMPLEMENT_ABSTRACT_CLASS(wxFilterInputStream, wxInputStream)
+
 wxFilterInputStream::wxFilterInputStream()
  :  m_parent_i_stream(NULL),
     m_owns(false)
@@ -1078,6 +1107,8 @@ wxFilterInputStream::~wxFilterInputStream()
 // wxFilterOutputStream
 // ----------------------------------------------------------------------------
 
+IMPLEMENT_ABSTRACT_CLASS(wxFilterOutputStream, wxOutputStream)
+
 wxFilterOutputStream::wxFilterOutputStream()
  :  m_parent_o_stream(NULL),
     m_owns(false)
@@ -1122,29 +1153,25 @@ wxString wxFilterClassFactoryBase::PopExtension(const wxString& location) const
 }
 
 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_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_FILEEXT)
         return FindExtension(protocol) != wxString::npos;
     else
         for (const wxChar *const *p = GetProtocols(type); *p; p++)
-            if (wxStrcmp(*p, protocol) == 0)
+            if (protocol == *p)
                 return true;
 
     return false;
@@ -1221,12 +1248,15 @@ 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;
     }