include/wx/stream.h

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        wx/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 #if defined(__GNUG__) && !defined(__APPLE__)
  16 #pragma interface "stream.h"
  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 enum wxStreamError
  42 {
  43     wxSTREAM_NO_ERROR = 0,
  44     wxSTREAM_NO_ERR = wxSTREAM_NO_ERROR,
  45     wxSTREAM_NOERROR = wxSTREAM_NO_ERROR,
  46
  47     wxSTREAM_EOF,
  48
  49     wxSTREAM_WRITE_ERROR,
  50     wxSTREAM_WRITE_ERR = wxSTREAM_WRITE_ERROR,
  51
  52     wxSTREAM_READ_ERROR,
  53     wxSTREAM_READ_ERR = wxSTREAM_READ_ERROR
  54 };
  55
  56 // compatibility
  57 #define wxStream_NOERROR    wxSTREAM_NOERROR
  58 #define wxStream_EOF        wxSTREAM_EOF
  59 #define wxStream_WRITE_ERR  wxSTREAM_WRITE_ERROR
  60 #define wxStream_READ_ERR   wxSTREAM_READ_ERROR
  61
  62 class WXDLLEXPORT wxStreamBase
  63 {
  64 public:
  65     wxStreamBase();
  66     virtual ~wxStreamBase();
  67
  68     // error testing
  69     wxStreamError GetLastError() const { return m_lasterror; }
  70     bool IsOk() const { return LastError() == wxSTREAM_NOERROR; }
  71     bool operator!() const { return LastError() != wxSTREAM_NOERROR; }
  72
  73     virtual size_t GetSize() const { return 0; }
  74
  75     // deprecated, for compatibility only
  76     wxStreamError LastError() const { return m_lasterror; }
  77     size_t StreamSize() const { return GetSize(); }
  78
  79 protected:
  80     // VZ: these functions are really pure virtual and shouldn't be declared
  81     //     in the base class because it creates ambiguties in stream classes
  82     //     deriving from both wxInputStream and wxOutputStream
  83 #if 0
  84     virtual size_t OnSysRead(void *buffer, size_t bufsize);
  85     virtual size_t OnSysWrite(const void *buffer, size_t bufsize);
  86 #endif
  87
  88     virtual off_t OnSysSeek(off_t seek, wxSeekMode mode);
  89     virtual off_t OnSysTell() const;
  90
  91     friend class wxStreamBuffer;
  92
  93     size_t m_lastcount;
  94     wxStreamError m_lasterror;
  95 };
  96
  97 class WXDLLEXPORT wxInputStream : /* virtual */ public wxStreamBase
  98 {
  99 public:
 100     wxInputStream();
 101     virtual ~wxInputStream();
 102
 103     // is the stream at EOF?
 104     virtual bool Eof() const;
 105
 106     // IO functions
 107     virtual char Peek();
 108     char GetC();
 109     virtual wxInputStream& Read(void *buffer, size_t size);
 110     wxInputStream& Read(wxOutputStream& stream_out);
 111
 112     // Position functions
 113     virtual off_t SeekI(off_t pos, wxSeekMode mode = wxFromStart);
 114     virtual off_t TellI() const;
 115
 116     // State functions
 117     virtual size_t LastRead() { return wxStreamBase::m_lastcount; }
 118
 119     // Ungetch
 120     size_t Ungetch(const void *buffer, size_t size);
 121     bool Ungetch(char c);
 122
 123     // Operators
 124     wxInputStream& operator>>(wxOutputStream& out) { return Read(out); }
 125     wxInputStream& operator>>( __wxInputManip func) { return func(*this); }
 126
 127 protected:
 128     // to be implemented in the derived classes (it should have been pure
 129     // virtual)
 130     virtual size_t OnSysRead(void *buffer, size_t bufsize);
 131
 132     // Ungetch managers
 133     char *m_wback;
 134     size_t m_wbacksize;
 135     size_t m_wbackcur;
 136
 137     char *AllocSpaceWBack(size_t needed_size);
 138     size_t GetWBack(void *buf, size_t bsize);
 139
 140     friend class wxStreamBuffer;
 141 };
 142
 143 class WXDLLEXPORT wxOutputStream : /* virtual */ public wxStreamBase
 144 {
 145 public:
 146     wxOutputStream();
 147     virtual ~wxOutputStream();
 148
 149     void PutC(char c);
 150     virtual wxOutputStream& Write(const void *buffer, size_t size);
 151     wxOutputStream& Write(wxInputStream& stream_in);
 152
 153     virtual off_t SeekO(off_t pos, wxSeekMode mode = wxFromStart);
 154     virtual off_t TellO() const;
 155
 156     virtual size_t LastWrite() const { return wxStreamBase::m_lastcount; }
 157
 158     virtual void Sync();
 159
 160     wxOutputStream& operator<<(wxInputStream& out) { return Write(out); }
 161     wxOutputStream& operator<<( __wxOutputManip func) { return func(*this); }
 162
 163 protected:
 164     // to be implemented in the derived classes (it should have been pure
 165     // virtual)
 166     virtual size_t OnSysWrite(const void *buffer, size_t bufsize);
 167
 168     friend class wxStreamBuffer;
 169 };
 170
 171 // ---------------------------------------------------------------------------
 172 // A stream for measuring streamed output
 173 // ---------------------------------------------------------------------------
 174
 175 class WXDLLEXPORT wxCountingOutputStream : public wxOutputStream
 176 {
 177 public:
 178     wxCountingOutputStream();
 179
 180     size_t GetSize() const;
 181     bool Ok() const { return TRUE; }
 182
 183 protected:
 184     virtual size_t OnSysWrite(const void *buffer, size_t size);
 185     virtual off_t OnSysSeek(off_t pos, wxSeekMode mode);
 186     virtual off_t OnSysTell() const;
 187
 188     size_t m_currentPos;
 189 };
 190
 191 // ---------------------------------------------------------------------------
 192 // "Filter" streams
 193 // ---------------------------------------------------------------------------
 194
 195 class WXDLLEXPORT wxFilterInputStream : public wxInputStream
 196 {
 197 public:
 198     wxFilterInputStream();
 199     wxFilterInputStream(wxInputStream& stream);
 200     virtual ~wxFilterInputStream();
 201
 202     char Peek() { return m_parent_i_stream->Peek(); }
 203
 204     size_t GetSize() const { return m_parent_i_stream->GetSize(); }
 205
 206     wxInputStream *GetFilterInputStream() const { return m_parent_i_stream; }
 207
 208 protected:
 209     wxInputStream *m_parent_i_stream;
 210 };
 211
 212 class WXDLLEXPORT wxFilterOutputStream : public wxOutputStream
 213 {
 214 public:
 215     wxFilterOutputStream();
 216     wxFilterOutputStream(wxOutputStream& stream);
 217     virtual ~wxFilterOutputStream();
 218
 219     size_t GetSize() const { return m_parent_o_stream->GetSize(); }
 220
 221     wxOutputStream *GetFilterOutputStream() const { return m_parent_o_stream; }
 222
 223 protected:
 224     wxOutputStream *m_parent_o_stream;
 225 };
 226
 227 // ---------------------------------------------------------------------------
 228 // Stream buffer: this class can be derived from and passed to
 229 // wxBufferedStreams to implement custom buffering
 230 // ---------------------------------------------------------------------------
 231
 232 class WXDLLEXPORT wxStreamBuffer
 233 {
 234 public:
 235     enum BufMode
 236     {
 237         read,
 238         write,
 239         read_write
 240     };
 241
 242     wxStreamBuffer(wxStreamBase& stream, BufMode mode);
 243     wxStreamBuffer(BufMode mode);
 244     wxStreamBuffer(const wxStreamBuffer& buf);
 245     virtual ~wxStreamBuffer();
 246
 247     // Filtered IO
 248     virtual size_t Read(void *buffer, size_t size);
 249     size_t Read(wxStreamBuffer *buf);
 250     virtual size_t Write(const void *buffer, size_t size);
 251     size_t Write(wxStreamBuffer *buf);
 252
 253     virtual char Peek();
 254     virtual char GetChar();
 255     virtual void PutChar(char c);
 256     virtual off_t Tell() const;
 257     virtual off_t Seek(off_t pos, wxSeekMode mode);
 258
 259     // Buffer control
 260     void ResetBuffer();
 261
 262     // NB: the buffer must always be allocated with malloc() if takeOwn is
 263     //     TRUE as it will be deallocated by free()
 264     void SetBufferIO(void *start, void *end, bool takeOwnership = FALSE);
 265     void SetBufferIO(void *start, size_t len, bool takeOwnership = FALSE);
 266     void SetBufferIO(size_t bufsize);
 267     void *GetBufferStart() const { return m_buffer_start; }
 268     void *GetBufferEnd() const { return m_buffer_end; }
 269     void *GetBufferPos() const { return m_buffer_pos; }
 270     size_t GetBufferSize() const { return m_buffer_size; }
 271     size_t GetIntPosition() const { return m_buffer_pos - m_buffer_start; }
 272     void SetIntPosition(size_t pos) { m_buffer_pos = m_buffer_start + pos; }
 273     size_t GetLastAccess() const { return m_buffer_end - m_buffer_start; }
 274     size_t GetBytesLeft() const { return m_buffer_end - m_buffer_pos; }
 275
 276     void Fixed(bool fixed) { m_fixed = fixed; }
 277     void Flushable(bool f) { m_flushable = f; }
 278
 279     bool FlushBuffer();
 280     bool FillBuffer();
 281     size_t GetDataLeft();
 282
 283     // misc accessors
 284     wxStreamBase *GetStream() const { return m_stream; }
 285     bool HasBuffer() const { return m_buffer_size != 0; }
 286
 287     bool IsFixed() const { return m_fixed; }
 288     bool IsFlushable() const { return m_flushable; }
 289
 290     // only for input/output buffers respectively, returns NULL otherwise
 291     wxInputStream *GetInputStream() const;
 292     wxOutputStream *GetOutputStream() const;
 293
 294     // deprecated, for compatibility only
 295     wxStreamBase *Stream() { return m_stream; }
 296
 297 protected:
 298     void GetFromBuffer(void *buffer, size_t size);
 299     void PutToBuffer(const void *buffer, size_t size);
 300
 301     // set the last error to the specified value if we didn't have it before
 302     void SetError(wxStreamError err);
 303
 304     // common part of several ctors
 305     void Init();
 306
 307     // init buffer variables to be empty
 308     void InitBuffer();
 309
 310     // free the buffer (always safe to call)
 311     void FreeBuffer();
 312
 313     // the buffer itself: the pointers to its start and end and the current
 314     // position in the buffer
 315     char *m_buffer_start,
 316          *m_buffer_end,
 317          *m_buffer_pos;
 318
 319     // the buffer size
 320     // FIXME: isn't it the same as m_buffer_end - m_buffer_start? (VZ)
 321     size_t m_buffer_size;
 322
 323     // the stream we're associated with
 324     wxStreamBase *m_stream;
 325
 326     // its mode
 327     BufMode m_mode;
 328
 329     // flags
 330     bool m_destroybuf,      // deallocate buffer?
 331          m_destroystream,   // delete associated stream?
 332          m_fixed,
 333          m_flushable;
 334 };
 335
 336 // ---------------------------------------------------------------------------
 337 // wxBufferedStreams
 338 // ---------------------------------------------------------------------------
 339
 340 class WXDLLEXPORT wxBufferedInputStream : public wxFilterInputStream
 341 {
 342 public:
 343     // if a non NULL buffer is given to the stream, it will be deleted by it
 344     wxBufferedInputStream(wxInputStream& stream,
 345                           wxStreamBuffer *buffer = NULL);
 346     virtual ~wxBufferedInputStream();
 347
 348     char Peek();
 349     wxInputStream& Read(void *buffer, size_t size);
 350
 351     // Position functions
 352     off_t SeekI(off_t pos, wxSeekMode mode = wxFromStart);
 353     off_t TellI() const;
 354
 355     // the buffer given to the stream will be deleted by it
 356     void SetInputStreamBuffer(wxStreamBuffer *buffer);
 357     wxStreamBuffer *GetInputStreamBuffer() const { return m_i_streambuf; }
 358
 359     // deprecated, for compatibility only
 360     wxStreamBuffer *InputStreamBuffer() const { return m_i_streambuf; }
 361
 362 protected:
 363     virtual size_t OnSysRead(void *buffer, size_t bufsize);
 364     virtual off_t OnSysSeek(off_t seek, wxSeekMode mode);
 365     virtual off_t OnSysTell() const;
 366
 367     wxStreamBuffer *m_i_streambuf;
 368 };
 369
 370 class WXDLLEXPORT wxBufferedOutputStream : public wxFilterOutputStream
 371 {
 372 public:
 373     // if a non NULL buffer is given to the stream, it will be deleted by it
 374     wxBufferedOutputStream(wxOutputStream& stream,
 375                            wxStreamBuffer *buffer = NULL);
 376     virtual ~wxBufferedOutputStream();
 377
 378     wxOutputStream& Write(const void *buffer, size_t size);
 379
 380     // Position functions
 381     off_t SeekO(off_t pos, wxSeekMode mode = wxFromStart);
 382     off_t TellO() const;
 383
 384     void Sync();
 385
 386     size_t GetSize() const;
 387
 388     // the buffer given to the stream will be deleted by it
 389     void SetOutputStreamBuffer(wxStreamBuffer *buffer);
 390     wxStreamBuffer *GetOutputStreamBuffer() const { return m_o_streambuf; }
 391
 392     // deprecated, for compatibility only
 393     wxStreamBuffer *OutputStreamBuffer() const { return m_o_streambuf; }
 394
 395 protected:
 396     virtual size_t OnSysWrite(const void *buffer, size_t bufsize);
 397     virtual off_t OnSysSeek(off_t seek, wxSeekMode mode);
 398     virtual off_t OnSysTell() const;
 399
 400     wxStreamBuffer *m_o_streambuf;
 401 };
 402
 403 #endif // wxUSE_STREAMS
 404
 405 #endif // _WX_WXSTREAM_H__
 406