home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / wxos2233.zip / wxOS2-2_3_3.zip / wxWindows-2.3.3 / include / wx / stream.h < prev    next >
C/C++ Source or Header  |  2002-08-31  |  13KB  |  407 lines
  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: stream.h,v 1.49 2002/08/31 11:29:11 GD Exp $
  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.  
  407.