Class: Zlib::GzipFile

Inherits:
Object show all
Defined in:
ext/zlib/zlib.c,
ext/zlib/zlib.c

Overview

Zlib::GzipFile is an abstract class for handling a gzip formatted compressed file. The operations are defined in the subclasses, Zlib::GzipReader for reading, and Zlib::GzipWriter for writing.

GzipReader should be used by associating an IO, or IO-like, object.

Method Catalogue

  • ::wrap

  • ::open (Zlib::GzipReader::open and Zlib::GzipWriter::open)

  • #close

  • #closed?

  • #comment

  • comment= (Zlib::GzipWriter#comment=)

  • #crc

  • eof? (Zlib::GzipReader#eof?)

  • #finish

  • #level

  • lineno (Zlib::GzipReader#lineno)

  • lineno= (Zlib::GzipReader#lineno=)

  • #mtime

  • mtime= (Zlib::GzipWriter#mtime=)

  • #orig_name

  • orig_name (Zlib::GzipWriter#orig_name=)

  • #os_code

  • path (when the underlying IO supports #path)

  • #sync

  • #sync=

  • #to_io

(due to internal structure, documentation may appear under Zlib::GzipReader or Zlib::GzipWriter)

Direct Known Subclasses

GzipReader, GzipWriter

Defined Under Namespace

Classes: CRCError, Error, LengthError, NoFooter

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.wrap(*args) ⇒ Object

call-seq:

Zlib::GzipReader.wrap(io, ...) { |gz| ... }
Zlib::GzipWriter.wrap(io, ...) { |gz| ... }

Creates a GzipReader or GzipWriter associated with io, passing in any necessary extra options, and executes the block with the newly created object just like File.open.

The GzipFile object will be closed automatically after executing the block. If you want to keep the associated IO object open, you may call Zlib::GzipFile#finish method in the block.



3223
3224
3225
3226
3227
 
# File 'ext/zlib/zlib.c', line 3223

static VALUE
rb_gzfile_s_wrap(int argc, VALUE *argv, VALUE klass)
{
    return gzfile_wrap(argc, argv, klass, 0);
}

Instance Method Details

#close ⇒ Object

Closes the GzipFile object. This method calls close method of the associated IO object. Returns the associated IO object.



3447
3448
3449
3450
3451
3452
3453
3454
3455
3456
3457
3458
3459
3460
 
# File 'ext/zlib/zlib.c', line 3447

static VALUE
rb_gzfile_close(VALUE obj)
{
    struct gzfile *gz;
    VALUE io;

    TypedData_Get_Struct(obj, struct gzfile, &gzfile_data_type, gz);
    if (!ZSTREAM_IS_READY(&gz->z)) {
        return Qnil;
    }
    io = gz->io;
    gzfile_close(gz, 1);
    return io;
}

#closed? ⇒ Boolean

Same as IO#closed?

Returns:

  • (Boolean) 


3486
3487
3488
3489
3490
3491
3492
 
# File 'ext/zlib/zlib.c', line 3486

static VALUE
rb_gzfile_closed_p(VALUE obj)
{
    struct gzfile *gz;
    TypedData_Get_Struct(obj, struct gzfile, &gzfile_data_type, gz);
    return NIL_P(gz->io) ? Qtrue : Qfalse;
}

#comment ⇒ Object

Returns comments recorded in the gzip file header, or nil if the comments is not present.



3323
3324
3325
3326
3327
3328
3329
3330
3331
 
# File 'ext/zlib/zlib.c', line 3323

static VALUE
rb_gzfile_comment(VALUE obj)
{
    VALUE str = get_gzfile(obj)->comment;
    if (!NIL_P(str)) {
	str = rb_str_dup(str);
    }
    return str;
}

#crc ⇒ Object

Returns CRC value of the uncompressed data.



3262
3263
3264
3265
3266
 
# File 'ext/zlib/zlib.c', line 3262

static VALUE
rb_gzfile_crc(VALUE obj)
{
    return rb_uint2inum(get_gzfile(obj)->crc);
}

#finish ⇒ Object

Closes the GzipFile object. Unlike Zlib::GzipFile#close, this method never calls the close method of the associated IO object. Returns the associated IO object.



3469
3470
3471
3472
3473
3474
3475
3476
3477
3478
 
# File 'ext/zlib/zlib.c', line 3469

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

    io = gz->io;
    gzfile_close(gz, 0);
    return io;
}

#level ⇒ Object

Returns compression level.



3284
3285
3286
3287
3288
 
# File 'ext/zlib/zlib.c', line 3284

static VALUE
rb_gzfile_level(VALUE obj)
{
    return INT2FIX(get_gzfile(obj)->level);
}

#mtime ⇒ Object

Returns last modification time recorded in the gzip file header.



3273
3274
3275
3276
3277
 
# File 'ext/zlib/zlib.c', line 3273

static VALUE
rb_gzfile_mtime(VALUE obj)
{
    return rb_time_new(get_gzfile(obj)->mtime, (time_t)0);
}

#orig_name ⇒ Object

Returns original filename recorded in the gzip file header, or nil if original filename is not present.



3307
3308
3309
3310
3311
3312
3313
3314
3315
 
# File 'ext/zlib/zlib.c', line 3307

static VALUE
rb_gzfile_orig_name(VALUE obj)
{
    VALUE str = get_gzfile(obj)->orig_name;
    if (!NIL_P(str)) {
	str = rb_str_dup(str);
    }
    return str;
}

#os_code ⇒ Object

Returns OS code number recorded in the gzip file header.



3295
3296
3297
3298
3299
 
# File 'ext/zlib/zlib.c', line 3295

static VALUE
rb_gzfile_os_code(VALUE obj)
{
    return INT2FIX(get_gzfile(obj)->os_code);
}

#sync ⇒ Object

Same as IO#sync



3512
3513
3514
3515
3516
 
# File 'ext/zlib/zlib.c', line 3512

static VALUE
rb_gzfile_sync(VALUE obj)
{
    return (get_gzfile(obj)->z.flags & GZFILE_FLAG_SYNC) ? Qtrue : Qfalse;
}

#sync=(mode) ⇒ Object

call-seq: sync = flag

Same as IO. If flag is true, the associated IO object must respond to the flush method. While sync mode is true, the compression ratio decreases sharply.



3527
3528
3529
3530
3531
3532
3533
3534
3535
3536
3537
3538
3539
 
# File 'ext/zlib/zlib.c', line 3527

static VALUE
rb_gzfile_set_sync(VALUE obj, VALUE mode)
{
    struct gzfile *gz = get_gzfile(obj);

    if (RTEST(mode)) {
	gz->z.flags |= GZFILE_FLAG_SYNC;
    }
    else {
	gz->z.flags &= ~GZFILE_FLAG_SYNC;
    }
    return mode;
}

#to_io ⇒ Object

Same as IO.



3251
3252
3253
3254
3255
 
# File 'ext/zlib/zlib.c', line 3251

static VALUE
rb_gzfile_to_io(VALUE obj)
{
    return get_gzfile(obj)->io;
}