Class: Zlib::GzipFile

Inherits:
Object
  • Object
show all
Defined in:
zlib.c,
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.



3084
3085
3086
3087
3088
# File 'zlib.c', line 3084

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

Instance Method Details

#closeObject

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



3308
3309
3310
3311
3312
3313
3314
3315
3316
3317
3318
3319
3320
3321
# File 'zlib.c', line 3308

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)


3347
3348
3349
3350
3351
3352
3353
# File 'zlib.c', line 3347

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

#commentObject

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



3184
3185
3186
3187
3188
3189
3190
3191
3192
# File 'zlib.c', line 3184

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

#crcObject

Returns CRC value of the uncompressed data.



3123
3124
3125
3126
3127
# File 'zlib.c', line 3123

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

#finishObject

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.



3330
3331
3332
3333
3334
3335
3336
3337
3338
3339
# File 'zlib.c', line 3330

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

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

#levelObject

Returns compression level.



3145
3146
3147
3148
3149
# File 'zlib.c', line 3145

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

#mtimeObject

Returns last modification time recorded in the gzip file header.



3134
3135
3136
3137
3138
# File 'zlib.c', line 3134

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

#orig_nameObject

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



3168
3169
3170
3171
3172
3173
3174
3175
3176
# File 'zlib.c', line 3168

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_codeObject

Returns OS code number recorded in the gzip file header.



3156
3157
3158
3159
3160
# File 'zlib.c', line 3156

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

#syncObject

Same as IO#sync



3373
3374
3375
3376
3377
# File 'zlib.c', line 3373

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.



3388
3389
3390
3391
3392
3393
3394
3395
3396
3397
3398
3399
3400
# File 'zlib.c', line 3388

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_ioObject

Same as IO.



3112
3113
3114
3115
3116
# File 'zlib.c', line 3112

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