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