} pair64_t;
#define pair64_lt(a,b) ((a).u < (b).u)
-KSORT_INIT(off, pair64_t, pair64_lt)
+KSORT_INIT(offt, pair64_t, pair64_lt)
typedef struct {
uint32_t m, n;
return tid;
}
-static int get_intv(ti_index_t *idx, kstring_t *str, ti_intv_t *intv)
+int ti_get_intv(const ti_conf_t *conf, int len, char *line, ti_interval_t *intv)
{
- int i, b = 0, id = 1;
+ int i, b = 0, id = 1, ncols = 0;
char *s;
- intv->tid = intv->beg = intv->end = intv->bin = -1;
- for (i = 0; i <= str->l; ++i) {
- if (str->s[i] == '\t' || str->s[i] == 0) {
- if (id == idx->conf.sc) {
- str->s[i] = 0;
- intv->tid = get_tid(idx, str->s + b);
- if (i != str->l) str->s[i] = '\t';
- } else if (id == idx->conf.bc) {
+ intv->ss = intv->se = 0; intv->beg = intv->end = -1;
+ for (i = 0; i <= len; ++i) {
+ if (line[i] == '\t' || line[i] == 0) {
+ ++ncols;
+ if (id == conf->sc) {
+ intv->ss = line + b; intv->se = line + i;
+ } else if (id == conf->bc) {
// here ->beg is 0-based.
- intv->beg = intv->end = strtol(str->s + b, &s, 0);
- if (!(idx->conf.preset&TI_FLAG_UCSC)) --intv->beg;
+ intv->beg = intv->end = strtol(line + b, &s, 0);
+ if (!(conf->preset&TI_FLAG_UCSC)) --intv->beg;
else ++intv->end;
if (intv->beg < 0) intv->beg = 0;
if (intv->end < 1) intv->end = 1;
} else {
- if ((idx->conf.preset&0xffff) == TI_PRESET_GENERIC) {
- if (id == idx->conf.ec) intv->end = strtol(str->s + b, &s, 0);
- } else if ((idx->conf.preset&0xffff) == TI_PRESET_SAM) {
+ if ((conf->preset&0xffff) == TI_PRESET_GENERIC) {
+ if (id == conf->ec) intv->end = strtol(line + b, &s, 0);
+ } else if ((conf->preset&0xffff) == TI_PRESET_SAM) {
if (id == 6) { // CIGAR
int l = 0, op;
char *t;
- for (s = str->s + b; s < str->s + i;) {
+ for (s = line + b; s < line + i;) {
long x = strtol(s, &t, 10);
op = toupper(*t);
if (op == 'M' || op == 'D' || op == 'N') l += x;
if (l == 0) l = 1;
intv->end = intv->beg + l;
}
- } else if ((idx->conf.preset&0xffff) == TI_PRESET_VCF) {
+ } else if ((conf->preset&0xffff) == TI_PRESET_VCF) {
// FIXME: the following is NOT tested and is likely to be buggy
- if (id == 5) { // ALT
- char *t;
- int max = 1;
- for (s = str->s + b; s < str->s + i;) {
- if (s[i] == 'D') {
- long x = strtol(s + 1, &t, 10);
- if (x > max) max = x;
- s = t + 1;
- } else ++s;
+ if (id == 4) {
+ if (b < i) intv->end = intv->beg + (i - b);
+ } else if (id == 8) { // look for "END="
+ int c = line[i];
+ line[i] = 0;
+ s = strstr(line + b, "END=");
+ if (s == line + b) s += 4;
+ else if (s) {
+ s = strstr(line + b, ";END=");
+ if (s) s += 5;
}
- intv->end = intv->beg + max;
+ if (s) intv->end = strtol(s, &s, 0);
+ line[i] = c;
}
}
}
++id;
}
}
- if (intv->tid < 0 || intv->beg < 0 || intv->end < 0) return -1;
- intv->bin = ti_reg2bin(intv->beg, intv->end);
+/*
+ if (ncols < conf->sc || ncols < conf->bc || ncols < conf->ec) {
+ if (ncols == 1) fprintf(stderr,"[get_intv] Is the file tab-delimited? The line has %d field only: %s\n", ncols, line);
+ else fprintf(stderr,"[get_intv] The line has %d field(s) only: %s\n", ncols, line);
+ exit(1);
+ }
+*/
+ if (intv->ss == 0 || intv->se == 0 || intv->beg < 0 || intv->end < 0) return -1;
return 0;
}
+static int get_intv(ti_index_t *idx, kstring_t *str, ti_intv_t *intv)
+{
+ ti_interval_t x;
+ intv->tid = intv->beg = intv->end = intv->bin = -1;
+ if (ti_get_intv(&idx->conf, str->l, str->s, &x) == 0) {
+ int c = *x.se;
+ *x.se = '\0'; intv->tid = get_tid(idx, x.ss); *x.se = c;
+ intv->beg = x.beg; intv->end = x.end;
+ intv->bin = ti_reg2bin(intv->beg, intv->end);
+ return (intv->tid >= 0 && intv->beg >= 0 && intv->end >= 0)? 0 : -1;
+ } else {
+ fprintf(stderr, "[%s] the following line cannot be parsed and skipped: %s\n", __func__, str->s);
+ return -1;
+ }
+}
+
/************
* indexing *
************/
l->list[l->n].u = beg; l->list[l->n++].v = end;
}
-static inline void insert_offset2(ti_lidx_t *index2, int _beg, int _end, uint64_t offset)
+static inline uint64_t insert_offset2(ti_lidx_t *index2, int _beg, int _end, uint64_t offset)
{
int i, beg, end;
beg = _beg >> TAD_LIDX_SHIFT;
if (index2->offset[i] == 0) index2->offset[i] = offset;
}
if (index2->n < end + 1) index2->n = end + 1;
+ return (uint64_t)beg<<32 | end;
}
static void merge_chunks(ti_index_t *idx)
ti_index_t *idx;
uint32_t last_bin, save_bin;
int32_t last_coor, last_tid, save_tid;
- uint64_t save_off, last_off, lineno = 0;
+ uint64_t save_off, last_off, lineno = 0, offset0 = (uint64_t)-1, tmp;
kstring_t *str;
str = calloc(1, sizeof(kstring_t));
continue;
}
get_intv(idx, str, &intv);
+ if ( intv.beg<0 || intv.end<0 )
+ {
+ fprintf(stderr,"[ti_index_core] the indexes overlap or are out of bounds\n");
+ exit(1);
+ }
if (last_tid != intv.tid) { // change of chromosomes
+ if (last_tid>intv.tid )
+ {
+ fprintf(stderr,"[ti_index_core] the chromosome blocks not continuous at line %llu, is the file sorted? [pos %d]\n",(unsigned long long)lineno,intv.beg+1);
+ exit(1);
+ }
last_tid = intv.tid;
last_bin = 0xffffffffu;
} else if (last_coor > intv.beg) {
fprintf(stderr, "[ti_index_core] the file out of order at line %llu\n", (unsigned long long)lineno);
exit(1);
}
- insert_offset2(&idx->index2[intv.tid], intv.beg, intv.end, last_off);
+ tmp = insert_offset2(&idx->index2[intv.tid], intv.beg, intv.end, last_off);
+ if (last_off == 0) offset0 = tmp;
if (intv.bin != last_bin) { // then possibly write the binning index
if (save_bin != 0xffffffffu) // save_bin==0xffffffffu only happens to the first record
insert_offset(idx->index[save_tid], save_bin, save_off, last_off);
if (save_tid >= 0) insert_offset(idx->index[save_tid], save_bin, save_off, bgzf_tell(fp));
merge_chunks(idx);
fill_missing(idx);
+ if (offset0 != (uint64_t)-1 && idx->n && idx->index2[0].offset) {
+ int i, beg = offset0>>32, end = offset0&0xffffffffu;
+ for (i = beg; i <= end; ++i) idx->index2[0].offset[i] = 0;
+ }
free(str->s); free(str);
return idx;
char *fname = get_local_version(fn);
if (fname == 0) return 0;
idx = ti_index_load_local(fname);
+ if (idx == 0) fprintf(stderr, "[ti_index_load] fail to load the index: %s\n", fname);
free(fname);
- if (idx == 0) fprintf(stderr, "[ti_index_load] fail to load BAM index.\n");
return idx;
}
BGZF *fp, *fpidx;
ti_index_t *idx;
if ((fp = bgzf_open(fn, "r")) == 0) {
- fprintf(stderr, "[ti_index_build2] fail to open the BAM file.\n");
+ fprintf(stderr, "[ti_index_build2] fail to open the file: %s\n", fn);
return -1;
}
idx = ti_index_core(fp, conf);
if (p->list[j].v > min_off) off[n_off++] = p->list[j];
}
}
+ if (n_off == 0) {
+ free(bins); free(off); return iter;
+ }
free(bins);
{
int l;
- ks_introsort(off, n_off, off);
+ ks_introsort(offt, n_off, off);
// resolve completely contained adjacent blocks
for (i = 1, l = 0; i < n_off; ++i)
if (off[l].v < off[i].v)
return 0;
}
+const ti_conf_t *ti_get_conf(ti_index_t *idx) { return idx? &idx->conf : 0; }
+
/*******************
* High-level APIs *
*******************/
return ti_iter_query(t->idx, tid, beg, end);
}
+ti_iter_t ti_querys(tabix_t *t, const char *reg)
+{
+ int tid, beg, end;
+ if (reg == 0) return ti_iter_first();
+ if (ti_lazy_index_load(t) != 0) return 0;
+ if (ti_parse_region(t->idx, reg, &tid, &beg, &end) < 0) return 0;
+ return ti_iter_query(t->idx, tid, beg, end);
+}
+
ti_iter_t ti_query(tabix_t *t, const char *name, int beg, int end)
{
int tid;