static wxFile::Access() added

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

diff --git a/src/common/zstream.cpp b/src/common/zstream.cpp
index 8ff3bf5c60331c80bff16cc5bde9c8ef9fd645c9..569401fdce270be46585d399fa83e7ee8916ee41 100644 (file)
--- a/src/common/zstream.cpp
+++ b/src/common/zstream.cpp
@@ -17,12 +17,15 @@
 #include <wx/stream.h>
 #include <wx/zstream.h>
 #include <wx/utils.h>
 #include <wx/stream.h>
 #include <wx/zstream.h>
 #include <wx/utils.h>

-#include "zlib.h"
+#include <wx/intl.h>
+#include "../zlib/zlib.h"   // don't change this, Robert

 
 #ifdef __BORLANDC__
 #pragma hdrstop
 #endif
 
 
 #ifdef __BORLANDC__
 #pragma hdrstop
 #endif
 

+#define ZSTREAM_BUFFER_SIZE 1024
+

 //////////////////////
 // wxZlibInputStream
 //////////////////////
 //////////////////////
 // wxZlibInputStream
 //////////////////////


@@ -32,6 +35,10 @@ wxZlibInputStream::wxZlibInputStream(wxInputStream& stream)
 {
   int err;
 
 {
   int err;
 

+  // I need a private stream buffer.
+  m_i_streambuf = new wxStreamBuffer(*this);
+  m_i_destroybuf = TRUE;
+

   m_inflate.zalloc = (alloc_func)0;
   m_inflate.zfree = (free_func)0;
   m_inflate.opaque = (voidpf)0;
   m_inflate.zalloc = (alloc_func)0;
   m_inflate.zfree = (free_func)0;
   m_inflate.opaque = (voidpf)0;


@@ -42,7 +49,11 @@ wxZlibInputStream::wxZlibInputStream(wxInputStream& stream)
     return;
   }
 
     return;
   }
 

+  m_z_buffer = new unsigned char[ZSTREAM_BUFFER_SIZE];
+  m_z_size = ZSTREAM_BUFFER_SIZE;
+

   m_inflate.avail_in = 0;
   m_inflate.avail_in = 0;

+  m_inflate.next_in = NULL;

 }
 
 wxZlibInputStream::~wxZlibInputStream()
 }
 
 wxZlibInputStream::~wxZlibInputStream()


@@ -50,50 +61,35 @@ wxZlibInputStream::~wxZlibInputStream()
   inflateEnd(&m_inflate);
 }
 
   inflateEnd(&m_inflate);
 }
 

-wxInputStream& wxZlibInputStream::Read(void *buffer, size_t size)
+size_t wxZlibInputStream::DoRead(void *buffer, size_t size)

 {
   int err;
 
   m_inflate.next_out = (unsigned char *)buffer;
   m_inflate.avail_out = size;
 {
   int err;
 
   m_inflate.next_out = (unsigned char *)buffer;
   m_inflate.avail_out = size;

-  m_eof = FALSE;

 
   while (m_inflate.avail_out > 0) {
     if (m_inflate.avail_in == 0) {
 
   while (m_inflate.avail_out > 0) {
     if (m_inflate.avail_in == 0) {

-      wxFilterInputStream::Read(m_z_buffer, m_z_size);
+
+      m_parent_i_stream->Read(m_z_buffer, m_z_size);

       m_inflate.next_in = m_z_buffer;
       m_inflate.next_in = m_z_buffer;

-      m_inflate.avail_in = wxFilterInputStream::LastRead();
-      if (wxFilterInputStream::Eof()) {
-        m_lastread = size - m_inflate.avail_out;
-        return *this;
-      }
+      m_inflate.avail_in = m_parent_i_stream->LastRead();
+
+      if (m_parent_i_stream->Eof())
+        return (size - m_inflate.avail_in);

     }
     err = inflate(&m_inflate, Z_FINISH);
     }
     err = inflate(&m_inflate, Z_FINISH);

-    if (err == Z_STREAM_END) {
-      m_lastread = size - m_inflate.avail_out;
-      m_eof = TRUE;
-      return *this;
-    }
+    if (err == Z_STREAM_END)
+      return (size - m_inflate.avail_in);

   }
 
   }
 

-  m_lastread = size;
-  return *this;
-}
-
-off_t wxZlibInputStream::SeekI(off_t WXUNUSED(pos), wxSeekMode WXUNUSED(mode))
-{
-  return 0;
-}
-
-off_t wxZlibInputStream::TellI() const
-{
-  return 0;
+  return size-m_inflate.avail_in;

 }
 
 bool wxZlibInputStream::Eof() const
 {
   if (!m_eof)
 }
 
 bool wxZlibInputStream::Eof() const
 {
   if (!m_eof)

-    return wxFilterInputStream::Eof();
+    return m_parent_i_stream->Eof();

   return m_eof;
 }
 
   return m_eof;
 }
 


@@ -106,6 +102,9 @@ wxZlibOutputStream::wxZlibOutputStream(wxOutputStream& stream)
 {
   int err;
 
 {
   int err;
 

+  m_o_streambuf = new wxStreamBuffer(*this);
+  m_o_destroybuf = TRUE;
+

   m_deflate.zalloc = (alloc_func)0;
   m_deflate.zfree = (free_func)0;
   m_deflate.opaque = (voidpf)0;
   m_deflate.zalloc = (alloc_func)0;
   m_deflate.zfree = (free_func)0;
   m_deflate.opaque = (voidpf)0;


@@ -115,6 +114,10 @@ wxZlibOutputStream::wxZlibOutputStream(wxOutputStream& stream)
     deflateEnd(&m_deflate);
     return;
   }
     deflateEnd(&m_deflate);
     return;
   }

+
+  m_z_buffer = new unsigned char[ZSTREAM_BUFFER_SIZE];
+  m_z_size = ZSTREAM_BUFFER_SIZE;
+

   m_deflate.avail_in = 0;
   m_deflate.next_out = m_z_buffer;
   m_deflate.avail_out = m_z_size;
   m_deflate.avail_in = 0;
   m_deflate.next_out = m_z_buffer;
   m_deflate.avail_out = m_z_size;


@@ -124,72 +127,67 @@ wxZlibOutputStream::~wxZlibOutputStream()
 {
   int err;
 
 {
   int err;
 

-  while (1) {
-    err = deflate(&m_deflate, Z_FINISH);
-    if (err == Z_STREAM_END)
-      break;
-    if (err < 0) {
-      wxDebugMsg("wxZlibOutputStream: error during final deflate");
-      break;
-    }
-    if (m_deflate.avail_out == 0) {
-      wxFilterOutputStream::Write(m_z_buffer, m_z_size);
-      if (wxFilterOutputStream::Bad()) {
-        wxDebugMsg("wxZlibOutputStream: error during final write");
-        break;
-      }
-      m_deflate.next_out = m_z_buffer;
-      m_deflate.avail_out = m_z_size;
-    }
+  Sync();
+
+  err = deflate(&m_deflate, Z_FINISH);
+  if (err != Z_STREAM_END) {
+    wxDebugMsg(_("wxZlibOutputStream: an error occured while we was closing "
+               "the stream.\n"));
+    return;

   }
   }

-  wxFilterOutputStream::Write(m_z_buffer, m_z_size-m_deflate.avail_out);

 
   deflateEnd(&m_deflate);
 
   deflateEnd(&m_deflate);

+
+  delete[] m_z_buffer;

 }
 
 }
 

-wxOutputStream& wxZlibOutputStream::Write(const void *buffer, size_t size)
+void wxZlibOutputStream::Sync()
+{
+  int err;
+
+  m_parent_o_stream->Write(m_z_buffer, m_z_size-m_deflate.avail_out);
+  m_deflate.next_out  = m_z_buffer;
+  m_deflate.avail_out = m_z_size;
+
+  err = deflate(&m_deflate, Z_FULL_FLUSH);
+  if (err != Z_OK) {
+    m_bad = TRUE;
+    return;
+  }
+
+  m_parent_o_stream->Write(m_z_buffer, m_z_size-m_deflate.avail_out);
+  m_deflate.next_out  = m_z_buffer;
+  m_deflate.avail_out = m_z_size;
+}
+
+size_t wxZlibOutputStream::DoWrite(const void *buffer, size_t size)

 {
   int err;
 
   m_deflate.next_in = (unsigned char *)buffer;
   m_deflate.avail_in = size;
 
 {
   int err;
 
   m_deflate.next_in = (unsigned char *)buffer;
   m_deflate.avail_in = size;
 

-  m_bad = FALSE;

   while (m_deflate.avail_in > 0) {
   while (m_deflate.avail_in > 0) {

+

     if (m_deflate.avail_out == 0) {
     if (m_deflate.avail_out == 0) {

-      wxFilterOutputStream::Write(m_z_buffer, m_z_size);
-      if (wxFilterOutputStream::Bad()) {
-        m_lastwrite = size - m_deflate.avail_in;
-        return *this;
-      }
-            
+      m_parent_o_stream->Write(m_z_buffer, m_z_size);
+      if (m_parent_o_stream->Bad())
+        return (size - m_deflate.avail_in);
+

       m_deflate.next_out = m_z_buffer;
       m_deflate.avail_out = m_z_size;
     }
       m_deflate.next_out = m_z_buffer;
       m_deflate.avail_out = m_z_size;
     }

+

     err = deflate(&m_deflate, Z_NO_FLUSH);
     err = deflate(&m_deflate, Z_NO_FLUSH);

-    if (err < 0) {
-      m_bad = TRUE;
-      m_lastwrite = size - m_deflate.avail_in;
-      return *this;
-    }
+    if (err != Z_OK)
+      return (size - m_deflate.avail_in);

   }
   }

-  m_lastwrite = size;
-  return *this;
-}
-
-off_t wxZlibOutputStream::SeekO(off_t WXUNUSED(pos), wxSeekMode WXUNUSED(mode))
-{
-  return 0;
-}
-
-off_t wxZlibOutputStream::TellO() const
-{
-  return 0;
+  return size;

 }
 
 bool wxZlibOutputStream::Bad() const
 {
   if (!m_bad)
 }
 
 bool wxZlibOutputStream::Bad() const
 {
   if (!m_bad)

-    return wxFilterOutputStream::Bad();
+    return m_parent_o_stream->Bad();

   return m_bad;
 }
   return m_bad;
 }