GtNodeVisitor* gt_cds_check_visitor_new(void) { GtNodeVisitor *nv = gt_node_visitor_create(gt_cds_check_visitor_class()); GtCDSCheckVisitor *v = cds_check_visitor_cast(nv); v->cds_features = gt_hashmap_new(GT_HASH_DIRECT, NULL, NULL); v->cds_features_to_split = gt_hashmap_new(GT_HASH_DIRECT, NULL, NULL); return nv; }
static void fa_init(void) { gt_assert(!fa); fa = gt_calloc(1, sizeof (FA)); fa->file_pointer = gt_hashmap_new(HASH_DIRECT, NULL, (GtFree) free_FAFileInfo); fa->memory_maps = gt_hashmap_new(HASH_DIRECT, NULL, (GtFree) free_FAMapInfo); }
GtFeatureInfo* gt_feature_info_new(void) { GtFeatureInfo *fi = gt_malloc(sizeof *fi); fi->id_to_genome_node = gt_hashmap_new(GT_HASH_STRING, gt_free_func, (GtFree) gt_genome_node_delete); fi->id_to_pseudo_parent = gt_hashmap_new(GT_HASH_STRING, gt_free_func, (GtFree) gt_genome_node_delete); return fi; }
GtTypeGraph* gt_type_graph_new(void) { GtTypeGraph *type_graph = gt_malloc(sizeof (GtTypeGraph)); type_graph->name2id = gt_hashmap_new(GT_HASH_DIRECT, NULL, NULL); type_graph->nodemap = gt_hashmap_new(GT_HASH_DIRECT, NULL, NULL); type_graph->nodes = gt_array_new(sizeof (GtTypeNode*)); type_graph->part_of_out_edges = gt_bool_matrix_new(); type_graph->part_of_in_edges = gt_bool_matrix_new(); type_graph->ready = false; return type_graph; }
static void gt_gff3_visitor_init(GtGFF3Visitor *gff3_visitor) { gff3_visitor->version_string_shown = false; gff3_visitor->fasta_directive_shown = false; gff3_visitor->id_counter = gt_string_distri_new(); gff3_visitor->feature_node_to_id_array = gt_hashmap_new(GT_HASH_DIRECT, NULL, (GtFree) gt_array_delete); gff3_visitor->feature_node_to_unique_id_str = gt_hashmap_new(GT_HASH_DIRECT, NULL, (GtFree) gt_str_delete); gff3_visitor->fasta_width = 0; gff3_visitor->used_ids = gt_cstr_table_new(); /* XXX */ gff3_visitor->retain_ids = getenv("GT_RETAINIDS") ? true : false; gff3_visitor->allow_nonunique_ids = false; }
GtToolbox* gt_toolbox_new(void) { GtToolbox *tb; tb = gt_malloc(sizeof (GtToolbox)); tb->tools = gt_hashmap_new(GT_HASH_STRING, NULL, (GtFree) gt_toolinfo_delete); return tb; }
GtXRFChecker* gt_xrf_checker_new(const char *file_path, GtError *err) { GtXRFChecker *xrc; GtUword i; gt_error_check(err); gt_assert(file_path); xrc = gt_calloc(1UL, sizeof (GtXRFChecker)); xrc->xpt = gt_xrf_abbr_parse_tree_new(file_path, err); if (!xrc->xpt) { gt_xrf_checker_delete(xrc); return NULL; } xrc->abbrvs = gt_hashmap_new(GT_HASH_STRING, NULL, NULL); for (i = 0; i < gt_xrf_abbr_parse_tree_num_of_entries(xrc->xpt); i++) { const GtXRFAbbrEntry *e = gt_xrf_abbr_parse_tree_get_entry(xrc->xpt, i); const char *synonym; gt_hashmap_add(xrc->abbrvs, (void*) gt_xrf_abbr_entry_get_value(e, "abbreviation"), (void*) e); if ((synonym = gt_xrf_abbr_entry_get_value(e, "synonym"))) { gt_hashmap_add(xrc->abbrvs, (void*) synonym, (void*) e); } } xrc->splitter = gt_splitter_new(); return xrc; }
GtLayout* gt_layout_new_with_twc(GtDiagram *diagram, unsigned int width, GtStyle *style, GtTextWidthCalculator *twc, GtError *err) { GtLayout *layout; GtLayoutTraverseInfo lti; gt_assert(diagram && style && twc && err); if (check_width(width, style, err) < 0) return NULL; layout = gt_calloc(1, sizeof (GtLayout)); layout->twc = twc; layout->style = style; layout->width = width; layout->viewrange = gt_diagram_get_range(diagram); layout->nof_tracks = 0; lti.layout = layout; lti.twc = twc; layout->own_twc = false; (void) gt_diagram_build(diagram); layout->custom_tracks = gt_array_ref(gt_diagram_get_custom_tracks(diagram)); /* XXX: use other container type here! */ layout->tracks = gt_hashmap_new(HASH_STRING, gt_free_func, (GtFree) gt_track_delete); (void) gt_hashmap_foreach(gt_diagram_get_blocks(diagram), layout_tracks, <i, NULL); return layout; }
void gth_region_factory_save(GthRegionFactory *rf, GtArray *nodes, GthInput *input) { GtHashmap *sequence_regions; GtUword i, j; GtStr *sequenceid; GT_UNUSED int had_err; gt_assert(rf && nodes && input); gt_assert(!rf->factory_was_used); rf->seqid_store = seqid_store_new(input); sequence_regions = gt_hashmap_new(GT_HASH_STRING, NULL, NULL); sequenceid = gt_str_new(); for (i = 0; i < gth_input_num_of_gen_files(input); i++) { gth_input_load_genomic_file(input, i, false); for (j = 0; j < gth_input_num_of_gen_seqs(input, i); j++) { gt_str_reset(sequenceid); gth_input_save_gen_identifier(input, sequenceid, i, j); make_sequence_region(sequence_regions, sequenceid, rf, input, i, j); } } gt_str_delete(sequenceid); had_err = gt_hashmap_foreach_in_key_order(sequence_regions, save_sequence_region, nodes, NULL); gt_assert(!had_err); /* should not happen */ gt_hashmap_delete(sequence_regions); rf->factory_was_used = true; }
GtNodeVisitor* gt_snp_annotator_visitor_new(GtFeatureNode *gene, GtTransTable *trans_table, GtRegionMapping *rmap, GtError *err) { GtNodeVisitor *nv; GtSNPAnnotatorVisitor *sav; gt_assert(gene && gt_feature_node_get_type(gene) == gt_symbol(gt_ft_gene)); nv = gt_node_visitor_create(gt_snp_annotator_visitor_class()); sav = snp_annotator_visitor_cast(nv); sav->gene = (GtFeatureNode*) gt_genome_node_ref((GtGenomeNode*) gene); sav->rmap = gt_region_mapping_ref(rmap); sav->mRNA_type = gt_symbol(gt_ft_mRNA); sav->CDS_type = gt_symbol(gt_ft_CDS); sav->SNV_type = gt_symbol(gt_ft_SNV); sav->SNP_type = gt_symbol(gt_ft_SNP); sav->rnaseqs = gt_hashmap_new(GT_HASH_DIRECT, NULL, gt_free_func); if (trans_table) { sav->tt = trans_table; sav->own_tt = false; } else { sav->tt = gt_trans_table_new_standard(err); sav->own_tt = true; } if (!sav->tt || gt_snp_annotator_visitor_prepare_gene(sav, err) != 0) { gt_node_visitor_delete(nv); return NULL; } return nv; }
GtFeatureIndex *agn_import_simple(int numfiles, const char **filenames, char *type, AgnLogger *logger) { GtFeatureIndex *features = gt_feature_index_memory_new(); GtNodeStream *gff3 = gt_gff3_in_stream_new_unsorted(numfiles, filenames); gt_gff3_in_stream_check_id_attributes((GtGFF3InStream *)gff3); gt_gff3_in_stream_enable_tidy_mode((GtGFF3InStream *)gff3); GtHashmap *typestokeep = gt_hashmap_new(GT_HASH_STRING, NULL, NULL); gt_hashmap_add(typestokeep, type, type); GtNodeStream *filterstream = agn_filter_stream_new(gff3, typestokeep); GtNodeStream *featstream = gt_feature_out_stream_new(filterstream, features); GtError *error = gt_error_new(); int result = gt_node_stream_pull(featstream, error); if(result == -1) { agn_logger_log_error(logger, "error processing node stream: %s", gt_error_get(error)); } gt_error_delete(error); if(agn_logger_has_error(logger)) { gt_feature_index_delete(features); features = NULL; } gt_node_stream_delete(gff3); gt_node_stream_delete(filterstream); gt_node_stream_delete(featstream); return features; }
GtNodeVisitor* gt_gff3_visitor_new(GtFile *outfp) { GtNodeVisitor *nv = gt_node_visitor_create(gt_gff3_visitor_class()); GtGFF3Visitor *gff3_visitor = gff3_visitor_cast(nv); gff3_visitor->version_string_shown = false; gff3_visitor->fasta_directive_shown = false; gff3_visitor->id_counter = gt_string_distri_new(); gff3_visitor->feature_node_to_id_array = gt_hashmap_new(GT_HASH_DIRECT, NULL, (GtFree) gt_array_delete); gff3_visitor->feature_node_to_unique_id_str = gt_hashmap_new(GT_HASH_DIRECT, NULL, (GtFree) gt_str_delete); gff3_visitor->fasta_width = 0; gff3_visitor->outfp = outfp; gff3_visitor->used_ids = gt_cstr_table_new(); gff3_visitor->retain_ids = false; return nv; }
GtGTFParser* gt_gtf_parser_new(GtTypeChecker *type_checker) { GtGTFParser *parser = gt_malloc(sizeof (GtGTFParser)); parser->gene_id_hash = gt_hashmap_new(GT_HASH_STRING, gt_free_func, (GtFree) gt_hashmap_delete); parser->seqid_to_str_mapping = gt_hashmap_new(GT_HASH_STRING, NULL, (GtFree) gt_str_delete); parser->source_to_str_mapping = gt_hashmap_new(GT_HASH_STRING, NULL, (GtFree) gt_str_delete); parser->gene_id_to_name_mapping = gt_hashmap_new(GT_HASH_STRING, gt_free_func, gt_free_func); parser->transcript_id_to_name_mapping = gt_hashmap_new(GT_HASH_STRING, gt_free_func, gt_free_func); parser->region_node_builder = gt_region_node_builder_new(); parser->type_checker = type_checker; return parser; }
GtNodeVisitor* gt_regioncov_visitor_new(GtUword max_feature_dist) { GtNodeVisitor *nv = gt_node_visitor_create(gt_regioncov_visitor_class()); GtRegionCovVisitor *regioncov_visitor = gt_regioncov_visitor_cast(nv); regioncov_visitor->max_feature_dist = max_feature_dist; regioncov_visitor->region2rangelist = gt_hashmap_new(GT_HASH_STRING, gt_free_func, (GtFree) gt_array_delete); return nv; }
static GtHMMERParseStatus* gt_hmmer_parse_status_new(void) { GtHMMERParseStatus *s; s = gt_calloc((size_t) 1, sizeof (GtHMMERParseStatus)); s->cur_model = gt_str_new(); s->models = gt_hashmap_new(GT_HASH_STRING, gt_free_func, (GtFree) gt_hmmer_model_hit_delete); return s; }
static void gv_test_calc_integrity(AgnUnitTest *test) { const char *filename = "data/gff3/gaeval-stream-unit-test-2.gff3"; GtNodeStream *align_in = gt_gff3_in_stream_new_unsorted(1, &filename); AgnGaevalParams params = { 0.6, 0.3, 0.05, 0.05, 400, 200, 100 }; GtNodeVisitor *nv = agn_gaeval_visitor_new(align_in, params); AgnGaevalVisitor *gv = gaeval_visitor_cast(nv); gt_node_stream_delete(align_in); GtNodeStream *gff3in = gt_gff3_in_stream_new_unsorted(1, &filename); GtHashmap *typestokeep = gt_hashmap_new(GT_HASH_STRING, NULL, NULL); gt_hashmap_add(typestokeep, "mRNA", "mRNA"); GtNodeStream *filtstream = agn_filter_stream_new(gff3in, typestokeep); GtLogger *logger = gt_logger_new(true, "", stderr); GtNodeStream *ics = agn_infer_cds_stream_new(filtstream, NULL, logger); GtNodeStream *ies = agn_infer_exons_stream_new(ics, NULL, logger); GtError *error = gt_error_new(); GtArray *feats = gt_array_new( sizeof(GtFeatureNode *) ); GtNodeStream *featstream = gt_array_out_stream_new(ies, feats, error); int result = gt_node_stream_pull(featstream, error); if(result == -1) { fprintf(stderr, "[AgnGaevalVisitor::gv_test_calc_integrity] error " "processing GFF3: %s\n", gt_error_get(error)); return; } gt_node_stream_delete(gff3in); gt_node_stream_delete(filtstream); gt_node_stream_delete(featstream); gt_node_stream_delete(ics); gt_node_stream_delete(ies); gt_logger_delete(logger); gt_hashmap_delete(typestokeep); agn_assert(gt_array_size(feats) == 2); GtFeatureNode *g1 = *(GtFeatureNode **)gt_array_get(feats, 0); GtFeatureNode *g2 = *(GtFeatureNode **)gt_array_get(feats, 1); double cov1 = gaeval_visitor_calculate_coverage(gv, g1, error); double cov2 = gaeval_visitor_calculate_coverage(gv, g2, error); double int1 = gaeval_visitor_calculate_integrity(gv, g1, cov1, NULL, error); double int2 = gaeval_visitor_calculate_integrity(gv, g2, cov2, NULL, error); bool test1 = fabs(cov1 - 1.000) < 0.001 && fabs(cov2 - 0.997) < 0.001 && fabs(int1 - 0.850) < 0.001 && fabs(int2 - 0.863) < 0.001; agn_unit_test_result(test, "calculate integrity", test1); gt_error_delete(error); gt_array_delete(feats); gt_genome_node_delete((GtGenomeNode *)g1); gt_genome_node_delete((GtGenomeNode *)g2); gt_node_visitor_delete(nv); }
static void build_md5map(GtMD5Tab *md5_tab) { GtUword i; gt_assert(md5_tab); md5_tab->md5map = gt_hashmap_new(GT_HASH_STRING, NULL, NULL); for (i = 0; i < md5_tab->num_of_md5s; i++) { gt_hashmap_add(md5_tab->md5map, (void*) gt_md5_tab_get(md5_tab, i), (void*) (i + 1)); } }
GtXRFAbbrEntry* gt_xrf_abbr_entry_new(GtUword line, GtStr *filename) { GtXRFAbbrEntry *abbr_entry = gt_malloc(sizeof *abbr_entry); abbr_entry->content = gt_hashmap_new(GT_HASH_STRING, gt_free_func, (GtFree) gt_str_delete); abbr_entry->line = line; abbr_entry->filename = gt_str_ref(filename); return abbr_entry; }
GtLineBreaker* gt_line_breaker_bases_new() { GtLineBreakerBases *lbb; GtLineBreaker *lb; lb = gt_line_breaker_create(gt_line_breaker_bases_class()); lbb = gt_line_breaker_bases_cast(lb); lbb->itrees = gt_hashmap_new(HASH_DIRECT, NULL, (GtFree) gt_interval_tree_delete); return lb; }
void gt_hpol_processor_enable_sorted_segments_output(GtHpolProcessor *hpp, unsigned long nfiles, GtSeqIterator **reads_iters, GtFile **outfiles) { gt_assert(hpp != NULL); gt_aligned_segments_pile_disable_segment_deletion(hpp->asp); hpp->processed_segments = gt_hashmap_new(GT_HASH_STRING, NULL, (GtFree)gt_aligned_segment_delete); hpp->reads_iters = reads_iters; hpp->outfiles = outfiles; hpp->nfiles = nfiles; }
GtBEDParser* gt_bed_parser_new(void) { GtBEDParser *bed_parser = gt_calloc(1, sizeof *bed_parser); bed_parser->region_node_builder = gt_region_node_builder_new(); bed_parser->feature_nodes = gt_queue_new(); bed_parser->seqid_to_str_mapping = gt_hashmap_new(GT_HASH_STRING, NULL, (GtFree) gt_str_delete); bed_parser->word = gt_str_new(); bed_parser->another_word = gt_str_new(); return bed_parser; }
static NodeInfoElement* nodeinfo_get(GtDiagram *d, GtFeatureNode *node) { NodeInfoElement *ni; gt_assert(d && node); if (!(ni = gt_hashmap_get(d->nodeinfo, node))) { ni = gt_calloc(1, sizeof (NodeInfoElement)); ni->type_index = gt_hashmap_new(GT_HASH_STRING, NULL, gt_free_func); ni->types = gt_str_array_new(); gt_hashmap_add(d->nodeinfo, node, ni); } return ni; }
GtNodeVisitor* gt_add_ids_visitor_new(bool ensure_sorting) { GtNodeVisitor *nv = gt_node_visitor_create(gt_add_ids_visitor_class()); GtAddIDsVisitor *add_ids_visitor = add_ids_visitor_cast(nv); add_ids_visitor->node_buffer = gt_queue_new(); add_ids_visitor->defined_seqids = gt_cstr_table_new(); add_ids_visitor->undefined_sequence_regions = gt_hashmap_new(GT_HASH_STRING, NULL, (GtFree) automatic_sequence_region_delete); add_ids_visitor->ensure_sorting = ensure_sorting; return nv; }
int main(int argc, char **argv) { if(argc != 2) { fputs("usage: vang schema.file\n", stderr); return 1; } gt_lib_init(); char *schemafile = argv[1]; FILE *schema = fopen(schemafile, "r"); if(schema == NULL) { fprintf(stderr, "error: unable to open schema file '%s'\n", schemafile); return 1; } GtArray *entry_datatypes = gt_array_new( sizeof(char *) ); GtHashmap *entries = gt_hashmap_new( GT_HASH_STRING, NULL, (GtFree)vang_schema_entry_delete ); VangSchemaEntry *entry; while( (entry = vang_schema_entry_next(schema)) != NULL ) { char *datatype = (char *)vang_schema_entry_get_datatype(entry); VangSchemaEntry *testentry = gt_hashmap_get(entries, datatype); if(testentry != NULL) { fprintf( stderr, "warning: already have an entry for data type '%s'; " "replacing\n", datatype ); vang_schema_entry_delete(testentry); } gt_hashmap_add(entries, datatype, entry); gt_array_add(entry_datatypes, datatype); } unsigned long i; for(i = 0; i < gt_array_size(entry_datatypes); i++) { const char *type = *(const char **)gt_array_get(entry_datatypes, i); VangSchemaEntry *entry = gt_hashmap_get(entries, type); vang_schema_entry_to_string(entry, stdout); puts(""); } gt_array_delete(entry_datatypes); gt_hashmap_delete(entries); gt_lib_clean(); return 0; }
GtNodeStream* gt_targetbest_filter_stream_new(GtNodeStream *in_stream) { GtTargetbestFilterStream *tfs; GtNodeStream *gs; gt_assert(in_stream); gs = gt_node_stream_create(gt_targetbest_filter_stream_class(), gt_node_stream_is_sorted(in_stream)); tfs = targetbest_filter_stream_cast(gs); tfs->in_stream = gt_node_stream_ref(in_stream); tfs->in_stream_processed = false; tfs->trees = gt_dlist_new(NULL); tfs->target_to_elem = gt_hashmap_new(HASH_STRING, gt_free_func, NULL); return gs; }
static void nodeinfo_add_block(NodeInfoElement *ni, const char *gft, GtFeatureNode *rep, GtBlock *block) { GtBlockTuple *bt; PerTypeInfo *type_struc = NULL; gt_assert(ni); bt = blocktuple_new(gft, rep, block); if (!(ni->type_index)) { ni->type_index = gt_hashmap_new(GT_HASH_STRING, NULL, gt_free_func); } if (!(type_struc = gt_hashmap_get(ni->type_index, gft))) { type_struc = gt_calloc(1, sizeof (PerTypeInfo)); type_struc->rep_index = gt_hashmap_new(GT_HASH_DIRECT, NULL, NULL); type_struc->blocktuples = gt_array_new(sizeof (GtBlockTuple*)); gt_hashmap_add(ni->type_index, (char*) gft, type_struc); gt_str_array_add_cstr(ni->types, gft); } gt_hashmap_add(type_struc->rep_index, rep, bt); if (rep != GT_UNDEF_REPR) type_struc->must_merge = true; gt_array_add(type_struc->blocktuples, bt); }
static GtDiagram* gt_diagram_new_generic(GtArray *features, const GtRange *range, GtStyle *style, bool ref_features) { GtDiagram *diagram; diagram = gt_calloc(1, sizeof (GtDiagram)); diagram->nodeinfo = gt_hashmap_new(GT_HASH_DIRECT, NULL, NULL); diagram->style = style; diagram->lock = gt_rwlock_new(); diagram->range = *range; if (ref_features) diagram->features = gt_array_ref(features); else diagram->features = features; diagram->select_func = default_track_selector; diagram->custom_tracks = gt_array_new(sizeof (GtCustomTrack*)); /* init caches */ diagram->collapsingtypes = gt_hashmap_new(GT_HASH_STRING, NULL, gt_free_func); diagram->groupedtypes = gt_hashmap_new(GT_HASH_STRING, NULL, gt_free_func); diagram->caption_display_status = gt_hashmap_new(GT_HASH_DIRECT, NULL, gt_free_func); return diagram; }
static int check_cds_phases_if_necessary(GtFeatureNode *fn, GtCDSCheckVisitor *v, bool second_pass, GtError *err) { GtFeatureNodeIterator *fni; GtFeatureNode *node; GtArray *cds_features = NULL; GtHashmap *multi_features = NULL; int had_err = 0; gt_error_check(err); gt_assert(fn); fni = gt_feature_node_iterator_new_direct(fn); while ((node = gt_feature_node_iterator_next(fni))) { if (gt_feature_node_has_type(node, gt_ft_CDS)) { if (gt_feature_node_is_multi(node)) { GtArray *features; if (!multi_features) multi_features = gt_hashmap_new(GT_HASH_DIRECT, NULL, (GtFree) gt_array_delete); if ((features = gt_hashmap_get(multi_features, gt_feature_node_get_multi_representative(node)))) { gt_array_add(features, node); } else { GtFeatureNode *representative; features = gt_array_new(sizeof (GtFeatureNode*)); representative = gt_feature_node_get_multi_representative(node); gt_array_add(features, representative); gt_hashmap_add(multi_features, representative, features); } } else { if (!cds_features) cds_features = gt_array_new(sizeof (GtFeatureNode*)); gt_array_add(cds_features, node); } } } if (cds_features) had_err = check_cds_phases(cds_features, v, false, second_pass, err); if (!had_err && multi_features) had_err = gt_hashmap_foreach(multi_features, check_cds_phases_hm, v, err); gt_array_delete(cds_features); gt_hashmap_delete(multi_features); gt_feature_node_iterator_delete(fni); return had_err; }
GtSeqid2SeqnumMapping* gt_seqid2seqnum_mapping_new_seqcol(GtSeqCol *seqcol, GtError *err) { GtSeqid2SeqnumMapping *mapping; gt_error_check(err); gt_assert(seqcol); mapping = gt_malloc(sizeof *mapping); mapping->filename = NULL; mapping->map = gt_hashmap_new(GT_HASH_STRING, gt_free_func, (GtFree) seqid_info_delete); if (fill_mapping(mapping, NULL, seqcol, err)) { gt_seqid2seqnum_mapping_delete(mapping); return NULL; } mapping->cached_seqid = NULL; return mapping; }
GtSeqid2SeqnumMapping* gt_seqid2seqnum_mapping_new_bioseq(GtBioseq *bioseq, GtError *err) { GtSeqid2SeqnumMapping *mapping; gt_error_check(err); gt_assert(bioseq); mapping = gt_malloc(sizeof *mapping); mapping->filename = gt_cstr_dup(gt_bioseq_filename(bioseq)); mapping->map = gt_hashmap_new(GT_HASH_STRING, gt_free_func, (GtFree) seqid_info_delete); if (fill_mapping(mapping, bioseq, NULL, err)) { gt_seqid2seqnum_mapping_delete(mapping); return NULL; } mapping->cached_seqid = NULL; return mapping; }