Class | Zlib::Inflate
In: | zlib/zlib.c
Parent: | Zlib::ZStream

Zlib:Inflate is the class for decompressing compressed data. Unlike Zlib::Deflate, an instance of this class is not able to duplicate (clone, dup) itself.

### Methods

<< inflate inflate new set_dictionary sync sync_point?

### Public Class methods

Zlib::Inflate.inflate(string)

Decompresses `string`. Raises a Zlib::NeedDict exception if a preset dictionary is needed for decompression.

This method is almost equivalent to the following code:

      def inflate(string)
        zstream = Zlib::Inflate.new
        buf = zstream.inflate(string)
        zstream.finish
        zstream.close
        buf
      end

[Source]

    /*
     * call-seq: Zlib::Inflate.inflate(string)
     *
     * Decompresses +string+. Raises a Zlib::NeedDict exception if a preset
     * dictionary is needed for decompression.
     *
     * This method is almost equivalent to the following code:
     *
     *   def inflate(string)
     *     zstream = Zlib::Inflate.new
     *     buf = zstream.inflate(string)
     *     zstream.finish
     *     zstream.close
     *     buf
     *   end
     *
     */
    static VALUE
    rb_inflate_s_inflate(obj, src)
        VALUE obj, src;
    {
        struct zstream z;
        VALUE dst, args[2];
        int err;

        StringValue(src);
        zstream_init_inflate(&z);
        err = inflateInit(&z.stream);
        if (err != Z_OK) {
    	raise_zlib_error(err, z.stream.msg);
        }
        ZSTREAM_READY(&z);

        args[0] = (VALUE)&z;
        args[1] = src;
        dst = rb_ensure(inflate_run, (VALUE)args, zstream_end, (VALUE)&z);

        OBJ_INFECT(dst, src);
        return dst;
    }

Zlib::Inflate.new(window_bits)

Creates a new inflate stream for decompression. See zlib.h for details of the argument. If `window_bits` is `nil`, the default value is used.

TODO: document better!

[Source]

    /*
     * call-seq: Zlib::Inflate.new(window_bits)
     *
     * Creates a new inflate stream for decompression. See zlib.h for details
     * of the argument.  If +window_bits+ is +nil+, the default value is used.
     *
     * TODO: document better!
     */
    static VALUE
    rb_inflate_initialize(argc, argv, obj)
        int argc;
        VALUE *argv;
        VALUE obj;
    {
        struct zstream *z;
        VALUE wbits;
        int err;

        rb_scan_args(argc, argv, "01", &wbits);
        Data_Get_Struct(obj, struct zstream, z);

        err = inflateInit2(&z->stream, ARG_WBITS(wbits));
        if (err != Z_OK) {
    	raise_zlib_error(err, z->stream.msg);
        }
        ZSTREAM_READY(z);

        return obj;
    }

### Public Instance methods

<<(p1)

Same as IO.

[Source]

    /*
     * call-seq: << string
     *
     * Inputs +string+ into the inflate stream just like Zlib::Inflate#inflate, but
     * returns the Zlib::Inflate object itself.  The output from the stream is
     * preserved in output buffer.
     */
    static VALUE
    rb_inflate_addstr(obj, src)
        VALUE obj, src;
    {
        struct zstream *z = get_zstream(obj);

        OBJ_INFECT(obj, src);

        if (ZSTREAM_IS_FINISHED(z)) {
    	if (!NIL_P(src)) {
    	    StringValue(src);
    	    zstream_append_buffer2(z, src);
    	}
        }
        else {
    	do_inflate(z, src);
    	if (ZSTREAM_IS_FINISHED(z)) {
    	    zstream_passthrough_input(z);
    	}
        }

        return obj;
    }

inflate(string)

Inputs `string` into the inflate stream and returns the output from the stream. Calling this method, both the input and the output buffer of the stream are flushed. If string is `nil`, this method finishes the stream, just like Zlib::ZStream#finish.

Raises a Zlib::NeedDict exception if a preset dictionary is needed to decompress. Set the dictionary by Zlib::Inflate#set_dictionary and then call this method again with an empty string. (???)

TODO: document better!

[Source]

    /*
     * call-seq: inflate(string)
     *
     * Inputs +string+ into the inflate stream and returns the output from the
     * stream.  Calling this method, both the input and the output buffer of the
     * stream are flushed.  If string is +nil+, this method finishes the stream,
     * just like Zlib::ZStream#finish.
     *
     * Raises a Zlib::NeedDict exception if a preset dictionary is needed to
     * decompress.  Set the dictionary by Zlib::Inflate#set_dictionary and then
     * call this method again with an empty string.  (<i>???</i>)
     *
     * TODO: document better!
     */
    static VALUE
    rb_inflate_inflate(obj, src)
        VALUE obj, src;
    {
        struct zstream *z = get_zstream(obj);
        VALUE dst;

        OBJ_INFECT(obj, src);

        if (ZSTREAM_IS_FINISHED(z)) {
    	if (NIL_P(src)) {
    	    dst = zstream_detach_buffer(z);
    	}
    	else {
    	    StringValue(src);
    	    zstream_append_buffer2(z, src);
    	    dst = rb_str_new(0, 0);
    	}
        }
        else {
    	do_inflate(z, src);
    	dst = zstream_detach_buffer(z);
    	if (ZSTREAM_IS_FINISHED(z)) {
    	    zstream_passthrough_input(z);
    	}
        }

        OBJ_INFECT(dst, obj);
        return dst;
    }

set_dictionary(p1)

Sets the preset dictionary and returns `string`. This method is available just only after a Zlib::NeedDict exception was raised. See zlib.h for details.

TODO: document better!

[Source]

    /*
     * Sets the preset dictionary and returns +string+.  This method is available just
     * only after a Zlib::NeedDict exception was raised.  See zlib.h for details.
     *
     * TODO: document better!
     */
    static VALUE
    rb_inflate_set_dictionary(obj, dic)
        VALUE obj, dic;
    {
        struct zstream *z = get_zstream(obj);
        VALUE src = dic;
        int err;

        OBJ_INFECT(obj, dic);
        StringValue(src);
        err = inflateSetDictionary(&z->stream,
    			       RSTRING(src)->ptr, RSTRING(src)->len);
        if (err != Z_OK) {
    	raise_zlib_error(err, z->stream.msg);
        }

        return dic;
    }

sync(string)

Inputs `string` into the end of input buffer and skips data until a full flush point can be found. If the point is found in the buffer, this method flushes the buffer and returns false. Otherwise it returns `true` and the following data of full flush point is preserved in the buffer.

[Source]

    /*
     * call-seq: sync(string)
     *
     * Inputs +string+ into the end of input buffer and skips data until a full
     * flush point can be found.  If the point is found in the buffer, this method
     * flushes the buffer and returns false.  Otherwise it returns +true+ and the
     * following data of full flush point is preserved in the buffer.
     */
    static VALUE
    rb_inflate_sync(obj, src)
        VALUE obj, src;
    {
        struct zstream *z = get_zstream(obj);

        OBJ_INFECT(obj, src);
        StringValue(src);
        return zstream_sync(z, RSTRING(src)->ptr, RSTRING(src)->len);
    }

sync_point?()

Quoted verbatim from original documentation:

      What is this?

`:)`

[Source]

    /*
     * Quoted verbatim from original documentation:
     *
     *   What is this?
     *
     * <tt>:)</tt>
     */
    static VALUE
    rb_inflate_sync_point_p(obj)
        VALUE obj;
    {
        struct zstream *z = get_zstream(obj);
        int err;

        err = inflateSyncPoint(&z->stream);
        if (err == 1) {
    	return Qtrue;
        }
        if (err != Z_OK) {
    	raise_zlib_error(err, z->stream.msg);
        }
        return Qfalse;
    }

[Validate]