class Zlib::GzipReader

Zlib::GzipReader ist die Klasse zum Lesen einer gzippten Datei. GzipReader sollte als IO- oder IO-ähnliches Objekt verwendet werden.

Zlib::GzipReader.open('hoge.gz') {|gz|
  print gz.read
}

File.open('hoge.gz') do |f|
  gz = Zlib::GzipReader.new(f)
  print gz.read
  gz.close
end

Methoden-Katalog

Die folgenden Methoden in Zlib::GzipReader sind wie ihre Gegenstücke in IO, aber sie lösen die Ausnahme Zlib::Error oder Zlib::GzipFile::Error aus, wenn ein Fehler in der gzip-Datei gefunden wurde.

Seien Sie vorsichtig beim Footer der gzip-Datei. Eine gzip-Datei hat die Prüfsumme der vorkomprimierten Daten in ihrem Footer. GzipReader überprüft alle unkomprimierten Daten gegen diese Prüfsumme in den folgenden Fällen und löst, wenn dies fehlschlägt, die Ausnahme Zlib::GzipFile::NoFooter, Zlib::GzipFile::CRCError oder Zlib::GzipFile::LengthError aus.

Wenn eine Leseanfrage über das Dateiende hinaus empfangen wird (das Ende der komprimierten Daten). Das heißt, wenn Zlib::GzipReader#read, Zlib::GzipReader#gets oder andere Lesemethoden nil zurückgeben.
Wenn die Methode Zlib::GzipFile#close aufgerufen wird, nachdem das Objekt das Dateiende erreicht hat.
Wenn die Methode Zlib::GzipReader#unused aufgerufen wird, nachdem das Objekt das Dateiende erreicht hat.

Die übrigen Methoden werden in ihrer eigenen Dokumentation ausreichend beschrieben.

Öffentliche Klassenmethoden

Zlib::GzipReader.new(io, options = {})

Source

static VALUE
rb_gzreader_initialize(int argc, VALUE *argv, VALUE obj)
{
    VALUE io, opt = Qnil;
    struct gzfile *gz;
    int err;

    TypedData_Get_Struct(obj, struct gzfile, &gzfile_data_type, gz);
    rb_scan_args(argc, argv, "1:", &io, &opt);

    /* this is undocumented feature of zlib */
    err = inflateInit2(&gz->z.stream, -MAX_WBITS);
    if (err != Z_OK) {
        raise_zlib_error(err, gz->z.stream.msg);
    }
    gz->io = io;
    ZSTREAM_READY(&gz->z);
    gzfile_read_header(gz, Qnil);
    rb_gzfile_ecopts(gz, opt);

    if (rb_respond_to(io, id_path)) {
        /* File#path may raise IOError in case when a path is unavailable */
        rb_rescue2(gzfile_initialize_path_partial, obj, NULL, Qnil, rb_eIOError, (VALUE)0);
    }

    return obj;
}

Erstellt ein GzipReader-Objekt, das mit io verknüpft ist. Der GzipReader liest gzippte Daten aus io und parst/dekomprimiert sie. io muss eine read-Methode haben, die sich genauso verhält wie die von IO#read.

Der options-Hash kann verwendet werden, um die Kodierung der Daten festzulegen. :external_encoding, :internal_encoding und :encoding können wie in IO::new gesetzt werden.

Wenn der Header der gzip-Datei fehlerhaft ist, wird eine Ausnahme Zlib::GzipFile::Error ausgelöst.

Zlib::GzipReader.open(filename) {|gz| ... }

Source

static VALUE
rb_gzreader_s_open(int argc, VALUE *argv, VALUE klass)
{
    return gzfile_s_open(argc, argv, klass, "rb");
}

Öffnet eine durch filename angegebene Datei als gzippte Datei und gibt ein GzipReader-Objekt zurück, das mit dieser Datei verknüpft ist. Weitere Details zu dieser Methode finden Sie unter Zlib::GzipReader.new und ZLib::GzipFile.wrap.

Zlib::GzipReader.zcat(io, options = {}, &block) → nil

Zlib::GzipReader.zcat(io, options = {}) → string

Source

static VALUE
rb_gzreader_s_zcat(int argc, VALUE *argv, VALUE klass)
{
    VALUE io, unused, obj, buf=0, tmpbuf;
    long pos;

    rb_check_arity(argc, 1, 2);
    io = argv[0];

    do {
        obj = rb_funcallv(klass, rb_intern("new"), argc, argv);
        if (rb_block_given_p()) {
           rb_gzreader_each(0, 0, obj);
        }
        else {
            if (!buf) {
                buf = rb_str_new(0, 0);
            }
            tmpbuf = gzfile_read_all(get_gzfile(obj), Qnil);
            rb_str_cat(buf, RSTRING_PTR(tmpbuf), RSTRING_LEN(tmpbuf));
        }

        rb_gzreader_read(0, 0, obj);
        pos = NUM2LONG(rb_funcall(io, rb_intern("pos"), 0));
        unused = rb_gzreader_unused(obj);
        rb_gzfile_finish(obj);
        if (!NIL_P(unused)) {
            pos -= NUM2LONG(rb_funcall(unused, rb_intern("length"), 0));
            rb_funcall(io, rb_intern("pos="), 1, LONG2NUM(pos));
        }
    } while (pos < NUM2LONG(rb_funcall(io, rb_intern("size"), 0)));

    if (rb_block_given_p()) {
        return Qnil;
    }
    return buf;
}

Dekomprimiert alle gzip-Daten im io und verarbeitet mehrere gzip-Streams bis zum Ende von io. Nach den gzip-Streams dürfen keine nicht-gzip-Daten vorhanden sein.

Wenn ein Block angegeben wird, werden Zeichenketten mit unkomprimierten Daten übergeben, und die Methode gibt nil zurück. Wenn kein Block angegeben wird, gibt die Methode die Verkettung aller unkomprimierten Daten in allen gzip-Streams zurück.

Öffentliche Instanzmethoden

each (*args)

Source

static VALUE
rb_gzreader_each(int argc, VALUE *argv, VALUE obj)
{
    VALUE str;

    RETURN_ENUMERATOR(obj, 0, 0);

    while (!NIL_P(str = gzreader_gets(argc, argv, obj))) {
        rb_yield(str);
    }
    return obj;
}

Siehe die Dokumentation von Zlib::GzipReader für eine Beschreibung.

Auch als each_line aliased.

each_byte ()

Source

static VALUE
rb_gzreader_each_byte(VALUE obj)
{
    VALUE c;

    RETURN_ENUMERATOR(obj, 0, 0);

    while (!NIL_P(c = rb_gzreader_getbyte(obj))) {
        rb_yield(c);
    }
    return Qnil;
}

Siehe die Dokumentation von Zlib::GzipReader für eine Beschreibung.

each_char ()

Source

static VALUE
rb_gzreader_each_char(VALUE obj)
{
    VALUE c;

    RETURN_ENUMERATOR(obj, 0, 0);

    while (!NIL_P(c = rb_gzreader_getc(obj))) {
        rb_yield(c);
    }
    return Qnil;
}

Siehe die Dokumentation von Zlib::GzipReader für eine Beschreibung.

each_line (*args)

Siehe die Dokumentation von Zlib::GzipReader für eine Beschreibung.

Alias für: each

eof ()

Source

static VALUE
rb_gzfile_eof_p(VALUE obj)
{
    struct gzfile *gz = get_gzfile(obj);
    while (!ZSTREAM_IS_FINISHED(&gz->z) && ZSTREAM_BUF_FILLED(&gz->z) == 0) {
        gzfile_read_more(gz, Qnil);
    }
    return GZFILE_IS_FINISHED(gz) ? Qtrue : Qfalse;
}

Gibt true oder false zurück, ob der Stream das Ende erreicht hat.

Auch als eof? aliased.

eof? ()

Gibt true oder false zurück, ob der Stream das Ende erreicht hat.

Alias für: eof

external_encoding ()

Source

static VALUE
rb_gzreader_external_encoding(VALUE self)
{
    return rb_enc_from_encoding(get_gzfile(self)->enc);
}

Siehe die Dokumentation von Zlib::GzipReader für eine Beschreibung.

getbyte ()

Source

static VALUE
rb_gzreader_getbyte(VALUE obj)
{
    struct gzfile *gz = get_gzfile(obj);
    VALUE dst;

    dst = gzfile_read(gz, 1, Qnil);
    if (!NIL_P(dst)) {
        dst = INT2FIX((unsigned int)(RSTRING_PTR(dst)[0]) & 0xff);
    }
    return dst;
}

Siehe die Dokumentation von Zlib::GzipReader für eine Beschreibung.

getc ()

Source

static VALUE
rb_gzreader_getc(VALUE obj)
{
    struct gzfile *gz = get_gzfile(obj);

    return gzfile_getc(gz);
}

Siehe die Dokumentation von Zlib::GzipReader für eine Beschreibung.

gets (*args)

Source

static VALUE
rb_gzreader_gets(int argc, VALUE *argv, VALUE obj)
{
    VALUE dst;
    dst = gzreader_gets(argc, argv, obj);
    if (!NIL_P(dst)) {
        rb_lastline_set(dst);
    }
    return dst;
}

Siehe die Dokumentation von Zlib::GzipReader für eine Beschreibung. Beachten Sie jedoch, dass diese Methode nil zurückgeben kann, auch wenn eof? false zurückgibt, im Gegensatz zum Verhalten von File#gets.

zeilennummer ()

Source

static VALUE
rb_gzfile_lineno(VALUE obj)
{
    return INT2NUM(get_gzfile(obj)->lineno);
}

Die Zeilennummer der letzten aus dieser Datei gelesenen Zeile.

lineno= (p1)

Source

static VALUE
rb_gzfile_set_lineno(VALUE obj, VALUE lineno)
{
    struct gzfile *gz = get_gzfile(obj);
    gz->lineno = NUM2INT(lineno);
    return lineno;
}

Legt die Zeilennummer der letzten aus dieser Datei gelesenen Zeile fest.

pos ()

Source

static VALUE
rb_gzfile_total_out(VALUE obj)
{
    struct gzfile *gz = get_gzfile(obj);
    uLong total_out = gz->z.stream.total_out;
    long buf_filled = ZSTREAM_BUF_FILLED(&gz->z);

    if (total_out >= (uLong)buf_filled) {
        return rb_uint2inum(total_out - buf_filled);
    } else {
        return LONG2FIX(-(buf_filled - (long)total_out));
    }
}

Gesamtzahl der bisher ausgegebenen Bytes.

Auch als tell aliased.

read (p1 = v1, p2 = v2)

Source

static VALUE
rb_gzreader_read(int argc, VALUE *argv, VALUE obj)
{
    struct gzfile *gz = get_gzfile(obj);
    VALUE vlen, outbuf;
    long len;

    rb_scan_args(argc, argv, "02", &vlen, &outbuf);
    if (NIL_P(vlen)) {
        return gzfile_read_all(gz, outbuf);
    }

    len = NUM2INT(vlen);
    if (len < 0) {
        rb_raise(rb_eArgError, "negative length %ld given", len);
    }
    return gzfile_read(gz, len, outbuf);
}

Siehe die Dokumentation von Zlib::GzipReader für eine Beschreibung.

readbyte ()

Source

static VALUE
rb_gzreader_readbyte(VALUE obj)
{
    VALUE dst;
    dst = rb_gzreader_getbyte(obj);
    if (NIL_P(dst)) {
        rb_raise(rb_eEOFError, "end of file reached");
    }
    return dst;
}

Siehe die Dokumentation von Zlib::GzipReader für eine Beschreibung.

readchar ()

Source

static VALUE
rb_gzreader_readchar(VALUE obj)
{
    VALUE dst;
    dst = rb_gzreader_getc(obj);
    if (NIL_P(dst)) {
        rb_raise(rb_eEOFError, "end of file reached");
    }
    return dst;
}

Siehe die Dokumentation von Zlib::GzipReader für eine Beschreibung.

readline (*args)

Source

static VALUE
rb_gzreader_readline(int argc, VALUE *argv, VALUE obj)
{
    VALUE dst;
    dst = rb_gzreader_gets(argc, argv, obj);
    if (NIL_P(dst)) {
        rb_raise(rb_eEOFError, "end of file reached");
    }
    return dst;
}

Siehe die Dokumentation von Zlib::GzipReader für eine Beschreibung.

readlines (*args)

Source

static VALUE
rb_gzreader_readlines(int argc, VALUE *argv, VALUE obj)
{
    VALUE str, dst;
    dst = rb_ary_new();
    while (!NIL_P(str = gzreader_gets(argc, argv, obj))) {
        rb_ary_push(dst, str);
    }
    return dst;
}

Siehe die Dokumentation von Zlib::GzipReader für eine Beschreibung.

readpartial(maxlen [, outbuf]) → string, outbuf

Source

static VALUE
rb_gzreader_readpartial(int argc, VALUE *argv, VALUE obj)
{
    struct gzfile *gz = get_gzfile(obj);
    VALUE vlen, outbuf;
    long len;

    rb_scan_args(argc, argv, "11", &vlen, &outbuf);

    len = NUM2INT(vlen);
    if (len < 0) {
        rb_raise(rb_eArgError, "negative length %ld given", len);
    }
    if (!NIL_P(outbuf))
        Check_Type(outbuf, T_STRING);
    return gzfile_readpartial(gz, len, outbuf);
}

Liest maximal maxlen Bytes aus dem gzippten Stream, blockiert aber nur, wenn gzipreader keine Daten sofort verfügbar hat. Wenn das optionale Argument outbuf vorhanden ist, muss es auf einen String verweisen, der die Daten empfängt. Löst EOFError am Dateiende aus.

rewind ()

Source

static VALUE
rb_gzreader_rewind(VALUE obj)
{
    struct gzfile *gz = get_gzfile(obj);
    gzfile_reader_rewind(gz);
    return INT2FIX(0);
}

Setzt die Position des Dateizeigers auf den Punkt zurück, an dem das GzipReader-Objekt erstellt wurde. Das zugehörige IO-Objekt muss auf die Methode seek reagieren.

tell ()

Gesamtzahl der bisher ausgegebenen Bytes.

Alias für: pos

ungetbyte (p1)

Source

static VALUE
rb_gzreader_ungetbyte(VALUE obj, VALUE ch)
{
    struct gzfile *gz = get_gzfile(obj);
    gzfile_ungetbyte(gz, NUM2CHR(ch));
    return Qnil;
}

Siehe die Dokumentation von Zlib::GzipReader für eine Beschreibung.

ungetc (p1)

Source

static VALUE
rb_gzreader_ungetc(VALUE obj, VALUE s)
{
    struct gzfile *gz;

    if (FIXNUM_P(s))
        return rb_gzreader_ungetbyte(obj, s);
    gz = get_gzfile(obj);
    StringValue(s);
    if (gz->enc2 && gz->enc2 != rb_ascii8bit_encoding()) {
        s = rb_str_conv_enc(s, rb_enc_get(s), gz->enc2);
    }
    gzfile_ungets(gz, (const Bytef*)RSTRING_PTR(s), RSTRING_LEN(s));
    RB_GC_GUARD(s);
    return Qnil;
}

Siehe die Dokumentation von Zlib::GzipReader für eine Beschreibung.

unused ()

Source

static VALUE
rb_gzreader_unused(VALUE obj)
{
    struct gzfile *gz;
    TypedData_Get_Struct(obj, struct gzfile, &gzfile_data_type, gz);
    return gzfile_reader_get_unused(gz);
}

Gibt die restlichen Daten zurück, die zum Parsen des gzip-Formats gelesen wurden, oder nil, wenn die gesamte gzip-Datei noch nicht geparst ist.