Class: Zstd::StreamDecoder

Inherits:

Object

• Object
• Zstd::StreamDecoder

Defined in:

ext/extzstd_stream.c

Constant Summary

INSIZE =

SIZET2NUM(ZSTD_DStreamInSize())

OUTSIZE =

SIZET2NUM(ZSTD_DStreamOutSize())

Instance Method Summary

• #initialize(predict) ⇒ Object constructor
• #reset ⇒ Object
• #sizeof ⇒ Object
• #update(src, srcoff, dest, maxdest) ⇒ Object

Constructor Details

#initialize(predict) ⇒ Object

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

static VALUE
dec_init(VALUE self, VALUE predict)
{
    /*
     * ZSTDLIB_API size_t ZSTD_initDStream(ZSTD_DStream* zds);
     * ZSTDLIB_API size_t ZSTD_initDStream_usingDict(ZSTD_DStream* zds, const void* dict, size_t dictSize);
     */

    ZSTD_DStream *p = getdecoder(self);

    if (NIL_P(predict)) {
        size_t s = ZSTD_initDStream(p);
        extzstd_check_error(s);
    } else {
        rb_check_type(predict, RUBY_T_STRING);
        size_t s = ZSTD_initDStream_usingDict(p, RSTRING_PTR(predict), RSTRING_LEN(predict));
        extzstd_check_error(s);
    }
    return self;
}

Instance Method Details

#reset ⇒ Object

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

static VALUE
dec_reset(VALUE self)
{
    /*
     * ZSTDLIB_API size_t ZSTD_resetDStream(ZSTD_DStream* zds);
     */
    size_t s = ZSTD_resetDStream(getdecoder(self));
    extzstd_check_error(s);
    return self;
}

#sizeof ⇒ Object

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

static VALUE
dec_sizeof(VALUE self)
{
    /*
     * ZSTDLIB_API size_t ZSTD_sizeof_DStream(const ZSTD_DStream* zds);
     */

    size_t s = ZSTD_sizeof_DStream(getdecoder(self));
    extzstd_check_error(s);
    return SIZET2NUM(s);
}

#update(src, srcoff, dest, maxdest) ⇒ Object

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

static VALUE
dec_update(VALUE self, VALUE src, VALUE srcoff, VALUE dest, VALUE maxdest)
{
    /*
     * ZSTDLIB_API size_t ZSTD_decompressStream(ZSTD_DStream* zds, ZSTD_outBuffer* output, ZSTD_inBuffer* input);
     */

    ZSTD_DStream *p = getdecoder(self);

    rb_check_type(src, RUBY_T_STRING);
    const char *q = RSTRING_PTR(src);
    const char *qq = RSTRING_END(src);
    const char *q1 = q + NUM2SIZET(srcoff);
    if (q1 < q || q1 > qq) {
        rb_raise(rb_eArgError,
                "``srcoff'' is out of range (given %"PRIuSIZE", expect 0..%"PRIuSIZE")",
                q1 - q, qq - q);
    }

    rb_check_type(dest, RUBY_T_STRING);
    rb_str_modify(dest);
    rb_str_set_len(dest, 0);
    rb_str_modify_expand(dest, NUM2SIZET(maxdest));
    rb_obj_infect(self, src);
    rb_obj_infect(dest, self);
    char *r = RSTRING_PTR(dest);
    const char *rr = r + rb_str_capacity(dest);

    ZSTD_inBuffer input = { q, qq - q, q1 - q };
    ZSTD_outBuffer output = { r, rr - r, 0 };
    size_t s = ZSTD_decompressStream(p, &output, &input);
    extzstd_check_error(s);
    rb_str_set_len(dest, output.pos);
    return SIZET2NUM(input.pos);
}