#include <stdexcept>
#include <string>
+#include <sigc++/trackable.h>
#include "base.h"
namespace Msp {
public:
zlib_error(const std::string &, int);
- ~zlib_error() throw() { }
+ virtual ~zlib_error() throw() = default;
int code() const throw() { return code_; }
};
To ensure proper termination of the compressed data stream, the ZlibCompressed
object must be destroyed before the underlying object is closed.
*/
-class ZlibCompressed: public Base
+class ZlibCompressed: public Base, public sigc::trackable
{
private:
struct Private;
Base &below;
- unsigned buffer_size;
- unsigned char *in_buffer;
- unsigned char *out_buffer;
- Private *priv;
+ std::size_t buffer_size = 1024;
+ unsigned char *in_buffer = 0;
+ unsigned char *out_buffer = 0;
+ bool stream_end = false;
+ Private *priv = 0;
public:
/** Creates a zlib de/compression object. The underlying object must be
open for reading or writing, not both. The level parameter determines
compression quality, ranging from 1 (fastest) to 9 (best compression). */
- ZlibCompressed(Base &, unsigned level = 9);
+ ZlibCompressed(Base &b, unsigned level = 9): ZlibCompressed(b, b.get_mode()&M_RDWR, level) { }
+
+ /** Creates a zlib de/compression object. Mode must be either read or
+ write, and compatible with the underlying object. */
+ ZlibCompressed(Base &, Mode, unsigned level = 9);
virtual ~ZlibCompressed();
+ virtual void set_block(bool);
+ virtual void set_inherit(bool);
+
void flush();
protected:
- virtual unsigned do_write(const char *, unsigned);
+ virtual std::size_t do_write(const char *, std::size_t);
private:
/** Compresses data and writes it to the underlying object. Returns true if
bool compress_data(int flush_mode);
public:
- virtual unsigned do_read(char *, unsigned);
+ virtual std::size_t do_read(char *, std::size_t);
+
+ virtual const Handle &get_handle(Mode);
};
} // namespace IO