static void include_feature(GtDlist *trees, GtHashmap *target_to_elem, GtFeatureNode *feature, GtStr *key) { gt_dlist_add(trees, feature); gt_hashmap_add(target_to_elem, gt_cstr_dup(gt_str_get(key)), gt_dlist_last(trees)); }
void gt_timer_show_progress_va(GtTimer *t, FILE *fp, const char *desc, va_list ap) { #ifndef _WIN32 char buf[BUFSIZ]; struct timeval elapsed_tv, elapsed_user_tv, elapsed_sys_tv; gt_assert(t && desc); gettimeofday(&t->stop_tv, NULL); gt_xgetrusage(RUSAGE_SELF, &t->stop_ru); timeval_subtract(&elapsed_tv, &t->stop_tv, &t->start_tv); timeval_subtract(&elapsed_user_tv, &t->stop_ru.ru_utime, &t->start_ru.ru_utime); timeval_subtract(&elapsed_sys_tv, &t->stop_ru.ru_stime, &t->start_ru.ru_stime); gt_timer_print_progress_report(t, &elapsed_tv, &elapsed_user_tv, &elapsed_sys_tv, t->statedesc, fp); if (t->statedesc) gt_free(t->statedesc); (void) vsnprintf(buf, BUFSIZ, desc, ap); t->statedesc = gt_cstr_dup(buf); gettimeofday(&t->start_tv, NULL); gt_xgetrusage(RUSAGE_SELF, &t->start_ru); #else /* XXX */ fprintf(stderr, "gt_timer_show_progress_va() not implemented\n"); exit(EXIT_FAILURE); #endif }
GtTimer* gt_timer_new_with_progress_description(const char* desc) { GtTimer *t = gt_timer_new(); t->statedesc = gt_cstr_dup(desc); t->has_desc = true; return t; }
static int list_tools(GtR *gtr) { GtToolIterator *ti; GtOptionParser *op; const char *name; char fulltoolname[BUFSIZ], *utoolname; GtTool *tool; GtStr *prefix = gt_str_new(); gt_assert(gtr); /* list 'gt' itself */ printf("\n"), printf("- link:tools/gt.html[gt]\n"); op = gtr_option_parser_new(gtr); printf(" %s\n", gt_option_parser_one_liner(op)); gt_option_parser_delete(op); /* list all tools in 'gt' */ ti = gt_tool_iterator_new(gtr->tools); gt_tool_iterator_set_prefix_target(ti, prefix, ' '); while (gt_tool_iterator_next(ti, &name, &tool)) { op = gt_tool_get_option_parser(tool); (void) snprintf(fulltoolname, BUFSIZ, "gt%c%s%s", ' ', gt_str_get(prefix), name); utoolname = gt_cstr_dup(fulltoolname); gt_cstr_rep(utoolname, ' ', '_'); printf("\n"), printf("- link:tools/%s.html[%s]\n", utoolname, fulltoolname); printf(" %s\n", gt_option_parser_one_liner(op)); gt_free(utoolname); } gt_tool_iterator_delete(ti); gt_str_delete(prefix); return EXIT_SUCCESS; }
static int fill_mapping(GtSeqid2SeqnumMapping *mapping, GtBioseq *bioseq, GtSeqCol *seqcol, GT_UNUSED GtError *err) { GtUword i, j, nof_sequences, nof_files; int had_err = 0; gt_error_check(err); gt_assert(mapping && (bioseq || seqcol) && !(bioseq && seqcol)); if (bioseq) { nof_files = 1; } else { gt_assert(seqcol); nof_files = gt_seq_col_num_of_files(seqcol); } for (j = 0; !had_err && j < nof_files; j++) { if (bioseq) nof_sequences = gt_bioseq_number_of_sequences(bioseq); else { gt_assert(seqcol); nof_sequences = gt_seq_col_num_of_seqs(seqcol, j); } for (i = 0; !had_err && i < nof_sequences; i++) { char *desc; if (bioseq) desc = gt_cstr_dup(gt_bioseq_get_description(bioseq, i)); else desc = gt_seq_col_get_description(seqcol, j, i); had_err = handle_description(mapping, desc, i, j, err); gt_free(desc); } } return had_err; }
static int create_manpage(const char *outdir, const char *toolname, GtOptionParser *option_parser, GtError *err) { GtFile *outfile = NULL; GtStr *man, *pathbuf; char *utoolname; int had_err = 0; gt_error_check(err); gt_assert(outdir && toolname && option_parser); man = gt_str_new(); pathbuf = gt_str_new_cstr(outdir); utoolname = gt_cstr_dup(toolname); gt_cstr_rep(utoolname, ' ', '_'); if (!gt_file_exists(gt_str_get(pathbuf))) gt_xmkdir(gt_str_get(pathbuf)); gt_str_append_char(pathbuf, GT_PATH_SEPARATOR); gt_str_append_cstr(pathbuf, utoolname); gt_str_append_cstr(pathbuf, ".mansrc"); gt_free(utoolname); if (!(outfile = gt_file_new(gt_str_get(pathbuf), "w+", err))) had_err = -1; if (!had_err) had_err = gt_option_parser_manpage(option_parser, toolname, man, err); if (!had_err) gt_file_xprintf(outfile, "%s", gt_str_get(man)); gt_file_delete(outfile); gt_str_delete(pathbuf); gt_str_delete(man); return had_err; }
static void proc_env_options(void) { int argc; char *env_options, **argv; GtSplitter *splitter; GtError *err; /* construct argument vector from $GT_ENV_OPTIONS */ env_options = getenv("GT_ENV_OPTIONS"); if (!env_options) return; env_options = gt_cstr_dup(env_options); /* make writeable copy */ splitter = gt_splitter_new(); gt_splitter_split(splitter, env_options, strlen(env_options), ' '); argc = gt_splitter_size(splitter); argv = gt_cstr_array_preprend((const char**) gt_splitter_get_tokens(splitter), "env"); argc++; /* parse options contained in $GT_ENV_OPTIONS */ err = gt_error_new(); switch (parse_env_options(argc, (const char**) argv, err)) { case GT_OPTION_PARSER_OK: break; case GT_OPTION_PARSER_ERROR: fprintf(stderr, "error parsing $GT_ENV_OPTIONS: %s\n", gt_error_get(err)); gt_error_unset(err); break; case GT_OPTION_PARSER_REQUESTS_EXIT: break; } gt_error_delete(err); gt_free(env_options); gt_splitter_delete(splitter); gt_cstr_array_delete(argv); }
int gt_parse_description_range(const char *description, GtRange *range) { unsigned long i, desclen; char *desc, *descptr; gt_assert(description && range); desc = gt_cstr_dup(description); desclen = strlen(desc); descptr = desc; /* ignore terminal '\n' */ if (desclen && desc[desclen-1] == '\n') { desc[desclen-1] = '\0'; desclen--; } /* ignore terminal '\r' */ if (desclen && desc[desclen-1] == '\r') { desc[desclen-1] = '\0'; desclen--; } /* find ':' */ for (i = 0; i < desclen; i++) { if (desc[i] == ':') break; } if (i == desclen) { /* no ':' found */ gt_free(descptr); return -1; } desc += i + 1; /* find '..' */ i = 0; while (desc[i] != '\0') { if (desc[i-1] == '.' && desc[i] == '.') break; i++; } if (desc[i] == '\0') { /* no '..' found */ gt_free(descptr); return -1; } /* parse range start */ gt_assert(desc[i-1] == '.' && desc[i] == '.'); desc[i-1] = '\0'; if (gt_parse_ulong(&range->start, desc)) { /* parsing failed */ gt_free(descptr); return -1; } /* parse range end */ desc += i + 1; if (gt_parse_ulong(&range->end, desc)) { /* parsing failed */ gt_free(descptr); return -1; } gt_free(descptr); return 0; }
void gt_feature_info_add_pseudo_parent(GtFeatureInfo *fi, const char *id, GtFeatureNode *pseudo_parent) { gt_assert(fi && id && pseudo_parent); gt_assert(gt_feature_node_is_pseudo((GtFeatureNode*) pseudo_parent)); gt_hashmap_add(fi->id_to_pseudo_parent, gt_cstr_dup(id), gt_genome_node_ref((GtGenomeNode*) pseudo_parent)); }
void agn_unit_test_result(AgnUnitTest *test, const char *label, bool success) { UnitTestResult result; agn_assert(test); result.label = gt_cstr_dup(label); result.success = success; gt_array_add(test->results, result); }
static char* gt_bioseq_col_get_description(const GtSeqCol *sc, GtUword filenum, GtUword seqnum) { GtBioseqCol *bsc; bsc = gt_bioseq_col_cast(sc); gt_assert(bsc && filenum < bsc->num_of_seqfiles); return gt_cstr_dup(gt_bioseq_get_description(bsc->bioseqs[filenum], seqnum)); }
GtFile* gt_file_open(GtFileMode file_mode, const char *path, const char *mode, GtError *err) { GtFile *file; gt_error_check(err); gt_assert(mode); file = gt_calloc(1, sizeof (GtFile)); file->mode = file_mode; file->reference_count = 0; if (path) { switch (file_mode) { case GT_FILE_MODE_UNCOMPRESSED: file->fileptr.file = gt_fa_fopen(path, mode, err); if (!file->fileptr.file) { gt_file_delete_without_handle(file); return NULL; } break; case GT_FILE_MODE_GZIP: file->fileptr.gzfile = gt_fa_gzopen(path, mode, err); if (!file->fileptr.gzfile) { gt_file_delete_without_handle(file); return NULL; } break; case GT_FILE_MODE_BZIP2: file->fileptr.bzfile = gt_fa_bzopen(path, mode, err); if (!file->fileptr.bzfile) { gt_file_delete_without_handle(file); return NULL; } file->orig_path = gt_cstr_dup(path); file->orig_mode = gt_cstr_dup(path); break; default: gt_assert(0); } } else { gt_assert(file_mode == GT_FILE_MODE_UNCOMPRESSED); file->fileptr.file = stdin; file->is_stdin = true; } return file; }
static int file_find_in_env_generic(GtStr *path, const char *file, const char *env, FileExistsFunc file_exists, GtError *err) { char *pathvariable, *pathcomponent = NULL; GtSplitter *splitter = NULL; GtUword i; int had_err = 0; gt_error_check(err); gt_assert(file); gt_assert(file_exists); /* check if 'file' has dirname */ gt_file_dirname(path, file); if (gt_str_length(path)) return had_err; /* 'file' has no dirname -> scan $env */ pathvariable = getenv(env); if (pathvariable != NULL) pathvariable = gt_cstr_dup(pathvariable); /* make writeable copy */ else { gt_error_set(err, "environment variable $%s is not defined", env); had_err = -1; } if (!had_err) { splitter = gt_splitter_new(); gt_splitter_split(splitter, pathvariable, (GtUword) strlen(pathvariable), GT_PATH_VAR_SEPARATOR); for (i = 0; i < gt_splitter_size(splitter); i++) { pathcomponent = gt_splitter_get_token(splitter, i); gt_str_reset(path); gt_str_append_cstr(path, pathcomponent); gt_str_append_char(path, GT_PATH_SEPARATOR); gt_str_append_cstr(path, file); if (file_exists(gt_str_get(path))) break; } if (i < gt_splitter_size(splitter)) { /* file found in path */ gt_str_reset(path); gt_str_append_cstr(path, pathcomponent); } else { /* file not found in path */ gt_str_reset(path); } } /* free */ gt_free(pathvariable); gt_splitter_delete(splitter); return had_err; }
AgnUnitTest *agn_unit_test_new(const char *label, bool (*testfunc)(AgnUnitTest *)) { AgnUnitTest *test = gt_malloc( sizeof(AgnUnitTest) ); test->label = gt_cstr_dup(label); test->testfunc = testfunc; test->results = gt_array_new( sizeof(UnitTestResult) ); test->passed = false; return test; }
GtNodeStream* gt_gtf_in_stream_new(const char *filename) { GtGTFInStream *gtf_in_stream; GtNodeStream *ns = gt_node_stream_create(gt_gtf_in_stream_class(), false); gtf_in_stream = gtf_in_stream_cast(ns); gtf_in_stream->genome_node_buffer = gt_queue_new(); gtf_in_stream->type_checker = gt_type_checker_builtin_new(); gtf_in_stream->filename = filename ? gt_cstr_dup(filename) : NULL; return ns; }
//----------------------------------------------------------------------------// // Method implementations //----------------------------------------------------------------------------// VangRelation *vang_relation_new(const char *id, const char *nodetype) { VangRelation *rel = gt_malloc( sizeof(VangRelation) ); rel->id = gt_cstr_dup(id); rel->nodetype = gt_cstr_dup(nodetype); // Apply default degree constraint: indegree == 1; see VangRelation.h for a // more detailed explanation rel->dc.context = DEGREE_IN; rel->dc.operator = EQUALS; rel->dc.degree = 1; // Apply default key (Parent), spatial constraint (none), and note (undefined) rel->key = gt_cstr_dup("Parent"); rel->spatial = SC_NONE; rel->note = NULL; return rel; };
void gt_xrf_abbr_entry_add(GtXRFAbbrEntry *abbr_entry, const char *tag, const char *value) { GtStr *s; gt_assert(abbr_entry && tag && value); if (!(s = gt_hashmap_get(abbr_entry->content, tag))) { s = gt_str_new_cstr(value); gt_hashmap_add(abbr_entry->content, gt_cstr_dup(tag), s); } }
void gt_seq_info_cache_add(GtSeqInfoCache *sic, const char *key, const GtSeqInfo *si) { GtSeqInfo *si_dup; gt_assert(sic && key && si); gt_assert(!gt_seq_info_cache_get(sic, key)); si_dup = gt_malloc(sizeof *si_dup); si_dup->filenum = si->filenum; si_dup->seqnum = si->seqnum; gt_hashmap_add(sic->cache, gt_cstr_dup(key), si_dup); }
void gt_lua_export_metatable(lua_State *L, const char *metatable_desc) { char *dot, *mt; gt_assert(L && metatable_desc); mt = gt_cstr_dup(metatable_desc); dot = strchr(mt, '.'); gt_assert(dot); *dot = '_'; lua_setglobal(L, mt); gt_free(mt); }
static int extracttarget_from_seqfiles(const char *target, GtStrArray *seqfiles, GtError *err) { GtStr *unescaped_target; char *escaped_target; GtSplitter *splitter; unsigned long i; int had_err = 0; gt_error_check(err); gt_assert(target && seqfiles); splitter = gt_splitter_new(); unescaped_target = gt_str_new(); escaped_target = gt_cstr_dup(target); gt_splitter_split(splitter, escaped_target, strlen(escaped_target), ','); for (i = 0; !had_err && i < gt_splitter_size(splitter); i++) { GtSplitter *blank_splitter; char *token = gt_splitter_get_token(splitter, i); blank_splitter = gt_splitter_new(); gt_splitter_split(blank_splitter, token, strlen(token), ' '); had_err = gt_gff3_unescape(unescaped_target, gt_splitter_get_token(blank_splitter, 0), strlen(gt_splitter_get_token(blank_splitter, 0)), err); if (!had_err) { unsigned long j; for (j = 0; j < gt_str_array_size(seqfiles); j++) { unsigned long k; GtBioseq *bioseq; if (!(bioseq = gt_bioseq_new(gt_str_array_get(seqfiles, j), err))) { had_err = -1; break; } for (k = 0; k < gt_bioseq_number_of_sequences(bioseq); k++) { TargetInfo target_info; const char *desc = gt_bioseq_get_description(bioseq, k); target_info.bioseq = bioseq; target_info.seqnum = k; gt_string_matching_bmh(desc, strlen(desc), gt_str_get(unescaped_target), gt_str_length(unescaped_target), show_target, &target_info); } gt_bioseq_delete(bioseq); } } gt_splitter_delete(blank_splitter); } gt_free(escaped_target); gt_str_delete(unescaped_target); gt_splitter_delete(splitter); return had_err; }
static int gt_regioncov_visitor_region_node(GtNodeVisitor *nv, GtRegionNode *rn, GT_UNUSED GtError *err) { GtRegionCovVisitor *regioncov_visitor; GtArray *rangelist; gt_error_check(err); regioncov_visitor = gt_regioncov_visitor_cast(nv); rangelist = gt_array_new(sizeof (GtRange)); gt_hashmap_add(regioncov_visitor->region2rangelist, gt_cstr_dup(gt_str_get(gt_genome_node_get_seqid((GtGenomeNode*) rn))), rangelist); return 0; }
static int hmmsearch_call_fine_search(GtStr *table_filename, char *fine_fasta_filename, char *hmmsearch_path, char *hmm_filename, GtLogger *logger, GtError *err) { int had_err = 0; GtSafePipe *pipe = NULL; char **hmmargs = NULL, *hmmenv[] = { NULL }; size_t hmmargc = (size_t) 4; unsigned int hmmidx = 0; if (table_filename != NULL) { hmmargc += (size_t) 2; } hmmargs = gt_calloc(hmmargc, sizeof (*hmmargs)); hmmargs[hmmidx++] = hmmsearch_path; if (table_filename != NULL) { hmmargs[hmmidx++] = gt_cstr_dup("--tblout"); hmmargs[hmmidx++] = gt_str_get(table_filename); } hmmargs[hmmidx++] = hmm_filename; hmmargs[hmmidx++] = fine_fasta_filename; gt_assert(hmmargs[hmmidx] == NULL); gt_logger_log(logger, "calling: %s", hmmsearch_path); pipe = gt_safe_popen(hmmsearch_path, hmmargs, hmmenv, err); if (table_filename != NULL) gt_free(hmmargs[1]); gt_free(hmmargs); if (pipe == NULL) had_err = -1; if (!had_err) { GtStr *line = gt_str_new(); gt_assert(pipe != NULL); /* shut up splint */ while (gt_str_read_next_line(line, pipe->read_fd) == 0) { printf("%s\n", gt_str_get(line)); gt_str_reset(line); } gt_str_delete(line); (void) gt_safe_pclose(pipe); } return had_err; }
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; }
static int layout_tracks(void *key, void *value, void *data, GT_UNUSED GtError *err) { unsigned long i, max; GtTrack *track; GtLayoutTraverseInfo *lti = (GtLayoutTraverseInfo*) data; GtArray *list = (GtArray*) value; GtStr *gt_track_key; const char *type = key; GtBlock *block; bool split; double tmp; gt_assert(type && list); /* to get a deterministic layout, we sort the GtBlocks for each type */ gt_array_sort_stable(list, blocklist_block_compare); block = *(GtBlock**) gt_array_get(list, 0); gt_track_key = gt_str_new_cstr((char*) key); if (!gt_style_get_bool(lti->layout->style, "format", "split_lines", &split, NULL)) split = true; if (split) if (!gt_style_get_bool(lti->layout->style, type, "split_lines", &split, NULL)) split = true; if (gt_style_get_num(lti->layout->style, type, "max_num_lines", &tmp, NULL)) max = tmp; else max = 50; track = gt_track_new(gt_track_key, max, split, gt_line_breaker_captions_new(lti->layout, lti->layout->width, lti->layout->style)); lti->layout->nof_tracks++; for (i = 0; i < gt_array_size(list); i++) { block = *(GtBlock**) gt_array_get(list, i); gt_track_insert_block(track, block); } gt_hashmap_add(lti->layout->tracks, gt_cstr_dup(gt_str_get(gt_track_key)), track); gt_str_delete(gt_track_key); return 0; }
static int handle_description(GtSeqid2SeqnumMapping *mapping, const char *desc, GtUword seqnum, GtUword filenum, GtError *err) { GtRange descrange; GtUword j; int had_err = 0; SeqidInfo *seqid_info; if (gt_parse_description_range(desc, &descrange)) { /* no offset could be parsed -> store description as sequence id */ descrange.start = 1; descrange.end = GT_UNDEF_UWORD; if ((seqid_info = gt_hashmap_get(mapping->map, desc))) { had_err = seqid_info_add(seqid_info, seqnum, filenum, &descrange, mapping->filename, desc, err); gt_assert(had_err); /* adding a seqid without range should fail */ } else { seqid_info = seqid_info_new(seqnum, filenum, &descrange); gt_hashmap_add(mapping->map, gt_cstr_dup(desc), seqid_info); } } else { char *dup; /* offset could be parsed -> store description up to ':' as sequence id */ j = 0; while (desc[j] != ':') j++; dup = gt_malloc((j + 1) * sizeof *dup); strncpy(dup, desc, j); dup[j] = '\0'; if ((seqid_info = gt_hashmap_get(mapping->map, dup))) { had_err = seqid_info_add(seqid_info, seqnum, filenum, &descrange, mapping->filename, dup, err); gt_free(dup); } else { seqid_info = seqid_info_new(seqnum, filenum, &descrange); gt_hashmap_add(mapping->map, dup, seqid_info); } } return had_err; }
void gt_timer_show_progress_va(GtTimer *t, FILE *fp, const char *desc, va_list ap) { char buf[BUFSIZ]; struct timeval elapsed_tv, elapsed_user_tv, elapsed_sys_tv; gt_assert(t && desc); gettimeofday(&t->stop_tv, NULL); gt_xgetrusage(RUSAGE_SELF, &t->stop_ru); timeval_subtract(&elapsed_tv, &t->stop_tv, &t->start_tv); timeval_subtract(&elapsed_user_tv, &t->stop_ru.ru_utime, &t->start_ru.ru_utime); timeval_subtract(&elapsed_sys_tv, &t->stop_ru.ru_stime, &t->start_ru.ru_stime); gt_timer_print_progress_report(t, &elapsed_tv, &elapsed_user_tv, &elapsed_sys_tv, t->statedesc, fp); if (t->statedesc) gt_free(t->statedesc); (void) vsnprintf(buf, BUFSIZ, desc, ap); t->statedesc = gt_cstr_dup(buf); gettimeofday(&t->start_tv, NULL); gt_xgetrusage(RUSAGE_SELF, &t->start_ru); }
static void gt_hmmer_parse_status_add_hit(GtHMMERParseStatus *s, GtHMMERSingleHit *hit) { GtHMMERModelHit *mh; gt_assert(s); if (!(mh = gt_hashmap_get(s->models, gt_str_get(s->cur_model)))) { mh = gt_calloc((size_t) 1, sizeof (*mh)); mh->fwd_hits = gt_array_new(sizeof (GtHMMERSingleHit*)); mh->rev_hits = gt_array_new(sizeof (GtHMMERSingleHit*)); mh->best_rev = mh->best_fwd = DBL_MAX; mh->modelname = gt_cstr_dup(gt_str_get(s->cur_model)); gt_hashmap_add(s->models, mh->modelname, mh); } gt_assert(mh && mh->fwd_hits &&mh->rev_hits); if (hit->strand == GT_STRAND_FORWARD) { if (gt_double_compare(mh->best_fwd, hit->evalue) > 0) mh->best_fwd = hit->evalue; gt_array_add(mh->fwd_hits, hit); } else { if (gt_double_compare(mh->best_rev, hit->evalue) > 0) mh->best_rev = hit->evalue; gt_array_add(mh->rev_hits, hit); } }
/*read condenseq data structure from file*/ GtCondenseq *gt_condenseq_new_from_file(const char *indexname, GtLogger *logger, GtError *err) { int had_err = 0; FILE* fp; GtEncseqLoader *esl; GtEncseq *unique_es; GtCondenseq *condenseq = NULL; /*load unique_es*/ esl = gt_encseq_loader_new(); unique_es = gt_encseq_loader_load(esl, indexname, err); if (!unique_es) had_err = -1; if (!had_err) { gt_encseq_loader_delete(esl); condenseq = condenseq_new_empty(gt_encseq_alphabet(unique_es)); condenseq->filename = gt_cstr_dup(indexname); condenseq->unique_es = unique_es; fp = gt_fa_fopen_with_suffix(indexname, GT_CONDENSEQ_FILE_SUFFIX, "rb", err); if (fp == NULL) { had_err = -1; } else { had_err = condenseq_io(condenseq, fp, gt_io_error_fread, err); if (!had_err) { GtUword i; gt_assert(condenseq->uniques); gt_assert(condenseq->links); gt_fa_fclose(fp); /*create link array for each unique entry*/ for (i = 0; i < condenseq->udb_nelems; i++) { GT_INITARRAY(&(condenseq->uniques[i].links),uint32_t); } /* check for overflows */ if (condenseq->ldb_nelems > (GtUword) ((uint32_t) 0 - (uint32_t) 1)) { gt_error_set(err, "Overflow, to many link-elements. Can't be stored"); had_err = -1; } /* iterate through link entrys and store ids in corresponding unique entry array */ for (i = 0; !had_err && (GtUword) i < condenseq->ldb_nelems; i++) { GtUword uid = condenseq->links[i].unique_id; gt_assert(uid < condenseq->udb_nelems); GT_STOREINARRAY(&(condenseq->uniques[uid].links), uint32_t, 10, (uint32_t) i); } } } } if (!had_err) { gt_assert(condenseq != NULL); if (condenseq->id_len != GT_UNDEF_UWORD) gt_logger_log(logger, "IDs const len: " GT_WU, condenseq->id_len); else gt_logger_log(logger, "using sdstab to access IDs"); } if (had_err) { gt_condenseq_delete(condenseq); condenseq = NULL; } return (condenseq); }
void vang_relation_set_note(VangRelation *rel, const char *note) { if(rel->note != NULL) gt_free(rel->note); rel->note = gt_cstr_dup(note); }
void vang_relation_set_key(VangRelation *rel, const char *key) { gt_free(rel->key); rel->key = gt_cstr_dup(key); }