класс Zlib::Deflate

static VALUE
rb_deflate_s_deflate(int argc, VALUE *argv, VALUE klass)
{
    struct zstream z;
    VALUE src, level, dst, args[2];
    int err, lev;

    rb_scan_args(argc, argv, "11", &src, &level);

    lev = ARG_LEVEL(level);
    StringValue(src);
    zstream_init_deflate(&z);
    err = deflateInit(&z.stream, lev);
    if (err != Z_OK) {
        raise_zlib_error(err, z.stream.msg);
    }
    ZSTREAM_READY(&z);

    args[0] = (VALUE)&z;
    args[1] = src;
    dst = rb_ensure(deflate_run, (VALUE)args, zstream_end, (VALUE)&z);

    OBJ_INFECT(dst, src);
    return dst;
}

Сжимает заданную string. Допустимые значения уровня — Zlib::NO_COMPRESSION, Zlib::BEST_SPEED, Zlib::BEST_COMPRESSION, Zlib::DEFAULT_COMPRESSION или целое число от 0 до 9.

Этот метод почти эквивалентен следующему коду:

def deflate(string, level)
  z = Zlib::Deflate.new(level)
  dst = z.deflate(string, Zlib::FINISH)
  z.close
  dst
end

См. также Zlib.inflate

static VALUE
rb_deflate_initialize(int argc, VALUE *argv, VALUE obj)
{
    struct zstream *z;
    VALUE level, wbits, memlevel, strategy;
    int err;

    rb_scan_args(argc, argv, "04", &level, &wbits, &memlevel, &strategy);
    TypedData_Get_Struct(obj, struct zstream, &zstream_data_type, z);

    err = deflateInit2(&z->stream, ARG_LEVEL(level), Z_DEFLATED,
                       ARG_WBITS(wbits), ARG_MEMLEVEL(memlevel),
                       ARG_STRATEGY(strategy));
    if (err != Z_OK) {
        raise_zlib_error(err, z->stream.msg);
    }
    ZSTREAM_READY(z);

    return obj;
}

Создаёт новый поток сжатия deflate. Если заданный аргумент имеет значение nil, используется значение по умолчанию для этого аргумента.

level устанавливает уровень сжатия для потока deflate в диапазоне от 0 (без сжатия) до 9 (лучшее сжатие). Для повышения читаемости кода определены следующие константы:

• Zlib::DEFAULT_COMPRESSION

• Zlib::NO_COMPRESSION

• Zlib::BEST_SPEED

• Zlib::BEST_COMPRESSION

Для получения дополнительной информации см. www.zlib.net/manual.html#Constants.

window_bits задаёт размер буфера истории и должен находиться в диапазоне от 8 до 15. Более высокие значения этого параметра приводят к лучшему сжатию за счёт увеличения использования памяти.

mem_level задаёт объём памяти, который следует выделить для внутреннего состояния сжатия. 1 использует минимальное количество памяти, но медленнее и снижает коэффициент сжатия, в то время как 9 использует максимальное количество памяти для оптимальной скорости. Значение по умолчанию — 8. Определены две константы:

• Zlib::DEF_MEM_LEVEL

• Zlib::MAX_MEM_LEVEL

strategy устанавливает стратегию сжатия deflate. Доступны следующие стратегии:

Zlib::DEFAULT_STRATEGY

Для обычных данных

Zlib::FILTERED

Для данных, полученных от фильтра или предсказателя

Zlib::FIXED

Препятствует динамическим кодам Хаффмана

Zlib::HUFFMAN_ONLY

Препятствует сопоставлению строк

Zlib::RLE

Разработан для лучшего сжатия данных изображений PNG

Для получения дополнительных сведений обратитесь к константам.

Примеры

Основной

open "compressed.file", "w+" do |io|
  io << Zlib::Deflate.new.deflate(File.read("big.file"))
end

Настройка сжатия

open "compressed.file", "w+" do |compressed_io|
  deflate = Zlib::Deflate.new(Zlib::BEST_COMPRESSION,
                              Zlib::MAX_WBITS,
                              Zlib::MAX_MEM_LEVEL,
                              Zlib::HUFFMAN_ONLY)

  begin
    open "big.file" do |big_io|
      until big_io.eof? do
        compressed_io << zd.deflate(big_io.read(16384))
      end
    end
  ensure
    deflate.close
  end
end

Хотя этот пример будет работать, для лучшей оптимизации просмотрите флаги для ваших конкретных требований к времени, использованию памяти и объёму выходных данных.

static VALUE
rb_deflate_addstr(VALUE obj, VALUE src)
{
    OBJ_INFECT(obj, src);
    do_deflate(get_zstream(obj), src, Z_NO_FLUSH);
    return obj;
}

Вводит string в поток deflate, как и в #deflate, но возвращает сам объект Zlib::Deflate. Выходные данные из потока сохраняются в буфере вывода.

static VALUE
rb_deflate_deflate(int argc, VALUE *argv, VALUE obj)
{
    struct zstream *z = get_zstream(obj);
    VALUE src, flush;

    rb_scan_args(argc, argv, "11", &src, &flush);
    OBJ_INFECT(obj, src);
    do_deflate(z, src, ARG_FLUSH(flush));

    return zstream_detach_buffer(z);
}

Вводит string в поток deflate и возвращает выходные данные из потока. При вызове этого метода буферы ввода и вывода потока сбрасываются. Если string имеет значение nil, этот метод завершает поток, как и Zlib::ZStream#finish.

Если предоставлен блок, последовательные сжатые куски из string передаются в блок, и nil возвращается.

Параметр flush задаёт режим сброса. Могут использоваться следующие константы:

Zlib::NO_FLUSH

Значение по умолчанию

Zlib::SYNC_FLUSH

Сбрасывает вывод до байтовой границы

Zlib::FULL_FLUSH

SYNC_FLUSH + сбрасывает состояние сжатия

Zlib::FINISH

Обрабатывает ожидающий ввод, сбрасывает ожидающий вывод.

См. константы для получения дополнительной информации.

static VALUE
rb_deflate_flush(int argc, VALUE *argv, VALUE obj)
{
    struct zstream *z = get_zstream(obj);
    VALUE v_flush;
    int flush;

    rb_scan_args(argc, argv, "01", &v_flush);
    flush = FIXNUMARG(v_flush, Z_SYNC_FLUSH);
    if (flush != Z_NO_FLUSH) {  /* prevent Z_BUF_ERROR */
        zstream_run(z, (Bytef*)"", 0, flush);
    }

    return zstream_detach_buffer(z);
}

Этот метод эквивалентен deflate('', flush). Этот метод просто предоставлен для улучшения удобочитаемости вашей Ruby-программы. Если задан блок, куски выходных данных deflate передаются в блок до сброса буфера.

См. #deflate для получения подробной информации о константах flush NO_FLUSH, SYNC_FLUSH, FULL_FLUSH и FINISH.

static VALUE
rb_deflate_init_copy(VALUE self, VALUE orig)
{
    struct zstream *z1, *z2;
    int err;

    TypedData_Get_Struct(self, struct zstream, &zstream_data_type, z1);
    z2 = get_zstream(orig);

    if (z1 == z2) return self;
    err = deflateCopy(&z1->stream, &z2->stream);
    if (err != Z_OK) {
        raise_zlib_error(err, 0);
    }
    z1->input = NIL_P(z2->input) ? Qnil : rb_str_dup(z2->input);
    z1->buf   = NIL_P(z2->buf)   ? Qnil : rb_str_dup(z2->buf);
    z1->flags = z2->flags;

    return self;
}

Создаёт копию потока deflate.

static VALUE
rb_deflate_params(VALUE obj, VALUE v_level, VALUE v_strategy)
{
    struct zstream *z = get_zstream(obj);
    int level, strategy;
    int err;
    uInt n;
    long filled;

    level = ARG_LEVEL(v_level);
    strategy = ARG_STRATEGY(v_strategy);

    n = z->stream.avail_out;
    err = deflateParams(&z->stream, level, strategy);
    filled = n - z->stream.avail_out;
    while (err == Z_BUF_ERROR) {
        rb_warning("deflateParams() returned Z_BUF_ERROR");
        zstream_expand_buffer(z);
        rb_str_set_len(z->buf, RSTRING_LEN(z->buf) + filled);
        n = z->stream.avail_out;
        err = deflateParams(&z->stream, level, strategy);
        filled = n - z->stream.avail_out;
    }
    if (err != Z_OK) {
        raise_zlib_error(err, z->stream.msg);
    }
    rb_str_set_len(z->buf, RSTRING_LEN(z->buf) + filled);

    return Qnil;
}

Изменяет параметры потока deflate, чтобы допускать изменения между различными типами данных, требующими различных типов сжатия. Все необработанные данные сбрасываются перед изменением параметров.

См. ::new для описания level и strategy.

static VALUE
rb_deflate_set_dictionary(VALUE obj, VALUE dic)
{
    struct zstream *z = get_zstream(obj);
    VALUE src = dic;
    int err;

    OBJ_INFECT(obj, dic);
    StringValue(src);
    err = deflateSetDictionary(&z->stream,
                               (Bytef*)RSTRING_PTR(src), RSTRING_LENINT(src));
    if (err != Z_OK) {
        raise_zlib_error(err, z->stream.msg);
    }

    return dic;
}

Устанавливает предопределённый словарь и возвращает string. Этот метод доступен только после вызова метода ::new или Zlib::ZStream#reset. Подробности см. в zlib.h.

Может генерировать ошибки Z_STREAM_ERROR, если параметр некорректен (например, словарь NULL) или состояние потока не согласуется, а также Z_DATA_ERROR, если предоставленный словарь не соответствует ожидаемому (неверное значение adler32).