Class: Bzip3::Encoder

Inherits:

Object

• Object
• Bzip3::Encoder

Defined in:

lib/extbzip3/fordoc.rb,
lib/extbzip3.rb,
ext/extbzip3_encoder.c

Overview

Encoder class.

Class Method Summary

• .encode(argv[], mod) ⇒ String

  Dest as decompression data.

• .open(*args, **opts, &block) ⇒ Object

Instance Method Summary

• #close ⇒ Object
• #closed? ⇒ Boolean
• #flush ⇒ Object
• #initialize ⇒ Object constructor
• #outport ⇒ Object
• #write(src) ⇒ Object (also: #<<)

Constructor Details

#initialize ⇒ Object

Class Method Details

.encode(src, maxdest = nil, dest = "", **opts) ⇒ String .encode(src, dest, **opts) ⇒ String

Returns dest as decompression data.

# File 'ext/extbzip3_encoder.c', line 280

static VALUE
encoder_s_encode(int argc, VALUE argv[], VALUE mod)
{
    size_t insize, outsize;
    struct { VALUE src, maxdest, dest, opts; } args;
    switch (rb_scan_args(argc, argv, "12:", &args.src, &args.maxdest, &args.dest, &args.opts)) {
    case 1:
        insize = RSTRING_LEN(args.src);
        outsize = bz3_bound(insize);
        args.dest = rb_str_buf_new(outsize);
        break;
    case 2:
        insize = RSTRING_LEN(args.src);

        if (rb_type_p(args.maxdest, RUBY_T_FIXNUM) || rb_type_p(args.maxdest, RUBY_T_BIGNUM)) {
            outsize = NUM2SIZET(args.maxdest);
            args.dest = rb_str_buf_new(outsize);
        } else {
            args.dest = args.maxdest;
            outsize = bz3_bound(insize);
            rb_str_modify(args.dest);
            rb_str_set_len(args.dest, 0);
            rb_str_modify_expand(args.dest, outsize);
        }

        break;
    case 3:
        insize = RSTRING_LEN(args.src);
        outsize = NUM2SIZET(args.maxdest);
        rb_str_modify(args.dest);
        rb_str_set_len(args.dest, 0);
        rb_str_modify_expand(args.dest, outsize);

        break;
    }

    enum { numkw = 2 };
    ID idtab[numkw] = { rb_intern("blocksize"), rb_intern("format") };
    union { struct { VALUE blocksize, format; }; VALUE vect[numkw]; } opts;
    rb_get_kwargs(args.opts, idtab, 0, numkw, opts.vect);

    uint32_t blocksize = aux_conv_to_blocksize(opts.blocksize);
    int status = aux_oneshot_encode(aux_conv_to_format(opts.format), blocksize,
                                    RSTRING_PTR(args.src), RSTRING_PTR(args.dest),
                                    insize, &outsize);
    extbzip3_check_error(status);
    rb_str_set_len(args.dest, outsize);

    return args.dest;
}

.open(*args, **opts, &block) ⇒ Object

# File 'lib/extbzip3.rb', line 52

def open(*args, **opts, &block)
  bz3 = new(*args, **opts)
  return bz3 unless block

  begin
    yield bz3
  ensure
    bz3.close unless bz3.closed?
  end
end

Instance Method Details

#close ⇒ Object

# File 'ext/extbzip3_encoder.c', line 246

static VALUE
encoder_close(VALUE self)
{
    struct encoder *p = get_encoder(self);

    if (rb_type_p(p->srcbuf, RUBY_T_STRING) && RSTRING_LEN(p->srcbuf) > 0) {
        encoder_write_encode(self, p, RSTRING_PTR(p->srcbuf), RSTRING_LEN(p->srcbuf));
        rb_str_set_len(p->srcbuf, 0);
    }

    p->closed = 1;

    return Qnil;
}

#closed? ⇒ Boolean

# File 'ext/extbzip3_encoder.c', line 261

static VALUE
encoder_closed_p(VALUE self)
{
    return get_encoder(self)->closed ? Qtrue : Qfalse;
}

#flush ⇒ Object

# File 'ext/extbzip3_encoder.c', line 233

static VALUE
encoder_flush(VALUE self)
{
    struct encoder *p = get_encoder(self);

    if (rb_type_p(p->srcbuf, RUBY_T_STRING) && RSTRING_LEN(p->srcbuf) > 0) {
        encoder_write_encode(self, p, RSTRING_PTR(p->srcbuf), RSTRING_LEN(p->srcbuf));
        rb_str_set_len(p->srcbuf, 0);
    }

    return Qnil;
}

#outport ⇒ Object

# File 'ext/extbzip3_encoder.c', line 135

static VALUE
encoder_outport(VALUE self)
{
    return get_encoder(self)->outport;
}

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

# File 'ext/extbzip3_encoder.c', line 169

static VALUE
encoder_write(VALUE self, VALUE src)
{
    struct encoder *p = get_encoder(self);

    rb_check_type(src, RUBY_T_STRING);

    size_t srclen = RSTRING_LEN(src);

    if (srclen <= p->blocksize) {
        if (rb_type_p(p->srcbuf, RUBY_T_STRING)) {
            size_t srcbuflen = RSTRING_LEN(p->srcbuf);
            size_t catlen = srclen + srcbuflen;

            if (catlen >= p->blocksize) {
                rb_str_cat(p->srcbuf, RSTRING_PTR(src), p->blocksize - srcbuflen);
                encoder_write_encode(self, p, RSTRING_PTR(p->srcbuf), RSTRING_LEN(p->srcbuf));
                rb_str_set_len(p->srcbuf, 0);
                rb_str_cat(p->srcbuf, RSTRING_PTR(src) + p->blocksize - srcbuflen, srclen - (p->blocksize - srcbuflen));

                return self;
            }
        } else {
            p->srcbuf = rb_str_new(0, 0);
        }

        rb_str_cat(p->srcbuf, RSTRING_PTR(src), srclen);

        return self;
    } else {
        size_t srcoff = 0;

        if (rb_type_p(p->srcbuf, RUBY_T_STRING) && RSTRING_LEN(p->srcbuf) > 0) {
            srcoff = p->blocksize - RSTRING_LEN(p->srcbuf);
            rb_str_cat(p->srcbuf, RSTRING_PTR(src), srcoff);
            encoder_write_encode(self, p, RSTRING_PTR(p->srcbuf), RSTRING_LEN(p->srcbuf));
            rb_str_set_len(p->srcbuf, 0);
            srclen = RSTRING_LEN(src); // maybe changed src with `outport << destbuf`
            if (srclen < srcoff) {
                return self;
            }
        }

        while (srclen - srcoff > p->blocksize) {
            encoder_write_encode(self, p, RSTRING_PTR(src) + srcoff, p->blocksize);
            srcoff += p->blocksize;
            srclen = RSTRING_LEN(src); // maybe changed src with `outport << destbuf`
            if (srclen < srcoff) {
                return self;
            }
        }

        if (srcoff < srclen) {
            if (!rb_type_p(p->srcbuf, RUBY_T_STRING)) {
                p->srcbuf = rb_str_new(0, 0);
            }

            rb_str_cat(p->srcbuf, RSTRING_PTR(src), srclen - srcoff);
        }

        return self;
    }
}