Class: Zstd::Encoder

Inherits:

Object

• Object
• Zstd::Encoder

Defined in:

lib/extzstd.rb,
ext/extzstd_stream.c

Constant Summary

INSIZE =

SIZET2NUM(ZSTD_CStreamInSize())

OUTSIZE =

SIZET2NUM(ZSTD_CStreamOutSize())

Class Method Summary

• .encode(src, params = nil, dest: nil, dict: nil) ⇒ Object (also: compress)
• .open(outport, *args) ⇒ Object

  call-seq: open(outport, level = nil, dict = nil) -> zstd encoder open(outport, encode_params, dict = nil) { |encoder| … } -> yield returned value.

Instance Method Summary

• #close ⇒ Object (also: #end, #finish)
• #eof ⇒ Object (also: #eof?)
• #initialize(outport, compression_parameters = nil, predict = nil) ⇒ Object constructor
• #reset(pledged_srcsize) ⇒ Object
• #sizeof ⇒ Object
• #sync ⇒ Object (also: #flush)
• #write(src) ⇒ Object (also: #<<, #update)

Constructor Details

#initialize(outport, compression_parameters = nil, predict = nil) ⇒ Object

# File 'ext/extzstd_stream.c', line 95

static VALUE
enc_init(int argc, VALUE argv[], VALUE self)
{
    /*
     * ZSTDLIB_API size_t ZSTD_initCStream(ZSTD_CStream* zcs, int compressionLevel);
     * ZSTDLIB_API size_t ZSTD_initCStream_usingDict(ZSTD_CStream* zcs, const void* dict, size_t dictSize, int compressionLevel);
     * ZSTDLIB_API size_t ZSTD_initCStream_advanced(ZSTD_CStream* zcs, const void* dict, size_t dictSize,
     *                                              ZSTD_parameters params, unsigned long long pledgedSrcSize);
     */

    VALUE outport, params, predict;
    switch (argc) {
    case 1:
        outport = argv[0];
        params = predict = Qnil;
        break;
    case 2:
        outport = argv[0];
        params = argv[1];
        predict = Qnil;
        break;
    case 3:
        outport = argv[0];
        params = argv[1];
        predict = argv[2];
        break;
    default:
        rb_error_arity(argc, 1, 3);
    }

    struct encoder *p = getencoder(self);
    if (p->context) {
        rb_raise(rb_eTypeError,
                "initialized already - #<%s:%p>",
                rb_obj_classname(self), (void *)self);
    }

    const void *predictp;
    size_t predictsize;
    if (NIL_P(predict)) {
        predictp = NULL;
        predictsize = 0;
    } else {
        rb_check_type(predict, RUBY_T_STRING);
        predict = rb_str_new_frozen(predict);
        RSTRING_GETMEM(predict, predictp, predictsize);
    }

    AUX_TRY_WITH_GC(
            p->context = ZSTD_createCStream(),
            "failed ZSTD_createCStream()");

    if (extzstd_params_p(params)) {
        ZSTD_parameters *paramsp = extzstd_getparams(params);
        ZSTD_CCtx *zstd = p->context;
        p->context = NULL; // 

Class Method Details

.encode(src, params = nil, dest: nil, dict: nil) ⇒ Object Also known as: compress

# File 'lib/extzstd.rb', line 102

def self.encode(src, params = nil, dest: nil, dict: nil)
  ContextLess.encode(src, dest || "".b, nil, dict, params)
end

.open(outport, *args) ⇒ Object

call-seq:

open(outport, level = nil, dict = nil) -> zstd encoder
open(outport, encode_params, dict = nil) { |encoder| ... } -> yield returned value

# File 'lib/extzstd.rb', line 90

def self.open(outport, *args)
  e = new(outport, *args)

  return e unless block_given?

  begin
    yield e
  ensure
    e.close unless e.eof?
  end
end

Instance Method Details

#close ⇒ Object Also known as: end, finish

# File 'ext/extzstd_stream.c', line 234

static VALUE
enc_close(VALUE self)
{
    /*
     * ZSTDLIB_API size_t ZSTD_endStream(ZSTD_CStream* zcs, ZSTD_outBuffer* output);
     */

    struct encoder *p = encoder_context(self);
    aux_str_buf_recycle(&p->destbuf, ZSTD_CStreamOutSize());
    rb_str_set_len(p->destbuf, 0);
    rb_obj_infect(p->destbuf, self);
    ZSTD_outBuffer output = { RSTRING_PTR(p->destbuf), rb_str_capacity(p->destbuf), 0 };
    size_t s = ZSTD_endStream(p->context, &output);
    extzstd_check_error(s);
    rb_str_set_len(p->destbuf, output.pos);

    AUX_FUNCALL(p->outport, id_op_lsh, p->destbuf);

    p->reached_eof = 1;

    return Qnil;
}

#eof ⇒ Object Also known as: eof?

# File 'ext/extzstd_stream.c', line 257

static VALUE
enc_eof(VALUE self)
{
    return (encoder_context(self)->reached_eof == 0 ? Qfalse : Qtrue);
}

#reset(pledged_srcsize) ⇒ Object

# File 'ext/extzstd_stream.c', line 263

static VALUE
enc_reset(VALUE self, VALUE pledged_srcsize)
{
    /*
     * ZSTDLIB_API size_t ZSTD_CCtx_reset(ZSTD_CCtx* cctx, ZSTD_ResetDirective reset);
     */

    size_t s = ZSTD_CCtx_reset(encoder_context(self)->context, ZSTD_reset_session_only);
    extzstd_check_error(s);

    if (pledged_srcsize == Qnil) {
        ZSTD_CCtx_setPledgedSrcSize(encoder_context(self)->context, ZSTD_CONTENTSIZE_UNKNOWN);
    } else {
        ZSTD_CCtx_setPledgedSrcSize(encoder_context(self)->context, NUM2ULL(pledged_srcsize));
    }

    return self;
}

#sizeof ⇒ Object

# File 'ext/extzstd_stream.c', line 282

static VALUE
enc_sizeof(VALUE self)
{
    /*
     * ZSTDLIB_API size_t ZSTD_sizeof_CStream(const ZSTD_CStream* zcs);
     */

    size_t s = ZSTD_sizeof_CStream(encoder_context(self)->context);
    extzstd_check_error(s);
    return SIZET2NUM(s);
}

#sync ⇒ Object Also known as: flush

# File 'ext/extzstd_stream.c', line 213

static VALUE
enc_sync(VALUE self)
{
    /*
     * ZSTDLIB_API size_t ZSTD_flushStream(ZSTD_CStream* zcs, ZSTD_outBuffer* output);
     */

    struct encoder *p = encoder_context(self);
    aux_str_buf_recycle(&p->destbuf, ZSTD_CStreamOutSize());
    rb_str_set_len(p->destbuf, 0);
    rb_obj_infect(p->destbuf, self);
    ZSTD_outBuffer output = { RSTRING_PTR(p->destbuf), rb_str_capacity(p->destbuf), 0 };
    size_t s = ZSTD_flushStream(p->context, &output);
    extzstd_check_error(s);
    rb_str_set_len(p->destbuf, output.pos);

    AUX_FUNCALL(p->outport, id_op_lsh, p->destbuf);

    return self;
}

#write(src) ⇒ Object Also known as: <<, update

# File 'ext/extzstd_stream.c', line 184

static VALUE
enc_write(VALUE self, VALUE src)
{
    /*
     * ZSTDLIB_API size_t ZSTD_compressStream(ZSTD_CStream* zcs, ZSTD_outBuffer* output, ZSTD_inBuffer* input);
     */

    struct encoder *p = encoder_context(self);
    src = rb_String(src);
    ZSTD_inBuffer input = { RSTRING_PTR(src), RSTRING_LEN(src), 0 };

    while (input.pos < input.size) {
        aux_str_buf_recycle(&p->destbuf, ZSTD_CStreamOutSize() * 2);
        rb_str_set_len(p->destbuf, 0);
        rb_obj_infect(self, src);
        rb_obj_infect(p->destbuf, self);
        ZSTD_outBuffer output = { RSTRING_PTR(p->destbuf), rb_str_capacity(p->destbuf), 0 };
        size_t s = ZSTD_compressStream(p->context, &output, &input);
        extzstd_check_error(s);
        rb_str_set_len(p->destbuf, output.pos);

        // TODO: