class Zlib::Deflate

Zlib::Deflate ist die Klasse zum Komprimieren von Daten. Weitere Informationen finden Sie unter Zlib::ZStream.

Öffentliche Klassenmethoden

Source

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

    return dst;
}

Komprimiert den gegebenen string. Gültige Werte für level sind Zlib::NO_COMPRESSION, Zlib::BEST_SPEED, Zlib::BEST_COMPRESSION, Zlib::DEFAULT_COMPRESSION oder eine Ganzzahl von 0 bis 9.

Diese Methode ist fast äquivalent zum folgenden Code

def deflate(string, level)
  z = Zlib::Deflate.new(level)
  dst = z.deflate(string, Zlib::FINISH)
  z.close
  dst
end

Siehe auch Zlib.inflate

Zlib::Deflate.new(level=DEFAULT_COMPRESSION, window_bits=MAX_WBITS, mem_level=DEF_MEM_LEVEL, strategy=DEFAULT_STRATEGY)

Source

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);
    TypedData_Get_Struct(obj, struct zstream, &zstream_data_type, 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;
}

Erstellt einen neuen Deflate-Stream zur Komprimierung. Wenn ein Argument nil ist, wird der Standardwert dieses Arguments verwendet.

Das level legt die Komprimierungsstufe für den Deflate-Stream fest, zwischen 0 (keine Komprimierung) und 9 (beste Komprimierung). Die folgenden Konstanten wurden definiert, um den Code lesbarer zu machen

Zlib::DEFAULT_COMPRESSION
Zlib::NO_COMPRESSION
Zlib::BEST_SPEED
Zlib::BEST_COMPRESSION

Weitere Informationen finden Sie unter www.zlib.net/manual.html#Constants.

Die window_bits legt die Größe des Verlaufs-Puffers fest und sollte zwischen 8 und 15 liegen. Größere Werte dieses Parameters führen zu besserer Komprimierung auf Kosten des Speicherverbrauchs.

Die mem_level gibt an, wie viel Speicher für den internen Komprimierungszustand zugewiesen werden soll. 1 verwendet minimalen Speicher, ist aber langsam und reduziert das Komprimierungsverhältnis, während 9 maximalen Speicher für optimale Geschwindigkeit verwendet. Der Standardwert ist 8. Zwei Konstanten sind definiert

Zlib::DEF_MEM_LEVEL
Zlib::MAX_MEM_LEVEL

Die strategy legt die Deflate-Komprimierungsstrategie fest. Die folgenden Strategien sind verfügbar

Zlib::DEFAULT_STRATEGY: Für normale Daten
Zlib::FILTERED: Für von einem Filter oder Prädiktor erzeugte Daten
Zlib::FIXED: Verhindert dynamische Huffman-Codes
Zlib::HUFFMAN_ONLY: Verhindert String-Matching
Zlib::RLE: Entwickelt für bessere Komprimierung von PNG-Bilddaten

Siehe die Konstanten für weitere Beschreibungen.

Beispiele

Grundlegend

open "compressed.file", "w+" do |io|
  io << Zlib::Deflate.new.deflate(File.read("big.file"))
end

Benutzerdefinierte Komprimierung

open "compressed.file", "w+" do |compressed_io|
  deflate = Zlib::Deflate.new(Zlib::BEST_COMPRESSION,
                              Zlib::MAX_WBITS,
                              Zlib::MAX_MEM_LEVEL,
                              Zlib::HUFFMAN_ONLY)

  begin
    open "big.file" do |big_io|
      until big_io.eof? do
        compressed_io << zd.deflate(big_io.read(16384))
      end
    end
  ensure
    deflate.close
  end
end

Obwohl dieses Beispiel funktioniert, sollten Sie für die beste Optimierung die Flags für Ihre spezifischen Anforderungen an Zeit, Speicherverbrauch und Ausgaberaum überprüfen.

Öffentliche Instanzmethoden

<< string

Source

static VALUE
rb_deflate_addstr(VALUE obj, VALUE src)
{
    do_deflate(get_zstream(obj), src, Z_NO_FLUSH);
    return obj;
}

Gibt den string in den Deflate-Stream ein, genau wie Zlib::Deflate#deflate, gibt aber das Zlib::Deflate-Objekt selbst zurück. Die Ausgabe aus dem Stream wird im Ausgabepuffer gespeichert.

deflate(string, flush = Zlib::NO_FLUSH) → String

deflate(string, flush = Zlib::NO_FLUSH) { |chunk| ... } → nil

Source

static VALUE
rb_deflate_deflate(int argc, VALUE *argv, VALUE obj)
{
    struct zstream *z = get_zstream(obj);
    VALUE src, flush;
    rb_scan_args(argc, argv, "11", &src, &flush);
    struct rb_zlib_deflate_arguments arguments = {z, src, ARG_FLUSH(flush)};

    return rb_mutex_synchronize(z->mutex, rb_deflate_deflate_body, (VALUE)&arguments);
}

Gibt den string in den Deflate-Stream ein und gibt die Ausgabe aus dem Stream zurück. Nach dem Aufruf dieser Methode werden sowohl die Eingabe- als auch die Ausgabepuffer des Streams geleert. Wenn string nil ist, beendet diese Methode den Stream, genau wie Zlib::ZStream#finish.

Wenn ein Block gegeben ist, werden aufeinanderfolgende deflate-Chunks aus dem string an den Block übergeben und nil wird zurückgegeben.

Der Parameter flush gibt den Flush-Modus an. Die folgenden Konstanten können verwendet werden

Zlib::NO_FLUSH: Der Standardwert
Zlib::SYNC_FLUSH: Leert die Ausgabe bis zu einer Bytegrenze
Zlib::FULL_FLUSH: SYNC_FLUSH + setzt den Komprimierungszustand zurück
Zlib::FINISH: Ausstehende Eingaben werden verarbeitet, ausstehende Ausgaben werden geleert.

Siehe die Konstanten für weitere Beschreibungen.

flush(flush = Zlib::SYNC_FLUSH) → String

flush(flush = Zlib::SYNC_FLUSH) { |chunk| ... } → nil

Source

static VALUE
rb_deflate_flush(int argc, VALUE *argv, VALUE obj)
{
    struct zstream *z = get_zstream(obj);
    VALUE v_flush;
    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);
    }

    return zstream_detach_buffer(z);
}

Diese Methode ist äquivalent zu deflate('', flush). Diese Methode wird nur bereitgestellt, um die Lesbarkeit Ihres Ruby-Programms zu verbessern. Wenn ein Block gegeben ist, werden Chunks der Deflate-Ausgabe an den Block übergeben, bis der Puffer geleert ist.

Siehe Zlib::Deflate#deflate für Details zu den flush-Konstanten NO_FLUSH, SYNC_FLUSH, FULL_FLUSH und FINISH.

initialize_copy (p1)

Source

static VALUE
rb_deflate_init_copy(VALUE self, VALUE orig)
{
    struct zstream *z1, *z2;
    int err;

    TypedData_Get_Struct(self, struct zstream, &zstream_data_type, z1);
    z2 = get_zstream(orig);

    if (z1 == z2) return self;
    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->flags = z2->flags;

    return self;
}

Dupliziert den Deflate-Stream.

params(level, strategy)

Source

static VALUE
rb_deflate_params(VALUE obj, VALUE v_level, VALUE v_strategy)
{
    struct zstream *z = get_zstream(obj);
    int level, strategy;
    int err;
    uInt n;
    long filled;

    level = ARG_LEVEL(v_level);
    strategy = ARG_STRATEGY(v_strategy);

    n = z->stream.avail_out;
    err = deflateParams(&z->stream, level, strategy);
    filled = n - z->stream.avail_out;
    while (err == Z_BUF_ERROR) {
        rb_warning("deflateParams() returned Z_BUF_ERROR");
        zstream_expand_buffer(z);
        rb_str_set_len(z->buf, RSTRING_LEN(z->buf) + filled);
        n = z->stream.avail_out;
        err = deflateParams(&z->stream, level, strategy);
        filled = n - z->stream.avail_out;
    }
    if (err != Z_OK) {
        raise_zlib_error(err, z->stream.msg);
    }
    rb_str_set_len(z->buf, RSTRING_LEN(z->buf) + filled);

    return Qnil;
}

Ändert die Parameter des Deflate-Streams, um Änderungen zwischen verschiedenen Datentypen zu ermöglichen, die unterschiedliche Komprimierungsarten erfordern. Alle unverarbeiteten Daten werden geleert, bevor die Parameter geändert werden.

Siehe Zlib::Deflate.new für eine Beschreibung von level und strategy.

set_dictionary(string)

Source

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

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

    return dic;
}

Legt das vordefinierte Wörterbuch fest und gibt string zurück. Diese Methode ist nur verfügbar, nachdem die Methode Zlib::Deflate.new oder Zlib::ZStream#reset aufgerufen wurde. Siehe zlib.h für Details.

Kann Fehler werfen wie Z_STREAM_ERROR, wenn ein Parameter ungültig ist (z. B. NULL-Wörterbuch) oder der Stream-Zustand inkonsistent ist, Z_DATA_ERROR, wenn das gegebene Wörterbuch nicht dem erwarteten entspricht (falscher Adler32-Wert)