src/common/stream.cpp

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