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