Class: LZ4::Decoder

Inherits:

Object

• Object
• LZ4::Decoder

Defined in:

ext/frameapi.c

Instance Method Summary

• #close ⇒ Object (also: #finish)
• #eof ⇒ Object (also: #eof?)
• #getbyte ⇒ Integer | nil

  Read one byte code integer.

• #getc ⇒ String | nil

  Read one byte character.

• #initialize(inport) ⇒ self constructor

  inport

  An I/O (liked) object for data read from LZ4 Frame.

• #inport ⇒ Object
• #inspect ⇒ Object
• #prefs_blocklink ⇒ Object
• #prefs_blocksize ⇒ Object
• #prefs_checksum ⇒ Object
• #read(argv[], dec) ⇒ Object

Constructor Details

#initialize(inport) ⇒ self

inport

An I/O (liked) object for data read from LZ4 Frame.

This object need .read method.

# File 'ext/frameapi.c', line 449

static VALUE
fdec_init(int argc, VALUE argv[], VALUE dec)
{
    struct decoder *p = getdecoder(dec);
    VALUE inport;
    //VALUE readblocksize;
    rb_scan_args(argc, argv, "1", &inport);
    LZ4F_errorCode_t err = LZ4F_createDecompressionContext(&p->decoder, LZ4F_VERSION);
    aux_lz4f_check_error(err);
    rb_obj_infect(dec, inport);
    p->inport = inport;
    p->readbuf = rb_str_buf_new(0);
    char *readp;
    size_t readsize;
    size_t zero = 0;
    size_t s = 4; /* magic number size of lz4 frame */
    int i;
    for (i = 0; i < 2; i ++) {
        /*
         * first step: check magic number
         * second step: check frame information
         */
        aux_read(inport, s, p->readbuf);
        aux_str_getmem(p->readbuf, &readp, &readsize);
        if (!readp || readsize < s) {
            rb_raise(extlz4_eError,
                     "unexpected EOF (read error) - #<%s:%p>",
                     rb_obj_classname(inport), (const void *)inport);
        }
        s = LZ4F_decompress(p->decoder, NULL, &zero, readp, &readsize, NULL);
        aux_lz4f_check_error(s);
    }
    p->status = s;
    s = LZ4F_getFrameInfo(p->decoder, &p->info, NULL, &zero);
    aux_lz4f_check_error(s);
    p->outbuf = rb_str_tmp_new(1 << (8 + p->info.blockSizeID * 2));
    rb_str_set_len(p->outbuf, 0);

    return dec;
}

Instance Method Details

#close ⇒ Object Also known as: finish

# File 'ext/frameapi.c', line 674

static VALUE
fdec_close(VALUE dec)
{
    struct decoder *p = getdecoder(dec);
    p->status = 0;
    // TODO: destroy decoder
    return dec;
}

#eof ⇒ Object Also known as: eof?

# File 'ext/frameapi.c', line 683

static VALUE
fdec_eof(VALUE dec)
{
    struct decoder *p = getdecoder(dec);
    if (p->status == 0) {
        return Qtrue;
    } else {
        return Qfalse;
    }
}

#getbyte ⇒ Integer | nil

Read one byte code integer.

Returns:

• (Integer | nil)

# File 'ext/frameapi.c', line 660

static VALUE
fdec_getbyte(VALUE dec)
{
    struct decoder *p = getdecoder(dec);

    char ch;
    size_t s = fdec_read_decode(dec, p, &ch, 1);
    if (s > 0) {
        return INT2FIX(ch);
    } else {
        return Qnil;
    }
}

#getc ⇒ String | nil

Read one byte character.

Returns:

• (String | nil)

# File 'ext/frameapi.c', line 634

static VALUE
fdec_getc(VALUE dec)
{
    struct decoder *p = getdecoder(dec);

    if (p->status == 0) {
        return Qnil;
    }

    char ch;
    size_t s = fdec_read_decode(dec, p, &ch, 1);
    if (s > 0) {
        VALUE v = rb_str_new(&ch, 1);
        rb_obj_infect(v, dec);
        return v;
    } else {
        return Qnil;
    }
}

#inport ⇒ Object

# File 'ext/frameapi.c', line 694

static VALUE
fdec_inport(VALUE dec)
{
    return getdecoder(dec)->inport;
}

#inspect ⇒ Object

# File 'ext/frameapi.c', line 724

static VALUE
fdec_inspect(VALUE dec)
{
    struct decoder *p = getdecoderp(dec);
    if (p) {
        return rb_sprintf("#<%s:%p inport=#<%s:%p>, blocksize=%d, blocklink=%s, checksum=%s>",
                rb_obj_classname(dec), (void *)dec,
                rb_obj_classname(p->inport), (void *)p->inport,
                fdec_blocksize(p),
                aux_frame_blocklink(&p->info) ? "true" : "false",
                aux_frame_checksum(&p->info) ? "true" : "false");
    } else {
        return rb_sprintf("#<%s:%p **INVALID REFERENCE**>",
                rb_obj_classname(dec), (void *)dec);
    }
}

#prefs_blocklink ⇒ Object

# File 'ext/frameapi.c', line 712

static VALUE
fdec_prefs_blocklink(VALUE dec)
{
    return aux_frame_blocklink(&getdecoder(dec)->info) ? Qtrue : Qfalse;
}

#prefs_blocksize ⇒ Object

# File 'ext/frameapi.c', line 706

static VALUE
fdec_prefs_blocksize(VALUE dec)
{
    return INT2NUM(fdec_blocksize(getdecoder(dec)));
}

#prefs_checksum ⇒ Object

# File 'ext/frameapi.c', line 718

static VALUE
fdec_prefs_checksum(VALUE dec)
{
    return aux_frame_checksum(&getdecoder(dec)->info) ? Qtrue : Qfalse;
}

#read ⇒ String #read(size) ⇒ String #read(size, buffer) ⇒ Object

Overloads:

• #read ⇒ String

  Returns:

  • (String)
• #read(size) ⇒ String

  Returns:

  • (String)

# File 'ext/frameapi.c', line 586

static VALUE
fdec_read(int argc, VALUE argv[], VALUE dec)
{
    struct decoder *p = getdecoder(dec);
    size_t size;
    VALUE dest;
    fdec_read_args(argc, argv, &size, &dest);
    if (size == 0) {
        rb_obj_infect(dest, dec);
        return dest;
    }

    if (p->status == 0) {
        return Qnil;
    }

    if ((ssize_t)size > 0) {
        char *destp = RSTRING_PTR(dest);
        size_t destsize = size;
        destsize = fdec_read_decode(dec, p, destp, destsize);
        rb_str_set_len(dest, destsize);
    } else {
        const size_t tmpsize = 4 * 1024 * 1024;
        VALUE tmpbuf = rb_str_tmp_new(tmpsize);
        char *tmp = RSTRING_PTR(tmpbuf);
        size_t s;
        rb_str_set_len(dest, 0);
        while ((s = fdec_read_decode(dec, p, tmp, tmpsize)) > 0) {
            rb_str_buf_cat(dest, tmp, s);
        }
        rb_str_resize(tmpbuf, 0);
    }

    rb_obj_infect(dest, dec);

    if (RSTRING_LEN(dest) > 0) {
        return dest;
    } else {
        return Qnil;
    }
}