Class: LZ4::Encoder

Inherits:

Object

• Object
• LZ4::Encoder

Defined in:

ext/frameapi.c

Instance Method Summary

• #<<(src) ⇒ Object
• #close ⇒ Object (also: #finish)
• #flush ⇒ Object
• #initialize(outport = "".b, level = 1, blocksize: nil, blocklink: false, checksum: true) ⇒ Object constructor
• #inspect ⇒ Object
• #outport ⇒ Object
• #outport=(outport) ⇒ Object
• #prefs_blocklink ⇒ Object
• #prefs_blocksize ⇒ Object
• #prefs_checksum ⇒ Object
• #prefs_level ⇒ Object
• #write(src) ⇒ self

Constructor Details

#initialize(outport = "".b, level = 1, blocksize: nil, blocklink: false, checksum: true) ⇒ Object

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

static VALUE
fenc_init(int argc, VALUE argv[], VALUE enc)
{
    struct encoder *p = getencoder(enc);
    VALUE outport;
    fenc_init_args(argc, argv, &outport, &p->prefs);

    LZ4F_errorCode_t status;
    status = LZ4F_createCompressionContext(&p->encoder, LZ4F_VERSION);
    aux_lz4f_check_error(status);
    p->workbuf = rb_str_buf_new(AUX_LZ4F_BLOCK_SIZE_MAX);
    size_t s = LZ4F_compressBegin(p->encoder, RSTRING_PTR(p->workbuf), rb_str_capacity(p->workbuf), &p->prefs);
    aux_lz4f_check_error(s);
    rb_str_set_len(p->workbuf, s);
    rb_funcall2(outport, id_op_lshift, 1, &p->workbuf);
    p->outport = outport;
    return enc;
}

Instance Method Details

#<<(src) ⇒ Object

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

static VALUE
fenc_push(VALUE enc, VALUE src)
{
    struct encoder *p = getencoder(enc);
    fenc_update(p, src, NULL);
    return enc;
}

#close ⇒ Object Also known as: finish

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

static VALUE
fenc_close(VALUE enc)
{
    struct encoder *p = getencoder(enc);
    size_t destsize = AUX_LZ4F_BLOCK_SIZE_MAX + AUX_LZ4F_FINISH_SIZE;
    aux_str_reserve(p->workbuf, destsize);
    char *destp = RSTRING_PTR(p->workbuf);
    size_t size = LZ4F_compressEnd(p->encoder, destp, destsize, NULL);
    aux_lz4f_check_error(size);
    rb_str_set_len(p->workbuf, size);
    rb_funcall2(p->outport, id_op_lshift, 1, &p->workbuf);

    return enc;
}

#flush ⇒ Object

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

static VALUE
fenc_flush(VALUE enc)
{
    struct encoder *p = getencoder(enc);
    size_t destsize = AUX_LZ4F_BLOCK_SIZE_MAX + AUX_LZ4F_FINISH_SIZE;
    aux_str_reserve(p->workbuf, destsize);
    char *destp = RSTRING_PTR(p->workbuf);
    size_t size = LZ4F_flush(p->encoder, destp, destsize, NULL);
    aux_lz4f_check_error(size);
    rb_str_set_len(p->workbuf, size);
    rb_funcall2(p->outport, id_op_lshift, 1, &p->workbuf);

    return enc;
}

#inspect ⇒ Object

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

static VALUE
fenc_inspect(VALUE enc)
{
    struct encoder *p = getencoderp(enc);
    if (p) {
        return rb_sprintf("#<%s:%p outport=#<%s:%p>, level=%d, blocksize=%d, blocklink=%s, checksum=%s>",
                rb_obj_classname(enc), (void *)enc,
                rb_obj_classname(p->outport), (void *)p->outport,
                p->prefs.compressionLevel, fenc_blocksize(p),
                aux_frame_blocklink(&p->prefs.frameInfo) ? "true" : "false",
                aux_frame_checksum(&p->prefs.frameInfo) ? "true" : "false");
    } else {
        return rb_sprintf("#<%s:%p **INVALID REFERENCE**>",
                rb_obj_classname(enc), (void *)enc);
    }
}

#outport ⇒ Object

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

static VALUE
fenc_getoutport(VALUE enc)
{
    return getencoder(enc)->outport;
}

#outport=(outport) ⇒ Object

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

static VALUE
fenc_setoutport(VALUE enc, VALUE outport)
{
    return getencoder(enc)->outport = outport;
}

#prefs_blocklink ⇒ Object

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

static VALUE
fenc_prefs_blocklink(VALUE enc)
{
    return aux_frame_blocklink(&getencoder(enc)->prefs.frameInfo) ? Qtrue : Qfalse;
}

#prefs_blocksize ⇒ Object

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

static VALUE
fenc_prefs_blocksize(VALUE enc)
{
    return INT2NUM(fenc_blocksize(getencoder(enc)));
}

#prefs_checksum ⇒ Object

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

static VALUE
fenc_prefs_checksum(VALUE enc)
{
    return aux_frame_checksum(&getencoder(enc)->prefs.frameInfo) ? Qtrue : Qfalse;
}

#prefs_level ⇒ Object

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

static VALUE
fenc_prefs_level(VALUE enc)
{
    return INT2NUM(aux_frame_level(&getencoder(enc)->prefs));
}

#write(src) ⇒ self

Returns:

• (self)

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

static VALUE
fenc_write(int argc, VALUE argv[], VALUE enc)
{
    struct encoder *p = getencoder(enc);
    VALUE src;
    rb_scan_args(argc, argv, "1", &src);
    fenc_update(p, src, NULL);
    return enc;
}