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