Class: Zstd::Decoder

Inherits:

Object

• Object
• Zstd::Decoder

Defined in:

lib/extzstd.rb,
ext/extzstd_stream.c

Constant Summary

INSIZE =

SIZET2NUM(ZSTD_DStreamInSize())

OUTSIZE =

SIZET2NUM(ZSTD_DStreamOutSize())

Class Method Summary

• .decode(src, dest: nil, dict: nil) ⇒ Object (also: decompress, uncompress)
• .open(inport, dict = nil) ⇒ Object

  call-seq: open(inport, dict = nil) -> decoder open(inport, dict = nil) { |decoder| … } -> yield returned value.

Instance Method Summary

• #close ⇒ Object
• #eof ⇒ Object (also: #eof?)
• #initialize(inport, predict = Qnil) ⇒ Object constructor
• #pos ⇒ Object
• #read(argv[], self) ⇒ Object
• #reset ⇒ Object
• #sizeof ⇒ Object

Constructor Details

#initialize(inport, predict = Qnil) ⇒ Object

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

static VALUE
dec_init(int argc, VALUE argv[], VALUE self)
{
    /*
     * ZSTDLIB_API size_t ZSTD_DCtx_loadDictionary(ZSTD_DCtx* dctx, const void* dict, size_t dictSize);
     *
     * 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);
     */

    VALUE inport, predict;

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

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

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

    //ZSTD_DCtx_reset
    //ZSTD_DCtx_loadDictionary
    if (NIL_P(predict)) {
        //size_t s = ZSTD_initDStream(p->context);
        //extzstd_check_error(s);
    } else {
        rb_check_type(predict, RUBY_T_STRING);
        predict = rb_str_new_frozen(predict);
        //size_t s = ZSTD_initDStream_usingDict(p->context, RSTRING_PTR(predict), RSTRING_LEN(predict));
        size_t s = ZSTD_DCtx_loadDictionary(p->context, RSTRING_PTR(predict), RSTRING_LEN(predict));
        extzstd_check_error(s);
    }

    p->inport = inport;
    p->predict = predict;

    return self;
}

Class Method Details

.decode(src, dest: nil, dict: nil) ⇒ Object Also known as: decompress, uncompress

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

def self.decode(src, dest: nil, dict: nil)
  # NOTE: ContextLess.decode は伸長時のサイズが必要なため、常に利用できるわけではない
  # ContextLess.decode(src, dest || "".b, nil, dict)

  new(StringIO.new(src), dict).read(nil, dest)
end

.open(inport, dict = nil) ⇒ Object

call-seq:

open(inport, dict = nil) -> decoder
open(inport, dict = nil) { |decoder| ... } -> yield returned value

inport

String instance or read method haved Object.

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

def self.open(inport, dict = nil)
  inport = StringIO.new(inport) if inport.kind_of?(String)

  dec = new(inport, dict)

  return dec unless block_given?

  begin
    yield(dec)
  ensure
    dec.close rescue nil
  end
end

Instance Method Details

#close ⇒ Object

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

static VALUE
dec_close(VALUE self)
{
    decoder_context(self)->reached_eof = 1;
    return Qnil;
}

#eof ⇒ Object Also known as: eof?

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

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

#pos ⇒ Object

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

static VALUE
dec_pos(VALUE self)
{
    decoder_context(self); /* check only */
    return INT2FIX(0);
}

#read ⇒ Object #read(readsize, buf = "".b) ⇒ Object

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

static VALUE
dec_read(int argc, VALUE argv[], VALUE self)
{
    /*
     * ZSTDLIB_API size_t ZSTD_decompressStream(ZSTD_DStream* zds, ZSTD_outBuffer* output, ZSTD_inBuffer* input);
     */

    ssize_t size;
    VALUE buf;
    dec_read_args(argc, argv, self, &buf, &size);

    struct decoder *p = decoder_context(self);

    if (size == 0) {
        rb_str_set_len(buf, 0);
        return buf;
    } else if (size > 0) {
        size = dec_read_decode(self, p, RSTRING_PTR(buf), size);
        rb_str_set_len(buf, size);
    } else {
        /* if (size < 0) */

        size_t capa = EXT_READ_GROWUP_SIZE;

        for (;;) {
            aux_str_modify_expand(buf, capa);
            size = dec_read_decode(self, p, RSTRING_PTR(buf) + RSTRING_LEN(buf), capa - RSTRING_LEN(buf));
            rb_str_set_len(buf, RSTRING_LEN(buf) + size);
            if (size == 0) { break; }
            size = rb_str_capacity(buf);
            if (size > RSTRING_LEN(buf)) { break; }
            if (size > EXT_READ_DOUBLE_GROWUP_LIMIT_SIZE) {
                capa += EXT_READ_DOUBLE_GROWUP_LIMIT_SIZE;
            } else {
                capa *= 2;
            }
        }
    }

    rb_obj_infect(buf, self);

    if (RSTRING_LEN(buf) == 0) {
        return Qnil;
    } else {
        return buf;
    }
}

#reset ⇒ Object

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

static VALUE
dec_reset(VALUE self)
{
    //> ZSTDLIB_API size_t ZSTD_DCtx_reset(ZSTD_DCtx* dctx, ZSTD_ResetDirective reset);

    size_t s = ZSTD_DCtx_reset(decoder_context(self)->context, ZSTD_reset_session_only);
    extzstd_check_error(s);
    return self;
}

#sizeof ⇒ Object

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

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

    size_t s = ZSTD_sizeof_DStream(decoder_context(self)->context);
    extzstd_check_error(s);
    return SIZET2NUM(s);
}