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

.wrapObject

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.


3042
3043
3044
3045
3046
# File 'zlib.c', line 3042

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.


3256
3257
3258
3259
3260
3261
3262
3263
3264
3265
# File 'zlib.c', line 3256

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

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

#closed?Boolean

Same as IO#closed?


3291
3292
3293
3294
3295
3296
3297
# File 'zlib.c', line 3291

static VALUE
rb_gzfile_closed_p(VALUE obj)
{
    struct gzfile *gz;
    Data_Get_Struct(obj, struct gzfile, 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.


3145
3146
3147
3148
3149
3150
3151
3152
3153
3154
# File 'zlib.c', line 3145

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

#crcObject

Returns CRC value of the uncompressed data.


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

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.


3274
3275
3276
3277
3278
3279
3280
3281
3282
3283
# File 'zlib.c', line 3274

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.


3105
3106
3107
3108
3109
# File 'zlib.c', line 3105

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

#mtimeObject

Returns last modification time recorded in the gzip file header.


3094
3095
3096
3097
3098
# File 'zlib.c', line 3094

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.


3128
3129
3130
3131
3132
3133
3134
3135
3136
3137
# File 'zlib.c', line 3128

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

#os_codeObject

Returns OS code number recorded in the gzip file header.


3116
3117
3118
3119
3120
# File 'zlib.c', line 3116

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

#syncObject

Same as IO#sync


3317
3318
3319
3320
3321
# File 'zlib.c', line 3317

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

#sync=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.


3332
3333
3334
3335
3336
3337
3338
3339
3340
3341
3342
3343
3344
# File 'zlib.c', line 3332

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.


3072
3073
3074
3075
3076
# File 'zlib.c', line 3072

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