]> git.saurik.com Git - wxWidgets.git/blob - src/common/stream.cpp
Always send an erase event to satisfy some users...
[wxWidgets.git] / 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,
6 // general code review
7 // Created: 11/07/98
8 // RCS-ID: $Id$
9 // Copyright: (c) Guilhem Lavaux
10 // Licence: wxWindows license
11 /////////////////////////////////////////////////////////////////////////////
12
13 // ============================================================================
14 // declarations
15 // ============================================================================
16
17 // ----------------------------------------------------------------------------
18 // headers
19 // ----------------------------------------------------------------------------
20
21 #ifdef __GNUG__
22 #pragma implementation "stream.h"
23 #endif
24
25 // For compilers that support precompilation, includes "wx.h".
26 #include "wx/wxprec.h"
27
28 #ifdef __BORLANDC__
29 #pragma hdrstop
30 #endif
31
32 #ifndef WX_PRECOMP
33 #include "wx/defs.h"
34 #endif
35
36 #if wxUSE_STREAMS
37
38 #include <ctype.h>
39 #include "wx/stream.h"
40 #include "wx/datstrm.h"
41 #include "wx/textfile.h"
42
43 // ----------------------------------------------------------------------------
44 // constants
45 // ----------------------------------------------------------------------------
46
47 // the temporary buffer size used when copying from stream to stream
48 #define BUF_TEMP_SIZE 10000
49
50 // ============================================================================
51 // implementation
52 // ============================================================================
53
54 // ----------------------------------------------------------------------------
55 // wxStreamBuffer
56 // ----------------------------------------------------------------------------
57
58 void wxStreamBuffer::SetError(wxStreamError err)
59 {
60 if ( m_stream->m_lasterror == wxStream_NOERROR )
61 m_stream->m_lasterror = err;
62 }
63
64 void wxStreamBuffer::InitBuffer()
65 {
66 m_buffer_start =
67 m_buffer_end =
68 m_buffer_pos = NULL;
69 m_buffer_size = 0;
70
71 // if we are going to allocate the buffer, we should free it later as well
72 m_destroybuf = TRUE;
73 }
74
75 void wxStreamBuffer::Init()
76 {
77 InitBuffer();
78
79 m_fixed = TRUE;
80 }
81
82 wxStreamBuffer::wxStreamBuffer(wxStreamBase& stream, BufMode mode)
83 {
84 Init();
85
86 m_stream = &stream;
87 m_mode = mode;
88
89 m_flushable = TRUE;
90 m_destroystream = FALSE;
91 }
92
93 wxStreamBuffer::wxStreamBuffer(BufMode mode)
94 {
95 Init();
96
97 wxASSERT_MSG(mode != read_write, wxT("you have to use the other ctor for read_write mode") );
98 if ( mode == read )
99 m_stream = new wxInputStream;
100 else if ( mode == write)
101 m_stream = new wxOutputStream;
102 else
103 m_stream = NULL;
104
105 m_mode = mode;
106
107 m_flushable = FALSE;
108 m_destroystream = TRUE;
109 }
110
111 wxStreamBuffer::wxStreamBuffer(const wxStreamBuffer& buffer)
112 {
113 // doing this has big chances to lead to a crashwhen the source buffer is
114 // destroyed (otherwise assume the caller knows what he does)
115 wxASSERT_MSG( !buffer.m_destroybuf && !buffer.m_destroystream,
116 _T("it's a bad idea to copy this buffer") );
117
118 m_buffer_start = buffer.m_buffer_start;
119 m_buffer_end = buffer.m_buffer_end;
120 m_buffer_pos = buffer.m_buffer_pos;
121 m_buffer_size = buffer.m_buffer_size;
122 m_fixed = buffer.m_fixed;
123 m_flushable = buffer.m_flushable;
124 m_stream = buffer.m_stream;
125 m_mode = buffer.m_mode;
126 m_destroybuf = FALSE;
127 m_destroystream = FALSE;
128 }
129
130 void wxStreamBuffer::FreeBuffer()
131 {
132 if ( m_destroybuf )
133 free(m_buffer_start);
134 }
135
136 wxStreamBuffer::~wxStreamBuffer()
137 {
138 FreeBuffer();
139
140 if ( m_destroystream )
141 delete m_stream;
142 }
143
144 wxInputStream *wxStreamBuffer::GetInputStream() const
145 {
146 return m_mode == write ? NULL : (wxInputStream *)m_stream;
147 }
148
149 wxOutputStream *wxStreamBuffer::GetOutputStream() const
150 {
151 return m_mode == read ? NULL : (wxOutputStream *)m_stream;
152 }
153
154 void wxStreamBuffer::SetBufferIO(void *buffer_start,
155 void *buffer_end,
156 bool takeOwnership)
157 {
158 SetBufferIO(buffer_start, (char *)buffer_end - (char *)buffer_start,
159 takeOwnership);
160 }
161
162 void wxStreamBuffer::SetBufferIO(void *start,
163 size_t len,
164 bool takeOwnership)
165 {
166 // start by freeing the old buffer
167 FreeBuffer();
168
169 m_buffer_start = (char *)start;
170 m_buffer_end = m_buffer_start + len;
171
172 m_buffer_size = len;
173
174 // if we own it, we free it
175 m_destroybuf = takeOwnership;
176
177 ResetBuffer();
178 }
179
180 void wxStreamBuffer::SetBufferIO(size_t bufsize)
181 {
182 // start by freeing the old buffer
183 FreeBuffer();
184
185 if ( bufsize )
186 {
187 SetBufferIO(malloc(bufsize), bufsize, TRUE /* take ownership */);
188 }
189 else // no buffer size => no buffer
190 {
191 InitBuffer();
192 }
193 }
194
195 void wxStreamBuffer::ResetBuffer()
196 {
197 wxCHECK_RET( m_stream, _T("should have a stream in wxStreamBuffer") );
198
199 m_stream->m_lasterror = wxStream_NOERROR;
200 m_stream->m_lastcount = 0;
201 if (m_mode == read && m_flushable)
202 m_buffer_pos = m_buffer_end;
203 else
204 m_buffer_pos = m_buffer_start;
205 }
206
207 // fill the buffer with as much data as possible (only for read buffers)
208 bool wxStreamBuffer::FillBuffer()
209 {
210 wxInputStream *inStream = GetInputStream();
211
212 wxCHECK_MSG( inStream, FALSE, _T("should have a stream in wxStreamBuffer") );
213
214 size_t count = inStream->OnSysRead(m_buffer_start, m_buffer_size);
215 if ( !count )
216 return FALSE;
217
218 m_buffer_end = m_buffer_start + count;
219 m_buffer_pos = m_buffer_start;
220
221 return TRUE;
222 }
223
224 // write the buffer contents to the stream (only for write buffers)
225 bool wxStreamBuffer::FlushBuffer()
226 {
227 wxCHECK_MSG( m_flushable, FALSE, _T("can't flush this buffer") );
228
229 // FIXME: what is this check for? (VZ)
230 if ( m_buffer_pos == m_buffer_start )
231 return FALSE;
232
233 wxOutputStream *outStream = GetOutputStream();
234
235 wxCHECK_MSG( outStream, FALSE, _T("should have a stream in wxStreamBuffer") );
236
237 size_t current = m_buffer_pos - m_buffer_start;
238 size_t count = outStream->OnSysWrite(m_buffer_start, current);
239 if ( count != current )
240 return FALSE;
241
242 m_buffer_pos = m_buffer_start;
243
244 return TRUE;
245 }
246
247 size_t wxStreamBuffer::GetDataLeft()
248 {
249 /* Why is this done? RR. */
250 if ( m_buffer_pos == m_buffer_end && m_flushable)
251 FillBuffer();
252
253 return GetBytesLeft();
254 }
255
256 // copy up to size bytes from our buffer into the provided one
257 void wxStreamBuffer::GetFromBuffer(void *buffer, size_t size)
258 {
259 // don't get more bytes than left in the buffer
260 size_t left = GetBytesLeft();
261
262 if ( size > left )
263 size = left;
264
265 memcpy(buffer, m_buffer_pos, size);
266 m_buffer_pos += size;
267 }
268
269 // copy the contents of the provided buffer into this one
270 void wxStreamBuffer::PutToBuffer(const void *buffer, size_t size)
271 {
272 size_t left = GetBytesLeft();
273 if ( size > left )
274 {
275 if ( m_fixed )
276 {
277 // we can't realloc the buffer, so just copy what we can
278 size = left;
279 }
280 else // !m_fixed
281 {
282 // realloc the buffer to have enough space for the data
283 size_t delta = m_buffer_pos - m_buffer_start;
284
285 char *startOld = m_buffer_start;
286 m_buffer_size += size;
287 m_buffer_start = (char *)realloc(m_buffer_start, m_buffer_size);
288 if ( !m_buffer_start )
289 {
290 // don't leak memory if realloc() failed
291 m_buffer_start = startOld;
292 m_buffer_size -= size;
293
294 // what else can we do?
295 return;
296 }
297
298 // adjust the pointers invalidated by realloc()
299 m_buffer_pos = m_buffer_start + delta;
300 m_buffer_end = m_buffer_start + m_buffer_size;
301 }
302 }
303
304 memcpy(m_buffer_pos, buffer, size);
305 m_buffer_pos += size;
306 }
307
308 void wxStreamBuffer::PutChar(char c)
309 {
310 wxOutputStream *outStream = GetOutputStream();
311
312 wxCHECK_RET( outStream, _T("should have a stream in wxStreamBuffer") );
313
314 // if we don't have buffer at all, just forward this call to the stream,
315 if ( !HasBuffer() )
316 {
317 outStream->OnSysWrite(&c, 1);
318 }
319 else
320 {
321 // otherwise check we have enough space left
322 if ( !GetDataLeft() && !FlushBuffer() )
323 {
324 // we don't
325 SetError(wxStream_WRITE_ERR);
326 }
327 else
328 {
329 PutToBuffer(&c, 1);
330 m_stream->m_lastcount = 1;
331 }
332 }
333 }
334
335 char wxStreamBuffer::Peek()
336 {
337 wxCHECK_MSG( m_stream && HasBuffer(), 0,
338 _T("should have the stream and the buffer in wxStreamBuffer") );
339
340 if ( !GetDataLeft() )
341 {
342 SetError(wxStream_READ_ERR);
343 return 0;
344 }
345
346 char c;
347 GetFromBuffer(&c, 1);
348 m_buffer_pos--;
349
350 return c;
351 }
352
353 char wxStreamBuffer::GetChar()
354 {
355 wxInputStream *inStream = GetInputStream();
356
357 wxCHECK_MSG( inStream, 0, _T("should have a stream in wxStreamBuffer") );
358
359 char c;
360 if ( !HasBuffer() )
361 {
362 inStream->OnSysRead(&c, 1);
363 }
364 else
365 {
366 if ( !GetDataLeft() )
367 {
368 SetError(wxStream_READ_ERR);
369 c = 0;
370 }
371 else
372 {
373 GetFromBuffer(&c, 1);
374 m_stream->m_lastcount = 1;
375 }
376 }
377
378 return c;
379 }
380
381 size_t wxStreamBuffer::Read(void *buffer, size_t size)
382 {
383 wxInputStream *inStream = GetInputStream();
384
385 wxCHECK_MSG( inStream, 0, _T("should have a stream in wxStreamBuffer") );
386
387 // lasterror is reset before all new IO calls
388 m_stream->m_lasterror = wxStream_NOERROR;
389
390 if ( !HasBuffer() )
391 {
392 m_stream->m_lastcount = inStream->OnSysRead(buffer, size);
393 }
394 else // we have a buffer, use it
395 {
396 size_t orig_size = size;
397
398 while ( size > 0 )
399 {
400 size_t left = GetDataLeft();
401
402 // if the requested number of bytes if greater than the buffer
403 // size, read data in chunks
404 if ( size > left )
405 {
406 GetFromBuffer(buffer, left);
407 size -= left;
408 buffer = (char *)buffer + left;
409
410 if ( !FillBuffer() )
411 {
412 SetError(wxStream_EOF);
413 break;
414 }
415 }
416 else // otherwise just do it in one gulp
417 {
418 GetFromBuffer(buffer, size);
419 size = 0;
420 }
421 }
422
423 m_stream->m_lastcount = orig_size - size;
424 }
425
426 return m_stream->m_lastcount;
427 }
428
429 // this should really be called "Copy()"
430 size_t wxStreamBuffer::Read(wxStreamBuffer *dbuf)
431 {
432 wxCHECK_MSG( m_mode != write, 0, _T("can't read from this buffer") );
433
434 char buf[BUF_TEMP_SIZE];
435 size_t nRead,
436 total = 0;
437
438 do
439 {
440 nRead = Read(dbuf, WXSIZEOF(buf));
441 if ( nRead )
442 {
443 nRead = dbuf->Write(buf, nRead);
444 total += nRead;
445 }
446 }
447 while ( nRead );
448
449 return total;
450 }
451
452 size_t wxStreamBuffer::Write(const void *buffer, size_t size)
453 {
454 wxOutputStream *outStream = GetOutputStream();
455
456 wxCHECK_MSG( outStream, 0, _T("should have a stream in wxStreamBuffer") );
457
458 // lasterror is reset before all new IO calls
459 m_stream->m_lasterror = wxStream_NOERROR;
460
461 if ( !HasBuffer() && m_fixed )
462 {
463 // no buffer, just forward the call to the stream
464 m_stream->m_lastcount = outStream->OnSysWrite(buffer, size);
465 }
466 else // we [may] have a buffer, use it
467 {
468 size_t orig_size = size;
469
470 while ( size > 0 )
471 {
472 size_t left = GetBytesLeft();
473
474 // if the buffer is too large to fit in the stream buffer, split
475 // it in smaller parts
476 //
477 // NB: If stream buffer isn't fixed (as for wxMemoryOutputStream),
478 // we always go to the second case.
479 //
480 // FIXME: fine, but if it fails we should (re)try writing it by
481 // chunks as this will (hopefully) always work (VZ)
482 if ( size > left && m_fixed )
483 {
484 PutToBuffer(buffer, left);
485 size -= left;
486 buffer = (char *)buffer + left;
487
488 if ( !FlushBuffer() )
489 {
490 SetError(wxStream_WRITE_ERR);
491
492 break;
493 }
494
495 m_buffer_pos = m_buffer_start;
496 }
497 else // we can do it in one gulp
498 {
499 PutToBuffer(buffer, size);
500 size = 0;
501 }
502 }
503
504 m_stream->m_lastcount = orig_size - size;
505 }
506
507 return m_stream->m_lastcount;
508 }
509
510 size_t wxStreamBuffer::Write(wxStreamBuffer *sbuf)
511 {
512 wxCHECK_MSG( m_mode != read, 0, _T("can't write to this buffer") );
513 wxCHECK_MSG( sbuf->m_mode != write, 0, _T("can't read from that buffer") );
514
515 char buf[BUF_TEMP_SIZE];
516 size_t nWrite,
517 total = 0;
518
519 do
520 {
521 size_t nRead = sbuf->Read(buf, WXSIZEOF(buf));
522 if ( nRead )
523 {
524 nWrite = Write(buf, nRead);
525 if ( nWrite < nRead )
526 {
527 // put back data we couldn't copy
528 wxInputStream *in_stream = (wxInputStream *)sbuf->GetStream();
529
530 in_stream->Ungetch(buf + nWrite, nRead - nWrite);
531 }
532
533 total += nWrite;
534 }
535 else
536 {
537 nWrite = 0;
538 }
539 }
540 while ( nWrite == WXSIZEOF(buf) );
541
542 return total;
543 }
544
545 off_t wxStreamBuffer::Seek(off_t pos, wxSeekMode mode)
546 {
547 off_t ret_off, diff;
548
549 off_t last_access = GetLastAccess();
550
551 if ( !m_flushable )
552 {
553 switch (mode)
554 {
555 case wxFromStart:
556 diff = pos;
557 break;
558
559 case wxFromCurrent:
560 diff = pos + GetIntPosition();
561 break;
562
563 case wxFromEnd:
564 diff = pos + last_access;
565 break;
566
567 default:
568 wxFAIL_MSG( _T("invalid seek mode") );
569
570 return wxInvalidOffset;
571 }
572 if (diff < 0 || diff > last_access)
573 return wxInvalidOffset;
574 SetIntPosition(diff);
575 return diff;
576 }
577
578 switch ( mode )
579 {
580 case wxFromStart:
581 // We'll try to compute an internal position later ...
582 ret_off = m_stream->OnSysSeek(pos, wxFromStart);
583 ResetBuffer();
584 return ret_off;
585
586 case wxFromCurrent:
587 diff = pos + GetIntPosition();
588
589 if ( (diff > last_access) || (diff < 0) )
590 {
591 // We must take into account the fact that we have read
592 // something previously.
593 ret_off = m_stream->OnSysSeek(diff-last_access, wxFromCurrent);
594 ResetBuffer();
595 return ret_off;
596 }
597 else
598 {
599 SetIntPosition(diff);
600 return pos;
601 }
602
603 case wxFromEnd:
604 // Hard to compute: always seek to the requested position.
605 ret_off = m_stream->OnSysSeek(pos, wxFromEnd);
606 ResetBuffer();
607 return ret_off;
608 }
609
610 return wxInvalidOffset;
611 }
612
613 off_t wxStreamBuffer::Tell() const
614 {
615 off_t pos = m_stream->OnSysTell();
616 if ( pos == wxInvalidOffset )
617 return wxInvalidOffset;
618
619 pos += GetIntPosition();
620
621 if ( m_mode == read && m_flushable )
622 pos -= GetLastAccess();
623
624 return pos;
625 }
626
627 // ----------------------------------------------------------------------------
628 // wxStreamBase
629 // ----------------------------------------------------------------------------
630
631 wxStreamBase::wxStreamBase()
632 {
633 m_lasterror = wxStream_NOERROR;
634 m_lastcount = 0;
635 }
636
637 wxStreamBase::~wxStreamBase()
638 {
639 }
640
641 off_t wxStreamBase::OnSysSeek(off_t WXUNUSED(seek), wxSeekMode WXUNUSED(mode))
642 {
643 return wxInvalidOffset;
644 }
645
646 off_t wxStreamBase::OnSysTell() const
647 {
648 return wxInvalidOffset;
649 }
650
651 // ----------------------------------------------------------------------------
652 // wxInputStream
653 // ----------------------------------------------------------------------------
654
655 wxInputStream::wxInputStream()
656 {
657 m_wback = NULL;
658 m_wbacksize =
659 m_wbackcur = 0;
660 }
661
662 wxInputStream::~wxInputStream()
663 {
664 free(m_wback);
665 }
666
667 size_t wxInputStream::OnSysRead(void * WXUNUSED(buffer),
668 size_t WXUNUSED(bufsize))
669 {
670 return 0;
671 }
672
673 bool wxInputStream::Eof() const
674 {
675 wxInputStream *self = wxConstCast(this, wxInputStream);
676
677 char c;
678 self->Read(&c, 1);
679
680 // some streams can know that they're at EOF before actually trying to
681 // read beyond the end of stream (e.g. files) while others have no way of
682 // knowing it, so to provide the same behaviour in all cases we only
683 // return TRUE from here if the character really couldn't be read
684 if ( !self->LastRead() && GetLastError() == wxSTREAM_EOF )
685 {
686 return TRUE;
687 }
688
689 self->Ungetch(c);
690
691 return FALSE;
692 }
693
694 char *wxInputStream::AllocSpaceWBack(size_t needed_size)
695 {
696 // get number of bytes left from previous wback buffer
697 size_t toget = m_wbacksize - m_wbackcur;
698
699 // allocate a buffer large enough to hold prev + new data
700 char *temp_b = (char *)malloc(needed_size + toget);
701
702 if (!temp_b)
703 return NULL;
704
705 /* copy previous data (and free old buffer) if needed */
706 if (m_wback)
707 {
708 memmove(temp_b + needed_size, m_wback + m_wbackcur, toget);
709 free(m_wback);
710 }
711
712 /* done */
713 m_wback = temp_b;
714 m_wbackcur = 0;
715 m_wbacksize = needed_size + toget;
716
717 return m_wback;
718 }
719
720 size_t wxInputStream::GetWBack(void *buf, size_t bsize)
721 {
722 if (!m_wback)
723 return 0;
724
725 // how many bytes do we have in the buffer?
726 size_t toget = m_wbacksize - m_wbackcur;
727
728 if ( bsize < toget )
729 {
730 // we won't read everything
731 toget = bsize;
732 }
733
734 // copy the data from the cache
735 memcpy(buf, m_wback + m_wbackcur, toget);
736
737 m_wbackcur += toget;
738 if ( m_wbackcur == m_wbacksize )
739 {
740 // TODO: should we really free it here all the time? maybe keep it?
741 free(m_wback);
742 m_wback = NULL;
743 m_wbacksize = 0;
744 m_wbackcur = 0;
745 }
746
747 // return the number of bytes copied
748 return toget;
749 }
750
751 size_t wxInputStream::Ungetch(const void *buf, size_t bufsize)
752 {
753 char *ptrback = AllocSpaceWBack(bufsize);
754 if (!ptrback)
755 return 0;
756
757 memcpy(ptrback, buf, bufsize);
758 return bufsize;
759 }
760
761 bool wxInputStream::Ungetch(char c)
762 {
763 void *ptrback = AllocSpaceWBack(1);
764 if (!ptrback)
765 return FALSE;
766
767 *(char *)ptrback = c;
768 return TRUE;
769 }
770
771 char wxInputStream::GetC()
772 {
773 char c;
774 Read(&c, 1);
775 return c;
776 }
777
778 wxInputStream& wxInputStream::Read(void *buf, size_t size)
779 {
780 size_t retsize = GetWBack(buf, size);
781 if (retsize == size)
782 {
783 m_lastcount = size;
784 m_lasterror = wxStream_NOERROR;
785 return *this;
786 }
787 size -= retsize;
788 buf = (char *)buf + retsize;
789
790 m_lastcount = OnSysRead(buf, size) + retsize;
791 return *this;
792 }
793
794 char wxInputStream::Peek()
795 {
796 char c;
797 Read(&c, 1);
798 if (m_lasterror == wxStream_NOERROR)
799 {
800 Ungetch(c);
801 return c;
802 }
803
804 return 0;
805 }
806
807 wxInputStream& wxInputStream::Read(wxOutputStream& stream_out)
808 {
809 char buf[BUF_TEMP_SIZE];
810 size_t bytes_read = BUF_TEMP_SIZE;
811
812 while (bytes_read == BUF_TEMP_SIZE)
813 {
814 bytes_read = Read(buf, bytes_read).LastRead();
815 bytes_read = stream_out.Write(buf, bytes_read).LastWrite();
816 }
817 return *this;
818 }
819
820 off_t wxInputStream::SeekI(off_t pos, wxSeekMode mode)
821 {
822 /* Should be check and improve, just to remove a slight bug !
823 I don't know whether it should be put as well in wxFileInputStream::OnSysSeek ? */
824 if (m_lasterror==wxSTREAM_EOF)
825 m_lasterror=wxSTREAM_NOERROR;
826
827 /* A call to SeekI() will automatically invalidate any previous call
828 to Ungetch(), otherwise it would be possible to SeekI() to one
829 one position, unread some bytes there, SeekI() to another position
830 and the data would be corrupted.
831
832 GRG: Could add code here to try to navigate within the wback
833 buffer if possible, but is it really needed? It would only work
834 when seeking in wxFromCurrent mode, else it would invalidate
835 anyway...
836 */
837 if (m_wback)
838 {
839 free(m_wback);
840 m_wback = NULL;
841 m_wbacksize = 0;
842 m_wbackcur = 0;
843 }
844
845 return OnSysSeek(pos, mode);
846 }
847
848 off_t wxInputStream::TellI() const
849 {
850 /* GRG: Changed to make it compatible with the wback buffer */
851 off_t pos = OnSysTell();
852
853 if (pos != wxInvalidOffset)
854 pos -= (m_wbacksize - m_wbackcur);
855
856 return pos;
857 }
858
859
860 // ----------------------------------------------------------------------------
861 // wxOutputStream
862 // ----------------------------------------------------------------------------
863
864 wxOutputStream::wxOutputStream()
865 {
866 }
867
868 wxOutputStream::~wxOutputStream()
869 {
870 }
871
872 size_t wxOutputStream::OnSysWrite(const void * WXUNUSED(buffer),
873 size_t WXUNUSED(bufsize))
874 {
875 return 0;
876 }
877
878 void wxOutputStream::PutC(char c)
879 {
880 Write(&c, 1);
881 }
882
883 wxOutputStream& wxOutputStream::Write(const void *buffer, size_t size)
884 {
885 m_lastcount = OnSysWrite(buffer, size);
886 return *this;
887 }
888
889 wxOutputStream& wxOutputStream::Write(wxInputStream& stream_in)
890 {
891 stream_in.Read(*this);
892 return *this;
893 }
894
895 off_t wxOutputStream::TellO() const
896 {
897 return OnSysTell();
898 }
899
900 off_t wxOutputStream::SeekO(off_t pos, wxSeekMode mode)
901 {
902 return OnSysSeek(pos, mode);
903 }
904
905 void wxOutputStream::Sync()
906 {
907 }
908
909
910 // ----------------------------------------------------------------------------
911 // wxCountingOutputStream
912 // ----------------------------------------------------------------------------
913
914 wxCountingOutputStream::wxCountingOutputStream ()
915 {
916 m_currentPos = 0;
917 }
918
919 size_t wxCountingOutputStream::GetSize() const
920 {
921 return m_lastcount;
922 }
923
924 size_t wxCountingOutputStream::OnSysWrite(const void *WXUNUSED(buffer),
925 size_t size)
926 {
927 m_currentPos += size;
928 if (m_currentPos > m_lastcount)
929 m_lastcount = m_currentPos;
930
931 return m_currentPos;
932 }
933
934 off_t wxCountingOutputStream::OnSysSeek(off_t pos, wxSeekMode mode)
935 {
936 switch ( mode )
937 {
938 case wxFromStart:
939 m_currentPos = pos;
940 break;
941
942 case wxFromEnd:
943 m_currentPos = m_lastcount + pos;
944 break;
945
946 case wxFromCurrent:
947 m_currentPos += pos;
948 break;
949
950 default:
951 wxFAIL_MSG( _T("invalid seek mode") );
952 return wxInvalidOffset;
953 }
954
955 if (m_currentPos > m_lastcount)
956 m_lastcount = m_currentPos;
957
958 return m_currentPos;
959 }
960
961 off_t wxCountingOutputStream::OnSysTell() const
962 {
963 return m_currentPos;
964 }
965
966 // ----------------------------------------------------------------------------
967 // wxFilterInputStream
968 // ----------------------------------------------------------------------------
969
970 wxFilterInputStream::wxFilterInputStream()
971 {
972 m_parent_i_stream = NULL;
973 }
974
975 wxFilterInputStream::wxFilterInputStream(wxInputStream& stream)
976 {
977 m_parent_i_stream = &stream;
978 }
979
980 wxFilterInputStream::~wxFilterInputStream()
981 {
982 }
983
984 // ----------------------------------------------------------------------------
985 // wxFilterOutputStream
986 // ----------------------------------------------------------------------------
987
988 wxFilterOutputStream::wxFilterOutputStream()
989 {
990 m_parent_o_stream = NULL;
991 }
992
993 wxFilterOutputStream::wxFilterOutputStream(wxOutputStream& stream)
994 {
995 m_parent_o_stream = &stream;
996 }
997
998 wxFilterOutputStream::~wxFilterOutputStream()
999 {
1000 }
1001
1002 // ----------------------------------------------------------------------------
1003 // wxBufferedInputStream
1004 // ----------------------------------------------------------------------------
1005
1006 wxBufferedInputStream::wxBufferedInputStream(wxInputStream& s,
1007 wxStreamBuffer *buffer)
1008 : wxFilterInputStream(s)
1009 {
1010 if ( buffer )
1011 {
1012 // use the buffer provided by the user
1013 m_i_streambuf = buffer;
1014 }
1015 else // create a default buffer
1016 {
1017 m_i_streambuf = new wxStreamBuffer(*this, wxStreamBuffer::read);
1018
1019 m_i_streambuf->SetBufferIO(1024);
1020 }
1021 }
1022
1023 wxBufferedInputStream::~wxBufferedInputStream()
1024 {
1025 m_parent_i_stream->SeekI(-(off_t)m_i_streambuf->GetBytesLeft(),
1026 wxFromCurrent);
1027
1028 delete m_i_streambuf;
1029 }
1030
1031 char wxBufferedInputStream::Peek()
1032 {
1033 return m_i_streambuf->Peek();
1034 }
1035
1036 wxInputStream& wxBufferedInputStream::Read(void *buf, size_t size)
1037 {
1038 // reset the error flag
1039 m_lasterror = wxStream_NOERROR;
1040
1041 // first read from the already cached data
1042 m_lastcount = GetWBack(buf, size);
1043
1044 // do we have to read anything more?
1045 if ( m_lastcount < size )
1046 {
1047 size -= m_lastcount;
1048 buf = (char *)buf + m_lastcount;
1049
1050 // the call to wxStreamBuffer::Read() below will reset our m_lastcount,
1051 // so save it
1052 size_t countOld = m_lastcount;
1053
1054 m_i_streambuf->Read(buf, size);
1055
1056 m_lastcount += countOld;
1057 }
1058
1059 return *this;
1060 }
1061
1062 off_t wxBufferedInputStream::SeekI(off_t pos, wxSeekMode mode)
1063 {
1064 return m_i_streambuf->Seek(pos, mode);
1065 }
1066
1067 off_t wxBufferedInputStream::TellI() const
1068 {
1069 return m_i_streambuf->Tell();
1070 }
1071
1072 size_t wxBufferedInputStream::OnSysRead(void *buffer, size_t bufsize)
1073 {
1074 return m_parent_i_stream->Read(buffer, bufsize).LastRead();
1075 }
1076
1077 off_t wxBufferedInputStream::OnSysSeek(off_t seek, wxSeekMode mode)
1078 {
1079 return m_parent_i_stream->SeekI(seek, mode);
1080 }
1081
1082 off_t wxBufferedInputStream::OnSysTell() const
1083 {
1084 return m_parent_i_stream->TellI();
1085 }
1086
1087 void wxBufferedInputStream::SetInputStreamBuffer(wxStreamBuffer *buffer)
1088 {
1089 wxCHECK_RET( buffer, _T("wxBufferedInputStream needs buffer") );
1090
1091 delete m_i_streambuf;
1092 m_i_streambuf = buffer;
1093 }
1094
1095 // ----------------------------------------------------------------------------
1096 // wxBufferedOutputStream
1097 // ----------------------------------------------------------------------------
1098
1099 wxBufferedOutputStream::wxBufferedOutputStream(wxOutputStream& s,
1100 wxStreamBuffer *buffer)
1101 : wxFilterOutputStream(s)
1102 {
1103 if ( buffer )
1104 {
1105 m_o_streambuf = buffer;
1106 }
1107 else // create a default one
1108 {
1109 m_o_streambuf = new wxStreamBuffer(*this, wxStreamBuffer::write);
1110
1111 m_o_streambuf->SetBufferIO(1024);
1112 }
1113 }
1114
1115 wxBufferedOutputStream::~wxBufferedOutputStream()
1116 {
1117 Sync();
1118 delete m_o_streambuf;
1119 }
1120
1121 wxOutputStream& wxBufferedOutputStream::Write(const void *buffer, size_t size)
1122 {
1123 m_lastcount = 0;
1124 m_o_streambuf->Write(buffer, size);
1125 return *this;
1126 }
1127
1128 off_t wxBufferedOutputStream::SeekO(off_t pos, wxSeekMode mode)
1129 {
1130 Sync();
1131 return m_o_streambuf->Seek(pos, mode);
1132 }
1133
1134 off_t wxBufferedOutputStream::TellO() const
1135 {
1136 return m_o_streambuf->Tell();
1137 }
1138
1139 void wxBufferedOutputStream::Sync()
1140 {
1141 m_o_streambuf->FlushBuffer();
1142 m_parent_o_stream->Sync();
1143 }
1144
1145 size_t wxBufferedOutputStream::OnSysWrite(const void *buffer, size_t bufsize)
1146 {
1147 return m_parent_o_stream->Write(buffer, bufsize).LastWrite();
1148 }
1149
1150 off_t wxBufferedOutputStream::OnSysSeek(off_t seek, wxSeekMode mode)
1151 {
1152 return m_parent_o_stream->SeekO(seek, mode);
1153 }
1154
1155 off_t wxBufferedOutputStream::OnSysTell() const
1156 {
1157 return m_parent_o_stream->TellO();
1158 }
1159
1160 size_t wxBufferedOutputStream::GetSize() const
1161 {
1162 return m_parent_o_stream->GetSize() + m_o_streambuf->GetIntPosition();
1163 }
1164
1165 void wxBufferedOutputStream::SetOutputStreamBuffer(wxStreamBuffer *buffer)
1166 {
1167 wxCHECK_RET( buffer, _T("wxBufferedOutputStream needs buffer") );
1168
1169 delete m_o_streambuf;
1170 m_o_streambuf = buffer;
1171 }
1172
1173 // ----------------------------------------------------------------------------
1174 // Some IOManip function
1175 // ----------------------------------------------------------------------------
1176
1177 wxOutputStream& wxEndL(wxOutputStream& stream)
1178 {
1179 static const wxChar *eol = wxTextFile::GetEOL();
1180
1181 return stream.Write(eol, wxStrlen(eol));
1182 }
1183
1184 #endif
1185 // wxUSE_STREAMS