macro_editor_context.cpp

Go to the documentation of this file.

Go to the SVN repository for this file.

/*  $Id: macro_editor_context.cpp 47479 2023-05-02 13:24:02Z ucko $
 * ===========================================================================
 *
 *                            PUBLIC DOMAIN NOTICE
 *               National Center for Biotechnology Information
 *
 *  This software/database is a "United States Government Work" under the
 *  terms of the United States Copyright Act.  It was written as part of
 *  the author's official duties as a United States Government employee and
 *  thus cannot be copyrighted.  This software/database is freely available
 *  to the public for use. The National Library of Medicine and the U.S.
 *  Government have not placed any restriction on its use or reproduction.
 *
 *  Although all reasonable efforts have been taken to ensure the accuracy
 *  and reliability of the software and data,  the NLM and the U.S.
 *  Government do not and cannot warrant the performance or results that
 *  may be obtained by using this software or data. The NLM and the U.S.
 *  Government disclaim all warranties,  express or implied,  including
 *  warranties of performance,  merchantability or fitness for any particular
 *  purpose.
 *
 *  Please cite the author in any work or product based on this material.
 *
 * ===========================================================================
 *
 * Authors:  Andrea Asztalos
 
 */
 
 
#include <ncbi_pch.hpp>
#include <objects/seqfeat/SubSource.hpp>
#include <objects/seqfeat/OrgMod.hpp>
#include <objects/seqfeat/RNA_gen.hpp>
#include <objects/macro/Feat_qual_legal.hpp>
#include <objtools/edit/field_handler.hpp>
 
#include <util/static_map.hpp>
#include <gui/widgets/wx/wx_utils.hpp>
#include <gui/objutils/utils.hpp>
#include <gui/objutils/macro_util.hpp>
#include <gui/objutils/macro_fn_where.hpp>
#include <gui/objutils/convert_feat.hpp>
#include <gui/widgets/edit/molinfo_fieldtype.hpp>
#include <gui/widgets/edit/dblink_fieldtype.hpp>
#include <gui/widgets/edit/source_field_name_panel.hpp>
#include <gui/widgets/edit/rna_field_name_panel.hpp>
#include <gui/widgets/edit/feature_field_name_panel.hpp>
#include <gui/widgets/edit/field_type_constants.hpp>
#include <gui/widgets/edit/feature_type_panel.hpp>
#include <gui/widgets/edit/cds_gene_prot_field_name_panel.hpp>
#include <gui/widgets/edit/macro_editor_context.hpp>
 
BEGIN_NCBI_SCOPE
USING_SCOPE(objects);
 
CMacroEditorContext::CMacroEditorContext()
{
    m_DescriptorMap.clear();
    using TPos = TBimapStrings::value_type;
    m_DescriptorMap.insert(TPos("Any", kEmptyStr));
    m_DescriptorMap.insert(TPos("Name", CSeqdesc::SelectionName(CSeqdesc::e_Name)));
    m_DescriptorMap.insert(TPos("Title", CSeqdesc::SelectionName(CSeqdesc::e_Title)));
    m_DescriptorMap.insert(TPos("Comment", CSeqdesc::SelectionName(CSeqdesc::e_Comment)));
    m_DescriptorMap.insert(TPos("Numbering", CSeqdesc::SelectionName(CSeqdesc::e_Num)));
    m_DescriptorMap.insert(TPos("MapLoc", CSeqdesc::SelectionName(CSeqdesc::e_Maploc)));
    m_DescriptorMap.insert(TPos("PIR", CSeqdesc::SelectionName(CSeqdesc::e_Pir)));
    m_DescriptorMap.insert(TPos("GenBank", CSeqdesc::SelectionName(CSeqdesc::e_Genbank)));
    m_DescriptorMap.insert(TPos("Publication", "Publication"));
    m_DescriptorMap.insert(TPos("Region", CSeqdesc::SelectionName(CSeqdesc::e_Region)));
    m_DescriptorMap.insert(TPos("User", "User"));
    m_DescriptorMap.insert(TPos("SWISS-PROT", CSeqdesc::SelectionName(CSeqdesc::e_Sp)));
    m_DescriptorMap.insert(TPos("dbXREF", CSeqdesc::SelectionName(CSeqdesc::e_Dbxref)));
    m_DescriptorMap.insert(TPos("EMBL", CSeqdesc::SelectionName(CSeqdesc::e_Embl)));
    m_DescriptorMap.insert(TPos("Create Date", CSeqdesc::SelectionName(CSeqdesc::e_Create_date)));
    m_DescriptorMap.insert(TPos("Update Date", CSeqdesc::SelectionName(CSeqdesc::e_Update_date)));
    m_DescriptorMap.insert(TPos("PRF", CSeqdesc::SelectionName(CSeqdesc::e_Prf)));
    m_DescriptorMap.insert(TPos("PDB", CSeqdesc::SelectionName(CSeqdesc::e_Pdb)));
    m_DescriptorMap.insert(TPos("Heterogen", CSeqdesc::SelectionName(CSeqdesc::e_Het)));
    m_DescriptorMap.insert(TPos("BioSource", "BioSource"));
    m_DescriptorMap.insert(TPos("MolInfo", "MolInfo"));
    m_DescriptorMap.insert(TPos("StructuredComment", "StructuredComment"));
    m_DescriptorMap.insert(TPos("DBLink", "DBLink"));
 
    CSeq_entry_Handle seh;
    set<string> existing;
 
    vector<const CFeatListItem *> featlist = GetSortedFeatList(seh);
    ITERATE(vector<const CFeatListItem *>, feat_it, featlist) {
        const CFeatListItem& item = **feat_it;
        string desc = item.GetDescription();
        int feat_type = item.GetType();
        int feat_subtype = item.GetSubtype();
        if (existing.find(desc) == existing.end()) {
            existing.insert(desc);
            m_Featuretypes.push_back(desc);
            m_FeatureMap.insert(make_pair(desc, make_pair(feat_type, feat_subtype)));
        }
    }
 
    copy(m_SourceTextKeys.begin(), m_SourceTextKeys.end(), back_inserter(m_SourceKeywords));
    copy(m_SourceTaxKeys.begin(), m_SourceTaxKeys.end(), back_inserter(m_SourceKeywords));
    m_DBLinkKeywords = CDBLinkFieldType::GetFieldNames();
    m_MolinfoKeywords = CMolInfoFieldType::GetFieldNames();
    m_PubdescKeywords = CPubFieldType::GetFieldNames(true);
    for (auto& it : m_PubdescKeywords) {
        it = "pub " + it;
    }
    for (auto& it : m_SourceTextKeys) {
        m_SourceKeywords.push_back(it);
    }
    m_CdsGeneProtKeywords = CCDSGeneProtFieldNamePanel::GetStrings();
}
 
string CMacroEditorContext::FindInBimapOrEmpty(const string& type, const TBimapStrings& str_bimap)
{
    auto left_it = str_bimap.left.find(type);
    if (left_it != str_bimap.left.end()) {
        return left_it->second;
    }
 
    auto right_it = str_bimap.right.find(type);
    if (right_it != str_bimap.right.end()) {
        return right_it->second;
    }
    return kEmptyStr;
}
 
vector<string> CMacroEditorContext::GetFieldNames(EMacroFieldType type) const
{
    bool allow_other = false;
    switch (type) {
    case EMacroFieldType::eBiosourceText:
        return x_GetBsrcTextFieldnames(false);
    case EMacroFieldType::eBiosourceTextAll:
        return x_GetBsrcTextFieldnames(true);
    case EMacroFieldType::eBiosourceTax:
        return x_GetBsrcTaxFieldnames();
    case EMacroFieldType::eBiosourceLocation:
        return CSourceFieldNamePanel::s_GetSourceLocationOptions();
    case EMacroFieldType::eBiosourceOrigin:
        return CSourceFieldNamePanel::s_GetSourceOriginOptions();
    case EMacroFieldType::eBiosourceAll:
        return x_GetAllBsrcFieldnames();
    case EMacroFieldType::eMolinfo:
        return m_MolinfoKeywords;
    case EMacroFieldType::eMolinfoClass:
        return CMolInfoFieldType::GetChoicesForField(CMolInfoFieldType::e_Class, allow_other);
    case EMacroFieldType::eMolinfoCompleteness:
        return CMolInfoFieldType::GetChoicesForField(CMolInfoFieldType::e_Completedness, allow_other);
    case EMacroFieldType::eMolinfoMolecule:
        return CMolInfoFieldType::GetChoicesForField(CMolInfoFieldType::e_MoleculeType, allow_other);
    case EMacroFieldType::eMolinfoStrand:
        return CMolInfoFieldType::GetChoicesForField(CMolInfoFieldType::e_Strand, allow_other);
    case EMacroFieldType::eMolinfoTech:
        return CMolInfoFieldType::GetChoicesForField(CMolInfoFieldType::e_Technique, allow_other);
    case EMacroFieldType::eMolinfoTopology:
        return CMolInfoFieldType::GetChoicesForField(CMolInfoFieldType::e_Topology, allow_other);
    case EMacroFieldType::eDBLink:
        return m_DBLinkKeywords;
    case EMacroFieldType::eMiscDescriptors:
        return m_MiscKeywords;
    case EMacroFieldType::eMiscDescriptorsToRmv:
        return m_MiscKeywordsToRmv;
    case EMacroFieldType::ePubdesc:
        return CPubFieldType::GetFieldNames(true);
    case EMacroFieldType::ePubStatus:
        return CPubFieldType::GetChoicesForField(CPubFieldType::ePubFieldType_Status, allow_other);
    case EMacroFieldType::eDescriptors:
        return x_GetDescriptorFieldnames();
    case EMacroFieldType::eStructComment:
        return x_GetStrCommFieldnames();
    case EMacroFieldType::eGene:
        return m_GeneKeywords;
    case EMacroFieldType::eProtein:
        return x_GetProteinFieldnames();
    case EMacroFieldType::eRNA:
        return CRNAFieldNamePanel::GetRNAFields();
    case EMacroFieldType::eCdsGeneProt:
        return m_CdsGeneProtKeywords;
    case EMacroFieldType::eOther:
        return{ "Local id", "Definition line" };
    case EMacroFieldType::eBiosourceAutodef:
        return m_BsrcAutodefWords;
    case EMacroFieldType::eSetFrom:
        return x_GetSetClassFieldnames(true);
    case EMacroFieldType::eSetTo:
        return x_GetSetClassFieldnames(false);
    default:
        break;
    }
    return vector<string>();
}
 
vector<string> CMacroEditorContext::x_GetBsrcTextFieldnames(bool complete) const
{
    vector<string> fieldnames;
    // subsource modifiers
    for (size_t i = 0; i < CSubSource::eSubtype_other; i++) {
        try {
            string qual_name = CSubSource::GetSubtypeName(static_cast<CSubSource::TSubtype>(i));
            if (!NStr::IsBlank(qual_name) && !CSubSource::IsDiscouraged(static_cast<CSubSource::TSubtype>(i))) {
                fieldnames.push_back((qual_name));
            }
 
        }
        catch (const exception&) {
        }
    }
    fieldnames.push_back(kSubSourceNote);
 
    // orgmod modifiers
    for (size_t i = 0; i < COrgMod::eSubtype_other; i++) {
        try {
            string qual_name = COrgMod::GetSubtypeName(static_cast<COrgMod::TSubtype>(i));
            if (!NStr::IsBlank(qual_name)) {
                // special case for nat-host
                if (NStr::EqualNocase(qual_name, kNatHost)) {
                    fieldnames.push_back(kHost);
                }
                else {
                    fieldnames.push_back(qual_name);
                    if (complete &&
                        (i == COrgMod::eSubtype_bio_material ||
                        i == COrgMod::eSubtype_culture_collection ||
                        i == COrgMod::eSubtype_specimen_voucher)) {
                        fieldnames.push_back(qual_name + macro::kColl_suffix);
                        fieldnames.push_back(qual_name + macro::kInst_suffix);
                        fieldnames.push_back(qual_name + macro::kSpecid_suffix);
                    }
                }
            }
 
        }
        catch (const exception&) {
        }
    }
    fieldnames.push_back(kOrgModNote);
 
    // primers
    fieldnames.push_back(kFwdPrimerName);
    fieldnames.push_back(kFwdPrimerSeq);
    fieldnames.push_back(kRevPrimerName);
    fieldnames.push_back(kRevPrimerSeq);
 
    fieldnames.push_back(kDbXref);
 
    sort(fieldnames.begin(), fieldnames.end());
    return fieldnames;
}
 
vector<string> CMacroEditorContext::x_GetBsrcTaxFieldnames() const
{
    return { "taxname", "common name", "division", "lineage" };
}
 
vector<string> CMacroEditorContext::x_GetAllBsrcFieldnames() const
{
    vector<string> fieldnames = x_GetBsrcTaxFieldnames();
    vector<string> text_names = x_GetBsrcTextFieldnames(true);
    fieldnames.reserve(fieldnames.size() + text_names.size() + 2);
    move(text_names.begin(), text_names.end(), inserter(fieldnames, fieldnames.end()));
    fieldnames.push_back("location");
    fieldnames.push_back("origin");
    return fieldnames;
}
 
vector<string> CMacroEditorContext::x_GetStrCommFieldnames() const
{
    return { "Field", "Database name", "Field name" };
}
 
vector<string> CMacroEditorContext::x_GetDescriptorFieldnames() const
{
    vector<string> fieldnames;
    for (auto& it : m_DescriptorMap.left) {
        fieldnames.push_back(it.first);
    }
    sort(fieldnames.begin(), fieldnames.end());
    return fieldnames;
}
 
vector<string> CMacroEditorContext::x_GetProteinFieldnames() const
{
    return {
        "protein name",
        "protein description",
        "protein EC number",
        "protein activity",
        "protein comment",
    };
}
 
vector<string> CMacroEditorContext::x_GetSetClassFieldnames(bool all) const
{
    vector<string> fieldnames;
    if (all) {
        CEnumeratedTypeValues::TValues values = CBioseq_set::ENUM_METHOD_NAME(EClass)()->GetValues();
        for (auto& it : values) {
            if (it.first == "gi" || it.first == "gibb") {
                it.first += "-set";
            }
            toupper((unsigned char)it.first[0]);
            fieldnames.push_back(it.first);
        }
    }
    else {
        fieldnames.push_back(CBioseq_set::ENUM_METHOD_NAME(EClass)()->FindName(CBioseq_set::eClass_genbank, true));
        fieldnames.push_back(CBioseq_set::ENUM_METHOD_NAME(EClass)()->FindName(CBioseq_set::eClass_mut_set, true));
        fieldnames.push_back(CBioseq_set::ENUM_METHOD_NAME(EClass)()->FindName(CBioseq_set::eClass_pop_set, true));
        fieldnames.push_back(CBioseq_set::ENUM_METHOD_NAME(EClass)()->FindName(CBioseq_set::eClass_phy_set, true));
        fieldnames.push_back(CBioseq_set::ENUM_METHOD_NAME(EClass)()->FindName(CBioseq_set::eClass_eco_set, true));
        fieldnames.push_back(CBioseq_set::ENUM_METHOD_NAME(EClass)()->FindName(CBioseq_set::eClass_wgs_set, true));
        fieldnames.push_back(CBioseq_set::ENUM_METHOD_NAME(EClass)()->FindName(CBioseq_set::eClass_small_genome_set, true));
        for (auto&& it : fieldnames) {
            toupper((unsigned char)it[0]);
        }
    }
    return fieldnames;
}
 
vector<string> CMacroEditorContext::GetFeatureTypes(bool for_removal, bool to_create, bool include_all) const
{
    // used for feature removal
    if (for_removal) {
        return m_Featuretypes;
    }
 
    vector<string> feat_list;
    if (to_create) {
        feat_list.push_back("Gene");
        feat_list.push_back("misc_feature");
    }
 
    // used for removing feature qualifier
    if (include_all) {
        feat_list.push_back("All");
    }
    for (auto& it : m_Featuretypes) {
        CSeqFeatData::ESubtype subtype = CSeqFeatData::SubtypeNameToValue(it);
        if (!CFeatureTypePanel::s_IsRarelyUsedOrDiscouragedFeatureType(subtype) && !CSeqFeatData::IsRegulatory(subtype)) {
            CSeqFeatData::E_Choice type = CSeqFeatData::GetTypeFromSubtype(subtype);
            if (!to_create) {
                feat_list.push_back(it);
            } else if (type == CSeqFeatData::e_Imp && find(feat_list.begin(), feat_list.end(), it) == feat_list.end()) {
                feat_list.push_back(it);
            }
        }
    }
    return feat_list;
}
 
pair<int, int> CMacroEditorContext::GetFeatureType(const string& name) const
{
    auto it = m_FeatureMap.find(name);
    return (it != m_FeatureMap.end()) ? it->second : pair<int, int>();
}
 
vector<string> CMacroEditorContext::GetLegalQualifiers(const string& feat_name) const
{
    CSeqFeatData::ESubtype subtype = macro::NMacroUtil::GetFeatSubtype(feat_name);
    auto quals = CSeqFeatData::GetLegalQualifiers(subtype);
    vector<string> qual_names;
    for (auto it : quals) {
        qual_names.push_back(CSeqFeatData::GetQualifierAsString(it));
    }
    return qual_names;
}
 
vector<string> CMacroEditorContext::GetFeatQualifiers() const
{
    wxArrayString qual_list = CFeatureFieldNamePanel::s_FillFeatQualList(CSeqFeatData::eSubtype_any);
    vector<string> names;
    FromArrayString(qual_list, names);
    return names;
}
 
vector<string> CMacroEditorContext::GetRNATypes() const
{
    return CRNAFieldNamePanel::GetRNATypes();
}
 
vector<string> CMacroEditorContext::GetncRNAClassTypes(bool include_any) const
{
    if (!include_any) {
        return CRNA_gen::GetncRNAClassList();
    }
 
    vector<string> types{ "any" };
    vector<string> class_types = CRNA_gen::GetncRNAClassList();
    types.reserve(class_types.size() + 1);
    copy(class_types.begin(), class_types.end(), back_inserter(types));
    return types;
}
 
vector<string> CMacroEditorContext::GetRNAProductnames(const string& rna_type) const
{
    if (NStr::EqualNocase(rna_type, "rRNA")) {
        return {
            "4.5S ribosomal RNA",
            "5S ribosomal RNA",
            "5.8S ribosomal RNA",
            "12S ribosomal RNA",
            "15S ribosomal RNA",
            "16S ribosomal RNA",
            "18S ribosomal RNA",
            "21S ribosomal RNA",
            "23S ribosomal RNA",
            "25S ribosomal RNA",
            "26S ribosomal RNA",
            "28S ribosomal RNA",
            "large subunit ribosomal RNA",
            "small subunit ribosomal RNA" };
    }
    else if (NStr::EqualNocase(rna_type, "tRNA")) {
        return{
            "A Alanine",
            "B Asp or Asn",
            "C Cysteine",
            "D Aspartic Acid",
            "E Glutamic Acid",
            "F Phenylalanine",
            "G Glycine",
            "H Histidine",
            "I Isoleucine",
            "J Leu or Ile",
            "K Lysine",
            "L Leucine",
            "M Methionine",
            "N Asparagine",
            "O Pyrrolysine",
            "P Proline",
            "Q Glutamine",
            "R Arginine",
            "S Serine",
            "T Threonine",
            "U Selenocysteine",
            "V Valine",
            "W Tryptophan",
            "X Undetermined",
            "Y Tyrosine",
            "Z Glu or Gln",
            "* Stop Codon" };
    }
    return {};
}
 
vector<string> CMacroEditorContext::GetBondTypes() const
{
    const CBondList* list = CSeqFeatData::GetBondList();
    vector<string> bond_list;
    for (auto it = list->begin(); it != list->end(); ++it) {
        bond_list.push_back(it->first);
    }
    return bond_list;
}
 
vector<string> CMacroEditorContext::GetSiteTypes() const
{
    const CSiteList* list = CSeqFeatData::GetSiteList();
    vector<string> site_list;
    for (auto it = list->begin(); it != list->end(); ++it) {
        site_list.push_back(it->first);
    }
    return site_list;
}
 
string CMacroEditorContext::GetConversionDescr(const string& from_feat, const string& to_feat)
{
    CSeqFeatData::ESubtype from_subtype = macro::NMacroUtil::GetFeatSubtype(from_feat);
    CSeqFeatData::ESubtype to_subtype = macro::NMacroUtil::GetFeatSubtype(to_feat);
    CRef<CConvertFeatureBase> converter = CConvertFeatureBaseFactory::Create(from_subtype, to_subtype);
    return converter->GetDescription();
}
 
const vector<string>& CMacroEditorContext::GetKeywords(EMacroFieldType type) const
{
    switch (type) {
    case EMacroFieldType::eBiosourceText:
        return m_SourceTextKeys;
    case EMacroFieldType::eBiosourceTax:
        return m_SourceTaxKeys;
    case EMacroFieldType::eMolinfo:
        return m_MolinfoKeywords;
    case EMacroFieldType::ePubdesc:
        return m_PubdescKeywords;
    case EMacroFieldType::eDBLink:
        return m_DBLinkKeywords;
    case EMacroFieldType::eMiscDescriptors:
        return m_MiscKeywords;
    case EMacroFieldType::eMiscDescriptorsToRmv:
        return m_MiscKeywordsToRmv;
    case EMacroFieldType::eDescriptors:
        return m_DescrKeywords;
    case EMacroFieldType::eGene:
        return m_GeneKeywords;
    case EMacroFieldType::eRNA:
        return m_RnaKeywords;
    case EMacroFieldType::eProtein:
        return m_ProteinKeywords;
    case EMacroFieldType::eFeatQualifiers:
        return m_FeatQualKeywords;
    case EMacroFieldType::eCdsGeneProt:
        return m_CdsGeneProtKeywords;
    case EMacroFieldType::eBiosourceAutodef:
        return m_BsrcAutodefWords;
    default:
        break;
    }
    return m_EmptyKeywords;
}
 
string CMacroEditorContext::GetAsnPathToFieldName(const string& feat, const string& qual)
{
    return x_GetAsnPathToFeatQuals(feat, qual);
}
 
string CMacroEditorContext::x_GetAsnPathToFeatQuals(const string& feat, const string& qual)
{
    string qual_name(qual);
    NStr::ReplaceInPlace(qual_name, "-", "_");
 
    string path;
    if (NStr::EqualNocase(feat, "gene")) {
        if (qual_name == "description") {
            path = "data.gene.desc";
        } else if (qual_name == "locus") {
            path = "data.gene.locus";
        } else if (macro::NMacroUtil::StringsAreEquivalent(qual_name, "locus-tag")) {
            path = "data.gene.locus-tag";
        } else if (qual_name == "synonym" || macro::NMacroUtil::StringsAreEquivalent(qual_name, "gene_synonym")) {
            path = "data.gene.syn";
        } else if (qual_name == "allele") {
            path = "data.gene.allele";
        }
    }
   
    if (NStr::EqualNocase(feat, "protein") || NStr::EqualNocase(feat, "Proprotein")) {
        if (qual_name == "product" || qual_name == "name") {
            path = "data.prot.name";
        } else if (qual_name == "description") {
            path = "data.prot.desc";
        } else if (qual_name == "activity") {
            path = "data.prot.activity";
        } else if (macro::NMacroUtil::StringsAreEquivalent(qual_name, "EC-number")) {
            path = "data.prot.ec";
        }
    }
 
    if (qual_name == "product") {
        if (feat.find("RNA") != NPOS) {
            if (NStr::EqualNocase(feat, "mRNA") ||
                NStr::EqualNocase(feat, "rRNA") ||
                NStr::EqualNocase(feat, "preRNA") ||
                NStr::EqualNocase(feat, "precursor_RNA")) {
                path = "data.rna.ext.name";
            }
            else if (NStr::EqualNocase(feat, "misc_RNA") ||
                NStr::EqualNocase(feat, "ncRNA") ||
                NStr::EqualNocase(feat, "scRNA") ||
                NStr::EqualNocase(feat, "snRNA") ||
                NStr::EqualNocase(feat, "snoRNA") ||
                NStr::EqualNocase(feat, "tmRNA")) {
                path = "data.rna.ext.gen.product";
            }
        }
    }
 
    if (NStr::EqualNocase(feat, "cds")) {
        if (qual_name == "product") {
            path = "data.prot.name";
        } else if (qual_name == "activity") {
            path = "data.prot.activity";
        }
        else if (macro::NMacroUtil::StringsAreEquivalent(qual_name, "EC-number")) {
            path = "data.prot.ec";
        }
        else if (macro::NMacroUtil::StringsAreEquivalent(qual_name, "codon-start")) {
            path = "data.cdregion.frame";
        }
    }
     
    if (qual_name == "note" || qual_name == "comment") {
        path = "comment";
    }
 
    if (qual_name == "db_xref") {
        path = "dbxref";
    }
 
    if (feat == "ncRNA" && macro::NMacroUtil::StringsAreEquivalent(qual_name, "ncRNA-class")) {
        path = "data.rna.ext.gen.class";
    }
    else if (feat == "tmRNA" && macro::NMacroUtil::StringsAreEquivalent(qual_name, "tag_peptide")) {
        path = "data.rna.ext.gen.quals,tag_peptide";
    }
    
    if (path.empty()) {
        path = "qual," + qual_name;
    }
 
    return path;
}
 
string CMacroEditorContext::GetAsnPathToFeature(const string& feat_name) const
{
    CSeqFeatData::ESubtype subtype = macro::NMacroUtil::GetFeatSubtype(feat_name);
    string asn_path_to_feature;
    switch (subtype) {
    case CSeqFeatData::eSubtype_cdregion:
    case CSeqFeatData::eSubtype_gene:
    case CSeqFeatData::eSubtype_prot:
    case CSeqFeatData::eSubtype_preprotein:
    case CSeqFeatData::eSubtype_mat_peptide_aa:
    case CSeqFeatData::eSubtype_sig_peptide_aa:
    case CSeqFeatData::eSubtype_transit_peptide_aa:
    case CSeqFeatData::eSubtype_preRNA:
    case CSeqFeatData::eSubtype_mRNA:
    case CSeqFeatData::eSubtype_bond:
    case CSeqFeatData::eSubtype_site:
    case CSeqFeatData::eSubtype_psec_str:
    case CSeqFeatData::eSubtype_region:
    case CSeqFeatData::eSubtype_pub:
    case CSeqFeatData::eSubtype_comment:
    case CSeqFeatData::eSubtype_biosrc:
        break;
    default:
        asn_path_to_feature = "\"data.imp.key\", \"" + CSeqFeatData::SubtypeValueToName(subtype) + "\"";
        break;
    }
    return asn_path_to_feature;
}
 
string CMacroEditorContext::GetAsnPathToAuthorFieldName(const string& author_name)
{
    string val;
    if (NStr::FindNoCase(author_name, "last") != NPOS)
        val = "last";
    else if (NStr::FindNoCase(author_name, "first") != NPOS)
        val = "first";
    else if (NStr::FindNoCase(author_name, "suffix") != NPOS)
        val = "suffix";
    else if (NStr::FindNoCase(author_name, "initials") != NPOS)
        val = "initials";
    else if (NStr::FindNoCase(author_name, "consortium") != NPOS)
        val = "consortium";
    return val;
}
 
string CMacroEditorContext::GetGUIAuthorName(const string& author_part)
{
    CPubFieldType::EPubFieldType type = CPubFieldType::ePubFieldType_Unknown;
    if (NStr::EqualNocase(author_part, "first"))
        type = CPubFieldType::ePubFieldType_AuthorFirstName;
    else if (NStr::EqualNocase(author_part, "last"))
        type = CPubFieldType::ePubFieldType_AuthorLastName;
    else if (NStr::EqualNocase(author_part, "suffix"))
        type = CPubFieldType::ePubFieldType_AuthorSuffix;
    else if (NStr::EqualNocase(author_part, "consortium"))
        type = CPubFieldType::ePubFieldType_AuthorConsortium;
    else if (NStr::EqualNocase(author_part, "initials"))
        type = CPubFieldType::ePubFieldType_AuthorMiddleInitial;
 
    return GetGUIPubField(type);
}
 
string CMacroEditorContext::GetGUIPubField(CPubFieldType::EPubFieldType type)
{
    string value = CPubFieldType::GetLabelForType(type);
    return CPubFieldType::NormalizePubFieldName(value);
}
 
string CMacroEditorContext::GetAsnPathToFieldName(const string& field, EMacroFieldType type, const string& target)
{
    m_Field = field;
 
    switch (type) {
    case EMacroFieldType::eBiosourceText:
    case EMacroFieldType::eBiosourceTextAll:
        return x_GetAsnPathToBsrcText();
    case EMacroFieldType::eBiosourceTax:
        return x_GetAsnPathToBsrcTax();
    case EMacroFieldType::eBiosourceOrigin:
        return "origin";
    case EMacroFieldType::eBiosourceLocation:
        return "genome";
    case EMacroFieldType::eBiosourceAll:
        return x_GetAsnPathToAllBsrc();
    case EMacroFieldType::eMolinfo:
        return x_GetAsnPathToMolinfo(target);
    case EMacroFieldType::ePubdesc:
    case EMacroFieldType::ePubTitle:
    case EMacroFieldType::ePubAuthors:
    case EMacroFieldType::ePubAffilCountry:
        return x_GetAsnPathToPub();
    case EMacroFieldType::ePubAffilFields:
        return x_GetAsnPathToAffilFields();
    case EMacroFieldType::ePubAffil:
        return "PUB_AFFIL()";
    case EMacroFieldType::ePubAffilExcept:
        return "PUB_AFFIL()";
    case EMacroFieldType::eDBLink:
        return x_GetAsnPathToDBLinkField(target);
    case EMacroFieldType::eMiscDescriptors:
    case EMacroFieldType::eMiscDescriptorsToRmv:
        return x_GetAsnPathToMiscDescr(target);
    case EMacroFieldType::eDescriptors:
        return x_GetAsnPathToDescriptors();
    case EMacroFieldType::eGene:
        return x_GetAsnPathtoGene();
    case EMacroFieldType::eRNA:
        return x_GetAsnPathToRna();
    case EMacroFieldType::eCds:
        return x_GetAsnPathToCDS();
    case EMacroFieldType::eCdsGeneProt:
        return x_GetAsnPathToCdsGeneProt();
    case EMacroFieldType::eProtein:
        return x_GetAsnPathToProtein();
    case EMacroFieldType::eFeatQualifiers:
        return x_GetAsnPathToFeatQuals();
    case EMacroFieldType::eOther:
        return x_GetAsnPathToMiscFields();
    case EMacroFieldType::eSetFrom:
    case EMacroFieldType::eSetTo:
        return x_GetAsnPathToSet();
    case EMacroFieldType::eSeqID:
        return macro::CMacroFunction_SeqID::GetFuncName() + "()";
    default:
        break;
    }
    return kEmptyStr;
}
 
string CMacroEditorContext::x_GetAsnPathToBsrcTax()
{
    string path;
    if (NStr::EqualNocase(m_Field, "taxname")) {
        path = "org.taxname";
    }
    else if (NStr::EqualNocase(m_Field, "common name")) {
        path = "org.common";
    }
    else if (NStr::EqualNocase(m_Field, "division")) {
        path = "org.orgname.div";
    }
    else if (NStr::EqualNocase(m_Field, "lineage")) {
        path = "org.orgname.lineage";
    }
    return path;
}
 
string CMacroEditorContext::x_GetAsnPathToBsrcText()
{
    string path;
    if (edit::CFieldHandler::QualifierNamesAreEquivalent(m_Field, kHost) ||
        edit::CFieldHandler::QualifierNamesAreEquivalent(m_Field, kNatHost)) {
        path = "org.orgname.mod,nat-host";
    }
    else if (edit::CFieldHandler::QualifierNamesAreEquivalent(m_Field, kOrgModNote)) {
        path = "org.orgname.mod,other";
    }
    else if (edit::CFieldHandler::QualifierNamesAreEquivalent(m_Field, kSubSourceNote)) {
        path = "subtype,other";
    }
    else if (NStr::EqualNocase(m_Field, kFwdPrimerSeq)) {
        path = "pcr-primers..forward..seq";
    }
    else if (NStr::EqualNocase(m_Field, kRevPrimerSeq)) {
        path = "pcr-primers..reverse..seq";
    }
    else if (NStr::EqualNocase(m_Field, kFwdPrimerName)) {
        path = "pcr-primers..forward..name";
    }
    else if (NStr::EqualNocase(m_Field, kRevPrimerName)) {
        path = "pcr-primers..reverse..name";
    }
    else if (edit::CFieldHandler::QualifierNamesAreEquivalent(m_Field, kDbXref)) {
        path = "org.db";
    }
    else if (COrgMod::IsValidSubtypeName(m_Field, COrgMod::eVocabulary_insdc)) {
        path = "org.orgname.mod," + m_Field;
    }
    else if (CSubSource::IsValidSubtypeName(m_Field, CSubSource::eVocabulary_insdc)) {
        path = "subtype," + m_Field;
    }
    
    return path;
}
 
string CMacroEditorContext::x_GetAsnPathToAllBsrc()
{
    string path = x_GetAsnPathToBsrcTax();
    if (path.empty()) {
        if (NStr::EqualNocase(m_Field, "origin"))
            path = "origin";
        else if (NStr::EqualNocase(m_Field, "location") || (NStr::EqualNocase(m_Field, "genome")))
            path = "genome";
        else {
            path = x_GetAsnPathToBsrcText();
        }
    }
    return path;
}
 
string CMacroEditorContext::GetGUIFieldName(const string& macro_field, const string& target, EMacroFieldType& type, EMSection clause)
{
    string field_name;
    type = EMacroFieldType::eNotSet;
 
    m_MacroField = macro_field;
    if (macro::NMacroUtil::StringsAreEquivalent(m_MacroField, "localid")) {
        type = EMacroFieldType::eOther;
        return "Local id";
    }
    else if (NStr::EqualNocase(m_MacroField, "defline") || NStr::EqualNocase(m_MacroField, "descr..title")) {
        type = EMacroFieldType::eOther;
        return "definition line";
    }
    else if (NStr::EqualNocase(m_MacroField, "SeqId")) {
        type = EMacroFieldType::eSeqID;
        return "SeqId";
    }
 
    if (NStr::EqualNocase(target, macro::CMacroBioData::sm_BioSource)) {
        if (!x_GetGUIFieldForBsrcTax(field_name, type)) {
            if (NStr::EqualNocase(m_MacroField, "origin")) {
                type = EMacroFieldType::eBiosourceOrigin;
                field_name = "origin";
            }
            else if (NStr::EqualNocase(m_MacroField, "genome")) {
                type = EMacroFieldType::eBiosourceLocation;
                field_name = "location";
            }
            else {
                x_GetGUIFieldForBsrcText(field_name, type);
            }
        }
        if (field_name.empty()) {
            if (!x_GetGUIFieldForStructComm(field_name, type, clause)) {
                x_IsDescriptor(field_name, type);
            }
        }
    }
    else if (NStr::EqualNocase(target, macro::CMacroBioData::sm_Seq) ||
            NStr::EqualNocase(target, macro::CMacroBioData::sm_SeqNa) ||
            NStr::EqualNocase(target, macro::CMacroBioData::sm_SeqAa)) {
        if (NStr::StartsWith(m_MacroField, "descr..molinfo.", NStr::eNocase)) {
            m_MacroField = m_MacroField.substr(CTempString("descr..molinfo.").length(), NPOS);
        } 
       
        if (m_MacroField == "inst.length" || m_MacroField == "inst.repr") {
            field_name = m_MacroField;
        }
        else {
            bool ret = x_GetGUIFieldForMolinfo(field_name, type);
            if (!ret) {
                ret = x_GetGUIFieldForDBLink(field_name, type);
            }
            if (!ret) {
                ret = x_GetGUIFieldForStructComm(field_name, type, clause);
            }
            if (!ret) {
                x_GetGUIFieldForMiscDescr(field_name, type);
            }
        }
    }
    else if (NStr::EqualNocase(target, macro::CMacroBioData::sm_MolInfo)) {
        bool ret = x_GetGUIFieldForMolinfo(field_name, type);
        if (!ret) {
            x_IsDescriptor(field_name, type);
        }
    }
    else if (NStr::EqualNocase(target, macro::CMacroBioData::sm_Pubdesc)) {
        if (!x_GetGUIFieldForPubdesc(field_name, type)) {
            x_IsDescriptor(field_name, type);
        }
    }
    else if (NStr::EqualNocase(target, macro::CMacroBioData::sm_StrComm)) {
        bool ret = x_GetGUIFieldForStructComm(field_name, type, clause);
        if (!ret) {
            x_IsDescriptor(field_name, type);
        }
    }
    else if (NStr::EqualNocase(target, macro::CMacroBioData::sm_DBLink)) {
        bool ret = x_GetGUIFieldForDBLink(field_name, type);
        if (!ret) {
            x_IsDescriptor(field_name, type);
        }
    }
    else if (NStr::EqualNocase(target, macro::CMacroBioData::sm_UserObject)) {
        x_IsDescriptor(field_name, type);
    }
    else if (NStr::EqualNocase(target, macro::CMacroBioData::sm_Seqdesc)) {
        field_name = s_GetGUIMappedMiscDescr(m_MacroField);
        if (!field_name.empty()) {
            type = EMacroFieldType::eMiscDescriptors;
        }
    }
    else if (NStr::EqualNocase(target, macro::CMacroBioData::sm_Gene)) {
        field_name = x_GetGUIFieldForGene();
        if (!field_name.empty()) {
            type = EMacroFieldType::eGene;
        }
        else {
            x_GetGUIFieldForCdsGeneProtRna(field_name, type);
        }
    }
    else if (NStr::EqualNocase(target, macro::CMacroBioData::sm_Protein)) {
        field_name = x_GetGUIFieldForProtein();
        if (!field_name.empty()) {
            type = EMacroFieldType::eProtein;
        }
        else {
            x_GetGUIFieldForCdsGeneProtRna(field_name, type);
        }
    }
    else if (NStr::EqualNocase(target, macro::CMacroBioData::sm_RNA) ||
        NStr::EqualNocase(target, macro::CMacroBioData::sm_miscRNA) ||
        NStr::EqualNocase(target, macro::CMacroBioData::sm_rRNA) ||
        NStr::EqualNocase(target, macro::CMacroBioData::sm_mRNA)) {
        field_name = x_GetGUIFieldForRNA();
        if (!field_name.empty()) {
            type = EMacroFieldType::eRNA;
        }
        else {
            x_GetGUIFieldForCdsGeneProtRna(field_name, type);
        }
    }
    else if (NStr::EqualNocase(target, macro::CMacroBioData::sm_CdRegion)) {
        field_name = x_GetGUIFieldForCDS();
        if (!field_name.empty()) {
            type = EMacroFieldType::eCdsGeneProt;
        } else {
            x_GetGUIFieldForCdsGeneProtRna(field_name, type);
        }
    }
    else if (NStr::EqualNocase(target, macro::CMacroBioData::sm_SeqFeat)) {
        if (NStr::StartsWith(m_MacroField, "protein,", NStr::eNocase)) {
            field_name = x_GetGUIFieldForProtein();
        } 
        else {
            field_name = x_GetGUIFieldForProtein();
            if (!field_name.empty()) {
                if (!NStr::StartsWith(m_MacroField, "protein,", NStr::eNocase)) {
                    NStr::ReplaceInPlace(field_name, "protein ", "");
                }
            }
            else if (NStr::StartsWith(m_MacroField, "gene,", NStr::eNocase)) {
                field_name = x_GetGUIFieldForGene();
            }
            else if (NStr::StartsWith(m_MacroField, "mRNA,", NStr::eNocase)) {
                m_MacroField = m_MacroField.substr(CTempString("mRNA,").length(), NPOS);
                field_name = x_GetGUIFieldForRNA();
                if (!field_name.empty()) {
                    field_name = "mRNA " + field_name;
                }
            }
            else if (NStr::StartsWith(m_MacroField, "cds", NStr::eNocase)) {
                field_name = x_GetGUIFieldForCDS();
            }
        }
 
        if (!field_name.empty()) {
            type = EMacroFieldType::eCdsGeneProt;
        }
    }
    else if (NStr::EqualNocase(target, macro::CMacroBioData::sm_SeqSet)) {
        if (m_MacroField == "class") {
            field_name = m_MacroField;
        }
        else {
            if (CBioseq_set::ENUM_METHOD_NAME(EClass)()->IsValidName(m_MacroField)) {
                field_name = m_MacroField;
                if (m_MacroField == "gi" || m_MacroField == "gibb") {
                    field_name = m_MacroField + "-set";
                }
            }
        }
    }
    else if (NStr::EqualNocase(target, macro::CMacroBioData::sm_AutodefOpts)) {
        field_name = m_MacroField;
    }
 
    if (field_name.empty() && macro::CMacroBioData::s_IsFeatSelector(target)) {
        if (NStr::EqualNocase(m_MacroField, "except-text") || 
            NStr::EqualNocase(m_MacroField, "except") ||
            m_MacroField == "product") {
            field_name = m_MacroField;
        } 
        else if (NStr::EqualNocase(m_MacroField, "comment")) {
            field_name = "note";
        }
        else if (NStr::EqualNocase(m_MacroField, "dbxref")) {
            field_name = "db-xref";
        }
        else if (s_IsGeneQualifier(m_MacroField)) {
            field_name = m_MacroField;
            NStr::ReplaceInPlace(field_name, "_", "-");
        }
 
        if (field_name.empty()) {
            auto pos = m_MacroField.find(",");
            if (pos != NPOS) {
                auto tmp = m_MacroField.substr(pos + 1, NPOS);
                if (NStr::StartsWith(m_MacroField, "qual,") &&
                    (CSeqFeatData::GetQualifierType(tmp) != CSeqFeatData::eQual_bad /*|| tmp == "codons_recognized" */)) {
                    field_name = tmp;
                    NStr::ReplaceInPlace(field_name, "_", "-");
                }
                else if (NStr::StartsWith(m_MacroField, "gene,", NStr::eNocase)) {
                    field_name = x_GetGUIFieldForGene();
                    NStr::ReplaceInPlace(field_name, "gene ", "");
                }
                else {
                    pos = tmp.find(",");
                    if (pos != NPOS) {
                        tmp = tmp.substr(pos + 1, NPOS);
                    }
                    if (macro::NMacroUtil::IsMobileElementTSubfield(tmp) || macro::NMacroUtil::IsSatelliteSubfield(tmp)) {
                        field_name = tmp;
                    }
                }
            }
        }
        if (!field_name.empty()) {
            type = EMacroFieldType::eFeatQualifiers;
        }
    }
 
    return field_name;
}
 
bool CMacroEditorContext::x_GetGUIFieldForCdsGeneProtRna(string& field_name, EMacroFieldType& type)
{
    if (!field_name.empty())
        return true;
 
    if (NStr::StartsWith(m_MacroField, "cds", NStr::eNocase)) {
        field_name = x_GetGUIFieldForCDS();
    }
    else if (NStr::StartsWith(m_MacroField, "protein,", NStr::eNocase)) {
        field_name = x_GetGUIFieldForProtein();
    }
    else if (NStr::StartsWith(m_MacroField, "gene,", NStr::eNocase)) {
        field_name = x_GetGUIFieldForGene();
    }
    else if (NStr::StartsWith(m_MacroField, "mat_peptide,", NStr::eNocase)) {
        m_MacroField = m_MacroField.substr(CTempString("mat_peptide,").length(), NPOS);
        field_name = x_GetGUIFieldForProtein();
        if (!field_name.empty()) {
            NStr::ReplaceInPlace(field_name, "protein", "mat_peptide");
        }
    }
    else if (NStr::StartsWith(m_MacroField, "mRNA,", NStr::eNocase)) {
        m_MacroField = m_MacroField.substr(CTempString("mRNA,").length(), NPOS);
        field_name = x_GetGUIFieldForRNA();
        if (!field_name.empty()) {
            field_name = "mRNA " + field_name;
        }
    }
    if (!field_name.empty()) {
        type = EMacroFieldType::eCdsGeneProt;
    }
    return (!field_name.empty());
}
 
string CMacroEditorContext::GetGUIFeatQualifier(const string& macro_field)
{
    string field_name;
    if (macro_field == "data.gene.allele") {
        field_name = "allele";
    }
    else if (macro_field == "data.gene.syn") {
        field_name = "gene_synonym";
    }
    else if (macro_field == "data.gene.locus-tag") {
        field_name = "locus_tag";
    }
    return field_name;
}
 
bool CMacroEditorContext::s_IsGeneQualifier(const string& field)
{
    return (macro::NMacroUtil::StringsAreEquivalent(field, "locus_tag") ||
        field == "locus" ||
        field == "allele" ||
        field == "maploc" ||
        field == "desc");  // maybe syn?
}
 
 
bool CMacroEditorContext::x_IsDescriptor(string& field_name, EMacroFieldType& type)
{
    field_name = FindInBimapOrEmpty(m_MacroField, m_DescriptorMap);
    if (!field_name.empty()) {
        type = EMacroFieldType::eDescriptors;
        return true;
    }
    return false;
}
 
 
bool CMacroEditorContext::x_GetGUIFieldForBsrcTax(string& field_name, EMacroFieldType& type)
{
    static const TBimapStrings::relation bsrc_tax_bm[] = {
            {"taxname", "org.taxname"},
            {"common name", "org.common"},
            {"division", "org.orgname.div"},
            {"lineage", "org.orgname.lineage"} };
    TBimapStrings const data{ begin(bsrc_tax_bm), end(bsrc_tax_bm) };
 
    field_name = FindInBimapOrEmpty(m_MacroField, data);
    if (!field_name.empty()) {
        type = EMacroFieldType::eBiosourceTax;
        return true;
    }
    return false;
}
 
bool CMacroEditorContext::x_GetGUIFieldForBsrcText(string& field_name, EMacroFieldType& type)
{
    static const TBimapStrings::relation bsrc_text_bm[] = {
            {kHost, "org.orgname.mod,nat-host"},
            {kOrgModNote, "org.orgname.mod,other"},
            {kSubSourceNote, "subtype,other"},
            {kFwdPrimerSeq, "pcr-primers..forward..seq"},
            {kRevPrimerSeq, "pcr-primers..reverse..seq"},
            {kFwdPrimerName, "pcr-primers..forward..name"},
            {kRevPrimerName, "pcr-primers..reverse..name"},
            {kDbXref, "org.db"} };
 
    TBimapStrings const data{ begin(bsrc_text_bm), end(bsrc_text_bm) };
 
    string ret = FindInBimapOrEmpty(m_MacroField, data);
    if (ret.empty() && (m_MacroField == "org.db.db")) {
        ret = kDbXref;
    }
    if (ret.empty()) {
        string tmp = m_MacroField;
        string sv_part;
 
        auto pos = m_MacroField.find(",");
        if (pos != NPOS) {
            tmp = m_MacroField.substr(pos + 1, NPOS);
            pos = tmp.find(",");
            if (pos != NPOS) {
                sv_part = "-" + tmp.substr(pos + 1, NPOS);
                tmp = tmp.substr(0, pos);
            }
        }
        if (COrgMod::IsValidSubtypeName(tmp) && !NStr::StartsWith(m_MacroField, "subtype,")) {
            ret = tmp;
        }
        else if (CSubSource::IsValidSubtypeName(tmp) && !NStr::StartsWith(m_MacroField, "org.orgname.mod,")) {
            ret = tmp;
        }
        if (!ret.empty() && pos != NPOS && macro::NMacroUtil::IsStructVoucherPart(sv_part)) {
                ret = ret + sv_part;
        } 
    }
    if (!ret.empty()) {
        field_name = ret;
        type = EMacroFieldType::eBiosourceText;
        return true;
    }
    return false;
}
 
string CMacroEditorContext::s_GetGUIMappedStructCommField(const string& value)
{
    static const TBimapStrings::relation struct_comm_bm[] = {
            {"Field", macro::kStrCommFieldValue},
            {"Database name", macro::kStrCommDbname},
            {"Field name", macro::kStrCommFieldName} };
 
    TBimapStrings const data{ begin(struct_comm_bm), end(struct_comm_bm) };
    return FindInBimapOrEmpty(value, data);
}
 
bool CMacroEditorContext::x_GetGUIFieldForStructComm(string& field_name, EMacroFieldType& type, EMSection clause)
{
    field_name = s_GetGUIMappedStructCommField(m_MacroField);
    if (!field_name.empty()) {
        type = EMacroFieldType::eStructComment;
        if (clause == EMSection::eWhereSection) {
            field_name = "Structured comment " + field_name;
        }
        return true;
    }
    return false;
}
 
string CMacroEditorContext::x_GetAsnPathToMolinfo(const string& target)
{
    string path;
    if (NStr::EqualNocase(m_Field, "molecule")) {
        path = "biomol";
    }
    else if (NStr::EqualNocase(m_Field, "technique")) {
        path = "tech";
    }
    else if (NStr::EqualNocase(m_Field, "completedness")) {
        path = "completeness";
    }
 
 
    if ((target == macro::CMacroBioData::sm_Seq ||
        target == macro::CMacroBioData::sm_SeqNa ||
        target == macro::CMacroBioData::sm_SeqAa) && !path.empty()) {
        path = "descr..molinfo." + path;
    }
 
    if (NStr::EqualNocase(m_Field, "class")) {
        path = "inst.mol";
    }
    else if (NStr::EqualNocase(m_Field, "topology")) {
        path = "inst.topology";
    }
    else if (NStr::EqualNocase(m_Field, "strand")) {
        path = "inst.strand";
    }
    return path;
}
 
bool CMacroEditorContext::x_GetGUIFieldForMolinfo(string& field_name, EMacroFieldType& type)
{
    static const TBimapStrings::relation molinfo_descr_bm[] = {
            {"biomol", "molecule"},
            {"tech", "technique"},
            {"completeness", "completedness"},
            {"inst.mol", "class"},
            {"inst.topology", "topology"},
            {"inst.strand", "strand"} };
 
    TBimapStrings const data{ begin(molinfo_descr_bm), end(molinfo_descr_bm) };
    field_name = FindInBimapOrEmpty(m_MacroField, data);
    if (!field_name.empty()) {
        type = EMacroFieldType::eMolinfo;
        return true;
    }
    return false;
}
 
bool CMacroEditorContext::x_GetGUIFieldForDBLink(string& field_name, EMacroFieldType& type)
{
    const auto it = find_if(m_DBLinkKeywords.begin(), m_DBLinkKeywords.end(),
        [this](const auto& elem) { return NStr::EqualNocase(elem, m_MacroField); });
    
    if (it != m_DBLinkKeywords.end()) {
        field_name = m_MacroField;
        type = EMacroFieldType::eDBLink;
        return true;
    }
    return false;
}
 
bool CMacroEditorContext::x_GetGUIFieldForPubdesc(string& field_name, EMacroFieldType& type)
{
    field_name.clear();
    if (m_MacroField == "affil") {
        field_name = CPubFieldType::GetLabelForType(CPubFieldType::ePubFieldType_AffilAffil);
    }
    else if (m_MacroField == "div") {
        field_name = CPubFieldType::GetLabelForType(CPubFieldType::ePubFieldType_AffilDept);
    }
    else if (m_MacroField == "sub") {
        field_name = CPubFieldType::GetLabelForType(CPubFieldType::ePubFieldType_AffilState);
    }
    else if (m_MacroField == "postal-code") {
        field_name = CPubFieldType::GetLabelForType(CPubFieldType::ePubFieldType_AffilPostalCode);
    }
    else {
        const auto fields = CPubFieldType::GetFieldNames(true);
        if (find(fields.begin(), fields.end(), m_MacroField) != fields.end())
            field_name = m_MacroField;
    }
    
    if (!field_name.empty()) {
        field_name = CPubFieldType::NormalizePubFieldName(field_name);
        type = EMacroFieldType::ePubdesc;
        return true;
    }
    return false;
}
 
string CMacroEditorContext::GetGUIAffilField(const string& macro_field)
{
    m_MacroField = macro_field;
    string field_name;
    EMacroFieldType type = EMacroFieldType::eNotSet;
    x_GetGUIFieldForPubdesc(field_name, type);
    return field_name;
}
 
string CMacroEditorContext::GetGUIDateField(const string& macro_field)
{
    CPubFieldType::EPubFieldType type = CPubFieldType::GetTypeForLabel(macro_field);
    string value = CPubFieldType::GetLabelForType(type);
    return CPubFieldType::NormalizePubFieldName(value);
}
 
string CMacroEditorContext::s_GetGUIMappedMiscDescr(const string& value)
{
    static const TBimapStrings::relation misc_descr_bm[] = {
            {"title", kDefinitionLineLabel},
            {"comment", kCommentDescriptorLabel},
            {"genbank.keywords", kGenbankBlockKeyword} };
 
    TBimapStrings const data{ begin(misc_descr_bm), end(misc_descr_bm) };
    return FindInBimapOrEmpty(value, data);
}
 
bool CMacroEditorContext::x_GetGUIFieldForMiscDescr(string& field_name, EMacroFieldType& type)
{
    string tmp = m_MacroField;
    if (NStr::StartsWith(m_MacroField, "descr..")) {
        tmp = tmp.substr(CTempString("descr..").length(), NPOS);
    }
 
    field_name = s_GetGUIMappedMiscDescr(tmp);
    if (!field_name.empty()) {
        type = EMacroFieldType::eMiscDescriptors;
        return true;
    }
    return false;
}
 
string CMacroEditorContext::x_GetAsnPathToMiscDescr(const string& target)
{
    string path;
    if (NStr::EqualNocase(m_Field, kDefinitionLineLabel)) {
        path = "title";
    }
    else if (NStr::EqualNocase(m_Field, kCommentDescriptorLabel)) {
        path = "comment";
    }
    else if (NStr::EqualNocase(m_Field, kGenbankBlockKeyword)) {
        path = "genbank.keywords";
    }
 
    if ((target == macro::CMacroBioData::sm_Seq ||
        target == macro::CMacroBioData::sm_SeqNa ||
        target == macro::CMacroBioData::sm_SeqAa) && !path.empty()) {
        path = "descr.." + path;
    }
    return path;
}
 
string CMacroEditorContext::x_GetAsnPathToMiscFields()
{
    string path;
    if (macro::NMacroUtil::StringsAreEquivalent(m_Field, "localid")) {
        path = "localid";
    }
    else if (NStr::EqualNocase(m_Field, "definition line")) {
        path = "defline";
    }
    return path;
}
 
string CMacroEditorContext::x_GetAsnPathToDBLinkField(const string& target)
{
    if (target == macro::CMacroBioData::sm_SeqNa) {
        return macro::CMacroFunction_GetDBLink::GetFuncName() + "(\"" + m_Field + "\")";
    }
    return "data.data.strs";
}
 
string CMacroEditorContext::x_GetAsnPathToPub()
{
    CPubFieldType::EPubFieldType field_type = CPubFieldType::GetTypeForLabel(m_Field);
    return CPubFieldType::GetMacroLabelForType(field_type);
}
 
string CMacroEditorContext::x_GetAsnPathToAffilFields()
{
    CPubFieldType::EPubFieldType type = CPubFieldType::GetTypeForLabel(m_Field);
    m_Field = CPubFieldType::NormalizePubFieldName(m_Field);
    switch (type) {
    case CPubFieldType::ePubFieldType_AffilAffil:
        return "affil";
    case CPubFieldType::ePubFieldType_AffilDept:
        return "div";
    case CPubFieldType::ePubFieldType_AffilState:
        return "sub";
    case CPubFieldType::ePubFieldType_AffilPostalCode:
        return "postal-code";
    default:
        break;
    }
    return m_Field;
}
 
string CMacroEditorContext::x_GetAsnPathToDescriptors()
{
    auto it = m_DescriptorMap.left.find(m_Field);
    if (it != m_DescriptorMap.left.end()) {
        return it->second;
    }
    return kEmptyStr;
}
 
string CMacroEditorContext::GetGUIDescriptor(const string& macro_field)
{
    return FindInBimapOrEmpty(macro_field, m_DescriptorMap);
}
 
static string s_GetGeneField(const string& value)
{
    static const CMacroEditorContext::TBimapStrings::relation gene_qual_bm[] = {
            {"gene locus", "data.gene.locus"},
            {"gene description", "data.gene.desc"},
            {"gene comment", "comment"},
            {"gene allele", "data.gene.allele"},
            {"gene maploc", "data.gene.maploc"},
            {"gene locus tag", "data.gene.locus-tag"},
            {"gene synonym", "data.gene.syn"}
    };
 
    CMacroEditorContext::TBimapStrings const data{ begin(gene_qual_bm), end(gene_qual_bm) };
    return CMacroEditorContext::FindInBimapOrEmpty(value, data);
}
 
 
string CMacroEditorContext::x_GetAsnPathtoGene()
{
 
    string path = s_GetGeneField(m_Field);
    if (path.empty() && NStr::StartsWith(m_Field, "gene ", NStr::eNocase)) {
        SIZE_TYPE pos = m_Field.find(" ");
        path = "qual," + m_Field.substr(pos + 1);
    }
    return path;
}
 
string CMacroEditorContext::x_GetGUIFieldForGene()
{
    if (NStr::StartsWith(m_MacroField, "gene,", NStr::eNocase)) {
        m_MacroField = m_MacroField.substr(CTempString("gene,").length(), NPOS);
    }
 
    string gui_elem = s_GetGeneField(m_MacroField);
    if (gui_elem.empty()) {
        if (m_MacroField == "inference" || NStr::EqualNocase(m_MacroField, "qual,inference")) {
            gui_elem = "gene inference";
        }
        else if (m_MacroField == "old_locus_tag") {
            gui_elem = "gene old_locus_tag";
        }
    }
    return gui_elem;
}
 
string CMacroEditorContext::x_GetAsnPathToCDS()
{
    string path;
    if (NStr::EqualNocase(m_Field, "cds comment")) {
        path = "comment";
    }
    else if (NStr::EqualNocase(m_Field, "cds inference")) {
        path = "qual,inference";
    }
    else if (macro::NMacroUtil::StringsAreEquivalent(m_Field, "codon-start")) {
        path = "data.cdregion.frame";
    }
    return path;
}
 
string CMacroEditorContext::x_GetGUIFieldForCDS()
{
    string gui_elem;
    if (NStr::StartsWith(m_MacroField, "cds,", NStr::eNocase)) {
        m_MacroField = m_MacroField.substr(string("cds,").length(), NPOS);
    }
    if (NStr::EqualNocase(m_MacroField, "comment")) {
        gui_elem = "cds comment";
    }
    else if (NStr::EqualNocase(m_MacroField, "qual,inference") || NStr::EqualNocase(m_MacroField, "inference")) {
        gui_elem = "cds inference";
    }
    else if (m_MacroField == "data.cdregion.frame") {
        gui_elem = "codon-start";
    }
    return gui_elem;
}
 
string CMacroEditorContext::x_GetAsnPathToRna()
{
    if (NStr::StartsWith(m_Field, "gene", NStr::eNocase)) {
        return x_GetAsnPathtoGene();
    }
    else {
        SIZE_TYPE pos = m_Field.find(" ");
        if (pos != NPOS) {
            return x_GetAsnPathToRnaFieldName(m_Field.substr(0, pos), m_Field.substr(pos + 1));
        }
    }
    return kEmptyStr;
}
 
static string s_GetProteinField(const string& value)
{
    static const CMacroEditorContext::TBimapStrings::relation protein_qual_bm[] = {
            {"protein comment", "comment"},
            {"protein name", "data.prot.name"},
            {"protein description", "data.prot.desc"},
            {"protein EC number", "data.prot.ec"},
            {"protein activity", "data.prot.activity"}
    };
 
    CMacroEditorContext::TBimapStrings const data{ begin(protein_qual_bm), end(protein_qual_bm) };
    return CMacroEditorContext::FindInBimapOrEmpty(value, data);
}
 
string CMacroEditorContext::x_GetAsnPathToProtein()
{
    return s_GetProteinField(m_Field);
}
 
string CMacroEditorContext::x_GetGUIFieldForProtein()
{
    if (NStr::StartsWith(m_MacroField, "protein,", NStr::eNocase)) {
        m_MacroField = m_MacroField.substr(CTempString("protein,").length(), NPOS);
    }
    return s_GetProteinField(m_MacroField);
}
 
string CMacroEditorContext::x_GetAsnPathToCdsGeneProt()
{
    if (NStr::StartsWith(m_Field, "mat_peptide", NStr::eNocase)) {
        NStr::ReplaceInPlace(m_Field, "mat_peptide", "protein");
    }
 
    if (NStr::StartsWith(m_Field, "protein", NStr::eNocase)) {
        return x_GetAsnPathToProtein();
    }
    else if (NStr::StartsWith(m_Field, "CDS", NStr::eNocase) ||
        macro::NMacroUtil::StringsAreEquivalent(m_Field, "codon-start")) {
        return x_GetAsnPathToCDS();
    }
    else if (NStr::StartsWith(m_Field, "gene", NStr::eNocase)) {
        return x_GetAsnPathtoGene();
    }
    else if (NStr::StartsWith(m_Field, "mRNA", NStr::eNocase)) {
        SIZE_TYPE pos = m_Field.find(" ");
        return x_GetAsnPathToRnaFieldName("mRNA", m_Field.substr(pos + 1));
    }
    return kEmptyStr;
}
 
string CMacroEditorContext::x_GetAsnPathToFeatQuals()
{
    vector<string> tokens;
    NStr::Split(m_Field, " ", tokens);
    if (tokens.size() == 2) {
        return x_GetAsnPathToFeatQuals(tokens[0], tokens[1]);
    }
    return kEmptyStr;
}
 
string CMacroEditorContext::x_GetAsnPathToRnaFieldName(const string& rna_type, const string& field)
{
    string path;
 
    if (field == "comment" || field == "note") {
        path = "comment";
    }
 
    if (field == "product") {
        if (NStr::EqualNocase(rna_type, "mRNA") ||
            NStr::EqualNocase(rna_type, "rRNA") ||
            NStr::EqualNocase(rna_type, "preRNA")) {
            path = "data.rna.ext.name";
        }
        else if (NStr::EqualNocase(rna_type, "miscRNA") ||
            NStr::EqualNocase(rna_type, "ncRNA") ||
            NStr::EqualNocase(rna_type, "tmRNA")) {
            path = "data.rna.ext.gen.product";
        }
        else if (NStr::EqualNocase(rna_type, "tRNA") ||
            NStr::EqualNocase(rna_type, "any")) {
            path = rna_type + "::" + field;
        }
    }
 
    if (NStr::EqualNocase(field, "ncRNA class") && NStr::EqualNocase(rna_type, "ncRNA")) {
        path = "data.rna.ext.gen.class";
    }
 
    if (macro::NMacroUtil::StringsAreEquivalent(field, "codons-recognized")) {
        if (NStr::EqualNocase(rna_type, "tRNA")) {
            // only to remove
            path = "data.rna.ext.tRNA.codon";
        }
        /*else {
            path = "qual,codons_recognized";
        }
        */
    }
 
    if (NStr::EqualNocase(field, "tag-peptide")) {
        if (NStr::EqualNocase(rna_type, "tmRNA")) {
            path = "data.rna.ext.gen.quals,tag_peptide";
        }
        else {
            path = "qual,tag_peptide";
        }
    }
 
    if (NStr::EqualNocase(field, "anticodon")) {
        if (NStr::EqualNocase(rna_type, "tRNA")) {
            // only to remove
            path = "data.rna.ext.tRNA.anticodon";
        }
        else {
            path = "qual," + field;
        }
    }
 
    return path;
}
 
string CMacroEditorContext::x_GetGUIFieldForRNA()
{
    if (NStr::StartsWith(m_MacroField, "gene,", NStr::eNocase)) {
        return x_GetGUIFieldForGene();
    }
 
    size_t pos = m_MacroField.find(",");
    if (pos != NPOS) {
        string tmp = m_MacroField.substr(0, pos);
        if (NStr::EndsWith(tmp, "RNA", NStr::eNocase) || tmp == "any") {
            m_MacroField = m_MacroField.substr(pos + 1, NPOS);
        }
    }
 
    if (m_MacroField == "product" ||
        m_MacroField == "any::product" ||
        m_MacroField == "tRNA::product" ||
        m_MacroField == "data.rna.ext.name" ||
        m_MacroField == "data.rna.ext.gen.product")
        return "product";
    else if (m_MacroField == "comment")
        return m_MacroField;
    else if (m_MacroField == "tag_peptide" || m_MacroField == "qual,tag_peptide" || m_MacroField == "data.rna.ext.gen.quals,tag_peptide")
        return "tag-peptide";
    else if (m_MacroField == "anticodon" || m_MacroField == "qual,anticodon" || m_MacroField == "data.rna.ext.tRNA.anticodon")
        return "anticodon";
    else if (m_MacroField == "codons recognized" || m_MacroField == "data.rna.ext.tRNA.codon")
        return "codons recognized";
    else if (m_MacroField == "data.rna.ext.gen.class")
        return "ncRNA class";
    
    return kEmptyStr;
}
 
static string s_MapStrandValues(const string& value)
{
    static const CMacroEditorContext::TBimapStrings::relation strand_bm[] = {
            {"na", "nucleotide"},
            {"aa", "protein"},
            {"ds", "double"},
            {"ss", "single"},
            {"pre-RNA", "precursor RNA"} };
    CMacroEditorContext::TBimapStrings const data{ begin(strand_bm), end(strand_bm) };
    return CMacroEditorContext::FindInBimapOrEmpty(value, data);
}
 
string CMacroEditorContext::GetAsnMolinfoValue(const string& molinfo_field, const string& choice)
{
    // handle outliers first:
    string ret = s_MapStrandValues(choice);
    if (!ret.empty())
        return ret;
 
 
    CMolInfoFieldType::EMolInfoFieldType field_type = CMolInfoFieldType::GetFieldType(molinfo_field);
    if (choice == " ") {
        switch (field_type) {
        case CMolInfoFieldType::e_Class:
        case CMolInfoFieldType::e_Strand:
        case CMolInfoFieldType::e_Topology:
        case CMolInfoFieldType::e_Repr:
            return "not-set";
        case CMolInfoFieldType::e_Completedness:
        case CMolInfoFieldType::e_MoleculeType:
        case CMolInfoFieldType::e_Technique:
            return "unknown";
        default:
            return kEmptyStr;
        }
    }
 
    if (field_type == CMolInfoFieldType::e_Repr) {
        if (choice == "consensus")
            return "consen";
        else if (choice == "constructed")
            return "const";
        else if (choice == "ordered map")
            return "map";
        else if (choice == "reference to another")
            return "ref";
        else if (choice == "segmented")
            return "seg";
    }
 
 
    CEnumeratedTypeValues::TValues values;
    switch (field_type) {
    case CMolInfoFieldType::e_Class:
        values = CSeq_inst::ENUM_METHOD_NAME(EMol)()->GetValues();
        break;
    case CMolInfoFieldType::e_Completedness:
        values = CMolInfo::ENUM_METHOD_NAME(ECompleteness)()->GetValues();
        break;
    case CMolInfoFieldType::e_MoleculeType:
        values = CMolInfo::ENUM_METHOD_NAME(EBiomol)()->GetValues();
        break;
    case CMolInfoFieldType::e_Strand:
        values = CSeq_inst::ENUM_METHOD_NAME(EStrand)()->GetValues();
        break;
    case CMolInfoFieldType::e_Technique:
        values = CMolInfo::ENUM_METHOD_NAME(ETech)()->GetValues();
        break;
    case CMolInfoFieldType::e_Topology:
        values = CSeq_inst::ENUM_METHOD_NAME(ETopology)()->GetValues();
        break;
    case CMolInfoFieldType::e_Repr:
        values = CSeq_inst::ENUM_METHOD_NAME(ERepr)()->GetValues();
    default:
        break;
    }
 
    auto it = find_if(values.begin(), values.end(), [&choice](const pair<string, TEnumValueType>& elem)
    { return edit::CFieldHandler::QualifierNamesAreEquivalent(elem.first, choice); });
    
    if (it != values.end()) {
        return it->first;
    }
    
    LOG_POST(Error << choice  << " could not be mapped onto an enum value");
    return kEmptyStr;
}
 
string CMacroEditorContext::GetGUIMolinfoValue(const string& macro_field, const string& molinfo_field)
{
    string ret = s_MapStrandValues(macro_field);
    if (!ret.empty())
        return ret;
 
    if (macro_field == "not-set" || macro_field == "unknown") {
        // pay attention as this is not an empty string
        return " ";
    }
 
    CMolInfoFieldType::EMolInfoFieldType field_type = CMolInfoFieldType::GetFieldType(molinfo_field);
    CEnumeratedTypeValues::TNameToValue name_to_values;
    switch (field_type) {
    case CMolInfoFieldType::e_Class:
        name_to_values = CSeq_inst::ENUM_METHOD_NAME(EMol)()->NameToValue();
        break;
    case CMolInfoFieldType::e_Completedness:
        name_to_values = CMolInfo::ENUM_METHOD_NAME(ECompleteness)()->NameToValue();
        break;
    case CMolInfoFieldType::e_MoleculeType:
        name_to_values = CMolInfo::ENUM_METHOD_NAME(EBiomol)()->NameToValue();
        break;
    case CMolInfoFieldType::e_Strand:
        name_to_values = CSeq_inst::ENUM_METHOD_NAME(EStrand)()->NameToValue();
        break;
    case CMolInfoFieldType::e_Technique:
        name_to_values = CMolInfo::ENUM_METHOD_NAME(ETech)()->NameToValue();
        break;
    case CMolInfoFieldType::e_Topology:
        name_to_values = CSeq_inst::ENUM_METHOD_NAME(ETopology)()->NameToValue();
        break;
    case CMolInfoFieldType::e_Repr:
        name_to_values = CSeq_inst::ENUM_METHOD_NAME(ERepr)()->NameToValue();
    default:
        break;
    }
    
    auto it = name_to_values.find(macro_field);
    if (it != name_to_values.end()) {
        switch (field_type) {
        case CMolInfoFieldType::e_Class:
            ret = CMolInfoFieldType::GetMolLabel((CSeq_inst::TMol)it->second);
            break;
        case CMolInfoFieldType::e_Completedness:
            ret = CMolInfoFieldType::GetCompletenessLabel((CMolInfo::TCompleteness)it->second);
            break;
        case CMolInfoFieldType::e_MoleculeType:
            ret = CMolInfoFieldType::GetBiomolLabel((CMolInfo::TBiomol)it->second);
            break;
        case CMolInfoFieldType::e_Strand:
            ret = CMolInfoFieldType::GetStrandLabel((CSeq_inst::TStrand)it->second);
            break;
        case CMolInfoFieldType::e_Technique:
            ret = CMolInfoFieldType::GetTechLabel((CMolInfo::TTech)it->second);
            break;
        case CMolInfoFieldType::e_Topology:
            ret = CMolInfoFieldType::GetTopologyLabel((CSeq_inst::TTopology)it->second);
            break;
        case CMolInfoFieldType::e_Repr:
            ret = CMolInfoFieldType::GetReprLabel((CSeq_inst::TRepr)it->second);
        default:
            break;
        }
    }
    return ret;
}
 
 
string CMacroEditorContext::x_GetAsnPathToSet()
{
    m_Field[0] = tolower((unsigned char)m_Field[0]);
    if (m_Field == "gi-set" || m_Field == "gibb-set") {
        m_Field = m_Field.substr(0, m_Field.find("-"));
    }
    return m_Field;
}
 
 
 
 
END_NCBI_SCOPE