]>
git.saurik.com Git - wxWidgets.git/blob - src/common/stream.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/common/stream.cpp
3 // Purpose: wxStream base classes
4 // Author: Guilhem Lavaux
5 // Modified by: VZ (23.11.00) to fix realloc()ing new[]ed memory,
9 // Copyright: (c) Guilhem Lavaux
10 // Licence: wxWindows license
11 /////////////////////////////////////////////////////////////////////////////
13 // ============================================================================
15 // ============================================================================
17 // ----------------------------------------------------------------------------
19 // ----------------------------------------------------------------------------
22 #pragma implementation "stream.h"
25 // For compilers that support precompilation, includes "wx.h".
26 #include "wx/wxprec.h"
39 #include "wx/stream.h"
40 #include "wx/datstrm.h"
41 #include "wx/textfile.h"
44 // ----------------------------------------------------------------------------
46 // ----------------------------------------------------------------------------
48 // the temporary buffer size used when copying from stream to stream
49 #define BUF_TEMP_SIZE 10000
51 // ============================================================================
53 // ============================================================================
55 // ----------------------------------------------------------------------------
57 // ----------------------------------------------------------------------------
59 void wxStreamBuffer::SetError(wxStreamError err
)
61 if ( m_stream
->m_lasterror
== wxStream_NOERROR
)
62 m_stream
->m_lasterror
= err
;
65 void wxStreamBuffer::InitBuffer()
72 // if we are going to allocate the buffer, we should free it later as well
76 void wxStreamBuffer::Init()
83 wxStreamBuffer::wxStreamBuffer(wxStreamBase
& stream
, BufMode mode
)
91 m_destroystream
= FALSE
;
94 wxStreamBuffer::wxStreamBuffer(BufMode mode
)
98 wxASSERT_MSG(mode
!= read_write
, wxT("you have to use the other ctor for read_write mode") );
100 m_stream
= new wxInputStream
;
101 else if ( mode
== write
)
102 m_stream
= new wxOutputStream
;
109 m_destroystream
= TRUE
;
112 wxStreamBuffer::wxStreamBuffer(const wxStreamBuffer
& buffer
)
114 // doing this has big chances to lead to a crashwhen the source buffer is
115 // destroyed (otherwise assume the caller knows what he does)
116 wxASSERT_MSG( !buffer
.m_destroybuf
&& !buffer
.m_destroystream
,
117 _T("it's a bad idea to copy this buffer") );
119 m_buffer_start
= buffer
.m_buffer_start
;
120 m_buffer_end
= buffer
.m_buffer_end
;
121 m_buffer_pos
= buffer
.m_buffer_pos
;
122 m_buffer_size
= buffer
.m_buffer_size
;
123 m_fixed
= buffer
.m_fixed
;
124 m_flushable
= buffer
.m_flushable
;
125 m_stream
= buffer
.m_stream
;
126 m_mode
= buffer
.m_mode
;
127 m_destroybuf
= FALSE
;
128 m_destroystream
= FALSE
;
131 void wxStreamBuffer::FreeBuffer()
134 free(m_buffer_start
);
137 wxStreamBuffer::~wxStreamBuffer()
141 if ( m_destroystream
)
145 wxInputStream
*wxStreamBuffer::GetInputStream() const
147 return m_mode
== write
? NULL
: (wxInputStream
*)m_stream
;
150 wxOutputStream
*wxStreamBuffer::GetOutputStream() const
152 return m_mode
== read
? NULL
: (wxOutputStream
*)m_stream
;
155 void wxStreamBuffer::SetBufferIO(void *buffer_start
,
159 SetBufferIO(buffer_start
, (char *)buffer_end
- (char *)buffer_start
,
163 void wxStreamBuffer::SetBufferIO(void *start
,
167 // start by freeing the old buffer
170 m_buffer_start
= (char *)start
;
171 m_buffer_end
= m_buffer_start
+ len
;
175 // if we own it, we free it
176 m_destroybuf
= takeOwnership
;
181 void wxStreamBuffer::SetBufferIO(size_t bufsize
)
183 // start by freeing the old buffer
188 SetBufferIO(malloc(bufsize
), bufsize
, TRUE
/* take ownership */);
190 else // no buffer size => no buffer
196 void wxStreamBuffer::ResetBuffer()
198 wxCHECK_RET( m_stream
, _T("should have a stream in wxStreamBuffer") );
200 m_stream
->m_lasterror
= wxStream_NOERROR
;
201 m_stream
->m_lastcount
= 0;
202 if (m_mode
== read
&& m_flushable
)
203 m_buffer_pos
= m_buffer_end
;
205 m_buffer_pos
= m_buffer_start
;
208 // fill the buffer with as much data as possible (only for read buffers)
209 bool wxStreamBuffer::FillBuffer()
211 wxInputStream
*inStream
= GetInputStream();
213 wxCHECK_MSG( inStream
, FALSE
, _T("should have a stream in wxStreamBuffer") );
215 size_t count
= inStream
->OnSysRead(m_buffer_start
, m_buffer_size
);
219 m_buffer_end
= m_buffer_start
+ count
;
220 m_buffer_pos
= m_buffer_start
;
225 // write the buffer contents to the stream (only for write buffers)
226 bool wxStreamBuffer::FlushBuffer()
228 wxCHECK_MSG( m_flushable
, FALSE
, _T("can't flush this buffer") );
230 // FIXME: what is this check for? (VZ)
231 if ( m_buffer_pos
== m_buffer_start
)
234 wxOutputStream
*outStream
= GetOutputStream();
236 wxCHECK_MSG( outStream
, FALSE
, _T("should have a stream in wxStreamBuffer") );
238 size_t current
= m_buffer_pos
- m_buffer_start
;
239 size_t count
= outStream
->OnSysWrite(m_buffer_start
, current
);
240 if ( count
!= current
)
243 m_buffer_pos
= m_buffer_start
;
248 size_t wxStreamBuffer::GetDataLeft()
250 /* Why is this done? RR. */
251 if ( m_buffer_pos
== m_buffer_end
&& m_flushable
)
254 return GetBytesLeft();
257 // copy up to size bytes from our buffer into the provided one
258 void wxStreamBuffer::GetFromBuffer(void *buffer
, size_t size
)
260 // don't get more bytes than left in the buffer
261 size_t left
= GetBytesLeft();
266 memcpy(buffer
, m_buffer_pos
, size
);
267 m_buffer_pos
+= size
;
270 // copy the contents of the provided buffer into this one
271 void wxStreamBuffer::PutToBuffer(const void *buffer
, size_t size
)
273 size_t left
= GetBytesLeft();
278 // we can't realloc the buffer, so just copy what we can
283 // realloc the buffer to have enough space for the data
284 size_t delta
= m_buffer_pos
- m_buffer_start
;
286 char *startOld
= m_buffer_start
;
287 m_buffer_size
+= size
;
288 m_buffer_start
= (char *)realloc(m_buffer_start
, m_buffer_size
);
289 if ( !m_buffer_start
)
291 // don't leak memory if realloc() failed
292 m_buffer_start
= startOld
;
293 m_buffer_size
-= size
;
295 // what else can we do?
299 // adjust the pointers invalidated by realloc()
300 m_buffer_pos
= m_buffer_start
+ delta
;
301 m_buffer_end
= m_buffer_start
+ m_buffer_size
;
305 memcpy(m_buffer_pos
, buffer
, size
);
306 m_buffer_pos
+= size
;
309 void wxStreamBuffer::PutChar(char c
)
311 wxOutputStream
*outStream
= GetOutputStream();
313 wxCHECK_RET( outStream
, _T("should have a stream in wxStreamBuffer") );
315 // if we don't have buffer at all, just forward this call to the stream,
318 outStream
->OnSysWrite(&c
, 1);
322 // otherwise check we have enough space left
323 if ( !GetDataLeft() && !FlushBuffer() )
326 SetError(wxStream_WRITE_ERR
);
331 m_stream
->m_lastcount
= 1;
336 char wxStreamBuffer::Peek()
338 wxCHECK_MSG( m_stream
&& HasBuffer(), 0,
339 _T("should have the stream and the buffer in wxStreamBuffer") );
341 if ( !GetDataLeft() )
343 SetError(wxStream_READ_ERR
);
348 GetFromBuffer(&c
, 1);
354 char wxStreamBuffer::GetChar()
356 wxInputStream
*inStream
= GetInputStream();
358 wxCHECK_MSG( inStream
, 0, _T("should have a stream in wxStreamBuffer") );
363 inStream
->OnSysRead(&c
, 1);
367 if ( !GetDataLeft() )
369 SetError(wxStream_READ_ERR
);
374 GetFromBuffer(&c
, 1);
375 m_stream
->m_lastcount
= 1;
382 size_t wxStreamBuffer::Read(void *buffer
, size_t size
)
384 wxInputStream
*inStream
= GetInputStream();
386 wxCHECK_MSG( inStream
, 0, _T("should have a stream in wxStreamBuffer") );
388 // lasterror is reset before all new IO calls
389 m_stream
->m_lasterror
= wxStream_NOERROR
;
393 m_stream
->m_lastcount
= inStream
->OnSysRead(buffer
, size
);
395 else // we have a buffer, use it
397 size_t orig_size
= size
;
401 size_t left
= GetDataLeft();
403 // if the requested number of bytes if greater than the buffer
404 // size, read data in chunks
407 GetFromBuffer(buffer
, left
);
409 buffer
= (char *)buffer
+ left
;
413 SetError(wxStream_EOF
);
417 else // otherwise just do it in one gulp
419 GetFromBuffer(buffer
, size
);
424 m_stream
->m_lastcount
= orig_size
- size
;
427 return m_stream
->m_lastcount
;
430 // this should really be called "Copy()"
431 size_t wxStreamBuffer::Read(wxStreamBuffer
*dbuf
)
433 wxCHECK_MSG( m_mode
!= write
, 0, _T("can't read from this buffer") );
435 char buf
[BUF_TEMP_SIZE
];
441 nRead
= Read(dbuf
, WXSIZEOF(buf
));
444 nRead
= dbuf
->Write(buf
, nRead
);
453 size_t wxStreamBuffer::Write(const void *buffer
, size_t size
)
455 wxOutputStream
*outStream
= GetOutputStream();
457 wxCHECK_MSG( outStream
, 0, _T("should have a stream in wxStreamBuffer") );
459 // lasterror is reset before all new IO calls
460 m_stream
->m_lasterror
= wxStream_NOERROR
;
462 if ( !HasBuffer() && m_fixed
)
464 // no buffer, just forward the call to the stream
465 m_stream
->m_lastcount
= outStream
->OnSysWrite(buffer
, size
);
467 else // we [may] have a buffer, use it
469 size_t orig_size
= size
;
473 size_t left
= GetBytesLeft();
475 // if the buffer is too large to fit in the stream buffer, split
476 // it in smaller parts
478 // NB: If stream buffer isn't fixed (as for wxMemoryOutputStream),
479 // we always go to the second case.
481 // FIXME: fine, but if it fails we should (re)try writing it by
482 // chunks as this will (hopefully) always work (VZ)
483 if ( size
> left
&& m_fixed
)
485 PutToBuffer(buffer
, left
);
487 buffer
= (char *)buffer
+ left
;
489 if ( !FlushBuffer() )
491 SetError(wxStream_WRITE_ERR
);
496 m_buffer_pos
= m_buffer_start
;
498 else // we can do it in one gulp
500 PutToBuffer(buffer
, size
);
505 m_stream
->m_lastcount
= orig_size
- size
;
508 return m_stream
->m_lastcount
;
511 size_t wxStreamBuffer::Write(wxStreamBuffer
*sbuf
)
513 wxCHECK_MSG( m_mode
!= read
, 0, _T("can't write to this buffer") );
514 wxCHECK_MSG( sbuf
->m_mode
!= write
, 0, _T("can't read from that buffer") );
516 char buf
[BUF_TEMP_SIZE
];
522 size_t nRead
= sbuf
->Read(buf
, WXSIZEOF(buf
));
525 nWrite
= Write(buf
, nRead
);
526 if ( nWrite
< nRead
)
528 // put back data we couldn't copy
529 wxInputStream
*in_stream
= (wxInputStream
*)sbuf
->GetStream();
531 in_stream
->Ungetch(buf
+ nWrite
, nRead
- nWrite
);
541 while ( nWrite
== WXSIZEOF(buf
) );
546 off_t
wxStreamBuffer::Seek(off_t pos
, wxSeekMode mode
)
550 off_t last_access
= GetLastAccess();
561 diff
= pos
+ GetIntPosition();
565 diff
= pos
+ last_access
;
569 wxFAIL_MSG( _T("invalid seek mode") );
571 return wxInvalidOffset
;
573 if (diff
< 0 || diff
> last_access
)
574 return wxInvalidOffset
;
575 SetIntPosition(diff
);
582 // We'll try to compute an internal position later ...
583 ret_off
= m_stream
->OnSysSeek(pos
, wxFromStart
);
588 diff
= pos
+ GetIntPosition();
590 if ( (diff
> last_access
) || (diff
< 0) )
592 // We must take into account the fact that we have read
593 // something previously.
594 ret_off
= m_stream
->OnSysSeek(diff
-last_access
, wxFromCurrent
);
600 SetIntPosition(diff
);
605 // Hard to compute: always seek to the requested position.
606 ret_off
= m_stream
->OnSysSeek(pos
, wxFromEnd
);
611 return wxInvalidOffset
;
614 off_t
wxStreamBuffer::Tell() const
618 // only ask the stream for position if we have a real stream and not a
619 // dummy one which we created ourselves, otherwise we'd call
620 // wxStream::OnSysTell() which would always return wxInvalidOffset
621 if ( !m_destroystream
)
623 pos
= m_stream
->OnSysTell();
624 if ( pos
== wxInvalidOffset
)
625 return wxInvalidOffset
;
627 else // no associated stream
632 pos
+= GetIntPosition();
634 if ( m_mode
== read
&& m_flushable
)
635 pos
-= GetLastAccess();
640 // ----------------------------------------------------------------------------
642 // ----------------------------------------------------------------------------
644 wxStreamBase::wxStreamBase()
646 m_lasterror
= wxStream_NOERROR
;
650 wxStreamBase::~wxStreamBase()
654 off_t
wxStreamBase::OnSysSeek(off_t
WXUNUSED(seek
), wxSeekMode
WXUNUSED(mode
))
656 return wxInvalidOffset
;
659 off_t
wxStreamBase::OnSysTell() const
661 return wxInvalidOffset
;
664 // ----------------------------------------------------------------------------
666 // ----------------------------------------------------------------------------
668 wxInputStream::wxInputStream()
675 wxInputStream::~wxInputStream()
680 size_t wxInputStream::OnSysRead(void * WXUNUSED(buffer
),
681 size_t WXUNUSED(bufsize
))
686 bool wxInputStream::Eof() const
688 wxInputStream
*self
= wxConstCast(this, wxInputStream
);
693 // some streams can know that they're at EOF before actually trying to
694 // read beyond the end of stream (e.g. files) while others have no way of
695 // knowing it, so to provide the same behaviour in all cases we only
696 // return TRUE from here if the character really couldn't be read
697 if ( !self
->LastRead() && GetLastError() == wxSTREAM_EOF
)
707 char *wxInputStream::AllocSpaceWBack(size_t needed_size
)
709 // get number of bytes left from previous wback buffer
710 size_t toget
= m_wbacksize
- m_wbackcur
;
712 // allocate a buffer large enough to hold prev + new data
713 char *temp_b
= (char *)malloc(needed_size
+ toget
);
718 // copy previous data (and free old buffer) if needed
721 memmove(temp_b
+ needed_size
, m_wback
+ m_wbackcur
, toget
);
728 m_wbacksize
= needed_size
+ toget
;
733 size_t wxInputStream::GetWBack(void *buf
, size_t bsize
)
738 // how many bytes do we have in the buffer?
739 size_t toget
= m_wbacksize
- m_wbackcur
;
743 // we won't read everything
747 // copy the data from the cache
748 memcpy(buf
, m_wback
+ m_wbackcur
, toget
);
751 if ( m_wbackcur
== m_wbacksize
)
753 // TODO: should we really free it here all the time? maybe keep it?
760 // return the number of bytes copied
764 size_t wxInputStream::Ungetch(const void *buf
, size_t bufsize
)
766 if ( m_lasterror
!= wxSTREAM_NO_ERROR
&& m_lasterror
!= wxSTREAM_EOF
)
768 // can't operate on this stream until the error is cleared
772 char *ptrback
= AllocSpaceWBack(bufsize
);
776 // Eof() shouldn't return TRUE any longer
777 if ( m_lasterror
== wxSTREAM_EOF
)
778 m_lasterror
= wxSTREAM_NO_ERROR
;
780 memcpy(ptrback
, buf
, bufsize
);
784 bool wxInputStream::Ungetch(char c
)
786 return Ungetch(&c
, sizeof(char)) != 0;
789 char wxInputStream::GetC()
796 wxInputStream
& wxInputStream::Read(void *buf
, size_t size
)
798 char *p
= (char *)buf
;
801 size_t read
= GetWBack(buf
, size
);
810 // we read the requested amount of data
814 read
= OnSysRead(p
, size
);
817 // no more data available
825 char wxInputStream::Peek()
829 if (m_lasterror
== wxStream_NOERROR
)
838 wxInputStream
& wxInputStream::Read(wxOutputStream
& stream_out
)
840 char buf
[BUF_TEMP_SIZE
];
841 size_t bytes_read
= BUF_TEMP_SIZE
;
843 while (bytes_read
== BUF_TEMP_SIZE
)
845 bytes_read
= Read(buf
, bytes_read
).LastRead();
846 bytes_read
= stream_out
.Write(buf
, bytes_read
).LastWrite();
851 off_t
wxInputStream::SeekI(off_t pos
, wxSeekMode mode
)
853 // RR: This code is duplicated in wxBufferedInputStream. This is
854 // not really a good design, but buffered stream are different
855 // from all other in that they handle two stream-related objects,
856 // the stream buffer and parent stream.
858 // I don't know whether it should be put as well in wxFileInputStream::OnSysSeek
859 if (m_lasterror
==wxSTREAM_EOF
)
860 m_lasterror
=wxSTREAM_NOERROR
;
862 /* RR: A call to SeekI() will automatically invalidate any previous
863 call to Ungetch(), otherwise it would be possible to SeekI() to
864 one position, unread some bytes there, SeekI() to another position
865 and the data would be corrupted.
867 GRG: Could add code here to try to navigate within the wback
868 buffer if possible, but is it really needed? It would only work
869 when seeking in wxFromCurrent mode, else it would invalidate
874 wxLogDebug( wxT("Seeking in stream which has data written back to it.") );
882 return OnSysSeek(pos
, mode
);
885 off_t
wxInputStream::TellI() const
887 off_t pos
= OnSysTell();
889 if (pos
!= wxInvalidOffset
)
890 pos
-= (m_wbacksize
- m_wbackcur
);
896 // ----------------------------------------------------------------------------
898 // ----------------------------------------------------------------------------
900 wxOutputStream::wxOutputStream()
904 wxOutputStream::~wxOutputStream()
908 size_t wxOutputStream::OnSysWrite(const void * WXUNUSED(buffer
),
909 size_t WXUNUSED(bufsize
))
914 void wxOutputStream::PutC(char c
)
919 wxOutputStream
& wxOutputStream::Write(const void *buffer
, size_t size
)
921 m_lastcount
= OnSysWrite(buffer
, size
);
925 wxOutputStream
& wxOutputStream::Write(wxInputStream
& stream_in
)
927 stream_in
.Read(*this);
931 off_t
wxOutputStream::TellO() const
936 off_t
wxOutputStream::SeekO(off_t pos
, wxSeekMode mode
)
938 return OnSysSeek(pos
, mode
);
941 void wxOutputStream::Sync()
946 // ----------------------------------------------------------------------------
947 // wxCountingOutputStream
948 // ----------------------------------------------------------------------------
950 wxCountingOutputStream::wxCountingOutputStream ()
955 size_t wxCountingOutputStream::GetSize() const
960 size_t wxCountingOutputStream::OnSysWrite(const void *WXUNUSED(buffer
),
963 m_currentPos
+= size
;
964 if (m_currentPos
> m_lastcount
)
965 m_lastcount
= m_currentPos
;
970 off_t
wxCountingOutputStream::OnSysSeek(off_t pos
, wxSeekMode mode
)
979 m_currentPos
= m_lastcount
+ pos
;
987 wxFAIL_MSG( _T("invalid seek mode") );
988 return wxInvalidOffset
;
991 if (m_currentPos
> m_lastcount
)
992 m_lastcount
= m_currentPos
;
997 off_t
wxCountingOutputStream::OnSysTell() const
1002 // ----------------------------------------------------------------------------
1003 // wxFilterInputStream
1004 // ----------------------------------------------------------------------------
1006 wxFilterInputStream::wxFilterInputStream()
1008 m_parent_i_stream
= NULL
;
1011 wxFilterInputStream::wxFilterInputStream(wxInputStream
& stream
)
1013 m_parent_i_stream
= &stream
;
1016 wxFilterInputStream::~wxFilterInputStream()
1020 // ----------------------------------------------------------------------------
1021 // wxFilterOutputStream
1022 // ----------------------------------------------------------------------------
1024 wxFilterOutputStream::wxFilterOutputStream()
1026 m_parent_o_stream
= NULL
;
1029 wxFilterOutputStream::wxFilterOutputStream(wxOutputStream
& stream
)
1031 m_parent_o_stream
= &stream
;
1034 wxFilterOutputStream::~wxFilterOutputStream()
1038 // ----------------------------------------------------------------------------
1039 // wxBufferedInputStream
1040 // ----------------------------------------------------------------------------
1042 wxBufferedInputStream::wxBufferedInputStream(wxInputStream
& s
,
1043 wxStreamBuffer
*buffer
)
1044 : wxFilterInputStream(s
)
1048 // use the buffer provided by the user
1049 m_i_streambuf
= buffer
;
1051 else // create a default buffer
1053 m_i_streambuf
= new wxStreamBuffer(*this, wxStreamBuffer::read
);
1055 m_i_streambuf
->SetBufferIO(1024);
1059 wxBufferedInputStream::~wxBufferedInputStream()
1061 m_parent_i_stream
->SeekI(-(off_t
)m_i_streambuf
->GetBytesLeft(),
1064 delete m_i_streambuf
;
1067 char wxBufferedInputStream::Peek()
1069 return m_i_streambuf
->Peek();
1072 wxInputStream
& wxBufferedInputStream::Read(void *buf
, size_t size
)
1074 // reset the error flag
1075 m_lasterror
= wxStream_NOERROR
;
1077 // first read from the already cached data
1078 m_lastcount
= GetWBack(buf
, size
);
1080 // do we have to read anything more?
1081 if ( m_lastcount
< size
)
1083 size
-= m_lastcount
;
1084 buf
= (char *)buf
+ m_lastcount
;
1086 // the call to wxStreamBuffer::Read() below will reset our m_lastcount,
1088 size_t countOld
= m_lastcount
;
1090 m_i_streambuf
->Read(buf
, size
);
1092 m_lastcount
+= countOld
;
1098 off_t
wxBufferedInputStream::SeekI(off_t pos
, wxSeekMode mode
)
1100 // RR: Look at wxInputStream for comments.
1102 if (m_lasterror
==wxSTREAM_EOF
)
1103 m_lasterror
=wxSTREAM_NOERROR
;
1107 wxLogDebug( wxT("Seeking in stream which has data written back to it.") );
1115 return m_i_streambuf
->Seek(pos
, mode
);
1118 off_t
wxBufferedInputStream::TellI() const
1120 off_t pos
= m_i_streambuf
->Tell();
1122 if (pos
!= wxInvalidOffset
)
1123 pos
-= (m_wbacksize
- m_wbackcur
);
1128 size_t wxBufferedInputStream::OnSysRead(void *buffer
, size_t bufsize
)
1130 return m_parent_i_stream
->Read(buffer
, bufsize
).LastRead();
1133 off_t
wxBufferedInputStream::OnSysSeek(off_t seek
, wxSeekMode mode
)
1135 return m_parent_i_stream
->SeekI(seek
, mode
);
1138 off_t
wxBufferedInputStream::OnSysTell() const
1140 return m_parent_i_stream
->TellI();
1143 void wxBufferedInputStream::SetInputStreamBuffer(wxStreamBuffer
*buffer
)
1145 wxCHECK_RET( buffer
, _T("wxBufferedInputStream needs buffer") );
1147 delete m_i_streambuf
;
1148 m_i_streambuf
= buffer
;
1151 // ----------------------------------------------------------------------------
1152 // wxBufferedOutputStream
1153 // ----------------------------------------------------------------------------
1155 wxBufferedOutputStream::wxBufferedOutputStream(wxOutputStream
& s
,
1156 wxStreamBuffer
*buffer
)
1157 : wxFilterOutputStream(s
)
1161 m_o_streambuf
= buffer
;
1163 else // create a default one
1165 m_o_streambuf
= new wxStreamBuffer(*this, wxStreamBuffer::write
);
1167 m_o_streambuf
->SetBufferIO(1024);
1171 wxBufferedOutputStream::~wxBufferedOutputStream()
1174 delete m_o_streambuf
;
1177 wxOutputStream
& wxBufferedOutputStream::Write(const void *buffer
, size_t size
)
1180 m_o_streambuf
->Write(buffer
, size
);
1184 off_t
wxBufferedOutputStream::SeekO(off_t pos
, wxSeekMode mode
)
1187 return m_o_streambuf
->Seek(pos
, mode
);
1190 off_t
wxBufferedOutputStream::TellO() const
1192 return m_o_streambuf
->Tell();
1195 void wxBufferedOutputStream::Sync()
1197 m_o_streambuf
->FlushBuffer();
1198 m_parent_o_stream
->Sync();
1201 size_t wxBufferedOutputStream::OnSysWrite(const void *buffer
, size_t bufsize
)
1203 return m_parent_o_stream
->Write(buffer
, bufsize
).LastWrite();
1206 off_t
wxBufferedOutputStream::OnSysSeek(off_t seek
, wxSeekMode mode
)
1208 return m_parent_o_stream
->SeekO(seek
, mode
);
1211 off_t
wxBufferedOutputStream::OnSysTell() const
1213 return m_parent_o_stream
->TellO();
1216 size_t wxBufferedOutputStream::GetSize() const
1218 return m_parent_o_stream
->GetSize() + m_o_streambuf
->GetIntPosition();
1221 void wxBufferedOutputStream::SetOutputStreamBuffer(wxStreamBuffer
*buffer
)
1223 wxCHECK_RET( buffer
, _T("wxBufferedOutputStream needs buffer") );
1225 delete m_o_streambuf
;
1226 m_o_streambuf
= buffer
;
1229 // ----------------------------------------------------------------------------
1230 // Some IOManip function
1231 // ----------------------------------------------------------------------------
1233 wxOutputStream
& wxEndL(wxOutputStream
& stream
)
1235 static const wxChar
*eol
= wxTextFile::GetEOL();
1237 return stream
.Write(eol
, wxStrlen(eol
));