MRB_API mrb_value
mrb_hash_keys(mrb_state *mrb, mrb_value hash)
{
khash_t(ht) *h = RHASH_TBL(hash);
khiter_t k;
mrb_int end;
mrb_value ary;
mrb_value *p;
if (!h || kh_size(h) == 0) return mrb_ary_new(mrb);
ary = mrb_ary_new_capa(mrb, kh_size(h));
end = kh_size(h)-1;
mrb_ary_set(mrb, ary, end, mrb_nil_value());
p = RARRAY_PTR(ary);
for (k = kh_begin(h); k != kh_end(h); k++) {
if (kh_exist(h, k)) {
mrb_value kv = kh_key(h, k);
mrb_hash_value hv = kh_value(h, k);
if (hv.n <= end) {
p[hv.n] = kv;
}
else {
p[end] = kv;
}
}
}
return ary;
}
bam_header_t *sam_header_read2(const char *fn)
{
bam_header_t *header;
int c, dret, ret;
gzFile fp;
kstream_t *ks;
kstring_t *str;
kh_ref_t *hash;
khiter_t k;
hash = kh_init(ref);
fp = (strcmp(fn, "-") == 0)? gzdopen(fileno(stdin), "r") : gzopen(fn, "r");
assert(fp);
ks = ks_init(fp);
str = (kstring_t*)calloc(1, sizeof(kstring_t));
while (ks_getuntil(ks, 0, str, &dret) > 0) {
char *s = strdup(str->s);
int len, i;
i = kh_size(hash);
ks_getuntil(ks, 0, str, &dret);
len = atoi(str->s);
k = kh_put(ref, hash, s, &ret);
kh_value(hash, k) = (uint64_t)len<<32 | i;
if (dret != '\n')
while ((c = ks_getc(ks)) != '\n' && c != -1);
}
ks_destroy(ks);
gzclose(fp);
free(str->s); free(str);
fprintf(stderr, "[sam_header_read2] %d sequences loaded.\n", kh_size(hash));
header = hash2header(hash);
kh_destroy(ref, hash);
return header;
}
// Check contig entries match reference
// We check that these match the reference just loaded
static void brkpnt_check_refs_match(cJSON *json,
const ChromHash *genome,
const char *path)
{
cJSON *version = json_hdr_get(json, "format_version", cJSON_Number, path);
if(version->valueint <= 2) return;
cJSON *command = json_hdr_get_curr_cmd(json, path);
cJSON *brkpnts = json_hdr_get(command, "breakpoints", cJSON_Object, path);
cJSON *contigs = json_hdr_get(brkpnts, "contigs", cJSON_Array, path);
cJSON *contig;
size_t num_chroms = 0;
for(contig = contigs->child; contig; contig = contig->next, num_chroms++)
{
cJSON *id = json_hdr_get(contig, "id", cJSON_String, path);
cJSON *len = json_hdr_get(contig, "length", cJSON_Number, path);
// Check chrom is loaded in ref and of expected length
khiter_t k = kh_get(kChromHash, genome, id->valuestring);
if(k == kh_end(genome)) warn("Cannot find chrom [%s]", id->valuestring);
else {
const read_t *r = kh_value(genome, k);
if(r->seq.end != (size_t)len->valueint) {
warn("Chrom lengths do not match %s input:%li ref:%zu",
id->valuestring, len->valueint, r->seq.end);
}
}
}
if(num_chroms != kh_size(genome)) {
warn("Number of chromosomes differ: %zu in header vs %zu in ref",
num_chroms, (size_t)kh_size(genome));
}
}
static mrb_value
hash_equal(mrb_state *mrb, mrb_value hash1, mrb_value hash2, mrb_bool eql)
{
khash_t(ht) *h1, *h2;
mrb_bool eq;
if (mrb_obj_equal(mrb, hash1, hash2)) return mrb_true_value();
if (!mrb_hash_p(hash2)) {
if (!mrb_respond_to(mrb, hash2, mrb_intern_lit(mrb, "to_hash"))) {
return mrb_false_value();
}
else {
if (eql) {
eq = mrb_eql(mrb, hash2, hash1);
}
else {
eq = mrb_equal(mrb, hash2, hash1);
}
return mrb_bool_value(eq);
}
}
h1 = RHASH_TBL(hash1);
h2 = RHASH_TBL(hash2);
if (!h1) {
return mrb_bool_value(!h2);
}
if (!h2) return mrb_false_value();
if (kh_size(h1) != kh_size(h2)) return mrb_false_value();
else {
khiter_t k1, k2;
mrb_value key;
for (k1 = kh_begin(h1); k1 != kh_end(h1); k1++) {
if (!kh_exist(h1, k1)) continue;
key = kh_key(h1,k1);
k2 = kh_get(ht, mrb, h2, key);
if (k2 != kh_end(h2)) {
if (eql)
eq = mrb_eql(mrb, kh_value(h1,k1), kh_value(h2,k2));
else
eq = mrb_equal(mrb, kh_value(h1,k1), kh_value(h2,k2));
if (eq) {
continue; /* next key */
}
}
return mrb_false_value();
}
}
return mrb_true_value();
}
MRB_API void
mrb_hash_set(mrb_state *mrb, mrb_value hash, mrb_value key, mrb_value val)
{
khash_t(ht) *h;
khiter_t k;
int r;
mrb_hash_modify(mrb, hash);
h = RHASH_TBL(hash);
if (!h) h = RHASH_TBL(hash) = kh_init(ht, mrb);
k = kh_put2(ht, mrb, h, key, &r);
kh_value(h, k).v = val;
if (r != 0) {
/* expand */
int ai = mrb_gc_arena_save(mrb);
key = kh_key(h, k) = KEY(key);
mrb_gc_arena_restore(mrb, ai);
kh_value(h, k).n = kh_size(h)-1;
}
mrb_field_write_barrier_value(mrb, (struct RBasic*)RHASH(hash), key);
mrb_field_write_barrier_value(mrb, (struct RBasic*)RHASH(hash), val);
return;
}
static mrb_value
mrb_hash_dup(mrb_state *mrb, mrb_value hash)
{
struct RHash* ret;
khash_t(ht) *h, *ret_h;
khiter_t k, ret_k;
h = RHASH_TBL(hash);
ret = (struct RHash*)mrb_obj_alloc(mrb, MRB_TT_HASH, mrb->hash_class);
ret->ht = kh_init(ht, mrb);
if (kh_size(h) > 0) {
ret_h = ret->ht;
for (k = kh_begin(h); k != kh_end(h); k++) {
if (kh_exist(h,k)) {
int ai = mrb_gc_arena_save(mrb);
ret_k = kh_put(ht, mrb, ret_h, KEY(kh_key(h,k)));
mrb_gc_arena_restore(mrb, ai);
kh_val(ret_h, ret_k) = kh_val(h,k);
}
}
}
return mrb_obj_value(ret);
}
static mrb_value
mrb_hash_shift(mrb_state *mrb, mrb_value hash)
{
khash_t(ht) *h = RHASH_TBL(hash);
khiter_t k;
mrb_value delKey, delVal;
mrb_hash_modify(mrb, hash);
if (h) {
if (kh_size(h) > 0) {
for (k = kh_begin(h); k != kh_end(h); k++) {
if (!kh_exist(h,k)) continue;
delKey = kh_key(h,k);
mrb_gc_protect(mrb, delKey);
delVal = mrb_hash_delete_key(mrb, hash, delKey);
mrb_gc_protect(mrb, delVal);
return mrb_assoc_new(mrb, delKey, delVal);
}
}
}
if (MRB_RHASH_PROCDEFAULT_P(hash)) {
return mrb_funcall(mrb, RHASH_PROCDEFAULT(hash), "call", 2, hash, mrb_nil_value());
}
else {
return RHASH_IFNONE(hash);
}
}
/**
* Gets sequence names and lengths
*/
void bcf_hdr_get_seqs_and_lens(const bcf_hdr_t *h, const char**& seqs, int32_t*& lens, int *n)
{
vdict_t *d = (vdict_t*)h->dict[BCF_DT_CTG];
int tid, m = kh_size(d);
seqs = (const char**) calloc(m,sizeof(const char*));
lens = (int32_t*) calloc(m,sizeof(int32_t));
khint_t k;
for (k=kh_begin(d); k<kh_end(d); k++)
{
if ( !kh_exist(d,k) ) continue;
tid = kh_val(d,k).id;
assert( tid<m );
seqs[tid] = kh_key(d,k);
lens[tid] = 0;
bcf_hrec_t *hrec = kh_val(d, k).hrec[0];
for (int i=0; i<hrec->nkeys; ++i)
{
if (!strcmp(hrec->keys[i],"length"))
{
lens[tid] = atoi(hrec->vals[i]);
}
}
assert(lens[tid]);
}
// sanity check: there should be no gaps
for (tid=0; tid<m; tid++)
assert(seqs[tid]);
*n = m;
}
/**
* Copies contigs found in bcf header to another bcf header.
*/
void bcf_hdr_transfer_contigs(const bcf_hdr_t *hsrc, bcf_hdr_t *hdest)
{
vdict_t *d = (vdict_t*)hsrc->dict[BCF_DT_CTG];
int tid, m = kh_size(d);
const char **names = (const char**) calloc(m,sizeof(const char*));
int len[m];
khint_t k;
for (k=kh_begin(d); k<kh_end(d); k++)
{
if ( !kh_exist(d,k) ) continue;
tid = kh_val(d,k).id;
len[tid] = bcf_hrec_find_key(kh_val(d, k).hrec[0],"length");
int j;
if ( sscanf(kh_val(d, k).hrec[0]->vals[len[tid]],"%d",&j) )
len[tid] = j;
names[tid] = kh_key(d,k);
}
kstring_t s = {0,0,0};
for (tid=0; tid<m; tid++)
{
s.l = 0;
ksprintf(&s, "##contig=<ID=%s,length=%d>", names[tid], len[tid]);
bcf_hdr_append(hdest, s.s);
}
if (s.m) free(s.s);
}
static mrb_value
inspect_hash(mrb_state *mrb, mrb_value hash, int recur)
{
mrb_value str, str2;
khash_t(ht) *h = RHASH_TBL(hash);
khiter_t k;
if (recur) return mrb_str_new_lit(mrb, "{...}");
str = mrb_str_new_lit(mrb, "{");
if (h && kh_size(h) > 0) {
for (k = kh_begin(h); k != kh_end(h); k++) {
int ai;
if (!kh_exist(h,k)) continue;
ai = mrb_gc_arena_save(mrb);
if (RSTRING_LEN(str) > 1) mrb_str_cat_lit(mrb, str, ", ");
str2 = mrb_inspect(mrb, kh_key(h,k));
mrb_str_append(mrb, str, str2);
mrb_str_cat_lit(mrb, str, "=>");
str2 = mrb_inspect(mrb, kh_value(h,k));
mrb_str_append(mrb, str, str2);
mrb_gc_arena_restore(mrb, ai);
}
}
mrb_str_cat_lit(mrb, str, "}");
return str;
}
void bcf_hdr_add_sample(bcf_hdr_t *h, char *s)
{
vdict_t *d = (vdict_t*)h->dict[BCF_DT_SAMPLE];
int ret;
int k = kh_put(vdict, d, s, &ret);
if (ret) { // absent
kh_val(d, k) = bcf_idinfo_def;
kh_val(d, k).id = kh_size(d) - 1;
} else {
if (hts_verbose >= 2)
fprintf(stderr, "[W::%s] Duplicated sample name '%s'. Skipped.\n", __func__, s);
}
int n = kh_size(d);
h->samples = (char**) realloc(h->samples,sizeof(char*)*n);
h->samples[n-1] = s;
}
static size_t
iv_size(mrb_state *mrb, iv_tbl *t)
{
if (t) {
return kh_size(&t->h);
}
return 0;
}
void h2o_filecache_destroy(h2o_filecache_t *cache)
{
h2o_filecache_clear(cache);
assert(kh_size(cache->hash) == 0);
assert(h2o_linklist_is_empty(&cache->lru));
kh_destroy(opencache_set, cache->hash);
free(cache);
}
/** Reset the per-interval counters in an attack vector
*
* @param av The attack vector to be reset
*/
static void attack_vector_reset(attack_vector_t *av)
{
assert(av != NULL);
av->interval_packet_cnt = 0;
av->interval_byte_cnt = 0;
av->attack_ip_cnt = kh_size(av->attack_ip_hash);
}
static size_t
iv_size(mrb_state *mrb, iv_tbl *t)
{
khash_t(iv) *h = &t->h;
if (!h) return 0;
return kh_size(h);
}
/*
* call-seq:
* hsh.empty? -> true or false
*
* Returns <code>true</code> if <i>hsh</i> contains no key-value pairs.
*
* {}.empty? #=> true
*
*/
mrb_value
mrb_hash_empty_p(mrb_state *mrb, mrb_value self)
{
khash_t(ht) *h = RHASH_TBL(self);
if (h) return mrb_bool_value(kh_size(h) == 0);
return mrb_true_value();
}
size_t
mrb_gc_mark_mt_size(mrb_state *mrb, struct RClass *c)
{
khash_t(mt) *h = c->mt;
if (!h) return 0;
return kh_size(h);
}
/*
* call-seq:
* hsh.length -> fixnum
* hsh.size -> fixnum
*
* Returns the number of key-value pairs in the hash.
*
* h = { "d" => 100, "a" => 200, "v" => 300, "e" => 400 }
* h.length #=> 4
* h.delete("a") #=> 200
* h.length #=> 3
*/
static mrb_value
mrb_hash_size_m(mrb_state *mrb, mrb_value self)
{
khash_t(ht) *h = RHASH_TBL(self);
if (!h) return mrb_fixnum_value(0);
return mrb_fixnum_value(kh_size(h));
}
int bcf_hdr_sync(bcf_hdr_t *h)
{
int i;
for (i = 0; i < 3; ++i) {
khint_t k;
vdict_t *d = (vdict_t*)h->dict[i];
if ( h->n[i] < kh_size(d) )
h->id[i] = (bcf_idpair_t*)realloc(h->id[i], kh_size(d) * sizeof(bcf_idpair_t));
h->n[i] = kh_size(d);
for (k = kh_begin(d); k != kh_end(d); ++k) {
if (!kh_exist(d, k)) continue;
h->id[i][kh_val(d, k).id].key = kh_key(d, k);
h->id[i][kh_val(d, k).id].val = &kh_val(d, k);
}
}
return 0;
}
static bam_header_t *hash2header(const kh_ref_t *hash)
{
bam_header_t *header;
khiter_t k;
header = bam_header_init();
header->n_targets = kh_size(hash);
header->target_name = (char**)calloc(kh_size(hash), sizeof(char*));
header->target_len = (uint32_t*)calloc(kh_size(hash), 4);
for (k = kh_begin(hash); k != kh_end(hash); ++k) {
if (kh_exist(hash, k)) {
int i = (int)kh_value(hash, k);
header->target_name[i] = (char*)kh_key(hash, k);
header->target_len[i] = kh_value(hash, k)>>32;
}
}
bam_init_header_hash(header);
return header;
}
static mrb_value
mrb_hash_inspect(mrb_state *mrb, mrb_value hash)
{
khash_t(ht) *h = RHASH_TBL(hash);
if (!h || kh_size(h) == 0)
return mrb_str_new_lit(mrb, "{}");
return inspect_hash(mrb, hash, 0);
}
static size_t
iv_size(mrb_state *mrb, iv_tbl *t)
{
khash_t(iv) *h;
if (t && (h = &t->h)) {
return kh_size(h);
}
return 0;
}
void h2o_filecache_clear(h2o_filecache_t *cache)
{
khiter_t iter;
for (iter = kh_begin(cache->hash); iter != kh_end(cache->hash); ++iter) {
if (!kh_exist(cache->hash, iter))
continue;
release_from_cache(cache, iter);
}
assert(kh_size(cache->hash) == 0);
}
void git_cache_dump_stats(git_cache *cache)
{
git_cached_obj *object;
if (kh_size(cache->map) == 0)
return;
Rprintf("Cache %p: %d items cached, %d bytes\n",
cache, kh_size(cache->map), (int)cache->used_memory);
kh_foreach_value(cache->map, object, {
char oid_str[9];
Rprintf(" %s%c %s (%d)\n",
git_object_type2string(object->type),
object->flags == GIT_CACHE_STORE_PARSED ? '*' : ' ',
git_oid_tostr(oid_str, sizeof(oid_str), &object->oid),
(int)object->size
);
});
h2o_filecache_ref_t *h2o_filecache_open_file(h2o_filecache_t *cache, const char *path, int oflag)
{
khiter_t iter = kh_get(opencache_set, cache->hash, path);
h2o_filecache_ref_t *ref;
int dummy;
/* lookup cache, and return the one if found */
if (iter != kh_end(cache->hash)) {
ref = H2O_STRUCT_FROM_MEMBER(h2o_filecache_ref_t, _path, kh_key(cache->hash, iter));
++ref->_refcnt;
goto Exit;
}
/* create a new cache entry */
ref = h2o_mem_alloc(offsetof(h2o_filecache_ref_t, _path) + strlen(path) + 1);
ref->_refcnt = 1;
ref->_lru = (h2o_linklist_t){NULL};
strcpy(ref->_path, path);
/* if cache is used, then... */
if (cache->capacity != 0) {
/* purge one entry from LRU if cache is full */
if (kh_size(cache->hash) == cache->capacity) {
h2o_filecache_ref_t *purge_ref = H2O_STRUCT_FROM_MEMBER(h2o_filecache_ref_t, _lru, cache->lru.prev);
khiter_t purge_iter = kh_get(opencache_set, cache->hash, purge_ref->_path);
assert(purge_iter != kh_end(cache->hash));
release_from_cache(cache, purge_iter);
}
/* assign the new entry */
++ref->_refcnt;
kh_put(opencache_set, cache->hash, ref->_path, &dummy);
h2o_linklist_insert(cache->lru.next, &ref->_lru);
}
/* open the file, or memoize the error */
if ((ref->fd = open(path, oflag)) != -1 && fstat(ref->fd, &ref->st) == 0) {
ref->_last_modified.str[0] = '\0';
ref->_etag.len = 0;
} else {
ref->open_err = errno;
if (ref->fd != -1) {
close(ref->fd);
ref->fd = -1;
}
}
Exit:
/* if the cache entry retains an error, return it instead of the reference */
if (ref->fd == -1) {
errno = ref->open_err;
h2o_filecache_close_file(ref);
ref = NULL;
}
return ref;
}
int bcf_hdr_parse1(bcf_hdr_t *h, const char *str)
{
khint_t k;
if (*str != '#') return -1;
if (str[1] == '#') {
uint32_t info;
int len, ret, id_beg, id_end;
char *s;
len = bcf_hdr_parse_line2(str, &info, &id_beg, &id_end);
if (len < 0) return -1;
s = (char*)malloc(id_end - id_beg + 1);
strncpy(s, str + id_beg, id_end - id_beg);
s[id_end - id_beg] = 0;
if (len > 0) { // a contig line
vdict_t *d = (vdict_t*)h->dict[BCF_DT_CTG];
k = kh_put(vdict, d, s, &ret);
if (ret == 0) {
if (hts_verbose >= 2)
fprintf(stderr, "[W::%s] Duplicated contig name '%s'. Skipped.\n", __func__, s);
free(s);
} else {
kh_val(d, k) = bcf_idinfo_def;
kh_val(d, k).id = kh_size(d) - 1;
kh_val(d, k).info[0] = len;
}
} else { // a FILTER/INFO/FORMAT line
vdict_t *d = (vdict_t*)h->dict[BCF_DT_ID];
k = kh_put(vdict, d, s, &ret);
if (ret) { // absent from the dict
kh_val(d, k) = bcf_idinfo_def;
kh_val(d, k).info[info&0xf] = info;
kh_val(d, k).id = kh_size(d) - 1;
} else {
kh_val(d, k).info[info&0xf] = info;
free(s);
}
}
} else
bcf_hdr_parse_sample_line(h, str);
return 0;
}
size_t
mrb_gc_mark_ht_size(mrb_state *mrb, struct RHash *c)
{
size_t ht_size = 0;
khash_t(ht) *h = c->ht;
/* ((struct RHash*)c)->ht */
if (h) ht_size += kh_size(h)*2;
return ht_size;
}
/*
* call-seq:
* hsh.empty? -> true or false
*
* Returns <code>true</code> if <i>hsh</i> contains no key-value pairs.
*
* {}.empty? #=> true
*
*/
static mrb_value
mrb_hash_empty_p(mrb_state *mrb, mrb_value self)
{
khash_t(ht) *h = RHASH_TBL(self);
if (h) {
if (kh_size(h) == 0)
return mrb_true_value();
}
return mrb_false_value();
}
static void deduplicate_islands(struct repository *r)
{
struct remote_island *island, *core = NULL, **list;
unsigned int island_count, dst, src, ref, i = 0;
island_count = kh_size(remote_islands);
ALLOC_ARRAY(list, island_count);
kh_foreach_value(remote_islands, island, {
list[i++] = island;
});
static mrb_value
hash_equal(mrb_state *mrb, mrb_value hash1, mrb_value hash2, int eql)
{
khash_t(ht) *h1, *h2;
if (mrb_obj_equal(mrb, hash1, hash2)) return mrb_true_value();
if (mrb_type(hash2) != MRB_TT_HASH) {
if (!mrb_respond_to(mrb, hash2, mrb_intern(mrb, "to_hash"))) {
return mrb_false_value();
}
if (eql)
return mrb_fixnum_value(mrb_eql(mrb, hash2, hash1));
else
return mrb_fixnum_value(mrb_equal(mrb, hash2, hash1));
}
h1 = RHASH_TBL(hash1);
h2 = RHASH_TBL(hash2);
if (!h2) {
if (!h2) return mrb_true_value();
return mrb_false_value();
}
if (!h2) return mrb_false_value();
if (kh_size(h1) != kh_size(h2)) return mrb_false_value();
else {
khiter_t k1, k2;
mrb_value key;
for (k1 = kh_begin(h1); k1 != kh_end(h1); k1++) {
if (!kh_exist(h1, k1)) continue;
key = kh_key(h1,k1);
k2 = kh_get(ht, h2, key);
if (k2 != kh_end(h2)) {
if (mrb_equal(mrb, kh_value(h1,k1), kh_value(h2,k2))) {
continue; /* next key */
}
}
return mrb_false_value();
}
}
return mrb_true_value();
}
