#include "wx/string.h"
#include "wx/filefn.h" // for wxFileOffset, wxInvalidOffset and wxSeekMode
-class WXDLLIMPEXP_BASE wxStreamBase;
-class WXDLLIMPEXP_BASE wxInputStream;
-class WXDLLIMPEXP_BASE wxOutputStream;
+class WXDLLIMPEXP_FWD_BASE wxStreamBase;
+class WXDLLIMPEXP_FWD_BASE wxInputStream;
+class WXDLLIMPEXP_FWD_BASE wxOutputStream;
typedef wxInputStream& (*__wxInputManip)(wxInputStream&);
typedef wxOutputStream& (*__wxOutputManip)(wxOutputStream&);
wxSTREAM_READ_ERROR // generic read error
};
+const int wxEOF = -1;
+
// ============================================================================
// base stream classes: wxInputStream and wxOutputStream
// ============================================================================
// wxStreamBase: common (but non virtual!) base for all stream classes
// ---------------------------------------------------------------------------
-class WXDLLIMPEXP_BASE wxStreamBase
+class WXDLLIMPEXP_BASE wxStreamBase : public wxObject
{
public:
wxStreamBase();
friend class wxStreamBuffer;
- DECLARE_NO_COPY_CLASS(wxStreamBase)
+ DECLARE_ABSTRACT_CLASS(wxStreamBase)
+ wxDECLARE_NO_COPY_CLASS(wxStreamBase);
};
// ----------------------------------------------------------------------------
// undefined), otherwise 1
virtual char Peek();
- // return one character from the stream, blocking until it appears if
+ // return one byte from the stream, blocking until it appears if
// necessary
//
- // if EOF, return value is undefined and LastRead() will return 0 and not 1
- char GetC();
+ // on success returns a value between 0 - 255, or wxEOF on EOF or error.
+ int GetC();
// read at most the given number of bytes from the stream
//
friend class wxStreamBuffer;
- DECLARE_NO_COPY_CLASS(wxInputStream)
+ DECLARE_ABSTRACT_CLASS(wxInputStream)
+ wxDECLARE_NO_COPY_CLASS(wxInputStream);
};
// ----------------------------------------------------------------------------
friend class wxStreamBuffer;
- DECLARE_NO_COPY_CLASS(wxOutputStream)
+ DECLARE_ABSTRACT_CLASS(wxOutputStream)
+ wxDECLARE_NO_COPY_CLASS(wxOutputStream);
};
// ============================================================================
size_t m_currentPos;
- DECLARE_NO_COPY_CLASS(wxCountingOutputStream)
+ DECLARE_DYNAMIC_CLASS(wxCountingOutputStream)
+ wxDECLARE_NO_COPY_CLASS(wxCountingOutputStream);
};
// ---------------------------------------------------------------------------
wxInputStream *m_parent_i_stream;
bool m_owns;
- DECLARE_NO_COPY_CLASS(wxFilterInputStream)
+ DECLARE_ABSTRACT_CLASS(wxFilterInputStream)
+ wxDECLARE_NO_COPY_CLASS(wxFilterInputStream);
};
class WXDLLIMPEXP_BASE wxFilterOutputStream : public wxOutputStream
wxOutputStream *m_parent_o_stream;
bool m_owns;
- DECLARE_NO_COPY_CLASS(wxFilterOutputStream)
+ DECLARE_ABSTRACT_CLASS(wxFilterOutputStream)
+ wxDECLARE_NO_COPY_CLASS(wxFilterOutputStream);
};
enum wxStreamProtocolType
{
- wxSTREAM_PROTOCOL, // wxFileSystem protocol (should be only one)
- wxSTREAM_MIMETYPE, // Mime types the stream handles
- wxSTREAM_ENCODING, // The http Content-Encodings the stream handles
- wxSTREAM_FILEEXTENSION // File extensions the stream handles
+ wxSTREAM_PROTOCOL, // wxFileSystem protocol (should be only one)
+ wxSTREAM_MIMETYPE, // MIME types the stream handles
+ wxSTREAM_ENCODING, // The HTTP Content-Encodings the stream handles
+ wxSTREAM_FILEEXT // File extensions the stream handles
};
void WXDLLIMPEXP_BASE wxUseFilterClasses();
virtual const wxChar * const *GetProtocols(wxStreamProtocolType type
= wxSTREAM_PROTOCOL) const = 0;
- bool CanHandle(const wxChar *protocol,
+ bool CanHandle(const wxString& protocol,
wxStreamProtocolType type
= wxSTREAM_PROTOCOL) const;
protected:
- wxString::size_type FindExtension(const wxChar *location) const;
+ wxString::size_type FindExtension(const wxString& location) const;
DECLARE_ABSTRACT_CLASS(wxFilterClassFactoryBase)
};
virtual wxFilterInputStream *NewStream(wxInputStream *stream) const = 0;
virtual wxFilterOutputStream *NewStream(wxOutputStream *stream) const = 0;
- static const wxFilterClassFactory *Find(const wxChar *protocol,
+ static const wxFilterClassFactory *Find(const wxString& protocol,
wxStreamProtocolType type
= wxSTREAM_PROTOCOL);
read_write
};
- wxStreamBuffer(wxStreamBase& stream, BufMode mode);
+ wxStreamBuffer(wxStreamBase& stream, BufMode mode)
+ {
+ InitWithStream(stream, mode);
+ }
+
+ wxStreamBuffer(size_t bufsize, wxInputStream& stream)
+ {
+ InitWithStream(stream, read);
+ SetBufferIO(bufsize);
+ }
+
+ wxStreamBuffer(size_t bufsize, wxOutputStream& stream)
+ {
+ InitWithStream(stream, write);
+ SetBufferIO(bufsize);
+ }
+
wxStreamBuffer(const wxStreamBuffer& buf);
virtual ~wxStreamBuffer();
// Buffer control
void ResetBuffer();
+ void Truncate();
// NB: the buffer must always be allocated with malloc() if takeOwn is
// true as it will be deallocated by free()
void *GetBufferStart() const { return m_buffer_start; }
void *GetBufferEnd() const { return m_buffer_end; }
void *GetBufferPos() const { return m_buffer_pos; }
- size_t GetBufferSize() const { return m_buffer_size; }
+ size_t GetBufferSize() const { return m_buffer_end - m_buffer_start; }
size_t GetIntPosition() const { return m_buffer_pos - m_buffer_start; }
void SetIntPosition(size_t pos) { m_buffer_pos = m_buffer_start + pos; }
size_t GetLastAccess() const { return m_buffer_end - m_buffer_start; }
// misc accessors
wxStreamBase *GetStream() const { return m_stream; }
- bool HasBuffer() const { return m_buffer_size != 0; }
+ bool HasBuffer() const { return m_buffer_start != m_buffer_end; }
bool IsFixed() const { return m_fixed; }
bool IsFlushable() const { return m_flushable; }
// common part of several ctors
void Init();
+ // common part of ctors taking wxStreamBase parameter
+ void InitWithStream(wxStreamBase& stream, BufMode mode);
+
// init buffer variables to be empty
void InitBuffer();
*m_buffer_end,
*m_buffer_pos;
- // the buffer size
- // FIXME: isn't it the same as m_buffer_end - m_buffer_start? (VZ)
- size_t m_buffer_size;
-
// the stream we're associated with
wxStreamBase *m_stream;
m_fixed,
m_flushable;
-private:
-// Cannot use
-// DECLARE_NO_COPY_CLASS(wxStreamBuffer)
-// because copy constructor is explicitly declared above;
-// but no copy assignment operator is defined, so declare
-// it private to prevent the compiler from defining it:
- wxStreamBuffer& operator=(const wxStreamBuffer&);
+
+ wxDECLARE_NO_ASSIGN_CLASS(wxStreamBuffer);
};
// ---------------------------------------------------------------------------
class WXDLLIMPEXP_BASE wxBufferedInputStream : public wxFilterInputStream
{
public:
- // if a non NULL buffer is given to the stream, it will be deleted by it
+ // create a buffered stream on top of the specified low-level stream
+ //
+ // if a non NULL buffer is given to the stream, it will be deleted by it,
+ // otherwise a default 1KB buffer will be used
wxBufferedInputStream(wxInputStream& stream,
wxStreamBuffer *buffer = NULL);
+
+ // ctor allowing to specify the buffer size, it's just a more convenient
+ // alternative to creating wxStreamBuffer, calling its SetBufferIO(bufsize)
+ // and using the ctor above
+ wxBufferedInputStream(wxInputStream& stream, size_t bufsize);
+
+
virtual ~wxBufferedInputStream();
char Peek();
wxStreamBuffer *m_i_streambuf;
- DECLARE_NO_COPY_CLASS(wxBufferedInputStream)
+ wxDECLARE_NO_COPY_CLASS(wxBufferedInputStream);
};
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_BASE wxBufferedOutputStream : public wxFilterOutputStream
{
public:
- // if a non NULL buffer is given to the stream, it will be deleted by it
+ // create a buffered stream on top of the specified low-level stream
+ //
+ // if a non NULL buffer is given to the stream, it will be deleted by it,
+ // otherwise a default 1KB buffer will be used
wxBufferedOutputStream(wxOutputStream& stream,
wxStreamBuffer *buffer = NULL);
+
+ // ctor allowing to specify the buffer size, it's just a more convenient
+ // alternative to creating wxStreamBuffer, calling its SetBufferIO(bufsize)
+ // and using the ctor above
+ wxBufferedOutputStream(wxOutputStream& stream, size_t bufsize);
+
virtual ~wxBufferedOutputStream();
wxOutputStream& Write(const void *buffer, size_t size);
wxStreamBuffer *m_o_streambuf;
- DECLARE_NO_COPY_CLASS(wxBufferedOutputStream)
+ wxDECLARE_NO_COPY_CLASS(wxBufferedOutputStream);
};
#if WXWIN_COMPATIBILITY_2_6
projects / wxWidgets.git / blobdiff