| 1 | ///////////////////////////////////////////////////////////////////////////// |
| 2 | // Name: wx/stream.h |
| 3 | // Purpose: stream classes |
| 4 | // Author: Guilhem Lavaux, Guillermo Rodriguez Garcia, Vadim Zeitlin |
| 5 | // Modified by: |
| 6 | // Created: 11/07/98 |
| 7 | // RCS-ID: $Id$ |
| 8 | // Copyright: (c) Guilhem Lavaux |
| 9 | // Licence: wxWindows licence |
| 10 | ///////////////////////////////////////////////////////////////////////////// |
| 11 | |
| 12 | #ifndef _WX_WXSTREAM_H__ |
| 13 | #define _WX_WXSTREAM_H__ |
| 14 | |
| 15 | #include "wx/defs.h" |
| 16 | |
| 17 | #if wxUSE_STREAMS |
| 18 | |
| 19 | #include <stdio.h> |
| 20 | #include "wx/object.h" |
| 21 | #include "wx/string.h" |
| 22 | #include "wx/filefn.h" // for wxFileOffset, wxInvalidOffset and wxSeekMode |
| 23 | |
| 24 | class WXDLLIMPEXP_FWD_BASE wxStreamBase; |
| 25 | class WXDLLIMPEXP_FWD_BASE wxInputStream; |
| 26 | class WXDLLIMPEXP_FWD_BASE wxOutputStream; |
| 27 | |
| 28 | typedef wxInputStream& (*__wxInputManip)(wxInputStream&); |
| 29 | typedef wxOutputStream& (*__wxOutputManip)(wxOutputStream&); |
| 30 | |
| 31 | WXDLLIMPEXP_BASE wxOutputStream& wxEndL(wxOutputStream& o_stream); |
| 32 | |
| 33 | // ---------------------------------------------------------------------------- |
| 34 | // constants |
| 35 | // ---------------------------------------------------------------------------- |
| 36 | |
| 37 | enum wxStreamError |
| 38 | { |
| 39 | wxSTREAM_NO_ERROR = 0, // stream is in good state |
| 40 | wxSTREAM_EOF, // EOF reached in Read() or similar |
| 41 | wxSTREAM_WRITE_ERROR, // generic write error |
| 42 | wxSTREAM_READ_ERROR // generic read error |
| 43 | }; |
| 44 | |
| 45 | const int wxEOF = -1; |
| 46 | |
| 47 | // ============================================================================ |
| 48 | // base stream classes: wxInputStream and wxOutputStream |
| 49 | // ============================================================================ |
| 50 | |
| 51 | // --------------------------------------------------------------------------- |
| 52 | // wxStreamBase: common (but non virtual!) base for all stream classes |
| 53 | // --------------------------------------------------------------------------- |
| 54 | |
| 55 | class WXDLLIMPEXP_BASE wxStreamBase : public wxObject |
| 56 | { |
| 57 | public: |
| 58 | wxStreamBase(); |
| 59 | virtual ~wxStreamBase(); |
| 60 | |
| 61 | // error testing |
| 62 | wxStreamError GetLastError() const { return m_lasterror; } |
| 63 | virtual bool IsOk() const { return GetLastError() == wxSTREAM_NO_ERROR; } |
| 64 | bool operator!() const { return !IsOk(); } |
| 65 | |
| 66 | // reset the stream state |
| 67 | void Reset() { m_lasterror = wxSTREAM_NO_ERROR; } |
| 68 | |
| 69 | // this doesn't make sense for all streams, always test its return value |
| 70 | virtual size_t GetSize() const; |
| 71 | virtual wxFileOffset GetLength() const { return wxInvalidOffset; } |
| 72 | |
| 73 | // returns true if the streams supports seeking to arbitrary offsets |
| 74 | virtual bool IsSeekable() const { return false; } |
| 75 | |
| 76 | protected: |
| 77 | virtual wxFileOffset OnSysSeek(wxFileOffset seek, wxSeekMode mode); |
| 78 | virtual wxFileOffset OnSysTell() const; |
| 79 | |
| 80 | size_t m_lastcount; |
| 81 | wxStreamError m_lasterror; |
| 82 | |
| 83 | friend class wxStreamBuffer; |
| 84 | |
| 85 | DECLARE_ABSTRACT_CLASS(wxStreamBase) |
| 86 | DECLARE_NO_COPY_CLASS(wxStreamBase) |
| 87 | }; |
| 88 | |
| 89 | // ---------------------------------------------------------------------------- |
| 90 | // wxInputStream: base class for the input streams |
| 91 | // ---------------------------------------------------------------------------- |
| 92 | |
| 93 | class WXDLLIMPEXP_BASE wxInputStream : public wxStreamBase |
| 94 | { |
| 95 | public: |
| 96 | // ctor and dtor, nothing exciting |
| 97 | wxInputStream(); |
| 98 | virtual ~wxInputStream(); |
| 99 | |
| 100 | |
| 101 | // IO functions |
| 102 | // ------------ |
| 103 | |
| 104 | // return a character from the stream without removing it, i.e. it will |
| 105 | // still be returned by the next call to GetC() |
| 106 | // |
| 107 | // blocks until something appears in the stream if necessary, if nothing |
| 108 | // ever does (i.e. EOF) LastRead() will return 0 (and the return value is |
| 109 | // undefined), otherwise 1 |
| 110 | virtual char Peek(); |
| 111 | |
| 112 | // return one byte from the stream, blocking until it appears if |
| 113 | // necessary |
| 114 | // |
| 115 | // on success returns a value between 0 - 255, or wxEOF on EOF or error. |
| 116 | int GetC(); |
| 117 | |
| 118 | // read at most the given number of bytes from the stream |
| 119 | // |
| 120 | // there are 2 possible situations here: either there is nothing at all in |
| 121 | // the stream right now in which case Read() blocks until something appears |
| 122 | // (use CanRead() to avoid this) or there is already some data available in |
| 123 | // the stream and then Read() doesn't block but returns just the data it |
| 124 | // can read without waiting for more |
| 125 | // |
| 126 | // in any case, if there are not enough bytes in the stream right now, |
| 127 | // LastRead() value will be less than size but greater than 0. If it is 0, |
| 128 | // it means that EOF has been reached. |
| 129 | virtual wxInputStream& Read(void *buffer, size_t size); |
| 130 | |
| 131 | // copy the entire contents of this stream into streamOut, stopping only |
| 132 | // when EOF is reached or an error occurs |
| 133 | wxInputStream& Read(wxOutputStream& streamOut); |
| 134 | |
| 135 | |
| 136 | // status functions |
| 137 | // ---------------- |
| 138 | |
| 139 | // returns the number of bytes read by the last call to Read(), GetC() or |
| 140 | // Peek() |
| 141 | // |
| 142 | // this should be used to discover whether that call succeeded in reading |
| 143 | // all the requested data or not |
| 144 | virtual size_t LastRead() const { return wxStreamBase::m_lastcount; } |
| 145 | |
| 146 | // returns true if some data is available in the stream right now, so that |
| 147 | // calling Read() wouldn't block |
| 148 | virtual bool CanRead() const; |
| 149 | |
| 150 | // is the stream at EOF? |
| 151 | // |
| 152 | // note that this cannot be really implemented for all streams and |
| 153 | // CanRead() is more reliable than Eof() |
| 154 | virtual bool Eof() const; |
| 155 | |
| 156 | |
| 157 | // write back buffer |
| 158 | // ----------------- |
| 159 | |
| 160 | // put back the specified number of bytes into the stream, they will be |
| 161 | // fetched by the next call to the read functions |
| 162 | // |
| 163 | // returns the number of bytes really stuffed back |
| 164 | size_t Ungetch(const void *buffer, size_t size); |
| 165 | |
| 166 | // put back the specified character in the stream |
| 167 | // |
| 168 | // returns true if ok, false on error |
| 169 | bool Ungetch(char c); |
| 170 | |
| 171 | |
| 172 | // position functions |
| 173 | // ------------------ |
| 174 | |
| 175 | // move the stream pointer to the given position (if the stream supports |
| 176 | // it) |
| 177 | // |
| 178 | // returns wxInvalidOffset on error |
| 179 | virtual wxFileOffset SeekI(wxFileOffset pos, wxSeekMode mode = wxFromStart); |
| 180 | |
| 181 | // return the current position of the stream pointer or wxInvalidOffset |
| 182 | virtual wxFileOffset TellI() const; |
| 183 | |
| 184 | |
| 185 | // stream-like operators |
| 186 | // --------------------- |
| 187 | |
| 188 | wxInputStream& operator>>(wxOutputStream& out) { return Read(out); } |
| 189 | wxInputStream& operator>>(__wxInputManip func) { return func(*this); } |
| 190 | |
| 191 | protected: |
| 192 | // do read up to size bytes of data into the provided buffer |
| 193 | // |
| 194 | // this method should return 0 if EOF has been reached or an error occurred |
| 195 | // (m_lasterror should be set accordingly as well) or the number of bytes |
| 196 | // read |
| 197 | virtual size_t OnSysRead(void *buffer, size_t size) = 0; |
| 198 | |
| 199 | // write-back buffer support |
| 200 | // ------------------------- |
| 201 | |
| 202 | // return the pointer to a buffer big enough to hold sizeNeeded bytes |
| 203 | char *AllocSpaceWBack(size_t sizeNeeded); |
| 204 | |
| 205 | // read up to size data from the write back buffer, return the number of |
| 206 | // bytes read |
| 207 | size_t GetWBack(void *buf, size_t size); |
| 208 | |
| 209 | // write back buffer or NULL if none |
| 210 | char *m_wback; |
| 211 | |
| 212 | // the size of the buffer |
| 213 | size_t m_wbacksize; |
| 214 | |
| 215 | // the current position in the buffer |
| 216 | size_t m_wbackcur; |
| 217 | |
| 218 | friend class wxStreamBuffer; |
| 219 | |
| 220 | DECLARE_ABSTRACT_CLASS(wxInputStream) |
| 221 | DECLARE_NO_COPY_CLASS(wxInputStream) |
| 222 | }; |
| 223 | |
| 224 | // ---------------------------------------------------------------------------- |
| 225 | // wxOutputStream: base for the output streams |
| 226 | // ---------------------------------------------------------------------------- |
| 227 | |
| 228 | class WXDLLIMPEXP_BASE wxOutputStream : public wxStreamBase |
| 229 | { |
| 230 | public: |
| 231 | wxOutputStream(); |
| 232 | virtual ~wxOutputStream(); |
| 233 | |
| 234 | void PutC(char c); |
| 235 | virtual wxOutputStream& Write(const void *buffer, size_t size); |
| 236 | wxOutputStream& Write(wxInputStream& stream_in); |
| 237 | |
| 238 | virtual wxFileOffset SeekO(wxFileOffset pos, wxSeekMode mode = wxFromStart); |
| 239 | virtual wxFileOffset TellO() const; |
| 240 | |
| 241 | virtual size_t LastWrite() const { return wxStreamBase::m_lastcount; } |
| 242 | |
| 243 | virtual void Sync(); |
| 244 | virtual bool Close() { return true; } |
| 245 | |
| 246 | wxOutputStream& operator<<(wxInputStream& out) { return Write(out); } |
| 247 | wxOutputStream& operator<<( __wxOutputManip func) { return func(*this); } |
| 248 | |
| 249 | protected: |
| 250 | // to be implemented in the derived classes (it should have been pure |
| 251 | // virtual) |
| 252 | virtual size_t OnSysWrite(const void *buffer, size_t bufsize); |
| 253 | |
| 254 | friend class wxStreamBuffer; |
| 255 | |
| 256 | DECLARE_ABSTRACT_CLASS(wxOutputStream) |
| 257 | DECLARE_NO_COPY_CLASS(wxOutputStream) |
| 258 | }; |
| 259 | |
| 260 | // ============================================================================ |
| 261 | // helper stream classes |
| 262 | // ============================================================================ |
| 263 | |
| 264 | // --------------------------------------------------------------------------- |
| 265 | // A stream for measuring streamed output |
| 266 | // --------------------------------------------------------------------------- |
| 267 | |
| 268 | class WXDLLIMPEXP_BASE wxCountingOutputStream : public wxOutputStream |
| 269 | { |
| 270 | public: |
| 271 | wxCountingOutputStream(); |
| 272 | |
| 273 | wxFileOffset GetLength() const; |
| 274 | bool Ok() const { return IsOk(); } |
| 275 | bool IsOk() const { return true; } |
| 276 | |
| 277 | protected: |
| 278 | virtual size_t OnSysWrite(const void *buffer, size_t size); |
| 279 | virtual wxFileOffset OnSysSeek(wxFileOffset pos, wxSeekMode mode); |
| 280 | virtual wxFileOffset OnSysTell() const; |
| 281 | |
| 282 | size_t m_currentPos; |
| 283 | |
| 284 | DECLARE_DYNAMIC_CLASS(wxCountingOutputStream) |
| 285 | DECLARE_NO_COPY_CLASS(wxCountingOutputStream) |
| 286 | }; |
| 287 | |
| 288 | // --------------------------------------------------------------------------- |
| 289 | // "Filter" streams |
| 290 | // --------------------------------------------------------------------------- |
| 291 | |
| 292 | class WXDLLIMPEXP_BASE wxFilterInputStream : public wxInputStream |
| 293 | { |
| 294 | public: |
| 295 | wxFilterInputStream(); |
| 296 | wxFilterInputStream(wxInputStream& stream); |
| 297 | wxFilterInputStream(wxInputStream *stream); |
| 298 | virtual ~wxFilterInputStream(); |
| 299 | |
| 300 | char Peek() { return m_parent_i_stream->Peek(); } |
| 301 | |
| 302 | wxFileOffset GetLength() const { return m_parent_i_stream->GetLength(); } |
| 303 | |
| 304 | wxInputStream *GetFilterInputStream() const { return m_parent_i_stream; } |
| 305 | |
| 306 | protected: |
| 307 | wxInputStream *m_parent_i_stream; |
| 308 | bool m_owns; |
| 309 | |
| 310 | DECLARE_ABSTRACT_CLASS(wxFilterInputStream) |
| 311 | DECLARE_NO_COPY_CLASS(wxFilterInputStream) |
| 312 | }; |
| 313 | |
| 314 | class WXDLLIMPEXP_BASE wxFilterOutputStream : public wxOutputStream |
| 315 | { |
| 316 | public: |
| 317 | wxFilterOutputStream(); |
| 318 | wxFilterOutputStream(wxOutputStream& stream); |
| 319 | wxFilterOutputStream(wxOutputStream *stream); |
| 320 | virtual ~wxFilterOutputStream(); |
| 321 | |
| 322 | wxFileOffset GetLength() const { return m_parent_o_stream->GetLength(); } |
| 323 | |
| 324 | wxOutputStream *GetFilterOutputStream() const { return m_parent_o_stream; } |
| 325 | |
| 326 | bool Close(); |
| 327 | |
| 328 | protected: |
| 329 | wxOutputStream *m_parent_o_stream; |
| 330 | bool m_owns; |
| 331 | |
| 332 | DECLARE_ABSTRACT_CLASS(wxFilterOutputStream) |
| 333 | DECLARE_NO_COPY_CLASS(wxFilterOutputStream) |
| 334 | }; |
| 335 | |
| 336 | enum wxStreamProtocolType |
| 337 | { |
| 338 | wxSTREAM_PROTOCOL, // wxFileSystem protocol (should be only one) |
| 339 | wxSTREAM_MIMETYPE, // MIME types the stream handles |
| 340 | wxSTREAM_ENCODING, // The HTTP Content-Encodings the stream handles |
| 341 | wxSTREAM_FILEEXT // File extensions the stream handles |
| 342 | }; |
| 343 | |
| 344 | void WXDLLIMPEXP_BASE wxUseFilterClasses(); |
| 345 | |
| 346 | class WXDLLIMPEXP_BASE wxFilterClassFactoryBase : public wxObject |
| 347 | { |
| 348 | public: |
| 349 | virtual ~wxFilterClassFactoryBase() { } |
| 350 | |
| 351 | wxString GetProtocol() const { return wxString(*GetProtocols()); } |
| 352 | wxString PopExtension(const wxString& location) const; |
| 353 | |
| 354 | virtual const wxChar * const *GetProtocols(wxStreamProtocolType type |
| 355 | = wxSTREAM_PROTOCOL) const = 0; |
| 356 | |
| 357 | bool CanHandle(const wxString& protocol, |
| 358 | wxStreamProtocolType type |
| 359 | = wxSTREAM_PROTOCOL) const; |
| 360 | |
| 361 | protected: |
| 362 | wxString::size_type FindExtension(const wxString& location) const; |
| 363 | |
| 364 | DECLARE_ABSTRACT_CLASS(wxFilterClassFactoryBase) |
| 365 | }; |
| 366 | |
| 367 | class WXDLLIMPEXP_BASE wxFilterClassFactory : public wxFilterClassFactoryBase |
| 368 | { |
| 369 | public: |
| 370 | virtual ~wxFilterClassFactory() { } |
| 371 | |
| 372 | virtual wxFilterInputStream *NewStream(wxInputStream& stream) const = 0; |
| 373 | virtual wxFilterOutputStream *NewStream(wxOutputStream& stream) const = 0; |
| 374 | virtual wxFilterInputStream *NewStream(wxInputStream *stream) const = 0; |
| 375 | virtual wxFilterOutputStream *NewStream(wxOutputStream *stream) const = 0; |
| 376 | |
| 377 | static const wxFilterClassFactory *Find(const wxString& protocol, |
| 378 | wxStreamProtocolType type |
| 379 | = wxSTREAM_PROTOCOL); |
| 380 | |
| 381 | static const wxFilterClassFactory *GetFirst(); |
| 382 | const wxFilterClassFactory *GetNext() const { return m_next; } |
| 383 | |
| 384 | void PushFront() { Remove(); m_next = sm_first; sm_first = this; } |
| 385 | void Remove(); |
| 386 | |
| 387 | protected: |
| 388 | wxFilterClassFactory() : m_next(this) { } |
| 389 | |
| 390 | wxFilterClassFactory& operator=(const wxFilterClassFactory&) |
| 391 | { return *this; } |
| 392 | |
| 393 | private: |
| 394 | static wxFilterClassFactory *sm_first; |
| 395 | wxFilterClassFactory *m_next; |
| 396 | |
| 397 | DECLARE_ABSTRACT_CLASS(wxFilterClassFactory) |
| 398 | }; |
| 399 | |
| 400 | // ============================================================================ |
| 401 | // buffered streams |
| 402 | // ============================================================================ |
| 403 | |
| 404 | // --------------------------------------------------------------------------- |
| 405 | // Stream buffer: this class can be derived from and passed to |
| 406 | // wxBufferedStreams to implement custom buffering |
| 407 | // --------------------------------------------------------------------------- |
| 408 | |
| 409 | class WXDLLIMPEXP_BASE wxStreamBuffer |
| 410 | { |
| 411 | public: |
| 412 | enum BufMode |
| 413 | { |
| 414 | read, |
| 415 | write, |
| 416 | read_write |
| 417 | }; |
| 418 | |
| 419 | wxStreamBuffer(wxStreamBase& stream, BufMode mode); |
| 420 | wxStreamBuffer(const wxStreamBuffer& buf); |
| 421 | virtual ~wxStreamBuffer(); |
| 422 | |
| 423 | // Filtered IO |
| 424 | virtual size_t Read(void *buffer, size_t size); |
| 425 | size_t Read(wxStreamBuffer *buf); |
| 426 | virtual size_t Write(const void *buffer, size_t size); |
| 427 | size_t Write(wxStreamBuffer *buf); |
| 428 | |
| 429 | virtual char Peek(); |
| 430 | virtual char GetChar(); |
| 431 | virtual void PutChar(char c); |
| 432 | virtual wxFileOffset Tell() const; |
| 433 | virtual wxFileOffset Seek(wxFileOffset pos, wxSeekMode mode); |
| 434 | |
| 435 | // Buffer control |
| 436 | void ResetBuffer(); |
| 437 | void Truncate(); |
| 438 | |
| 439 | // NB: the buffer must always be allocated with malloc() if takeOwn is |
| 440 | // true as it will be deallocated by free() |
| 441 | void SetBufferIO(void *start, void *end, bool takeOwnership = false); |
| 442 | void SetBufferIO(void *start, size_t len, bool takeOwnership = false); |
| 443 | void SetBufferIO(size_t bufsize); |
| 444 | void *GetBufferStart() const { return m_buffer_start; } |
| 445 | void *GetBufferEnd() const { return m_buffer_end; } |
| 446 | void *GetBufferPos() const { return m_buffer_pos; } |
| 447 | size_t GetBufferSize() const { return m_buffer_size; } |
| 448 | size_t GetIntPosition() const { return m_buffer_pos - m_buffer_start; } |
| 449 | void SetIntPosition(size_t pos) { m_buffer_pos = m_buffer_start + pos; } |
| 450 | size_t GetLastAccess() const { return m_buffer_end - m_buffer_start; } |
| 451 | size_t GetBytesLeft() const { return m_buffer_end - m_buffer_pos; } |
| 452 | |
| 453 | void Fixed(bool fixed) { m_fixed = fixed; } |
| 454 | void Flushable(bool f) { m_flushable = f; } |
| 455 | |
| 456 | bool FlushBuffer(); |
| 457 | bool FillBuffer(); |
| 458 | size_t GetDataLeft(); |
| 459 | |
| 460 | // misc accessors |
| 461 | wxStreamBase *GetStream() const { return m_stream; } |
| 462 | bool HasBuffer() const { return m_buffer_size != 0; } |
| 463 | |
| 464 | bool IsFixed() const { return m_fixed; } |
| 465 | bool IsFlushable() const { return m_flushable; } |
| 466 | |
| 467 | // only for input/output buffers respectively, returns NULL otherwise |
| 468 | wxInputStream *GetInputStream() const; |
| 469 | wxOutputStream *GetOutputStream() const; |
| 470 | |
| 471 | #if WXWIN_COMPATIBILITY_2_6 |
| 472 | // deprecated, for compatibility only |
| 473 | wxDEPRECATED( wxStreamBase *Stream() ); |
| 474 | #endif // WXWIN_COMPATIBILITY_2_6 |
| 475 | |
| 476 | // this constructs a dummy wxStreamBuffer, used by (and exists for) |
| 477 | // wxMemoryStreams only, don't use! |
| 478 | wxStreamBuffer(BufMode mode); |
| 479 | |
| 480 | protected: |
| 481 | void GetFromBuffer(void *buffer, size_t size); |
| 482 | void PutToBuffer(const void *buffer, size_t size); |
| 483 | |
| 484 | // set the last error to the specified value if we didn't have it before |
| 485 | void SetError(wxStreamError err); |
| 486 | |
| 487 | // common part of several ctors |
| 488 | void Init(); |
| 489 | |
| 490 | // init buffer variables to be empty |
| 491 | void InitBuffer(); |
| 492 | |
| 493 | // free the buffer (always safe to call) |
| 494 | void FreeBuffer(); |
| 495 | |
| 496 | // the buffer itself: the pointers to its start and end and the current |
| 497 | // position in the buffer |
| 498 | char *m_buffer_start, |
| 499 | *m_buffer_end, |
| 500 | *m_buffer_pos; |
| 501 | |
| 502 | // the buffer size |
| 503 | // FIXME: isn't it the same as m_buffer_end - m_buffer_start? (VZ) |
| 504 | size_t m_buffer_size; |
| 505 | |
| 506 | // the stream we're associated with |
| 507 | wxStreamBase *m_stream; |
| 508 | |
| 509 | // its mode |
| 510 | BufMode m_mode; |
| 511 | |
| 512 | // flags |
| 513 | bool m_destroybuf, // deallocate buffer? |
| 514 | m_fixed, |
| 515 | m_flushable; |
| 516 | |
| 517 | private: |
| 518 | // Cannot use |
| 519 | // DECLARE_NO_COPY_CLASS(wxStreamBuffer) |
| 520 | // because copy constructor is explicitly declared above; |
| 521 | // but no copy assignment operator is defined, so declare |
| 522 | // it private to prevent the compiler from defining it: |
| 523 | wxStreamBuffer& operator=(const wxStreamBuffer&); |
| 524 | }; |
| 525 | |
| 526 | // --------------------------------------------------------------------------- |
| 527 | // wxBufferedInputStream |
| 528 | // --------------------------------------------------------------------------- |
| 529 | |
| 530 | class WXDLLIMPEXP_BASE wxBufferedInputStream : public wxFilterInputStream |
| 531 | { |
| 532 | public: |
| 533 | // if a non NULL buffer is given to the stream, it will be deleted by it |
| 534 | wxBufferedInputStream(wxInputStream& stream, |
| 535 | wxStreamBuffer *buffer = NULL); |
| 536 | virtual ~wxBufferedInputStream(); |
| 537 | |
| 538 | char Peek(); |
| 539 | wxInputStream& Read(void *buffer, size_t size); |
| 540 | |
| 541 | // Position functions |
| 542 | wxFileOffset SeekI(wxFileOffset pos, wxSeekMode mode = wxFromStart); |
| 543 | wxFileOffset TellI() const; |
| 544 | bool IsSeekable() const { return m_parent_i_stream->IsSeekable(); } |
| 545 | |
| 546 | // the buffer given to the stream will be deleted by it |
| 547 | void SetInputStreamBuffer(wxStreamBuffer *buffer); |
| 548 | wxStreamBuffer *GetInputStreamBuffer() const { return m_i_streambuf; } |
| 549 | |
| 550 | #if WXWIN_COMPATIBILITY_2_6 |
| 551 | // deprecated, for compatibility only |
| 552 | wxDEPRECATED( wxStreamBuffer *InputStreamBuffer() const ); |
| 553 | #endif // WXWIN_COMPATIBILITY_2_6 |
| 554 | |
| 555 | protected: |
| 556 | virtual size_t OnSysRead(void *buffer, size_t bufsize); |
| 557 | virtual wxFileOffset OnSysSeek(wxFileOffset seek, wxSeekMode mode); |
| 558 | virtual wxFileOffset OnSysTell() const; |
| 559 | |
| 560 | wxStreamBuffer *m_i_streambuf; |
| 561 | |
| 562 | DECLARE_NO_COPY_CLASS(wxBufferedInputStream) |
| 563 | }; |
| 564 | |
| 565 | // ---------------------------------------------------------------------------- |
| 566 | // wxBufferedOutputStream |
| 567 | // ---------------------------------------------------------------------------- |
| 568 | |
| 569 | class WXDLLIMPEXP_BASE wxBufferedOutputStream : public wxFilterOutputStream |
| 570 | { |
| 571 | public: |
| 572 | // if a non NULL buffer is given to the stream, it will be deleted by it |
| 573 | wxBufferedOutputStream(wxOutputStream& stream, |
| 574 | wxStreamBuffer *buffer = NULL); |
| 575 | virtual ~wxBufferedOutputStream(); |
| 576 | |
| 577 | wxOutputStream& Write(const void *buffer, size_t size); |
| 578 | |
| 579 | // Position functions |
| 580 | wxFileOffset SeekO(wxFileOffset pos, wxSeekMode mode = wxFromStart); |
| 581 | wxFileOffset TellO() const; |
| 582 | bool IsSeekable() const { return m_parent_o_stream->IsSeekable(); } |
| 583 | |
| 584 | void Sync(); |
| 585 | bool Close(); |
| 586 | |
| 587 | wxFileOffset GetLength() const; |
| 588 | |
| 589 | // the buffer given to the stream will be deleted by it |
| 590 | void SetOutputStreamBuffer(wxStreamBuffer *buffer); |
| 591 | wxStreamBuffer *GetOutputStreamBuffer() const { return m_o_streambuf; } |
| 592 | |
| 593 | #if WXWIN_COMPATIBILITY_2_6 |
| 594 | // deprecated, for compatibility only |
| 595 | wxDEPRECATED( wxStreamBuffer *OutputStreamBuffer() const ); |
| 596 | #endif // WXWIN_COMPATIBILITY_2_6 |
| 597 | |
| 598 | protected: |
| 599 | virtual size_t OnSysWrite(const void *buffer, size_t bufsize); |
| 600 | virtual wxFileOffset OnSysSeek(wxFileOffset seek, wxSeekMode mode); |
| 601 | virtual wxFileOffset OnSysTell() const; |
| 602 | |
| 603 | wxStreamBuffer *m_o_streambuf; |
| 604 | |
| 605 | DECLARE_NO_COPY_CLASS(wxBufferedOutputStream) |
| 606 | }; |
| 607 | |
| 608 | #if WXWIN_COMPATIBILITY_2_6 |
| 609 | inline wxStreamBase *wxStreamBuffer::Stream() { return m_stream; } |
| 610 | inline wxStreamBuffer *wxBufferedInputStream::InputStreamBuffer() const { return m_i_streambuf; } |
| 611 | inline wxStreamBuffer *wxBufferedOutputStream::OutputStreamBuffer() const { return m_o_streambuf; } |
| 612 | #endif // WXWIN_COMPATIBILITY_2_6 |
| 613 | |
| 614 | #endif // wxUSE_STREAMS |
| 615 | |
| 616 | #endif // _WX_WXSTREAM_H__ |