static mrb_value
mrb_hash_has_valueWithvalue(mrb_state *mrb, mrb_value hash, mrb_value value)
{
khash_t(ht) *h = RHASH_TBL(hash);
khiter_t k;
if (h) {
for (k = kh_begin(h); k != kh_end(h); k++) {
if (!kh_exist(h, k)) continue;
if (mrb_equal(mrb, kh_value(h,k), value)) {
return mrb_true_value();
}
}
}
return mrb_false_value();
}
mrb_value
mrb_hash_get(mrb_state *mrb, mrb_value hash, mrb_value key)
{
khash_t(ht) *h = RHASH_TBL(hash);
khiter_t k;
if (h) {
k = kh_get(ht, h, key);
if (k != kh_end(h))
return kh_value(h, k);
}
/* not found */
if (MRB_RHASH_PROCDEFAULT_P(hash)) {
return mrb_funcall(mrb, RHASH_PROCDEFAULT(hash), "call", 2, hash, key);
}
return RHASH_IFNONE(hash);
}
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_values(mrb_state *mrb, mrb_value hash)
{
khash_t(ht) *h = RHASH_TBL(hash);
khiter_t k;
mrb_value ary = mrb_ary_new(mrb);
if (!h) return ary;
for (k = kh_begin(h); k != kh_end(h); k++) {
if (kh_exist(h, k)){
mrb_value v = kh_value(h,k);
if ( !mrb_special_const_p(v) )
v = mrb_obj_dup(mrb, v);
mrb_ary_push(mrb, ary, v);
}
}
return ary;
}
mrb_value
mrb_hash_delete_key(mrb_state *mrb, mrb_value hash, mrb_value key)
{
khash_t(ht) *h = RHASH_TBL(hash);
khiter_t k;
mrb_value delVal;
if (h) {
k = kh_get(ht, mrb, h, key);
if (k != kh_end(h)) {
delVal = kh_value(h, k);
kh_del(ht, mrb, h, k);
return delVal;
}
}
/* not found */
return mrb_nil_value();
}
mrb_value
mrb_check_intern(mrb_state *mrb, const char *name, size_t len)
{
khash_t(n2s) *h = mrb->name2sym;
symbol_name sname;
khiter_t k;
if (len > UINT16_MAX) {
mrb_raise(mrb, E_ARGUMENT_ERROR, "symbol length too long");
}
sname.len = len;
sname.name = name;
k = kh_get(n2s, mrb, h, sname);
if (k != kh_end(h)) {
return mrb_symbol_value(kh_value(h, k));
}
return mrb_nil_value();
}
int merge_interval(kh_pos_t* positions_read, char *max_chromosome_merged, unsigned long max_position_merged,
char **chromosome_order, int num_chromosomes, vcf_file_t **files,
shared_options_data_t *shared_options_data, merge_options_data_t *options_data, list_t *output_list) {
int num_entries = 0;
#pragma omp parallel for num_threads(shared_options_data->num_threads) reduction(+:num_entries)
for (int k = kh_begin(positions_read); k < kh_end(positions_read); k++) {
if (kh_exist(positions_read, k)) {
array_list_t *records_in_position = kh_value(positions_read, k);
assert(records_in_position);
vcf_record_t *record = ((vcf_record_file_link*) array_list_get(0, records_in_position))->record;
vcf_record_file_link **links = NULL;
int num_links = 0;
// Remove positions prior to the last chromosome:position to merge
int cmp_chrom = compare_chromosomes(record->chromosome, max_chromosome_merged, chromosome_order, num_chromosomes);
if (cmp_chrom < 0 || (cmp_chrom == 0 && compare_positions(record->position, max_position_merged) <= 0)) {
links = records_in_position->items;
num_links = records_in_position->size;
}
// Launch merge
if (num_links > 0) {
// printf("links[0] = %s:%ld in file %s\n", links[0]->record->chromosome, links[0]->record->position, links[0]->file->filename);
int err_code = 0;
vcf_record_t *merged = merge_position(links, num_links, files, options_data->num_files, options_data, &err_code);
if (!err_code) {
list_item_t *item = list_item_new(k, MERGED_RECORD, merged);
list_insert_item(item, output_list);
num_entries += 1;
}
// Free empty nodes (lists of records in the same position)
array_list_free(records_in_position, vcf_record_file_link_free);
kh_del(pos, positions_read, k);
}
} // End kh_exist
}
return num_entries;
}
static int
add_to_include_set(struct bitmap *base, struct commit *commit)
{
khiter_t hash_pos;
uint32_t bitmap_pos = find_object_pos(commit->object.sha1);
if (bitmap_get(base, bitmap_pos))
return 0;
hash_pos = kh_get_sha1(writer.bitmaps, commit->object.sha1);
if (hash_pos < kh_end(writer.bitmaps)) {
struct bitmapped_commit *bc = kh_value(writer.bitmaps, hash_pos);
bitmap_or_ewah(base, bc->bitmap);
return 0;
}
bitmap_set(base, bitmap_pos);
return 1;
}
void
int_htable_destroy(int_htable *ht)
{
khiter_t k;
if (!ht) {
return;
}
for (k = kh_begin(sh->htable); k != kh_end(ht->htable); ++k) {
if (kh_exist(ht->htable, k)) {
if (ht->free_value_fn) {
ht->free_value_fn(kh_value(ht->htable,k));
}
}
}
kh_destroy(int, ht->htable);
free(ht);
}
void
mrb_hash_set(mrb_state *mrb, mrb_value hash, mrb_value key, mrb_value val) /* mrb_hash_aset */
{
khash_t(ht) *h;
khiter_t k;
mrb_hash_modify(mrb, hash);
h = RHASH_TBL(hash);
k = kh_get(ht, h, key);
if (k == kh_end(h)) {
/* expand */
k = kh_put(ht, h, KEY(key));
}
kh_value(h, k) = val;
mrb_write_barrier(mrb, (struct RBasic*)RHASH(hash));
return;
}
/* lenp must be a pointer to a size_t variable */
const char*
mrb_sym2name_len(mrb_state *mrb, mrb_sym sym, size_t *lenp)
{
khash_t(n2s) *h = mrb->name2sym;
khiter_t k;
symbol_name sname;
for (k = kh_begin(h); k != kh_end(h); k++) {
if (kh_exist(h, k)) {
if (kh_value(h, k) == sym) {
sname = kh_key(h, k);
*lenp = sname.len;
return sname.name;
}
}
}
*lenp = 0;
return NULL; /* missing */
}
int forwardIndexTokenFunc(void *ctx, Token t) {
ForwardIndex *idx = ctx;
// we hash the string ourselves because khash suckz azz
u_int32_t hval = fnv_32a_buf((void *)t.s, t.len, 0);
ForwardIndexEntry *h = NULL;
khiter_t k = kh_get(32, idx->hits, hval); // first have to get ieter
if (k == kh_end(idx->hits)) { // k will be equal to kh_end if key not present
h = calloc(1, sizeof(ForwardIndexEntry));
h->docId = idx->docId;
h->flags = 0;
h->term = t.s;
h->len = t.len;
h->vw = NewVarintVectorWriter(4);
h->docScore = idx->docScore;
int ret;
k = kh_put(32, idx->hits, hval, &ret);
kh_value(idx->hits, k) = h;
} else {
h = kh_val(idx->hits, k);
}
h->flags |= (t.fieldId & 0xff);
float score = (float)t.score;
// stem tokens get lower score
if (t.type == DT_STEM) {
score *= STEM_TOKEN_FACTOR;
}
h->freq += score;
idx->totalFreq += (float)t.score;
idx->maxFreq = MAX(h->freq, idx->maxFreq);
VVW_Write(h->vw, t.pos);
// LG_DEBUG("%d) %s, token freq: %f total freq: %f\n", t.pos, t.s, h->freq, idx->totalFreq);
return 0;
}
char* release(int procid){
printf("Process %d released critical action.\n", procid);
inquired = false;
state = "NONE";
if(kh_size(h) == 0){
voted = false;
return "0, 0";
}
else{
int process = findProcessWithLowestTimeStamp();
int minTimeStamp = kh_value(h, process);
kh_del(16, h, process);
candidateID = process;
candidateLamport = minTimeStamp;
locked = candidateID;
char back[30];
sprintf(back, "%d, LOCKED.", candidateID);
return strdup(back);
}
}
static mrb_bool
iv_foreach(mrb_state *mrb, iv_tbl *t, iv_foreach_func *func, void *p)
{
khash_t(iv) *h = &t->h;
khiter_t k;
int n;
if (h) {
for (k = kh_begin(h); k != kh_end(h); k++) {
if (kh_exist(h, k)) {
n = (*func)(mrb, kh_key(h, k), kh_value(h, k), p);
if (n > 0) return FALSE;
if (n < 0) {
kh_del(iv, h, k);
}
}
}
}
return TRUE;
}
MRB_API mrb_value
mrb_hash_get(mrb_state *mrb, mrb_value hash, mrb_value key)
{
khash_t(ht) *h = RHASH_TBL(hash);
khiter_t k;
mrb_sym mid;
if (h) {
k = kh_get(ht, mrb, h, key);
if (k != kh_end(h))
return kh_value(h, k).v;
}
mid = mrb_intern_lit(mrb, "default");
if (mrb_func_basic_p(mrb, hash, mid, mrb_hash_default)) {
return hash_default(mrb, hash, key);
}
/* xxx mrb_funcall_tailcall(mrb, hash, "default", 1, key); */
return mrb_funcall_argv(mrb, hash, mid, 1, &key);
}
/* incremented reference count and return the handler */
static ucs_async_handler_t *ucs_async_handler_get(int id)
{
ucs_async_handler_t *handler;
khiter_t hash_it;
pthread_rwlock_rdlock(&ucs_async_global_context.handlers_lock);
hash_it = ucs_async_handler_kh_get(id);
if (ucs_async_handler_kh_is_end(hash_it)) {
handler = NULL;
goto out_unlock;
}
handler = kh_value(&ucs_async_global_context.handlers, hash_it);
ucs_assert_always(handler->id == id);
ucs_async_handler_hold(handler);
out_unlock:
pthread_rwlock_unlock(&ucs_async_global_context.handlers_lock);
return handler;
}
bam_header_t *sam_header_read2(const char *fn)
{
bam_header_t *header;
int c, dret, ret, error = 0;
gzFile fp;
kstream_t *ks;
kstring_t *str;
kh_ref_t *hash;
khiter_t k;
if (fn == 0) return 0;
fp = (strcmp(fn, "-") == 0)? gzdopen(fileno(stdin), "r") : gzopen(fn, "r");
if (fp == 0) return 0;
hash = kh_init(ref);
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);
if (ret == 0) {
// REP: fprintf(stderr, "[sam_header_read2] duplicated sequence name: %s\n", s);
Rprintf("[sam_header_read2] duplicated sequence name: %s\n", s);
error = 1;
}
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);
// REP: fprintf(stderr, "[sam_header_read2] %d sequences loaded.\n", kh_size(hash));
Rprintf("[sam_header_read2] %d sequences loaded.\n", kh_size(hash));
if (error) return 0;
header = hash2header(hash);
kh_destroy(ref, hash);
return header;
}
static mrb_value
mrb_hash_has_value(mrb_state *mrb, mrb_value hash)
{
mrb_value val;
khash_t(ht) *h;
khiter_t k;
mrb_get_args(mrb, "o", &val);
h = RHASH_TBL(hash);
if (h) {
for (k = kh_begin(h); k != kh_end(h); k++) {
if (!kh_exist(h, k)) continue;
if (mrb_equal(mrb, kh_value(h, k).v, val)) {
return mrb_true_value();
}
}
}
return mrb_false_value();
}
/* remove from hash and return the handler */
static ucs_async_handler_t *ucs_async_handler_extract(int id)
{
ucs_async_handler_t *handler;
khiter_t hash_it;
pthread_rwlock_wrlock(&ucs_async_global_context.handlers_lock);
hash_it = ucs_async_handler_kh_get(id);
if (ucs_async_handler_kh_is_end(hash_it)) {
ucs_debug("async handler [id=%d] not found in hash table", id);
handler = NULL;
} else {
handler = kh_value(&ucs_async_global_context.handlers, hash_it);
ucs_assert_always(handler->id == id);
kh_del(ucs_async_handler, &ucs_async_global_context.handlers, hash_it);
ucs_debug("removed async handler " UCS_ASYNC_HANDLER_FMT " from hash",
UCS_ASYNC_HANDLER_ARG(handler));
}
pthread_rwlock_unlock(&ucs_async_global_context.handlers_lock);
return handler;
}
mrb_value
mrb_hash_keys(mrb_state *mrb, mrb_value hash)
{
khash_t(ht) *h = RHASH_TBL(hash);
khiter_t k;
mrb_value ary, *p;
if (!h || kh_size(h) == 0) return mrb_ary_new(mrb);
ary = mrb_ary_new_capa(mrb, kh_size(h));
mrb_ary_set(mrb, ary, kh_size(h)-1, 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);
p[hv.n] = kv;
}
}
return ary;
}
void setup_test_3(bam1_t** b_in, trans_tbl_t* tbl) {
bam1_t* b;
b = bam_init1();
trans_tbl_test_init(tbl, 4);
tbl->tid_trans[0] = 5;
tbl->tid_trans[1] = 6;
tbl->tid_trans[2] = 7;
tbl->tid_trans[3] = 8;
int in_there = 0;
khiter_t iter = kh_put(c2c, tbl->pg_trans, strdup("hello"), &in_there);
kh_value(tbl->pg_trans,iter) = strdup("goodbye");
b->core.tid = 0;
b->core.pos = 1334;
b->core.bin = 0;
b->core.qual = 10;
b->core.l_qname = 10;
b->core.flag = 0;
b->core.n_cigar = 1;
b->core.l_qseq = 10;
b->core.mtid = -1;
b->core.mpos = 0;
b->core.isize = -1;
size_t data_len = 10 + 4 + 5 + 10 + 9;
b->data = (uint8_t*)malloc(data_len);
memcpy(b->data,
"123456789\0" // q_name
"\x00\x00\x00\xA0" // cigar
"\x00\x00\x00\x00\x00" // qseq
"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF" // qual
"PGZhello\0" // aux
, data_len
);
b->m_data = b->l_data = data_len;
*b_in = b;
}
char* request(int procid, int id, int votingStamp){
printf("Process %d got request from %d at %d \n", procid, id, votingStamp );
if(voted){
int ret;
khiter_t k= kh_put(16, h, id, &ret);
kh_value(h, k) = votingStamp;
if(votingStamp < candidateLamport && !inquired){
inquired = true;
return "INQUIRE.";
}
else{
return "FAIL.";
}
}
else{
candidateLamport = votingStamp;
voted = true;
locked = id;
return "LOCKED.";
}
}
// Create chrom->read genome hash
// `chroms` and `genome` must already be allocated
void chrom_hash_load2(seq_file_t **seq_files, size_t num_files,
ReadBuffer *chroms, ChromHash *genome)
{
size_t i;
khiter_t k;
int hret;
seq_load_all_reads(seq_files, num_files, chroms);
for(i = 0; i < chroms->len; i++)
{
seq_read_to_uppercase(&chroms->b[i]);
seq_read_truncate_name(&chroms->b[i]);
if(strchr(chroms->b[i].name.b,':') != NULL)
die("Please remove colons from chromosome names [%s]", chroms->b[i].name.b);
k = kh_put(kChromHash, genome, chroms->b[i].name.b, &hret);
if(hret == 0)
warn("duplicate chromosome (take first only): '%s'", chroms->b[i].name.b);
else
kh_value(genome, k) = &chroms->b[i];
}
}
/* remove pfx/peer from state */
static void rm_pfx_peer(struct bgpcorsaro_pfxmonitor_state_t *state,
const bgpstream_pfx_storage_t *pfx, uint32_t peer_asn)
{
khiter_t k;
khash_t(peer_asn_map) * pam;
/* does the pfx exist? */
if ((k = kh_get(pfx_info_map, state->pfx_info, *pfx)) ==
kh_end(state->pfx_info)) {
return;
}
pam = kh_value(state->pfx_info, k);
/* does this peer exist for this pfx */
if ((k = kh_get(peer_asn_map, pam, peer_asn)) == kh_end(pam)) {
return;
}
kh_del(peer_asn_map, pam, k);
return;
}
void
mrb_hash_set(mrb_state *mrb, mrb_value hash, mrb_value key, mrb_value val)
{
khash_t(ht) *h;
khiter_t k;
mrb_hash_modify(mrb, hash);
h = RHASH_TBL(hash);
if (!h) h = RHASH_TBL(hash) = kh_init(ht, mrb);
k = kh_get(ht, mrb, h, key);
if (k == kh_end(h)) {
/* expand */
int ai = mrb_gc_arena_save(mrb);
k = kh_put(ht, mrb, h, KEY(key));
mrb_gc_arena_restore(mrb, ai);
}
kh_value(h, k) = val;
mrb_write_barrier(mrb, (struct RBasic*)RHASH(hash));
return;
}
/*
* call-seq:
* obj.instance_variables -> array
*
* Returns an array of instance variable names for the receiver. Note
* that simply defining an accessor does not create the corresponding
* instance variable.
*
* class Fred
* attr_accessor :a1
* def initialize
* @iv = 3
* end
* end
* Fred.new.instance_variables #=> [:@iv]
*/
mrb_value
mrb_obj_instance_variables(mrb_state *mrb, mrb_value self)
{
mrb_value ary;
kh_iv_t *h = RCLASS_IV_TBL(self);
int i;
const char* p;
ary = mrb_ary_new(mrb);
if (h) {
for (i=0;i<kh_end(h);i++) {
if (kh_exist(h, i)) {
p = mrb_sym2name(mrb, kh_key(h,i));
if (*p == '@') {
if (mrb_type(kh_value(h, i)) != MRB_TT_UNDEF)
mrb_ary_push(mrb, ary, mrb_str_new_cstr(mrb, p));
}
}
}
}
return ary;
}
void parg_asset_preload(parg_token id)
{
if (!_pngsuffix) {
_pngsuffix = sdsnew(".png");
}
sds filename = parg_token_to_sds(id);
parg_buffer* buf = parg_buffer_from_path(filename);
parg_assert(buf, "Unable to load asset");
if (sdslen(filename) > 4) {
sds suffix = sdsdup(filename);
sdsrange(suffix, -4, -1);
if (!sdscmp(suffix, _pngsuffix)) {
unsigned char* decoded;
unsigned dims[3] = {0, 0, 4};
unsigned char* filedata = parg_buffer_lock(buf, PARG_READ);
unsigned err = lodepng_decode_memory(&decoded, &dims[0], &dims[1],
filedata, parg_buffer_length(buf), LCT_RGBA, 8);
parg_assert(err == 0, "PNG decoding error");
parg_buffer_free(buf);
int nbytes = dims[0] * dims[1] * dims[2];
buf = parg_buffer_alloc(nbytes + 12, PARG_CPU);
int* ptr = parg_buffer_lock(buf, PARG_WRITE);
*ptr++ = dims[0];
*ptr++ = dims[1];
*ptr++ = dims[2];
memcpy(ptr, decoded, nbytes);
free(decoded);
parg_buffer_unlock(buf);
}
sdsfree(suffix);
}
if (!_asset_registry) {
_asset_registry = kh_init(assmap);
}
int ret;
int iter = kh_put(assmap, _asset_registry, id, &ret);
kh_value(_asset_registry, iter) = buf;
}
char *faidx_fetch_seq(const faidx_t *fai, const char *c_name, int p_beg_i, int p_end_i, int *len)
{
int l, c;
khiter_t iter;
faidx1_t val;
char *seq=NULL;
// Adjust position
iter = kh_get(s, fai->hash, c_name);
if (iter == kh_end(fai->hash))
{
*len = -2;
fprintf(stderr, "[fai_fetch_seq] The sequence \"%s\" not found\n", c_name);
return NULL;
}
val = kh_value(fai->hash, iter);
if(p_end_i < p_beg_i) p_beg_i = p_end_i;
if(p_beg_i < 0) p_beg_i = 0;
else if(val.len <= p_beg_i) p_beg_i = val.len - 1;
if(p_end_i < 0) p_end_i = 0;
else if(val.len <= p_end_i) p_end_i = val.len - 1;
// Now retrieve the sequence
int ret = bgzf_useek(fai->bgzf, val.offset + p_beg_i / val.line_blen * val.line_len + p_beg_i % val.line_blen, SEEK_SET);
if ( ret<0 )
{
*len = -1;
fprintf(stderr, "[fai_fetch_seq] Error: fai_fetch failed. (Seeking in a compressed, .gzi unindexed, file?)\n");
return NULL;
}
l = 0;
seq = (char*)malloc(p_end_i - p_beg_i + 2);
while ( (c=bgzf_getc(fai->bgzf))>=0 && l < p_end_i - p_beg_i + 1)
if (isgraph(c)) seq[l++] = c;
seq[l] = '\0';
*len = l;
return seq;
}
int
mrb_obj_respond_to(struct RClass* c, mrb_sym mid)
{
khiter_t k;
while (c) {
khash_t(mt) *h = c->mt;
if (h) {
k = kh_get(mt, h, mid);
if (k != kh_end(h)) {
if (kh_value(h, k)) {
return TRUE; /* method exists */
}
else {
return FALSE; /* undefined method */
}
}
}
c = c->super;
}
return FALSE; /* no method */
}
struct RProc*
mrb_method_search_vm(mrb_state *mrb, struct RClass **cp, mrb_sym mid)
{
khiter_t k;
struct RProc *m;
struct RClass *c = *cp;
while (c) {
khash_t(mt) *h = c->mt;
if (h) {
k = kh_get(mt, h, mid);
if (k != kh_end(h)) {
m = kh_value(h, k);
if (!m) break;
*cp = c;
return m;
}
}
c = c->super;
}
return 0; /* no method */
}
