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