]>
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 licence
11 /////////////////////////////////////////////////////////////////////////////
13 // ============================================================================
15 // ============================================================================
17 // ----------------------------------------------------------------------------
19 // ----------------------------------------------------------------------------
21 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
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 4096
51 // ============================================================================
53 // ============================================================================
55 // ----------------------------------------------------------------------------
57 // ----------------------------------------------------------------------------
59 void wxStreamBuffer::SetError(wxStreamError err
)
61 if ( m_stream
&& m_stream
->m_lasterror
== wxSTREAM_NO_ERROR
)
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(BufMode mode
)
93 wxStreamBuffer::wxStreamBuffer(wxStreamBase
& stream
, BufMode mode
)
103 wxStreamBuffer::wxStreamBuffer(const wxStreamBuffer
& buffer
)
105 // doing this has big chances to lead to a crash when the source buffer is
106 // destroyed (otherwise assume the caller knows what he does)
107 wxASSERT_MSG( !buffer
.m_destroybuf
,
108 _T("it's a bad idea to copy this buffer") );
110 m_buffer_start
= buffer
.m_buffer_start
;
111 m_buffer_end
= buffer
.m_buffer_end
;
112 m_buffer_pos
= buffer
.m_buffer_pos
;
113 m_buffer_size
= buffer
.m_buffer_size
;
114 m_fixed
= buffer
.m_fixed
;
115 m_flushable
= buffer
.m_flushable
;
116 m_stream
= buffer
.m_stream
;
117 m_mode
= buffer
.m_mode
;
118 m_destroybuf
= false;
121 void wxStreamBuffer::FreeBuffer()
124 free(m_buffer_start
);
127 wxStreamBuffer::~wxStreamBuffer()
132 wxInputStream
*wxStreamBuffer::GetInputStream() const
134 return m_mode
== write
? NULL
: (wxInputStream
*)m_stream
;
137 wxOutputStream
*wxStreamBuffer::GetOutputStream() const
139 return m_mode
== read
? NULL
: (wxOutputStream
*)m_stream
;
142 void wxStreamBuffer::SetBufferIO(void *buffer_start
,
146 SetBufferIO(buffer_start
, (char *)buffer_end
- (char *)buffer_start
,
150 void wxStreamBuffer::SetBufferIO(void *start
,
154 // start by freeing the old buffer
157 m_buffer_start
= (char *)start
;
158 m_buffer_end
= m_buffer_start
+ len
;
162 // if we own it, we free it
163 m_destroybuf
= takeOwnership
;
168 void wxStreamBuffer::SetBufferIO(size_t bufsize
)
170 // start by freeing the old buffer
175 SetBufferIO(malloc(bufsize
), bufsize
, true /* take ownership */);
177 else // no buffer size => no buffer
183 void wxStreamBuffer::ResetBuffer()
188 m_stream
->m_lastcount
= 0;
191 m_buffer_pos
= m_mode
== read
&& m_flushable
196 // fill the buffer with as much data as possible (only for read buffers)
197 bool wxStreamBuffer::FillBuffer()
199 wxInputStream
*inStream
= GetInputStream();
201 // It's legal to have no stream, so we don't complain about it just return false
205 size_t count
= inStream
->OnSysRead(m_buffer_start
, m_buffer_size
);
209 m_buffer_end
= m_buffer_start
+ count
;
210 m_buffer_pos
= m_buffer_start
;
215 // write the buffer contents to the stream (only for write buffers)
216 bool wxStreamBuffer::FlushBuffer()
218 wxCHECK_MSG( m_flushable
, false, _T("can't flush this buffer") );
220 // FIXME: what is this check for? (VZ)
221 if ( m_buffer_pos
== m_buffer_start
)
224 wxOutputStream
*outStream
= GetOutputStream();
226 wxCHECK_MSG( outStream
, false, _T("should have a stream in wxStreamBuffer") );
228 size_t current
= m_buffer_pos
- m_buffer_start
;
229 size_t count
= outStream
->OnSysWrite(m_buffer_start
, current
);
230 if ( count
!= current
)
233 m_buffer_pos
= m_buffer_start
;
238 size_t wxStreamBuffer::GetDataLeft()
240 /* Why is this done? RR. */
241 if ( m_buffer_pos
== m_buffer_end
&& m_flushable
)
244 return GetBytesLeft();
247 // copy up to size bytes from our buffer into the provided one
248 void wxStreamBuffer::GetFromBuffer(void *buffer
, size_t size
)
250 // don't get more bytes than left in the buffer
251 size_t left
= GetBytesLeft();
256 memcpy(buffer
, m_buffer_pos
, size
);
257 m_buffer_pos
+= size
;
260 // copy the contents of the provided buffer into this one
261 void wxStreamBuffer::PutToBuffer(const void *buffer
, size_t size
)
263 size_t left
= GetBytesLeft();
269 // we can't realloc the buffer, so just copy what we can
274 // realloc the buffer to have enough space for the data
275 size_t delta
= m_buffer_pos
- m_buffer_start
;
277 char *startOld
= m_buffer_start
;
278 m_buffer_size
+= size
;
279 m_buffer_start
= (char *)realloc(m_buffer_start
, m_buffer_size
);
280 if ( !m_buffer_start
)
282 // don't leak memory if realloc() failed
283 m_buffer_start
= startOld
;
284 m_buffer_size
-= size
;
286 // what else can we do?
290 // adjust the pointers invalidated by realloc()
291 m_buffer_pos
= m_buffer_start
+ delta
;
292 m_buffer_end
= m_buffer_start
+ m_buffer_size
;
296 memcpy(m_buffer_pos
, buffer
, size
);
297 m_buffer_pos
+= size
;
300 void wxStreamBuffer::PutChar(char c
)
302 wxOutputStream
*outStream
= GetOutputStream();
304 wxCHECK_RET( outStream
, _T("should have a stream in wxStreamBuffer") );
306 // if we don't have buffer at all, just forward this call to the stream,
309 outStream
->OnSysWrite(&c
, sizeof(c
));
313 // otherwise check we have enough space left
314 if ( !GetDataLeft() && !FlushBuffer() )
317 SetError(wxSTREAM_WRITE_ERROR
);
321 PutToBuffer(&c
, sizeof(c
));
322 m_stream
->m_lastcount
= 1;
327 char wxStreamBuffer::Peek()
329 wxCHECK_MSG( m_stream
&& HasBuffer(), 0,
330 _T("should have the stream and the buffer in wxStreamBuffer") );
332 if ( !GetDataLeft() )
334 SetError(wxSTREAM_READ_ERROR
);
339 GetFromBuffer(&c
, sizeof(c
));
345 char wxStreamBuffer::GetChar()
347 wxInputStream
*inStream
= GetInputStream();
349 wxCHECK_MSG( inStream
, 0, _T("should have a stream in wxStreamBuffer") );
354 inStream
->OnSysRead(&c
, sizeof(c
));
358 if ( !GetDataLeft() )
360 SetError(wxSTREAM_READ_ERROR
);
365 GetFromBuffer(&c
, sizeof(c
));
366 m_stream
->m_lastcount
= 1;
373 size_t wxStreamBuffer::Read(void *buffer
, size_t size
)
375 // lasterror is reset before all new IO calls
382 wxInputStream
*inStream
= GetInputStream();
384 wxCHECK_MSG( inStream
, 0, _T("should have a stream in wxStreamBuffer") );
386 read
= inStream
->OnSysRead(buffer
, size
);
388 else // we have a buffer, use it
390 size_t orig_size
= size
;
394 size_t left
= GetDataLeft();
396 // if the requested number of bytes if greater than the buffer
397 // size, read data in chunks
400 GetFromBuffer(buffer
, left
);
402 buffer
= (char *)buffer
+ left
;
406 SetError(wxSTREAM_EOF
);
410 else // otherwise just do it in one gulp
412 GetFromBuffer(buffer
, size
);
417 read
= orig_size
- size
;
421 m_stream
->m_lastcount
= read
;
426 // this should really be called "Copy()"
427 size_t wxStreamBuffer::Read(wxStreamBuffer
*dbuf
)
429 wxCHECK_MSG( m_mode
!= write
, 0, _T("can't read from this buffer") );
431 char buf
[BUF_TEMP_SIZE
];
437 nRead
= Read(dbuf
, WXSIZEOF(buf
));
440 nRead
= dbuf
->Write(buf
, nRead
);
449 size_t wxStreamBuffer::Write(const void *buffer
, size_t size
)
453 // lasterror is reset before all new IO calls
459 if ( !HasBuffer() && m_fixed
)
461 wxOutputStream
*outStream
= GetOutputStream();
463 wxCHECK_MSG( outStream
, 0, _T("should have a stream in wxStreamBuffer") );
465 // no buffer, just forward the call to the stream
466 ret
= outStream
->OnSysWrite(buffer
, size
);
468 else // we [may] have a buffer, use it
470 size_t orig_size
= size
;
474 size_t left
= GetBytesLeft();
476 // if the buffer is too large to fit in the stream buffer, split
477 // it in smaller parts
479 // NB: If stream buffer isn't fixed (as for wxMemoryOutputStream),
480 // we always go to the second case.
482 // FIXME: fine, but if it fails we should (re)try writing it by
483 // chunks as this will (hopefully) always work (VZ)
485 if ( size
> left
&& m_fixed
)
487 PutToBuffer(buffer
, left
);
489 buffer
= (char *)buffer
+ left
;
491 if ( !FlushBuffer() )
493 SetError(wxSTREAM_WRITE_ERROR
);
498 m_buffer_pos
= m_buffer_start
;
500 else // we can do it in one gulp
502 PutToBuffer(buffer
, size
);
507 ret
= orig_size
- size
;
512 // i am not entirely sure what we do this for
513 m_stream
->m_lastcount
= ret
;
519 size_t wxStreamBuffer::Write(wxStreamBuffer
*sbuf
)
521 wxCHECK_MSG( m_mode
!= read
, 0, _T("can't write to this buffer") );
522 wxCHECK_MSG( sbuf
->m_mode
!= write
, 0, _T("can't read from that buffer") );
524 char buf
[BUF_TEMP_SIZE
];
530 size_t nRead
= sbuf
->Read(buf
, WXSIZEOF(buf
));
533 nWrite
= Write(buf
, nRead
);
534 if ( nWrite
< nRead
)
536 // put back data we couldn't copy
537 wxInputStream
*in_stream
= (wxInputStream
*)sbuf
->GetStream();
539 in_stream
->Ungetch(buf
+ nWrite
, nRead
- nWrite
);
549 while ( nWrite
== WXSIZEOF(buf
) );
554 wxFileOffset
wxStreamBuffer::Seek(wxFileOffset pos
, wxSeekMode mode
)
556 wxFileOffset ret_off
, diff
;
558 wxFileOffset last_access
= GetLastAccess();
569 diff
= pos
+ GetIntPosition();
573 diff
= pos
+ last_access
;
577 wxFAIL_MSG( _T("invalid seek mode") );
579 return (wxFileOffset
) wxInvalidOffset
;
581 if (diff
< 0 || diff
> last_access
)
582 return (wxFileOffset
) wxInvalidOffset
;
583 SetIntPosition(diff
);
590 // We'll try to compute an internal position later ...
591 ret_off
= m_stream
->OnSysSeek(pos
, wxFromStart
);
596 diff
= pos
+ GetIntPosition();
598 if ( (diff
> last_access
) || (diff
< 0) )
600 // We must take into account the fact that we have read
601 // something previously.
602 ret_off
= m_stream
->OnSysSeek(diff
-last_access
, wxFromCurrent
);
608 SetIntPosition(diff
);
613 // Hard to compute: always seek to the requested position.
614 ret_off
= m_stream
->OnSysSeek(pos
, wxFromEnd
);
619 return (wxFileOffset
) wxInvalidOffset
;
622 wxFileOffset
wxStreamBuffer::Tell() const
626 // ask the stream for position if we have a real one
629 pos
= m_stream
->OnSysTell();
630 if ( pos
== wxInvalidOffset
)
631 return (wxFileOffset
) wxInvalidOffset
;
633 else // no associated stream
638 pos
+= GetIntPosition();
640 if ( m_mode
== read
&& m_flushable
)
641 pos
-= GetLastAccess();
646 // ----------------------------------------------------------------------------
648 // ----------------------------------------------------------------------------
650 wxStreamBase::wxStreamBase()
652 m_lasterror
= wxSTREAM_NO_ERROR
;
656 wxStreamBase::~wxStreamBase()
660 wxFileOffset
wxStreamBase::OnSysSeek(wxFileOffset
WXUNUSED(seek
), wxSeekMode
WXUNUSED(mode
))
662 return (wxFileOffset
) wxInvalidOffset
;
665 wxFileOffset
wxStreamBase::OnSysTell() const
667 return (wxFileOffset
) wxInvalidOffset
;
670 // ----------------------------------------------------------------------------
672 // ----------------------------------------------------------------------------
674 wxInputStream::wxInputStream()
681 wxInputStream::~wxInputStream()
686 bool wxInputStream::CanRead() const
688 // we don't know if there is anything to read or not and by default we
689 // prefer to be optimistic and try to read data unless we know for sure
690 // there is no more of it
691 return m_lasterror
!= wxSTREAM_EOF
;
694 bool wxInputStream::Eof() const
696 // the only way the base class can know we're at EOF is when we'd already
697 // tried to read beyond it in which case last error is set accordingly
698 return GetLastError() == wxSTREAM_EOF
;
701 char *wxInputStream::AllocSpaceWBack(size_t needed_size
)
703 // get number of bytes left from previous wback buffer
704 size_t toget
= m_wbacksize
- m_wbackcur
;
706 // allocate a buffer large enough to hold prev + new data
707 char *temp_b
= (char *)malloc(needed_size
+ toget
);
712 // copy previous data (and free old buffer) if needed
715 memmove(temp_b
+ needed_size
, m_wback
+ m_wbackcur
, toget
);
722 m_wbacksize
= needed_size
+ toget
;
727 size_t wxInputStream::GetWBack(void *buf
, size_t size
)
732 // how many bytes do we have in the buffer?
733 size_t toget
= m_wbacksize
- m_wbackcur
;
737 // we won't read everything
741 // copy the data from the cache
742 memcpy(buf
, m_wback
+ m_wbackcur
, toget
);
745 if ( m_wbackcur
== m_wbacksize
)
747 // TODO: should we really free it here all the time? maybe keep it?
754 // return the number of bytes copied
758 size_t wxInputStream::Ungetch(const void *buf
, size_t bufsize
)
760 if ( m_lasterror
!= wxSTREAM_NO_ERROR
&& m_lasterror
!= wxSTREAM_EOF
)
762 // can't operate on this stream until the error is cleared
766 char *ptrback
= AllocSpaceWBack(bufsize
);
770 // Eof() shouldn't return true any longer
771 if ( m_lasterror
== wxSTREAM_EOF
)
772 m_lasterror
= wxSTREAM_NO_ERROR
;
774 memcpy(ptrback
, buf
, bufsize
);
778 bool wxInputStream::Ungetch(char c
)
780 return Ungetch(&c
, sizeof(c
)) != 0;
783 char wxInputStream::GetC()
790 wxInputStream
& wxInputStream::Read(void *buf
, size_t size
)
792 char *p
= (char *)buf
;
795 size_t read
= GetWBack(buf
, size
);
804 // we read the requested amount of data
808 if ( p
!= buf
&& !CanRead() )
810 // we have already read something and we would block in OnSysRead()
811 // now: don't do it but return immediately
815 read
= OnSysRead(p
, size
);
818 // no more data available
826 char wxInputStream::Peek()
830 if (m_lasterror
== wxSTREAM_NO_ERROR
)
839 wxInputStream
& wxInputStream::Read(wxOutputStream
& stream_out
)
841 char buf
[BUF_TEMP_SIZE
];
845 size_t bytes_read
= Read(buf
, WXSIZEOF(buf
)).LastRead();
849 if ( stream_out
.Write(buf
, bytes_read
).LastWrite() != bytes_read
)
856 wxFileOffset
wxInputStream::SeekI(wxFileOffset pos
, wxSeekMode mode
)
858 // RR: This code is duplicated in wxBufferedInputStream. This is
859 // not really a good design, but buffered stream are different
860 // from all other in that they handle two stream-related objects,
861 // the stream buffer and parent stream.
863 // I don't know whether it should be put as well in wxFileInputStream::OnSysSeek
864 if (m_lasterror
==wxSTREAM_EOF
)
865 m_lasterror
=wxSTREAM_NO_ERROR
;
867 /* RR: A call to SeekI() will automatically invalidate any previous
868 call to Ungetch(), otherwise it would be possible to SeekI() to
869 one position, unread some bytes there, SeekI() to another position
870 and the data would be corrupted.
872 GRG: Could add code here to try to navigate within the wback
873 buffer if possible, but is it really needed? It would only work
874 when seeking in wxFromCurrent mode, else it would invalidate
879 wxLogDebug( wxT("Seeking in stream which has data written back to it.") );
887 return OnSysSeek(pos
, mode
);
890 wxFileOffset
wxInputStream::TellI() const
892 wxFileSize_t pos
= OnSysTell();
894 if (pos
!= wxInvalidOffset
)
895 pos
-= (m_wbacksize
- m_wbackcur
);
901 // ----------------------------------------------------------------------------
903 // ----------------------------------------------------------------------------
905 wxOutputStream::wxOutputStream()
909 wxOutputStream::~wxOutputStream()
913 size_t wxOutputStream::OnSysWrite(const void * WXUNUSED(buffer
),
914 size_t WXUNUSED(bufsize
))
919 void wxOutputStream::PutC(char c
)
921 Write(&c
, sizeof(c
));
924 wxOutputStream
& wxOutputStream::Write(const void *buffer
, size_t size
)
926 m_lastcount
= OnSysWrite(buffer
, size
);
930 wxOutputStream
& wxOutputStream::Write(wxInputStream
& stream_in
)
932 stream_in
.Read(*this);
936 wxFileOffset
wxOutputStream::TellO() const
941 wxFileOffset
wxOutputStream::SeekO(wxFileOffset pos
, wxSeekMode mode
)
943 return OnSysSeek(pos
, mode
);
946 void wxOutputStream::Sync()
951 // ----------------------------------------------------------------------------
952 // wxCountingOutputStream
953 // ----------------------------------------------------------------------------
955 wxCountingOutputStream::wxCountingOutputStream ()
960 size_t wxCountingOutputStream::GetSize() const
965 size_t wxCountingOutputStream::OnSysWrite(const void *WXUNUSED(buffer
),
968 m_currentPos
+= size
;
969 if (m_currentPos
> m_lastcount
)
970 m_lastcount
= m_currentPos
;
975 wxFileOffset
wxCountingOutputStream::OnSysSeek(wxFileOffset pos
, wxSeekMode mode
)
984 m_currentPos
= m_lastcount
+ pos
;
992 wxFAIL_MSG( _T("invalid seek mode") );
993 return (wxFileOffset
) wxInvalidOffset
;
996 if (m_currentPos
> m_lastcount
)
997 m_lastcount
= m_currentPos
;
1002 wxFileOffset
wxCountingOutputStream::OnSysTell() const
1004 return m_currentPos
;
1007 // ----------------------------------------------------------------------------
1008 // wxFilterInputStream
1009 // ----------------------------------------------------------------------------
1011 wxFilterInputStream::wxFilterInputStream()
1013 m_parent_i_stream
= NULL
;
1016 wxFilterInputStream::wxFilterInputStream(wxInputStream
& stream
)
1018 m_parent_i_stream
= &stream
;
1021 wxFilterInputStream::~wxFilterInputStream()
1025 // ----------------------------------------------------------------------------
1026 // wxFilterOutputStream
1027 // ----------------------------------------------------------------------------
1029 wxFilterOutputStream::wxFilterOutputStream()
1031 m_parent_o_stream
= NULL
;
1034 wxFilterOutputStream::wxFilterOutputStream(wxOutputStream
& stream
)
1036 m_parent_o_stream
= &stream
;
1039 wxFilterOutputStream::~wxFilterOutputStream()
1043 // ----------------------------------------------------------------------------
1044 // wxBufferedInputStream
1045 // ----------------------------------------------------------------------------
1047 wxBufferedInputStream::wxBufferedInputStream(wxInputStream
& s
,
1048 wxStreamBuffer
*buffer
)
1049 : wxFilterInputStream(s
)
1053 // use the buffer provided by the user
1054 m_i_streambuf
= buffer
;
1056 else // create a default buffer
1058 m_i_streambuf
= new wxStreamBuffer(*this, wxStreamBuffer::read
);
1060 m_i_streambuf
->SetBufferIO(1024);
1064 wxBufferedInputStream::~wxBufferedInputStream()
1066 m_parent_i_stream
->SeekI(-(wxFileOffset
)m_i_streambuf
->GetBytesLeft(),
1069 delete m_i_streambuf
;
1072 char wxBufferedInputStream::Peek()
1074 return m_i_streambuf
->Peek();
1077 wxInputStream
& wxBufferedInputStream::Read(void *buf
, size_t size
)
1079 // reset the error flag
1082 // first read from the already cached data
1083 m_lastcount
= GetWBack(buf
, size
);
1085 // do we have to read anything more?
1086 if ( m_lastcount
< size
)
1088 size
-= m_lastcount
;
1089 buf
= (char *)buf
+ m_lastcount
;
1091 // the call to wxStreamBuffer::Read() below will reset our m_lastcount,
1093 size_t countOld
= m_lastcount
;
1095 m_i_streambuf
->Read(buf
, size
);
1097 m_lastcount
+= countOld
;
1103 wxFileOffset
wxBufferedInputStream::SeekI(wxFileOffset pos
, wxSeekMode mode
)
1105 // RR: Look at wxInputStream for comments.
1107 if (m_lasterror
==wxSTREAM_EOF
)
1112 wxLogDebug( wxT("Seeking in stream which has data written back to it.") );
1120 return m_i_streambuf
->Seek(pos
, mode
);
1123 wxFileOffset
wxBufferedInputStream::TellI() const
1125 wxFileSize_t pos
= m_i_streambuf
->Tell();
1127 if (pos
!= wxInvalidOffset
)
1128 pos
-= (m_wbacksize
- m_wbackcur
);
1133 size_t wxBufferedInputStream::OnSysRead(void *buffer
, size_t bufsize
)
1135 return m_parent_i_stream
->Read(buffer
, bufsize
).LastRead();
1138 wxFileOffset
wxBufferedInputStream::OnSysSeek(wxFileOffset seek
, wxSeekMode mode
)
1140 return m_parent_i_stream
->SeekI(seek
, mode
);
1143 wxFileOffset
wxBufferedInputStream::OnSysTell() const
1145 return m_parent_i_stream
->TellI();
1148 void wxBufferedInputStream::SetInputStreamBuffer(wxStreamBuffer
*buffer
)
1150 wxCHECK_RET( buffer
, _T("wxBufferedInputStream needs buffer") );
1152 delete m_i_streambuf
;
1153 m_i_streambuf
= buffer
;
1156 // ----------------------------------------------------------------------------
1157 // wxBufferedOutputStream
1158 // ----------------------------------------------------------------------------
1160 wxBufferedOutputStream::wxBufferedOutputStream(wxOutputStream
& s
,
1161 wxStreamBuffer
*buffer
)
1162 : wxFilterOutputStream(s
)
1166 m_o_streambuf
= buffer
;
1168 else // create a default one
1170 m_o_streambuf
= new wxStreamBuffer(*this, wxStreamBuffer::write
);
1172 m_o_streambuf
->SetBufferIO(1024);
1176 wxBufferedOutputStream::~wxBufferedOutputStream()
1179 delete m_o_streambuf
;
1182 wxOutputStream
& wxBufferedOutputStream::Write(const void *buffer
, size_t size
)
1185 m_o_streambuf
->Write(buffer
, size
);
1189 wxFileOffset
wxBufferedOutputStream::SeekO(wxFileOffset pos
, wxSeekMode mode
)
1192 return m_o_streambuf
->Seek(pos
, mode
);
1195 wxFileOffset
wxBufferedOutputStream::TellO() const
1197 return m_o_streambuf
->Tell();
1200 void wxBufferedOutputStream::Sync()
1202 m_o_streambuf
->FlushBuffer();
1203 m_parent_o_stream
->Sync();
1206 size_t wxBufferedOutputStream::OnSysWrite(const void *buffer
, size_t bufsize
)
1208 return m_parent_o_stream
->Write(buffer
, bufsize
).LastWrite();
1211 wxFileOffset
wxBufferedOutputStream::OnSysSeek(wxFileOffset seek
, wxSeekMode mode
)
1213 return m_parent_o_stream
->SeekO(seek
, mode
);
1216 wxFileOffset
wxBufferedOutputStream::OnSysTell() const
1218 return m_parent_o_stream
->TellO();
1221 size_t wxBufferedOutputStream::GetSize() const
1223 return m_parent_o_stream
->GetSize() + m_o_streambuf
->GetIntPosition();
1226 void wxBufferedOutputStream::SetOutputStreamBuffer(wxStreamBuffer
*buffer
)
1228 wxCHECK_RET( buffer
, _T("wxBufferedOutputStream needs buffer") );
1230 delete m_o_streambuf
;
1231 m_o_streambuf
= buffer
;
1234 // ----------------------------------------------------------------------------
1235 // Some IOManip function
1236 // ----------------------------------------------------------------------------
1238 wxOutputStream
& wxEndL(wxOutputStream
& stream
)
1240 static const wxChar
*eol
= wxTextFile::GetEOL();
1242 return stream
.Write(eol
, wxStrlen(eol
));