// =============================================================== // // // // File : MG_species.cxx // // Purpose : // // // // Institute of Microbiology (Technical University Munich) // // http://www.arb-home.de/ // // // // =============================================================== // #include "merge.hxx" #include "MG_adapt_ali.hxx" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #define AWAR_SPECIES_SRC AWAR_MERGE_TMP_SRC "name" #define AWAR_FIELD_SRC AWAR_MERGE_TMP_SRC "field" #define AWAR_TAG_SRC AWAR_MERGE_TMP_SRC "tag" #define AWAR_SPECIES_DST AWAR_MERGE_TMP_DST "name" #define AWAR_FIELD_DST AWAR_MERGE_TMP_DST "field" #define AWAR_TAG_DST AWAR_MERGE_TMP_DST "tag" #define AWAR_TAG_DEL AWAR_MERGE_TMP "tagdel" #define AWAR_APPEND AWAR_MERGE_TMP "append" #define AWAR_SPECIES_XFER_TYPE AWAR_MERGE_SAV "xferType" #define AWAR_SPECIES_XFER_SCOPE AWAR_MERGE_SAV "xferScope" #define AWAR_SPECIES_XFER_FTS AWAR_MERGE_SAV "fts" static DbScanner *scanner_src = NULp; static DbScanner *scanner_dst = NULp; enum SpeciesXferType { SXT_WHOLE_SPECIES, SXT_SINGLE_FIELD, // (skips alignment data) SXT_USING_FTS, // field transfer set SXT_USING_FTS_SKIP_ALI, // field transfer set (skips alignment data) }; enum SpeciesXferScope { SXS_SELECTED_SPECIES, SXS_LISTED_SPECIES, }; const char *MG_left_AWAR_SPECIES_NAME() { return AWAR_SPECIES_SRC; } void MG_create_species_awars(AW_root *aw_root, AW_default aw_def) { aw_root->awar_string(AWAR_SPECIES_SRC, "", aw_def); aw_root->awar_string(AWAR_SPECIES_DST, "", aw_def); aw_root->awar_string(AWAR_FIELD_SRC, NO_FIELD_SELECTED, aw_def); aw_root->awar_string(AWAR_FIELD_DST, NO_FIELD_SELECTED, aw_def); aw_root->awar_int(AWAR_APPEND, 0, aw_def); aw_root->awar_int(AWAR_SPECIES_XFER_TYPE, SXT_WHOLE_SPECIES, aw_def); aw_root->awar_int(AWAR_SPECIES_XFER_SCOPE, SXS_LISTED_SPECIES, aw_def); aw_root->awar_string(AWAR_SPECIES_XFER_FTS, "", aw_def); } static void MG_map_species(AW_root *aw_root, DbSel db) { GBDATA *gb_main = get_gb_main(db); const char *awar_name = db == SRC_DB ? AWAR_SPECIES_SRC : AWAR_SPECIES_DST; DbScanner *scanner = db == SRC_DB ? scanner_src : scanner_dst; GB_transaction ta(gb_main); char *selected_species = aw_root->awar(awar_name)->read_string(); GBDATA *gb_species = GBT_find_species(gb_main, selected_species); if (gb_species) { scanner->Map(gb_species, awar_name); // @@@ why is awar_name passed here? (normally a changekey-path is used) // @@@ undocumented feature in DbScanner or bug? } free(selected_species); } static GB_ERROR MG_transfer_fields_info(char *fieldname = NULp) { GBDATA *gb_key_data = GB_search(GLOBAL_gb_src, CHANGE_KEY_PATH, GB_CREATE_CONTAINER); GB_ERROR error = NULp; if (!gb_key_data) error = GB_await_error(); else { if (!GB_search(GLOBAL_gb_dst, CHANGE_KEY_PATH, GB_CREATE_CONTAINER)) error = GB_await_error(); else { for (GBDATA *gb_key = GB_entry(gb_key_data, CHANGEKEY); gb_key && !error; gb_key = GB_nextEntry(gb_key)) { GBDATA *gb_key_name = GB_entry(gb_key, CHANGEKEY_NAME); if (gb_key_name) { GBDATA *gb_key_type = GB_entry(gb_key, CHANGEKEY_TYPE); if (gb_key_type) { char *name = GB_read_string(gb_key_name); if (!fieldname || strcmp(fieldname, name) == 0) { error = GBT_add_new_species_changekey(GLOBAL_gb_dst, name, GB_TYPES(GB_read_int(gb_key_type))); } free(name); } } } } } return error; } static GB_ERROR MG_transfer_one_species(AW_root *aw_root, MG_remaps& remap, GBDATA *gb_src_species, GBDATA *gb_dst_species_data, bool src_is_genome, bool dst_is_genome, GB_HASH *source_organism_hash, GB_HASH *dest_species_hash, GB_HASH *error_suppressor) { // copies species 'gb_src_species' from source to destination DB. // // 'source_organism_hash' may be NULp, otherwise it's used to search for source organisms (when merging from genome DB) // 'dest_species_hash' may be NULp, otherwise created species is stored there mg_assert(gb_src_species); GB_ERROR error = NULp; const char *src_name = GBT_get_name(gb_src_species); bool transfer_fields = false; if (!src_name) { error = "refused to transfer unnamed species"; } else { if (src_is_genome) { if (dst_is_genome) { // genome -> genome if (GEN_is_pseudo_gene_species(gb_src_species)) { const char *origin = GEN_origin_organism(gb_src_species); GBDATA *dest_organism = dest_species_hash ? (GBDATA*)GBS_read_hash(dest_species_hash, origin) : GEN_find_organism(GLOBAL_gb_dst, origin); if (dest_organism) transfer_fields = true; else { error = GBS_global_string("Destination DB does not contain '%s's origin-organism '%s'", src_name, origin); } } // else: merge organism ok } else { // genome -> non-genome if (GEN_is_pseudo_gene_species(gb_src_species)) transfer_fields = true; else { error = GBS_global_string("You can't merge organisms (%s) into a non-genome DB.\n" "Only pseudo-species are possible", src_name); } } } else { if (dst_is_genome) { // non-genome -> genome error = GBS_global_string("You can't merge non-genome species (%s) into a genome DB", src_name); } // else: non-genome -> non-genome ok } } GBDATA *gb_dst_species = NULp; if (!error) { gb_dst_species = dest_species_hash ? (GBDATA*)GBS_read_hash(dest_species_hash, src_name) : GBT_find_species_rel_species_data(gb_dst_species_data, src_name); if (gb_dst_species) error = GB_delete(gb_dst_species); } if (!error) { gb_dst_species = GB_create_container(gb_dst_species_data, "species"); if (!gb_dst_species) error = GB_await_error(); } if (!error) error = GB_copy_dropProtectMarksAndTempstate(gb_dst_species, gb_src_species); if (!error && transfer_fields) { mg_assert(src_is_genome); error = MG_export_fields(aw_root, gb_src_species, gb_dst_species, error_suppressor, source_organism_hash); } if (!error) GB_write_flag(gb_dst_species, 1); if (!error) error = MG_adaptAllCopiedAlignments(remap, gb_src_species, gb_dst_species); if (!error && dest_species_hash) GBS_write_hash(dest_species_hash, src_name, (long)gb_dst_species); return error; } static const char *get_reference_species_names(AW_root *awr) { return awr->awar(AWAR_REMAP_SPECIES_LIST)->read_char_pntr(); } static bool adaption_enabled(AW_root *awr) { return awr->awar(AWAR_REMAP_ENABLE)->read_int() != 0; } static void mg_transfer_selected_species(AW_window *aww) { if (MG_copy_and_check_alignments() != 0) return; AW_root *aw_root = aww->get_root(); char *src_name = aw_root->awar(AWAR_SPECIES_SRC)->read_string(); GB_ERROR error = NULp; if (!src_name || !src_name[0]) { error = "Please select a species in the left list"; } else { arb_progress progress("Transferring selected species"); error = GB_begin_transaction(GLOBAL_gb_src); if (!error) error = GB_begin_transaction(GLOBAL_gb_dst); if (!error) { MG_remaps rm(GLOBAL_gb_src, GLOBAL_gb_dst, adaption_enabled(aw_root), get_reference_species_names(aw_root)); GBDATA *gb_src_species_data = GBT_get_species_data(GLOBAL_gb_src); GBDATA *gb_dst_species_data = GBT_get_species_data(GLOBAL_gb_dst); bool src_is_genome = GEN_is_genome_db(GLOBAL_gb_src, -1); bool dst_is_genome = GEN_is_genome_db(GLOBAL_gb_dst, -1); GBDATA *gb_src_species = GBT_find_species_rel_species_data(gb_src_species_data, src_name); if (!gb_src_species) { error = GBS_global_string("Could not find species '%s' in source database", src_name); } else { error = MG_transfer_one_species(aw_root, rm, gb_src_species, gb_dst_species_data, src_is_genome, dst_is_genome, NULp, NULp, NULp); } } if (!error) error = MG_transfer_fields_info(); error = GB_end_transaction(GLOBAL_gb_src, error); error = GB_end_transaction(GLOBAL_gb_dst, error); } if (error) aw_message(error); } static void mg_transfer_listed_species(AW_window *aww) { if (MG_copy_and_check_alignments() != 0) return; GB_ERROR error = NULp; GB_begin_transaction(GLOBAL_gb_src); GB_begin_transaction(GLOBAL_gb_dst); bool src_is_genome = GEN_is_genome_db(GLOBAL_gb_src, -1); bool dst_is_genome = GEN_is_genome_db(GLOBAL_gb_dst, -1); GB_HASH *error_suppressor = GBS_create_hash(50, GB_IGNORE_CASE); GB_HASH *dest_species_hash = GBT_create_species_hash(GLOBAL_gb_dst); GB_HASH *source_organism_hash = src_is_genome ? GBT_create_organism_hash(GLOBAL_gb_src) : NULp; AW_root *aw_root = aww->get_root(); MG_remaps rm(GLOBAL_gb_src, GLOBAL_gb_dst, adaption_enabled(aw_root), get_reference_species_names(aw_root)); GBDATA *gb_src_species; arb_progress progress("Transferring listed species", mg_count_queried(GLOBAL_gb_src)); for (gb_src_species = GBT_first_species(GLOBAL_gb_src); gb_src_species; gb_src_species = GBT_next_species(gb_src_species)) { if (IS_QUERIED_SPECIES(gb_src_species)) { GBDATA *gb_dst_species_data = GBT_get_species_data(GLOBAL_gb_dst); error = MG_transfer_one_species(aw_root, rm, gb_src_species, gb_dst_species_data, src_is_genome, dst_is_genome, source_organism_hash, dest_species_hash, error_suppressor); progress.inc_and_check_user_abort(error); } } GBS_free_hash(dest_species_hash); if (source_organism_hash) GBS_free_hash(source_organism_hash); GBS_free_hash(error_suppressor); if (!error) error = MG_transfer_fields_info(); error = GB_end_transaction(GLOBAL_gb_src, error); GB_end_transaction_show_error(GLOBAL_gb_dst, error, aw_message); } static GB_ERROR transfer_single_field(GBDATA *const gb_src_species, GBDATA *const gb_dst_species, const char *const field, GBDATA *const gb_src_field, const bool append, const bool transfer_of_alignment, const MG_remaps& rm) { GBDATA *gb_dst_field = GB_search(gb_dst_species, field, GB_FIND); GB_TYPES src_type = GB_read_type(gb_src_field); GB_TYPES dst_type = gb_dst_field ? GB_read_type(gb_dst_field) : src_type; bool use_copy = true; GB_ERROR error = NULp; if (append) { if (src_type != GB_STRING || dst_type != GB_STRING) { error = "You can use 'Append data' with text fields only!"; } else if (gb_dst_field) { // append possible (otherwise use_copy!) char *src_val = GB_read_string(gb_src_field); char *dst_val = GB_read_string(gb_dst_field); if (!src_val || !dst_val) error = GB_await_error(); else { if (!GBS_find_string(dst_val, src_val, 0)) { // do not append if dst_val contains src_val error = GB_write_string(gb_dst_field, GBS_global_string("%s %s", dst_val, src_val)); if (!error) GB_write_flag(gb_dst_species, 1); } } free(src_val); free(dst_val); use_copy = false; } } if (!error && use_copy) { if (dst_type != src_type) error = "type mismatch"; // abort early (previously failed in call to MG_transfer_fields_info below) if (!error && src_type == GB_DB && gb_dst_field) { // if type is container -> delete before copy // (otherwise it would generate a mix of both containers; if wanted provide optionally) error = GB_delete(gb_dst_field); gb_dst_field = NULp; // trigger recreation+copy } if (!error && !gb_dst_field) { // create missing target field (otherwise simply overwrite) gb_dst_field = GB_search(gb_dst_species, field, src_type); if (!gb_dst_field) error = GB_await_error(); // failed to create? } if (!error) error = GB_copy_dropProtectMarksAndTempstate(gb_dst_field, gb_src_field); // [Note: if transfer_of_alignment -> copies 'data' field of one alignment] if (!error && transfer_of_alignment) error = MG_adaptAllCopiedAlignments(rm, gb_src_species, gb_dst_species); // [Note: adapts all copied alignments, if adapt toggle is checked] if (!error) GB_write_flag(gb_dst_species, 1); } return error; } inline bool fieldContainsAlignment(const char *field) { return GBS_string_matches(field, "ali_*", GB_MIND_CASE); } static void transfer_field_of_listed_cb(AW_window *aww) { if (MG_copy_and_check_alignments() != 0) return; AW_root *aw_root = aww->get_root(); char *field = aw_root->awar(AWAR_FIELD_SRC)->read_string(); const bool append = aw_root->awar(AWAR_APPEND)->read_int(); GB_ERROR error = NULp; if (strcmp(field, NO_FIELD_SELECTED) == 0) { error = "Please select the field you like to transfer"; } else if (strcmp(field, "name") == 0) { error = "Transferring the 'name' field is forbidden"; } else { const bool transfer_of_alignment = fieldContainsAlignment(field); if (transfer_of_alignment && append) { error = "Appending alignment data is not permitted\n" "(please refer to ARB/Sequence/Concatenate.. to do so)"; } else { error = GB_begin_transaction(GLOBAL_gb_src); if (!error) error = GB_begin_transaction(GLOBAL_gb_dst); if (!error) { arb_progress progress("Transferring fields of listed", mg_count_queried(GLOBAL_gb_src)); MG_remaps rm(GLOBAL_gb_src, GLOBAL_gb_dst, adaption_enabled(aw_root), get_reference_species_names(aw_root)); // @@@ unused if transfer_of_alignment == false GBDATA *gb_dest_species_data = GBT_get_species_data(GLOBAL_gb_dst); if (!gb_dest_species_data) error = GB_await_error(); for (GBDATA *gb_src_species = GBT_first_species(GLOBAL_gb_src); gb_src_species && !error; gb_src_species = GBT_next_species(gb_src_species)) { if (IS_QUERIED_SPECIES(gb_src_species)) { const char *src_name = GBT_get_name(gb_src_species); if (src_name) { GBDATA *gb_dst_species = GB_find_string(gb_dest_species_data, "name", src_name, GB_IGNORE_CASE, SEARCH_GRANDCHILD); if (!gb_dst_species) { gb_dst_species = GB_create_container(gb_dest_species_data, "species"); if (!gb_dst_species) error = GB_await_error(); else error = GBT_write_string(gb_dst_species, "name", src_name); } else { gb_dst_species = GB_get_father(gb_dst_species); } if (!error) { // @@@ DRY vs inner part of body of transfer_field_of_selected_cb .@DRY_TRANSFER_FIELD GBDATA *gb_src_field = GB_search(gb_src_species, field, GB_FIND); if (gb_src_field) { error = transfer_single_field(gb_src_species, gb_dst_species, field, gb_src_field, append, transfer_of_alignment, rm); } } if (error) error = GBS_global_string("%s (species=%s)", error, src_name); // mention name of species in error message } else { error = "refusing to transfer from unnamed species"; } progress.inc_and_check_user_abort(error); } } } if (!error) error = MG_transfer_fields_info(field); error = GB_end_transaction(GLOBAL_gb_src, error); error = GB_end_transaction(GLOBAL_gb_dst, error); } } if (error) aw_message(error); free(field); } static void transfer_field_of_selected_cb(AW_window *aww) { if (MG_copy_and_check_alignments() != 0) return; AW_root *aw_root = aww->get_root(); char *field = aw_root->awar(AWAR_FIELD_SRC)->read_string(); const bool append = false; // @@@ provide via GUI? GB_ERROR error = NULp; if (strcmp(field, NO_FIELD_SELECTED) == 0) { error = "Please select the field you like to transfer"; } else if (strcmp(field, "name") == 0) { error = "Transferring the 'name' field is forbidden"; } else { const bool transfer_of_alignment = fieldContainsAlignment(field); if (transfer_of_alignment && append) { // @@@ append always false (see above) error = "Appending alignment data is not permitted\n" "(please refer to ARB/Sequence/Concatenate.. to do so)"; } else { error = GB_begin_transaction(GLOBAL_gb_src); if (!error) error = GB_begin_transaction(GLOBAL_gb_dst); if (!error) { arb_progress progress("Cross copy field"); MG_remaps rm(GLOBAL_gb_src, GLOBAL_gb_dst, adaption_enabled(aw_root), get_reference_species_names(aw_root)); // @@@ unused if transfer_of_alignment == false GBDATA *gb_src_species; GBDATA *gb_dst_species; { char *src_name = aw_root->awar(AWAR_SPECIES_SRC)->read_string(); char *dst_name = aw_root->awar(AWAR_SPECIES_DST)->read_string(); gb_src_species = GBT_find_species(GLOBAL_gb_src, src_name); gb_dst_species = GBT_find_species(GLOBAL_gb_dst, dst_name); free(dst_name); free(src_name); } if (!gb_src_species) error = "Please select a species in left hitlist"; if (!gb_dst_species) error = "Please select a species in right hitlist"; if (!error) { // @@@ DRY vs loop-body of transfer_field_of_listed_cb .@DRY_TRANSFER_FIELD GBDATA *gb_src_field = GB_search(gb_src_species, field, GB_FIND); if (!gb_src_field) error = GBS_global_string("Source species has no field '%s'", field); if (!error) { error = transfer_single_field(gb_src_species, gb_dst_species, field, gb_src_field, append, transfer_of_alignment, rm); } } } if (!error) error = MG_transfer_fields_info(field); error = GB_end_transaction(GLOBAL_gb_src, error); error = GB_end_transaction(GLOBAL_gb_dst, error); } } if (error) aw_message(error); free(field); } static void popup_single_field_transfer_window(AW_root *aw_root, SpeciesXferScope scope) { static AW_window *aww[2] = { NULp, NULp }; // its ok to store windows here (not handled by popper()) if (!aww[scope]) { GB_transaction ta(GLOBAL_gb_src); AW_window_simple *aws = new AW_window_simple; bool listed = scope == SXS_LISTED_SPECIES; mg_assert(implicated(!listed, scope == SXS_SELECTED_SPECIES)); if (listed) aws->init(aw_root, "MERGE_XFER_FIELD_OF_LISTED", "Transfer field of listed"); else aws->init(aw_root, "MERGE_XFER_SINGLE_FIELD", "Transfer field of selected"); aws->load_xfig("merge/mg_transfield.fig"); aws->button_length(10); aws->callback(AW_POPDOWN); aws->at("close"); aws->create_button("CLOSE", "CLOSE", "C"); aws->at("help"); aws->callback(makeHelpCallback(listed ? "mg_xfer_field_of_listed.hlp" : "mg_xfer_field_of_sel.hlp")); aws->create_button("HELP", "HELP"); if (listed) { aws->at("append"); aws->label("Append data?"); aws->create_toggle(AWAR_APPEND); } long typeFilter = listed ? FIELD_FILTER_ANY_FIELD : FIELD_UNFILTERED; create_itemfield_selection_button(aws, FieldSelDef(AWAR_FIELD_SRC, GLOBAL_gb_src, SPECIES_get_selector(), typeFilter, "source/target field"), "scandb"); aws->at("go"); aws->callback(listed ? transfer_field_of_listed_cb : transfer_field_of_selected_cb); aws->create_button("GO", "GO"); aww[scope] = aws; } aww[scope]->activate(); } static void MG_merge_tagged_field_cb(AW_window *aww) { GB_transaction ta_merge(GLOBAL_gb_src); GB_ERROR error = GB_begin_transaction(GLOBAL_gb_dst); if (!error) { AW_root *awr = aww->get_root(); char *src_field = awr->awar(AWAR_FIELD_SRC)->read_string(); char *dst_field = awr->awar(AWAR_FIELD_DST)->read_string(); if (strcmp(src_field, NO_FIELD_SELECTED) == 0 || strcmp(dst_field, NO_FIELD_SELECTED) == 0) { error = "Please select source- and target-fields."; } if (!error) { char *src_tag = awr->awar(AWAR_TAG_SRC)->read_string(); char *dst_tag = awr->awar(AWAR_TAG_DST)->read_string(); char *del_tag = awr->awar(AWAR_TAG_DEL)->read_string(); arb_progress progress("Merging tagged fields", mg_count_queried(GLOBAL_gb_src)); GBDATA *gb_dest_species_data = GBT_get_species_data(GLOBAL_gb_dst); if (!gb_dest_species_data) error = GB_await_error(); else { for (GBDATA *gb_src_species = GBT_first_species(GLOBAL_gb_src); gb_src_species && !error; gb_src_species = GBT_next_species(gb_src_species)) { if (IS_QUERIED_SPECIES(gb_src_species)) { char *name = GBT_read_string(gb_src_species, "name"); if (!name) error = GB_await_error(); else { GBDATA *gb_dst_species = GBT_find_or_create_species_rel_species_data(gb_dest_species_data, name, true); if (!gb_dst_species) error = GB_await_error(); else { char *src_val = GBT_readOrCreate_string(gb_src_species, src_field, ""); char *dst_val = GBT_readOrCreate_string(gb_dst_species, dst_field, ""); if (!src_val || !dst_val) error = GB_await_error(); else { char *sum = GBS_merge_tagged_strings(src_val, src_tag, del_tag, dst_val, dst_tag, del_tag); if (!sum) error = GB_await_error(); else error = GBT_write_string(gb_dst_species, dst_field, sum); free(sum); } free(dst_val); free(src_val); } } free(name); progress.inc_and_check_user_abort(error); } } } if (error) progress.done(); free(del_tag); free(dst_tag); free(src_tag); } free(dst_field); free(src_field); } GB_end_transaction_show_error(GLOBAL_gb_dst, error, aw_message); } static AW_window *create_mg_merge_tagged_fields_window(AW_root *aw_root) { static AW_window_simple *aws = NULp; if (aws) return aws; GB_transaction ta(GLOBAL_gb_src); aw_root->awar_string(AWAR_TAG_SRC, "S"); aw_root->awar_string(AWAR_TAG_DST, "D"); aw_root->awar_string(AWAR_TAG_DEL, "S*"); aws = new AW_window_simple; aws->init(aw_root, "MERGE_TAGGED_FIELD", "Merge tagged field"); aws->load_xfig("merge/mg_mergetaggedfield.fig"); aws->button_length(13); aws->callback(AW_POPDOWN); aws->at("close"); aws->create_button("CLOSE", "CLOSE", "C"); aws->at("go"); aws->callback(MG_merge_tagged_field_cb); aws->create_button("GO", "GO"); aws->at("help"); aws->callback(makeHelpCallback("mergetaggedfield.hlp")); aws->create_button("HELP", "HELP"); aws->at("tag1"); aws->create_input_field(AWAR_TAG_SRC, 5); aws->at("tag2"); aws->create_input_field(AWAR_TAG_DST, 5); aws->at("del1"); aws->create_input_field(AWAR_TAG_DEL, 5); create_itemfield_selection_button(aws, FieldSelDef(AWAR_FIELD_SRC, GLOBAL_gb_src, SPECIES_get_selector(), FIELD_FILTER_STRING, "source-field"), "fields1"); create_itemfield_selection_button(aws, FieldSelDef(AWAR_FIELD_DST, GLOBAL_gb_dst, SPECIES_get_selector(), FIELD_FILTER_STRING, "target-field"), "fields2"); return aws; } static GB_ERROR MG_equal_alignments(bool autoselect_equal_alignment_name) { //! Make the alignment names equal ConstStrArray S_alignment_names; ConstStrArray D_alignment_names; GBT_get_alignment_names(S_alignment_names, GLOBAL_gb_src); GBT_get_alignment_names(D_alignment_names, GLOBAL_gb_dst); GB_ERROR error = NULp; if (!S_alignment_names[0]) { error = GB_export_error("No source sequences found"); } else { char *src_type = GBT_get_alignment_type_string(GLOBAL_gb_src, S_alignment_names[0]); const char *dest = NULp; for (int d = D_alignment_names.size()-1; d>0; --d) { char *dst_type = GBT_get_alignment_type_string(GLOBAL_gb_dst, D_alignment_names[d]); if (strcmp(src_type, dst_type) != 0) D_alignment_names.remove(d--); free(dst_type); } int d = D_alignment_names.size(); switch (d) { case 0: error = GB_export_errorf("Cannot find a target alignment with a type of '%s'\n" "You should create one first or select a different alignment type\n" "during sequence import", src_type); break; case 1: dest = D_alignment_names[0]; break; default: if (autoselect_equal_alignment_name) { for (int i = 0; i= d) { error = "Operation Aborted"; break; } dest = D_alignment_names[aliid]; } break; } if (!error && dest && strcmp(S_alignment_names[0], dest) != 0) { error = GBT_rename_alignment(GLOBAL_gb_src, S_alignment_names[0], dest); if (error) { error = GBS_global_string("Failed to rename alignment '%s' to '%s' (Reason: %s)", S_alignment_names[0], dest, error); } else { error = GBT_add_alignment_changekeys(GLOBAL_gb_src, dest); } } free(src_type); } return error; } GB_ERROR MERGE_sequences_simple(AW_root *awr) { //! Merge the sequences of two databases static char *s_name = NULp; GB_HASH *D_species_hash = NULp; GB_topSecurityLevel srcUnsecured(GLOBAL_gb_src); GB_topSecurityLevel dstUnsecured(GLOBAL_gb_dst); GB_transaction taSrc(GLOBAL_gb_src); GB_transaction taDst(GLOBAL_gb_dst); GB_ERROR error = MG_equal_alignments(true); if (!error) { GBDATA *S_species_data = GBT_get_species_data(GLOBAL_gb_src); GBDATA *D_species_data = GBT_get_species_data(GLOBAL_gb_dst); freenull(s_name); { long S_species_count = GB_number_of_subentries(S_species_data); long D_species_count = GB_number_of_subentries(D_species_data); // create hash containing all species from gb_dst, // but sized to hold all species from both DBs: D_species_hash = GBT_create_species_hash_sized(GLOBAL_gb_dst, S_species_count+D_species_count); } bool overwriteall = false; bool autorenameall = false; for (GBDATA *S_species = GB_entry(S_species_data, "species"); S_species; S_species = GB_nextEntry(S_species)) { GBDATA *S_name = GB_search(S_species, "name", GB_STRING); freeset(s_name, GB_read_string(S_name)); int count = 1; bool retry; do { retry = false; count++; GBDATA *D_species = (GBDATA*)GBS_read_hash(D_species_hash, s_name); if (D_species) { if (overwriteall) { error = GB_delete(D_species); } else if (autorenameall) { GB_ERROR dummy; char *newname = AWTC_create_numbered_suffix(D_species_hash, s_name, dummy); mg_assert(newname); freeset(s_name, newname); } else { switch (aw_question("merge_existing_species", GBS_global_string("Warning: There is an ID conflict for species '%s'\n" " You may:\n" " - Overwrite existing species\n" " - Overwrite all species with ID conflicts\n" " - Not import species\n" " - Enter ID for imported species\n" " - Automatically create unique species IDs (append .NUM)\n" " - Abort everything", s_name), "overwrite, overwrite all, don't import, create ID, auto-create IDs, abort")) { case 1: overwriteall = true; FALLTHROUGH; case 0: GB_delete(D_species); break; case 2: continue; case 3: { GB_ERROR warning; // duplicated species warning (does not apply here) char *autoname = AWTC_create_numbered_suffix(D_species_hash, s_name, warning); if (!autoname) autoname = ARB_strdup(s_name); freeset(s_name, aw_input("Species ID", "Enter new species ID", autoname)); free(autoname); retry = true; break; } case 4: autorenameall = true; retry = true; break; case 5: error = "Operation aborted"; break; } } } } while (retry); if (!error) { GBDATA *D_species = GB_create_container(D_species_data, "species"); if (!D_species) error = GB_await_error(); else { error = GB_copy_dropMarksAndTempstate(D_species, S_species); if (!error) { GB_write_flag(D_species, 1); // mark species GB_raise_user_flag(D_species, GB_USERFLAG_QUERY); // put in search&query hitlist error = GBT_write_string(D_species, "name", s_name); } } GBS_write_hash(D_species_hash, s_name, (long)D_species); } if (error) break; } } if (D_species_hash) GBS_free_hash(D_species_hash); if (!error) error = MG_transfer_fields_info(); if (!error) awr->awar(AWAR_SPECIES_NAME)->write_string(s_name); error = taSrc.close(error); error = taDst.close(error); aw_message_if(error); return error; } // ----------------------------- // MG_species_selector static void mg_select_species1(GBDATA*, AW_root *aw_root, const char *item_name) { aw_root->awar(AWAR_SPECIES_SRC)->write_string(item_name); } static void mg_select_species2(GBDATA*, AW_root *aw_root, const char *item_name) { aw_root->awar(AWAR_SPECIES_DST)->write_string(item_name); } static GBDATA *mg_get_first_species_data1(GBDATA*, AW_root*, QUERY_RANGE) { return GBT_get_species_data(GLOBAL_gb_src); } static GBDATA *mg_get_first_species_data2(GBDATA*, AW_root*, QUERY_RANGE) { return GBT_get_species_data(GLOBAL_gb_dst); } static GBDATA *mg_get_selected_species1(GBDATA*, AW_root *aw_root) { GB_transaction ta(GLOBAL_gb_src); const char *species_name = aw_root->awar(AWAR_SPECIES_SRC)->read_char_pntr(); return species_name[0] ? GBT_find_species(GLOBAL_gb_src, species_name) : NULp; } static GBDATA *mg_get_selected_species2(GBDATA*, AW_root *aw_root) { GB_transaction ta(GLOBAL_gb_dst); const char *species_name = aw_root->awar(AWAR_SPECIES_DST)->read_char_pntr(); return species_name[0] ? GBT_find_species(GLOBAL_gb_dst, species_name) : NULp; } static MutableItemSelector MG_species_selector[2]; static void mg_initialize_species_selectors() { static bool initialized = false; if (!initialized) { MG_species_selector[0] = MG_species_selector[1] = SPECIES_get_selector(); for (int s = 0; s <= 1; ++s) { MutableItemSelector& sel = MG_species_selector[s]; sel.update_item_awars = s ? mg_select_species2 : mg_select_species1; sel.get_first_item_container = s ? mg_get_first_species_data2 : mg_get_first_species_data1; sel.get_selected_item = s ? mg_get_selected_species2 : mg_get_selected_species1; sel.items_name = sel.item_name = s ? "target species" : "source species"; } initialized = true; } } class ScopedTransporter { // @@@ later also use for old merge types (SXT_WHOLE_SPECIES + SXT_SINGLE_FIELD) static QUERY::DbQuery *query2update; GBDATA *expect_selected_species(GBDATA *gb_main, const char *awarname_selected, const char *species_role, const char *listLocation, GB_ERROR& error, bool acceptNone) { GBDATA *gb_species = NULp; if (!error) { const char *species_name = AW_root::SINGLETON->awar(awarname_selected)->read_char_pntr(); if (species_name[0]) { gb_species = GBT_expect_species(gb_main, species_name); if (!gb_species) { error = GBS_global_string("%s (selected in %s hitlist)", GB_await_error(), listLocation); } } else { if (!acceptNone) { error = GBS_global_string("Please select a %s species in %s hitlist", species_role, listLocation); } } } mg_assert(implicated(!acceptNone, contradicted(error, gb_species))); mg_assert(!(error && gb_species)); return gb_species; } GB_ERROR transferExistingOrNew(GBDATA *gb_src_item, GBDATA *gb_dst_item_container) { GB_ERROR error = NULp; const char *name = GBT_get_name(gb_src_item); if (!name) { error = "unnamed item"; } else { GBDATA *gb_dst_item = GBT_find_species_rel_species_data(gb_dst_item_container, name); if (gb_dst_item) { // found existing species error = transferOne(gb_src_item, gb_dst_item, NULp); // use it as target } else { // not found if (GB_have_error()) { // due to error error = GB_await_error(); } else { // otherwise create new species error = transferOne(gb_src_item, NULp, gb_dst_item_container); } } } return error; } protected: static void markTarget(GBDATA *gb_dst_item) { mg_assert(GB_is_ancestor_of(GLOBAL_gb_dst, gb_dst_item)); // only modify userflag of destination(!) database GB_write_flag(gb_dst_item, 1); // mark species GB_raise_user_flag(gb_dst_item, GB_USERFLAG_QUERY); // put in search&query (destination) hitlist } public: virtual ~ScopedTransporter() {} static void set_query_to_update(QUERY::DbQuery *query) { query2update = query; } virtual GB_ERROR transferOne(GBDATA *gb_src_item, GBDATA *gb_dst_item, GBDATA *gb_dst_item_container) = 0; /*! transfer one species (used when transferring selected/listed species) * @param gb_src_item source of transfer * @param gb_dst_item target of transfer (if not NULp) * @param gb_dst_item_container transfer target will be created inside this container (if gb_dst_item == NULp) */ GB_ERROR transferAllIn(SpeciesXferScope scope, const char *progressTitle) { GB_ERROR error = GB_begin_transaction(GLOBAL_gb_src); error = GB_begin_transaction(GLOBAL_gb_dst); { unsigned long scopeSize = 0; switch (scope) { case SXS_SELECTED_SPECIES: scopeSize = 1; break; case SXS_LISTED_SPECIES: scopeSize = mg_count_queried(GLOBAL_gb_src); break; } arb_progress progress(progressTitle, scopeSize); GBDATA *gb_dst_species_container = GBT_get_species_data(GLOBAL_gb_dst); if (!error) { switch (scope) { case SXS_SELECTED_SPECIES: { GBDATA *gb_src_species = expect_selected_species(GLOBAL_gb_src, AWAR_SPECIES_SRC, "source", "left", error, false); GBDATA *gb_dst_species = expect_selected_species(GLOBAL_gb_dst, AWAR_SPECIES_DST, "target", "right", error, true); if (!error) { if (gb_dst_species) { // source and target explicitely selected error = transferOne(gb_src_species, gb_dst_species, NULp); } else { error = transferExistingOrNew(gb_src_species, gb_dst_species_container); } progress.inc_and_check_user_abort(error); } break; } case SXS_LISTED_SPECIES: { for (GBDATA *gb_src_species = GBT_first_species(GLOBAL_gb_src); gb_src_species && !error; gb_src_species = GBT_next_species(gb_src_species)) { if (IS_QUERIED_SPECIES(gb_src_species)) { error = transferExistingOrNew(gb_src_species, gb_dst_species_container); if (error) { // mention name of species in error message: error = GBS_global_string("%s (species=%s)", error, GBT_get_name_or_description(gb_src_species)); } progress.inc_and_check_user_abort(error); } } break; } } } if (error) progress.done(); } error = GB_end_transaction(GLOBAL_gb_src, error); error = GB_end_transaction(GLOBAL_gb_dst, error); if (!error && query2update) DbQuery_update_list(query2update); // no need to update in case of error return error; } }; QUERY::DbQuery *ScopedTransporter::query2update = NULp; using namespace FieldTransfer; typedef SmartPtr MG_remapsPtr; class AdaptedAlignmentTransporter : public AlignmentTransporter { MG_remapsPtr remaps; public: AdaptedAlignmentTransporter(MG_remapsPtr remaps_) : remaps(remaps_) {} bool shallCopyBefore() const OVERRIDE { return true; // ItemClonedByRuleSet::copyAlignments() shall be called b4 calling transport() } GB_ERROR transport(GBDATA *gb_src_item, GBDATA *gb_dst_item) const OVERRIDE { return MG_adaptAllCopiedAlignments(*remaps, gb_src_item, gb_dst_item); } }; struct DontTransportAlignment : public AlignmentTransporter { // this AlignmentTransporter simply does not transport anything bool shallCopyBefore() const OVERRIDE { return false; } // do not call copyAlignments() b4 calling transport() GB_ERROR transport(GBDATA *, GBDATA *) const OVERRIDE { return NULp; } // do not transport alignment data }; class ViaFtsTransporter : public ScopedTransporter { RuleSetPtr fts; AlignmentTransporterPtr aliTransporter; public: ViaFtsTransporter(RuleSetPtr fts_, AlignmentTransporterPtr transp) : fts(fts_), aliTransporter(transp) {} GB_ERROR transferOne(GBDATA *gb_src_item, GBDATA *gb_dst_item, GBDATA *gb_dst_item_container) OVERRIDE { mg_assert(fts.isSet()); mg_assert(contradicted(gb_dst_item, gb_dst_item_container)); // exactly one of both shall be set GB_ERROR error = NULp; GBDATA *gb_transferred = NULp; { ItemClonedByRuleSet transfer(gb_src_item, CLONE_ITEM_SPECIES, fts, gb_dst_item ? CLONE_INTO_EXISTING : REAL_CLONE, gb_dst_item ? gb_dst_item : gb_dst_item_container, &*aliTransporter); if (transfer.has_error()) { error = transfer.get_error(); } else { gb_transferred = transfer.get_clone(); } } mg_assert(contradicted(error, gb_transferred)); if (!error) markTarget(gb_transferred); return error; } }; static void mg_xfer_via_fts(AW_root *aw_root, SpeciesXferScope scope, bool xfer_seq_data) { if (MG_copy_and_check_alignments() != 0) return; GB_ERROR error = NULp; const char *ftsname = XFER_getFullFTS(aw_root->awar(AWAR_SPECIES_XFER_FTS)->read_char_pntr()); if (!ftsname[0]) { error = "No FTS selected"; } else { ErrorOrRuleSetPtr loaded = RuleSet::loadFrom(ftsname); if (loaded.hasError()) { ARB_ERROR lerror = loaded.getError(); error = lerror.deliver(); } else { AlignmentTransporterPtr transport_ali; if (xfer_seq_data) { MG_remapsPtr remaps; { GB_transaction ta_src(GLOBAL_gb_src); GB_transaction ta_dst(GLOBAL_gb_dst); remaps = new MG_remaps(GLOBAL_gb_src, GLOBAL_gb_dst, adaption_enabled(aw_root), get_reference_species_names(aw_root)); // @@@ use factory to make MG_remaps / MG_remapsPtr // @@@ can MG_remaps report error? (e.g. if wrong SAI/species specified as reference) } transport_ali = new AdaptedAlignmentTransporter(remaps); } else { transport_ali = new DontTransportAlignment; } ViaFtsTransporter transporter(loaded.getValue(), transport_ali); error = transporter.transferAllIn(scope, "Transfer using FTS"); } } aw_message_if(error); } struct MergeFieldScanner : public AvailableFieldScanner { void scanFields(StrArray& fields, FieldsToScan whatToScan) const OVERRIDE { if (whatToScan & SCAN_INPUT_FIELDS) { collectKeysRegisteredInDatabase(fields, GLOBAL_gb_src, SPECIES_get_selector(), true, false); } if (whatToScan & SCAN_OUTPUT_FIELDS) { collectKeysRegisteredInDatabase(fields, GLOBAL_gb_dst, SPECIES_get_selector(), true, false); } } }; static MergeFieldScanner fieldScanner; static void MG_transfer_species(AW_window *aww) { AW_root *awr = aww->get_root(); SpeciesXferType type = SpeciesXferType (awr->awar(AWAR_SPECIES_XFER_TYPE) ->read_int()); SpeciesXferScope scope = SpeciesXferScope(awr->awar(AWAR_SPECIES_XFER_SCOPE)->read_int()); switch (type) { case SXT_WHOLE_SPECIES: switch (scope) { case SXS_LISTED_SPECIES: mg_transfer_listed_species(aww); break; case SXS_SELECTED_SPECIES: mg_transfer_selected_species(aww); break; } break; case SXT_SINGLE_FIELD: popup_single_field_transfer_window(awr, scope); break; case SXT_USING_FTS: case SXT_USING_FTS_SKIP_ALI: { bool xfer_seq_data = (type == SXT_USING_FTS); mg_xfer_via_fts(awr, scope, xfer_seq_data); break; } } } AW_window *MG_create_merge_species_window(AW_root *awr, bool dst_is_new) { GB_ERROR error = MG_expect_renamed(); if (error) { aw_message(error); return NULp; // deny to open window before user has renamed species } awr->awar_string(AWAR_REMAP_SPECIES_LIST, "ecoli", GLOBAL_gb_dst); awr->awar_int(AWAR_REMAP_ENABLE, 0, GLOBAL_gb_dst); AW_window_simple_menu *aws = new AW_window_simple_menu; aws->init(awr, "MERGE_TRANSFER_SPECIES", "TRANSFER SPECIES"); aws->load_xfig("merge/species.fig"); aws->at("close"); aws->callback(AW_POPDOWN); aws->create_button("CLOSE", "CLOSE", "C"); aws->at("help"); aws->callback(makeHelpCallback("mg_species.hlp")); aws->create_button("HELP", "HELP", "H"); mg_initialize_species_selectors(); // define macro IDs and window titles for both config managers used in transfer window: AWT_predef_config_manager("MERGE_TRANSFER_SOURCE_SPECIES_config", "Configurations for source species query"); AWT_predef_config_manager("MERGE_TRANSFER_TARGET_SPECIES_config", "Configurations for target species query"); { QUERY::query_spec awtqs(MG_species_selector[0]); aws->create_menu("Source-DB", "S"); awtqs.gb_main = GLOBAL_gb_src; awtqs.gb_ref = GLOBAL_gb_dst; awtqs.expect_hit_in_ref_list = false; awtqs.species_name = AWAR_SPECIES_SRC; awtqs.tree_name = NULp; // no selected tree here -> can't use tree related ACI commands without specifying a tree awtqs.select_bit = GB_USERFLAG_QUERY; awtqs.ere_pos_fig = "ere1"; awtqs.by_pos_fig = "by1"; awtqs.qbox_pos_fig = "qbox1"; awtqs.key_pos_fig = NULp; awtqs.query_pos_fig = "content1"; awtqs.result_pos_fig = "result1"; awtqs.count_pos_fig = "count1"; awtqs.do_query_pos_fig = "doquery1"; awtqs.config_pos_fig = "doconfig1"; awtqs.do_mark_pos_fig = NULp; awtqs.do_unmark_pos_fig = NULp; awtqs.do_delete_pos_fig = "dodelete1"; awtqs.do_set_pos_fig = "doset1"; awtqs.do_refresh_pos_fig = "dorefresh1"; create_query_box(aws, &awtqs, "db1"); DbScanner *scanner = DbScanner::create(GLOBAL_gb_src, "merge_spec1", aws, "box1", NULp, NULp, DB_SCANNER, NULp, awtqs.get_queried_itemtype()); scanner_src = scanner; aws->get_root()->awar(AWAR_SPECIES_SRC)->add_callback(makeRootCallback(MG_map_species, SRC_DB)); } { QUERY::query_spec awtqs(MG_species_selector[1]); aws->create_menu("Target-DB", "T"); awtqs.gb_main = GLOBAL_gb_dst; awtqs.gb_ref = GLOBAL_gb_src; awtqs.expect_hit_in_ref_list = true; awtqs.species_name = AWAR_SPECIES_DST; awtqs.select_bit = GB_USERFLAG_QUERY; awtqs.ere_pos_fig = "ere2"; awtqs.by_pos_fig = "by2"; awtqs.qbox_pos_fig = "qbox2"; awtqs.key_pos_fig = NULp; awtqs.query_pos_fig = "content2"; awtqs.result_pos_fig = "result2"; awtqs.count_pos_fig = "count2"; awtqs.do_query_pos_fig = "doquery2"; awtqs.config_pos_fig = "doconfig2"; awtqs.do_mark_pos_fig = NULp; awtqs.do_unmark_pos_fig = NULp; awtqs.do_delete_pos_fig = "dodelete2"; awtqs.do_set_pos_fig = "doset2"; awtqs.do_refresh_pos_fig = "dorefresh2"; ScopedTransporter::set_query_to_update(create_query_box(aws, &awtqs, "db2")); DbScanner *scanner = DbScanner::create(GLOBAL_gb_dst, "merge_spec2", aws, "box2", NULp, NULp, DB_SCANNER, NULp, awtqs.get_queried_itemtype()); scanner_dst = scanner; aws->get_root()->awar(AWAR_SPECIES_DST)->add_callback(makeRootCallback(MG_map_species, DST_DB)); } #define AWAR_MARKED_LABEL_NAME(db) awar_name_tmp(db, "marked_label") aws->at("marked1"); create_species_selection_button(aws, makeWindowCallback(MG_popup_selection_admin, SRC_DB), "select1", AWAR_MARKED_LABEL_NAME(SRC_DB), GLOBAL_gb_src); aws->at("marked2"); create_species_selection_button(aws, makeWindowCallback(MG_popup_selection_admin, DST_DB), "select2", AWAR_MARKED_LABEL_NAME(DST_DB), GLOBAL_gb_dst); // --------------------- // middle area // top icon aws->button_length(0); aws->at("icon"); aws->callback(makeHelpCallback("mg_species.hlp")); aws->create_button("HELP_MERGE", "#merge/icon.xpm"); // adapt alignments { if (dst_is_new) { aws->sens_mask(AWM_DISABLED); // if dest DB is new = > adaption impossible awr->awar(AWAR_REMAP_ENABLE)->write_int(0); // disable adaption } aws->at("adapt"); aws->create_toggle(AWAR_REMAP_ENABLE); aws->at("reference"); aws->create_text_field(AWAR_REMAP_SPECIES_LIST); aws->at("pres_sel"); aws->callback(MG_create_preserves_selection_window); aws->create_autosize_button("SELECT", "SELECT", "S"); aws->sens_mask(AWM_ALL); } // transfer options: aws->at("xferType"); aws->create_option_menu(AWAR_SPECIES_XFER_TYPE); aws->insert_option("whole species", "w", SXT_WHOLE_SPECIES); aws->insert_option("single field", "s", SXT_SINGLE_FIELD); aws->insert_option("using FTS (with seq)", "F", SXT_USING_FTS); aws->insert_option("using FTS (w/o seq)", "o", SXT_USING_FTS_SKIP_ALI); aws->update_option_menu(); aws->at("fts"); aws->callback(makeWindowCallback(XFER_select_RuleSet, AWAR_SPECIES_XFER_FTS, static_cast(&fieldScanner))); aws->create_button("SELECT_FTS", AWAR_SPECIES_XFER_FTS); aws->at("xferWhat"); aws->create_option_menu(AWAR_SPECIES_XFER_SCOPE); aws->insert_option("listed species", "l", SXS_LISTED_SPECIES); aws->insert_option("selected species", "s", SXS_SELECTED_SPECIES); aws->update_option_menu(); { aws->shadow_width(3); aws->at("transfer"); aws->callback(MG_transfer_species); aws->create_button("TRANSFER", "Transfer species"); aws->shadow_width(1); } aws->create_menu("Source->Target", "g"); aws->insert_menu_topic("compare_field_of_listed", "Compare a field of listed species ...", "C", "checkfield.hlp", AWM_ALL, create_mg_check_fields_window); aws->insert_menu_topic("merge_field_of_listed_to_new_field", "Merge tagged field ...", "M", "mergetaggedfield.hlp", AWM_ALL, create_mg_merge_tagged_fields_window); aws->sep______________(); aws->insert_menu_topic("def_gene_species_field_xfer", "Define field transfer for gene-species", "g", "gene_species_field_transfer.hlp", AWM_ALL, MG_gene_species_create_field_transfer_def_window); return aws; }