Zlib::Deflate is the class for compressing data. See Zlib::Stream for more information.
Compresses the given string
. Valid values of level are
Zlib::NO_COMPRESSION
, Zlib::BEST_SPEED
,
Zlib::BEST_COMPRESSION
,
Zlib::DEFAULT_COMPRESSION
, and an integer from 0 to 9.
This method is almost equivalent to the following code:
def deflate(string, level) z = Zlib::Deflate.new(level) dst = z.deflate(string, Zlib::FINISH) z.close dst end
TODO: what’s default value of level
?
static VALUE rb_deflate_s_deflate(int argc, VALUE *argv, VALUE klass) { struct zstream z; VALUE src, level, dst, args[2]; int err, lev; rb_scan_args(argc, argv, "11", &src, &level); lev = ARG_LEVEL(level); StringValue(src); zstream_init_deflate(&z); err = deflateInit(&z.stream, lev); if (err != Z_OK) { raise_zlib_error(err, z.stream.msg); } ZSTREAM_READY(&z); args[0] = (VALUE)&z; args[1] = src; dst = rb_ensure(deflate_run, (VALUE)args, zstream_end, (VALUE)&z); OBJ_INFECT(dst, src); return dst; }
Creates a new deflate stream for compression. See zlib.h for details of each argument. If an argument is nil, the default value of that argument is used.
TODO: document better!
static VALUE rb_deflate_initialize(int argc, VALUE *argv, VALUE obj) { struct zstream *z; VALUE level, wbits, memlevel, strategy; int err; rb_scan_args(argc, argv, "04", &level, &wbits, &memlevel, &strategy); Data_Get_Struct(obj, struct zstream, z); err = deflateInit2(&z->stream, ARG_LEVEL(level), Z_DEFLATED, ARG_WBITS(wbits), ARG_MEMLEVEL(memlevel), ARG_STRATEGY(strategy)); if (err != Z_OK) { raise_zlib_error(err, z->stream.msg); } ZSTREAM_READY(z); return obj; }
Same as IO.
static VALUE rb_deflate_addstr(VALUE obj, VALUE src) { OBJ_INFECT(obj, src); do_deflate(get_zstream(obj), src, Z_NO_FLUSH); return obj; }
Inputs string
into the deflate stream and returns the output
from the stream. On calling this method, both the input and the output
buffers of the stream are flushed. If string
is nil, this
method finishes the stream, just like Zlib::ZStream#finish.
The value of flush
should be either
Zlib::NO_FLUSH
, Zlib::SYNC_FLUSH
,
Zlib::FULL_FLUSH
, or Zlib::FINISH
. See zlib.h for
details.
TODO: document better!
static VALUE rb_deflate_deflate(int argc, VALUE *argv, VALUE obj) { struct zstream *z = get_zstream(obj); VALUE src, flush, dst; rb_scan_args(argc, argv, "11", &src, &flush); OBJ_INFECT(obj, src); do_deflate(z, src, ARG_FLUSH(flush)); dst = zstream_detach_buffer(z); OBJ_INFECT(dst, obj); return dst; }
This method is equivalent to deflate('', flush)
. If flush is
omitted, Zlib::SYNC_FLUSH
is used as flush. This method is
just provided to improve the readability of your Ruby program.
TODO: document better!
static VALUE rb_deflate_flush(int argc, VALUE *argv, VALUE obj) { struct zstream *z = get_zstream(obj); VALUE v_flush, dst; int flush; rb_scan_args(argc, argv, "01", &v_flush); flush = FIXNUMARG(v_flush, Z_SYNC_FLUSH); if (flush != Z_NO_FLUSH) { /* prevent Z_BUF_ERROR */ zstream_run(z, (Bytef*)"", 0, flush); } dst = zstream_detach_buffer(z); OBJ_INFECT(dst, obj); return dst; }
Duplicates the deflate stream.
static VALUE rb_deflate_init_copy(VALUE self, VALUE orig) { struct zstream *z1, *z2; int err; Data_Get_Struct(self, struct zstream, z1); z2 = get_zstream(orig); err = deflateCopy(&z1->stream, &z2->stream); if (err != Z_OK) { raise_zlib_error(err, 0); } z1->input = NIL_P(z2->input) ? Qnil : rb_str_dup(z2->input); z1->buf = NIL_P(z2->buf) ? Qnil : rb_str_dup(z2->buf); z1->buf_filled = z2->buf_filled; z1->flags = z2->flags; return self; }
Changes the parameters of the deflate stream. See zlib.h for details. The output from the stream by changing the params is preserved in output buffer.
TODO: document better!
static VALUE rb_deflate_params(VALUE obj, VALUE v_level, VALUE v_strategy) { struct zstream *z = get_zstream(obj); int level, strategy; int err; level = ARG_LEVEL(v_level); strategy = ARG_STRATEGY(v_strategy); zstream_run(z, (Bytef*)"", 0, Z_SYNC_FLUSH); err = deflateParams(&z->stream, level, strategy); while (err == Z_BUF_ERROR) { rb_warning("deflateParams() returned Z_BUF_ERROR"); zstream_expand_buffer(z); err = deflateParams(&z->stream, level, strategy); } if (err != Z_OK) { raise_zlib_error(err, z->stream.msg); } return Qnil; }
Sets the preset dictionary and returns string
. This method is
available just only after ::new or
Zlib::ZStream#reset method was
called. See zlib.h for details.
TODO: document better!
static VALUE rb_deflate_set_dictionary(VALUE obj, VALUE dic) { struct zstream *z = get_zstream(obj); VALUE src = dic; int err; OBJ_INFECT(obj, dic); StringValue(src); err = deflateSetDictionary(&z->stream, (Bytef*)RSTRING_PTR(src), RSTRING_LEN(src)); if (err != Z_OK) { raise_zlib_error(err, z->stream.msg); } return dic; }
Commenting is here to help enhance the documentation. For example, code samples, or clarification of the documentation.
If you have questions about Ruby or the documentation, please post to one of the Ruby mailing lists. You will get better, faster, help that way.
If you wish to post a correction of the docs, please do so, but also file bug report so that it can be corrected for the next release. Thank you.
If you want to help improve the Ruby documentation, please visit Documenting-ruby.org.