include/wx/stream.h

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        stream.h
   3 // Purpose:     "wxWindows stream" 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 #ifndef _WX_WXSTREAM_H__
  13 #define _WX_WXSTREAM_H__
  14
  15 #ifdef __GNUG__
  16 #pragma interface
  17 #endif
  18
  19 #include "wx/defs.h"
  20
  21 #if wxUSE_STREAMS
  22
  23 #include <stdio.h>
  24 #include "wx/object.h"
  25 #include "wx/string.h"
  26 #include "wx/filefn.h"  // for off_t, wxInvalidOffset and wxSeekMode
  27
  28 class WXDLLEXPORT wxStreamBase;
  29 class WXDLLEXPORT wxInputStream;
  30 class WXDLLEXPORT wxOutputStream;
  31
  32 typedef wxInputStream& (*__wxInputManip)(wxInputStream&);
  33 typedef wxOutputStream& (*__wxOutputManip)(wxOutputStream&);
  34
  35 WXDLLEXPORT wxOutputStream& wxEndL(wxOutputStream& o_stream);
  36
  37 // ---------------------------------------------------------------------------
  38 // wxStream: base classes
  39 // ---------------------------------------------------------------------------
  40
  41 #define wxStream_NOERROR    wxSTREAM_NOERROR
  42 #define wxStream_EOF        wxSTREAM_EOF
  43 #define wxStream_WRITE_ERR  wxSTREAM_WRITE_ERROR
  44 #define wxStream_READ_ERR   wxSTREAM_READ_ERROR
  45
  46 typedef enum {
  47   wxStream_NOERROR = 0,
  48   wxStream_EOF,
  49   wxStream_WRITE_ERR,
  50   wxStream_READ_ERR
  51 } wxStreamError;
  52
  53 class WXDLLEXPORT wxStreamBase {
  54  public:
  55   wxStreamBase();
  56   virtual ~wxStreamBase();
  57
  58   bool operator!() const { return (LastError() != wxSTREAM_NOERROR); }
  59   wxStreamError LastError() const { return m_lasterror; }
  60   virtual size_t GetSize() const { return ~((size_t)0); }
  61   size_t StreamSize() const { return GetSize(); }
  62
  63  protected:
  64
  65   virtual size_t OnSysRead(void *buffer, size_t bufsize);
  66   virtual size_t OnSysWrite(const void *buffer, size_t bufsize);
  67   virtual off_t OnSysSeek(off_t seek, wxSeekMode mode);
  68   virtual off_t OnSysTell() const;
  69
  70  protected:
  71   friend class wxStreamBuffer;
  72
  73   size_t m_lastcount;
  74   wxStreamError m_lasterror;
  75 };
  76
  77 class WXDLLEXPORT wxInputStream: public wxStreamBase {
  78  public:
  79   wxInputStream();
  80   virtual ~wxInputStream();
  81
  82   // IO functions
  83   virtual char Peek();
  84   char GetC();
  85   virtual wxInputStream& Read(void *buffer, size_t size);
  86   wxInputStream& Read(wxOutputStream& stream_out);
  87
  88   // Position functions
  89   virtual off_t SeekI(off_t pos, wxSeekMode mode = wxFromStart);
  90   virtual off_t TellI() const;
  91
  92   // State functions
  93   virtual size_t LastRead() { return wxStreamBase::m_lastcount; }
  94
  95   // Ungetch
  96   size_t Ungetch(void *buffer, size_t size);
  97   bool Ungetch(char c);
  98
  99   // Operators
 100   wxInputStream& operator>>(wxOutputStream& out) { return Read(out); }
 101 #if wxUSE_SERIAL
 102   wxInputStream& operator>>(wxObject *& obj);
 103 #endif
 104   wxInputStream& operator>>( __wxInputManip func) { return func(*this); }
 105
 106  protected:
 107   // Ungetch managers
 108   char *m_wback;
 109   size_t m_wbacksize;
 110   size_t m_wbackcur;
 111
 112   char *AllocSpaceWBack(size_t needed_size);
 113   size_t GetWBack(char *buf, size_t bsize);
 114
 115 };
 116
 117 class WXDLLEXPORT wxOutputStream: public wxStreamBase {
 118  public:
 119   wxOutputStream();
 120   virtual ~wxOutputStream();
 121
 122   virtual wxOutputStream& Write(const void *buffer, size_t size);
 123   wxOutputStream& Write(wxInputStream& stream_in);
 124
 125   virtual off_t SeekO(off_t pos, wxSeekMode mode = wxFromStart);
 126   virtual off_t TellO() const;
 127
 128   virtual size_t LastWrite() const { return wxStreamBase::m_lastcount; }
 129
 130   virtual void Sync();
 131
 132   wxOutputStream& operator<<(wxInputStream& out) { return Write(out); }
 133 #if wxUSE_SERIAL
 134   wxOutputStream& operator<<(wxObject& obj);
 135 #endif
 136   wxOutputStream& operator<<( __wxOutputManip func) { return func(*this); }
 137 };
 138
 139 // ---------------------------------------------------------------------------
 140 // "Filter" streams
 141 // ---------------------------------------------------------------------------
 142
 143 class WXDLLEXPORT wxFilterInputStream: public wxInputStream {
 144  public:
 145   wxFilterInputStream();
 146   wxFilterInputStream(wxInputStream& stream);
 147   ~wxFilterInputStream();
 148
 149   char Peek() { return m_parent_i_stream->Peek(); }
 150
 151   wxStreamError LastError() const { return m_parent_i_stream->LastError(); }
 152   size_t GetSize() const { return m_parent_i_stream->GetSize(); }
 153
 154  protected:
 155   wxInputStream *m_parent_i_stream;
 156 };
 157
 158 class WXDLLEXPORT wxFilterOutputStream: public wxOutputStream {
 159  public:
 160   wxFilterOutputStream();
 161   wxFilterOutputStream(wxOutputStream& stream);
 162   ~wxFilterOutputStream();
 163
 164   wxStreamError LastError() const { return m_parent_o_stream->LastError(); }
 165   size_t GetSize() const { return m_parent_o_stream->GetSize(); }
 166
 167  protected:
 168   wxOutputStream *m_parent_o_stream;
 169 };
 170
 171 // ---------------------------------------------------------------------------
 172 // Stream buffer
 173 // ---------------------------------------------------------------------------
 174
 175 class WXDLLEXPORT wxStreamBuffer {
 176  public:
 177   typedef enum {
 178     read = 0, write, read_write
 179   } BufMode;
 180
 181   // -----------
 182   // ctor & dtor
 183   // -----------
 184   wxStreamBuffer(wxStreamBase& stream, BufMode mode);
 185   wxStreamBuffer(BufMode mode);
 186   wxStreamBuffer(const wxStreamBuffer& buf);
 187   ~wxStreamBuffer();
 188
 189   // -----------
 190   // Filtered IO
 191   // -----------
 192   size_t Read(void *buffer, size_t size);
 193   size_t Read(wxStreamBuffer *buf);
 194   size_t Write(const void *buffer, size_t size);
 195   size_t Write(wxStreamBuffer *buf);
 196
 197   char GetChar();
 198   void PutChar(char c);
 199   off_t Tell() const;
 200   off_t Seek(off_t pos, wxSeekMode mode);
 201
 202   // --------------
 203   // Buffer control
 204   // --------------
 205   void ResetBuffer();
 206   void SetBufferIO(char *buffer_start, char *buffer_end);
 207   void SetBufferIO(size_t bufsize);
 208   char *GetBufferStart() const { return m_buffer_start; }
 209   char *GetBufferEnd() const { return m_buffer_end; }
 210   char *GetBufferPos() const { return m_buffer_pos; }
 211   off_t GetIntPosition() const { return m_buffer_pos-m_buffer_start; }
 212   void SetIntPosition(off_t pos) { m_buffer_pos = m_buffer_start+pos; }
 213   size_t GetLastAccess() const { return m_buffer_end-m_buffer_start; }
 214
 215   void Fixed(bool fixed) { m_fixed = fixed; }
 216   void Flushable(bool f) { m_flushable = f; }
 217
 218   bool FlushBuffer();
 219   bool FillBuffer();
 220   size_t GetDataLeft();
 221
 222   // --------------
 223   // Administration
 224   // --------------
 225   wxStreamBase *Stream() { return m_stream; }
 226
 227  protected:
 228   void GetFromBuffer(void *buffer, size_t size);
 229   void PutToBuffer(const void *buffer, size_t size);
 230
 231  protected:
 232   char *m_buffer_start, *m_buffer_end, *m_buffer_pos;
 233   size_t m_buffer_size;
 234
 235   char *m_wback;
 236   size_t m_wbacksize, m_wbackcur;
 237
 238   bool m_fixed, m_flushable;
 239
 240   wxStreamBase *m_stream;
 241   BufMode m_mode;
 242   bool m_destroybuf, m_destroystream;
 243 };
 244
 245 // ---------------------------------------------------------------------------
 246 // wxBufferedStreams
 247 // ---------------------------------------------------------------------------
 248
 249 class wxBufferedInputStream: public wxFilterInputStream {
 250  public:
 251   wxBufferedInputStream(wxInputStream& stream);
 252   ~wxBufferedInputStream();
 253
 254   wxInputStream& Read(void *buffer, size_t size);
 255
 256   // Position functions
 257   off_t SeekI(off_t pos, wxSeekMode mode = wxFromStart);
 258   off_t TellI() const;
 259
 260   wxStreamBuffer *InputStreamBuffer() const { return m_i_streambuf; }
 261
 262  protected:
 263   size_t OnSysRead(void *buffer, size_t bufsize);
 264   off_t OnSysSeek(off_t seek, wxSeekMode mode);
 265   off_t OnSysTell() const;
 266
 267  protected:
 268   wxStreamBuffer *m_i_streambuf;
 269 };
 270
 271 class wxBufferedOutputStream: public wxFilterOutputStream {
 272  public:
 273   wxBufferedOutputStream(wxOutputStream& stream);
 274   ~wxBufferedOutputStream();
 275
 276   wxOutputStream& Write(const void *buffer, size_t size);
 277
 278   // Position functions
 279   off_t SeekO(off_t pos, wxSeekMode mode = wxFromStart);
 280   off_t TellO() const;
 281
 282   void Sync();
 283
 284   wxStreamBuffer *OutputStreamBuffer() const { return m_o_streambuf; }
 285
 286  protected:
 287   size_t OnSysWrite(const void *buffer, size_t bufsize);
 288   off_t OnSysSeek(off_t seek, wxSeekMode mode);
 289   off_t OnSysTell() const;
 290
 291  protected:
 292   wxStreamBuffer *m_o_streambuf;
 293 };
 294
 295 #endif
 296   // wxUSE_STREAMS
 297
 298 #endif
 299   // _WX_WXSTREAM_H__