// =============================================================== // // // // File : adali.cxx // // Purpose : alignments // // // // Institute of Microbiology (Technical University Munich) // // http://www.arb-home.de/ // // // // =============================================================== // #include #include #include "gb_local.h" #include #include #include static void check_for_species_without_data(const char *species_name, long value, void *counterPtr) { if (value == 1) { long cnt = *((long*)counterPtr); if (cnt<40) { GB_warningf("Species '%s' has no data in any alignment", species_name); } *((long*)counterPtr) = cnt+1; } } GBDATA *GBT_get_presets(GBDATA *gb_main) { return GBT_find_or_create(gb_main, "presets", 7); } int GBT_count_alignments(GBDATA *gb_main) { int count = 0; GBDATA *gb_presets = GBT_get_presets(gb_main); for (GBDATA *gb_ali = GB_entry(gb_presets, "alignment"); gb_ali; gb_ali = GB_nextEntry(gb_ali)) { ++count; } return count; } static GB_ERROR GBT_check_alignment(GBDATA *gb_main, GBDATA *preset_alignment, GB_HASH *species_name_hash) { /* check * - whether alignment has correct size and * - whether all data is present. * * Sets the security deletes and writes. * * If 'species_name_hash' is not NULp, * - it initially has to contain value == 1 for each existing species. * - afterwards it will contain value == 2 for each species where an alignment has been found. */ GBDATA *gb_species_data = GBT_get_species_data(gb_main); GBDATA *gb_extended_data = GBT_get_SAI_data(gb_main); GB_ERROR error = NULp; char *ali_name = GBT_read_string(preset_alignment, "alignment_name"); if (!ali_name) error = "Alignment w/o 'alignment_name'"; if (!error) { long security_write = -1; long stored_ali_len = -1; long found_ali_len = -1; long aligned = 1; GBDATA *gb_ali_len = NULp; { GBDATA *gb_ali_wsec = GB_entry(preset_alignment, "alignment_write_security"); if (!gb_ali_wsec) { error = "has no 'alignment_write_security' entry"; } else { security_write = GB_read_int(gb_ali_wsec); } } if (!error) { gb_ali_len = GB_entry(preset_alignment, "alignment_len"); if (!gb_ali_len) { error = "has no 'alignment_len' entry"; } else { stored_ali_len = GB_read_int(gb_ali_len); } } if (!error) { GBDATA *gb_species; for (gb_species = GBT_first_species_rel_species_data(gb_species_data); gb_species && !error; gb_species = GBT_next_species(gb_species)) { GBDATA *gb_name = GB_entry(gb_species, "name"); const char *name = NULp; int alignment_seen = 0; if (!gb_name) { // fatal: name is missing -> create a unique name char *unique = GBT_create_unique_species_name(gb_main, "autoname."); error = GBT_write_string(gb_species, "name", unique); if (!error) { gb_name = GB_entry(gb_species, "name"); GBS_write_hash(species_name_hash, unique, 1); // not seen before GB_warningf("Seen unnamed species (gave name '%s')", unique); } free(unique); } if (!error) { name = GB_read_char_pntr(gb_name); if (species_name_hash) { int seen = GBS_read_hash(species_name_hash, name); gb_assert(seen != 0); // species_name_hash not initialized correctly if (seen == 2) alignment_seen = 1; // already seen an alignment } } if (!error) { GB_topSecurityLevel unsecured(gb_name); error = GB_write_security_delete(gb_name, 7); if (!error) error = GB_write_security_write(gb_name, 6); if (!error) { GBDATA *gb_ali = GB_entry(gb_species, ali_name); if (gb_ali) { GBDATA *gb_data = GB_entry(gb_ali, "data"); if (!gb_data) { error = GBT_write_string(gb_ali, "data", "Error: entry 'data' was missing and therefore was filled with this text."); GB_warningf("No '%s/data' entry for species '%s' (has been filled with dummy data)", ali_name, name); } else { if (GB_read_type(gb_data) != GB_STRING) { GB_delete(gb_data); error = GBS_global_string("'%s/data' of species '%s' had wrong DB-type (%s) and has been deleted!", ali_name, name, GB_read_key_pntr(gb_data)); } else { long data_len = GB_read_string_count(gb_data); if (found_ali_len != data_len) { if (found_ali_len>0) aligned = 0; if (found_ali_len0) aligned = 0; if (found_ali_len check all existing alignments * otherwise -> check only one alignment */ GB_ERROR error = NULp; GBDATA *gb_sd = GBT_get_species_data(Main); GBDATA *gb_presets = GBT_get_presets(Main); GB_HASH *species_name_hash = NULp; // create rest of main containers GBT_get_SAI_data(Main); GBT_get_tree_data(Main); if (alignment_name) { GBDATA *gb_ali_name = GB_find_string(gb_presets, "alignment_name", alignment_name, GB_IGNORE_CASE, SEARCH_GRANDCHILD); if (!gb_ali_name) { error = GBS_global_string("Alignment '%s' does not exist - it can't be checked.", alignment_name); } } if (!error) { // check whether we have an default alignment GBDATA *gb_use = GB_entry(gb_presets, "use"); if (!gb_use) { // if we have no default alignment -> look for any alignment GBDATA *gb_ali_name = GB_find_string(gb_presets, "alignment_name", alignment_name, GB_IGNORE_CASE, SEARCH_GRANDCHILD); error = gb_ali_name ? GBT_write_string(gb_presets, "use", GB_read_char_pntr(gb_ali_name)) : "No alignment defined"; } } if (!alignment_name && !error) { // if all alignments are checked -> use species_name_hash to detect duplicated species and species w/o data long duplicates = 0; long unnamed = 0; species_name_hash = GBS_create_hash(GBT_get_species_count(Main), GB_IGNORE_CASE); if (!error) { for (GBDATA *gb_species = GBT_first_species_rel_species_data(gb_sd); gb_species; gb_species = GBT_next_species(gb_species)) { const char *name = GBT_get_name(gb_species); if (name) { if (GBS_read_hash(species_name_hash, name)) duplicates++; GBS_incr_hash(species_name_hash, name); } else { unnamed++; } } } if (duplicates) { error = GBS_global_string("Database is corrupted:\n" "Found %li duplicated species with identical names!\n" "Fix the problem using\n" " 'Search For Equal Fields and Mark Duplicates'\n" "in ARBs search tool, save DB and restart ARB.", duplicates); } else if (unnamed) { error = GBS_global_string("Database is corrupted:\n" "Found %li species without IDs ('name')!\n" "This is a sewere problem!\n" "ARB will not work as expected!", unnamed); } } if (!error) { for (GBDATA *gb_ali = GB_entry(gb_presets, "alignment"); gb_ali && !error; gb_ali = GB_nextEntry(gb_ali)) { error = GBT_check_alignment(Main, gb_ali, species_name_hash); } } if (species_name_hash) { if (!error) { long counter = 0; GBS_hash_do_const_loop(species_name_hash, check_for_species_without_data, &counter); if (counter>0) { GB_warningf("Found %li species without alignment data (only some were listed)", counter); } } GBS_free_hash(species_name_hash); } return error; } void GBT_get_alignment_names(ConstStrArray& names, GBDATA *gbd) { /* Get names of existing alignments from database. * * Returns: array of strings, the last element is NULp */ GBDATA *presets = GBT_get_presets(gbd); for (GBDATA *ali = GB_entry(presets, "alignment"); ali; ali = GB_nextEntry(ali)) { GBDATA *name = GB_entry(ali, "alignment_name"); names.put(name ? GB_read_char_pntr(name) : ""); } } static char *gbt_nonexisting_alignment(GBDATA *gbMain) { char *ali_other = NULp; int counter; for (counter = 1; !ali_other; ++counter) { ali_other = GBS_global_string_copy("ali_x%i", counter); if (GBT_get_alignment(gbMain, ali_other)) freenull(ali_other); // exists -> continue } GB_clear_error(); // from GBT_get_alignment return ali_other; } GB_ERROR GBT_check_alignment_name(const char *alignment_name) { GB_ERROR error = GB_check_key(alignment_name); if (!error && !ARB_strBeginsWith(alignment_name, "ali_")) { error = GBS_global_string("alignment name '%s' has to start with 'ali_'", alignment_name); } return error; } static GB_ERROR create_ali_strEntry(GBDATA *gb_ali, const char *field, const char *strval, long write_protection) { GB_ERROR error = NULp; GBDATA *gb_sub = GB_create(gb_ali, field, GB_STRING); if (!gb_sub) error = GB_await_error(); else { error = GB_write_string(gb_sub, strval); if (!error) error = GB_write_security_delete(gb_sub, 7); if (!error) error = GB_write_security_write(gb_sub, write_protection); } if (error) { error = GBS_global_string("failed to create alignment subentry '%s'\n" "(Reason: %s)", field, error); } return error; } static GB_ERROR create_ali_intEntry(GBDATA *gb_ali, const char *field, int intval, long write_protection) { GB_ERROR error = NULp; GBDATA *gb_sub = GB_create(gb_ali, field, GB_INT); if (!gb_sub) error = GB_await_error(); else { error = GB_write_int(gb_sub, intval); if (!error) error = GB_write_security_delete(gb_sub, 7); if (!error) error = GB_write_security_write(gb_sub, write_protection); } if (error) { error = GBS_global_string("failed to create alignment subentry '%s'\n" "(Reason: %s)", field, error); } return error; } GBDATA *GBT_create_new_alignment(GBDATA *gb_main, const char *name, long len, long aligned, long security, const char *type, const char *why_created) { /* create alignment * * returns pointer to alignment or * NULp (in this case an error has been exported) */ GB_ERROR error = NULp; GBDATA *gb_presets = GBT_get_presets(gb_main); GBDATA *result = NULp; if (!gb_presets) { error = GBS_global_string("can't find/create 'presets' (Reason: %s)", GB_await_error()); } else { error = GBT_check_alignment_name(name); if (!error && (security<0 || security>6)) { error = GBS_global_string("Illegal security value %li (allowed 0..6)", security); } if (!error) { const char *allowed_types = ":dna:rna:ami:usr:"; int tlen = strlen(type); const char *found = strstr(allowed_types, type); if (!found || found == allowed_types || found[-1] != ':' || found[tlen] != ':') { error = GBS_global_string("Invalid alignment type '%s'", type); } } if (!error) { GBDATA *gb_name = GB_find_string(gb_presets, "alignment_name", name, GB_IGNORE_CASE, SEARCH_GRANDCHILD); if (gb_name) error = GBS_global_string("Alignment '%s' already exists", name); else { GBDATA *gb_ali = GB_create_container(gb_presets, "alignment"); if (!gb_ali) error = GB_await_error(); else { char *remark = GBS_global_string_copy("%s: alignment created %s", ARB_date_string(), why_created); error = GB_write_security_delete(gb_ali, 6); if (!error) error = create_ali_strEntry(gb_ali, "alignment_name", name, 6); if (!error) error = create_ali_intEntry(gb_ali, "alignment_len", len, 0); if (!error) error = create_ali_intEntry(gb_ali, "aligned", aligned <= 0 ? 0 : 1, 0); if (!error) error = create_ali_intEntry(gb_ali, "alignment_write_security", security, 6); if (!error) error = create_ali_strEntry(gb_ali, "alignment_type", type, 0); if (!error) error = create_ali_strEntry(gb_ali, "alignment_rem", remark, 0); free(remark); } if (!error) result = gb_ali; } } } if (!result) { gb_assert(error); GB_export_errorf("in GBT_create_new_alignment: %s", error); } #if defined(DEBUG) else gb_assert(!error); #endif // DEBUG return result; } GBDATA *GBT_create_alignment(GBDATA *gb_main, const char *name, long len, long aligned, long security, const char *type) { // goes to header: __ATTR__DEPRECATED_TODO("better use GBT_create_new_alignment()") // // This method restores compatibility with older binaries (esp. sina 1.3). // Reverts incompatibility introduced by r19146. return GBT_create_new_alignment(gb_main, name, len, aligned, security, type, "created by outdated non-arb-binary"); } enum CopyMoveDelMode { COPY, MOVE, DELETE }; static GB_ERROR gbt_rename_alignment_of_item(GBDATA *gb_item_container, const char *item_name, const char *item_entry_name, const char *source, const char *dest, CopyMoveDelMode mode) { GB_ERROR error = NULp; GBDATA *gb_item; for (gb_item = GB_entry(gb_item_container, item_entry_name); gb_item && !error; gb_item = GB_nextEntry(gb_item)) { GBDATA *gb_ali = GB_entry(gb_item, source); if (!gb_ali) continue; if (mode != DELETE) { GBDATA *gb_new = GB_entry(gb_item, dest); if (gb_new) { error = GBS_global_string("Entry '%s' already exists", dest); } else { gb_new = GB_create_container(gb_item, dest); if (!gb_new) error = GB_await_error(); else error = GB_copy_dropProtectMarksAndTempstate(gb_new, gb_ali); } } if (mode != COPY) error = GB_delete(gb_ali); } if (error && gb_item) { UNCOVERED(); error = GBS_global_string("%s\n(while renaming alignment for %s '%s')", error, item_name, GBT_get_name_or_description(gb_item)); } return error; } static GB_ERROR copy_move_del_alignment(GBDATA *gbMain, const char *source, const char *dest, CopyMoveDelMode mode) { // copies, moves or deletes alignments. // affects all data of that alignment in species and SAIs. gb_assert(!GB_have_error()); // illegal to enter this function when an error is exported! GB_ERROR error = NULp; bool is_case_error = false; GB_transaction ta(gbMain); gb_assert(correlated(mode == DELETE, dest == NULp)); // dest shall be NULp for DELETE + !NULp otherwise. GBDATA *gb_presets = GBT_get_presets(gbMain); GBDATA *gb_species_data = gb_presets ? GBT_get_species_data(gbMain) : NULp; GBDATA *gb_extended_data = gb_species_data ? GBT_get_SAI_data(gbMain) : NULp; if (!gb_extended_data) error = GB_await_error(); // create copy and/or delete old alignment description if (!error) { GBDATA *gb_old_alignment = GBT_get_alignment(gbMain, source); if (!gb_old_alignment) { error = GB_await_error(); } else { if (mode != DELETE) { // copy source -> dest GBDATA *gbh = GBT_get_alignment(gbMain, dest); if (gbh) { error = GBS_global_string("destination alignment '%s' already exists", dest); is_case_error = (strcasecmp(source, dest) == 0); // test for case-only difference } else { GB_clear_error(); // from GBT_get_alignment error = GBT_check_alignment_name(dest); if (!error) { GBDATA *gb_new_alignment = GB_create_container(gb_presets, "alignment"); error = GB_copy_dropProtectMarksAndTempstate(gb_new_alignment, gb_old_alignment); if (!error) error = GBT_write_string(gb_new_alignment, "alignment_name", dest); } } } if (mode != COPY && !error) { // delete source error = GB_delete(gb_old_alignment); } } } // change default alignment if (!error && mode == MOVE) { error = GBT_write_string(gb_presets, "use", dest); } // copy and/or delete alignment entries in species if (!error) { error = gbt_rename_alignment_of_item(gb_species_data, "Species", "species", source, dest, mode); } // copy and/or delete alignment entries in SAIs if (!error) { error = gbt_rename_alignment_of_item(gb_extended_data, "SAI", "extended", source, dest, mode); } if (is_case_error) { gb_assert(mode != DELETE); if (mode==COPY) { error = "Cannot copy alignment if destination name only differs in case."; } else { gb_assert(!GB_have_error()); // alignments source and dest only differ in case char *ali_other = gbt_nonexisting_alignment(gbMain); gb_assert(mode==MOVE); gb_assert(!GB_have_error()); printf("Renaming alignment '%s' -> '%s' -> '%s' (to avoid case-problem)\n", source, ali_other, dest); error = copy_move_del_alignment(gbMain, source, ali_other, MOVE); if (!error) error = copy_move_del_alignment(gbMain, ali_other, dest, MOVE); free(ali_other); } } error = ta.close(error); return error; } GB_ERROR GBT_copy_alignment(GBDATA *gbMain, const char *source, const char *dest) { return copy_move_del_alignment(gbMain, source, dest, COPY); } GB_ERROR GBT_rename_alignment(GBDATA *gbMain, const char *source, const char *dest) { return copy_move_del_alignment(gbMain, source, dest, MOVE); } GB_ERROR GBT_delete_alignment(GBDATA *gbMain, const char *source) { return copy_move_del_alignment(gbMain, source, NULp, DELETE); } // ----------------------------------------- // alignment related item functions NOT4PERL GBDATA *GBT_add_data(GBDATA *species, const char *ali_name, const char *key, GB_TYPES type) { // goes to header: __ATTR__DEPRECATED_TODO("better use GBT_create_sequence_data()") /* replace this function by GBT_create_sequence_data * the same as GB_search(species, 'ali_name/key', GB_CREATE) * * Note: The behavior is weird, cause it does sth special for GB_STRING (write default content "...") * * returns create database entry (or NULp; exports an error in this case) */ GB_ERROR error = GB_check_key(ali_name); if (error) { error = GBS_global_string("Invalid alignment name '%s' (Reason: %s)", ali_name, error); } else { error = GB_check_hkey(key); if (error) { error = GBS_global_string("Invalid field name '%s' (Reason: %s)", key, error); } } GBDATA *gb_data = NULp; if (error) { GB_export_error(error); } else { GBDATA *gb_gb = GB_entry(species, ali_name); if (!gb_gb) gb_gb = GB_create_container(species, ali_name); if (gb_gb) { if (type == GB_STRING) { gb_data = GB_search(gb_gb, key, GB_FIND); if (!gb_data) { gb_data = GB_search(gb_gb, key, GB_STRING); GB_write_string(gb_data, "..."); } } else { gb_data = GB_search(gb_gb, key, type); } } } return gb_data; } NOT4PERL GBDATA *GBT_create_sequence_data(GBDATA *species, const char *ali_name, const char *key, GB_TYPES type, int security_write) { GBDATA *gb_data = GBT_add_data(species, ali_name, key, type); if (gb_data) { GB_ERROR error = GB_write_security_write(gb_data, security_write); if (error) { GB_export_error(error); gb_data = NULp; } } return gb_data; } GBDATA *GBT_gen_accession_number(GBDATA *gb_species, const char *ali_name) { GBDATA *gb_acc = GB_entry(gb_species, "acc"); if (!gb_acc) { GBDATA *gb_data = GBT_find_sequence(gb_species, ali_name); if (gb_data) { // found a valid alignment GB_CSTR sequence = GB_read_char_pntr(gb_data); long id = GBS_checksum(sequence, 1, ".-"); const char *acc = GBS_global_string("ARB_%lX", id); GB_ERROR error = GBT_write_string(gb_species, "acc", acc); if (error) GB_export_error(error); } } return gb_acc; } int GBT_is_partial(GBDATA *gb_species, int default_value, bool define_if_undef) { // checks whether a species has a partial or full sequence // // Note: partial sequences should not be used for tree calculations // // returns: 0 if sequence is full // 1 if sequence is partial // -1 in case of error (which is exported in this case) // // if the sequence has no 'ARB_partial' entry it returns 'default_value' // if 'define_if_undef' is true then create an 'ARB_partial'-entry with the default value int result = -1; GB_ERROR error = NULp; GBDATA *gb_partial = GB_entry(gb_species, "ARB_partial"); if (gb_partial) { result = GB_read_int(gb_partial); if (result != 0 && result != 1) { error = "Illegal value for 'ARB_partial' (only 1 or 0 allowed)"; } } else { if (define_if_undef) { error = GBT_write_int(gb_species, "ARB_partial", default_value); } result = default_value; } if (error) { GB_export_error(error); return -1; } return result; } GBDATA *GBT_find_sequence(GBDATA *gb_species, const char *aliname) { GBDATA *gb_ali = GB_entry(gb_species, aliname); return gb_ali ? GB_entry(gb_ali, "data") : NULp; } static char *get_default_alignment(GBDATA *gb_main, bool use_startup_ali) { /*! behavior @see GBT_get_default_alignment. * @param use_startup_ali if 'true' -> always return the value seen when first called with 'true' + make calls with 'false' always return an error. * The intention is to be able to force that an applications sticks with the * alignment found at startup and ignores if alignment is changed in arb_ntree. */ gb_assert(!GB_have_error()); // illegal to enter this function when an error is exported! static SmartCharPtr startup_ali_name; // set once (when function is first called with 'use_startup_ali'==true) char *ali_name = NULp; if (startup_ali_name.isSet()) { ali_name = ARB_strdup(&*startup_ali_name); } else { ali_name = GBT_read_string(gb_main, GB_DEFAULT_ALIGNMENT); if (ali_name) { if (strcmp(ali_name, NO_ALI_SELECTED) == 0) { GB_export_error("No alignment is selected."); freenull(ali_name); } else if (!ARB_strBeginsWith(ali_name, "ali_")) { GB_export_errorf("Selected alignment '%s' is not valid!", ali_name); freenull(ali_name); } } if (ali_name && use_startup_ali) { // first sucessful call with 'use_startup_ali==true' startup_ali_name = ARB_strdup(ali_name); // this will remain default until program terminates } } gb_assert(contradicted(ali_name, GB_have_error())); // either result or error! return ali_name; } char *GBT_get_default_alignment(GBDATA *gb_main) { /*! @return default alignment * returns * - the alignment that was selected in ARB alignment admin, when GBT_get_startup_alignment was called first OR * - the alignment currently selected in ARB alignment admin OR * - NULp if NO (valid) alignment selected. * An error is exported in that case! */ return get_default_alignment(gb_main, false); } char *GBT_get_startup_alignment(GBDATA *gb_main) { /*! same interface as GBT_get_default_alignment. * When this was called once w/o error, calls to GBT_get_default_alignment always return * the alignment which was default then. */ return get_default_alignment(gb_main, true); } GB_ERROR GBT_set_default_alignment(GBDATA *gb_main, const char *alignment_name) { return GBT_write_string(gb_main, GB_DEFAULT_ALIGNMENT, alignment_name); } GB_ERROR GBT_set_startup_alignment(GBDATA *gb_main, const char *alignment_name) { // Similar to GBT_set_default_alignment, but does not change database default alignment. // Instead it changes the application-local alignment which is derived from default // alignment and "freezed" on first request (by using GBT_get_startup_alignment). // // Warning: GBT_set_startup_alignment fails if GBT_get_startup_alignment was already called! GB_ERROR error = NULp; char *default_ali = GBT_get_default_alignment(gb_main); bool freeze_and_reset = false; if (!default_ali) { GB_clear_error(); default_ali = ARB_strdup(NO_ALI_SELECTED); freeze_and_reset = true; } else { freeze_and_reset = strcmp(default_ali, alignment_name) != 0; } if (freeze_and_reset) { error = GBT_set_default_alignment(gb_main, alignment_name); if (!error) { char *startup_ali = GBT_get_startup_alignment(gb_main); if (!startup_ali) error = GB_await_error(); // most unlikely else { if (strcmp(startup_ali, alignment_name) != 0) { error = GBS_global_string("Cannot freeze alignment to '%s' (already was frozen to '%s' before)", alignment_name, startup_ali); } // fine, the correct alignment is freezed! free(startup_ali); } } // undo (tmp) change to default alignment: GB_ERROR minerr = GBT_set_default_alignment(gb_main, default_ali); error = error ? error : minerr; } free(default_ali); return error; } GBDATA *GBT_get_alignment(GBDATA *gb_main, const char *aliname) { /*! @return global alignment container for alignment 'aliname' or * NULp if alignment not found (error exported in that case) */ GBDATA *gb_ali = NULp; if (!aliname || strcmp(aliname, NO_ALI_SELECTED) == 0) { GB_export_error("no alignment selected"); } else { GBDATA *gb_presets = GBT_get_presets(gb_main); GBDATA *gb_alignment_name = GB_find_string(gb_presets, "alignment_name", aliname, GB_IGNORE_CASE, SEARCH_GRANDCHILD); if (!gb_alignment_name) { GB_export_errorf("alignment '%s' not found", aliname); } else { gb_ali = GB_get_father(gb_alignment_name); } } gb_assert(contradicted(gb_ali, GB_have_error())); // either result or error! return gb_ali; } // @@@ recode and change result type to long* ? long GBT_get_alignment_len(GBDATA *gb_main, const char *aliname) { /*! @return length (>0) of alignment 'aliname' or * -1 if alignment not found (error exported in that case) * 0 if alignment length is zero (=invalid; error exported in that case) */ GBDATA *gb_alignment = GBT_get_alignment(gb_main, aliname); long len = gb_alignment ? *GBT_read_int(gb_alignment, "alignment_len") : -1; if (len == 0) GB_export_errorf("alignment '%s' has no data", aliname); gb_assert(contradicted(len>0, GB_have_error())); // either valid result or error! return len; } GB_ERROR GBT_set_alignment_len(GBDATA *gb_main, const char *aliname, long new_len) { GB_ERROR error = NULp; GBDATA *gb_alignment = GBT_get_alignment(gb_main, aliname); if (!gb_alignment) { error = GB_await_error(); } else { GB_topSecurityLevel unsecured(gb_main); error = GBT_write_int(gb_alignment, "alignment_len", new_len); // write new len if (!error) error = GBT_write_int(gb_alignment, "aligned", 0); // mark as unaligned } return error; } char *GBT_get_alignment_type_string(GBDATA *gb_main, const char *aliname) { /*! @return type-string of alignment 'aliname' or * NULp if alignment not found (error exported in that case) */ GBDATA *gb_alignment = GBT_get_alignment(gb_main, aliname); char *result = gb_alignment ? GBT_read_string(gb_alignment, "alignment_type") : NULp; if (!result && !GB_have_error()) { GB_export_errorf("Alignment '%s' has no alignment_type defined", aliname); } gb_assert(contradicted(result, GB_have_error())); // either result or error! return result; } GB_alignment_type GBT_get_alignment_type(GBDATA *gb_main, const char *aliname) { /*! @return type of alignment as enum type (GB_alignment_type). * GB_AT_UNKNOWN if alignment not found (error exported in that case) */ char *ali_type = GBT_get_alignment_type_string(gb_main, aliname); GB_alignment_type at = GB_AT_UNKNOWN; if (ali_type) { switch (ali_type[0]) { case 'r': if (strcmp(ali_type, "rna")==0) at = GB_AT_RNA; break; case 'd': if (strcmp(ali_type, "dna")==0) at = GB_AT_DNA; break; case 'a': if (strcmp(ali_type, "ami")==0) at = GB_AT_AA; break; case 'p': if (strcmp(ali_type, "pro")==0) at = GB_AT_AA; break; default: gb_assert(0); break; } free(ali_type); } return at; } bool GBT_is_alignment_protein(GBDATA *gb_main, const char *alignment_name) { GB_alignment_type ali_type = GBT_get_alignment_type(gb_main, alignment_name); gb_assert(ali_type != GB_AT_UNKNOWN); return ali_type == GB_AT_AA; } // ----------------------- // gene sequence static const char *gb_cache_genome(GBDATA *gb_genome) { static GBDATA *gb_last_genome = NULp; static char *last_genome = NULp; if (gb_genome != gb_last_genome) { free(last_genome); last_genome = GB_read_string(gb_genome); gb_last_genome = gb_genome; } return last_genome; } struct gene_part_pos { int parts; // initialized for parts unsigned char *certain; // contains parts "=" chars char offset[256]; }; static gene_part_pos *gpp = NULp; static void init_gpp(int parts) { if (!gpp) { int i; ARB_alloc(gpp, 1); gpp->certain = NULp; for (i = 0; i<256; ++i) gpp->offset[i] = 0; gpp->offset[(int)'+'] = 1; gpp->offset[(int)'-'] = -1; } else { if (parts>gpp->parts) freenull(gpp->certain); } if (!gpp->certain) { int forParts = parts+10; ARB_alloc(gpp->certain, forParts+1); memset(gpp->certain, '=', forParts); gpp->certain[forParts] = 0; gpp->parts = forParts; } } static void getPartPositions(const GEN_position *pos, int part, size_t *startPos, size_t *stopPos) { // returns 'startPos' and 'stopPos' of one part of a gene gb_assert(partparts); *startPos = pos->start_pos[part]+gpp->offset[(pos->start_uncertain ? pos->start_uncertain : gpp->certain)[part]]; *stopPos = pos->stop_pos [part]+gpp->offset[(pos->stop_uncertain ? pos->stop_uncertain : gpp->certain)[part]]; } NOT4PERL char *GBT_read_gene_sequence_and_length(GBDATA *gb_gene, bool use_revComplement, char partSeparator, size_t *gene_length) { // return the sequence data of a gene // // if use_revComplement is true -> use data from complementary strand (if complement is set for gene) // otherwise -> use data from primary strand (sort+merge parts by position) // // if partSeparator not is 0 -> insert partSeparator between single (non-merged) parts // // returns sequence as result (and length of sequence if 'gene_length' points to something) // // if 'pos_certain' contains '+', start behind position (or end at position) // '-', start at position (or end before position) // // For zero-length genes (e.g. "711^712") this function returns an empty string. GB_ERROR error = NULp; char *result = NULp; GBDATA *gb_species = GB_get_grandfather(gb_gene); GEN_position *pos = GEN_read_position(gb_gene); if (!pos) error = GB_await_error(); else { GBDATA *gb_seq = GBT_find_sequence(gb_species, "ali_genom"); unsigned long seq_length = GB_read_count(gb_seq); int p; int parts = pos->parts; int resultlen = 0; int separatorSize = partSeparator ? 1 : 0; init_gpp(parts); // test positions and calculate overall result length for (p = 0; p(stop+1) || stop > seq_length) { // do not reject zero-length genes (start == stop+1) error = GBS_global_string("Illegal gene position(s): start=%zu, end=%zu, seq.length=%li", start, stop, seq_length); } else { resultlen += stop-start+1; } } if (separatorSize) resultlen += (parts-1)*separatorSize; if (!error) { char T_or_U = 0; if (use_revComplement) { error = GBT_determine_T_or_U(GB_AT_DNA, &T_or_U, "reverse-complement"); } else if (parts>1) { GEN_sortAndMergeLocationParts(pos); parts = pos->parts; // may have changed } if (!error) { const char *seq_data = gb_cache_genome(gb_seq); char *resultpos; ARB_alloc(result, resultlen+1); resultpos = result; if (gene_length) *gene_length = resultlen; for (p = 0; p0) *resultpos++ = partSeparator; memcpy(resultpos, seq_data+start-1, len); if (T_or_U && pos->complement[p]) { GBT_reverseComplementNucSequence(resultpos, len, T_or_U); } resultpos += len; } resultpos[0] = 0; } } GEN_free_position(pos); } gb_assert(contradicted(result, error)); // either result or error! if (error) { char *id = GEN_global_gene_identifier(gb_gene, gb_species); error = GB_export_errorf("Can't read sequence of '%s' (Reason: %s)", id, error); free(id); free(result); result = NULp; } return result; } char *GBT_read_gene_sequence(GBDATA *gb_gene, bool use_revComplement, char partSeparator) { return GBT_read_gene_sequence_and_length(gb_gene, use_revComplement, partSeparator, NULp); } // -------------------------------------------------------------------------------- #ifdef UNIT_TESTS #include #define TEST_EXPECT_EXISTING_ALIGNMENTS(expected) do{ \ names.erase(); \ GBT_get_alignment_names(names, gb_main); \ TEST_EXPECT_STRARRAY_CONTAINS(names, '*', expected); \ }while(0) #define TEST_EXPECT_EXISTING_ALIGNMENTS__BROKEN(want,got) do{ \ names.erase(); \ GBT_get_alignment_names(names, gb_main); \ TEST_EXPECT_STRARRAY_CONTAINS__BROKEN(names, '*', want,got); \ }while(0) #define TEST_EXPECT_DEFAULT_ALIGNMENT(expected) \ TEST_EXPECT_EQUAL_STRINGCOPY__NOERROREXPORTED(GBT_get_default_alignment(gb_main), expected); #define TEST_EXPECT_ALIGNMENT_STATE(expected_default,expected_existing) do{ \ GB_initial_transaction ta(gb_main); \ TEST_EXPECT_DEFAULT_ALIGNMENT(expected_default); \ TEST_EXPECT_EXISTING_ALIGNMENTS(expected_existing); \ }while(0) void TEST_alignment() { GB_shell shell; GBDATA *gb_main = GB_open("TEST_prot.arb", "r"); // ../UNIT_TESTER/run/TEST_prot.arb ConstStrArray names; { GB_transaction ta(gb_main); TEST_EXPECT_EQUAL(GBT_count_alignments(gb_main), 2); TEST_EXPECT_DEFAULT_ALIGNMENT("ali_tuf_dna"); TEST_EXPECT_EXISTING_ALIGNMENTS("ali_tuf_pro*ali_tuf_dna"); for (int i = 0; names[i]; ++i) { long len = GBT_get_alignment_len(gb_main, names[i]); TEST_EXPECT_EQUAL(len, i ? 1462 : 487); char *type_name = GBT_get_alignment_type_string(gb_main, names[i]); TEST_EXPECT_EQUAL(type_name, i ? "dna" : "ami"); free(type_name); GB_alignment_type type = GBT_get_alignment_type(gb_main, names[i]); TEST_EXPECT_EQUAL(type, i ? GB_AT_DNA : GB_AT_AA); TEST_EXPECT_EQUAL(GBT_is_alignment_protein(gb_main, names[i]), !i); } // test functions called with aliname == NULp TEST_EXPECT_NORESULT__ERROREXPORTED_CONTAINS(GBT_get_alignment(gb_main, NULp), "no alignment"); TEST_EXPECT_EQUAL(GBT_get_alignment_len(gb_main, NULp), -1); TEST_EXPECT_CONTAINS(GB_await_error(), "no alignment"); TEST_EXPECT_NORESULT__ERROREXPORTED_CONTAINS(GBT_get_alignment_type_string(gb_main, NULp), "no alignment"); // test functions called with aliname == NO_ALI_SELECTED TEST_EXPECT_NORESULT__ERROREXPORTED_CONTAINS(GBT_get_alignment(gb_main, NO_ALI_SELECTED), "no alignment"); TEST_EXPECT_EQUAL(GBT_get_alignment_len(gb_main, NO_ALI_SELECTED), -1); TEST_EXPECT_CONTAINS(GB_await_error(), "no alignment"); TEST_EXPECT_NORESULT__ERROREXPORTED_CONTAINS(GBT_get_alignment_type_string(gb_main, NO_ALI_SELECTED), "no alignment"); } // test copy, move(rename), delete alignments TEST_EXPECT_ALIGNMENT_STATE("ali_tuf_dna", "ali_tuf_pro*ali_tuf_dna"); // copy ali + test names: { GB_transaction ta(gb_main); TEST_EXPECT_NO_ERROR(GBT_copy_alignment(gb_main, "ali_tuf_pro", "ali_copied_pro")); TEST_EXPECT_NO_ERROR(GBT_copy_alignment(gb_main, "ali_tuf_dna", "ali_copied_dna")); } TEST_EXPECT_ALIGNMENT_STATE("ali_tuf_dna", "ali_tuf_pro*ali_tuf_dna*ali_copied_pro*ali_copied_dna"); // rename ali + test names: { GB_transaction ta(gb_main); TEST_EXPECT_ERROR_CONTAINS(GBT_rename_alignment(gb_main, "ali_tuf_pro", "ali_moved_pro"), "Security error: deleting entry 'alignment' not permitted"); } TEST_EXPECT_ALIGNMENT_STATE("ali_tuf_dna", "ali_tuf_pro*ali_tuf_dna*ali_copied_pro*ali_copied_dna"); { GB_transaction ta(gb_main); GB_securityLevel raise(gb_main, 6); TEST_EXPECT_NO_ERROR(GBT_rename_alignment(gb_main, "ali_tuf_pro", "ali_moved_pro")); TEST_EXPECT_NO_ERROR(GBT_rename_alignment(gb_main, "ali_tuf_dna", "ali_moved_dna")); } TEST_EXPECT_ALIGNMENT_STATE("ali_moved_dna", "ali_copied_pro*ali_copied_dna*ali_moved_pro*ali_moved_dna"); // delete ali + test names: { GB_transaction ta(gb_main); TEST_EXPECT_NO_ERROR(GBT_delete_alignment(gb_main, "ali_copied_pro")); TEST_EXPECT_NO_ERROR(GBT_delete_alignment(gb_main, "ali_moved_dna")); // @@@ the rename-test (above) lowered the security of 'ali_tuf_dna' (from 6 to 0?). unwanted behavior! } TEST_EXPECT_ALIGNMENT_STATE("ali_moved_dna", // @@@ unwanted behavior (deleted alignment is selected as default) "ali_copied_dna*ali_moved_pro"); // trigger error cases: { GB_transaction ta(gb_main); TEST_EXPECT_ERROR_CONTAINS(GBT_rename_alignment(gb_main, "ali_copied_dna", "ali_moved_pro"), "destination alignment 'ali_moved_pro' already exists"); TEST_EXPECT_ERROR_CONTAINS(GBT_copy_alignment(gb_main, "ali_copied_dna", "ali_copied_DNA"), "Cannot copy alignment if destination name only differs in case."); } // test case-only rename { GB_transaction ta(gb_main); TEST_EXPECT_NO_ERROR(GBT_rename_alignment(gb_main, "ali_copied_dna", "ali_copied_DNA")); } TEST_EXPECT_ALIGNMENT_STATE("ali_copied_DNA", "ali_moved_pro*ali_copied_DNA"); GB_close(gb_main); } TEST_PUBLISH(TEST_alignment); #endif // UNIT_TESTS