]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/common/stream.cpp
Converted the virtual-methods-callbacks into real events, leaving the
[wxWidgets.git] / src / common / stream.cpp
... / ...
CommitLineData
1/////////////////////////////////////////////////////////////////////////////
2// Name: stream.cpp
3// Purpose: wxStream base classes
4// Author: Guilhem Lavaux
5// Modified by:
6// Created: 11/07/98
7// RCS-ID: $Id$
8// Copyright: (c) Guilhem Lavaux
9// Licence: wxWindows license
10/////////////////////////////////////////////////////////////////////////////
11
12#ifdef __GNUG__
13#pragma implementation "stream.h"
14#endif
15
16// For compilers that support precompilation, includes "wx.h".
17#include "wx/wxprec.h"
18#include <ctype.h>
19#include <wx/stream.h>
20#include <wx/datstrm.h>
21#include <wx/objstrm.h>
22
23#ifdef __BORLANDC__
24#pragma hdrstop
25#endif
26
27#define BUF_TEMP_SIZE 10000
28
29// ----------------------------------------------------------------------------
30// wxStreamBuffer
31// ----------------------------------------------------------------------------
32
33wxStreamBuffer::wxStreamBuffer(wxStreamBase& stream, BufMode mode)
34 : m_buffer_start(NULL), m_buffer_end(NULL), m_buffer_pos(NULL),
35 m_buffer_size(0), m_fixed(TRUE), m_flushable(TRUE), m_stream(&stream),
36 m_mode(mode), m_destroybuf(FALSE), m_destroystream(FALSE)
37{
38}
39
40wxStreamBuffer::wxStreamBuffer(BufMode mode)
41 : m_buffer_start(NULL), m_buffer_end(NULL), m_buffer_pos(NULL),
42 m_buffer_size(0), m_fixed(TRUE), m_flushable(FALSE), m_stream(NULL),
43 m_mode(mode), m_destroybuf(FALSE), m_destroystream(TRUE)
44{
45 m_stream = new wxStreamBase();
46}
47
48wxStreamBuffer::wxStreamBuffer(const wxStreamBuffer& buffer)
49{
50 m_buffer_start = buffer.m_buffer_start;
51 m_buffer_end = buffer.m_buffer_end;
52 m_buffer_pos = buffer.m_buffer_pos;
53 m_buffer_size = buffer.m_buffer_size;
54 m_fixed = buffer.m_fixed;
55 m_flushable = buffer.m_flushable;
56 m_stream = buffer.m_stream;
57 m_mode = buffer.m_mode;
58 m_destroybuf = FALSE;
59 m_destroystream = FALSE;
60}
61
62wxStreamBuffer::~wxStreamBuffer()
63{
64 if (m_destroybuf)
65 wxDELETEA(m_buffer_start);
66 if (m_destroystream)
67 delete m_stream;
68}
69
70size_t wxStreamBuffer::WriteBack(const char *buf, size_t bufsize)
71{
72 char *ptrback;
73
74 ptrback = AllocSpaceWBack(bufsize);
75 if (!ptrback)
76 return 0;
77
78 memcpy(ptrback, buf, bufsize);
79 return bufsize;
80}
81
82bool wxStreamBuffer::WriteBack(char c)
83{
84 char *ptrback;
85
86 ptrback = AllocSpaceWBack(1);
87 if (!ptrback)
88 return FALSE;
89
90 *ptrback = c;
91 return TRUE;
92}
93
94void wxStreamBuffer::SetBufferIO(char *buffer_start, char *buffer_end)
95{
96 if (m_destroybuf)
97 wxDELETEA(m_buffer_start);
98 m_buffer_start = buffer_start;
99 m_buffer_end = buffer_end;
100
101 m_buffer_size = m_buffer_end-m_buffer_start;
102 m_destroybuf = FALSE;
103 ResetBuffer();
104}
105
106void wxStreamBuffer::SetBufferIO(size_t bufsize)
107{
108 char *b_start;
109
110 wxDELETE(m_buffer_start);
111
112 if (!bufsize) {
113 m_buffer_start = NULL;
114 m_buffer_end = NULL;
115 m_buffer_pos = NULL;
116 m_buffer_size = 0;
117 return;
118 }
119
120 b_start = new char[bufsize];
121 SetBufferIO(b_start, b_start + bufsize);
122 m_destroybuf = TRUE;
123}
124
125void wxStreamBuffer::ResetBuffer()
126{
127 if (m_mode == read)
128 m_buffer_pos = m_buffer_end;
129 else
130 m_buffer_pos = m_buffer_start;
131}
132
133char *wxStreamBuffer::AllocSpaceWBack(size_t needed_size)
134{
135 char *temp_b;
136
137 m_wbacksize += needed_size;
138
139 if (!m_wback)
140 temp_b = (char *)malloc(m_wbacksize);
141 else
142 temp_b = (char *)realloc(m_wback, m_wbacksize);
143
144 if (!temp_b)
145 return NULL;
146 return (char *)((size_t)m_wback+(m_wbacksize-needed_size));
147}
148
149size_t wxStreamBuffer::GetWBack(char *buf, size_t bsize)
150{
151 size_t s_toget = m_wbacksize-m_wbackcur;
152
153 if (bsize < s_toget)
154 s_toget = bsize;
155
156 memcpy(buf, (m_wback+m_wbackcur), s_toget);
157
158 m_wbackcur += s_toget;
159 if (m_wbackcur == m_wbacksize) {
160 free(m_wback);
161 m_wback = (char *)NULL;
162 m_wbacksize = 0;
163 m_wbackcur = 0;
164 }
165
166 return s_toget;
167}
168
169bool wxStreamBuffer::FillBuffer()
170{
171 size_t count;
172
173 count = m_stream->OnSysRead(m_buffer_start, m_buffer_size);
174 m_buffer_end = m_buffer_start+count;
175 m_buffer_pos = m_buffer_start;
176
177 if (count == 0)
178 return FALSE;
179 return TRUE;
180}
181
182bool wxStreamBuffer::FlushBuffer()
183{
184 size_t count, current;
185
186 if (m_buffer_pos == m_buffer_start || !m_flushable)
187 return FALSE;
188
189 current = m_buffer_pos-m_buffer_start;
190 count = m_stream->OnSysWrite(m_buffer_start, current);
191 if (count != current)
192 return FALSE;
193 m_buffer_pos = m_buffer_start;
194
195 return TRUE;
196}
197
198void wxStreamBuffer::GetFromBuffer(void *buffer, size_t size)
199{
200 size_t s_toget = m_buffer_end-m_buffer_pos;
201
202 if (size < s_toget)
203 s_toget = size;
204
205 memcpy(buffer, m_buffer_pos, s_toget);
206 m_buffer_pos += s_toget;
207}
208
209void wxStreamBuffer::PutToBuffer(const void *buffer, size_t size)
210{
211 size_t s_toput = m_buffer_end-m_buffer_pos;
212
213 if (s_toput < size && !m_fixed) {
214 m_buffer_start = (char *)realloc(m_buffer_start, m_buffer_size+size);
215 // I round a bit
216 m_buffer_size += size;
217 m_buffer_end = m_buffer_start+m_buffer_size;
218 s_toput = size;
219 }
220 if (s_toput > size)
221 s_toput = size;
222 memcpy(m_buffer_pos, buffer, s_toput);
223 m_buffer_pos += s_toput;
224}
225
226void wxStreamBuffer::PutChar(char c)
227{
228 wxASSERT(m_stream != NULL);
229
230 if (!m_buffer_size) {
231 m_stream->OnSysWrite(&c, 1);
232 return;
233 }
234
235 if (!GetDataLeft() && !FlushBuffer()) {
236 m_stream->m_lasterror = wxStream_EOF;
237 return;
238 }
239
240 PutToBuffer(&c, 1);
241 m_stream->m_lastcount = 1;
242}
243
244char wxStreamBuffer::GetChar()
245{
246 char c;
247
248 wxASSERT(m_stream != NULL);
249
250 if (!m_buffer_size) {
251 m_stream->OnSysRead(&c, 1);
252 return c;
253 }
254
255 if (!GetDataLeft()) {
256 m_stream->m_lasterror = wxStream_EOF;
257 return 0;
258 }
259
260 GetFromBuffer(&c, 1);
261 m_stream->m_lastcount = 1;
262 return c;
263}
264
265size_t wxStreamBuffer::Read(void *buffer, size_t size)
266{
267 wxASSERT(m_stream != NULL);
268
269 // ------------------
270 // Buffering disabled
271 // ------------------
272
273 m_stream->m_lastcount = GetWBack((char *)buffer, size);
274 size -= m_stream->m_lastcount;
275 if (size == 0)
276 return m_stream->m_lastcount;
277
278 buffer = (void *)((char *)buffer+m_stream->m_lastcount);
279
280 if (!m_buffer_size) {
281 return (m_stream->m_lastcount += m_stream->OnSysRead(buffer, size));
282 }
283
284 // -----------------
285 // Buffering enabled
286 // -----------------
287 size_t buf_left, orig_size = size;
288
289 while (size > 0) {
290 buf_left = GetDataLeft();
291
292 // First case: the requested buffer is larger than the stream buffer,
293 // we split it.
294 if (size > buf_left) {
295 GetFromBuffer(buffer, buf_left);
296 size -= buf_left;
297 buffer = (char *)buffer + buf_left; // ANSI C++ violation.
298
299 if (!FillBuffer()) {
300 if (m_stream->m_lasterror == wxStream_NOERROR)
301 m_stream->m_lasterror = wxStream_EOF;
302 return (m_stream->m_lastcount = orig_size-size);
303 }
304 } else {
305
306 // Second case: we just copy from the stream buffer.
307 GetFromBuffer(buffer, size);
308 break;
309 }
310 }
311 return (m_stream->m_lastcount += orig_size);
312}
313
314size_t wxStreamBuffer::Read(wxStreamBuffer *s_buf)
315{
316 char buf[BUF_TEMP_SIZE];
317 size_t s = 0, bytes_read = BUF_TEMP_SIZE;
318
319 while (bytes_read == BUF_TEMP_SIZE) {
320 bytes_read = Read(buf, bytes_read);
321 bytes_read = s_buf->Write(buf, bytes_read);
322 s += bytes_read;
323 }
324 return s;
325}
326
327size_t wxStreamBuffer::Write(const void *buffer, size_t size)
328{
329 wxASSERT(m_stream != NULL);
330
331 // ------------------
332 // Buffering disabled
333 // ------------------
334
335 if (!m_buffer_size)
336 return (m_stream->m_lastcount = m_stream->OnSysWrite(buffer, size));
337
338 // ------------------
339 // Buffering enabled
340 // ------------------
341
342 size_t buf_left, orig_size = size;
343
344 while (size > 0) {
345 buf_left = m_buffer_end - m_buffer_pos;
346
347 // First case: the buffer to write is larger than the stream buffer,
348 // we split it
349 if (size > buf_left) {
350 PutToBuffer(buffer, buf_left);
351 size -= buf_left;
352 buffer = (char *)buffer + buf_left; // ANSI C++ violation.
353
354 if (!FlushBuffer()) {
355 if (m_stream->m_lasterror == wxStream_NOERROR)
356 m_stream->m_lasterror = wxStream_EOF;
357 return (m_stream->m_lastcount = orig_size-size);
358 }
359
360 m_buffer_pos = m_buffer_start;
361
362 } else {
363
364 // Second case: just copy it in the stream buffer.
365 PutToBuffer(buffer, size);
366 break;
367 }
368 }
369 return (m_stream->m_lastcount = orig_size);
370}
371
372size_t wxStreamBuffer::Write(wxStreamBuffer *sbuf)
373{
374 char buf[BUF_TEMP_SIZE];
375 size_t s = 0, bytes_count = BUF_TEMP_SIZE;
376
377 while (bytes_count == BUF_TEMP_SIZE) {
378 if (m_stream->StreamSize() < bytes_count)
379 bytes_count = m_stream->StreamSize();
380 bytes_count = sbuf->Read(buf, bytes_count);
381 bytes_count = Write(buf, bytes_count);
382 s += bytes_count;
383 }
384 return s;
385}
386
387off_t wxStreamBuffer::Seek(off_t pos, wxSeekMode mode)
388{
389 off_t ret_off, diff, last_access;
390
391 last_access = GetLastAccess();
392
393 if (!m_flushable) {
394 diff = pos + GetIntPosition();
395 if (diff < 0 || diff > last_access)
396 return wxInvalidOffset;
397 SetIntPosition(diff);
398 return diff;
399 }
400
401 switch (mode) {
402 case wxFromStart: {
403 // We'll try to compute an internal position later ...
404 ret_off = m_stream->OnSysSeek(pos, wxFromStart);
405 ResetBuffer();
406 return ret_off;
407 }
408 case wxFromCurrent: {
409 diff = pos + GetIntPosition();
410
411 if ( (diff > last_access) || (diff < 0) ) {
412 ret_off = m_stream->OnSysSeek(pos, wxFromCurrent);
413 ResetBuffer();
414 return ret_off;
415 } else {
416 SetIntPosition(diff);
417 return pos;
418 }
419 }
420 case wxFromEnd:
421 // Hard to compute: always seek to the requested position.
422 ret_off = m_stream->OnSysSeek(pos, wxFromEnd);
423 ResetBuffer();
424 return ret_off;
425 }
426 return wxInvalidOffset;
427}
428
429off_t wxStreamBuffer::Tell() const
430{
431 off_t pos;
432
433 if (m_flushable) {
434 pos = m_stream->OnSysTell();
435 if (pos == wxInvalidOffset)
436 return wxInvalidOffset;
437 return pos - GetLastAccess() + GetIntPosition();
438 } else
439 return GetIntPosition();
440}
441
442size_t wxStreamBuffer::GetDataLeft()
443{
444 if (m_buffer_end == m_buffer_pos && m_flushable)
445 FillBuffer();
446 return m_buffer_end-m_buffer_pos;
447}
448
449// ----------------------------------------------------------------------------
450// wxStreamBase
451// ----------------------------------------------------------------------------
452
453wxStreamBase::wxStreamBase()
454{
455 m_lasterror = wxStream_NOERROR;
456 m_lastcount = 0;
457}
458
459wxStreamBase::~wxStreamBase()
460{
461}
462
463size_t wxStreamBase::OnSysRead(void *WXUNUSED(buffer), size_t WXUNUSED(size))
464{
465 return 0;
466}
467
468size_t wxStreamBase::OnSysWrite(const void *WXUNUSED(buffer), size_t WXUNUSED(bufsize))
469{
470 return 0;
471}
472
473off_t wxStreamBase::OnSysSeek(off_t WXUNUSED(seek), wxSeekMode WXUNUSED(mode))
474{
475 return wxInvalidOffset;
476}
477
478off_t wxStreamBase::OnSysTell() const
479{
480 return wxInvalidOffset;
481}
482
483// ----------------------------------------------------------------------------
484// wxInputStream
485// ----------------------------------------------------------------------------
486
487wxInputStream::wxInputStream()
488 : wxStreamBase()
489{
490 m_i_destroybuf = TRUE;
491 m_i_streambuf = new wxStreamBuffer(*this, wxStreamBuffer::read);
492}
493
494wxInputStream::wxInputStream(wxStreamBuffer *buffer)
495 : wxStreamBase()
496{
497 m_i_destroybuf = FALSE;
498 m_i_streambuf = buffer;
499}
500
501wxInputStream::~wxInputStream()
502{
503 if (m_i_destroybuf)
504 delete m_i_streambuf;
505}
506
507char wxInputStream::GetC()
508{
509 char c;
510 m_i_streambuf->Read(&c, 1);
511 return c;
512}
513
514wxInputStream& wxInputStream::Read(void *buffer, size_t size)
515{
516 m_i_streambuf->Read(buffer, size);
517 // wxStreamBuffer sets all variables for us
518 return *this;
519}
520
521char wxInputStream::Peek()
522{
523 m_i_streambuf->GetDataLeft();
524
525 return *(m_i_streambuf->GetBufferPos());
526}
527
528
529wxInputStream& wxInputStream::Read(wxOutputStream& stream_out)
530{
531 char buf[BUF_TEMP_SIZE];
532 size_t bytes_read = BUF_TEMP_SIZE;
533
534 while (bytes_read == BUF_TEMP_SIZE) {
535 bytes_read = Read(buf, bytes_read).LastRead();
536 bytes_read = stream_out.Write(buf, bytes_read).LastWrite();
537 }
538 return *this;
539}
540
541off_t wxInputStream::SeekI(off_t pos, wxSeekMode mode)
542{
543 return m_i_streambuf->Seek(pos, mode);
544}
545
546off_t wxInputStream::TellI() const
547{
548 return m_i_streambuf->Tell();
549}
550
551// --------------------
552// Overloaded operators
553// --------------------
554
555wxInputStream& wxInputStream::operator>>(wxString& line)
556{
557 wxDataInputStream s(*this);
558
559 line = s.ReadLine();
560 return *this;
561}
562
563wxInputStream& wxInputStream::operator>>(char& c)
564{
565 c = GetC();
566 return *this;
567}
568
569wxInputStream& wxInputStream::operator>>(short& i)
570{
571 long l;
572
573 *this >> l;
574 i = (short)l;
575 return *this;
576}
577
578wxInputStream& wxInputStream::operator>>(int& i)
579{
580 long l;
581
582 *this >> l;
583 i = (short)l;
584 return *this;
585}
586
587wxInputStream& wxInputStream::operator>>(long& i)
588{
589 /* I only implemented a simple integer parser */
590 int c, sign;
591
592 while (isspace( c = GetC() ) )
593 /* Do nothing */ ;
594
595 i = 0;
596 if (! (c == '-' || isdigit(c)) ) {
597 InputStreamBuffer()->WriteBack(c);
598 return *this;
599 }
600
601 if (c == '-') {
602 sign = -1;
603 c = GetC();
604 } else
605 sign = 1;
606
607 while (isdigit(c)) {
608 i = i*10 + c;
609 c = GetC();
610 }
611
612 i *= sign;
613
614 return *this;
615}
616
617wxInputStream& wxInputStream::operator>>(double& f)
618{
619 /* I only implemented a simple float parser */
620 int c, sign;
621
622 while (isspace( c = GetC() ) )
623 /* Do nothing */ ;
624
625 f = 0.0;
626 if (! (c == '-' || isdigit(c)) ) {
627 InputStreamBuffer()->WriteBack(c);
628 return *this;
629 }
630
631 if (c == '-') {
632 sign = -1;
633 c = GetC();
634 } else
635 sign = 1;
636
637 while (isdigit(c)) {
638 f = f*10 + (c - '0');
639 c = GetC();
640 }
641
642 if (c == '.') {
643 double f_multiplicator = (double) 0.1;
644 c = GetC();
645
646 while (isdigit(c)) {
647 f += (c-'0')*f_multiplicator;
648 f_multiplicator /= 10;
649 c = GetC();
650 }
651 }
652
653 f *= sign;
654
655 return *this;
656}
657
658#if wxUSE_SERIAL
659wxInputStream& wxInputStream::operator>>(wxObject *& obj)
660{
661 wxObjectInputStream obj_s(*this);
662 obj = obj_s.LoadObject();
663 return *this;
664}
665#endif
666
667
668// ----------------------------------------------------------------------------
669// wxOutputStream
670// ----------------------------------------------------------------------------
671wxOutputStream::wxOutputStream()
672 : wxStreamBase()
673{
674 m_o_destroybuf = TRUE;
675 m_o_streambuf = new wxStreamBuffer(*this, wxStreamBuffer::write);
676}
677
678wxOutputStream::wxOutputStream(wxStreamBuffer *buffer)
679 : wxStreamBase()
680{
681 m_o_destroybuf = FALSE;
682 m_o_streambuf = buffer;
683}
684
685wxOutputStream::~wxOutputStream()
686{
687 if (m_o_destroybuf)
688 delete m_o_streambuf;
689}
690
691wxOutputStream& wxOutputStream::Write(const void *buffer, size_t size)
692{
693 m_o_streambuf->Write(buffer, size);
694 return *this;
695}
696
697wxOutputStream& wxOutputStream::Write(wxInputStream& stream_in)
698{
699 stream_in.Read(*this);
700 return *this;
701}
702
703off_t wxOutputStream::TellO() const
704{
705 return m_o_streambuf->Tell();
706}
707
708off_t wxOutputStream::SeekO(off_t pos, wxSeekMode mode)
709{
710 return m_o_streambuf->Seek(pos, mode);
711}
712
713void wxOutputStream::Sync()
714{
715 m_o_streambuf->FlushBuffer();
716}
717
718wxOutputStream& wxOutputStream::operator<<(const char *string)
719{
720 return Write(string, strlen(string));
721}
722
723wxOutputStream& wxOutputStream::operator<<(wxString& string)
724{
725 return Write(string, string.Len());
726}
727
728wxOutputStream& wxOutputStream::operator<<(char c)
729{
730 return Write(&c, 1);
731}
732
733wxOutputStream& wxOutputStream::operator<<(short i)
734{
735 wxString strint;
736
737 strint.Printf("%i", i);
738 return Write(strint, strint.Len());
739}
740
741wxOutputStream& wxOutputStream::operator<<(int i)
742{
743 wxString strint;
744
745 strint.Printf("%i", i);
746 return Write(strint, strint.Len());
747}
748
749wxOutputStream& wxOutputStream::operator<<(long i)
750{
751 wxString strlong;
752
753 strlong.Printf("%i", i);
754 return Write((const char *)strlong, strlong.Len());
755}
756
757wxOutputStream& wxOutputStream::operator<<(double f)
758{
759 wxString strfloat;
760
761 strfloat.Printf("%f", f);
762 return Write(strfloat, strfloat.Len());
763}
764
765#if wxUSE_SERIAL
766wxOutputStream& wxOutputStream::operator<<(wxObject& obj)
767{
768 wxObjectOutputStream obj_s(*this);
769 obj_s.SaveObject(obj);
770 return *this;
771}
772#endif
773
774// ----------------------------------------------------------------------------
775// wxFilterInputStream
776// ----------------------------------------------------------------------------
777wxFilterInputStream::wxFilterInputStream()
778 : wxInputStream(NULL)
779{
780 // WARNING streambuf set to NULL !
781}
782
783wxFilterInputStream::wxFilterInputStream(wxInputStream& stream)
784 : wxInputStream(stream.InputStreamBuffer())
785{
786 m_parent_i_stream = &stream;
787}
788
789wxFilterInputStream::~wxFilterInputStream()
790{
791}
792
793// ----------------------------------------------------------------------------
794// wxFilterOutputStream
795// ----------------------------------------------------------------------------
796wxFilterOutputStream::wxFilterOutputStream()
797 : wxOutputStream(NULL)
798{
799}
800
801wxFilterOutputStream::wxFilterOutputStream(wxOutputStream& stream)
802 : wxOutputStream(stream.OutputStreamBuffer())
803{
804 m_parent_o_stream = &stream;
805}
806
807wxFilterOutputStream::~wxFilterOutputStream()
808{
809}
810
811// ----------------------------------------------------------------------------
812// Some IOManip function
813// ----------------------------------------------------------------------------
814
815wxOutputStream& wxEndL(wxOutputStream& stream)
816{
817#ifdef __MSW__
818 return stream.Write("\r\n", 2);
819#else
820 return stream.Write("\n", 1);
821#endif
822}