macro_fn_aecr.cpp

Go to the documentation of this file.

Go to the SVN repository for this file.

/*  $Id: macro_fn_aecr.cpp 47378 2023-02-27 20:09:44Z asztalos $
 * ===========================================================================
 *
 *                            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/BioSource.hpp>
#include <objects/seqfeat/Org_ref.hpp>
#include <objects/seqfeat/OrgName.hpp>
#include <objects/seqfeat/seqfeat_macros.hpp>
#include <objects/seqblock/GB_block.hpp>
#include <objects/seq/Seqdesc.hpp>
 
#include <objects/valid/Comment_rule.hpp>
#include <objects/valid/Comment_set.hpp>
#include <objects/general/User_object.hpp>
#include <objects/general/general_macros.hpp>
#include <util/xregexp/regexp.hpp>
#include <objmgr/util/sequence.hpp>
 
#include <objtools/cleanup/cleanup.hpp>
#include <objtools/edit/field_handler.hpp>
 
#include <gui/objutils/cmd_create_desc.hpp>
#include <gui/objutils/cmd_create_feat.hpp>
#include <gui/objutils/cmd_del_desc.hpp>
#include <gui/objutils/descriptor_change.hpp>
#include <gui/objutils/util_cmds.hpp>
 
#include <gui/objutils/macro_util.hpp>
#include <gui/objutils/macro_ex.hpp>
#include <gui/objutils/macro_field_resolve.hpp>
#include <gui/objutils/macro_fn_pubfields.hpp>
#include <gui/objutils/macro_fn_aecr.hpp>
 
/** @addtogroup GUI_MACRO_SCRIPTS_UTIL
 *
 * @{
 */
 
BEGIN_NCBI_SCOPE
BEGIN_SCOPE(macro)
USING_SCOPE(objects);
 
// All DO functions should make changes on the "Edited" object of the BioDataIterator
 
/// class CMacroFunction_SwapRelatedFeaturesQual_Depr
/// SwapRelateFeaturesQual(src_field, dest_feat_subtype, dest_field);
///
DEFINE_MACRO_FUNCNAME(CMacroFunction_SwapRelatedFeaturesQual_Depr, "SwapRelateFeaturesQual")
void CMacroFunction_SwapRelatedFeaturesQual_Depr::TheFunction()
{
    CConstRef<CObject> obj = m_DataIter->GetScopedObject().object;
    const CSeq_feat* src_feat = dynamic_cast<const CSeq_feat*>(obj.GetPointer());
    CRef<CScope> scope = m_DataIter->GetScopedObject().scope;
    if (!src_feat || !scope)
        return;
 
    CObjectInfo oi = m_DataIter->GetEditedObject();
 
    CMQueryNodeValue::TObs src_objs;
    CMQueryNodeValue::EType src_type = m_Args[0]->GetDataType();
 
    // the source field has to be set
    if (src_type == CMQueryNodeValue::eString) {
        if (!GetFieldsByName(&src_objs, oi, m_Args[0]->GetString()))
            return;
    }
    else if (src_type == CMQueryNodeValue::eObjects) {
        src_objs = m_Args[0]->GetObjects();
    }
    else if (src_type == CMQueryNodeValue::eRef) {
        x_GetObjectsFromRef(src_objs, 0);
    }
 
    if (src_objs.empty()) {
        return;
    }
 
    // the destination field also has to be set and 
    // should be a field from the corresponding feature
    CSeqFeatData::ESubtype related_feature = NMacroUtil::GetFeatSubtype(m_Args[1]->GetString());
    NMacroUtil::TVecFeatList feat_list = edit::GetRelatedFeatures(*src_feat, related_feature, scope);
    if (feat_list.empty()) {
        return;
    }
 
    CConstRef<CSeq_feat> orig_feat = *feat_list.begin();
    CRef<CSeq_feat> new_feat(new CSeq_feat);
    new_feat->Assign(*orig_feat);
    CObjectInfo objInfo(new_feat.GetPointer(), new_feat.GetPointer()->GetTypeInfo());
 
    CMQueryNodeValue::TObs dest_objs;
    const string& dest_field = m_Args[2]->GetString();
    if (!GetFieldsByName(&dest_objs, objInfo, dest_field) || dest_objs.empty()) {
        return;
    }
 
    CMQueryNodeValue::TObs::iterator src_it = src_objs.begin();
    CMQueryNodeValue::TObs::iterator dest_it = dest_objs.begin();
 
    while (src_it != src_objs.end() && dest_it != dest_objs.end()) {
        CObjectInfo src_prim = NMacroUtil::GetPrimitiveObjInfo(src_it->field);
        CObjectInfo dest_prim = NMacroUtil::GetPrimitiveObjInfo(dest_it->field);
        if (CMacroFunction_SwapQual::s_SwapFields(src_prim, dest_prim)) {
            m_QualsChangedCount += 2;
        }
        ++src_it;
        ++dest_it;
    }
 
    if (m_QualsChangedCount) {
        m_DataIter->SetModified();
 
        CRef<CCmdComposite> cmd(new CCmdComposite("Change Related feature"));
        cmd->AddCommand(*CRef<CCmdChangeSeq_feat>(new CCmdChangeSeq_feat(scope->GetSeq_featHandle(*orig_feat), *new_feat)));
        m_DataIter->RunCommand(cmd, m_CmdComposite);
 
        TChangedQuals report;
        report["swapping qualifiers"] = m_QualsChangedCount;
        CRef<IFunctionLog> fnc_log(new CGeneralFuncLog(report));
        x_LogChangedQuals(fnc_log);
    }
}
 
bool CMacroFunction_SwapRelatedFeaturesQual_Depr::x_ValidArguments() const
{
    if (m_Args.size() != 3) {
        return false;
    }
 
    if (!(m_Args[0]->IsString() || m_Args[0]->AreObjects() || m_Args[0]->IsRef()))
        return false;
 
    for (size_t index = 1; index < m_Args.size(); ++index) {
        if (m_Args[index]->GetDataType() != CMQueryNodeValue::eString) {
            return false;
        }
    }
 
    return true;
}
 
 
///////////////////////////////////////////////////////////////////////////////
/// class CMacroFunction_RemoveQual
/// RemoveQual("genome");
/// or
/// obj = PUB_AFFIL("sub"); 
/// RemoveQual(obj);
///
DEFINE_MACRO_FUNCNAME(CMacroFunction_RemoveQual, "RemoveQual")
 
void CMacroFunction_RemoveQual::TheFunction()
{
    CMQueryNodeValue::EType type = m_Args[0]->GetDataType();
 
    CObjectInfo oi = m_DataIter->GetEditedObject();
    CMQueryNodeValue::TObs res_oi;
    if (type == CMQueryNodeValue::eString) {
        const string& field_name = m_Args[0]->GetString();
        if (!GetFieldsByName(&res_oi, oi, field_name))
            return;
    }
    else if (type == CMQueryNodeValue::eObjects) {
        res_oi = m_Args[0]->GetObjects();
    }
    else if (type == CMQueryNodeValue::eRef) {
        x_GetObjectsFromRef(res_oi, 0);
    }
 
    if (res_oi.empty()) {
        return;
    }
 
    m_QualsChangedCount = s_RemoveFields(m_DataIter, res_oi);
 
    if (m_QualsChangedCount) {
        TChangedQuals report;
        report["removal of qualifiers"] = m_QualsChangedCount;
        CRef<IFunctionLog> fnc_log(new CGeneralFuncLog(report));
        x_LogChangedQuals(fnc_log);
    }
}
 
bool CMacroFunction_RemoveQual::x_ValidArguments() const
{
    if (m_Args.empty()) return false;
    bool first_ok = (m_Args[0]->IsString() || m_Args[0]->AreObjects() || m_Args[0]->IsRef());      
    return (m_Args.size() == 1 && first_ok);
}
 
Int4 CMacroFunction_RemoveQual::s_RemoveFields(CIRef<IMacroBioDataIter>& dataiter, CMQueryNodeValue::TObs& objs)
{
    if (objs.empty())
        return 0;
 
    Int4 quals_changed = 0;
    CObjectInfo oi = dataiter->GetEditedObject();
 
    // special attention to gene qualifiers that are removed from gene Xrefs
    bool is_gene_suppressed_before = false;
    bool is_gene_suppressed_after = false;
    CConstRef<CObject> obj = dataiter->GetScopedObject().object;
    if (dynamic_cast<const CSeq_feat*>(obj.GetPointer())) {
        CSeq_feat* feat = CTypeConverter<CSeq_feat>::SafeCast(oi.GetObjectPtr());
        auto gene_xref = feat->GetGeneXref();
        is_gene_suppressed_before = gene_xref && gene_xref->IsSuppressed();
    }
 
    bool is_taxname = NMacroUtil::IsTaxname(objs.front());
    NON_CONST_ITERATE(CMQueryNodeValue::TObs, it, objs) {
        if (NStr::EqualNocase(it->parent.GetName(), "Name-std")) {
            CObjectInfoMI mem = it->parent.FindClassMember("first");
            if (mem.IsSet() && mem.GetMember() == it->field) {
                CName_std* std_name = CTypeConverter<CName_std>::SafeCast(it->parent.GetObjectPtr());
                NMacroUtil::RemoveFirstName(*std_name);
                quals_changed++;
            }
            else {
                if (RemoveFieldByName(*it)) {
                    quals_changed++;
                }
            }
        }
        else {
            if (RemoveFieldByName(*it)) {
                quals_changed++;
            }
        }
    }
 
    if (quals_changed) {
        if (is_taxname) {
            NMacroUtil::CleanupForTaxnameChange(oi);
        }
        CConstRef<CObject> obj = dataiter->GetScopedObject().object;
        CRef<CScope> scope = dataiter->GetScopedObject().scope;
 
        if (dynamic_cast<const CUser_object*>(obj.GetPointer())) {
            CUser_object* userobj = CTypeConverter<CUser_object>::SafeCast(oi.GetObjectPtr());
            if (userobj->IsSetData() && userobj->GetData().empty()) {
                dataiter->SetToDelete(true);
            }
            else if (userobj->GetType().IsStr() && NStr::EqualCase(userobj->GetType().GetStr(), "DBLink")) {
                EDIT_EACH_USERFIELD_ON_USEROBJECT(field_it, *userobj) {
                    CUser_field& field = **field_it;
                    if (field.IsSetData()) {
                        if ((field.GetData().IsStrs() && field.GetData().GetStrs().empty()) ||
                            (field.GetData().IsStr() && field.GetData().GetStr().empty())) {
                            ERASE_USERFIELD_ON_USEROBJECT(field_it, *userobj);
                        }
                    }
                }
            }
        }
        else if (dynamic_cast<const CSeqdesc*>(obj.GetPointer())) {
            CSeqdesc* desc = CTypeConverter<CSeqdesc>::SafeCast(oi.GetObjectPtr());
            if (desc->IsGenbank() && desc->GetGenbank().IsEmpty()) {
                dataiter->SetToDelete(true);
            }
        }
        else if (dynamic_cast<const CBioseq*>(obj.GetPointer())) {
            CBioseq* bseq = CTypeConverter<CBioseq>::SafeCast(oi.GetObjectPtr());
            NMacroUtil::RemoveEmptyDescriptors(*bseq);
        } else {
            CCleanup cleanup;
            if (dynamic_cast<const CSeq_feat*>(obj.GetPointer())) {
                CSeq_feat* seq_feat = CTypeConverter<CSeq_feat>::SafeCast(oi.GetObjectPtr());
                cleanup.BasicCleanup(*seq_feat);
                if (seq_feat->IsSetXref()) {
                    auto gene_xref = seq_feat->GetGeneXref();
                    if (gene_xref) {
                        is_gene_suppressed_after = gene_xref->IsSuppressed();
                        if (!is_gene_suppressed_before && is_gene_suppressed_after)
                            NMacroUtil::RemoveGeneXref(*seq_feat);
                    }
                }
            }
            else if (dynamic_cast<const CBioSource*>(obj.GetPointer())) {
                CBioSource* bsrc = CTypeConverter<CBioSource>::SafeCast(oi.GetObjectPtr());
                cleanup.BasicCleanup(*bsrc);
                if (bsrc->IsSetOrg() && bsrc->GetOrg().IsSetDb() && bsrc->GetOrg().GetDb().empty()) {
                    bsrc->SetOrg().ResetDb();
                }
            }
        }
 
        dataiter->SetModified();
    }
    return quals_changed;
}
 
 
// cleanup for biosource
static void s_ResetModSubsrcQuals(CBioSource& bsrc)
{
    if (bsrc.IsSetOrgMod()) {
        if (bsrc.GetOrg().GetOrgname().GetMod().empty()) {
            bsrc.SetOrg().SetOrgname().ResetMod();
        }
    }
 
    if (bsrc.IsSetSubtype()) {
        if (bsrc.GetSubtype().empty()) {
            bsrc.ResetSubtype();
        }
    }
}
 
///////////////////////////////////////////////////////////////////////////////
/// class CMacroFunction_RemoveModifier
/// o = Resolve(path_to_container) Where o.subtype = subtype;
/// RemoveModifier(o) - deleting subtype modifier from the list of modifiers
///
DEFINE_MACRO_FUNCNAME(CMacroFunction_RemoveModifier, "RemoveModifier")
 
void CMacroFunction_RemoveModifier::TheFunction()
{
    // objects to be removed:
    CMQueryNodeValue::TObs res_oi;
    x_GetObjectsFromRef(res_oi, 0);
    if (res_oi.empty()) {
        // nothing to delete
        return;
    }
 
    CConstRef<CObject> obj = m_DataIter->GetScopedObject().object;
    const CBioSource* c_bsrc = dynamic_cast<const CBioSource*>(obj.GetPointer());
    // the asn selector should be a biosource
    if (!c_bsrc) {
        return;
    }
 
    NON_CONST_ITERATE(CMQueryNodeValue::TObs, it, res_oi) {
        if (RemoveFieldByName(*it)) {
            m_QualsChangedCount++;
        }
    }
 
    if (m_QualsChangedCount) {
        CObjectInfo oi = m_DataIter->GetEditedObject();
        CBioSource* bsrc = CTypeConverter<CBioSource>::SafeCast(oi.GetObjectPtr());
        s_ResetModSubsrcQuals(*bsrc);
        m_DataIter->SetModified();
        
        TChangedQuals report;
        report["removing source modifiers"] = m_QualsChangedCount;
        CRef<IFunctionLog> fnc_log(new CGeneralFuncLog(report));
        x_LogChangedQuals(fnc_log);
    }
}
 
bool CMacroFunction_RemoveModifier::x_ValidArguments() const
{
    return (m_Args.size() == 1 && m_Args[0]->GetDataType() == CMQueryNodeValue::eRef);
}
 
 
///////////////////////////////////////////////////////////////////////////////
// class CMacroFunction_RemoveOutside
/// RemoveOutsideStringQual(field_name(str/obj), before_match(b), left_del(str), rmv_left(b), 
///                         after_match(b), right_del(str), rmv_right(b), case_insensitive(b), whole_word(b), update_mrna(b))
/// Last parameter is optional
///
DEFINE_MACRO_FUNCNAME(CMacroFunction_RemoveOutside, "RemoveOutsideStringQual")
 
void CMacroFunction_RemoveOutside::TheFunction()
{
    CObjectInfo oi = m_DataIter->GetEditedObject();
    CMQueryNodeValue::TObs res_oi;
    CMQueryNodeValue::EType type = m_Args[0]->GetDataType();
 
    if (type == CMQueryNodeValue::eString) {
        if (!GetFieldsByName(&res_oi, oi, m_Args[0]->GetString()))
            return;
    }
    else if (type == CMQueryNodeValue::eObjects) {
        res_oi = m_Args[0]->GetObjects();
    }
    else if (type == CMQueryNodeValue::eRef) {
        x_GetObjectsFromRef(res_oi, 0);
        NMacroUtil::SwapGbQualWithValues(res_oi);
    }
 
    if (res_oi.empty()) {
        return;
    }
 
 
    CRef<CRemoveTextOptions> options = x_GetRemoveTextOptions(1);
    x_RmvOutsideFields(res_oi, *options);
 
    if (m_QualsChangedCount) {
        NMacroUtil::CleanupForTaxnameChange(res_oi.front(), oi);
        m_DataIter->SetModified();
 
        CNcbiOstrstream log;
        log << m_DataIter->GetBestDescr() << ": removed text outside string in " << m_QualsChangedCount << " qualifiers";
 
        bool update_mrna = (m_Args.size() == 10) ? m_Args[9]->GetBool() : false;
        CConstRef<CObject> object = m_DataIter->GetScopedObject().object;
        const CSeq_feat* feat = dynamic_cast<const CSeq_feat*>(object.GetPointer());
        
        if (update_mrna && feat && feat->GetData().GetSubtype() == CSeqFeatData::eSubtype_prot) {
            string message;
            CRef<CScope> scope = m_DataIter->GetScopedObject().scope;
            CSeq_feat* edit_feat = CTypeConverter<CSeq_feat>::SafeCast(oi.GetObjectPtr());
            string prot_product = edit_feat->GetData().GetProt().GetName().front();
            CRef<CCmdComposite> cmd = UpdatemRNAProduct(prot_product, object, *scope);
            if (cmd) {
                m_DataIter->RunCommand(cmd, m_CmdComposite);
                log << ", applied " + prot_product + " to mRNA product name ";
            }
        }
        x_LogFunction(log);
    }
}
 
CRef<CRemoveTextOptions> CMacroFunction_RemoveOutside::x_GetRemoveTextOptions(size_t start_index) const
{
    CRemoveTextOptions::EMatchType before_match = CRemoveTextOptions::eNone;
    string left_del = m_Args[start_index + 1]->GetString();
    bool remove_before_match = false;
    if (m_Args[start_index]->GetBool()) {
        if (NStr::EqualCase(left_del, "eDigits")) {
            before_match = CRemoveTextOptions::eDigits;
            left_del = kEmptyStr;
        }
        else if (NStr::EqualCase(left_del, "eLetters")) {
            before_match = CRemoveTextOptions::eLetters;
            left_del = kEmptyStr;
        }
        else {
            before_match = CRemoveTextOptions::eText;
        }
        remove_before_match = m_Args[start_index + 2]->GetBool();
    }
    
 
    CRemoveTextOptions::EMatchType after_match = CRemoveTextOptions::eNone;
    string right_del = m_Args[start_index + 4]->GetString();
    bool remove_after_match = false;
    if (m_Args[start_index + 3]->GetBool()) {
        if (NStr::EqualCase(right_del, "eDigits")) {
            after_match = CRemoveTextOptions::eDigits;
            right_del = kEmptyStr;
        }
        else if (NStr::EqualCase(right_del, "eLetters")) {
            after_match = CRemoveTextOptions::eLetters;
            right_del = kEmptyStr;
        }
        else {
            after_match = CRemoveTextOptions::eText;
        }
        remove_after_match = m_Args[start_index + 5]->GetBool();
    }
    
    bool case_insensitive = m_Args[start_index + 6]->GetBool();
    bool whole_word = m_Args[start_index + 7]->GetBool();
 
    CRef<CRemoveTextOptions> options(new CRemoveTextOptions(before_match, left_del, remove_before_match,
                                                            after_match, right_del, remove_after_match,
                                                            case_insensitive, whole_word));
    return options;
}
 
void CMacroFunction_RemoveOutside::x_RmvOutsideFields(CMQueryNodeValue::TObs& resolved_objs, const CRemoveTextOptions& options)
{
    for (auto& it : resolved_objs) {
        CMQueryNodeValue::TObs objs;
        NMacroUtil::GetPrimitiveObjectInfos(objs, it);
        for (auto& iter : objs) {
            CObjectInfo obj_oi = iter.field;
            if (obj_oi.GetPrimitiveValueType() == ePrimitiveValueString) {
                string value = obj_oi.GetPrimitiveValueString();
                if (options.EditText(value)) {
                    SetQualStringValue(obj_oi, value);
                }
            }
            else if (obj_oi.GetPrimitiveValueType() == ePrimitiveValueEnum) {
                string value;
                try {
                    value = obj_oi.GetPrimitiveValueString();
                }
                catch (const CException&) {
                    value = NStr::NumericToString(obj_oi.GetPrimitiveValueInt4());
                }
                if (options.EditText(value)) {
                    try {
                        obj_oi.SetPrimitiveValueString(value);
                        m_QualsChangedCount++;
                    }
                    catch (const CException&) {
                        // if this fails, try to convert the string to int and assign again
                        try {
                            NStr::TruncateSpacesInPlace(value);
                            obj_oi.SetPrimitiveValueInt4(NStr::StringToLong(value));
                            m_QualsChangedCount++;
                        }
                        catch (const CException&) {}
                    }
                }
            }
        }
    }
}
 
bool CMacroFunction_RemoveOutside::x_ValidArguments() const
{
    if (m_Args.size() != 9 && m_Args.size() != 10)
        return false;
 
    CMQueryNodeValue::EType type = m_Args[0]->GetDataType();
    bool first_ok = (type == CMQueryNodeValue::eString) || (type == CMQueryNodeValue::eObjects) || (type == CMQueryNodeValue::eRef);
    if (!first_ok)
        return false;
 
    return x_CheckArguments(1);
}
 
bool CMacroFunction_RemoveOutside::x_CheckArguments(size_t index) const
{
    if (m_Args[index]->GetDataType() != CMQueryNodeValue::eBool
        || m_Args[++index]->GetDataType() != CMQueryNodeValue::eString
        || m_Args[++index]->GetDataType() != CMQueryNodeValue::eBool) {
        return false;
    }
    if (m_Args[++index]->GetDataType() != CMQueryNodeValue::eBool
        || m_Args[++index]->GetDataType() != CMQueryNodeValue::eString
        || m_Args[++index]->GetDataType() != CMQueryNodeValue::eBool) {
        return false;
    }
    ++index;
    for (size_t i = index; i < m_Args.size(); ++i) {
        if (m_Args[i]->GetDataType() != CMQueryNodeValue::eBool)
            return false;
    }
    return true;
}
 
///////////////////////////////////////////////////////////////////////////////
/// class CMacroFunction_SetStringQual
/// Expected Syntax:
/// SetStringQual(field_name, newValue, existingtext_option, delimiter, remove_blank)
/// The last two parameters are optional. 
/// Empty new values don't have any effect by default. If remove_blank is True,
/// the existing field is removed.
///
DEFINE_MACRO_FUNCNAME(CMacroFunction_SetStringQual, "SetStringQual")
 
void CMacroFunction_SetStringQual::TheFunction()
{
    size_t index = 1;
    string newValue = NMacroUtil::GetStringValue(m_Args[index]);
    const string& action_type = m_Args[++index]->GetString();
    string delimiter;
    bool remove_field = false;
    x_GetOptionalArgs(delimiter, remove_field, index);
 
    CObjectInfo oi = m_DataIter->GetEditedObject();
    CMQueryNodeValue::TObs res_oi;
    CMQueryNodeValue::EType type = m_Args[0]->GetDataType();
 
    if (type == CMQueryNodeValue::eString) {
        if (remove_field && newValue.empty()) {
            if (!GetFieldsByName(&res_oi, oi, m_Args[0]->GetString()))
                return;
        }
        else if (!newValue.empty() && !SetFieldsByName(&res_oi, oi, m_Args[0]->GetString())) {
            return;
        }
    }
    else if (type == CMQueryNodeValue::eObjects) {
        res_oi = m_Args[0]->GetObjects();
    }
    else if (type == CMQueryNodeValue::eRef) {
        x_GetObjectsFromRef(res_oi, 0);
    }
 
    if (res_oi.empty()) {
        return;
    }
 
    if (!newValue.empty()) {
        vector<string> new_values;
        edit::EExistingText existing_text = NMacroUtil::ActionTypeToExistingTextOption(action_type, delimiter);
        x_SetFields(res_oi, newValue, existing_text, new_values);
 
        m_Result->SetBool(false);
        if (m_QualsChangedCount) {
            NMacroUtil::CleanupForTaxnameChange(res_oi.front(), oi);
            m_DataIter->SetModified();
            m_Result->SetBool(true);
 
            CNcbiOstrstream log;
            for (size_t i = 0; i < new_values.size(); ++i) {
                log << m_DataIter->GetBestDescr() << ": set '" << new_values[i] << "' as a new value\n";
            }
            x_LogFunction(log);
        }
    }
    else if (remove_field) {
        m_QualsChangedCount = CMacroFunction_RemoveQual::s_RemoveFields(m_DataIter, res_oi);
        if (m_QualsChangedCount) {
            CNcbiOstrstream log;
            log << m_DataIter->GetBestDescr() << ": removed " << m_QualsChangedCount << " qualifiers";
            x_LogFunction(log);
        }
    }
}
 
bool CMacroFunction_SetStringQual::x_ValidArguments() const
{
    // can accept as its first parameter: objects, string or reference
    size_t arg_nr = m_Args.size();
    if (arg_nr < 3 && arg_nr > 5) {
        return false;
    }
 
    size_t index = 0;
    bool first_ok = m_Args[index]->IsString() || m_Args[index]->AreObjects() || m_Args[index]->IsRef();
    if (!first_ok) return false;
 
    ++index;
    NMacroUtil::GetPrimitiveFromRef(m_Args[index].GetNCObject());
    bool second_ok = m_Args[index]->IsString() || m_Args[index]->IsInt() || m_Args[index]->IsDouble();
    if (!second_ok) return false;
 
    if (!m_Args[++index]->IsString()) return false;
 
    if (arg_nr > 3 && (!m_Args[++index]->IsString() && !m_Args[index]->IsBool())) return false;
 
    if (arg_nr > 4 && !m_Args[++index]->IsBool()) return false;
 
    return true;
}
 
void CMacroFunction_SetStringQual::x_SetFields(CMQueryNodeValue::TObs& objs, const string& newValue,
    edit::EExistingText existing_text, vector<string>& new_values)
{
    for (auto& it : objs) {
        CObjectInfo obj = it.field;
        switch (obj.GetTypeFamily()) {
        case eTypeFamilyPrimitive: // works when the field exists or does not
            if (existing_text != edit::eExistingText_add_qual) {
                x_SetNewPrimitiveValue(obj, newValue, existing_text, new_values);
            }
            else if (it.parent.GetTypeFamily() == eTypeFamilyContainer) {
                // add new element to the container
                CObjectInfo new_oi(it.parent.AddNewElement());
                SetQualStringValue(new_oi, newValue);
                new_values.push_back(newValue);
            }
            break;
        case eTypeFamilyPointer:  // works only when the field exists
            if (obj.GetPointedObject().GetTypeFamily() == eTypeFamilyPrimitive) {
                CObjectInfo oi_ptr(obj.GetPointedObject());
                x_SetNewPrimitiveValue(oi_ptr, newValue, existing_text, new_values);
            }
            break;
        case eTypeFamilyContainer: { // works when the field exists or does not
            CMQueryNodeValue::TObs objs;
            NMacroUtil::GetPrimitiveObjectInfos(objs, it);
 
            if (objs.empty() || existing_text == edit::eExistingText_add_qual) {
                if (obj.GetElementType().GetTypeFamily() == eTypeFamilyPointer) {
                    CObjectInfo new_oi(obj.AddNewPointedElement());
                    SetQualStringValue(new_oi, newValue);
                    new_values.push_back(newValue);
                }
                else {
                    CObjectInfo new_oi(obj.AddNewElement());
                    SetQualStringValue(new_oi, newValue);
                    new_values.push_back(newValue);
                }
            }
            else {
                if (existing_text == edit::eExistingText_replace_old) {
                    if (objs.size() > 1) {
                        // keep the first element, update it and delete the rest from the container
                        CObjectInfoEI first = obj.BeginElements();
                        CObjectInfoEI e = first;
                        ++e;
                        while (e) {
                            e.Erase();
                            e = first;
                            ++e;
                        }
                    }
                    SetQualStringValue(objs.front().field, newValue);
                    new_values.push_back(newValue);
                }
                else {
                    // there are multiple ones, and all of them needs to be updated
                    NON_CONST_ITERATE(CMQueryNodeValue::TObs, iter, objs) {
                        x_SetNewPrimitiveValue(iter->field, newValue, existing_text, new_values);
                    }
                }
            }
            break;
        }
        default:
            break;
        }
    }
}
 
void CMacroFunction_SetStringQual::x_SetNewPrimitiveValue(CObjectInfo& oi,
    const string& newValue, edit::EExistingText existing_text, vector<string>& new_values)
{
    _ASSERT(oi.GetTypeFamily() == eTypeFamilyPrimitive);
 
    if (oi.GetPrimitiveValueType() == ePrimitiveValueString ||
        oi.GetPrimitiveValueType() == ePrimitiveValueEnum) {
 
        string orig_value = oi.GetPrimitiveValueString();
        if (edit::AddValueToString(orig_value, newValue, existing_text)) {
            if (SetQualStringValue(oi, orig_value)) {
                new_values.push_back(orig_value);
            }
        }
    }
}
 
///////////////////////////////////////////////////////////////////////////////
///class CMacroFunction_SetRnaProduct
/// SetRnaProduct(new_value, existing_text_opt, delimiter, remove_blank)
///
DEFINE_MACRO_FUNCNAME(CMacroFunction_SetRnaProduct, "SetRnaProduct")
void CMacroFunction_SetRnaProduct::TheFunction()
{
    CConstRef<CObject> object = m_DataIter->GetScopedObject().object;
    const CSeq_feat* seq_feat = dynamic_cast<const CSeq_feat*>(object.GetPointer());
    CRef<CScope> scope = m_DataIter->GetScopedObject().scope;
    if (!seq_feat || !seq_feat->GetData().IsRna() || !scope)
        return;
 
    size_t index = 0;
    string newValue = NMacroUtil::GetStringValue(m_Args[index]);
    const string& action_type = m_Args[++index]->GetString();
    string delimiter;
    bool remove_field = false;
    x_GetOptionalArgs(delimiter, remove_field, index);
 
    CObjectInfo oi = m_DataIter->GetEditedObject();
    CSeq_feat* edit_feat = CTypeConverter<CSeq_feat>::SafeCast(oi.GetObjectPtr());
    edit::EExistingText existing_text = NMacroUtil::ActionTypeToExistingTextOption(action_type, delimiter);
 
    CRNA_ref& rna_ref = edit_feat->SetData().SetRna();
    string orig_value = rna_ref.GetRnaProductName();
 
    if (!newValue.empty()) {
        string remainder;
        if (edit::AddValueToString(orig_value, newValue, existing_text)) {
            rna_ref.SetRnaProductName(orig_value, remainder);
            m_QualsChangedCount++;
            if (!remainder.empty()) {
                if (edit_feat->IsSetComment()) {
                    existing_text = edit::eExistingText_append_semi;
                    edit::AddValueToString(edit_feat->SetComment(), remainder, existing_text);
                }
            }
        }
    }
    else if (remove_field) {
        string remainder;
        rna_ref.SetRnaProductName(kEmptyStr, remainder);
        m_QualsChangedCount++;
    }
    
    if (m_QualsChangedCount) {
        m_DataIter->SetModified();
 
        CNcbiOstrstream log;
        log << m_DataIter->GetBestDescr();
        if (newValue.empty() && remove_field) {
            log << ": removed rna product";
        }
        else {
            log << ": set '" << orig_value << "' as new rna product value";
        }
        x_LogFunction(log);
    }
}
 
bool CMacroFunction_SetRnaProduct::x_ValidArguments() const
{
    // can accept as its first parameter: objects, string or reference
    size_t arg_nr = m_Args.size();
    if (arg_nr < 2 && arg_nr > 4) {
        return false;
    }
 
    size_t index = 0;
    NMacroUtil::GetPrimitiveFromRef(m_Args[index].GetNCObject());
    bool first_ok = m_Args[index]->IsString() || m_Args[index]->IsInt() || m_Args[index]->IsDouble();
    if (!first_ok) return false;
 
    if (!m_Args[++index]->IsString()) return false;
    if (arg_nr > 2 && (!m_Args[++index]->IsString() && !m_Args[index]->IsBool())) return false;
    if (arg_nr > 3 && !m_Args[++index]->IsBool()) return false;
 
    return true;
}
 
 
///////////////////////////////////////////////////////////////////////////////
/// class CMacroFunction_GetRnaProduct
/// GetRnaProduct()
///
DEFINE_MACRO_FUNCNAME(CMacroFunction_GetRnaProduct, "GETRNAPRODUCT")
 
void CMacroFunction_GetRnaProduct::TheFunction()
{
    CConstRef<CObject> obj = m_DataIter->GetScopedObject().object;
    const CSeq_feat* feat = dynamic_cast<const CSeq_feat*>(obj.GetPointer());
    CRef<CScope> scope = m_DataIter->GetScopedObject().scope;
    m_Result->SetNotSet();
    if (!feat || !scope || !(feat->IsSetData() && feat->GetData().IsRna()))
        return;
 
    const CRNA_ref& rna_ref = feat->GetData().GetRna();
    string value = rna_ref.GetRnaProductName();
 
    if (m_Nested == eNotNested) { // return a string
        m_Result->SetString(value);
    }
    else {
        // return a reference to a CMQueryNodeValue of type string
        CRef<CMQueryNodeValue> new_node(new CMQueryNodeValue);
        new_node->SetString(value);
        m_Result->SetRef(new_node);
    }
}
 
bool CMacroFunction_GetRnaProduct::x_ValidArguments() const
{
    return (m_Args.empty());
}
///////////////////////////////////////////////////////////////////////////////
/// class CMacroFunction_RemoveRnaProduct
/// RemoveRnaProduct()
///
DEFINE_MACRO_FUNCNAME(CMacroFunction_RemoveRnaProduct, "RemoveRnaProduct")
void CMacroFunction_RemoveRnaProduct::TheFunction()
{
    CObjectInfo oi = m_DataIter->GetEditedObject();
    CSeq_feat* edit_feat = CTypeConverter<CSeq_feat>::SafeCast(oi.GetObjectPtr());
    CRef<CScope> scope = m_DataIter->GetScopedObject().scope;
    if (!edit_feat || !edit_feat->GetData().IsRna() || !scope)
        return;
 
    CRNA_ref& rna_ref = edit_feat->SetData().SetRna();
    string remainder;
    rna_ref.SetRnaProductName(kEmptyStr, remainder);
 
    m_DataIter->SetModified();
    m_QualsChangedCount++;
 
    TChangedQuals report;
    report["removing RNA product"] = m_QualsChangedCount;
    CRef<IFunctionLog> fnc_log(new CGeneralFuncLog(report));
    x_LogChangedQuals(fnc_log);
}
 
bool CMacroFunction_RemoveRnaProduct::x_ValidArguments() const
{
    return (m_Args.empty());
}
 
 
///////////////////////////////////////////////////////////////////////////////
/// class CMacroFunction_EditStringQual
/// Usage: EditStringQual(field_name|rt_obj, find_text, repl_text, location, case_sensitive, is_regex)
///
DEFINE_MACRO_FUNCNAME(CMacroFunction_EditStringQual, "EditStringQual")
 
void CMacroFunction_EditStringQual::TheFunction()
{
    size_t index = 1;
    const string& find_txt = NMacroUtil::GetStringValue(m_Args[index]);
    string repl_txt = NMacroUtil::GetStringValue(m_Args[++index]);
    const string& location = m_Args[++index]->GetString();
    bool case_sensitive = m_Args[++index]->GetBool();
    bool is_regex = (++index < m_Args.size()) ? m_Args[index]->GetBool() : false;
 
    m_Result->SetBool(false);  // assume, that no change has been made
 
    CObjectInfo oi = m_DataIter->GetEditedObject();
    CMQueryNodeValue::TObs res_oi;
    CMQueryNodeValue::EType type = m_Args[0]->GetDataType();
 
    if (type == CMQueryNodeValue::eString) {
        if (!GetFieldsByName(&res_oi, oi, m_Args[0]->GetString()))
            return;
    }
    else if (type == CMQueryNodeValue::eObjects) {
        res_oi = m_Args[0]->GetObjects();
    }
    else if (type == CMQueryNodeValue::eRef) {
        x_GetObjectsFromRef(res_oi, 0);
        NMacroUtil::SwapGbQualWithValues(res_oi);
    }
 
    if (res_oi.empty()) {
        return;
    }
 
    x_EditFields(res_oi, find_txt, repl_txt, s_GetLocFromName(location), case_sensitive, is_regex);
    if (m_QualsChangedCount) {
        NMacroUtil::CleanupForTaxnameChange(res_oi.front(), oi);
 
        m_DataIter->SetModified();
        m_Result->SetBool(true);  // the field has been modified
 
        CNcbiOstrstream log;
        log << m_DataIter->GetBestDescr() << ": edited " << m_QualsChangedCount << " qualifiers, replaced " << find_txt;
        if (NStr::IsBlank(repl_txt)) {
            repl_txt.assign("''");
        }
        log << " with " << repl_txt;
        x_LogFunction(log);
    }
}
 
bool CMacroFunction_EditStringQual::s_EditText(string& str, const string& find,
    const string& replace, ESearchLoc loc, bool case_sensitive, bool is_regex)
{
    bool rval = false;
    if (is_regex)
    {
        CRegexp::TCompile options = CRegexp::fCompile_ignore_case;
        if (case_sensitive)
        {
            options = CRegexp::fCompile_default;
        }
 
        CRegexpUtil replacer(str);
        size_t num = replacer.Replace(find, replace, options, CRegexp::fMatch_default, 0);
        if (num > 0)
        {
            str = replacer.GetResult();
            rval = true;
        }
    }
    else
    {
        SIZE_TYPE pos = NPOS;
        if (loc == eAnywhere) {
            pos = NStr::Find(str, find, (case_sensitive) ? NStr::eCase : NStr::eNocase);
            while (pos != NPOS) {
                str = str.substr(0, pos) + replace + str.substr(pos + find.length());
                if (case_sensitive) {
                    pos = NStr::FindCase(str, find, pos + replace.length());
                }
                else {
                    pos = NStr::FindNoCase(str, find, pos + replace.length());
                }
                rval = true;
            }
        }
        else {
            pos = NPOS;
            if (loc == eBeginning) {
                if (NStr::StartsWith(str, find, (case_sensitive) ? NStr::eCase : NStr::eNocase)) {
                    pos = 0;
                }
            }
            else if (loc == eEnd) {
                if (NStr::EndsWith(str, find, (case_sensitive) ? NStr::eCase : NStr::eNocase)) {
                    pos = str.length() - find.length();
                }
            }
            if (pos != NPOS) {
                str = str.substr(0, pos) + replace + str.substr(pos + find.length());
                rval = true;
            }
        }
    }
    NStr::TruncateSpacesInPlace(str);
 
    return rval;
}
 
void CMacroFunction_EditStringQual::x_EditFields(
    CMQueryNodeValue::TObs& resolved_objs, 
    const string& find_txt, 
    const string& repl_txt, 
    ESearchLoc loc,
    bool case_sensitive,
    bool is_regex)
{
    for (auto& it : resolved_objs) {
        CMQueryNodeValue::TObs objs;
        NMacroUtil::GetPrimitiveObjectInfos(objs, it);
        for(auto& iter : objs) {
            CObjectInfo oi = iter.field;
            if (oi.GetPrimitiveValueType() == ePrimitiveValueString) {
                string value = oi.GetPrimitiveValueString();
                if (s_EditText(value, find_txt, repl_txt, loc, case_sensitive, is_regex)) {
                    if (NStr::EqualNocase(iter.parent.GetName(), "Name-std")) {
                        CObjectInfoMI mem = iter.parent.FindClassMember("first");
                        if (mem.IsSet() && mem.GetMember() == oi) {
                            CName_std* std_name = CTypeConverter<CName_std>::SafeCast(iter.parent.GetObjectPtr());
                            NMacroUtil::ApplyFirstName(*std_name, value, edit::eExistingText_replace_old);
                            m_QualsChangedCount++;
                        }
                        SetQualStringValue(oi, value);
                    }
                    else {
                        SetQualStringValue(oi, value);
                    }
                }
            }
            else if (oi.GetPrimitiveValueType() == ePrimitiveValueInteger) {
                Int8 value = oi.GetPrimitiveValueInt8();
                string orig_val = NStr::Int8ToString(value);
                if (s_EditText(orig_val, find_txt, repl_txt, loc, case_sensitive, is_regex)) {
                    NStr::TruncateSpacesInPlace(orig_val);
                    oi.SetPrimitiveValueInt8(NStr::StringToInt8(orig_val));
                    m_QualsChangedCount++;
                }
            }
 
            else if (oi.GetPrimitiveValueType() == ePrimitiveValueEnum) {
                string value;
                try {
                    value = oi.GetPrimitiveValueString();
                }
                catch (const CException&) {
                    value = NStr::NumericToString(oi.GetPrimitiveValueInt4());
                }
                if (s_EditText(value, find_txt, repl_txt, loc, case_sensitive, is_regex)) {
                    try {
                        oi.SetPrimitiveValueString(value);
                        m_QualsChangedCount++;
                    }
                    catch (const CException&) {
                        // if this fails, try to convert the string to int and assign again
                        try {
                            oi.SetPrimitiveValueInt4(NStr::StringToLong(value));
                            m_QualsChangedCount++;
                        }
                        catch (const CException&) {}
                    }
                }
            }
        }
    }
}
 
CMacroFunction_EditStringQual::ESearchLoc CMacroFunction_EditStringQual::s_GetLocFromName(const string& name)
{
    ESearchLoc loc = eAnywhere;  // default search location
    if (NStr::EqualNocase(name, "at the beginning")) {
        loc = eBeginning;
    }
    else if (NStr::EqualNocase(name, "at the end")) {
        loc = eEnd;
    }
    return loc;
}
 
bool CMacroFunction_EditStringQual::x_ValidArguments() const
{
    if (m_Args.size() != 5 && m_Args.size() != 6)
        return false;
 
    bool first_ok = m_Args[0]->IsString() || m_Args[0]->AreObjects() || m_Args[0]->IsRef();
    if (!first_ok) {
        return false;
    }
 
    for (size_t index = 1; index < 3; index++) {
        if (!m_Args[index]->IsString() && !m_Args[index]->IsInt()) {
            return false;
        }
    }
    if (m_Args.size() == 6) {
        if (!m_Args.back()->IsBool())
            return false;
    }
    return (m_Args[3]->IsString() && m_Args[4]->IsBool());
}
 
 
///////////////////////////////////////////////////////////////////////////////
namespace {
 
    vector<string> kSatelliteTypes = { "satellite", "microsatellite", "minisatellite" };
    vector<string> kMobileETypeTypes = {
        "insertion sequence",
        "integron",
        "LINE",
        "MITE",
        "non-LTR retrotransposon",
        "other",
        "P-element",
        "retrotransposon",
        "SINE",
        "superintegron",
        "transposable element",
        "transposon"
    };
    bool GetBioSourceDestObjects(CObjectInfo& oi, const string& field_name, CMQueryNodeValue::TObs& dest_objs);
 
    bool SetFeatDestinationField(CRef<CSeq_feat> feat, const string& field_name, CMQueryNodeValue::TObs& result);
 
    bool IstRNAProductField(const CSeq_feat& feat, const string& field_name);
 
    bool GetDestinationObjects(CConstRef<CObject> object, CObjectInfo& oi, const string& field_name, CMQueryNodeValue::TObs& result)
    {
        const CBioSource* bsrc = dynamic_cast<const CBioSource*>(object.GetPointer());
        const CSeq_feat* seq_feat = dynamic_cast<const CSeq_feat*>(object.GetPointer());
        if (bsrc) {
            return GetBioSourceDestObjects(oi, field_name, result);
        }
        if (seq_feat) {
            CSeq_feat* feat = CTypeConverter<CSeq_feat>::SafeCast(oi.GetObjectPtr());
            return SetFeatDestinationField(Ref(feat), field_name, result);
        }
 
        return SetFieldsByName(&result, oi, field_name);
    }
 
    bool GetBioSourceDestObjects(CObjectInfo& oi, const string& field_name, CMQueryNodeValue::TObs& dest_objs)
    {
        if (field_name.empty())
            return false;
 
        size_t orig_size = dest_objs.size();
        // check if the field denotes an orgmod or a subsource modifier
        if (NMacroUtil::IsBiosourceModifier(field_name)) {
 
            // extract it into a function that adds these modifier fields
            CBioSource* bsrc = CTypeConverter<CBioSource>::SafeCast(oi.GetObjectPtr());
            if (!bsrc)
                return false;
            // check if it's a subsource modifier
            if (CSubSource::IsValidSubtypeName(field_name, CSubSource::eVocabulary_insdc)) {
                CSubSource::TSubtype st = CSubSource::GetSubtypeValue(field_name, CSubSource::eVocabulary_insdc);
 
                EDIT_EACH_SUBSOURCE_ON_BIOSOURCE(subsrc, *bsrc) {
                    if ((*subsrc)->IsSetSubtype() && (*subsrc)->GetSubtype() == st) {
                        CObjectInfo subsrc_oi((*subsrc).GetPointer(), (*subsrc)->GetTypeInfo());
                        CObjectInfo name_oi = subsrc_oi.FindClassMember("name").GetMember();
                        dest_objs.push_back(CMQueryNodeValue::SResolvedField(subsrc_oi, name_oi));
                    }
                }
 
                if (dest_objs.empty()) {
                    CRef<CSubSource> sub_src(new CSubSource());
                    sub_src->SetSubtype(st);
                    bsrc->SetSubtype().push_back(sub_src);
                    CObjectInfo subsrc_oi(sub_src.GetPointer(), sub_src->GetTypeInfo());
                    CObjectInfo name_oi = subsrc_oi.FindClassMember("name").GetMember();
                    dest_objs.push_back(CMQueryNodeValue::SResolvedField(subsrc_oi, name_oi));
                }
                // check if it's an orgmod modifier
            }
            else if (COrgMod::IsValidSubtypeName(field_name, COrgMod::eVocabulary_insdc)) {
                COrgMod::TSubtype st = COrgMod::GetSubtypeValue(field_name, COrgMod::eVocabulary_insdc);
 
                EDIT_EACH_ORGMOD_ON_BIOSOURCE(orgmod, *bsrc) {
                    if ((*orgmod)->IsSetSubtype() && (*orgmod)->GetSubtype() == st) {
                        CObjectInfo orgmod_oi((*orgmod).GetPointer(), (*orgmod)->GetTypeInfo());
                        CObjectInfo subname_oi = orgmod_oi.FindClassMember("subname").GetMember();
                        dest_objs.push_back(CMQueryNodeValue::SResolvedField(orgmod_oi, subname_oi));
                    }
                }
 
                if (dest_objs.empty()) {
                    CRef<COrgMod> orgmod(new COrgMod());
                    orgmod->SetSubtype(st);
                    orgmod->SetSubname(kEmptyStr);
                    if (!bsrc->IsSetOrgname()) {
                        CRef<COrgName> orgname(new COrgName());
                        orgname->SetMod().push_back(orgmod);
                        bsrc->SetOrg().SetOrgname(*orgname);
                    }
                    else {
                        bsrc->SetOrg().SetOrgname().SetMod().push_back(orgmod);
                    }
                    CObjectInfo orgmod_oi(orgmod.GetPointer(), orgmod->GetTypeInfo());
                    CObjectInfo subname_oi = orgmod_oi.FindClassMember("subname").GetMember();
                    dest_objs.push_back(CMQueryNodeValue::SResolvedField(orgmod_oi, subname_oi));
                }
            }
        }
        else {
            SetFieldsByName(&dest_objs, oi, field_name);
        }
 
        return dest_objs.size() - orig_size > 0;
    }
 
        // feature related functions
    bool SetFeatDestinationField(CRef<CSeq_feat> feat, const string& field_name, CMQueryNodeValue::TObs& result)
    {
        if (feat.IsNull() || field_name.empty())
            return false;
 
        CObjectInfo dest_oi(feat.GetPointer(), feat->GetThisTypeInfo());
        if (SetFieldsByName(&result, dest_oi, field_name)) {
            return true;
        }
 
        size_t orig_size = result.size();
        string field = field_name;
        if (NMacroUtil::IsSatelliteSubfield(field_name)) {
            field = "satellite";
        }
        else if (NMacroUtil::StringsAreEquivalent(field_name, "mobile-element-type-type")) {
            field = "mobile-element-type";
        }
 
        // field_name is a possible GB qualifier
        EDIT_EACH_GBQUAL_ON_SEQFEAT(gbq_it, *feat) {
            if ((*gbq_it)->IsSetQual() && NStr::EqualNocase((*gbq_it)->GetQual(), field)) {
                CObjectInfo gbqual_oi((*gbq_it).GetPointer(), (*gbq_it)->GetTypeInfo());
                CObjectInfo val_oi = gbqual_oi.FindClassMember("val").GetMember();
                result.push_back(CMQueryNodeValue::SResolvedField(gbqual_oi, val_oi));
            }
        }
 
        if (result.empty()) {
            if (NStr::EndsWith(field_name, "::product"))
                return true; // returning true but the output argument results is empty!
 
            CRef<CGb_qual> new_gbqual(new CGb_qual(field, kEmptyStr));
            feat->SetQual().push_back(new_gbqual);
            CObjectInfo gbqual_oi(new_gbqual.GetPointer(), new_gbqual->GetTypeInfo());
            CObjectInfo val_oi = gbqual_oi.FindClassMember("val").GetMember();
            result.push_back(CMQueryNodeValue::SResolvedField(gbqual_oi, val_oi));
        }
 
        return result.size() - orig_size > 0;
    }
 
    bool GetFeatDestinationField(CRef<CSeq_feat> feat, const string& field_name, CMQueryNodeValue::TObs& result)
    {
        if (field_name.empty())
            return false;
 
        CObjectInfo dest_oi(feat.GetPointer(), feat->GetThisTypeInfo());
        if (GetFieldsByName(&result, dest_oi, field_name)) {
            return true;
        }
 
        string field = field_name;
        if (NMacroUtil::IsSatelliteSubfield(field_name)) {
            field = "satellite";
        }
        else if (NMacroUtil::StringsAreEquivalent(field_name, "mobile-element-type-type")) {
            field = "mobile-element-type";
        }
 
        // field_name is a possible GB qualifier
        EDIT_EACH_GBQUAL_ON_SEQFEAT(gbq_it, *feat) {
            if ((*gbq_it)->IsSetQual() && NStr::EqualNocase((*gbq_it)->GetQual(), field)) {
                CObjectInfo gbqual_oi((*gbq_it).GetPointer(), (*gbq_it)->GetTypeInfo());
                CObjectInfo val_oi = gbqual_oi.FindClassMember("val").GetMember();
                result.push_back(CMQueryNodeValue::SResolvedField(gbqual_oi, val_oi));
            }
        }
        return (!result.empty());
    }
 
    bool IstRNAProductField(const CSeq_feat& feat, const string& field_name)
    {
        return (feat.IsSetData() && 
            feat.GetData().GetSubtype() == CSeqFeatData::eSubtype_tRNA &&
            (NStr::EqualNocase(field_name, "tRNA::product") || NStr::EqualNocase(field_name, "any::product")));
    }
 
    CRef<CSeq_feat> CreateNewGene(const CSeq_feat& src_feat, CScope& scope);
 
    CRef<CSeq_feat> CreateNewProtein(const CSeq_feat& src_feat, CScope& scope);
 
    CRef<CSeq_feat> CreateNewRelatedFeature(const CSeq_feat& src_feat, const string& field_name, CScope& scope)
    {
        if (NStr::EndsWith(field_name, "locus")) {
            return CreateNewGene(src_feat, scope);
        }
        else if (NMacroUtil::StringsAreEquivalent(field_name, "protein name") ||
            NMacroUtil::StringsAreEquivalent(field_name, "data.prot.name") ||
            NMacroUtil::StringsAreEquivalent(field_name, "data.prot.ec")) {
            return CreateNewProtein(src_feat, scope);
        }
        return CRef<CSeq_feat>(nullptr);
    }
 
    CRef<CSeq_feat> CreateNewGene(const CSeq_feat& src_feat, CScope& scope)
    {
        if (!src_feat.IsSetData() || !src_feat.IsSetLocation())
            return CRef<CSeq_feat>(nullptr);
 
        CRef<CSeq_feat> new_gene(new CSeq_feat);
        CConstRef<CSeq_loc> loc(&src_feat.GetLocation());
 
        CConstRef<CSeq_feat> cds_feat;
        if (src_feat.GetData().IsProt()) {
            CBioseq_Handle product = scope.GetBioseqHandle(src_feat.GetLocation());
            if (product) {
                cds_feat = sequence::GetCDSForProduct(product);
            }
        }
        else if (src_feat.GetData().IsCdregion()) {
            cds_feat = ConstRef(&src_feat);
        }
 
        if (cds_feat) {
            CSeq_feat_Handle mrna = feature::GetBestMrnaForCds(scope.GetSeq_featHandle(*cds_feat));
            if (mrna) {
                loc = Ref(&mrna.GetLocation());
            }
            else {
                loc = Ref(&cds_feat->GetLocation());
            }
        }
 
        CRef<CSeq_loc> gene_loc = sequence::Seq_loc_Merge(*loc, CSeq_loc::fMerge_SingleRange, &scope);
        new_gene->SetLocation(*gene_loc);
        new_gene->SetPartial(new_gene->GetLocation().IsPartialStart(eExtreme_Biological) || new_gene->GetLocation().IsPartialStop(eExtreme_Biological));
        return new_gene;
    }
 
    CRef<CSeq_feat> CreateNewProtein(const CSeq_feat& src_feat, CScope& scope)
    {
        if (!src_feat.IsSetData() || !src_feat.IsSetLocation())
            return CRef<CSeq_feat>(nullptr);
 
        CRef<CSeq_feat> prot(new CSeq_feat);
        if (src_feat.GetData().IsCdregion()) {
            if (src_feat.IsSetProduct()) {
                CBioseq_Handle product = scope.GetBioseqHandle(src_feat.GetProduct());
                if (product && !CFeat_CI(product, CSeqFeatData::eSubtype_prot)) {
                    SetProteinFeature(*prot, product, src_feat);
                }
            }
        }
        else if (src_feat.GetData().GetSubtype() == CSeqFeatData::eSubtype_mRNA) {
            CSeq_feat_Handle cds = feature::GetBestCdsForMrna(scope.GetSeq_featHandle(src_feat));
            if (cds && cds.IsSetProduct()) {
                CBioseq_Handle product = scope.GetBioseqHandle(cds.GetProduct());
                if (product && !CFeat_CI(product, CSeqFeatData::eSubtype_prot)) {
                    SetProteinFeature(*prot, product, *cds.GetOriginalSeq_feat());
                }
            }
        }
        else if (src_feat.GetData().IsGene()) {
            list<CMappedFeat> cds_feats;
            feature::GetCdssForGene(scope.GetSeq_featHandle(src_feat), cds_feats);
            for (auto& it : cds_feats) {
                if (it.IsSetProduct()) {
                    CBioseq_Handle product = scope.GetBioseqHandle(it.GetProduct());
                    if (product && !CFeat_CI(product, CSeqFeatData::eSubtype_prot)) {
                        SetProteinFeature(*prot, product, src_feat);
                        continue;
                    }
                }
            }
        }
        else if (src_feat.GetData().GetSubtype() == CSeqFeatData::eSubtype_mat_peptide_aa) {
            CBioseq_Handle product = scope.GetBioseqHandle(src_feat.GetLocation());
            if (product && !CFeat_CI(product, CSeqFeatData::eSubtype_prot)) {
                CConstRef<CSeq_feat> cds_feat(sequence::GetCDSForProduct(product));
                if (cds_feat) {
                    SetProteinFeature(*prot, product, *cds_feat);
                }
            }
        }
        return prot;
    }
 
}
 
///////////////////////////////////////////////////////////////////////////////
/// class CMacroFunction_CopyStringQual
/// Expected syntax:
/// CopyStringQual( src_field, dest_field, existingtext_opt, delimiter)
/// the last parameter is optional
/// src_field_name and dest_field_name are subfields of the same object
/// Can not use this function to copy from taxname to protein description
 
DEFINE_MACRO_FUNCNAME(CMacroFunction_CopyStringQual, "CopyStringQual")
 
void CMacroFunction_CopyStringQual::TheFunction()
{
    CObjectInfo oi = m_DataIter->GetEditedObject();
    CMQueryNodeValue::TObs src_objs;
    size_t index = 0;
    if (!x_GetSourceFields(oi, index, src_objs))
        return;
 
    CMQueryNodeValue::TObs dest_objs;
    if (!x_GetDestFields(oi, ++index, dest_objs))
        return;
 
    const string& action_type = m_Args[++index]->GetString();
    string delimiter = (++index < m_Args.size()) ? m_Args[index]->GetString() : kEmptyStr;
    m_ExistingText = NMacroUtil::ActionTypeToExistingTextOption(action_type, delimiter);
 
    CConstRef<CObject> obj = m_DataIter->GetScopedObject().object;
    const CSeq_feat* src_feat = dynamic_cast<const CSeq_feat*>(obj.GetPointer());
    if (src_feat && m_Args[1]->IsString() && NStr::EndsWith(m_Args[1]->GetString(), "::product")) {
        CSeq_feat* edit_feat = CTypeConverter<CSeq_feat>::SafeCast(oi.GetObjectPtr());
        for (auto&& it : src_objs) {
            CMQueryNodeValue::TObs src_prim_objs;
            NMacroUtil::GetPrimitiveObjectInfos(src_prim_objs, it);
 
            CObjectInfo src = src_prim_objs.front().field;
            string src_val = x_GetSourceString(src);
 
            string remainder;
            edit_feat->SetData().SetRna().SetRnaProductName(src_val, remainder);
            m_QualsChangedCount++;
        }
    }
    else {
        ChangeFields(src_objs, dest_objs);
    }
 
    if (m_QualsChangedCount) {
        if (!dest_objs.empty()) {
            NMacroUtil::CleanupForTaxnameChange(dest_objs.front(), oi);
        }
        m_DataIter->SetModified();
        CNcbiOstrstream log;
        log << m_DataIter->GetBestDescr() << ": copied " << m_QualsChangedCount << " qualifiers";
        x_LogFunction(log);
    }
}
 
bool CMacroFunction_CopyStringQual::x_ValidArguments() const
{
    size_t arg_size = m_Args.size();
    if (arg_size != 3 && arg_size != 4) {
        return false;
    }
 
    for (size_t i = 0; i < 2; ++i) {
        CMQueryNodeValue::EType type = m_Args[i]->GetDataType();
        bool type_ok = (type == CMQueryNodeValue::eString)
            || (type == CMQueryNodeValue::eObjects)
            || (type == CMQueryNodeValue::eRef);
        if (!type_ok)
            return false;
    }
 
    for (size_t i = 2; i < arg_size; ++i) {
        if (m_Args[i]->GetDataType() != CMQueryNodeValue::eString)
            return false;
    }
    return true;
}
 
bool CMacroFunction_CopyStringQual::x_ChangeFields(CObjectInfo& src, CObjectInfo& dest)
{
    if (dest.GetTypeFamily() != eTypeFamilyPrimitive) {
        return false;
    }
 
    string src_val = x_GetSourceString(src);
    string dest_val = dest.GetPrimitiveValueString();
    if (edit::AddValueToString(dest_val, src_val, m_ExistingText)) {
        return SetQualStringValue(dest, dest_val);
    }
    return false;
}
 
 
// class CMacroFunction_CopyFeatQual
/// CopyFeatureQual(src_field, dest_feature_type, dest_feature_field, update_mrna, existing_text_opt, delimiter)
/// The last parameter is optional
/// The related mRNA is only updated if the action is successful and the destination feature is protein
///
DEFINE_MACRO_FUNCNAME(CMacroFunction_CopyFeatQual, "CopyFeatureQual");
void CMacroFunction_CopyFeatQual::TheFunction()
{
    CConstRef<CObject> obj = m_DataIter->GetScopedObject().object;
    const CSeq_feat* src_feat = dynamic_cast<const CSeq_feat*>(obj.GetPointer());
    CRef<CScope> scope = m_DataIter->GetScopedObject().scope;
    if (!src_feat || !scope)
        return;
 
    const string& dest_field = m_Args[2]->GetString();
    if (dest_field.empty())
        return;
 
    CObjectInfo oi = m_DataIter->GetEditedObject();
    CMQueryNodeValue::TObs src_objs;
    if (!x_GetSourceFields(oi, 0, src_objs))
        return;
 
    // the destination field can be set at this point
    CSeqFeatData::ESubtype target_feature = NMacroUtil::GetFeatSubtype(m_Args[1]->GetString());
    NMacroUtil::TVecFeatList feat_list = edit::GetRelatedFeatures(*src_feat, target_feature, scope);
    CMQueryNodeValue::TObs dest_objs;
    bool changed = false, created = false;
    CRef<CSeq_feat> dest_feat;
    CSeq_feat_Handle fh;
    if (!feat_list.empty() && feat_list.size() == 1) {
        dest_feat.Reset(new CSeq_feat);
        dest_feat->Assign(*feat_list.front());
        if (!SetFeatDestinationField(dest_feat, dest_field, dest_objs)) {
            return;
        }
        fh = scope->GetSeq_featHandle(*feat_list.front());
        changed = true;
    }
    else {
        // new feature
        dest_feat = CreateNewRelatedFeature(*src_feat, dest_field, *scope);
        if (!dest_feat) return;
        if (!SetFeatDestinationField(dest_feat, dest_field, dest_objs)) {
            return;
        }
        created = true;
        if (src_feat->GetData().IsCdregion() && src_feat->IsSetXref() && dest_feat->GetData().IsProt()) {
            CSeq_feat* edit_feat = CTypeConverter<CSeq_feat>::SafeCast(oi.GetObjectPtr());
            NON_CONST_ITERATE(CSeq_feat::TXref, it, edit_feat->SetXref()) {
                if ((*it)->IsSetData() && (*it)->GetData().IsProt()) {
                    dest_feat->SetData().SetProt().Assign((*it)->GetData().GetProt());
                    edit_feat->SetXref().erase(it);
                    break;
                }
            }
            if (edit_feat->GetXref().empty()) {
                edit_feat->ResetXref();
            }
        }
    }
 
    size_t index = 3;
    bool update_mrna = m_Args[index]->GetBool();
    const string& action_type = m_Args[++index]->GetString();
    string delimiter = (++index < m_Args.size()) ? m_Args[index]->GetString() : kEmptyStr;
 
    m_ExistingText = NMacroUtil::ActionTypeToExistingTextOption(action_type, delimiter);
 
    if (IstRNAProductField(*dest_feat, dest_field)) {
        for (auto&& it : src_objs) {
            CMQueryNodeValue::TObs src_prim_objs;
            NMacroUtil::GetPrimitiveObjectInfos(src_prim_objs, it);
            
            CObjectInfo src = src_prim_objs.front().field;
            string src_val = x_GetSourceString(src);
 
            string remainder;
            dest_feat->SetData().SetRna().SetRnaProductName(src_val, remainder);
            m_QualsChangedCount++;
        }
    }
    else {
        ChangeFields(src_objs, dest_objs);
    }
 
    if (m_QualsChangedCount) {
        m_DataIter->SetModified();
        CNcbiOstrstream log;
        log << m_DataIter->GetBestDescr() << ": copied " << m_QualsChangedCount << " qualifiers";
 
        CRef<CCmdComposite> cmd;
        if (changed && fh) {
            cmd.Reset(new CCmdComposite("Change Related feature"));
            cmd->AddCommand(*CRef<CCmdChangeSeq_feat>(new CCmdChangeSeq_feat(fh, *dest_feat)));
        }
        else if (created) {
            cmd.Reset(new CCmdComposite("Create feature"));
            CBioseq_Handle bsh = scope->GetBioseqHandle(dest_feat->GetLocation());
            cmd->AddCommand(*CRef<CCmdCreateFeatBioseq>(new CCmdCreateFeatBioseq(bsh, *dest_feat)));
        }
 
        if (update_mrna) {
            if (dest_feat->GetData().GetSubtype() == CSeqFeatData::eSubtype_prot) {
                string message;
                CRef<CCmdComposite> upd_cmd = UpdatemRNAProduct(*dest_feat, *scope, message);
                if (upd_cmd) {
                    cmd->AddCommand(*upd_cmd);
                    log << ", " << message;
                }
            }
            else if (src_feat->GetData().GetSubtype() == CSeqFeatData::eSubtype_prot) {
                CSeq_feat* edit_feat = CTypeConverter<CSeq_feat>::SafeCast(oi.GetObjectPtr());
                string prot_product = edit_feat->GetData().GetProt().GetName().front();
                CRef<CCmdComposite> upd_cmd = UpdatemRNAProduct(prot_product, obj, *scope);
                if (upd_cmd) {
                    cmd->AddCommand(*upd_cmd);
                    log << ", applied " + prot_product + " to mRNA product name ";
                }
            }
        }
        m_DataIter->RunCommand(cmd, m_CmdComposite);
        x_LogFunction(log);
    }
}
 
bool CMacroFunction_CopyFeatQual::x_ValidArguments() const
{
    if (m_Args.size() < 5 || m_Args.size() > 6)
        return false;
 
    if (!( m_Args[0]->IsString() || m_Args[0]->AreObjects() || m_Args[0]->IsRef())) 
        return false;
 
    auto type = m_Args[0]->GetDataType();
    for (size_t index = 1; index < m_Args.size(); ++index) {
        type = (index != 3) ? CMQueryNodeValue::eString : CMQueryNodeValue::eBool;
        if (m_Args[index]->GetDataType() != type)
            return false;
    }
    return true;
}
 
 
///////////////////////////////////////////////////////////////////////////////
//  CMacroFunction_CopyRNARelQual
/// CopyRnaRelQual('rna'/'gene', src_field, 'gene'/'rna', dest_field, existing_text_opt, delimiter)
/// The last parameter is optional
/// Use this function when you need to copy from/to an RNA qualifier and a Gene qualifier
/// Don't use this function to copy between two RNA qualifiers
DEFINE_MACRO_FUNCNAME(CMacroFunction_CopyRNARelQual, "CopyRnaRelQual");
void CMacroFunction_CopyRNARelQual::TheFunction()
{
    // The iterator should be an RNA feature
    CConstRef<CObject> obj = m_DataIter->GetScopedObject().object;
    const CSeq_feat* rna_feat = dynamic_cast<const CSeq_feat*>(obj.GetPointer());
 
    CRef<CScope> scope = m_DataIter->GetScopedObject().scope;
    if (!rna_feat || !scope)
        return;
 
    if (rna_feat->IsSetData() && !rna_feat->GetData().IsRna())
        return;
 
    const string& src_feat = m_Args[0]->GetString();
    const string& dest_feat = m_Args[2]->GetString();
    if (src_feat == "rna" && src_feat == dest_feat)
        return;
 
    if ((src_feat != "rna" && src_feat != "gene") || (dest_feat != "rna" && dest_feat != "gene"))
        return;
 
    size_t index = 4;
    const string& action_type = m_Args[index]->GetString();
    string delimiter = (++index < m_Args.size()) ? m_Args[index]->GetString() : kEmptyStr;
    m_ExistingText = NMacroUtil::ActionTypeToExistingTextOption(action_type, delimiter);
 
    if (src_feat == "rna" && dest_feat == "gene") {
        CObjectInfo oi = m_DataIter->GetEditedObject();
        CMQueryNodeValue::TObs src_objs;
        if (!x_GetSourceFields(oi, 1, src_objs))
            return;
 
        const string dest_field = m_Args[3]->GetString();
        // the destination field can be set at this point
        NMacroUtil::TVecFeatList feat_list = edit::GetRelatedFeatures(*rna_feat, CSeqFeatData::eSubtype_gene, scope);
        CMQueryNodeValue::TObs dest_objs;
        bool changed = false, created = false;
        CRef<CSeq_feat> dest_feat;
        CSeq_feat_Handle fh;
        if (!feat_list.empty() && feat_list.size() == 1) {
            dest_feat.Reset(new CSeq_feat);
            dest_feat->Assign(*feat_list.front());
            if (!SetFeatDestinationField(dest_feat, dest_field, dest_objs)) {
                return;
            }
            fh = scope->GetSeq_featHandle(*feat_list.front());
            changed = true;
        }
        else {
            // new feature
            dest_feat = CreateNewRelatedFeature(*rna_feat, dest_field, *scope);
            if (!dest_feat) return;
            if (!SetFeatDestinationField(dest_feat, dest_field, dest_objs)) {
                return;
            }
            created = true;
        }
 
        ChangeFields(src_objs, dest_objs);
 
        if (m_QualsChangedCount) {
            CRef<CCmdComposite> cmd;
            if (changed && fh) {
                cmd.Reset(new CCmdComposite("Change Related feature"));
                cmd->AddCommand(*CRef<CCmdChangeSeq_feat>(new CCmdChangeSeq_feat(fh, *dest_feat)));
            }
            else if (created) {
                cmd.Reset(new CCmdComposite("Create feature"));
                CBioseq_Handle bsh = scope->GetBioseqHandle(dest_feat->GetLocation());
                cmd->AddCommand(*CRef<CCmdCreateFeatBioseq>(new CCmdCreateFeatBioseq(bsh, *dest_feat)));
            }
 
            m_DataIter->RunCommand(cmd, m_CmdComposite);
            CNcbiOstrstream log;
            log << m_DataIter->GetBestDescr() << ": copied " << m_QualsChangedCount << " qualifiers";
            x_LogFunction(log);
        }
    }
    else if (src_feat == "gene" && dest_feat == "gene") {
        NMacroUtil::TVecFeatList feat_list = edit::GetRelatedFeatures(*rna_feat, CSeqFeatData::eSubtype_gene, scope);
        CMQueryNodeValue::TObs src_objs, dest_objs;
 
        CRef<CSeq_feat> gene_feat;
        CSeq_feat_Handle fh;
        if (!feat_list.empty() && feat_list.size() == 1) {
            gene_feat.Reset(new CSeq_feat);
            gene_feat->Assign(*feat_list.front());
 
            CObjectInfo gene_oi(gene_feat.GetPointer(), gene_feat->GetThisTypeInfo());
            if (!x_GetSourceFields(gene_oi, 1, src_objs))
                return;
 
            if (!x_GetDestFields(gene_oi, 3, dest_objs))
                return;
 
            fh = scope->GetSeq_featHandle(*feat_list.front());
        }
        else {
            // no gene was found
            return;
        }
 
        ChangeFields(src_objs, dest_objs);
 
        if (m_QualsChangedCount) {
            CRef<CCmdComposite> cmd;
            if (fh) {
                cmd.Reset(new CCmdComposite("Change Related feature"));
                cmd->AddCommand(*CRef<CCmdChangeSeq_feat>(new CCmdChangeSeq_feat(fh, *gene_feat)));
            }
 
            m_DataIter->RunCommand(cmd, m_CmdComposite);
            CNcbiOstrstream log;
            log << m_DataIter->GetBestDescr() << ": copied " << m_QualsChangedCount << " qualifiers";
            x_LogFunction(log);
        }
    }
    else if (src_feat == "gene" && dest_feat == "rna") {
 
        NMacroUtil::TVecFeatList feat_list = edit::GetRelatedFeatures(*rna_feat, CSeqFeatData::eSubtype_gene, scope);
        CMQueryNodeValue::TObs src_objs, dest_objs;
        CRef<CSeq_feat> gene_feat;
        if (!feat_list.empty() && feat_list.size() == 1) {
            gene_feat.Reset(new CSeq_feat);
            gene_feat->Assign(*feat_list.front());
 
            CObjectInfo gene_oi(gene_feat.GetPointer(), gene_feat->GetThisTypeInfo());
            if (!x_GetSourceFields(gene_oi, 1, src_objs))
                return;
        }
        else {
            // no gene was found
            return;
        }
 
        CObjectInfo oi = m_DataIter->GetEditedObject();
        if (!x_GetDestFields(oi, 3, dest_objs))
            return;
 
        CSeq_feat* edit_feat = CTypeConverter<CSeq_feat>::SafeCast(oi.GetObjectPtr());
        if (m_Args[3]->IsString() && NStr::EndsWith(m_Args[3]->GetString(), "::product")) {
            for (auto&& it : src_objs) {
                CMQueryNodeValue::TObs src_prim_objs;
                NMacroUtil::GetPrimitiveObjectInfos(src_prim_objs, it);
 
                CObjectInfo src = src_prim_objs.front().field;
                string src_val = x_GetSourceString(src);
 
                string remainder;
                edit_feat->SetData().SetRna().SetRnaProductName(src_val, remainder);
                m_QualsChangedCount++;
            }
        }
        else {
            ChangeFields(src_objs, dest_objs);
        }
 
        if (m_QualsChangedCount) {
            m_DataIter->SetModified();
            CNcbiOstrstream log;
            log << m_DataIter->GetBestDescr() << ": copied " << m_QualsChangedCount << " qualifiers";
            x_LogFunction(log);
        }
    }
}
 
bool CMacroFunction_CopyRNARelQual::x_ValidArguments() const
{
    if (m_Args.size() < 5 || m_Args.size() > 6)
        return false;
 
    if (!m_Args[0]->IsString() || !m_Args[2]->IsString() || !m_Args[4]->IsString())
        return false;
 
    for (size_t index = 1; index < 4; index += 2) {
        if (!(m_Args[index]->IsString() || m_Args[index]->AreObjects() || m_Args[index]->IsRef()))
            return false;
    }
    return (m_Args.size() == 5 || (m_Args.size() == 6 && m_Args[5]->IsString()));
}
 
 
///////////////////////////////////////////////////////////////////////////////
// CMacroFunction_SetRelFeatQual
/// SetRelatedFeatureQual(feat_type, field_name, new_value, existing_text_option, delimiter, remove_blank, update_mrna)
/// The last three parameters are optional
///
DEFINE_MACRO_FUNCNAME(CMacroFunction_SetRelFeatQual,"SetRelatedFeatureQual");
void CMacroFunction_SetRelFeatQual::TheFunction()
{
    CConstRef<CObject> obj = m_DataIter->GetScopedObject().object;
    const CSeq_feat* src_feat = dynamic_cast<const CSeq_feat*>(obj.GetPointer());
    CRef<CScope> scope = m_DataIter->GetScopedObject().scope;
    if (!src_feat || !scope)
        return;
 
    CObjectInfo oi = m_DataIter->GetEditedObject();
    const string& field_name = m_Args[1]->GetString();
    CSeqFeatData::ESubtype feat_type = NMacroUtil::GetFeatSubtype(m_Args[0]->GetString());
    NMacroUtil::TVecFeatList feat_list = edit::GetRelatedFeatures(*src_feat, feat_type, scope);
    
    size_t index = 2;
    string newValue = NMacroUtil::GetStringValue(m_Args[index]);
    const string& action_type = m_Args[++index]->GetString();
    string delimiter;
    bool remove_field = false;
    bool update_mrna = false;
    size_t arg_nr = m_Args.size();
 
    if (++index < arg_nr) {
        if (m_Args[index]->IsString()) {
            delimiter = m_Args[index]->GetString();
            if (++index < arg_nr) {
                remove_field = m_Args[index]->GetBool();
                if (++index < arg_nr)
                    update_mrna = m_Args[index]->GetBool();
            }
        }
        else if (m_Args[index]->IsBool()) {
            remove_field = m_Args[index]->GetBool();
            if (++index < arg_nr)
                update_mrna = m_Args[index]->GetBool();
        }
    }
    edit::EExistingText existing_text = NMacroUtil::ActionTypeToExistingTextOption(action_type, delimiter);
 
    if (!newValue.empty()) {
        CMQueryNodeValue::TObs objs;
        bool changed = false, created = false;
        CRef<CSeq_feat> dest_feat;
        CSeq_feat_Handle fh;
        if (!feat_list.empty() && feat_list.size() == 1) {
            dest_feat.Reset(new CSeq_feat);
            dest_feat->Assign(*feat_list.front());
            if (!SetFeatDestinationField(dest_feat, field_name, objs)) {
                return;
            }
            fh = scope->GetSeq_featHandle(*feat_list.front());
            changed = true;
        }
        else {
            // new feature
            dest_feat = CreateNewRelatedFeature(*src_feat, field_name, *scope);
            if (!dest_feat) return;
            if (!SetFeatDestinationField(dest_feat, field_name, objs)) {
                return;
            }
            created = true;
            if (src_feat->GetData().IsCdregion() && src_feat->IsSetXref() && dest_feat->GetData().IsProt()) {
                CSeq_feat* edit_feat = CTypeConverter<CSeq_feat>::SafeCast(oi.GetObjectPtr());
                NON_CONST_ITERATE(CSeq_feat::TXref, it, edit_feat->SetXref()) {
                    if ((*it)->IsSetData() && (*it)->GetData().IsProt()) {
                        dest_feat->SetData().SetProt().Assign((*it)->GetData().GetProt());
                        edit_feat->SetXref().erase(it);
                        m_QualsChangedCount++;
                        break;
                    }
                }
                if (edit_feat->GetXref().empty()) {
                    edit_feat->ResetXref();
                }
            }
        }
 
        vector<string> new_values;
        x_SetFields(objs, newValue, existing_text, new_values);
 
        if (m_QualsChangedCount) {
            m_DataIter->SetModified();
            CNcbiOstrstream log;
            log << m_DataIter->GetBestDescr();
            for (size_t i = 0; i < new_values.size(); ++i) {
                log << ": set '" << new_values[i] << "' as a new value";
            }
 
            if (changed && fh) {
                CRef<CCmdComposite> cmd(new CCmdComposite("Change Related feature"));
                cmd->AddCommand(*CRef<CCmdChangeSeq_feat>(new CCmdChangeSeq_feat(fh, *dest_feat)));
                if (update_mrna && dest_feat->GetData().GetSubtype() == CSeqFeatData::eSubtype_prot) {
                    string prot_product = dest_feat->GetData().GetProt().GetName().front();
                    CRef<CCmdComposite> upd_cmd = UpdatemRNAProduct(prot_product, feat_list.front(), *scope);
                    if (upd_cmd) {
                        cmd->AddCommand(*upd_cmd);
                        log << ", applied " + prot_product + " to mRNA product name ";
                    }
                }
                m_DataIter->RunCommand(cmd, m_CmdComposite);
            }
            else if (created) {
                CRef<CCmdComposite> cmd(new CCmdComposite("Create feature"));
                CBioseq_Handle bsh = scope->GetBioseqHandle(dest_feat->GetLocation());
                cmd->AddCommand(*CRef<CCmdCreateFeatBioseq>(new CCmdCreateFeatBioseq(bsh, *dest_feat)));
                if (update_mrna && dest_feat->GetData().GetSubtype() == CSeqFeatData::eSubtype_prot) {
                    string message;
                    CRef<CCmdComposite> upd_cmd = UpdatemRNAProduct(*dest_feat, *scope, message);
                    if (upd_cmd) {
                        cmd->AddCommand(*upd_cmd);
                        log << ", " << message;
                    }
                }
                m_DataIter->RunCommand(cmd, m_CmdComposite);
            }
 
            x_LogFunction(log);
        }
    }
    else if (remove_field) {
        CMQueryNodeValue::TObs objs;
        CRef<CSeq_feat> dest_feat;
        CSeq_feat_Handle fh;
        if (!feat_list.empty() && feat_list.size() == 1) {
            dest_feat.Reset(new CSeq_feat);
            dest_feat->Assign(*feat_list.front());
            if (!GetFeatDestinationField(dest_feat, field_name, objs)) {
                return;
            }
            fh = scope->GetSeq_featHandle(*feat_list.front());
        }
 
        for (auto& it : objs) {
            if (RemoveFieldByName(it)) {
                m_QualsChangedCount++;
            }
        }
 
        if (m_QualsChangedCount) {
            CNcbiOstrstream log;
            if (fh) {
                CCleanup cleanup(scope);
                cleanup.BasicCleanup(*dest_feat);
 
                CRef<CCmdComposite> cmd(new CCmdComposite("Change Related feature"));
                cmd->AddCommand(*CRef<CCmdChangeSeq_feat>(new CCmdChangeSeq_feat(fh, *dest_feat)));
                log << m_DataIter->GetBestDescr() << ": removed " << m_QualsChangedCount << " qualifiers";
 
                if (update_mrna && dest_feat->GetData().GetSubtype() == CSeqFeatData::eSubtype_prot) {
                    string message;
                    CRef<CCmdComposite> upd_cmd = UpdatemRNAProduct(*dest_feat, *scope, message);
                    if (upd_cmd) {
                        cmd->AddCommand(*upd_cmd);
                        log << ", " << message;
                    }
                }
                m_DataIter->RunCommand(cmd, m_CmdComposite);
            }
            x_LogFunction(log);
        }
    }
}
 
bool CMacroFunction_SetRelFeatQual::x_ValidArguments() const
{
    // can accept as its first parameter: objects, string or reference
    size_t arg_nr = m_Args.size();
    if (arg_nr < 4 && arg_nr > 7) {
        return false;
    }
 
    NMacroUtil::GetPrimitiveFromRef(m_Args[2].GetNCObject());
    size_t index = 0;
    for (; index < 4; ++index) {
        if (!m_Args[index]->IsString())
            return false;
    }
 
    if (index < arg_nr && (!m_Args[index]->IsString() && !m_Args[index]->IsBool())) return false;
    if (++index < arg_nr && !m_Args[index]->IsBool()) return false;
    if (++index < arg_nr && !m_Args[index]->IsBool()) return false;
    return true;
}
 
 
///////////////////////////////////////////////////////////////////////////////
// CMacroFunction_EditRelFeatQual
/// EditRelatedFeatureQual(feat_type, field_name, find_text, repl_text, location, case_sensitive, is_regex)
///
const char* CMacroFunction_EditRelFeatQual::sm_FunctionName = "EditRelatedFeatureQual";
void CMacroFunction_EditRelFeatQual::TheFunction()
{
    CConstRef<CObject> obj = m_DataIter->GetScopedObject().object;
    const CSeq_feat* src_feat = dynamic_cast<const CSeq_feat*>(obj.GetPointer());
    CRef<CScope> scope = m_DataIter->GetScopedObject().scope;
    if (!src_feat || !scope)
        return;
 
    size_t index = 2;
    const string& find_txt = NMacroUtil::GetStringValue(m_Args[index]);
    string repl_txt = NMacroUtil::GetStringValue(m_Args[++index]);
    const string& location = m_Args[++index]->GetString();
    bool case_sensitive = m_Args[++index]->GetBool();
    bool is_regex = (++index < m_Args.size()) ? m_Args[index]->GetBool() : false;
 
    CObjectInfo oi = m_DataIter->GetEditedObject();
    const string& field_name = m_Args[1]->GetString();
    CSeqFeatData::ESubtype feat_type = NMacroUtil::GetFeatSubtype(m_Args[0]->GetString());
    NMacroUtil::TVecFeatList feat_list = edit::GetRelatedFeatures(*src_feat, feat_type, scope);
 
    CMQueryNodeValue::TObs objs;
    CRef<CSeq_feat> dest_feat;
    CSeq_feat_Handle fh;
    if (!feat_list.empty() && feat_list.size() == 1) {
        dest_feat.Reset(new CSeq_feat);
        dest_feat->Assign(*feat_list.front());
        if (!GetFeatDestinationField(dest_feat, field_name, objs)) {
            return;
        }
        fh = scope->GetSeq_featHandle(*feat_list.front());
    }
 
    x_EditFields(objs, find_txt, repl_txt, s_GetLocFromName(location), case_sensitive, is_regex);
    if (m_QualsChangedCount) {
        if (fh) {
            CRef<CCmdComposite> cmd(new CCmdComposite("Change Related feature"));
            cmd->AddCommand(*CRef<CCmdChangeSeq_feat>(new CCmdChangeSeq_feat(fh, *dest_feat)));
            m_DataIter->RunCommand(cmd, m_CmdComposite);
        }
 
        CNcbiOstrstream log;
        log << m_DataIter->GetBestDescr() << ": edited " << m_QualsChangedCount << " qualifiers, replaced " << find_txt;
        if (NStr::IsBlank(repl_txt)) {
            repl_txt.assign("''");
        }
        log << " with " << repl_txt;
        x_LogFunction(log);
    }
}
 
bool CMacroFunction_EditRelFeatQual::x_ValidArguments() const
{
    if (m_Args.size() != 6 && m_Args.size() != 7)
        return false;
 
    for (size_t index = 2; index < 4; index++) {
        if (m_Args[index]->GetDataType() != CMQueryNodeValue::eString && m_Args[index]->GetDataType() != CMQueryNodeValue::eInt) {
            return false;
        }
    }
 
    if (m_Args.size() == 7) {
        if (m_Args.back()->GetDataType() != CMQueryNodeValue::eBool)
            return false;
    }
    return (m_Args[0]->GetDataType() == CMQueryNodeValue::eString
            && m_Args[1]->GetDataType() == CMQueryNodeValue::eString
            && m_Args[5]->GetDataType() == CMQueryNodeValue::eBool);
}
 
 
///////////////////////////////////////////////////////////////////////////////
// CMacroFunction_RmvRelFeatQual
/// RemoveRelatedFeatureQual(feat_type, field_name)
///
DEFINE_MACRO_FUNCNAME(CMacroFunction_RmvRelFeatQual, "RemoveRelatedFeatureQual")
void CMacroFunction_RmvRelFeatQual::TheFunction()
{
    CConstRef<CObject> obj = m_DataIter->GetScopedObject().object;
    const CSeq_feat* src_feat = dynamic_cast<const CSeq_feat*>(obj.GetPointer());
    CRef<CScope> scope = m_DataIter->GetScopedObject().scope;
    if (!src_feat || !scope)
        return;
 
    CObjectInfo oi = m_DataIter->GetEditedObject();
    const string& field_name = m_Args[1]->GetString();
    CSeqFeatData::ESubtype feat_type = NMacroUtil::GetFeatSubtype(m_Args[0]->GetString());
    NMacroUtil::TVecFeatList feat_list = edit::GetRelatedFeatures(*src_feat, feat_type, scope);
 
    CMQueryNodeValue::TObs objs;
    CRef<CSeq_feat> dest_feat;
    CSeq_feat_Handle fh;
    if (!feat_list.empty() && feat_list.size() == 1) {
        dest_feat.Reset(new CSeq_feat);
        dest_feat->Assign(*feat_list.front());
        if (!GetFeatDestinationField(dest_feat, field_name, objs)) {
            return;
        }
        fh = scope->GetSeq_featHandle(*feat_list.front());
    }
 
    for (auto& it : objs) {
        if (RemoveFieldByName(it)) {
            m_QualsChangedCount++;
        }
    }
 
 
    if (m_QualsChangedCount) {
        if (fh) {
            CCleanup cleanup(scope);
            cleanup.BasicCleanup(*dest_feat);
 
            CRef<CCmdComposite> cmd(new CCmdComposite("Change Related feature"));
            cmd->AddCommand(*CRef<CCmdChangeSeq_feat>(new CCmdChangeSeq_feat(fh, *dest_feat)));
            m_DataIter->RunCommand(cmd, m_CmdComposite);
        }
        CNcbiOstrstream log;
        log << m_DataIter->GetBestDescr() << ": removed " << m_QualsChangedCount << " qualifiers";
        x_LogFunction(log);
    }
}
 
bool CMacroFunction_RmvRelFeatQual::x_ValidArguments() const
{
    if (m_Args.size() != 2)
        return false;
 
    //TODO - extend it to accept reference, for example: gene synonym with a constraint
    return (m_Args[0]->IsString() && m_Args[1]->IsString());
}
 
 
///////////////////////////////////////////////////////////////////////////////
// class CMacroFunction_RmvOutsideRelFeatQual
/// RmvOutsideRelatedFeatureQual(feat_type, field_name, before_match(b), left_del(str), rmv_left(b), 
///                         after_match(b), right_del(str), rmv_right(b), case_insensitive(b), whole_word(b), update_mrna(b))
 
DEFINE_MACRO_FUNCNAME(CMacroFunction_RmvOutsideRelFeatQual, "RmvOutsideRelatedFeatureQual")
 
void CMacroFunction_RmvOutsideRelFeatQual::TheFunction()
{
    CConstRef<CObject> obj = m_DataIter->GetScopedObject().object;
    const CSeq_feat* src_feat = dynamic_cast<const CSeq_feat*>(obj.GetPointer());
    CRef<CScope> scope = m_DataIter->GetScopedObject().scope;
    if (!src_feat || !scope)
        return;
 
    CObjectInfo oi = m_DataIter->GetEditedObject();
    const string& field_name = m_Args[1]->GetString();
    CSeqFeatData::ESubtype feat_type = NMacroUtil::GetFeatSubtype(m_Args[0]->GetString());
    NMacroUtil::TVecFeatList feat_list = edit::GetRelatedFeatures(*src_feat, feat_type, scope);
 
 
    CMQueryNodeValue::TObs objs;
    CRef<CSeq_feat> dest_feat;
    CSeq_feat_Handle fh;
    if (!feat_list.empty() && feat_list.size() == 1) {
        dest_feat.Reset(new CSeq_feat);
        dest_feat->Assign(*feat_list.front());
        if (!GetFeatDestinationField(dest_feat, field_name, objs)) {
            return;
        }
        fh = scope->GetSeq_featHandle(*feat_list.front());
    }
 
    CRef<CRemoveTextOptions> options = x_GetRemoveTextOptions(2);
    x_RmvOutsideFields(objs, *options);
    if (m_QualsChangedCount) {
        if (fh) {
            CRef<CCmdComposite> cmd(new CCmdComposite("Change Related feature"));
            cmd->AddCommand(*CRef<CCmdChangeSeq_feat>(new CCmdChangeSeq_feat(fh, *dest_feat)));
            m_DataIter->RunCommand(cmd, m_CmdComposite);
        }
 
        CNcbiOstrstream log;
        log << m_DataIter->GetBestDescr() << ": removed text outside string in " << m_QualsChangedCount << " qualifiers";
 
        bool update_mrna = (m_Args.size() == 11) ? m_Args[10]->GetBool() : false;
        if (update_mrna && dest_feat->GetData().GetSubtype() == CSeqFeatData::eSubtype_prot) {
            string message;
            CRef<CScope> scope = m_DataIter->GetScopedObject().scope;
            string prot_product = dest_feat->GetData().GetProt().GetName().front();
            CRef<CCmdComposite> cmd = UpdatemRNAProduct(prot_product, feat_list.front(), *scope);
            if (cmd) {
                m_DataIter->RunCommand(cmd, m_CmdComposite);
                log << ", applied " + prot_product + " to mRNA product name ";
            }
        }
 
        x_LogFunction(log);
    }
}
 
bool CMacroFunction_RmvOutsideRelFeatQual::x_ValidArguments() const
{
    if (m_Args.size() != 10 && m_Args.size() != 11)
        return false;
 
    if (m_Args[0]->GetDataType() != CMQueryNodeValue::eString || m_Args[1]->GetDataType() != CMQueryNodeValue::eString)
        return false;
 
    return x_CheckArguments(2);
}
 
 
// IOperateOnTwoQuals interface
void IOperateOnTwoQuals::ChangeFields(CMQueryNodeValue::TObs& src_objs, CMQueryNodeValue::TObs& dest_objs)
{
    _ASSERT(!src_objs.empty() && !dest_objs.empty());
    CMQueryNodeValue::TObs::iterator src_it = src_objs.begin();
    CMQueryNodeValue::TObs::iterator dest_it = dest_objs.begin();
 
    while (src_it != src_objs.end()) {
        CMQueryNodeValue::TObs src_prim_objs;
        NMacroUtil::GetPrimitiveObjectInfos(src_prim_objs, *src_it);
        CMQueryNodeValue::TObs dest_prim_objs;
        NMacroUtil::GetPrimitiveObjectInfos(dest_prim_objs, *dest_it);
        if (dest_prim_objs.empty() && dest_it->field.GetTypeFamily() == eTypeFamilyContainer) {
            // add new element when the container is empty
            CObjectInfo new_oi(dest_it->field.AddNewElement());
            dest_prim_objs.push_back(CMQueryNodeValue::SResolvedField(dest_it->field, new_oi));
        }
        for (auto& it : src_prim_objs) {
            x_ChangeFields(it.field, dest_prim_objs.front().field);
        }
 
        ++src_it;
        ++dest_it;
        if (dest_it == dest_objs.end()) {
            --dest_it;
        }
    }
}
 
bool IOperateOnTwoQuals::x_GetSourceFields(CObjectInfo oi, size_t index, CMQueryNodeValue::TObs& result)
{
    if (index >= m_Args.size())
        return false;
 
    // the source field has to be set
    CMQueryNodeValue::EType src_type = m_Args[index]->GetDataType();
 
    if (src_type == CMQueryNodeValue::eString) {
        if (!GetFieldsByName(&result, oi, m_Args[index]->GetString()))
            return false;
    }
    else if (src_type == CMQueryNodeValue::eObjects) {
        result = m_Args[index]->GetObjects();
    }
    else if (src_type == CMQueryNodeValue::eRef) {
        x_GetObjectsFromRef(result, index);
        NMacroUtil::SwapGbQualWithValues(result);
    }
 
    return (!result.empty());
}
 
bool IOperateOnTwoQuals::x_GetDestFields(CObjectInfo oi, size_t index, CMQueryNodeValue::TObs& result)
{
    // the destination field might be set during this action
    CMQueryNodeValue::EType dest_type = m_Args[index]->GetDataType();
 
    if (dest_type == CMQueryNodeValue::eString) {
        const string& dest_field = m_Args[index]->GetString();
        CConstRef<CObject> object = m_DataIter->GetScopedObject().object;
        bool valid = GetDestinationObjects(object, oi, dest_field, result);
        if (valid && result.empty()) // for tRNA product 
            return valid;
    }
    else if (dest_type == CMQueryNodeValue::eObjects) {
        result = m_Args[index]->GetObjects();
    }
    else if (dest_type == CMQueryNodeValue::eRef) {
        x_GetObjectsFromRef(result, index);
    }
    return !result.empty();
}
 
string IOperateOnTwoQuals::x_GetSourceString(CObjectInfo& src)
{
    string src_val;
    if (src.GetTypeFamily() == eTypeFamilyPrimitive) {
        switch (src.GetPrimitiveValueType()) {
        case ePrimitiveValueString:
            src_val = src.GetPrimitiveValueString();
            // strip_name is not implemented yet
            break;
        case ePrimitiveValueEnum: //e.g., codon-start
            src_val = NStr::IntToString(src.GetPrimitiveValueInt());
            break;
        case ePrimitiveValueInteger:  // e.g., local_id
            src_val = NStr::IntToString(src.GetPrimitiveValueInt4());
            break;
        case ePrimitiveValueReal:
            src_val = NStr::DoubleToString(src.GetPrimitiveValueDouble());
            break;
        case ePrimitiveValueBool:
            src_val = NStr::BoolToString(src.GetPrimitiveValueBool());
            break;
        default:
            break;
        } 
    }
    else if (src.GetTypeFamily() == eTypeFamilyClass) {
        if (src.GetName() == "Dbtag") {
            CDbtag* tag = CTypeConverter<CDbtag>::SafeCast(src.GetObjectPtr());
            if (tag) {
                tag->GetLabel(&src_val);
            }
        }
    }
    return src_val;
}
 
 
///////////////////////////////////////////////////////////////////////////////
/// class CMacroFunction_ConvertStringQual
/// ConvertStringQual(src_field, dst_field, capitalization, strip_name, existing_text_opt, delimiter)
/// last parameter is optional
/// The function will NOT delete the src_field.
/// If the user wants to delete the src_field, (s)he should use RemoveQual() or RemoveModifier() functions
///
DEFINE_MACRO_FUNCNAME(CMacroFunction_ConvertStringQual, "ConvertStringQual")
 
void CMacroFunction_ConvertStringQual::TheFunction()
{
    CObjectInfo oi = m_DataIter->GetEditedObject();
    CMQueryNodeValue::TObs src_objs;
    size_t index = 0;
    if (!x_GetSourceFields(oi, index, src_objs))
        return;
 
    CMQueryNodeValue::TObs dest_objs;
    if (!x_GetDestFields(oi, ++index, dest_objs))
        return;
 
    const string& capitalization = m_Args[++index]->GetString();
    //bool strip_name = m_Args[++index]->GetBool();
    //strip_name = false; // this option is not implemented ( it's false by default)
    ++index;
    const string& action_type = m_Args[++index]->GetString();
    string delimiter = (++index < m_Args.size()) ? m_Args[index]->GetString() : kEmptyStr;
    m_ExistingText = NMacroUtil::ActionTypeToExistingTextOption(action_type, delimiter);
    m_CapChange = NMacroUtil::ConvertStringtoCapitalOption(capitalization);
 
    CConstRef<CObject> obj = m_DataIter->GetScopedObject().object;
    const CSeq_feat* src_feat = dynamic_cast<const CSeq_feat*>(obj.GetPointer());
    if (src_feat && m_Args[1]->IsString() && NStr::EndsWith(m_Args[1]->GetString(), "::product")) {
        CSeq_feat* edit_feat = CTypeConverter<CSeq_feat>::SafeCast(oi.GetObjectPtr());
        for (auto&& it : src_objs) {
            CMQueryNodeValue::TObs src_prim_objs;
            NMacroUtil::GetPrimitiveObjectInfos(src_prim_objs, it);
 
            CObjectInfo src = src_prim_objs.front().field;
            string src_val = x_GetSourceString(src);
 
            string remainder;
            edit_feat->SetData().SetRna().SetRnaProductName(src_val, remainder);
            m_QualsChangedCount++;
        }
    }
    else {
        ChangeFields(src_objs, dest_objs);
    }
 
    if (m_QualsChangedCount) {
        if (!dest_objs.empty()) {
            NMacroUtil::CleanupForTaxnameChange(dest_objs.front(), oi);
        }
        m_DataIter->SetModified();
        CNcbiOstrstream log;
        log << m_DataIter->GetBestDescr() << ": converted " << m_QualsChangedCount << " qualifiers";
        x_LogFunction(log);
    }
}
 
bool CMacroFunction_ConvertStringQual::x_ChangeFields(CObjectInfo& src, CObjectInfo& dest)
{
    if (dest.GetTypeFamily() != eTypeFamilyPrimitive) {
        return false;
    }
 
    string src_val = x_GetSourceString(src);
    if (dest.GetPrimitiveValueType() == ePrimitiveValueString) {
        string dest_val = dest.GetPrimitiveValueString();
        if (edit::AddValueToString(dest_val, src_val, m_ExistingText)) {
            return SetQualStringValue(dest, dest_val);
        }
    }
    return false;
}
 
string CMacroFunction_ConvertStringQual::x_GetSourceString(CObjectInfo& src)
{
    string src_val = IOperateOnTwoQuals::x_GetSourceString(src);
    CSeq_entry_Handle seh = m_DataIter->GetSEH();
    FixCapitalizationInString(seh, src_val, m_CapChange);
    return src_val;
}
 
 
bool CMacroFunction_ConvertStringQual::x_ValidArguments() const
{
    size_t as = m_Args.size();
    if (!(as == 5 || as == 6)) {
        return false;
    }
 
    for (size_t i = 0; i < 2; ++i) {
        CMQueryNodeValue::EType type = m_Args[i]->GetDataType();
        bool type_ok = (type == CMQueryNodeValue::eString)
            || (type == CMQueryNodeValue::eObjects)
            || (type == CMQueryNodeValue::eRef);
        if (!type_ok)
            return false;
    }
 
    bool m_Args_ok = (m_Args[2]->GetDataType() == CMQueryNodeValue::eString);
    m_Args_ok = m_Args_ok && (m_Args[3]->GetDataType() == CMQueryNodeValue::eBool)
        && (m_Args[4]->GetDataType() == CMQueryNodeValue::eString);
 
    if (as == 6) {
        m_Args_ok = m_Args_ok && (m_Args[5]->GetDataType() == CMQueryNodeValue::eString);
    }
 
    if (!m_Args_ok) {
        return false;
    }
 
    return true;
}
 
 
///////////////////////////////////////////////////////////////////////////////
/// class CMacroFunction_SwapQual
/// SwapQual(src_fieldname, dest_fieldname)
/// Swaps the content of two fields. If one field is blank/does not exist, the other field will be removed
///
DEFINE_MACRO_FUNCNAME(CMacroFunction_SwapQual, "SwapQual")
 
void CMacroFunction_SwapQual::TheFunction()
{
    CObjectInfo oi = m_DataIter->GetEditedObject();
    CMQueryNodeValue::TObs src_objs;
    CMQueryNodeValue::TObs dest_objs;
    size_t src_index = 0, dest_index = 1;
 
    if ((m_Args.size() == 3 && m_Args[0]->GetDataType() != CMQueryNodeValue::eString)
        || m_Args.size() == 4) {
        dest_index = 2;
    }
 
    // check that at least one of the fields exist
    bool src_set = x_DoFieldsExist(oi, src_objs, src_index);
    bool dest_set = x_DoFieldsExist(oi, dest_objs, dest_index);
 
    if (!src_set && !dest_set)
        return;
 
    // special attention to gene qualifiers that are removed from gene Xrefs
    bool is_gene_suppressed_before = false;
    bool is_gene_suppressed_after = false;
    CConstRef<CObject> obj = m_DataIter->GetScopedObject().object;
    if (dynamic_cast<const CSeq_feat*>(obj.GetPointer())) {
        CSeq_feat* feat = CTypeConverter<CSeq_feat>::SafeCast(oi.GetObjectPtr());
        auto gene_xref = feat->GetGeneXref();
        is_gene_suppressed_before = gene_xref && gene_xref->IsSuppressed();
    }
 
    if (!src_set) {
        x_SetFields(oi, src_objs, src_index);
    } 
    if (!dest_set) {
        x_SetFields(oi, dest_objs, dest_index);
    }
 
    if (src_set && dest_set) {
        CMQueryNodeValue::TObs::iterator src_it = src_objs.begin();
        CMQueryNodeValue::TObs::iterator dest_it = dest_objs.begin();
 
        while (src_it != src_objs.end() && dest_it != dest_objs.end()) {
            CMQueryNodeValue::TObs src_prim_objs;
            NMacroUtil::GetPrimitiveObjInfosWithContainers(src_prim_objs, *src_it);
            CMQueryNodeValue::TObs dest_prim_objs;
            NMacroUtil::GetPrimitiveObjInfosWithContainers(dest_prim_objs, *dest_it);
            if (dest_prim_objs.empty() && dest_it->field.GetTypeFamily() == eTypeFamilyContainer) {
                // add new element when the container is empty
                CObjectInfo new_oi(dest_it->field.AddNewElement());
                dest_prim_objs.push_back(CMQueryNodeValue::SResolvedField(dest_it->field, new_oi));
            }
            x_SwapFields(src_prim_objs.front().field, dest_prim_objs.front().field);
 
            ++src_it;
            ++dest_it;
        }
        NMacroUtil::CleanupForTaxnameChange(src_objs.front(), oi);
        NMacroUtil::CleanupForTaxnameChange(dest_objs.front(), oi);
    }
    else if (!src_set) {
        // copy destination field into the source field
        x_CopyFields(dest_objs, src_objs);
 
        bool is_taxname = NMacroUtil::IsTaxname(dest_objs.front());
        // delete destination field
        NON_CONST_ITERATE(CMQueryNodeValue::TObs, it, dest_objs) {
            RemoveFieldByName(*it);
        }
        if (is_taxname) {
            NMacroUtil::CleanupForTaxnameChange(oi);
        }
    }
    else if (!dest_set) {
        // copy source field into the destination field
        x_CopyFields(src_objs, dest_objs);
 
        bool is_taxname = NMacroUtil::IsTaxname(src_objs.front());
        // delete source field
        NON_CONST_ITERATE(CMQueryNodeValue::TObs, it, src_objs) {
            RemoveFieldByName(*it);
        }
        if (is_taxname) {
            NMacroUtil::CleanupForTaxnameChange(oi);
        }
    }
 
    CCleanup cleanup;
    if (dynamic_cast<const CSeq_feat*>(obj.GetPointer())) {
        CSeq_feat* seq_feat = CTypeConverter<CSeq_feat>::SafeCast(oi.GetObjectPtr());
        cleanup.BasicCleanup(*seq_feat);
        if (seq_feat->IsSetXref()) {
            auto gene_xref = seq_feat->GetGeneXref();
            is_gene_suppressed_after = gene_xref->IsSuppressed();
            if (!is_gene_suppressed_before && is_gene_suppressed_after)
                NMacroUtil::RemoveGeneXref(*seq_feat);
        }
    }
    else if (dynamic_cast<const CBioSource*>(obj.GetPointer())) {
        CBioSource* bsrc = CTypeConverter<CBioSource>::SafeCast(oi.GetObjectPtr());
        cleanup.BasicCleanup(*bsrc);
        if (bsrc->IsSetOrg() && bsrc->GetOrg().IsSetDb() && bsrc->GetOrg().GetDb().empty()) {
            bsrc->SetOrg().ResetDb();
        }
    }
 
    if (m_QualsChangedCount) {
        m_DataIter->SetModified();
        CNcbiOstrstream log;
        log << m_DataIter->GetBestDescr() << ": swapped " << m_QualsChangedCount << " qualifiers";
        x_LogFunction(log);
    }
}
 
bool CMacroFunction_SwapQual::x_ValidArguments() const
{
    if (m_Args.size() < 2) {
        return false;
    }
 
    for (auto& it : m_Args) {
        CMQueryNodeValue::EType type = it->GetDataType();
        if (type != CMQueryNodeValue::eString && type != CMQueryNodeValue::eObjects && type != CMQueryNodeValue::eRef) {
            return false;
        }
    }
    return true;
}
 
 
bool CMacroFunction_SwapQual::x_DoFieldsExist(CObjectInfo oi, CMQueryNodeValue::TObs& result, size_t index)
{
    if (index >= m_Args.size())
        return false;
 
    CMQueryNodeValue::EType type = m_Args[index]->GetDataType();
    if (type == CMQueryNodeValue::eString) {
        GetFieldsByName(&result, oi, m_Args[index]->GetString());
    }
    else if (type == CMQueryNodeValue::eObjects) {
        result = m_Args[index]->GetObjects();
    }
    else if (type == CMQueryNodeValue::eRef) {
        x_GetObjectsFromRef(result, index);
    }
 
    return (!result.empty());
}
 
bool CMacroFunction_SwapQual::x_SetFields(CObjectInfo oi, CMQueryNodeValue::TObs& result, size_t index)
{
    if (index >= m_Args.size())
        return false;
 
    // the field does not have to be set
    CMQueryNodeValue::EType type = m_Args[index]->GetDataType();
    if (type == CMQueryNodeValue::eString) {
        SetFieldsByName(&result, oi, m_Args[index]->GetString());
    }
    else {
        CConstRef<CObject> obj = m_DataIter->GetScopedObject().object;
        x_SetField(obj, m_Args[++index]->GetString(), result);
    }
    return (!result.empty());
}
 
static void s_SetBioSourceField(CRef<CBioSource> bsrc, CObjectInfo& oi, const string& field_name, CMQueryNodeValue::TObs& dest_objs)
{
    if (field_name.empty())
        return;
 
    // check if the field denotes an orgmod or a subsource modifier
    if (NMacroUtil::IsBiosourceModifier(field_name)) {
        // check if it's a subsource modifier
        if (CSubSource::IsValidSubtypeName(field_name, CSubSource::eVocabulary_insdc)) {
            CSubSource::TSubtype st = CSubSource::GetSubtypeValue(field_name, CSubSource::eVocabulary_insdc);
 
            CRef<CSubSource> sub_src(new CSubSource());
            sub_src->SetSubtype(st);
            sub_src->SetName(kEmptyStr);
            bsrc->SetSubtype().push_back(sub_src);
            CObjectInfo subsrc_oi(sub_src.GetPointer(), sub_src->GetTypeInfo());
            dest_objs.push_back(CMQueryNodeValue::SResolvedField(oi, subsrc_oi));
            // check if it's an orgmod modifier
        }
        else if (COrgMod::IsValidSubtypeName(field_name, COrgMod::eVocabulary_insdc)) {
            COrgMod::TSubtype st = COrgMod::GetSubtypeValue(field_name, COrgMod::eVocabulary_insdc);
 
            CRef<COrgMod> orgmod(new COrgMod());
            orgmod->SetSubtype(st);
            orgmod->SetSubname(kEmptyStr);
            CRef<COrgName> orgname;
            if (!bsrc->IsSetOrgname()) {
                orgname.Reset(new COrgName());
                orgname->SetMod().push_back(orgmod);
                bsrc->SetOrg().SetOrgname(*orgname);
            }
            else {
                orgname = Ref(&(bsrc->SetOrg().SetOrgname()));
                orgname->SetMod().push_back(orgmod);
            }
            CObjectInfo parent_mod_oi(orgname.GetPointer(), orgname->GetThisTypeInfo());
            CObjectInfo orgmod_oi(orgmod.GetPointer(), orgmod->GetThisTypeInfo());
            dest_objs.push_back(CMQueryNodeValue::SResolvedField(parent_mod_oi, orgmod_oi));
        }
    }
    else {
        SetFieldsByName(&dest_objs, oi, field_name);
    }
}
 
static void s_SetFeatField(CRef<CSeq_feat> feat, CObjectInfo& oi,const string& field_name, CMQueryNodeValue::TObs& result)
{
    if (field_name.empty())
        return;
 
    if (SetFieldsByName(&result, oi, field_name)) {
        return;
    }
 
    CRef<CGb_qual> new_gbqual(new CGb_qual(field_name, kEmptyStr));
    feat->SetQual().push_back(new_gbqual);
    CObjectInfo gbqual_oi(new_gbqual.GetPointer(), new_gbqual->GetTypeInfo());
    result.push_back(CMQueryNodeValue::SResolvedField(oi, gbqual_oi));
}
 
void CMacroFunction_SwapQual::x_SetField(CConstRef<CObject>& obj, const string& field_name, CMQueryNodeValue::TObs& result)
{
    CObjectInfo oi = m_DataIter->GetEditedObject();
    const CBioSource* cbsrc = dynamic_cast<const CBioSource*>(obj.GetPointer());
    const CSeq_feat* cfeat = dynamic_cast<const CSeq_feat*>(obj.GetPointer());
    if (cbsrc) {
        CBioSource* bsrc = CTypeConverter<CBioSource>::SafeCast(oi.GetObjectPtr());
        return s_SetBioSourceField(Ref(bsrc), oi, field_name, result);
    }
    if (cfeat) {
        CSeq_feat* feat = CTypeConverter<CSeq_feat>::SafeCast(oi.GetObjectPtr());
        return s_SetFeatField(Ref(feat), oi, field_name, result);
    }
}
 
static string s_GetEnumValue(CObjectInfo& obj)
{
    string value;
    if (obj.GetTypeFamily() == eTypeFamilyPrimitive && obj.GetPrimitiveValueType() == ePrimitiveValueEnum) {
        try {
            value = obj.GetPrimitiveValueString();
        }
        catch (const CException&) {
            value = NStr::NumericToString(obj.GetPrimitiveValueInt4(), NStr::fConvErr_NoThrow);
        }
    }
    return value;
}
 
static bool s_SetEnumValue(CObjectInfo& obj, const string& str)
{
    bool set = false;
    if (obj.GetTypeFamily() == eTypeFamilyPrimitive && obj.GetPrimitiveValueType() == ePrimitiveValueEnum) {
        try {
            obj.SetPrimitiveValueString(str);
            set = true;
        }
        catch (const CException&) {
            // if this fails, try to convert the string to int and assign again
            try {
                obj.SetPrimitiveValueInt4(NStr::StringToLong(str));
                set = true;
            }
            catch (const CException&) {}
        }
    }
    return set;
}
 
 
bool CMacroFunction_SwapQual::x_SwapFields(CObjectInfo& src, CObjectInfo& dest)
{
    if (src.GetTypeFamily() != dest.GetTypeFamily() || src.GetTypeFamily() != eTypeFamilyPrimitive) {
        return false;
    }
 
    bool swapped = false;
    if (src.GetPrimitiveValueType() == ePrimitiveValueString) {
        string tmp = src.GetPrimitiveValueString();
        if (dest.GetPrimitiveValueType() == ePrimitiveValueString) {
            src.SetPrimitiveValueString(dest.GetPrimitiveValueString());
            dest.SetPrimitiveValueString(tmp);
            swapped = true;
        }
        else if (dest.GetPrimitiveValueType() == ePrimitiveValueEnum) {
            string dest_value = s_GetEnumValue(dest);
            src.SetPrimitiveValueString(dest_value);
            swapped = s_SetEnumValue(dest, tmp);
        }
    }
    else if (src.GetPrimitiveValueType() == ePrimitiveValueEnum) {
        string tmp = s_GetEnumValue(src);
        if (dest.GetPrimitiveValueType() == ePrimitiveValueString) {
            swapped = s_SetEnumValue(src, dest.GetPrimitiveValueString());
            dest.SetPrimitiveValueString(tmp);
        }
        else if (dest.GetPrimitiveValueType() == ePrimitiveValueEnum) {
            string dest_value = s_GetEnumValue(dest);
            swapped = s_SetEnumValue(src, dest_value);
            swapped = swapped && s_SetEnumValue(dest, tmp);
        }
    }
 
    if (swapped)
        m_QualsChangedCount++;
    return swapped;
}
 
bool CMacroFunction_SwapQual::s_SwapFields(CObjectInfo& src, CObjectInfo& dest)
{
    // swaps primitive values
    // both src and dest should be of primitive type
    if (src.GetTypeFamily() != dest.GetTypeFamily() || src.GetTypeFamily() != eTypeFamilyPrimitive) {
        return false;
    }
 
    switch (src.GetPrimitiveValueType()) {
    case ePrimitiveValueBool: {
        bool tmp = dest.GetPrimitiveValueBool();
        dest.SetPrimitiveValueBool(src.GetPrimitiveValueBool());
        src.SetPrimitiveValueBool(tmp);
        return true;
    }
    case ePrimitiveValueInteger:
    case ePrimitiveValueChar: {
        int tmp = dest.GetPrimitiveValueInt();
        dest.SetPrimitiveValueInt(src.GetPrimitiveValueInt());
        src.SetPrimitiveValueInt(tmp);
        return true;
    }
    case ePrimitiveValueReal: {
        double tmp = dest.GetPrimitiveValueDouble();
        dest.SetPrimitiveValueDouble(src.GetPrimitiveValueDouble());
        src.SetPrimitiveValueDouble(tmp);
        return true;
    }
    case ePrimitiveValueString: {
        string tmp = dest.GetPrimitiveValueString();
        dest.SetPrimitiveValueString(src.GetPrimitiveValueString());
        src.SetPrimitiveValueString(tmp);
        return true;
    }
    case ePrimitiveValueEnum: // to be done
        return false;
    default:
        ;
    }
    return false;
}
 
void CMacroFunction_SwapQual::x_CopyFields(CMQueryNodeValue::TObs& src_objs, CMQueryNodeValue::TObs& dest_objs)
{
    // copy contents of the destination field into the source field
    CMQueryNodeValue::TObs::iterator src_it = src_objs.begin();
    CMQueryNodeValue::TObs::iterator dest_it = dest_objs.begin();
 
    while (src_it != src_objs.end() && dest_it != dest_objs.end()) {
        CMQueryNodeValue::TObs src_prim_objs;
        NMacroUtil::GetPrimitiveObjInfosWithContainers(src_prim_objs, *src_it);
        CMQueryNodeValue::TObs dest_prim_objs;
        NMacroUtil::GetPrimitiveObjInfosWithContainers(dest_prim_objs, *dest_it);
 
        if (dest_prim_objs.empty() && dest_it->field.GetTypeFamily() == eTypeFamilyContainer) {
            // add new element when the container is empty
            CObjectInfo new_oi(dest_it->field.AddNewElement());
            dest_prim_objs.push_back(CMQueryNodeValue::SResolvedField(dest_it->field, new_oi));
        }
        x_CopyFields(src_prim_objs.front().field, dest_prim_objs.front().field);
 
        ++src_it;
        ++dest_it;
    }
}
 
bool CMacroFunction_SwapQual::x_CopyFields(CObjectInfo& src, CObjectInfo& dest)
{
    if (src.GetTypeFamily() != dest.GetTypeFamily() || src.GetTypeFamily() != eTypeFamilyPrimitive) {
        return false;
    }
 
    string src_val;
    if (src.GetPrimitiveValueType() == ePrimitiveValueString) {
        src_val = src.GetPrimitiveValueString();
    }
    else if (src.GetPrimitiveValueType() == ePrimitiveValueEnum) { // codon-start
        src_val = NStr::IntToString(src.GetPrimitiveValueInt());
    }
 
    string dest_val = dest.GetPrimitiveValueString();
    if (edit::AddValueToString(dest_val, src_val, edit::eExistingText_replace_old)) {
        return SetQualStringValue(dest, dest_val);
    }
    return false;
}
 
 
/// class CMacroFunction_SwapRelFeatQual
/// SwapFeatureQual([src_obj,] src_field, dest_feat_subtype, dest_field, update_mrna);
/// 
DEFINE_MACRO_FUNCNAME(CMacroFunction_SwapRelFeatQual, "SwapFeatureQual")
 
void CMacroFunction_SwapRelFeatQual::TheFunction()
{
    CConstRef<CObject> obj = m_DataIter->GetScopedObject().object;
    const CSeq_feat* src_feat = dynamic_cast<const CSeq_feat*>(obj.GetPointer());
    CRef<CScope> scope = m_DataIter->GetScopedObject().scope;
    if (!src_feat || !scope)
        return;
 
    size_t src_index = 0, dest_index = 1;
    if (m_Args.size() == 5) {
        dest_index = 2;
    }
    if (m_Args[dest_index]->GetString().empty() || m_Args[dest_index + 1]->GetString().empty())
        return;
 
    const string& dest_feattype = m_Args[dest_index]->GetString();
    const string& dest_field = m_Args[dest_index + 1]->GetString();
    const string src_field = (m_Args[src_index]->GetDataType() == CMQueryNodeValue::eString) ?
        m_Args[src_index]->GetString() : kEmptyStr;
 
    // reset members
    m_ConstDestFeat.Reset(nullptr);
    m_EditDestFeat.Reset(nullptr);
    m_CreatedFeat.Reset(nullptr);
 
    // check that at least one of the fields exist
    CObjectInfo oi = m_DataIter->GetEditedObject();
    CMQueryNodeValue::TObs src_objs;
    CMQueryNodeValue::TObs dest_objs;
    CSeq_feat* seq_feat = CTypeConverter<CSeq_feat>::SafeCast(oi.GetObjectPtr());
 
    bool src_set = x_DoFieldsExist(oi, src_objs, src_index);
    if (IstRNAProductField(*src_feat, src_field)) {
        src_set = !src_feat->GetData().GetRna().GetRnaProductName().empty();
    }
    bool dest_set = x_DoDestFeatFieldsExist(*src_feat, dest_objs, dest_feattype, dest_field);
 
    if (!src_set && !dest_set)
        return;
 
    if (!src_set) {
        x_SetFields(oi, src_objs, src_index);
    }
    if (!dest_set) {
        x_SetOrCreateDestFeatFields(*src_feat, dest_objs, dest_index + 1);
    }
 
    if (src_set && dest_set) {
        CMQueryNodeValue::TObs::iterator src_it = src_objs.begin();
        CMQueryNodeValue::TObs::iterator dest_it = dest_objs.begin();
 
        while (src_it != src_objs.end() && dest_it != dest_objs.end()) {
            CMQueryNodeValue::TObs src_prim_objs;
            NMacroUtil::GetPrimitiveObjInfosWithContainers(src_prim_objs, *src_it);
            CMQueryNodeValue::TObs dest_prim_objs;
            NMacroUtil::GetPrimitiveObjInfosWithContainers(dest_prim_objs, *dest_it);
            if (dest_prim_objs.empty() && dest_it->field.GetTypeFamily() == eTypeFamilyContainer) {
                // add new element when the container is empty
                CObjectInfo new_oi(dest_it->field.AddNewElement());
                dest_prim_objs.push_back(CMQueryNodeValue::SResolvedField(dest_it->field, new_oi));
            }
            x_SwapFields(src_prim_objs.front().field, dest_prim_objs.front().field);
 
            ++src_it;
            ++dest_it;
        }
 
        if (m_EditDestFeat && IstRNAProductField(*m_EditDestFeat, dest_field)) {
            while (src_it != src_objs.end()) {
                CMQueryNodeValue::TObs src_prim_objs;
                NMacroUtil::GetPrimitiveObjInfosWithContainers(src_prim_objs, *src_it);
 
                string dest_str = m_EditDestFeat->GetData().GetRna().GetRnaProductName();
                CObjectInfo src = src_prim_objs.front().field;
 
                if (src.GetPrimitiveValueType() == ePrimitiveValueString) {
                    string tmp = src.GetPrimitiveValueString();
                    src.SetPrimitiveValueString(dest_str);
                    string remainder;
                    m_EditDestFeat->SetData().SetRna().SetRnaProductName(tmp, remainder);
                    m_QualsChangedCount++;
                }
                ++src_it;
            }
        }
        else if (IstRNAProductField(*src_feat, src_field)) {
            while (dest_it != dest_objs.end()) {
                CMQueryNodeValue::TObs dest_prim_objs;
                NMacroUtil::GetPrimitiveObjInfosWithContainers(dest_prim_objs, *dest_it);
                if (dest_prim_objs.empty() && dest_it->field.GetTypeFamily() == eTypeFamilyContainer) {
                    // add new element when the container is empty
                    CObjectInfo new_oi(dest_it->field.AddNewElement());
                    dest_prim_objs.push_back(CMQueryNodeValue::SResolvedField(dest_it->field, new_oi));
                }
 
                string src_str = src_feat->GetData().GetRna().GetRnaProductName();
                CObjectInfo d = dest_prim_objs.front().field;
                if (d.GetPrimitiveValueType() == ePrimitiveValueString) {
                    string tmp = d.GetPrimitiveValueString();
                    d.SetPrimitiveValueString(src_str);
                    
                    string remainder;
                    seq_feat->SetData().SetRna().SetRnaProductName(tmp, remainder);
                    m_QualsChangedCount++;
                }
                ++dest_it;
            }
        }
    }
    else if (!src_set) {
        // copy destination field into the source field
        x_CopyFields(dest_objs, src_objs);
 
        if (IstRNAProductField(*seq_feat, src_field)) {
            CMQueryNodeValue::TObs::iterator dest_it = dest_objs.begin();
 
            while (dest_it != dest_objs.end()) {
                CMQueryNodeValue::TObs dest_prim_objs;
                NMacroUtil::GetPrimitiveObjInfosWithContainers(dest_prim_objs, *dest_it);
 
                CObjectInfo d = dest_prim_objs.front().field;
                string dest_val;
                if (d.GetPrimitiveValueType() == ePrimitiveValueString) {
                    dest_val = d.GetPrimitiveValueString();
                }
                else if (d.GetPrimitiveValueType() == ePrimitiveValueEnum) { // codon-start
                    dest_val = NStr::IntToString(d.GetPrimitiveValueInt());
                }
 
                string remainder;
                seq_feat->SetData().SetRna().SetRnaProductName(dest_val, remainder);
                m_QualsChangedCount++;
                ++dest_it;
            }
        }
 
        if (m_EditDestFeat && IstRNAProductField(*m_EditDestFeat, dest_field)) {
            CMQueryNodeValue::TObs::iterator src_it = src_objs.begin();
 
            while (src_it != src_objs.end()) {
                CMQueryNodeValue::TObs src_prim_objs;
                NMacroUtil::GetPrimitiveObjInfosWithContainers(src_prim_objs, *src_it);
 
                string rna_str = m_EditDestFeat->GetData().GetRna().GetRnaProductName();
                CObjectInfo src = src_prim_objs.front().field;
                src.SetPrimitiveValueString(rna_str);
                m_QualsChangedCount++;
                ++src_it;
            }
        }
 
        // delete destination field
        if (m_EditDestFeat && IstRNAProductField(*m_EditDestFeat, dest_field)) {
            string remainder;
            m_EditDestFeat->SetData().SetRna().SetRnaProductName(kEmptyStr, remainder);
        }
        
        NON_CONST_ITERATE(CMQueryNodeValue::TObs, it, dest_objs) {
            if (it->parent.GetName() == "Gb-qual" && m_EditDestFeat) {
                const string& qual_name = m_Args[m_Args.size() - 2]->GetString();
                m_EditDestFeat->RemoveQualifier(qual_name);
            }
            else {
                RemoveFieldByName(*it);
            }
        }
    }
    else if (!dest_set) {
        // copy source field into the destination field
        x_CopyFields(src_objs, dest_objs);
 
        if (m_EditDestFeat && IstRNAProductField(*m_EditDestFeat, dest_field)) {
            CMQueryNodeValue::TObs::iterator src_it = src_objs.begin();
 
            while (src_it != src_objs.end()) {
                CMQueryNodeValue::TObs src_prim_objs;
                NMacroUtil::GetPrimitiveObjInfosWithContainers(src_prim_objs, *src_it);
 
                CObjectInfo src = src_prim_objs.front().field;
                string src_val;
                if (src.GetPrimitiveValueType() == ePrimitiveValueString) {
                    src_val = src.GetPrimitiveValueString();
                }
                else if (src.GetPrimitiveValueType() == ePrimitiveValueEnum) { // codon-start
                    src_val = NStr::IntToString(src.GetPrimitiveValueInt());
                }
 
                string remainder;
                m_EditDestFeat->SetData().SetRna().SetRnaProductName(src_val, remainder);
                m_QualsChangedCount++;
                ++src_it;
            }
        }
 
        if (IstRNAProductField(*seq_feat, src_field)) {
            CMQueryNodeValue::TObs::iterator dest_it = dest_objs.begin();
 
            while (dest_it != dest_objs.end()) {
                CMQueryNodeValue::TObs dest_prim_objs;
                NMacroUtil::GetPrimitiveObjInfosWithContainers(dest_prim_objs, *dest_it);
 
                string rna_str = seq_feat->GetData().GetRna().GetRnaProductName();
                CObjectInfo d = dest_prim_objs.front().field;
                d.SetPrimitiveValueString(rna_str);
                m_QualsChangedCount++;
                ++dest_it;
            }
        }
 
        // delete source field
        if (IstRNAProductField(*seq_feat, src_field)) {
            string remainder;
            seq_feat->SetData().SetRna().SetRnaProductName(kEmptyStr, remainder);
        }
        NON_CONST_ITERATE(CMQueryNodeValue::TObs, it, src_objs) {
            RemoveFieldByName(*it);
        }
    }
 
    bool update_mrna = (m_Args.back()->GetDataType() == CMQueryNodeValue::eBool) ? m_Args.back()->GetBool() : false;
 
    CCleanup cleanup;
    cleanup.BasicCleanup(*seq_feat);
    if (m_EditDestFeat) {
        cleanup.BasicCleanup(*m_EditDestFeat);
    }
    else if (m_CreatedFeat) {
        cleanup.BasicCleanup(*m_CreatedFeat);
    }
 
    if (m_QualsChangedCount) {
        m_DataIter->SetModified();
        CNcbiOstrstream log;
        log << m_DataIter->GetBestDescr() << ": swapped " << m_QualsChangedCount << " qualifiers";
 
        CRef<CCmdComposite> cmd;
        if (m_ConstDestFeat && m_EditDestFeat) {
            cmd.Reset(new CCmdComposite("Change Related feature"));
            CSeq_feat_Handle fh = scope->GetSeq_featHandle(*m_ConstDestFeat);
            cmd->AddCommand(*CRef<CCmdChangeSeq_feat>(new CCmdChangeSeq_feat(fh, *m_EditDestFeat)));
            if (update_mrna && m_EditDestFeat->GetData().GetSubtype() == CSeqFeatData::eSubtype_prot) {
                string message;
                CRef<CCmdComposite> upd_cmd = UpdatemRNAProduct(*m_EditDestFeat, *scope, message);
                if (upd_cmd) {
                    cmd->AddCommand(*upd_cmd);
                    log << ", " << message;
                }
            }
        }
        else if (m_CreatedFeat) {
            cmd.Reset(new CCmdComposite("Create feature"));
            CBioseq_Handle bsh = scope->GetBioseqHandle(m_CreatedFeat->GetLocation());
            cmd->AddCommand(*CRef<CCmdCreateFeatBioseq>(new CCmdCreateFeatBioseq(bsh, *m_CreatedFeat)));
            if (update_mrna && m_CreatedFeat->GetData().GetSubtype() == CSeqFeatData::eSubtype_prot) {
                string message;
                CRef<CCmdComposite> upd_cmd = UpdatemRNAProduct(*m_CreatedFeat, *scope, message);
                if (upd_cmd) {
                    cmd->AddCommand(*upd_cmd);
                    log << ", " << message;
                }
            }
        }
        if (cmd) {
            m_DataIter->RunCommand(cmd, m_CmdComposite);
        }
 
        if (update_mrna && src_feat->GetData().GetSubtype() == CSeqFeatData::eSubtype_prot) {
            CSeq_feat* edit_feat = CTypeConverter<CSeq_feat>::SafeCast(oi.GetObjectPtr());
            string prot_product = edit_feat->GetData().GetProt().GetName().front();
            CRef<CCmdComposite> upd_cmd = UpdatemRNAProduct(prot_product, obj, *scope);
            if (upd_cmd) {
                m_DataIter->RunCommand(upd_cmd, m_CmdComposite);
                log << ", applied " + prot_product + " to mRNA product name ";
            }
        }
        x_LogFunction(log);
    }
}
 
bool CMacroFunction_SwapRelFeatQual::x_DoDestFeatFieldsExist(
    const CSeq_feat& src_feat, CMQueryNodeValue::TObs& result, const string& dest_feattype, const string& dest_field)
{
    CSeqFeatData::ESubtype target_feature = NMacroUtil::GetFeatSubtype(dest_feattype);
    NMacroUtil::TVecFeatList feat_list = edit::GetRelatedFeatures(src_feat, target_feature, Ref(&(m_DataIter->GetSEH().GetScope())));
    
    if (!feat_list.empty() && feat_list.size() == 1) {
        m_ConstDestFeat.Reset(feat_list.front());
        m_EditDestFeat.Reset(new CSeq_feat);
        m_EditDestFeat->Assign(*feat_list.front());
        GetFeatDestinationField(m_EditDestFeat, dest_field, result);
 
        if (IstRNAProductField(*m_EditDestFeat, dest_field)) {
            return (!m_EditDestFeat->GetData().GetRna().GetRnaProductName().empty());
            // it might return true but the output argument results is empty!
        }
    }
    return (!result.empty());
}
 
void CMacroFunction_SwapRelFeatQual::x_SetOrCreateDestFeatFields(const CSeq_feat& src_feat, CMQueryNodeValue::TObs& result, size_t index)
{
    if (index >= m_Args.size())
        return;
    const string& dest_field = m_Args[index]->GetString();
 
    if (m_ConstDestFeat && m_EditDestFeat) {
        if (!SetFeatDestinationField(m_EditDestFeat, dest_field, result)) {
            return;
        }
    }
    else {
        // create a new feature
        m_CreatedFeat = CreateNewRelatedFeature(src_feat, dest_field, m_DataIter->GetSEH().GetScope());
        if (!SetFeatDestinationField(m_CreatedFeat, dest_field, result)) {
            return;
        }
 
        if (src_feat.GetData().IsCdregion() && src_feat.IsSetXref() && m_CreatedFeat->GetData().IsProt()) {
            CObjectInfo oi = m_DataIter->GetEditedObject();
            CSeq_feat* edit_feat = CTypeConverter<CSeq_feat>::SafeCast(oi.GetObjectPtr());
            NON_CONST_ITERATE(CSeq_feat::TXref, it, edit_feat->SetXref()) {
                if ((*it)->IsSetData() && (*it)->GetData().IsProt()) {
                    m_CreatedFeat->SetData().SetProt().Assign((*it)->GetData().GetProt());
                    edit_feat->SetXref().erase(it);
                    break;
                }
            }
            if (edit_feat->GetXref().empty()) {
                edit_feat->ResetXref();
            }
        }
    }
}
 
bool CMacroFunction_SwapRelFeatQual::x_ValidArguments() const
{
    if (m_Args.size() < 4 || m_Args.size() > 5) {
        return false;
    }
 
    bool first_ok = (m_Args[0]->IsString() || m_Args[0]->AreObjects() || m_Args[0]->IsRef());
    if (!first_ok) {
        return false;
    }
    for (size_t index = 1; index < m_Args.size() - 1; ++index) {
        if (!m_Args[index]->IsString()) {
            return false;
        }
    }
    return (m_Args.back()->IsBool());
}
 
 
///////////////////////////////////////////////////////////////////////////////
/// class CMacroFunction_ConvertFeatQual
/// ConvertFeatureQual(src_field, dest_feature_type, dest_feature_field, capitalization, strip_name, update_mrna, existing_text_opt, delimiter)
/// The last parameter is optional
/// The function will NOT delete the src_field.
/// To delete the src_field, use RemoveQual() function
/// The related mRNA is only updated if the action is successful and the destination feature is protein
///
DEFINE_MACRO_FUNCNAME(CMacroFunction_ConvertFeatQual, "ConvertFeatureQual");
void CMacroFunction_ConvertFeatQual::TheFunction()
{
    CConstRef<CObject> obj = m_DataIter->GetScopedObject().object;
    const CSeq_feat* src_feat = dynamic_cast<const CSeq_feat*>(obj.GetPointer());
    CRef<CScope> scope = m_DataIter->GetScopedObject().scope;
    if (!src_feat || !scope)
        return;
 
    const string& dest_field = m_Args[2]->GetString();
    if (dest_field.empty())
        return;
 
    CObjectInfo oi = m_DataIter->GetEditedObject();
    CMQueryNodeValue::TObs src_objs;
    if (!x_GetSourceFields(oi, 0, src_objs))
        return;
 
    // the destination field can be set at this point
    CSeqFeatData::ESubtype target_feature = NMacroUtil::GetFeatSubtype(m_Args[1]->GetString());
    NMacroUtil::TVecFeatList feat_list = edit::GetRelatedFeatures(*src_feat, target_feature, scope);
    CMQueryNodeValue::TObs dest_objs;
    bool changed = false, created = false;
    CRef<CSeq_feat> dest_feat;
    CSeq_feat_Handle fh;
    if (!feat_list.empty() && feat_list.size() == 1) {
        dest_feat.Reset(new CSeq_feat);
        dest_feat->Assign(*feat_list.front());
        if (!SetFeatDestinationField(dest_feat, dest_field, dest_objs)) {
            return;
        }
        fh = scope->GetSeq_featHandle(*feat_list.front());
        changed = true;
    }
    else {
        // new feature
        dest_feat = CreateNewRelatedFeature(*src_feat, dest_field, *scope);
        if (!dest_feat) return;
        if (!SetFeatDestinationField(dest_feat, dest_field, dest_objs)) {
            return;
        }
        created = true;
        if (src_feat->GetData().IsCdregion() && src_feat->IsSetXref() && dest_feat->GetData().IsProt()) {
            CSeq_feat* edit_feat = CTypeConverter<CSeq_feat>::SafeCast(oi.GetObjectPtr());
            NON_CONST_ITERATE(CSeq_feat::TXref, it, edit_feat->SetXref()) {
                if ((*it)->IsSetData() && (*it)->GetData().IsProt()) {
                    dest_feat->SetData().SetProt().Assign((*it)->GetData().GetProt());
                    edit_feat->SetXref().erase(it);
                    break;
                }
            }
            if (edit_feat->GetXref().empty()) {
                edit_feat->ResetXref();
            }
        }
    }
 
    size_t index = 3;
    const string& capitalization = m_Args[index]->GetString();
    //bool strip_name = m_Args[++index]->GetBool();
    //strip_name = false; // this option is not implemented (it's false by default)
    ++index;
    bool update_mrna = m_Args[++index]->GetBool();
    const string& action_type = m_Args[++index]->GetString();
    string delimiter = (++index < m_Args.size()) ? m_Args[index]->GetString() : kEmptyStr;
 
    m_ExistingText = NMacroUtil::ActionTypeToExistingTextOption(action_type, delimiter);
    m_CapChange = NMacroUtil::ConvertStringtoCapitalOption(capitalization);
 
    if (IstRNAProductField(*dest_feat, dest_field)) {
        for (auto&& it : src_objs) {
            CMQueryNodeValue::TObs src_prim_objs;
            NMacroUtil::GetPrimitiveObjectInfos(src_prim_objs, it);
 
            CObjectInfo src = src_prim_objs.front().field;
            string src_val = x_GetSourceString(src);
 
            string remainder;
            dest_feat->SetData().SetRna().SetRnaProductName(src_val, remainder);
            m_QualsChangedCount++;
        }
    }
    else {
        ChangeFields(src_objs, dest_objs);
    }
 
    if (m_QualsChangedCount) {
        m_DataIter->SetModified();
        CNcbiOstrstream log;
        log << m_DataIter->GetBestDescr() << ": converted " << m_QualsChangedCount << " qualifiers";
 
        CRef<CCmdComposite> cmd;
        if (changed && fh) {
            cmd.Reset(new CCmdComposite("Change Related feature"));
            cmd->AddCommand(*CRef<CCmdChangeSeq_feat>(new CCmdChangeSeq_feat(fh, *dest_feat)));
        }
        else if (created) {
            cmd.Reset(new CCmdComposite("Create feature"));
            CBioseq_Handle bsh = scope->GetBioseqHandle(dest_feat->GetLocation());
            cmd->AddCommand(*CRef<CCmdCreateFeatBioseq>(new CCmdCreateFeatBioseq(bsh, *dest_feat)));
        }
 
        if (update_mrna) {
            if (dest_feat->GetData().GetSubtype() == CSeqFeatData::eSubtype_prot) {
                string message;
                CRef<CCmdComposite> upd_cmd = UpdatemRNAProduct(*dest_feat, *scope, message);
                if (upd_cmd) {
                    cmd->AddCommand(*upd_cmd);
                    log << ", " << message;
                }
            }
            else if(src_feat->GetData().GetSubtype() == CSeqFeatData::eSubtype_prot) {
                CSeq_feat* edit_feat = CTypeConverter<CSeq_feat>::SafeCast(oi.GetObjectPtr());
                string prot_product = edit_feat->GetData().GetProt().GetName().front();
                CRef<CCmdComposite> upd_cmd = UpdatemRNAProduct(prot_product, obj, *scope);
                if (upd_cmd) {
                    cmd->AddCommand(*upd_cmd);
                    log << ", applied " + prot_product + " to mRNA product name ";
                }
            }
        }
        m_DataIter->RunCommand(cmd, m_CmdComposite);
        x_LogFunction(log);
    }
}
 
bool CMacroFunction_ConvertFeatQual::x_ValidArguments() const
{
    if (m_Args.size() < 7 || m_Args.size() > 8)
        return false;
 
    if (!( m_Args[0]->IsString() || m_Args[0]->AreObjects() || m_Args[0]->IsRef()))
        return false;
 
    for (size_t index = 1; index < m_Args.size(); ++index) {
        auto type = (index != 4 && index != 5) ? CMQueryNodeValue::eString : CMQueryNodeValue::eBool;
        if (m_Args[index]->GetDataType() != type)
            return false;
    }
    return true;
}
 
 
///////////////////////////////////////////////////////////////////////////////
//  CMacroFunction_ConvertRNARelQual
/// ConvertRnaRelQual('rna'/'gene', src_field, 'gene'/'rna', dest_field, capitalization, strip_name, existing_text_opt, delimiter)
/// The last parameter is optional
/// Use this function when you need to convert from/to an RNA qualifier and a Gene qualifier
/// Don't use this function to convert between two RNA qualifiers
DEFINE_MACRO_FUNCNAME(CMacroFunction_ConvertRNARelQual, "ConvertRnaRelQual");
void CMacroFunction_ConvertRNARelQual::TheFunction()
{
    // The iterator should be an RNA feature
    CConstRef<CObject> obj = m_DataIter->GetScopedObject().object;
    const CSeq_feat* rna_feat = dynamic_cast<const CSeq_feat*>(obj.GetPointer());
    CRef<CScope> scope = m_DataIter->GetScopedObject().scope;
    if (!rna_feat || !scope)
        return;
 
    if (rna_feat->IsSetData() && !rna_feat->GetData().IsRna())
        return;
 
    const string& src_feat = m_Args[0]->GetString();
    const string& dest_feat = m_Args[2]->GetString();
    if (src_feat == "rna" && src_feat == dest_feat)
        return;
 
    if ((src_feat != "rna" && src_feat != "gene") || (dest_feat != "rna" && dest_feat != "gene"))
        return;
 
    size_t index = 4;
    const string& capitalization = m_Args[index]->GetString();
    //bool strip_name = m_Args[++index]->GetBool();
    //strip_name = false; // this option is not implemented (it's false by default)
    ++index;
    const string& action_type = m_Args[++index]->GetString();
    string delimiter = (++index < m_Args.size()) ? m_Args[index]->GetString() : kEmptyStr;
    m_ExistingText = NMacroUtil::ActionTypeToExistingTextOption(action_type, delimiter);
    m_CapChange = NMacroUtil::ConvertStringtoCapitalOption(capitalization);
 
    if (src_feat == "rna" && dest_feat == "gene") {
        CObjectInfo oi = m_DataIter->GetEditedObject();
        CMQueryNodeValue::TObs src_objs;
        if (!x_GetSourceFields(oi, 1, src_objs))
            return;
 
        const string dest_field = m_Args[3]->GetString();
        // the destination field can be set at this point
        NMacroUtil::TVecFeatList feat_list = edit::GetRelatedFeatures(*rna_feat, CSeqFeatData::eSubtype_gene, scope);
        CMQueryNodeValue::TObs dest_objs;
        bool changed = false, created = false;
        CRef<CSeq_feat> dest_feat;
        CSeq_feat_Handle fh;
        if (!feat_list.empty() && feat_list.size() == 1) {
            dest_feat.Reset(new CSeq_feat);
            dest_feat->Assign(*feat_list.front());
            if (!SetFeatDestinationField(dest_feat, dest_field, dest_objs)) {
                return;
            }
            fh = scope->GetSeq_featHandle(*feat_list.front());
            changed = true;
        }
        else {
            // new feature
            dest_feat = CreateNewRelatedFeature(*rna_feat, dest_field, *scope);
            if (!dest_feat) return;
            if (!SetFeatDestinationField(dest_feat, dest_field, dest_objs)) {
                return;
            }
            created = true;
        }
 
        ChangeFields(src_objs, dest_objs);
 
        if (m_QualsChangedCount) {
            CRef<CCmdComposite> cmd;
            if (changed && fh) {
                cmd.Reset(new CCmdComposite("Change Related feature"));
                cmd->AddCommand(*CRef<CCmdChangeSeq_feat>(new CCmdChangeSeq_feat(fh, *dest_feat)));
            }
            else if (created) {
                cmd.Reset(new CCmdComposite("Create feature"));
                CBioseq_Handle bsh = scope->GetBioseqHandle(dest_feat->GetLocation());
                cmd->AddCommand(*CRef<CCmdCreateFeatBioseq>(new CCmdCreateFeatBioseq(bsh, *dest_feat)));
            }
 
            m_DataIter->RunCommand(cmd, m_CmdComposite);
            CNcbiOstrstream log;
            log << m_DataIter->GetBestDescr() << ": converted " << m_QualsChangedCount << " qualifiers";
            x_LogFunction(log);
        }
    }
    else if (src_feat == "gene" && dest_feat == "gene") {
        NMacroUtil::TVecFeatList feat_list = edit::GetRelatedFeatures(*rna_feat, CSeqFeatData::eSubtype_gene, scope);
        CMQueryNodeValue::TObs src_objs, dest_objs;
 
        CRef<CSeq_feat> gene_feat;
        CSeq_feat_Handle fh;
        if (!feat_list.empty() && feat_list.size() == 1) {
            gene_feat.Reset(new CSeq_feat);
            gene_feat->Assign(*feat_list.front());
 
            CObjectInfo gene_oi(gene_feat.GetPointer(), gene_feat->GetThisTypeInfo());
            if (!x_GetSourceFields(gene_oi, 1, src_objs))
                return;
 
            if (!x_GetDestFields(gene_oi, 3, dest_objs))
                return;
 
            fh = scope->GetSeq_featHandle(*feat_list.front());
        }
        else {
            // no gene was found
            return;
        }
 
        ChangeFields(src_objs, dest_objs);
 
        if (m_QualsChangedCount) {
            CRef<CCmdComposite> cmd;
            if (fh) {
                cmd.Reset(new CCmdComposite("Change Related feature"));
                cmd->AddCommand(*CRef<CCmdChangeSeq_feat>(new CCmdChangeSeq_feat(fh, *gene_feat)));
            }
 
            m_DataIter->RunCommand(cmd, m_CmdComposite);
            CNcbiOstrstream log;
            log << m_DataIter->GetBestDescr() << ": converted " << m_QualsChangedCount << " qualifiers";
            x_LogFunction(log);
        }
    }
    else if (src_feat == "gene" && dest_feat == "rna") {
 
        NMacroUtil::TVecFeatList feat_list = edit::GetRelatedFeatures(*rna_feat, CSeqFeatData::eSubtype_gene, scope);
        CMQueryNodeValue::TObs src_objs, dest_objs;
        CRef<CSeq_feat> gene_feat;
        if (!feat_list.empty() && feat_list.size() == 1) {
            gene_feat.Reset(new CSeq_feat);
            gene_feat->Assign(*feat_list.front());
 
            CObjectInfo gene_oi(gene_feat.GetPointer(), gene_feat->GetThisTypeInfo());
            if (!x_GetSourceFields(gene_oi, 1, src_objs))
                return;
        }
        else {
            // no gene was found
            return;
        }
 
        CObjectInfo oi = m_DataIter->GetEditedObject();
        if (!x_GetDestFields(oi, 3, dest_objs))
            return;
 
        CSeq_feat* edit_feat = CTypeConverter<CSeq_feat>::SafeCast(oi.GetObjectPtr());
        if (m_Args[3]->IsString() && NStr::EndsWith(m_Args[3]->GetString(), "::product")) {
            for (auto&& it : src_objs) {
                CMQueryNodeValue::TObs src_prim_objs;
                NMacroUtil::GetPrimitiveObjectInfos(src_prim_objs, it);
 
                CObjectInfo src = src_prim_objs.front().field;
                string src_val = x_GetSourceString(src);
 
                string remainder;
                edit_feat->SetData().SetRna().SetRnaProductName(src_val, remainder);
                m_QualsChangedCount++;
            }
        }
        else {
            ChangeFields(src_objs, dest_objs);
        }
 
        if (m_QualsChangedCount) {
            m_DataIter->SetModified();
            CNcbiOstrstream log;
            log << m_DataIter->GetBestDescr() << ": converted " << m_QualsChangedCount << " qualifiers";
            x_LogFunction(log);
        }
    }
}
 
bool CMacroFunction_ConvertRNARelQual::x_ValidArguments() const
{
    auto nr_args = m_Args.size();
    if (nr_args < 7 || nr_args > 8)
        return false;
 
    if (!m_Args[0]->IsString() || !m_Args[2]->IsString())
        return false;
 
    for (size_t index = 1; index < 4; index += 2) {
        if (!(m_Args[index]->IsString() || m_Args[index]->AreObjects() || m_Args[index]->IsRef()))
            return false;
    }
 
    for (size_t index = 4; index < nr_args; ++index) {
        if (index != 5 && !m_Args[index]->IsString())
            return false;
    }
    return (m_Args[5]->IsBool());
}
 
///////////////////////////////////////////////////////////////////////////////
/// class CMacroFunction_ParseStringQual - used when parsing SeqId
/// ParseStringQual(from_field, to_field, capitalization, existing_text_opt, delimiter) // when all the text should be copied
/// Last parameter is optional
///
DEFINE_MACRO_FUNCNAME(CMacroFunction_ParseStringQual, "ParseStringQual");
void CMacroFunction_ParseStringQual::TheFunction()
{
    CObjectInfo oi = m_DataIter->GetEditedObject();
    CMQueryNodeValue::TObs src_objs;
    size_t index = 0;
    if (!x_GetSourceFields(oi, index, src_objs))
        return;
 
    CMQueryNodeValue::TObs dest_objs;
    if (!x_GetDestFields(oi, ++index, dest_objs))
        return;
 
    const string& capitalization = m_Args[++index]->GetString();
    const string& action_type = m_Args[++index]->GetString();
    string delimiter = (++index < m_Args.size()) ? m_Args[index]->GetString() : kEmptyStr;
 
    m_ExistingText = NMacroUtil::ActionTypeToExistingTextOption(action_type, delimiter);
    m_CapChange = NMacroUtil::ConvertStringtoCapitalOption(capitalization);
 
    CConstRef<CObject> obj = m_DataIter->GetScopedObject().object;
    const CSeq_feat* src_feat = dynamic_cast<const CSeq_feat*>(obj.GetPointer());
    if (src_feat && m_Args[1]->IsString() && NStr::EndsWith(m_Args[1]->GetString(), "::product")) {
        CSeq_feat* edit_feat = CTypeConverter<CSeq_feat>::SafeCast(oi.GetObjectPtr());
        for (auto&& it : src_objs) {
            CMQueryNodeValue::TObs src_prim_objs;
            NMacroUtil::GetPrimitiveObjectInfos(src_prim_objs, it);
 
            CObjectInfo src = src_prim_objs.front().field;
            string src_val = x_GetSourceString(src);
 
            string remainder;
            edit_feat->SetData().SetRna().SetRnaProductName(src_val, remainder);
            m_QualsChangedCount++;
        }
    }
    else {
        ChangeFields(src_objs, dest_objs);
    }
    if (m_QualsChangedCount) {
        if (!dest_objs.empty()) {
            NMacroUtil::CleanupForTaxnameChange(dest_objs.front(), oi);
        }
        m_DataIter->SetModified();
        CNcbiOstrstream log;
        log << m_DataIter->GetBestDescr() << ": parsed " << m_QualsChangedCount << " qualifiers";
        x_LogFunction(log);
    }
}
 
bool CMacroFunction_ParseStringQual::x_ChangeFields(CObjectInfo& src, CObjectInfo& dest)
{
    if (dest.GetTypeFamily() != eTypeFamilyPrimitive) {
        return false;
    }
 
    _ASSERT(dest.GetPrimitiveValueType() == ePrimitiveValueString);
 
    string src_val = x_GetSourceString(src);
    string dest_val = dest.GetPrimitiveValueString();
    if (edit::AddValueToString(dest_val, src_val, m_ExistingText)) {
        return SetQualStringValue(dest, dest_val);
    }
    return false;
}
 
string CMacroFunction_ParseStringQual::x_GetSourceString(CObjectInfo& src)
{
    string src_val = IOperateOnTwoQuals::x_GetSourceString(src);
    // it copies the whole string
    CSeq_entry_Handle seh = m_DataIter->GetSEH();
    FixCapitalizationInString(seh, src_val, m_CapChange);
    return src_val;
}
 
bool CMacroFunction_ParseStringQual::x_ValidArguments(void) const
{
    size_t as = m_Args.size();
    if (as < 1 || as > 5) {
        return false;
    }
    for (size_t i = 0; i < 2; ++i) {
        if (!(m_Args[i]->IsString() || m_Args[i]->AreObjects() || m_Args[i]->IsRef()))
            return false;
    }
    for (size_t index = 2; index < as; ++index) {
        if (!m_Args[index]->IsString()) {
            return false;
        }
    }
    return true;
}
 
 
///////////////////////////////////////////////////////////////////////////////
/// class CMacroFunction_ParseFeatQual
/// ParseFeatureQual(src_field, dest_feature_type, dest_feature_field, capitalization, update_mrna, existing_text_opt, delimiter)
/// The last parameter is optional
/// The related mRNA is only updated if the action is successful and the destination feature is protein
///
DEFINE_MACRO_FUNCNAME(CMacroFunction_ParseFeatQual, "ParseFeatureQual");
void CMacroFunction_ParseFeatQual::TheFunction()
{
    CConstRef<CObject> obj = m_DataIter->GetScopedObject().object;
    const CSeq_feat* src_feat = dynamic_cast<const CSeq_feat*>(obj.GetPointer());
    CRef<CScope> scope = m_DataIter->GetScopedObject().scope;
    if (!src_feat || !scope)
        return;
 
    const string& dest_field = m_Args[2]->GetString();
    if (dest_field.empty())
        return;
 
    CObjectInfo oi = m_DataIter->GetEditedObject();
    CMQueryNodeValue::TObs src_objs;
    if (!x_GetSourceFields(oi, 0, src_objs))
        return;
 
    // the destination field can be set at this point
    CSeqFeatData::ESubtype target_feature = NMacroUtil::GetFeatSubtype(m_Args[1]->GetString());
    NMacroUtil::TVecFeatList feat_list = edit::GetRelatedFeatures(*src_feat, target_feature, scope);
    CMQueryNodeValue::TObs dest_objs;
    bool changed = false, created = false;
    CRef<CSeq_feat> dest_feat;
    CSeq_feat_Handle fh;
    if (!feat_list.empty() && feat_list.size() == 1) {
        dest_feat.Reset(new CSeq_feat);
        dest_feat->Assign(*feat_list.front());
        if (!SetFeatDestinationField(dest_feat, dest_field, dest_objs)) {
            return;
        }
        fh = scope->GetSeq_featHandle(*feat_list.front());
        changed = true;
    }
    else {
        // new feature
        dest_feat = CreateNewRelatedFeature(*src_feat, dest_field, *scope);
        if (!dest_feat) return;
        if (!SetFeatDestinationField(dest_feat, dest_field, dest_objs)) {
            return;
        }
        created = true;
        if (src_feat->GetData().IsCdregion() && src_feat->IsSetXref() && dest_feat->GetData().IsProt()) {
            CSeq_feat* edit_feat = CTypeConverter<CSeq_feat>::SafeCast(oi.GetObjectPtr());
            NON_CONST_ITERATE(CSeq_feat::TXref, it, edit_feat->SetXref()) {
                if ((*it)->IsSetData() && (*it)->GetData().IsProt()) {
                    dest_feat->SetData().SetProt().Assign((*it)->GetData().GetProt());
                    edit_feat->SetXref().erase(it);
                    break;
                }
            }
            if (edit_feat->GetXref().empty()) {
                edit_feat->ResetXref();
            }
        }
    }
 
    size_t index = 3;
    const string& capitalization = m_Args[index]->GetString();
    bool update_mrna = m_Args[++index]->GetBool();
    const string& action_type = m_Args[++index]->GetString();
    string delimiter = (++index < m_Args.size()) ? m_Args[index]->GetString() : kEmptyStr;
 
    m_ExistingText = NMacroUtil::ActionTypeToExistingTextOption(action_type, delimiter);
    m_CapChange = NMacroUtil::ConvertStringtoCapitalOption(capitalization);
 
    if (IstRNAProductField(*dest_feat, dest_field)) {
        for (auto&& it : src_objs) {
            CMQueryNodeValue::TObs src_prim_objs;
            NMacroUtil::GetPrimitiveObjectInfos(src_prim_objs, it);
 
            CObjectInfo src = src_prim_objs.front().field;
            string src_val = x_GetSourceString(src);
 
            string remainder;
            dest_feat->SetData().SetRna().SetRnaProductName(src_val, remainder);
            m_QualsChangedCount++;
        }
    }
    else {
        ChangeFields(src_objs, dest_objs);
    }
 
    if (m_QualsChangedCount) {
        m_DataIter->SetModified();
        CNcbiOstrstream log;
        log << m_DataIter->GetBestDescr() << ": parsed " << m_QualsChangedCount << " qualifiers";
 
        CRef<CCmdComposite> cmd;
        if (changed && fh) {
            cmd.Reset(new CCmdComposite("Change Related feature"));
            cmd->AddCommand(*CRef<CCmdChangeSeq_feat>(new CCmdChangeSeq_feat(fh, *dest_feat)));
        }
        else if (created) {
            cmd.Reset(new CCmdComposite("Create feature"));
            CBioseq_Handle bsh = scope->GetBioseqHandle(dest_feat->GetLocation());
            cmd->AddCommand(*CRef<CCmdCreateFeatBioseq>(new CCmdCreateFeatBioseq(bsh, *dest_feat)));
        }
 
        if (update_mrna) {
            if (dest_feat->GetData().GetSubtype() == CSeqFeatData::eSubtype_prot) {
                string message;
                CRef<CCmdComposite> upd_cmd = UpdatemRNAProduct(*dest_feat, *scope, message);
                if (upd_cmd) {
                    cmd->AddCommand(*upd_cmd);
                    log << ", " << message;
                }
            }
            else if (src_feat->GetData().GetSubtype() == CSeqFeatData::eSubtype_prot) {
                CSeq_feat* edit_feat = CTypeConverter<CSeq_feat>::SafeCast(oi.GetObjectPtr());
                string prot_product = edit_feat->GetData().GetProt().GetName().front();
                CRef<CCmdComposite> upd_cmd = UpdatemRNAProduct(prot_product, obj, *scope);
                if (upd_cmd) {
                    cmd->AddCommand(*upd_cmd);
                    log << ", applied " + prot_product + " to mRNA product name ";
                }
            }
        }
        m_DataIter->RunCommand(cmd, m_CmdComposite);
        x_LogFunction(log);
    }
}
 
bool CMacroFunction_ParseFeatQual::x_ValidArguments() const
{
    if (m_Args.size() < 6 || m_Args.size() > 7)
        return false;
 
    CMQueryNodeValue::EType type = m_Args[0]->GetDataType();
    bool first_ok = (type == CMQueryNodeValue::eString)
        || (type == CMQueryNodeValue::eObjects)
        || (type == CMQueryNodeValue::eRef);
    if (!first_ok)
        return false;
 
    for (size_t index = 1; index < m_Args.size(); ++index) {
        type = (index != 4) ? CMQueryNodeValue::eString : CMQueryNodeValue::eBool;
        if (m_Args[index]->GetDataType() != type)
            return false;
    }
    return true;
}
 
 
///////////////////////////////////////////////////////////////////////////////
// class CMacroFunction_ParseRNARelQual
/// ParseRnaRelQual('rna'/'gene', src_field, 'gene'/'rna', dest_field, capitalization, existing_text_opt, delimiter)
/// The last parameter is optional
/// Use this function when you need to convert from/to an RNA qualifier and a Gene qualifier
/// Don't use this function to convert between two RNA qualifiers
DEFINE_MACRO_FUNCNAME(CMacroFunction_ParseRNARelQual, "ParseRnaRelQual");
void CMacroFunction_ParseRNARelQual::TheFunction()
{
    // The iterator should be an RNA feature
    CConstRef<CObject> obj = m_DataIter->GetScopedObject().object;
    const CSeq_feat* rna_feat = dynamic_cast<const CSeq_feat*>(obj.GetPointer());
    CRef<CScope> scope = m_DataIter->GetScopedObject().scope;
    if (!rna_feat || !scope)
        return;
 
    if (rna_feat->IsSetData() && !rna_feat->GetData().IsRna())
        return;
 
    const string& src_feat = m_Args[0]->GetString();
    const string& dest_feat = m_Args[2]->GetString();
    if (src_feat == "rna" && src_feat == dest_feat)
        return;
 
    if ((src_feat != "rna" && src_feat != "gene") || (dest_feat != "rna" && dest_feat != "gene"))
        return;
 
    size_t index = 4;
    const string& capitalization = m_Args[index]->GetString();
    const string& action_type = m_Args[++index]->GetString();
    string delimiter = (++index < m_Args.size()) ? m_Args[index]->GetString() : kEmptyStr;
    m_ExistingText = NMacroUtil::ActionTypeToExistingTextOption(action_type, delimiter);
    m_CapChange = NMacroUtil::ConvertStringtoCapitalOption(capitalization);
 
    if (src_feat == "rna" && dest_feat == "gene") {
        CObjectInfo oi = m_DataIter->GetEditedObject();
        CMQueryNodeValue::TObs src_objs;
        if (!x_GetSourceFields(oi, 1, src_objs))
            return;
 
        const string dest_field = m_Args[3]->GetString();
        // the destination field can be set at this point
        NMacroUtil::TVecFeatList feat_list = edit::GetRelatedFeatures(*rna_feat, CSeqFeatData::eSubtype_gene, scope);
        CMQueryNodeValue::TObs dest_objs;
        bool changed = false, created = false;
        CRef<CSeq_feat> dest_feat;
        CSeq_feat_Handle fh;
        if (!feat_list.empty() && feat_list.size() == 1) {
            dest_feat.Reset(new CSeq_feat);
            dest_feat->Assign(*feat_list.front());
            if (!SetFeatDestinationField(dest_feat, dest_field, dest_objs)) {
                return;
            }
            fh = scope->GetSeq_featHandle(*feat_list.front());
            changed = true;
        }
        else {
            // new feature
            dest_feat = CreateNewRelatedFeature(*rna_feat, dest_field, *scope);
            if (!dest_feat) return;
            if (!SetFeatDestinationField(dest_feat, dest_field, dest_objs)) {
                return;
            }
            created = true;
        }
 
        ChangeFields(src_objs, dest_objs);
 
        if (m_QualsChangedCount) {
            CRef<CCmdComposite> cmd;
            if (changed && fh) {
                cmd.Reset(new CCmdComposite("Change Related feature"));
                cmd->AddCommand(*CRef<CCmdChangeSeq_feat>(new CCmdChangeSeq_feat(fh, *dest_feat)));
            }
            else if (created) {
                cmd.Reset(new CCmdComposite("Create feature"));
                CBioseq_Handle bsh = scope->GetBioseqHandle(dest_feat->GetLocation());
                cmd->AddCommand(*CRef<CCmdCreateFeatBioseq>(new CCmdCreateFeatBioseq(bsh, *dest_feat)));
            }
 
            m_DataIter->RunCommand(cmd, m_CmdComposite);
            CNcbiOstrstream log;
            log << m_DataIter->GetBestDescr() << ": parsed " << m_QualsChangedCount << " qualifiers";
            x_LogFunction(log);
        }
    }
    else if (src_feat == "gene" && dest_feat == "gene") {
        NMacroUtil::TVecFeatList feat_list = edit::GetRelatedFeatures(*rna_feat, CSeqFeatData::eSubtype_gene, scope);
        CMQueryNodeValue::TObs src_objs, dest_objs;
 
        CRef<CSeq_feat> gene_feat;
        CSeq_feat_Handle fh;
        if (!feat_list.empty() && feat_list.size() == 1) {
            gene_feat.Reset(new CSeq_feat);
            gene_feat->Assign(*feat_list.front());
 
            CObjectInfo gene_oi(gene_feat.GetPointer(), gene_feat->GetThisTypeInfo());
            if (!x_GetSourceFields(gene_oi, 1, src_objs))
                return;
 
            if (!x_GetDestFields(gene_oi, 3, dest_objs))
                return;
 
            fh = scope->GetSeq_featHandle(*feat_list.front());
        }
        else {
            // no gene was found
            return;
        }
 
        ChangeFields(src_objs, dest_objs);
 
        if (m_QualsChangedCount) {
            CRef<CCmdComposite> cmd;
            if (fh) {
                cmd.Reset(new CCmdComposite("Change Related feature"));
                cmd->AddCommand(*CRef<CCmdChangeSeq_feat>(new CCmdChangeSeq_feat(fh, *gene_feat)));
            }
 
            m_DataIter->RunCommand(cmd, m_CmdComposite);
            CNcbiOstrstream log;
            log << m_DataIter->GetBestDescr() << ": parsed " << m_QualsChangedCount << " qualifiers";
            x_LogFunction(log);
        }
    }
    else if (src_feat == "gene" && dest_feat == "rna") {
        NMacroUtil::TVecFeatList feat_list = edit::GetRelatedFeatures(*rna_feat, CSeqFeatData::eSubtype_gene, scope);
        CMQueryNodeValue::TObs src_objs, dest_objs;
        CRef<CSeq_feat> gene_feat;
        if (!feat_list.empty() && feat_list.size() == 1) {
            gene_feat.Reset(new CSeq_feat);
            gene_feat->Assign(*feat_list.front());
 
            CObjectInfo gene_oi(gene_feat.GetPointer(), gene_feat->GetThisTypeInfo());
            if (!x_GetSourceFields(gene_oi, 1, src_objs))
                return;
        }
        else {
            // no gene was found
            return;
        }
 
        CObjectInfo oi = m_DataIter->GetEditedObject();
        if (!x_GetDestFields(oi, 3, dest_objs))
            return;
 
        CSeq_feat* edit_feat = CTypeConverter<CSeq_feat>::SafeCast(oi.GetObjectPtr());
        if (m_Args[3]->IsString() && NStr::EndsWith(m_Args[3]->GetString(), "::product")) {
            for (auto&& it : src_objs) {
                CMQueryNodeValue::TObs src_prim_objs;
                NMacroUtil::GetPrimitiveObjectInfos(src_prim_objs, it);
 
                CObjectInfo src = src_prim_objs.front().field;
                string src_val = x_GetSourceString(src);
 
                string remainder;
                edit_feat->SetData().SetRna().SetRnaProductName(src_val, remainder);
                m_QualsChangedCount++;
            }
        }
        else {
            ChangeFields(src_objs, dest_objs);
        }
 
        if (m_QualsChangedCount) {
            m_DataIter->SetModified();
            CNcbiOstrstream log;
            log << m_DataIter->GetBestDescr() << ": parsed " << m_QualsChangedCount << " qualifiers";
            x_LogFunction(log);
        }
    }
}
 
bool CMacroFunction_ParseRNARelQual::x_ValidArguments() const
{
    if (m_Args.size() < 6 || m_Args.size() > 7)
        return false;
 
    if (!m_Args[0]->IsString() || !m_Args[2]->IsString())
        return false;
 
    for (size_t index = 1; index < 4; index += 2) {
        if (!(m_Args[index]->IsString() || m_Args[index]->AreObjects() || m_Args[index]->IsRef()))
            return false;
    }
    for (size_t index = 4; index < m_Args.size(); ++index) {
        if (!m_Args[index]->IsString())
            return false;
    }
    return true;
}
 
 
/// class CMacroFunction_AddParsedText
/// AddParsedText(parsed_text, to_field, capitalization, existing_text_opt, delimiter)
/// Deprecated name: AECRParseStringQual
/// when only the "text" portion is copied 
/// The capitalization change applies to the parsed text portion
/// 
DEFINE_MACRO_FUNCNAME(CMacroFunction_AddParsedText, "AddParsedText");
 
void CMacroFunction_AddParsedText::TheFunction()
{
    CObjectInfo oi = m_DataIter->GetEditedObject();
 
    // obtain the wanted text portion
    CMQueryNodeValue& parsed_obj = m_Args[0].GetNCObject();
    parsed_obj.Dereference();
    if (parsed_obj.GetDataType() != CMQueryNodeValue::eString) {
        return;
    }
    string text_portion = parsed_obj.GetString();
    if (text_portion.empty()) {
        return;
    }
    size_t index = 1;
    // the destination field might be set during this action
    CMQueryNodeValue::TObs dest_objs;
    CMQueryNodeValue::EType dest_type = m_Args[index]->GetDataType();
 
    if (dest_type == CMQueryNodeValue::eString) {
        const string& dest_field = m_Args[index]->GetString();
        CConstRef<CObject> obj = m_DataIter->GetScopedObject().object;
        GetDestinationObjects(obj, oi, dest_field, dest_objs);
    }
    else if (dest_type == CMQueryNodeValue::eObjects) {
        dest_objs = m_Args[index]->GetObjects();
    }
    else if (dest_type == CMQueryNodeValue::eRef) {
        x_GetObjectsFromRef(dest_objs, index);
    }
 
    if (dest_objs.empty()) {
        return;
    }
 
    const string& capitalization = m_Args[++index]->GetString();
    const string& action_type = m_Args[++index]->GetString();
    string delimiter = (++index < m_Args.size()) ? m_Args[index]->GetString() : kEmptyStr;
 
    edit::EExistingText existing_text = NMacroUtil::ActionTypeToExistingTextOption(action_type, delimiter);
    ECapChange cap_change = NMacroUtil::ConvertStringtoCapitalOption(capitalization);
 
    CSeq_entry_Handle seh = m_DataIter->GetSEH();
    FixCapitalizationInString(seh, text_portion, cap_change);
    x_ParseFields(dest_objs, text_portion, existing_text);
 
    if (m_QualsChangedCount) {
        NMacroUtil::CleanupForTaxnameChange(dest_objs.front(), oi);
        m_DataIter->SetModified();
        CNcbiOstrstream log;
        log << m_DataIter->GetBestDescr() << ": parsed " << m_QualsChangedCount << " fields";
        x_LogFunction(log);
    }
}
 
void CMacroFunction_AddParsedText::x_ParseFields(CMQueryNodeValue::TObs& dest_objs, 
    const string& text_portion, edit::EExistingText existing_text)
{
    CMQueryNodeValue::TObs objs;
    NMacroUtil::GetPrimitiveObjectInfos(objs, dest_objs.front());
    if (objs.empty() && dest_objs.front().field.GetTypeFamily() == eTypeFamilyContainer) {
        // add new element when the container is empty
        CObjectInfo new_oi(dest_objs.front().field.AddNewElement());
        objs.push_back(CMQueryNodeValue::SResolvedField(dest_objs.front().field, new_oi));
    }
    CObjectInfo dest = objs.front().field;
    _ASSERT(dest.GetPrimitiveValueType() == ePrimitiveValueString);
 
    if (dest.GetPrimitiveValueType() == ePrimitiveValueString) {
 
        string dest_val = dest.GetPrimitiveValueString();
        if (edit::AddValueToString(dest_val, text_portion, existing_text)) {
            SetQualStringValue(dest, dest_val);
        }
    }
}
 
 
bool CMacroFunction_AddParsedText::x_ValidArguments(void) const
{
    size_t as = m_Args.size();
    if (as != 4 && as != 5) {
        return false;
    }
 
    if (m_Args[0]->GetDataType() != CMQueryNodeValue::eRef) {
        return false;
    }
 
    CMQueryNodeValue::EType type = m_Args[1]->GetDataType();
    bool type_ok = (type == CMQueryNodeValue::eString)
        || (type == CMQueryNodeValue::eObjects)
        || (type == CMQueryNodeValue::eRef);
    if (!type_ok)
        return false;
 
    for (size_t index = 2; index < as; ++index) {
        if (m_Args[index]->GetDataType() != CMQueryNodeValue::eString) {
            return false;
        }
    }
 
    return true;
}
 
// class CMacroFunction_AddParsedFeatQual
/// AddParsedTextToFeatureQual(parsed_text, dest_feature_type, dest_feature_field, capitalization, update_mrna, existing_text_opt, delimiter)
/// The last parameter is optional
/// The related mRNA is only updated if the action is successful and the destination feature is protein
DEFINE_MACRO_FUNCNAME(CMacroFunction_AddParsedToFeatQual, "AddParsedTextToFeatureQual");
void CMacroFunction_AddParsedToFeatQual::TheFunction()
{
    CConstRef<CObject> obj = m_DataIter->GetScopedObject().object;
    const CSeq_feat* src_feat = dynamic_cast<const CSeq_feat*>(obj.GetPointer());
    CRef<CScope> scope = m_DataIter->GetScopedObject().scope;
    if (!src_feat || !scope)
        return;
 
    CObjectInfo oi = m_DataIter->GetEditedObject();
 
    // obtain the wanted text portion
    CMQueryNodeValue& parsed_obj = m_Args[0].GetNCObject();
    parsed_obj.Dereference();
    if (parsed_obj.GetDataType() != CMQueryNodeValue::eString) {
        return;
    }
    string text_portion = parsed_obj.GetString();
    if (text_portion.empty()) {
        return;
    }
 
    const string& dest_field = m_Args[2]->GetString();
    if (dest_field.empty())
        return;
 
    // the destination field can be set at this point
    CSeqFeatData::ESubtype target_feature = NMacroUtil::GetFeatSubtype(m_Args[1]->GetString());
    NMacroUtil::TVecFeatList feat_list = edit::GetRelatedFeatures(*src_feat, target_feature, scope);
    CMQueryNodeValue::TObs dest_objs;
    bool changed = false, created = false;
    CRef<CSeq_feat> dest_feat;
    CSeq_feat_Handle fh;
 
    if (!feat_list.empty() && feat_list.size() == 1) {
        dest_feat.Reset(new CSeq_feat);
        dest_feat->Assign(*feat_list.front());
        if (!SetFeatDestinationField(dest_feat, dest_field, dest_objs)) {
            return;
        }
        fh = scope->GetSeq_featHandle(*feat_list.front());
        changed = true;
    }
    else {
        // new feature
        dest_feat = CreateNewRelatedFeature(*src_feat, dest_field, *scope);
        if (!dest_feat) return;
        if (!SetFeatDestinationField(dest_feat, dest_field, dest_objs)) {
            return;
        }
        created = true;
        if (src_feat->GetData().IsCdregion() && src_feat->IsSetXref() && dest_feat->GetData().IsProt()) {
            CSeq_feat* edit_feat = CTypeConverter<CSeq_feat>::SafeCast(oi.GetObjectPtr());
            NON_CONST_ITERATE(CSeq_feat::TXref, it, edit_feat->SetXref()) {
                if ((*it)->IsSetData() && (*it)->GetData().IsProt()) {
                    dest_feat->SetData().SetProt().Assign((*it)->GetData().GetProt());
                    edit_feat->SetXref().erase(it);
                    break;
                }
            }
            if (edit_feat->GetXref().empty()) {
                edit_feat->ResetXref();
            }
        }
    }
 
    size_t index = 3;
    const string& capitalization = m_Args[index]->GetString();
    bool update_mrna = m_Args[++index]->GetBool();
    const string& action_type = m_Args[++index]->GetString();
    string delimiter = (++index < m_Args.size()) ? m_Args[index]->GetString() : kEmptyStr;
 
    edit::EExistingText existing_text = NMacroUtil::ActionTypeToExistingTextOption(action_type, delimiter);
    ECapChange cap_change = NMacroUtil::ConvertStringtoCapitalOption(capitalization);
 
    CSeq_entry_Handle seh = m_DataIter->GetSEH();
    FixCapitalizationInString(seh, text_portion, cap_change);
    if (IstRNAProductField(*dest_feat, dest_field)) {
        string remainder;
        dest_feat->SetData().SetRna().SetRnaProductName(text_portion, remainder);
        m_QualsChangedCount++;
    }
    else {
        x_ParseFields(dest_objs, text_portion, existing_text);
    }
 
    if (m_QualsChangedCount) {
        m_DataIter->SetModified();
        CNcbiOstrstream log;
        log << m_DataIter->GetBestDescr() << ": parsed " << m_QualsChangedCount << " fields";
 
        if (changed && fh) {
            CRef<CCmdComposite> cmd(new CCmdComposite("Change Related feature"));
            cmd->AddCommand(*CRef<CCmdChangeSeq_feat>(new CCmdChangeSeq_feat(fh, *dest_feat)));
            m_DataIter->RunCommand(cmd, m_CmdComposite);
        }
        else if (created) {
            CRef<CCmdComposite> cmd(new CCmdComposite("Create feature"));
            CBioseq_Handle bsh = scope->GetBioseqHandle(dest_feat->GetLocation());
            cmd->AddCommand(*CRef<CCmdCreateFeatBioseq>(new CCmdCreateFeatBioseq(bsh, *dest_feat)));
            m_DataIter->RunCommand(cmd, m_CmdComposite);
        }
 
        if (update_mrna && dest_feat->GetData().GetSubtype() == CSeqFeatData::eSubtype_prot) {
            string message;
            CRef<CCmdComposite> cmd = UpdatemRNAProduct(*dest_feat, *scope, message);
            if (cmd) {
                m_DataIter->RunCommand(cmd, m_CmdComposite);
                log << ", " << message;
            }
        }
        x_LogFunction(log);
    }
}
 
bool CMacroFunction_AddParsedToFeatQual::x_ValidArguments() const
{
    if (m_Args.size() < 6 || m_Args.size() > 7)
        return false;
    
    if (m_Args[0]->GetDataType() != CMQueryNodeValue::eRef) {
        return false;
    }
    CMQueryNodeValue::EType type;
    for (size_t index = 1; index < m_Args.size(); ++index) {
        type = (index != 4) ? CMQueryNodeValue::eString : CMQueryNodeValue::eBool;
        if (m_Args[index]->GetDataType() != type)
            return false;
    }
    return true;
 
}
 
///////////////////////////////////////////////////////////////////////////////
// class CMacroFunction_ParseToStructComm
/// ParseToStructComment(text/src_field, structcomm_field ("fieldvalue"|"dbname"|"fieldname"), [fieldname,] 
/// capitalization, existing_text_opt, delimiter))
///
DEFINE_MACRO_FUNCNAME(CMacroFunction_ParseToStructComm, "ParseToStructComment")
 
void CMacroFunction_ParseToStructComm::TheFunction()
{
    CConstRef<CObject> object = m_DataIter->GetScopedObject().object;
    CRef<CScope> scope = m_DataIter->GetScopedObject().scope;
    if (!scope || !object)
        return;
 
    CObjectInfo oi = m_DataIter->GetEditedObject();
    size_t index = 0;
 
    CMQueryNodeValue text_holder;
    string text_portion;
 
    CMQueryNodeValue::TObs res_oi;
    CMQueryNodeValue::EType type = m_Args[index]->GetDataType();
    if (type == CMQueryNodeValue::eString) {
        const string& field = m_Args[0]->GetString();
        ResolveIdentToSimple(oi, field, text_holder);
        GetFieldsByName(&res_oi, oi, field);
    }
    else if (type == CMQueryNodeValue::eObjects) {
        res_oi = m_Args[index]->GetObjects();
        if (!res_oi.empty()) {
            ResolveIdentToSimple(res_oi.front().field, kEmptyStr, text_holder);
        }
    }
    else if (type == CMQueryNodeValue::eRef) {
        CMQueryNodeValue& objs = m_Args[index].GetNCObject();
        objs.Dereference();
 
        if (objs.GetDataType() == CMQueryNodeValue::eObjects) {
            res_oi = objs.GetObjects();
            if (!res_oi.empty()) {
                ResolveIdentToSimple(res_oi.front().field, kEmptyStr, text_holder);
            }
        }
        else if (objs.GetDataType() == CMQueryNodeValue::eString) {
            text_portion = objs.GetString();
        }
    }
 
    if (text_holder.GetDataType() == CMQueryNodeValue::eString && text_portion.empty()) {
        text_portion = text_holder.GetString();
    }
 
    if (text_portion.empty())
        return;
    
    x_SetFieldType(m_Args[++index]->GetString());
    string fieldname = (m_Type == eFieldValue) ? m_Args[++index]->GetString() : kEmptyStr;
    if (m_Type == eFieldError) {
        NCBI_THROW(CMacroExecException, eWrongArguments, "Wrong structured comment fieldname is given (consider replacing it with either 'fieldvalue', 'dbname' or 'fieldname'");
    }
 
    string capitalization, action_type;
    if (++index < m_Args.size()) {
        capitalization = m_Args[index]->GetString();
    }
    if (++index < m_Args.size()) {
        action_type = m_Args[index]->GetString();
    }
    if (capitalization.empty() || action_type.empty()) {
        NCBI_THROW(CMacroExecException, eWrongArguments, "Wrong arguments specified");
    }
 
    string delimiter = (++index < m_Args.size()) ? m_Args[index]->GetString() : kEmptyStr;
    
    ECapChange cap_change = NMacroUtil::ConvertStringtoCapitalOption(capitalization);
    CSeq_entry_Handle seh = m_DataIter->GetSEH();
    FixCapitalizationInString(seh, text_portion, cap_change);
 
    edit::EExistingText existing_text = NMacroUtil::ActionTypeToExistingTextOption(action_type, delimiter);
    CBioseq_Handle bsh = m_DataIter->GetBioseqHandle();
    if (!bsh)
        return;
 
    CRef<CCmdComposite> cmd;
    CSeqdesc_CI strcomm_it(bsh, CSeqdesc::e_User);
    // obtain the existing structured comment
    for ( ; strcomm_it; ++strcomm_it) {
        if (CComment_rule::IsStructuredComment(strcomm_it->GetUser())) {
            break;
        }
    }
    const string kPrefix = "StructuredCommentPrefix";
    const string kSuffix = "StructuredCommentSuffix";
 
    if (strcomm_it) {
        CRef<CSeqdesc> new_desc(new CSeqdesc);
        new_desc->Assign(*strcomm_it);
 
        CUser_object& user_object = new_desc->SetUser();
        if (existing_text == edit::eExistingText_add_qual) {
            // add a new field to the structured comment
            if (m_Type == eFieldValue) {
                user_object.AddField(fieldname, text_portion);
                m_QualsChangedCount++;
            }
        }
        else {
            if (m_Type == eFieldValue) {
                if (user_object.HasField(fieldname)) {
                    CUser_field& user_field = user_object.SetField(fieldname);
                    if (user_field.IsSetData() && user_field.GetData().IsStr()) {
                        string orig_val = user_field.GetData().GetStr();
                        if (AddValueToString(orig_val, text_portion, existing_text)) {
                            user_field.SetData().SetStr(orig_val);
                            m_QualsChangedCount++;
                        }
                    }
                }
                else {
                    // add a new field to the structured comment
                    user_object.AddField(fieldname, text_portion);
                    m_QualsChangedCount++;
                }
            }
            else if (m_Type == eDbName) {
                m_QualsChangedCount += CMacroFunction_SetStructCommDb::s_UpdateStructCommentDb(*new_desc, kPrefix, text_portion, existing_text);
                m_QualsChangedCount += CMacroFunction_SetStructCommDb::s_UpdateStructCommentDb(*new_desc, kSuffix, text_portion, existing_text);
            }
            else if (m_Type == eFieldName) {
                EDIT_EACH_USERFIELD_ON_USEROBJECT(field_it, user_object) {
                    CUser_field& user_field = **field_it;
                    if (user_field.GetLabel().IsStr() &&
                        !NStr::Equal(user_field.GetLabel().GetStr(), kPrefix) &&
                        !NStr::Equal(user_field.GetLabel().GetStr(), kSuffix)) {
                        string orig_val = user_field.GetLabel().GetStr();
                        if (AddValueToString(orig_val, text_portion, existing_text)) {
                            user_field.SetLabel().SetStr(orig_val);
                            m_QualsChangedCount++;
                        }
                    }
                }
            }
 
            if (m_QualsChangedCount) {
                CMacroFunction_SetStructCommDb::s_MoveSuffixToTheEnd(new_desc->SetUser());
                CCleanup::CleanupUserObject(new_desc->SetUser());
 
                CRef<CCmdChangeSeqdesc> ecmd(new CCmdChangeSeqdesc(strcomm_it.GetSeq_entry_Handle(), *strcomm_it, *new_desc));
                cmd.Reset(new CCmdComposite("Update structured comment"));
                cmd->AddCommand(*ecmd);
            }
        }
 
    }
    else { // make a new one
        if ( existing_text == edit::eExistingText_leave_old) {
            return;
        }
 
        CRef<CCmdComposite> cmd;
        CRef<CSeqdesc> new_desc(new CSeqdesc());
        CUser_object& user_object = new_desc->SetUser();
        user_object.SetObjectType(CUser_object::eObjectType_StructuredComment);
        switch (m_Type) {
        case eFieldValue:
            user_object.AddField(fieldname, text_portion);
            m_QualsChangedCount++;
            break;
        case eDbName:
            user_object.AddField(kPrefix, CComment_rule::MakePrefixFromRoot(text_portion));
            user_object.AddField(kSuffix, CComment_rule::MakeSuffixFromRoot(text_portion));
            m_QualsChangedCount++;
            break;
        case eFieldName:
            user_object.AddField(text_portion, kEmptyStr);
            m_QualsChangedCount++;
            break;
        default:
            break;
        }
 
        if (m_QualsChangedCount) {
            cmd.Reset(new CCmdComposite("Create structured comment"));
            cmd->AddCommand(*(new CCmdCreateDesc(bsh.GetSeq_entry_Handle(), *new_desc)));
        }
    }
 
    if (cmd) {
        m_DataIter->RunCommand(cmd, m_CmdComposite);
        
        TChangedQuals report;
        string msg = "parsing text to structured comment ";
        switch (m_Type) {
        case eFieldValue:
            msg +=  "field '" + fieldname + "'";
            break;
        case eDbName:
            msg += "database name";
            break;
        case eFieldName:
            msg += "fieldname";
            break;
        default:
            break;
        }
        report[msg] = m_QualsChangedCount;
        CRef<IFunctionLog> fnc_log(new CGeneralFuncLog(report));
        x_LogChangedQuals(fnc_log);
    }
}
 
bool CMacroFunction_ParseToStructComm::x_ValidArguments() const
{
    if (m_Args.size() > 6 || m_Args.size() < 4) {
        return false;
    }
    if (!(m_Args[0]->IsString() || m_Args[0]->AreObjects() || m_Args[0]->IsRef()))
        return false;
 
    for (size_t index = 1; index < m_Args.size(); ++index) {
        if (m_Args[index]->GetDataType() != CMQueryNodeValue::eString)
            return false;
    }
    return true;
}
 
void CMacroFunction_ParseToStructComm::x_SetFieldType(const string& strcomm_field)
{
    m_Type = eFieldError;
    if (NStr::EqualNocase(strcomm_field, kStrCommFieldValue)) {
        m_Type = eFieldValue;
    }
    else if (NStr::EqualNocase(strcomm_field, kStrCommDbname)) {
        m_Type = eDbName;
    }
    else if (NStr::EqualNocase(strcomm_field, kStrCommFieldName)) {
        m_Type = eFieldName;
    }
}
 
 
///////////////////////////////////////////////////////////////////////////////
/// class CMacroFunction_ParsedText
/// Obtains a portion of the text
/// ParsedText(field_name(str/objects), left_del(str), include_left(b), right_del(str), include_right(b), 
///            case_sensitive(b), whole_word(b), rmv_from_parsed(b), rmv_left(b), rmv_right(b));
/// left_del and right_del can be free_text, "eDigits", "eLetters"
/// the last three parameters are optional
/// It may also modify the content of the field
///
DEFINE_MACRO_FUNCNAME(CMacroFunction_ParsedText, "ParsedText");
void CMacroFunction_ParsedText::TheFunction()
{
    m_ChangedDescriptors.clear();
    CRef<CScope> scope = m_DataIter->GetScopedObject().scope;
    CObjectInfo oi = m_DataIter->GetEditedObject();
 
    CMQueryNodeValue::TObs res_oi;
    CMQueryNodeValue::EType type = m_Args[0]->GetDataType();
    if (type == CMQueryNodeValue::eString) {
        const string& field = m_Args[0]->GetString();
        if (NStr::EqualNocase(field, "localid") || NStr::EqualNocase(field, "defline")) {
            x_GetSpecialField(field, res_oi, *scope);
        }
        else {
            ResolveIdentToSimple(oi, field, *m_Result);
            GetFieldsByName(&res_oi, oi, field);
        }
    }
    else {
        if (type == CMQueryNodeValue::eObjects) {
            res_oi = m_Args[0]->GetObjects();
        }
        else if (type == CMQueryNodeValue::eRef) {
            x_GetObjectsFromRef(res_oi, 0);
            NMacroUtil::SwapGbQualWithValues(res_oi);
        }
 
        if (res_oi.empty()) return;
        ResolveIdentToSimple(res_oi.front().field, kEmptyStr, *m_Result);
    }
    
    if (m_Result->GetDataType() != CMQueryNodeValue::eString) {
        m_Result->SetDataType(CMQueryNodeValue::eNotSet);
        return;
    }
 
    const string& full_text = m_Result->GetString();
    CRef<edit::CParseTextOptions> options = x_GetParseOptions(1);
    string parsed_text = options->GetSelectedText(full_text);
    m_Result->SetString(parsed_text);
 
    if (options->ShouldRemoveFromParsed()) {
        if (!m_ChangedDescriptors.empty()) {
            auto it = m_ChangedDescriptors.begin();
            if (CSeqdesc* desc = dynamic_cast<CSeqdesc*>(it->second.GetNCPointer())) {
                if (desc->IsTitle()) {
                    string orig_val = desc->GetTitle();
                    options->RemoveSelectedText(orig_val);
                    if (!orig_val.empty()) {
                        desc->SetTitle() = orig_val;
 
                        CRef<CCmdChangeSeqdesc> chg_cmd(new CCmdChangeSeqdesc(it->first.GetSeq_entry_Handle(), *it->first, *it->second));
                        CRef<CCmdComposite> cmd(new CCmdComposite("Update definition line"));
                        cmd->AddCommand(*chg_cmd);
                        m_DataIter->RunCommand(cmd, m_CmdComposite);
                    }
                    // the title will not be deleted
                }
            }
        }
        else if (!res_oi.empty()) {
            CMQueryNodeValue::TObs objs;
            NMacroUtil::GetPrimitiveObjectInfos(objs, res_oi.front());
            CObjectInfo objInfo = objs.front().field;
            _ASSERT(objInfo.GetPrimitiveValueType() == ePrimitiveValueString);
 
            bool is_taxname = NMacroUtil::IsTaxname(objs.front());
            string orig_val = objInfo.GetPrimitiveValueString();
            options->RemoveSelectedText(orig_val);
            if (orig_val.empty()) {
                RemoveFieldByName(res_oi.front());
                m_QualsChangedCount++;
            }
            else {
                SetQualStringValue(objInfo, orig_val);
            }
            if (is_taxname) {
                NMacroUtil::CleanupForTaxnameChange(oi);
            }
        }
    }
 
    if (m_QualsChangedCount) {
        m_DataIter->SetModified();
    }
}
 
bool CMacroFunction_ParsedText::x_ValidArguments() const
{
    size_t as = m_Args.size();
    if (as < 7 || as > 10) {
        return false;
    }
    if (!(m_Args[0]->IsString() || m_Args[0]->AreObjects() || m_Args[0]->IsRef()))
        return false;
    
    if (!m_Args[1]->IsString() || !m_Args[2]->IsBool() || !m_Args[3]->IsString()) {
        return false;
    }
 
    for (size_t i = 4; i < as; ++i) {
        if (!m_Args[i]->IsBool())
            return false;
    }
    return true;
}
 
bool CMacroFunction_ParsedText::x_GetSpecialField(const string& field, CMQueryNodeValue::TObs& objs, CScope& scope)
{
    CBioseq_Handle bsh = m_DataIter->GetBioseqHandle();
    if (bsh && bsh.IsAa()) {
        const CSeq_feat* cds = sequence::GetCDSForProduct(*bsh.GetCompleteBioseq(), &scope);
        if (cds) {
            bsh = scope.GetBioseqHandle(cds->GetLocation());
        }
    }
    if (!bsh) return false;
 
    if (NStr::EqualNocase(field, "defline")) {
        CSeqdesc_CI title_ci(bsh, CSeqdesc::e_Title, 1);
        if (title_ci && !title_ci->GetTitle().empty()) {
            CRef<CSeqdesc> new_desc(new CSeqdesc);
            new_desc->Assign(*title_ci);
            CObjectInfo oi(new_desc, new_desc->GetThisTypeInfo());
            CObjectInfo parent;
            objs.push_back(CMQueryNodeValue::SResolvedField(parent, oi));
            if (ResolveIdentToSimple(oi, "title", *m_Result)) {
                m_ChangedDescriptors.emplace_back(title_ci, new_desc);
                return true;
            }
        }
    }
    else if (NStr::EqualNocase(field, "localid")) {
        for (CSeqdesc_CI desc(bsh, CSeqdesc::e_User); desc; ++desc) {
            const CUser_object& user = desc->GetUser();
            if (user.GetObjectType() == CUser_object::eObjectType_OriginalId) {
                if (!user.GetData().empty()) {
                    const CRef<CUser_field>& user_field = user.GetData().front();
                    if (user_field->IsSetLabel() && user_field->GetLabel().IsStr()
                        && user_field->IsSetData()
                        && NStr::EqualCase(user_field->GetLabel().GetStr(), "LocalId")) {
 
                        if (user_field->GetData().IsStr()) {
                            CObjectInfo objInfo(user_field.GetNCPointer(), user_field->GetTypeInfo());
                            if (ResolveIdentToSimple(objInfo, "data.str", *m_Result))
                                return true;
                        }
                    }
                }
            }
        }
 
 
        if (m_Result->GetDataType() == CMQueryNodeValue::eNotSet) {
            CBioseq& seq = const_cast<CBioseq&>(bsh.GetCompleteBioseq().GetObject());
            CObjectInfo objInfo(&seq, seq.GetTypeInfo());
            if (ResolveIdentToSimple(objInfo, "id.local.str", *m_Result)) {
                return true;
            }
        }
    }
    return false;
}
 
CRef<edit::CParseTextOptions> CMacroFunction_ParsedText::x_GetParseOptions(size_t start_index)
{
    CRef<edit::CParseTextOptions> options(new edit::CParseTextOptions());
    const string& left_del = m_Args[start_index]->GetString();
    if (NStr::EqualCase(left_del, "eDigits")) {
        options->SetStartDigits();
    }
    else if (NStr::EqualCase(left_del, "eLetters")) {
        options->SetStartLetters();
    }
    else {
        options->SetStartText(left_del);
    }
    options->SetIncludeStart(m_Args[++start_index]->GetBool());  // include_start
 
    const string& right_del = m_Args[++start_index]->GetString();
    if (NStr::EqualCase(right_del, "eDigits")) {
        options->SetStopDigits();
    }
    else if (NStr::EqualCase(right_del, "eLetters")) {
        options->SetStopLetters();
    }
    else {
        options->SetStopText(right_del);
    }
    options->SetIncludeStop(m_Args[++start_index]->GetBool()); // include_stop
 
    options->SetCaseInsensitive(!m_Args[++start_index]->GetBool()); // case_sensitivity
    options->SetWholeWord(m_Args[++start_index]->GetBool());
 
    auto nr_args = m_Args.size();
    if (++start_index < nr_args) {
        options->SetShouldRemove(m_Args[start_index]->GetBool());
    }
    if (++start_index < nr_args) {
        options->SetShouldRmvBeforePattern(m_Args[start_index]->GetBool());
    }
    if (++start_index < nr_args) {
        options->SetShouldRmvAfterPattern(m_Args[start_index]->GetBool());
    }
 
    return options;
}
 
 
// class CMacroFunction_ParsedTextFrom
/// Obtains a portion of the text from a different feature that the current one
/// ParsedTextFromFeature(feature_type, field_name(str/objects), left_del(str), include_left(b), right_del(str), include_right(b), 
///            case_sensitive(b), whole_word(b), rmv_from_parsed(b), rmv_left(b), rmv_right(b));
/// left_del and right_del can be free_text, "eDigits", "eLetters"
/// the last three parameters are optional
/// It may also modify the content of the field
///
DEFINE_MACRO_FUNCNAME(CMacroFunction_ParsedTextFrom, "ParsedTextFromFeature");
void CMacroFunction_ParsedTextFrom::TheFunction()
{
    // The iterator should be an RNA feature - TODO: extend it to accept other features as well
    CConstRef<CObject> obj = m_DataIter->GetScopedObject().object;
    const CSeq_feat* rna_feat = dynamic_cast<const CSeq_feat*>(obj.GetPointer());
    CRef<CScope> scope = m_DataIter->GetScopedObject().scope;
    if (!rna_feat || !scope)
        return;
 
    if (rna_feat->IsSetData() && !rna_feat->GetData().IsRna())
        return;
 
    const string& src_feat = m_Args[0]->GetString();
    if (src_feat != "gene")
        return;
 
    NMacroUtil::TVecFeatList feat_list = edit::GetRelatedFeatures(*rna_feat, CSeqFeatData::eSubtype_gene, scope);
    CMQueryNodeValue::TObs res_oi;
    CRef<CSeq_feat> gene_feat;
    CSeq_feat_Handle fh;
    if (!feat_list.empty() && feat_list.size() == 1) {
        gene_feat.Reset(new CSeq_feat);
        gene_feat->Assign(*feat_list.front());
 
        CObjectInfo gene_oi(gene_feat.GetPointer(), gene_feat->GetThisTypeInfo());
        size_t index = 1;
        if (m_Args[index]->IsString()) {
            if (!GetFieldsByName(&res_oi, gene_oi, m_Args[index]->GetString()))
                return;
        }
        else if (m_Args[index]->AreObjects()) {
            res_oi = m_Args[index]->GetObjects();
        }
        else if (m_Args[index]->IsRef()) {
            x_GetObjectsFromRef(res_oi, index);
            NMacroUtil::SwapGbQualWithValues(res_oi);
        }
 
        fh = scope->GetSeq_featHandle(*feat_list.front());
    }
 
 
    if (res_oi.empty())
        return;
    
    ResolveIdentToSimple(res_oi.front().field, kEmptyStr, *m_Result);
    if (!m_Result->IsString()) {
        m_Result->SetDataType(CMQueryNodeValue::eNotSet);
        return;
    }
 
    const string& full_text = m_Result->GetString();
    CRef<edit::CParseTextOptions> options = x_GetParseOptions(2);
    string parsed_text = options->GetSelectedText(full_text);
    m_Result->SetString(parsed_text);
 
    if (!parsed_text.empty() && options->ShouldRemoveFromParsed()) {
        CMQueryNodeValue::TObs objs;
        NMacroUtil::GetPrimitiveObjectInfos(objs, res_oi.front());
        CObjectInfo objInfo = objs.front().field;
        _ASSERT(objInfo.GetPrimitiveValueType() == ePrimitiveValueString);
 
        
        string orig_val = objInfo.GetPrimitiveValueString();
        options->RemoveSelectedText(orig_val);
        if (orig_val.empty()) {
            RemoveFieldByName(res_oi.front());
            m_QualsChangedCount++;
        }
        else {
            SetQualStringValue(objInfo, orig_val);
        }
 
        CRef<CCmdComposite> cmd;
        if (fh) {
            cmd.Reset(new CCmdComposite("Remove parsed text from gene"));
            cmd->AddCommand(*CRef<CCmdChangeSeq_feat>(new CCmdChangeSeq_feat(fh, *gene_feat)));
            m_DataIter->RunCommand(cmd, m_CmdComposite);
        }
    }
}
 
bool CMacroFunction_ParsedTextFrom::x_ValidArguments() const
{
    size_t as = m_Args.size();
    if (as < 8 || as > 11) {
        return false;
    }
    if (!m_Args[0]->IsString() || (!(m_Args[1]->IsString() || m_Args[1]->AreObjects() || m_Args[1]->IsRef())))
        return false;
 
    if (!m_Args[2]->IsString() || !m_Args[3]->IsBool() || !m_Args[4]->IsString()) {
        return false;
    }
 
    for (size_t i = 5; i < as; ++i) {
        if (!m_Args[i]->IsBool())
            return false;
    }
    return true;
}
 
///////////////////////////////////////////////////////////////////////////////
/// class CMacroFunction_LocalID
/// Resolves the local id: the original id if there is one, otherwise the actual local id on the sequence
///
DEFINE_MACRO_FUNCNAME(CMacroFunction_LocalID, "LocalID")
void CMacroFunction_LocalID::TheFunction()
{
    CBioseq_Handle bsh = m_DataIter->GetBioseqHandle();
    if (!bsh) return;
 
    for (CSeqdesc_CI desc(bsh, CSeqdesc::e_User); desc; ++desc) {
        const CUser_object& user = desc->GetUser();
        if (user.GetObjectType() == CUser_object::eObjectType_OriginalId) {
            if (!user.GetData().empty()) {
                const CRef<CUser_field>& user_field = user.GetData().front();
                if (user_field->IsSetLabel() && user_field->GetLabel().IsStr()
                    && user_field->IsSetData()
                    && NStr::EqualCase(user_field->GetLabel().GetStr(), "LocalId")) {
 
                    if (user_field->GetData().IsStr()) {
                        CObjectInfo objInfo(user_field.GetNCPointer(), user_field->GetTypeInfo());
                        if (ResolveIdentToObjects(objInfo, "data.str", *m_Result))
                            return;
                    }
                }
            }
        }
    }
 
 
    if (m_Result->IsNotSet()) {
        CBioseq& seq = const_cast<CBioseq&>(bsh.GetCompleteBioseq().GetObject());
        CObjectInfo objInfo(&seq, seq.GetTypeInfo());
        ResolveIdentToObjects(objInfo, "id.local.str", *m_Result);
        if (m_Result->IsNotSet()) {
            ResolveIdentToObjects(objInfo, "id.local.id", *m_Result);
        }
    }
 
}
 
bool CMacroFunction_LocalID::x_ValidArguments() const
{
    return (m_Args.empty());
}
 
 
///////////////////////////////////////////////////////////////////////////////
/// class CMacroFunction_SetQual
/// SetQual(field_name, newValue)
///
DEFINE_MACRO_FUNCNAME(CMacroFunction_SetQual, "SetQual")
 
void CMacroFunction_SetQual::TheFunction()
{
    CMQueryNodeValue::EType type = m_Args[0]->GetDataType();
    CMQueryNodeValue& new_value = *m_Args[1];
 
    CObjectInfo oi = m_DataIter->GetEditedObject();
    CMQueryNodeValue::TObs res_oi;
    if (type == CMQueryNodeValue::eString) {
        if (!SetFieldsByName(&res_oi, oi, m_Args[0]->GetString())) {
            return;
        }
    }
    else if (type == CMQueryNodeValue::eObjects) {
        res_oi = m_Args[0]->GetObjects();
    }
    else if (type == CMQueryNodeValue::eRef) {
        x_GetObjectsFromRef(res_oi, 0);
    }
 
    if (res_oi.empty()) {
        return;
    }
 
    NON_CONST_ITERATE(CMQueryNodeValue::TObs, it, res_oi) {
        if (SetSimpleTypeValue(it->field, new_value)) {
            m_QualsChangedCount++;
        }
    }
 
    if (m_QualsChangedCount) {
        NMacroUtil::CleanupForTaxnameChange(res_oi.front(), oi);
        m_DataIter->SetModified();
        CNcbiOstrstream log;
        log << m_DataIter->GetBestDescr() << ": set new value to " << m_QualsChangedCount << " qualifiers";
        x_LogFunction(log);
    }
}
 
bool CMacroFunction_SetQual::x_ValidArguments() const
{
    // can accept as its first parameter: objects, string or reference
    CMQueryNodeValue::EType type = m_Args[0]->GetDataType();
    bool first_ok = (type == CMQueryNodeValue::eString) || (type == CMQueryNodeValue::eObjects) || (type == CMQueryNodeValue::eRef);
    if (m_Args.size() != 2 || !first_ok)
        return false;
 
    if (!m_Args[1]->IsSimpleType()) {
        return false;
    }
    return true;
}
 
 
///////////////////////////////////////////////////////////////////////////////
// class CMacroFunction_AddDBLink
/// AddDBLink(dblink_type, newValue, existing_text, delimiter, remove_blank)
/// The last parameter is optional
///
DEFINE_MACRO_FUNCNAME(CMacroFunction_AddDBLink, "AddDBLink")
 
static void s_AddNewDBlinkValue(CUser_field& user_field, const string& newValue);
 
static void s_SetVectorValue(CUser_field& user_field, const string& newValue, const string& del);
 
static bool s_AddNewUserField(CRef<CSeqdesc>& user_object_desc, const string& dblink, const string& newValue);
 
void CMacroFunction_AddDBLink::TheFunction()
{
    CConstRef<CObject> obj = m_DataIter->GetScopedObject().object;
    const CBioseq* bseq = dynamic_cast<const CBioseq*>(obj.GetPointer());
    CRef<CScope> scope = m_DataIter->GetScopedObject().scope;
    if (!scope || !bseq || bseq->IsAa())
        return;
 
    size_t index = 0;
    const string& dblink = m_Args[index]->GetString();
    string newValue = NMacroUtil::GetStringValue(m_Args[++index]);
    const string& existing_text_option = m_Args[++index]->GetString();
    string delimiter;
    bool remove_field = false;
    x_GetOptionalArgs(delimiter, remove_field, index);
    edit::EExistingText existing_text = NMacroUtil::ActionTypeToExistingTextOption(existing_text_option, delimiter);
 
    CRef<CCmdComposite> cmd;
 
    if (!newValue.empty()) {
        vector<pair<CSeqdesc_CI, CRef<CSeqdesc>>> changed_descs;
        CBioseq_Handle bsh = m_DataIter->GetBioseqHandle();
        if (!bsh)
            return;
 
        for (CSeqdesc_CI desc_it(bsh, CSeqdesc::e_User); desc_it; ++desc_it) {
            if (desc_it->GetUser().GetType().IsStr() && desc_it->GetUser().GetType().GetStr() == "DBLink") {
                CRef<CSeqdesc> new_desc(new CSeqdesc);
                new_desc->Assign(*desc_it);
 
                bool found_user_field = false;
                EDIT_EACH_USERFIELD_ON_USEROBJECT(user_it, new_desc->SetUser()) {
                    CUser_field& field = **user_it;
                    if (field.GetLabel().IsStr() && NStr::Equal(field.GetLabel().GetStr(), dblink) && field.IsSetData()) {
                        found_user_field = true;
                        if (field.GetData().IsStrs()) {
                            if (existing_text == edit::eExistingText_add_qual) {
                                s_AddNewDBlinkValue(field, newValue);
                                m_QualsChangedCount++;
                            }
                            else if (existing_text == edit::eExistingText_replace_old) {
                                // apply the same logic as in SetStrinQual:
                                // keep the first element, update it and delete the rest 
                                field.SetData().Reset();
                                field.ResetNum();
                                s_AddNewDBlinkValue(field, newValue);
                                m_QualsChangedCount++;
                                
                            } else {
                                // update all of them
                                for (auto& it : field.SetData().SetStrs()) {
                                    string orig_value = it;
                                    if (edit::AddValueToString(orig_value, newValue, existing_text)) {
                                        it = orig_value;
                                        m_QualsChangedCount++;