class Zlib::Inflate

Zlib:Inflate ist die Klasse zur Dekompression komprimierter Daten. Im Gegensatz zu Zlib::Deflate kann eine Instanz dieser Klasse sich nicht selbst duplizieren (klonen, dup).

Öffentliche Klassenmethoden

inflate(string)

Zlib::Inflate.inflate(string)

Source

static VALUE
rb_inflate_s_inflate(VALUE obj, VALUE 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_ensure_end, (VALUE)&z);

    return dst;
}

Dekomprimiert string. Löst eine Zlib::NeedDict-Ausnahme aus, wenn ein voreingestelltes Wörterbuch für die Dekompression benötigt wird.

Diese Methode ist fast äquivalent zum folgenden Code

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

Siehe auch Zlib.deflate

Zlib::Inflate.new(window_bits = Zlib::MAX_WBITS)

Source

static VALUE
rb_inflate_initialize(int argc, VALUE *argv, VALUE obj)
{
    struct zstream *z;
    VALUE wbits;
    int err;

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

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

    return obj;
}

Erstellt einen neuen Inflate-Stream zur Dekompression. window_bits legt die Größe des Verlaufs-Puffers fest und kann folgende Werte annehmen

0

Verwendet die Fenstergröße aus dem zlib-Header des komprimierten Streams.

(8..15)

Überschreibt die Fenstergröße des Inflate-Headers im komprimierten Stream. Die Fenstergröße muss größer oder gleich der Fenstergröße des komprimierten Streams sein.

Größer als 15

Addiere 32 zu window_bits, um zlib und gzip-Dekodierung mit automatischer Header-Erkennung zu aktivieren, oder addiere 16, um nur das gzip-Format zu dekodieren (eine Zlib::DataError wird für einen Nicht-gzip-Stream ausgelöst).

(-8..-15)

Aktiviert den Raw-Deflate-Modus, der keinen Prüfwert generiert und am Ende des Streams keine Prüfwerte zum Vergleich sucht.

Dies ist für die Verwendung mit anderen Formaten, die das komprimierte Datenformat Deflate verwenden, wie z. B. zip, das eigene Prüfwerte bereitstellt.

Beispiel

open "compressed.file" do |compressed_io|
  zi = Zlib::Inflate.new(Zlib::MAX_WBITS + 32)

  begin
    open "uncompressed.file", "w+" do |uncompressed_io|
      uncompressed_io << zi.inflate(compressed_io.read)
    end
  ensure
    zi.close
  end
end

Öffentliche Instanzmethoden

<< (p1)

Source

static VALUE
rb_inflate_addstr(VALUE obj, VALUE src)
{
    struct zstream *z = get_zstream(obj);

    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;
}

Gleich wie IO.

add_dictionary(string)

Source

static VALUE
rb_inflate_add_dictionary(VALUE obj, VALUE dictionary)
{
    VALUE dictionaries = rb_ivar_get(obj, id_dictionaries);
    VALUE checksum = do_checksum(1, &dictionary, adler32);

    rb_hash_aset(dictionaries, checksum, dictionary);

    return obj;
}

Stellt dem Inflate-Stream ein Wörterbuch zur Verfügung, das zukünftig benötigt werden könnte. Mehrere Wörterbücher können bereitgestellt werden. Der Inflate-Stream wählt automatisch das richtige vom Benutzer bereitgestellte Wörterbuch basierend auf dem benötigten Wörterbuch des Streams aus.

inflate(deflate_string, buffer: nil) → String

inflate(deflate_string, buffer: nil) { |chunk| ... } → nil

Source

static VALUE
rb_inflate_inflate(int argc, VALUE* argv, VALUE obj)
{
    struct zstream *z = get_zstream(obj);
    struct rb_zlib_inflate_arguments arguments = {z, argc, argv};
    return rb_mutex_synchronize(z->mutex, rb_inflate_inflate_body, (VALUE)&arguments);
}

Führt deflate_string in den Inflate-Stream ein und gibt die Ausgabe aus dem Stream zurück. Durch den Aufruf dieser Methode werden sowohl der Eingangs- als auch der Ausgangspuffer des Streams geleert. Wenn string nil ist, beendet diese Methode den Stream, genau wie Zlib::ZStream#finish.

Wenn ein Block gegeben ist, werden aufeinanderfolgende dekomprimierte Blöcke aus deflate_string an den Block übergeben und nil zurückgegeben.

Wenn ein `:buffer`-Schlüsselwortargument gegeben und nicht nil ist

Das `:buffer`-Schlüsselwort sollte ein String sein und wird als Ausgabe-Puffer verwendet. Die Verwendung dieser Option kann den während der Inflation benötigten Speicher wiederverwenden.
Wenn kein Block übergeben wird, ist der Rückgabewert dasselbe Objekt wie das `:buffer`-Schlüsselwortargument.
Wenn ein Block übergeben wird, sind die übergebenen Blöcke derselbe Wert wie das `:buffer`-Schlüsselwortargument.

Löst eine Zlib::NeedDict-Ausnahme aus, wenn ein voreingestelltes Wörterbuch zur Dekompression benötigt wird. Setze das Wörterbuch mit Zlib::Inflate#set_dictionary und rufe dann diese Methode erneut mit einem leeren String auf, um den Stream zu leeren.

inflater = Zlib::Inflate.new

begin
  out = inflater.inflate compressed
rescue Zlib::NeedDict
  # ensure the dictionary matches the stream's required dictionary
  raise unless inflater.adler == Zlib.adler32(dictionary)

  inflater.set_dictionary dictionary
  inflater.inflate ''
end

# ...

inflater.close

Siehe auch Zlib::Inflate.new

set_dictionary (p1)

Source

static VALUE
rb_inflate_set_dictionary(VALUE obj, VALUE dic)
{
    struct zstream *z = get_zstream(obj);
    VALUE src = dic;
    int err;

    StringValue(src);
    err = inflateSetDictionary(&z->stream,
                               (Bytef*)RSTRING_PTR(src), RSTRING_LENINT(src));
    if (err != Z_OK) {
        raise_zlib_error(err, z->stream.msg);
    }

    return dic;
}

Setzt das voreingestellte Wörterbuch und gibt string zurück. Diese Methode ist nur verfügbar, nachdem eine Zlib::NeedDict-Ausnahme ausgelöst wurde. Details siehe zlib.h.

sync(string)

Source

static VALUE
rb_inflate_sync(VALUE obj, VALUE src)
{
    struct zstream *z = get_zstream(obj);

    StringValue(src);
    return zstream_sync(z, (Bytef*)RSTRING_PTR(src), RSTRING_LEN(src));
}

Führt string in das Ende des Eingabepuffers ein und überspringt Daten, bis ein vollständiger Flush-Punkt gefunden wird. Wenn der Punkt im Puffer gefunden wird, leert diese Methode den Puffer und gibt false zurück. Andernfalls gibt sie true zurück und die folgenden Daten des vollständigen Flush-Punkts werden im Puffer beibehalten.

sync_point? ()

Source

static VALUE
rb_inflate_sync_point_p(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;
}

Wörtlich aus der Originaldokumentation zitiert

What is this?

:)