added test for writing empty value to the config

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

diff --git a/src/common/stream.cpp b/src/common/stream.cpp
index 872d03c52cd3afe23a11cdb07b08864b0374ceb1..9c006b8f7ad4133686cc0fb8dddfc0d6150bc40a 100644 (file)
--- a/src/common/stream.cpp
+++ b/src/common/stream.cpp
@@ -17,8 +17,9 @@
 // ----------------------------------------------------------------------------
 // headers
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // headers
 // ----------------------------------------------------------------------------

+

 #ifdef __GNUG__
 #ifdef __GNUG__

-#pragma implementation "stream.h"
+    #pragma implementation "stream.h"

 #endif
 
 // For compilers that support precompilation, includes "wx.h".
 #endif
 
 // For compilers that support precompilation, includes "wx.h".


@@ -38,6 +39,7 @@
 #include "wx/stream.h"
 #include "wx/datstrm.h"
 #include "wx/objstrm.h"
 #include "wx/stream.h"
 #include "wx/datstrm.h"
 #include "wx/objstrm.h"

+#include "wx/textfile.h"

 
 // ----------------------------------------------------------------------------
 // constants
 
 // ----------------------------------------------------------------------------
 // constants


@@ -80,6 +82,8 @@ void wxStreamBuffer::Init()
 
 wxStreamBuffer::wxStreamBuffer(wxStreamBase& stream, BufMode mode)
 {
 
 wxStreamBuffer::wxStreamBuffer(wxStreamBase& stream, BufMode mode)
 {

+    Init();
+

     m_stream = &stream;
     m_mode = mode;
 
     m_stream = &stream;
     m_mode = mode;
 


@@ -89,6 +93,8 @@ wxStreamBuffer::wxStreamBuffer(wxStreamBase& stream, BufMode mode)
 
 wxStreamBuffer::wxStreamBuffer(BufMode mode)
 {
 
 wxStreamBuffer::wxStreamBuffer(BufMode mode)
 {

+    Init();
+

     m_stream = new wxStreamBase;
     m_mode = mode;
 
     m_stream = new wxStreamBase;
     m_mode = mode;
 


@@ -129,20 +135,38 @@ wxStreamBuffer::~wxStreamBuffer()
         delete m_stream;
 }
 
         delete m_stream;
 }
 

+wxInputStream *wxStreamBuffer::GetInputStream() const
+{
+    return m_mode == write ? NULL : (wxInputStream *)m_stream;
+}
+
+wxOutputStream *wxStreamBuffer::GetOutputStream() const
+{
+    return m_mode == read ? NULL : (wxOutputStream *)m_stream;
+}
+

 void wxStreamBuffer::SetBufferIO(void *buffer_start,
                                  void *buffer_end,
                                  bool takeOwnership)
 void wxStreamBuffer::SetBufferIO(void *buffer_start,
                                  void *buffer_end,
                                  bool takeOwnership)

+{
+    SetBufferIO(buffer_start, (char *)buffer_end - (char *)buffer_start,
+                takeOwnership);
+}
+
+void wxStreamBuffer::SetBufferIO(void *start,
+                                 size_t len,
+                                 bool takeOwnership)

 {
     // start by freeing the old buffer
     FreeBuffer();
 
 {
     // start by freeing the old buffer
     FreeBuffer();
 

-    m_buffer_start = (char *)buffer_start;
-    m_buffer_end   = (char *)buffer_end;
+    m_buffer_start = (char *)start;
+    m_buffer_end   = m_buffer_start + len;

 
 

-    m_buffer_size = m_buffer_end - m_buffer_start;
+    m_buffer_size = len;

 
     // if we own it, we free it
 
     // if we own it, we free it

-    m_destroybuf = !takeOwnership;
+    m_destroybuf = takeOwnership;

 
     ResetBuffer();
 }
 
     ResetBuffer();
 }


@@ -154,8 +178,7 @@ void wxStreamBuffer::SetBufferIO(size_t bufsize)
 
     if ( bufsize )
     {
 
     if ( bufsize )
     {

-        char *buf = (char *)malloc(bufsize);
-        SetBufferIO(buf, buf + bufsize, TRUE /* take ownership */);
+        SetBufferIO(malloc(bufsize), bufsize, TRUE /* take ownership */);

     }
     else // no buffer size => no buffer
     {
     }
     else // no buffer size => no buffer
     {


@@ -178,9 +201,11 @@ void wxStreamBuffer::ResetBuffer()
 // fill the buffer with as much data as possible (only for read buffers)
 bool wxStreamBuffer::FillBuffer()
 {
 // fill the buffer with as much data as possible (only for read buffers)
 bool wxStreamBuffer::FillBuffer()
 {

-    wxCHECK_MSG( m_stream, FALSE, _T("should have a stream in wxStreamBuffer") );
+    wxInputStream *inStream = GetInputStream();
+
+    wxCHECK_MSG( inStream, FALSE, _T("should have a stream in wxStreamBuffer") );

 
 

-    size_t count = m_stream->OnSysRead(m_buffer_start, m_buffer_size);
+    size_t count = inStream->OnSysRead(m_buffer_start, m_buffer_size);

     if ( !count )
         return FALSE;
 
     if ( !count )
         return FALSE;
 


@@ -199,10 +224,12 @@ bool wxStreamBuffer::FlushBuffer()
     if ( m_buffer_pos == m_buffer_start )
         return FALSE;
 
     if ( m_buffer_pos == m_buffer_start )
         return FALSE;
 

-    wxCHECK_MSG( m_stream, FALSE, _T("should have a stream in wxStreamBuffer") );
+    wxOutputStream *outStream = GetOutputStream();
+
+    wxCHECK_MSG( outStream, FALSE, _T("should have a stream in wxStreamBuffer") );

 
     size_t current = m_buffer_pos - m_buffer_start;
 
     size_t current = m_buffer_pos - m_buffer_start;

-    size_t count = m_stream->OnSysWrite(m_buffer_start, current);
+    size_t count = outStream->OnSysWrite(m_buffer_start, current);

     if ( count != current )
         return FALSE;
 
     if ( count != current )
         return FALSE;
 


@@ -274,12 +301,14 @@ void wxStreamBuffer::PutToBuffer(const void *buffer, size_t size)
 
 void wxStreamBuffer::PutChar(char c)
 {
 
 void wxStreamBuffer::PutChar(char c)
 {

-    wxCHECK_RET( m_stream, _T("should have a stream in wxStreamBuffer") );
+    wxOutputStream *outStream = GetOutputStream();
+
+    wxCHECK_RET( outStream, _T("should have a stream in wxStreamBuffer") );

 
     // if we don't have buffer at all, just forward this call to the stream,
     if ( !HasBuffer() )
     {
 
     // if we don't have buffer at all, just forward this call to the stream,
     if ( !HasBuffer() )
     {

-        m_stream->OnSysWrite(&c, 1);
+        outStream->OnSysWrite(&c, 1);

     }
     else
     {
     }
     else
     {


@@ -317,12 +346,14 @@ char wxStreamBuffer::Peek()
 
 char wxStreamBuffer::GetChar()
 {
 
 char wxStreamBuffer::GetChar()
 {

-    wxCHECK_MSG( m_stream, 0, _T("should have a stream in wxStreamBuffer") );
+    wxInputStream *inStream = GetInputStream();
+
+    wxCHECK_MSG( inStream, 0, _T("should have a stream in wxStreamBuffer") );

 
     char c;
     if ( !HasBuffer() )
     {
 
     char c;
     if ( !HasBuffer() )
     {

-        m_stream->OnSysRead(&c, 1);
+        inStream->OnSysRead(&c, 1);

     }
     else
     {
     }
     else
     {


@@ -343,16 +374,16 @@ char wxStreamBuffer::GetChar()
 
 size_t wxStreamBuffer::Read(void *buffer, size_t size)
 {
 
 size_t wxStreamBuffer::Read(void *buffer, size_t size)
 {

-    wxCHECK_MSG( m_stream, 0, _T("should have a stream in wxStreamBuffer") );
+    wxInputStream *inStream = GetInputStream();

 
 

-    wxCHECK_MSG( m_mode != write, 0, _T("can't read from this buffer") );
+    wxCHECK_MSG( inStream, 0, _T("should have a stream in wxStreamBuffer") );

 
     // lasterror is reset before all new IO calls
     m_stream->m_lasterror = wxStream_NOERROR;
 
     if ( !HasBuffer() )
     {
 
     // lasterror is reset before all new IO calls
     m_stream->m_lasterror = wxStream_NOERROR;
 
     if ( !HasBuffer() )
     {

-        m_stream->m_lastcount = m_stream->OnSysRead(buffer, size);
+        m_stream->m_lastcount = inStream->OnSysRead(buffer, size);

     }
     else // we have a buffer, use it
     {
     }
     else // we have a buffer, use it
     {


@@ -414,8 +445,9 @@ size_t wxStreamBuffer::Read(wxStreamBuffer *dbuf)
 
 size_t wxStreamBuffer::Write(const void *buffer, size_t size)
 {
 
 size_t wxStreamBuffer::Write(const void *buffer, size_t size)
 {

-    wxCHECK_MSG( m_stream, 0, _T("should have a stream in wxStreamBuffer") );
-    wxCHECK_MSG( m_mode != read, 0, _T("can't write to this buffer") );
+    wxOutputStream *outStream = GetOutputStream();
+
+    wxCHECK_MSG( outStream, 0, _T("should have a stream in wxStreamBuffer") );

 
     // lasterror is reset before all new IO calls
     m_stream->m_lasterror = wxStream_NOERROR;
 
     // lasterror is reset before all new IO calls
     m_stream->m_lasterror = wxStream_NOERROR;


@@ -423,7 +455,7 @@ size_t wxStreamBuffer::Write(const void *buffer, size_t size)
     if ( !HasBuffer() && m_fixed )
     {
         // no buffer, just forward the call to the stream
     if ( !HasBuffer() && m_fixed )
     {
         // no buffer, just forward the call to the stream

-        m_stream->m_lastcount = m_stream->OnSysWrite(buffer, size);
+        m_stream->m_lastcount = outStream->OnSysWrite(buffer, size);

     }
     else // we [may] have a buffer, use it
     {
     }
     else // we [may] have a buffer, use it
     {


@@ -600,16 +632,6 @@ 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::OnSysSeek(off_t WXUNUSED(seek), wxSeekMode WXUNUSED(mode))
 {
     return wxInvalidOffset;


@@ -636,13 +658,24 @@ wxInputStream::~wxInputStream()
     free(m_wback);
 }
 
     free(m_wback);
 }
 

+size_t wxInputStream::OnSysRead(void * WXUNUSED(buffer),
+                                size_t WXUNUSED(bufsize))
+{
+    return 0;
+}
+

 bool wxInputStream::Eof() const
 {
     wxInputStream *self = wxConstCast(this, wxInputStream);
 
     char c;
     self->Read(&c, 1);
 bool wxInputStream::Eof() const
 {
     wxInputStream *self = wxConstCast(this, wxInputStream);
 
     char c;
     self->Read(&c, 1);

-    if ( GetLastError() == wxSTREAM_EOF )
+
+    // some streams can know that they're at EOF before actually trying to
+    // read beyond the end of stream (e.g. files) while others have no way of
+    // knowing it, so to provide the same behaviour in all cases we only
+    // return TRUE from here if the character really couldn't be read
+    if ( !self->LastRead() && GetLastError() == wxSTREAM_EOF )

     {
         return TRUE;
     }
     {
         return TRUE;
     }


@@ -836,6 +869,12 @@ wxOutputStream::~wxOutputStream()
 {
 }
 
 {
 }
 

+size_t wxOutputStream::OnSysWrite(const void * WXUNUSED(buffer),
+                                  size_t WXUNUSED(bufsize))
+{
+    return 0;
+}
+

 void wxOutputStream::PutC(char c)
 {
     Write(&c, 1);
 void wxOutputStream::PutC(char c)
 {
     Write(&c, 1);


@@ -938,6 +977,7 @@ off_t wxCountingOutputStream::OnSysTell() const
 
 wxFilterInputStream::wxFilterInputStream()
 {
 
 wxFilterInputStream::wxFilterInputStream()
 {

+    m_parent_i_stream = NULL;

 }
 
 wxFilterInputStream::wxFilterInputStream(wxInputStream& stream)
 }
 
 wxFilterInputStream::wxFilterInputStream(wxInputStream& stream)


@@ -955,6 +995,7 @@ wxFilterInputStream::~wxFilterInputStream()
 
 wxFilterOutputStream::wxFilterOutputStream()
 {
 
 wxFilterOutputStream::wxFilterOutputStream()
 {

+    m_parent_o_stream = NULL;

 }
 
 wxFilterOutputStream::wxFilterOutputStream(wxOutputStream& stream)
 }
 
 wxFilterOutputStream::wxFilterOutputStream(wxOutputStream& stream)


@@ -970,17 +1011,27 @@ wxFilterOutputStream::~wxFilterOutputStream()
 // wxBufferedInputStream
 // ----------------------------------------------------------------------------
 
 // wxBufferedInputStream
 // ----------------------------------------------------------------------------
 

-wxBufferedInputStream::wxBufferedInputStream(wxInputStream& s)
+wxBufferedInputStream::wxBufferedInputStream(wxInputStream& s,
+                                             wxStreamBuffer *buffer)

                      : wxFilterInputStream(s)
 {
                      : wxFilterInputStream(s)
 {

-    m_i_streambuf = new wxStreamBuffer(*this, wxStreamBuffer::read);
+    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->SetBufferIO(1024);
+        m_i_streambuf->SetBufferIO(1024);
+    }

 }
 
 wxBufferedInputStream::~wxBufferedInputStream()
 {
 }
 
 wxBufferedInputStream::~wxBufferedInputStream()
 {

-    m_parent_i_stream->SeekI(-m_i_streambuf->GetBytesLeft(), wxFromCurrent);
+    m_parent_i_stream->SeekI(-(off_t)m_i_streambuf->GetBytesLeft(),
+                             wxFromCurrent);

 
     delete m_i_streambuf;
 }
 
     delete m_i_streambuf;
 }


@@ -996,7 +1047,7 @@ wxInputStream& wxBufferedInputStream::Read(void *buf, size_t size)
 
     retsize = GetWBack(buf, size);
     m_lastcount = retsize;
 
     retsize = GetWBack(buf, size);
     m_lastcount = retsize;

-    if (retsize == size)
+    if ( retsize == size )

     {
         m_lasterror = wxStream_NOERROR;
         return *this;
     {
         m_lasterror = wxStream_NOERROR;
         return *this;


@@ -1034,15 +1085,32 @@ off_t wxBufferedInputStream::OnSysTell() const
     return m_parent_i_stream->TellI();
 }
 
     return m_parent_i_stream->TellI();
 }
 

+void wxBufferedInputStream::SetInputStreamBuffer(wxStreamBuffer *buffer)
+{
+    wxCHECK_RET( buffer, _T("wxBufferedInputStream needs buffer") );
+
+    delete m_i_streambuf;
+    m_i_streambuf = buffer;
+}
+

 // ----------------------------------------------------------------------------
 // wxBufferedOutputStream
 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 // wxBufferedOutputStream
 // ----------------------------------------------------------------------------
 

-wxBufferedOutputStream::wxBufferedOutputStream(wxOutputStream& s)
+wxBufferedOutputStream::wxBufferedOutputStream(wxOutputStream& s,
+                                               wxStreamBuffer *buffer)

                       : wxFilterOutputStream(s)
 {
                       : wxFilterOutputStream(s)
 {

-    m_o_streambuf = new wxStreamBuffer(*this, wxStreamBuffer::write);
-    m_o_streambuf->SetBufferIO(1024);
+    if ( buffer )
+    {
+        m_o_streambuf = buffer;
+    }
+    else // create a default one
+    {
+        m_o_streambuf = new wxStreamBuffer(*this, wxStreamBuffer::write);
+
+        m_o_streambuf->SetBufferIO(1024);
+    }

 }
 
 wxBufferedOutputStream::~wxBufferedOutputStream()
 }
 
 wxBufferedOutputStream::~wxBufferedOutputStream()


@@ -1095,21 +1163,23 @@ size_t wxBufferedOutputStream::GetSize() const
    return m_parent_o_stream->GetSize() + m_o_streambuf->GetIntPosition();
 }
 
    return m_parent_o_stream->GetSize() + m_o_streambuf->GetIntPosition();
 }
 

+void wxBufferedOutputStream::SetOutputStreamBuffer(wxStreamBuffer *buffer)
+{
+    wxCHECK_RET( buffer, _T("wxBufferedOutputStream needs buffer") );
+
+    delete m_o_streambuf;
+    m_o_streambuf = buffer;
+}
+

 // ----------------------------------------------------------------------------
 // Some IOManip function
 // ----------------------------------------------------------------------------
 
 wxOutputStream& wxEndL(wxOutputStream& stream)
 {
 // ----------------------------------------------------------------------------
 // Some IOManip function
 // ----------------------------------------------------------------------------
 
 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
+    static const wxChar *eol = wxTextFile::GetEOL();
+
+    return stream.Write(eol, wxStrlen(eol));

 }
 
 #endif
 }
 
 #endif