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 wxStreamBuffer::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
  40 wxStreamBuffer::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
  48 wxStreamBuffer::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
  62 wxStreamBuffer::~wxStreamBuffer()
  63 {
  64   if (m_destroybuf)
  65     wxDELETEA(m_buffer_start);
  66   if (m_destroystream)
  67     delete m_stream;
  68 }
  69
  70 size_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
  82 bool 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
  94 void 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
 106 void 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
 125 void 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
 133 char *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
 149 size_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
 169 bool 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
 182 bool 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
 198 void 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
 209 void 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
 226 void 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
 244 char 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
 265 size_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
 314 size_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
 327 size_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
 372 size_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
 387 off_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
 429 off_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
 442 size_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
 453 wxStreamBase::wxStreamBase()
 454 {
 455   m_lasterror = wxStream_NOERROR;
 456   m_lastcount = 0;
 457 }
 458
 459 wxStreamBase::~wxStreamBase()
 460 {
 461 }
 462
 463 size_t wxStreamBase::OnSysRead(void *WXUNUSED(buffer), size_t WXUNUSED(size))
 464 {
 465   return 0;
 466 }
 467
 468 size_t wxStreamBase::OnSysWrite(const void *WXUNUSED(buffer), size_t WXUNUSED(bufsize))
 469 {
 470   return 0;
 471 }
 472
 473 off_t wxStreamBase::OnSysSeek(off_t WXUNUSED(seek), wxSeekMode WXUNUSED(mode))
 474 {
 475   return wxInvalidOffset;
 476 }
 477
 478 off_t wxStreamBase::OnSysTell() const
 479 {
 480   return wxInvalidOffset;
 481 }
 482
 483 // ----------------------------------------------------------------------------
 484 // wxInputStream
 485 // ----------------------------------------------------------------------------
 486
 487 wxInputStream::wxInputStream()
 488   : wxStreamBase()
 489 {
 490   m_i_destroybuf = TRUE;
 491   m_i_streambuf = new wxStreamBuffer(*this, wxStreamBuffer::read);
 492 }
 493
 494 wxInputStream::wxInputStream(wxStreamBuffer *buffer)
 495   : wxStreamBase()
 496 {
 497   m_i_destroybuf = FALSE;
 498   m_i_streambuf = buffer;
 499 }
 500
 501 wxInputStream::~wxInputStream()
 502 {
 503   if (m_i_destroybuf)
 504     delete m_i_streambuf;
 505 }
 506
 507 char wxInputStream::GetC()
 508 {
 509   char c;
 510   m_i_streambuf->Read(&c, 1);
 511   return c;
 512 }
 513
 514 wxInputStream& 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
 521 char wxInputStream::Peek()
 522 {
 523   m_i_streambuf->GetDataLeft();
 524
 525   return *(m_i_streambuf->GetBufferPos());
 526 }
 527
 528
 529 wxInputStream& 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
 541 off_t wxInputStream::SeekI(off_t pos, wxSeekMode mode)
 542 {
 543   return m_i_streambuf->Seek(pos, mode);
 544 }
 545
 546 off_t wxInputStream::TellI() const
 547 {
 548   return m_i_streambuf->Tell();
 549 }
 550
 551 // --------------------
 552 // Overloaded operators
 553 // --------------------
 554
 555 wxInputStream& wxInputStream::operator>>(wxString& line)
 556 {
 557   wxDataInputStream s(*this);
 558
 559   line = s.ReadLine();
 560   return *this;
 561 }
 562
 563 wxInputStream& wxInputStream::operator>>(char& c)
 564 {
 565   c = GetC();
 566   return *this;
 567 }
 568
 569 wxInputStream& wxInputStream::operator>>(short& i)
 570 {
 571   long l;
 572
 573   *this >> l;
 574   i = (short)l;
 575   return *this;
 576 }
 577
 578 wxInputStream& wxInputStream::operator>>(int& i)
 579 {
 580   long l;
 581
 582   *this >> l;
 583   i = (short)l;
 584   return *this;
 585 }
 586
 587 wxInputStream& 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
 617 wxInputStream& 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
 659 wxInputStream& 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 // ----------------------------------------------------------------------------
 671 wxOutputStream::wxOutputStream()
 672   : wxStreamBase()
 673 {
 674   m_o_destroybuf = TRUE;
 675   m_o_streambuf = new wxStreamBuffer(*this, wxStreamBuffer::write);
 676 }
 677
 678 wxOutputStream::wxOutputStream(wxStreamBuffer *buffer)
 679   : wxStreamBase()
 680 {
 681   m_o_destroybuf = FALSE;
 682   m_o_streambuf = buffer;
 683 }
 684
 685 wxOutputStream::~wxOutputStream()
 686 {
 687   if (m_o_destroybuf)
 688     delete m_o_streambuf;
 689 }
 690
 691 wxOutputStream& wxOutputStream::Write(const void *buffer, size_t size)
 692 {
 693   m_o_streambuf->Write(buffer, size);
 694   return *this;
 695 }
 696
 697 wxOutputStream& wxOutputStream::Write(wxInputStream& stream_in)
 698 {
 699   stream_in.Read(*this);
 700   return *this;
 701 }
 702
 703 off_t wxOutputStream::TellO() const
 704 {
 705   return m_o_streambuf->Tell();
 706 }
 707
 708 off_t wxOutputStream::SeekO(off_t pos, wxSeekMode mode)
 709 {
 710   return m_o_streambuf->Seek(pos, mode);
 711 }
 712
 713 void wxOutputStream::Sync()
 714 {
 715   m_o_streambuf->FlushBuffer();
 716 }
 717
 718 wxOutputStream& wxOutputStream::operator<<(const char *string)
 719 {
 720   return Write(string, strlen(string));
 721 }
 722
 723 wxOutputStream& wxOutputStream::operator<<(wxString& string)
 724 {
 725   return Write(string, string.Len());
 726 }
 727
 728 wxOutputStream& wxOutputStream::operator<<(char c)
 729 {
 730   return Write(&c, 1);
 731 }
 732
 733 wxOutputStream& wxOutputStream::operator<<(short i)
 734 {
 735   wxString strint;
 736
 737   strint.Printf("%i", i);
 738   return Write(strint, strint.Len());
 739 }
 740
 741 wxOutputStream& wxOutputStream::operator<<(int i)
 742 {
 743   wxString strint;
 744
 745   strint.Printf("%i", i);
 746   return Write(strint, strint.Len());
 747 }
 748
 749 wxOutputStream& wxOutputStream::operator<<(long i)
 750 {
 751   wxString strlong;
 752
 753   strlong.Printf("%i", i);
 754   return Write((const char *)strlong, strlong.Len());
 755 }
 756
 757 wxOutputStream& 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
 766 wxOutputStream& 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 // ----------------------------------------------------------------------------
 777 wxFilterInputStream::wxFilterInputStream()
 778   : wxInputStream(NULL)
 779 {
 780   // WARNING streambuf set to NULL !
 781 }
 782
 783 wxFilterInputStream::wxFilterInputStream(wxInputStream& stream)
 784   : wxInputStream(stream.InputStreamBuffer())
 785 {
 786   m_parent_i_stream = &stream;
 787 }
 788
 789 wxFilterInputStream::~wxFilterInputStream()
 790 {
 791 }
 792
 793 // ----------------------------------------------------------------------------
 794 // wxFilterOutputStream
 795 // ----------------------------------------------------------------------------
 796 wxFilterOutputStream::wxFilterOutputStream()
 797   : wxOutputStream(NULL)
 798 {
 799 }
 800
 801 wxFilterOutputStream::wxFilterOutputStream(wxOutputStream& stream)
 802   : wxOutputStream(stream.OutputStreamBuffer())
 803 {
 804   m_parent_o_stream = &stream;
 805 }
 806
 807 wxFilterOutputStream::~wxFilterOutputStream()
 808 {
 809 }
 810
 811 // ----------------------------------------------------------------------------
 812 // Some IOManip function
 813 // ----------------------------------------------------------------------------
 814
 815 wxOutputStream& 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 }