Class: HTS::Native::MpileupHandle

Inherits:

Object

• Object
• HTS::Native::MpileupHandle

Defined in:

ext/htslib_native/native_bam.c

Class Method Summary

• .open(files, headers, region, beg, end, maxcnt, overlaps) ⇒ Object

Instance Method Summary

• #close ⇒ Object
• #next ⇒ Object
• #reset ⇒ Object

Class Method Details

.open(files, headers, region, beg, end, maxcnt, overlaps) ⇒ Object

# File 'ext/htslib_native/native_bam.c', line 990

static VALUE native_mpileup_open(VALUE klass, VALUE files, VALUE headers, VALUE region,
                                 VALUE beg, VALUE end, VALUE maxcnt, VALUE overlaps) {
    ruby_mpileup_t *value;
    VALUE object;
    int index, count;
    Check_Type(files, T_ARRAY);
    Check_Type(headers, T_ARRAY);
    count = RARRAY_LEN(files);
    if (count <= 0 || RARRAY_LEN(headers) != count) rb_raise(rb_eArgError, "invalid mpileup inputs");
    object = TypedData_Make_Struct(klass, ruby_mpileup_t, &mpileup_type, value);
    memset(value, 0, sizeof(*value));
    value->count = count;
    value->files = files;
    value->headers = headers;
    RB_OBJ_WRITE(object, &value->files, files);
    RB_OBJ_WRITE(object, &value->headers, headers);
    value->inputs = ALLOC_N(ruby_mplp_input_t, count);
    value->input_data = ALLOC_N(void *, count);
    value->depths = ALLOC_N(int, count);
    value->entries = ALLOC_N(const bam_pileup1_t *, count);
    memset(value->inputs, 0, sizeof(ruby_mplp_input_t) * count);
    for (index = 0; index < count; index++) {
        ruby_bam_file_t *file = get_file(rb_ary_entry(files, index), 0);
        sam_hdr_t *header = get_header(rb_ary_entry(headers, index))->pointer;
        value->inputs[index].file = file;
        value->inputs[index].header = header;
        if (!NIL_P(region)) {
            if (!file->index) { mpileup_release(value); rb_raise(rb_eRuntimeError, "index file is required to use region mpileup"); }
            if (NIL_P(beg) && NIL_P(end))
                value->inputs[index].iterator = sam_itr_querys(file->index, header, StringValueCStr(region));
            else
                value->inputs[index].iterator = sam_itr_queryi(file->index, sam_hdr_name2tid(header, StringValueCStr(region)), NUM2LL(beg), NUM2LL(end));
            if (!value->inputs[index].iterator) { mpileup_release(value); rb_raise(rb_eRuntimeError, "failed to query mpileup region"); }
        }
        value->input_data[index] = &value->inputs[index];
    }
    value->pileup = bam_mplp_init(count, native_mpileup_read, value->input_data);
    if (!value->pileup) { mpileup_release(value); rb_raise(rb_eNoMemError, "bam_mplp_init failed"); }
    if (!NIL_P(maxcnt)) bam_mplp_set_maxcnt(value->pileup, NUM2INT(maxcnt));
    if (RTEST(overlaps) && bam_mplp_init_overlaps(value->pileup) < 0) {
        mpileup_release(value);
        rb_raise(rb_eRuntimeError, "bam_mplp_init_overlaps failed");
    }
    return object;
}

Instance Method Details

#close ⇒ Object

# File 'ext/htslib_native/native_bam.c', line 1057

static VALUE native_mpileup_close(VALUE self) { mpileup_release(get_mpileup(self, 1)); return Qnil; }

#next ⇒ Object

# File 'ext/htslib_native/native_bam.c', line 1035

static VALUE native_mpileup_next(VALUE self) {
    ruby_mpileup_t *value = get_mpileup(self, 0);
    int tid = -1, result, index;
    hts_pos_t position = -1;
    VALUE rows, depths, output;
    result = bam_mplp64_auto(value->pileup, &tid, &position, value->depths, value->entries);
    if (result == 0) return Qnil;
    if (result < 0) rb_raise(rb_eRuntimeError, "HTSlib mpileup error");
    rows = rb_ary_new_capa(value->count);
    depths = rb_ary_new_capa(value->count);
    for (index = 0; index < value->count; index++) {
        rb_ary_push(depths, INT2NUM(value->depths[index]));
        rb_ary_push(rows, pileup_rows(value->entries[index], value->depths[index]));
    }
    output = rb_ary_new_capa(4);
    rb_ary_push(output, INT2NUM(tid));
    rb_ary_push(output, LL2NUM(position));
    rb_ary_push(output, depths);
    rb_ary_push(output, rows);
    return output;
}

#reset ⇒ Object

# File 'ext/htslib_native/native_bam.c', line 1056

static VALUE native_mpileup_reset(VALUE self) { bam_mplp_reset(get_mpileup(self, 0)->pileup); return Qnil; }