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 */ }