class Zlib::Deflate

Overview

A write-only IO object to compress data in zlib or gzip format.

Instances of this class wrap another IO object. When you write to this instance, it compresses the data and writes it to the underlying IO.

Note: unless created with a block, #close must be invoked after all data has been written to a Zlib::Deflate instance.

Example: compress a file

File.open("./file.txt", "r") do |input_file|
  File.open("./file.gzip", "w") do |output_file|
    Zlib::Deflate.gzip(output_file) do |deflate|
      IO.copy(input_file, deflate)
    end
  end
end

See also: Zlib::Inflate for decompressing data.

Included Modules

Defined in:

zlib/deflate.cr

Class Method Summary

Instance Method Summary

Instance methods inherited from module IO

<<(obj) : self <<, close close, closed? closed?, cooked(&block) cooked, cooked! cooked!, each_byte
each_byte(&block) each_byte, each_char(&block)
each_char each_char, each_line(*args)
each_line(*args, &block) each_line, encoding : String encoding, flush flush, gets(limit : Int) : String | Nil
gets(delimiter : Char, limit : Int) : String | Nil
gets(delimiter : Char) : String | Nil
gets : String | Nil
gets(delimiter : String) : String | Nil gets, gets_to_end : String gets_to_end, print(obj) : Nil
print(*objects : _) : Nil print, printf(format_string, *args) : Nil
printf(format_string, args : Array | Tuple) : Nil printf, puts : Nil
puts(*objects : _) : Nil
puts(string : String) : Nil
puts(obj) : Nil puts, raw(&block) raw, raw! raw!, read(slice : Slice(UInt8)) read, read_byte : UInt8 | Nil read_byte, read_bytes(type, format : IO::ByteFormat = IO::ByteFormat::SystemEndian) read_bytes, read_char : Char | Nil read_char, read_fully(slice : Slice(UInt8)) read_fully, read_line(*args) : String | Nil read_line, read_nonblock(size) read_nonblock, read_utf8(slice : Slice(UInt8)) read_utf8, read_utf8_byte read_utf8_byte, rewind rewind, set_encoding(encoding : String, invalid : Symbol | Nil = nil) set_encoding, skip(bytes_count : Int) : Nil skip, tty? : Bool tty?, write(slice : Slice(UInt8)) : Nil write, write_byte(byte : UInt8) write_byte, write_bytes(object, format : IO::ByteFormat = IO::ByteFormat::SystemEndian) write_bytes, write_utf8(slice : Slice(UInt8)) write_utf8

Class methods inherited from module IO

copy(src, dst) copy, pipe(read_blocking = false, write_blocking = false, &block)
pipe(read_blocking = false, write_blocking = false) pipe, select(read_ios, write_ios, error_ios, timeout_sec : LibC::TimeT | Int | Float | Nil)
select(read_ios, write_ios = nil, error_ios = nil) select

Instance methods inherited from module JSON::Builder

json_array(&block) json_array, json_object(&block) json_object

Instance methods inherited from class Reference

==(other)
==(other : self) ==, hash hash, inspect(io : IO) : Nil inspect, object_id : UInt64 object_id, same?(other : Reference)
same?(other : Nil) same?, to_s(io : IO) : Nil to_s

Instance methods inherited from class Object

!=(other) !=, !~(other) !~, ==(other) ==, ===(other)
===(other : YAML::Any)
===(other : JSON::Any) ===, =~(other) =~, class class, clone clone, crystal_type_id crystal_type_id, dup dup, hash hash, inspect
inspect(io : IO) inspect, itself itself, not_nil! not_nil!, tap(&block) tap, to_json to_json, to_pretty_json(io : IO)
to_pretty_json to_pretty_json, to_s
to_s(io : IO) to_s, to_yaml(io : IO)
to_yaml to_yaml, try(&block) try

Class methods inherited from class Object

==(other : Class) ==, ===(other) ===, cast(other) : self cast, from_json(string_or_io) : self from_json, from_yaml(string : String) : self from_yaml, hash hash, inspect(io) inspect, name : String name, to_s(io) to_s, |(other : U.class) |

Class Method Detail

def self.gzip(output, sync_close : Bool = false, &block) #

Creates an instance of Zlib::Deflate for the gzip format, yields it to the given block, and closes it at its end.


[View source]
def self.gzip(output, sync_close : Bool = false) : self #

Creates an instance of Zlib::Deflate for the gzip format. #close must be invoked after all data has written.


[View source]
def self.new(output : IO, level = LibZ::DEFAULT_COMPRESSION, wbits = LibZ::MAX_BITS, mem_level = LibZ::DEF_MEM_LEVEL, strategy = LibZ::Strategy::DEFAULT_STRATEGY, sync_close : Bool = false, &block) #

Creates an instance of Zlib::Deflate, yields it to the given block, and closes it at its end.


[View source]
def self.new(output : IO, level = LibZ::DEFAULT_COMPRESSION, wbits = LibZ::MAX_BITS, mem_level = LibZ::DEF_MEM_LEVEL, strategy = LibZ::Strategy::DEFAULT_STRATEGY, sync_close : Bool = false) #

Creates an instance of Zlib::Deflate. #close must be invoked after all data has written.


[View source]

Instance Method Detail

def close #

Closes this IO. Must be invoked after all data has been written.


[View source]
def closed? : Bool #

Returns true if this IO is closed.


[View source]
def flush #

See IO#flush.


[View source]
def read(slice : Slice(UInt8)) #

Always raises: this is a write-only IO.


[View source]
def sync_close=(sync_close : Bool) #

def sync_close? : Bool #

def write(slice : Slice(UInt8)) #

See IO#write.


[View source]