NCBI C++ ToolKit
macro_treeitemdata.cpp
Go to the documentation of this file.

Go to the SVN repository for this file.

1 /* $Id: macro_treeitemdata.cpp 47274 2022-12-06 16:17:02Z asztalos $
2  * ===========================================================================
3  *
4  * PUBLIC DOMAIN NOTICE
5  * National Center for Biotechnology Information
6  *
7  * This software/database is a "United States Government Work" under the
8  * terms of the United States Copyright Act. It was written as part of
9  * the author's official duties as a United States Government employee and
10  * thus cannot be copyrighted. This software/database is freely available
11  * to the public for use. The National Library of Medicine and the U.S.
12  * Government have not placed any restriction on its use or reproduction.
13  *
14  * Although all reasonable efforts have been taken to ensure the accuracy
15  * and reliability of the software and data, the NLM and the U.S.
16  * Government do not and cannot warrant the performance or results that
17  * may be obtained by using this software or data. The NLM and the U.S.
18  * Government disclaim all warranties, express or implied, including
19  * warranties of performance, merchantability or fitness for any particular
20  * purpose.
21  *
22  * Please cite the author in any work or product based on this material.
23  *
24  * ===========================================================================
25  *
26  * Authors: Andrea Asztalos
27 
28  */
29 
30 
31 #include <ncbi_pch.hpp>
33 #include <util/xregexp/regexp.hpp>
46 
63 
67 
68 
69 void IMacroActionItemData::CreateParamPanel(wxStaticBoxSizer& action_sizer, wxPanel* parent_panel)
70 {
71  x_AddParamPanel((wxWindow*)action_sizer.GetStaticBox());
72 
74  action_sizer.Add(m_Panel->GetPanel(), 1, wxALIGN_CENTER_HORIZONTAL | wxALL, 2);
75  action_sizer.Layout();
76 
77  parent_panel->Layout();
78  parent_panel->Fit();
79  parent_panel->Refresh();
80 }
81 
82 void IMacroActionItemData::x_LoadPanel(wxWindow* parent, const string &panel_name, const TArgumentsVector &arguments)
83 {
84  try {
85  m_Panel.reset(new CMacroPanelLoader(parent, panel_name, arguments));
86  }
87  catch (const exception& ex) {
88  NcbiMessageBox(ex.what());
89  return;
90  }
91  m_ArgList = m_Panel->GetArgumentList();
92  // initialize the arguments member
94 }
95 
97 {
98  if (m_Panel == nullptr) return;
99  wxPanel* panel = m_Panel->GetPanel();
100  if (panel) {
101  wxSizer* sizer = panel->GetContainingSizer();
102  if (sizer) {
103  sizer->Detach(panel);
104  }
105  }
106 
107  m_Panel.reset(nullptr);
108 }
109 
111 {
112  _ASSERT(m_Panel);
113  if (!m_Panel->TransferDataFromPanel())
114  return false;
115  m_ArgList = m_Panel->GetArgumentList();
117  return true;
118 }
119 
120 bool IMacroActionItemData::TransferDataToPanel(const vector<CFuncWithArgs>& func_info)
121 {
122  _ASSERT(m_Panel);
123  m_ArgList = m_Panel->SetArgumentList();
126  return true;
127 
128  for (const auto& fn_it : func_info) {
129  const auto& fn_args = fn_it.m_FArgs;
130  // set the arguments on the panel
131  for (auto& arg : m_Args) {
132  auto it = fn_args.find(arg->GetName());
133  if (it!= fn_args.end()) {
134  arg->SetValue() = it->second;
135  }
136  }
137  }
138 
139  auto field_type_from = func_info.front().m_FieldTypeFrom;
140  if (field_type_from != EMacroFieldType::eNotSet) {
141  for (auto& arg : m_Args) {
142  const auto& name = arg->GetName();
143  if (name == kBsrcText || name == kBsrcTextFrom) {
144  arg->SetValue() = NStr::BoolToString(field_type_from == EMacroFieldType::eBiosourceText);
145  }
146  else if (name == kBsrcTax || name == kBsrcTaxFrom) {
147  arg->SetValue() = NStr::BoolToString(field_type_from == EMacroFieldType::eBiosourceTax);
148  }
149  else if (name == kBsrcLoc) {
150  arg->SetValue() = NStr::BoolToString(field_type_from == EMacroFieldType::eBiosourceLocation);
151  }
152  else if (name == kBsrcOrigin) {
153  arg->SetValue() = NStr::BoolToString(field_type_from == EMacroFieldType::eBiosourceOrigin);
154  }
155  }
156  }
157  auto field_type_to = func_info.front().m_FieldTypeTo;
158  if (field_type_to != EMacroFieldType::eNotSet) {
159  for (auto& arg : m_Args) {
160  const auto& name = arg->GetName();
161  if (name == kBsrcTextTo) {
162  arg->SetValue() = NStr::BoolToString(field_type_to == EMacroFieldType::eBiosourceText);
163  }
164  else if (name == kBsrcTaxTo) {
165  arg->SetValue() = NStr::BoolToString(field_type_to == EMacroFieldType::eBiosourceTax);
166  }
167  }
168  }
169 
170  bool ret = true;
171  ECustomPanelType panel_type = GetCustomPanelType();
172  if (panel_type == ECustomPanelType::eAddAuthorsPanel) {
173  CApplyAuthorsTreeItemData* datapanel = dynamic_cast<CApplyAuthorsTreeItemData*>(this);
174  if (datapanel)
175  ret = ret && datapanel->SetData(func_info);
176  }
177  else if (panel_type == ECustomPanelType::eAddAssmGapsByNPanel) {
178  CAddAssemblyGapsNTreeItemData* datapanel = dynamic_cast<CAddAssemblyGapsNTreeItemData*>(this);
179  if (datapanel)
180  ret = ret && datapanel->SetData(func_info);
181  }
182  else if (panel_type == ECustomPanelType::eAddGapFeaturesByNPanel) {
183  CAddGapsNTreeItemData* datapanel = dynamic_cast<CAddGapsNTreeItemData*>(this);
184  if (datapanel)
185  ret = ret && datapanel->SetData(func_info);
186  }
187  else if (panel_type == ECustomPanelType::eAddStructCommPanel) {
188  CApplyStructCommentTreeItemData* datapanel = dynamic_cast<CApplyStructCommentTreeItemData*>(this);
189  if (datapanel)
190  ret = ret && datapanel->SetData(func_info);
191  }
192  else if (CMacroPanelLoader::s_IsTablePanel(panel_type)) {
193  CApplyTableItemData* datapanel = dynamic_cast<CApplyTableItemData*>(this);
194  if (datapanel)
195  ret = ret && datapanel->SetData(func_info);
196  }
197  else if (panel_type == ECustomPanelType::eUpdateProteinsPanel) {
198  CUpdateProteinsTreeItemData* datapanel = dynamic_cast<CUpdateProteinsTreeItemData*>(this);
199  if (datapanel)
200  ret = ret && datapanel->SetData(func_info);
201  }
202  return ret && m_Panel->TransferDataToPanel();
203 }
204 
205 string IMacroActionItemData::x_GetVariables(const vector<CTempString>& args) const
206 {
207  string vars;
208  for (auto& it : args) {
209  vars += it + " = %" + m_ArgList[it].GetValue() + "%\n";
210  }
211  return vars;
212 }
213 
215 {
216  TArgumentsVector args;
217  x_LoadPanel(parent, "DefaultAction", args);
218 }
219 
220 const vector<string>& CMacroActionItemData::GetKeywords() const
221 {
223 }
224 
226 {
227  return { macro::CMacroFunction_PubFields::sm_PubTitle,
228  macro::CMacroFunction_PubFields::sm_PubAffil,
229  macro::CMacroFunction_PubFields::sm_PubAuthors,
230  macro::CMacroFunction_PubFields::sm_PubCit,
231  macro::CMacroFunction_PubFields::sm_PubDate,
232  macro::CMacroFunction_PubFields::sm_PubVolume,
233  macro::CMacroFunction_PubFields::sm_PubIssue,
234  macro::CMacroFunction_PubFields::sm_PubJournal,
235  macro::CMacroFunction_PubFields::sm_PubPages,
236  macro::CMacroFunction_PubFields::sm_PubPMID,
237  macro::CMacroFunction_PubFields::sm_PubClass,
238  macro::CMacroFunction_PubFields::sm_PubStatus,
239  macro::CMacroFunction_PubFields::sm_PubSerialNumber };
240 }
241 
243 {
245  m_ActionMap.emplace(EMActionType::eEditBsrcText, new CEditQualTreeItemData("Edit existing biosource text qualifiers", EMacroFieldType::eBiosourceTextAll));
246 
247  m_ActionMap.emplace(EMActionType::eEditBsrcTax, new CEditQualTreeItemData("Edit existing biosource qualifiers", EMacroFieldType::eBiosourceTax));
255  m_ActionMap.emplace(EMActionType::eFixSubsrcFormat, new CFixSubsrcFormatTreeItemData("Fix format of subsource modifiers: altitude, collection-date, lat-lon"));
256  m_ActionMap.emplace(EMActionType::eFixSrcQuals, new CFixSrcQualsTreeItemData("Fix capitalization in biosource qualifiers"));
257  m_ActionMap.emplace(EMActionType::eFixMouseStrain, new CFixMouseStrainTreeItemData("Fix capitalization in common Mus Musculus strains"));
258  m_ActionMap.emplace(EMActionType::eFixFormatPrimer, new CFixPrimerTreeItemData("Fix i in primer (forward and reverse) sequences", true));
259  m_ActionMap.emplace(EMActionType::eTrimJunk, new CFixPrimerTreeItemData("Trim junk from primer (forward and reverse) sequences", false));
260  m_ActionMap.emplace(EMActionType::eRmvLineageNotes, new CMacroActionSimpleItemData(macro::CMacroFunction_RemoveLineageSourceNotes::GetFuncName(), "Remove lineage source notes"));
264  m_ActionMap.emplace(EMActionType::eUnculturedTaxLookup, new CMacroActionSimpleItemData(macro::CMacroFunction_UnculturedTaxLookup::GetFuncName(), "Lookup uncultured taxnames"));
265  m_ActionMap.emplace(EMActionType::eCulturedTaxLookup, new CMacroActionSimpleItemData(macro::CMacroFunction_CulturedTaxLookup::GetFuncName(), "Lookup cultured taxnames"));
266 
268  m_ActionMap.emplace(EMActionType::eEditMolinfo, new CEditQualTreeItemData("Edit existing molinfo qualifiers", EMacroFieldType::eMolinfo));
270  m_ActionMap.emplace(EMActionType::eRmvOutsideMolinfo, new CRmvOutsideQualTreeItemData("Remove text outside string in molinfo qualifiers", EMacroFieldType::eMolinfo));
273 
276  m_ActionMap.emplace(EMActionType::eEditPub, new CEditQualTreeItemData("Edit existing publication fields", EMacroFieldType::ePubdesc));
277  m_ActionMap.emplace(EMActionType::eRmvPub, new CRmvQualTreeItemData("Remove publication fields", EMacroFieldType::ePubdesc));
278  m_ActionMap.emplace(EMActionType::eRmvOutsidePub, new CRmvOutsideQualTreeItemData("Remove text outside string in publication fields", EMacroFieldType::ePubdesc));
279  m_ActionMap.emplace(EMActionType::eISOJTALookup, new CMacroActionSimpleItemData(macro::CMacroFunction_ISOJTALookup::GetFuncName(), "Lookup ISOJTA titles in article publications"));
280  m_ActionMap.emplace(EMActionType::ePMIDLookup, new CMacroActionSimpleItemData(macro::CMacroFunction_LookupPub::GetFuncName(), "Lookup publications by PMID"));
282  m_ActionMap.emplace(EMActionType::eFixUSAandStates, new CMacroActionSimpleItemData(macro::CMacroFunction_FixUSAandStatesAbbrev::GetFuncName(), "Fix USA and state abbreviations in publications"));
283  m_ActionMap.emplace(EMActionType::eFixPubTitle, new CFixPubCapsTreeItemData("Fix capitalization in publication title", EMacroFieldType::ePubTitle));
284  m_ActionMap.emplace(EMActionType::eFixPubAuthors, new CFixPubCapsTreeItemData("Fix capitalization in publication authors", EMacroFieldType::ePubAuthors));
285  m_ActionMap.emplace(EMActionType::eFixPubAffil, new CFixPubCapsTreeItemData("Fix capitalization in publication affiliation fields", EMacroFieldType::ePubAffil));
286  m_ActionMap.emplace(EMActionType::eFixPubAffilCountry, new CFixPubCapsTreeItemData("Fix capitalization in publication affiliation country", EMacroFieldType::ePubAffilCountry));
287  m_ActionMap.emplace(EMActionType::eFixPubAffilExcept, new CFixPubCapsTreeItemData("Fix capitalization in publication affiliation fields except institute and department", EMacroFieldType::ePubAffilExcept));
288  m_ActionMap.emplace(EMActionType::eFixPubLastName, new CFixCapsLastNameTreeItemData("Fix capitalization in publication author last name"));
289  m_ActionMap.emplace(EMActionType::eMoveMiddleName, new CMacroActionSimpleItemData(macro::CMacroFunction_MoveMiddleName::GetFuncName(), "Move middle name to first name"));
290  m_ActionMap.emplace(EMActionType::eStripSuffix, new CMacroActionSimpleItemData(macro::CMacroFunction_StripSuffix::GetFuncName(), "Remove author name suffix"));
291  m_ActionMap.emplace(EMActionType::eTruncateMI, new CMacroActionSimpleItemData(macro::CMacroFunction_TruncateMI::GetFuncName(), "Truncate middle initials"));
292  m_ActionMap.emplace(EMActionType::eReverseAuthorNames, new CMacroActionSimpleItemData(macro::CMacroFunction_ReverseAuthNames::GetFuncName(), "Reverse author names"));
294 
296  m_ActionMap.emplace(EMActionType::eEditDBLink, new CEditQualTreeItemData("Edit existing DBLink fields", EMacroFieldType::eDBLink));
298  m_ActionMap.emplace(EMActionType::eRmvOutsideDBLink, new CRmvOutsideQualTreeItemData("Remove text outside string in DBLink fields", EMacroFieldType::eDBLink));
301 
302  m_ActionMap.emplace(EMActionType::eApplyMisc, new CApplyQualTreeItemData("Apply new value to selected descriptors", EMacroFieldType::eMiscDescriptors));
305  m_ActionMap.emplace(EMActionType::eRmvOutsideMisc, new CRmvOutsideQualTreeItemData("Remove text outside string in selected descriptors", EMacroFieldType::eMiscDescriptors));
307 
314 
316 
318 
319  m_ActionMap.emplace(EMActionType::eTrimTerminalNs, new CMacroActionSimpleItemData(macro::CMacroFunction_TrimTerminalNs::GetFuncName(), "Trim terminal Ns from nucleotide sequences"));
320  m_ActionMap.emplace(EMActionType::eBoldXref, new CMacroActionSimpleItemData(macro::CMacroFunction_MakeBoldXrefs::GetFuncName(), "Make BARCODE DbXrefs"));
321  m_ActionMap.emplace(EMActionType::eReorderStructComm, new CMacroActionSimpleItemData(macro::CMacroFunction_ReorderStructComment::GetFuncName(), "Reorder structured comments"));
322  m_ActionMap.emplace(EMActionType::eRmvDuplStructComm, new CMacroActionSimpleItemData(macro::CMacroFunction_RmvDuplStructComments::GetFuncName(), "Remove duplicate structured comments"));
328 
338 
348 
355 
356  m_ActionMap.emplace(EMActionType::eAdjustConsensusSpliceSite, new CMacroActionSimpleItemData(macro::CMacroFunction_AdjustConsensusSpliceSites::GetFuncName(), "Adjust CDS for consensus splice sites"));
357  m_ActionMap.emplace(EMActionType::eSynchronizeCDSPartials, new CMacroActionSimpleItemData(macro::CMacroFunction_SynchronizeCDSPartials::GetFuncName(), "Synchronize CDS partials"));
358  m_ActionMap.emplace(EMActionType::eReplaceStopsSel, new CMacroActionSimpleItemData(macro::CMacroFunction_ReplaceStopWithSelenocysteine::GetFuncName(), "Replace stops with selenocysteines"));
359  m_ActionMap.emplace(EMActionType::eTrimStopsFromCompleteCDS, new CMacroActionSimpleItemData(macro::CMacroFunction_TrimStopFromCompleteCDS::GetFuncName(), "Remove trailing * from complete CDS"));
372 
373  m_ActionMap.emplace(EMActionType::eAddGeneXref, new CAddGeneXrefTreeItemData("Add gene Xref to features"));
374  m_ActionMap.emplace(EMActionType::eRemoveGeneXref, new CRemoveGeneXrefTreeItemData("Remove gene Xrefs from features"));
376  m_ActionMap.emplace(EMActionType::eDiscrAutofix, new CDiscrepancyAutofixTreeItemData("Perform automatic fixes for the selected discrepancy report tests"));
377  m_ActionMap.emplace(EMActionType::eFixSpelling, new CMacroActionSimpleItemData(macro::CMacroFunction_FixSpelling::GetFuncName(), "Fix spelling"));
378  m_ActionMap.emplace(EMActionType::eAutodefID, new CMacroActionSimpleItemData(macro::CMacroFunction_AutodefId::GetFuncName(), "Create unique deflines"));
380  m_ActionMap.emplace(EMActionType::eRefreshDefline, new CMacroActionSimpleItemData(macro::CMacroFunction_RefreshDefline::GetFuncName(), "Refresh deflines"));
381 
382  m_ActionMap.emplace(EMActionType::eApplyGene, new CApplyQualTreeItemData("Apply new value to gene qualifiers", EMacroFieldType::eGene));
383  m_ActionMap.emplace(EMActionType::eEditGene, new CEditQualTreeItemData("Edit existing gene qualifiers", EMacroFieldType::eGene));
388  m_ActionMap.emplace(EMActionType::eRmvGene, new CRmvQualTreeItemData("Remove gene qualifiers", EMacroFieldType::eGene));
389  m_ActionMap.emplace(EMActionType::eRmvOutsideGene, new CRmvOutsideQualTreeItemData("Remove text outside string in gene qualifiers", EMacroFieldType::eGene));
390 
399  m_ActionMap.emplace(EMActionType::eFixProtFormat, new CMacroActionSimpleItemData(macro::CMacroFunction_FixProteinFormat::GetFuncName(), "Remove organism names from CDS product names"));
400  m_ActionMap.emplace(EMActionType::eRmvInvalidEC, new CMacroActionSimpleItemData(macro::CMacroFunction_RemoveInvalidECNumbers::GetFuncName(), "Remove invalid EC numbers from CDS product"));
401  m_ActionMap.emplace(EMActionType::eUpdateEC, new CUpdateReplacedECTreeItemData("Update replaced EC numbers in CDS product"));
402 
406  m_ActionMap.emplace(EMActionType::eRmvSegGaps, new CMacroActionSimpleItemData(macro::CMacroFunction_RemoveSegGaps::GetFuncName(), "Remove seg-gaps from alignments"));
407  m_ActionMap.emplace(EMActionType::eRmvAlign, new CMacroActionSimpleItemData(macro::CMacroFunction_RemoveAlignment::GetFuncName(), "Remove alignment"));
408 
409  m_ActionMap.emplace(EMActionType::eAddProteinTitle, new CMacroActionSimpleItemData(macro::CMacroFunction_AddProteinTitles::GetFuncName(), "Instantiate protein titles"));
410  m_ActionMap.emplace(EMActionType::eRmvSequence, new CMacroActionSimpleItemData(macro::CMacroFunction_RemoveSequence::GetFuncName(), "Remove sequence"));
411  m_ActionMap.emplace(EMActionType::eJointRNA, new CMacroActionSimpleItemData(macro::CMacroFunction_JoinShorttRNAs::GetFuncName(), "Join short tRNA for nucleotide sequences"));
412  m_ActionMap.emplace(EMActionType::eTaxLookup, new CMacroActionSimpleItemData(macro::CMacroFunction_TaxLookup::GetFuncName(), "Perform taxonomy lookup and extended cleanup"));
413  m_ActionMap.emplace(EMActionType::eCreateProtFeats, new CMacroActionSimpleItemData(macro::CMacroFunction_CreateProteinFeats::GetFuncName(), "Create full length protein features on protein sequences"));
414  m_ActionMap.emplace(EMActionType::eRemoveSingleItem, new CMacroActionSimpleItemData(macro::CMacroFunction_RemoveSingleItemSet::GetFuncName(), "Remove single-sequence set"));
415  m_ActionMap.emplace(EMActionType::eRenormNucProt, new CMacroActionSimpleItemData(macro::CMacroFunction_RenormalizeNucProtSet::GetFuncName(), "Renormalize nuc-prot sets"));
416  m_ActionMap.emplace(EMActionType::eDeltaToRaw, new CMacroActionSimpleItemData(macro::CMacroFunction_DeltaSeqToRaw::GetFuncName(), "Remove assembly gaps"));
424 }
425 
426 wxTreeItemData* CMTreeItemDataBuilder::GetTreeItemData(const CMActionNode& node) const
427 {
428  wxTreeItemData* data = nullptr;
429  if (node.GetActionType() == EMActionType::eNotSet) {
430  return new CMIteratorItemData(node.GetTarget());
431  }
432 
433  auto it = m_ActionMap.find(node.GetActionType());
434  if (it != m_ActionMap.end()) {
435  data = it->second;
436  if (IMacroActionItemData* action_data = dynamic_cast<IMacroActionItemData*>(data)) {
437  action_data->SetTarget(node.GetTarget());
438  }
439  }
440 
441  return data;
442 }
443 
444 static bool s_AreGoodPair(const vector<CFuncWithArgs>& func_info)
445 {
446  if (func_info.size() == 2) {
447  if (NStr::EqualNocase(func_info[0].m_FName, macro::CMacroFunction_ConvertStringQual::GetFuncName()) &&
448  (NStr::EqualNocase(func_info[1].m_FName, macro::CMacroFunction_RemoveModifier::GetFuncName()) ||
449  NStr::EqualNocase(func_info[1].m_FName, macro::CMacroFunction_RemoveQual::GetFuncName()))) {
450  return true;
451  }
452  if (NStr::EqualNocase(func_info[0].m_FName, func_info[1].m_FName) &&
453  (NStr::EqualNocase(func_info[0].m_FName, macro::CMacroFunction_FixIInPrimers::GetFuncName()) ||
454  NStr::EqualNocase(func_info[0].m_FName, macro::CMacroFunction_TrimJunkFromPrimers::GetFuncName()))) {
455  return true;
456  }
457  }
458  return false;
459 }
460 
461 EMActionType CMTreeItemDataBuilder::GetMActionType(const macro::CMacroRep& macro_rep,
462  const vector<EMActionType>& types, CMacroInterpreter& macro_interpret) const
463 {
465  const string& target = macro_rep.GetForEachString();
466  vector<string> do_funcs = NMFncParse::GetDoFunctions(macro_rep);
467  if (target.empty() || do_funcs.empty())
468  return type;
469 
470  // TODO - multiple functions are not allowed, i.e, multiple EditstringQual
471  sort(do_funcs.begin(), do_funcs.end());
472  do_funcs.erase(unique(do_funcs.begin(), do_funcs.end()), do_funcs.end());
473 
474  vector<EMActionType> possible_types;
475  // narrow down types based on the functions
476  for (const auto& type_it : types) {
477  auto data_it = m_ActionMap.find(type_it);
478  if (data_it != m_ActionMap.end()) {
479  vector<string> possible_actions = data_it->second->GetFunctionNames();
480  sort(possible_actions.begin(), possible_actions.end());
481  if (do_funcs.size() == 1) {
482  if (possible_actions == do_funcs) {
483  possible_types.push_back(data_it->first);
484  }
485  }
486  // both vectors should be sorted
487  if (includes(possible_actions.begin(), possible_actions.end(), do_funcs.begin(), do_funcs.end())) {
488  const auto& main_fncs = data_it->second->GetMainFunctions();
489  if (!main_fncs.empty()) {
490  for (const auto& fnc_it : main_fncs) {
491  if (find(do_funcs.begin(), do_funcs.end(), fnc_it) != do_funcs.end()) {
492  possible_types.push_back(data_it->first);
493  }
494  }
495  }
496  else {
497  possible_types.push_back(data_it->first);
498  }
499  }
500  }
501  }
502 
503  LOG_POST(Info << "Possible types: " << possible_types.size());
504  sort(possible_types.begin(), possible_types.end());
505  possible_types.erase(unique(possible_types.begin(), possible_types.end()), possible_types.end());
506 
507  auto& func_info = macro_interpret.SetInterpretedFunctions();
508  if (possible_types.empty()) {
509  LOG_POST(Error << "Functions not recognized for this action:");
510  for (const auto& it : do_funcs) {
511  LOG_POST(Error << it);
512  }
513  NCBI_THROW(CException, eUnknown, "Editing action targeting " + target + " is not recognized");
514  return type;
515  }
516  else if (possible_types.size() == 1) {
517  vector<EMActionType> need_processing{ EMActionType::eEditMolinfoFields,
536  if (find(need_processing.begin(), need_processing.end(), possible_types[0]) != need_processing.end()) {
537  if (!macro_interpret.PostProcess(possible_types[0])) {
538  NCBI_THROW(CException, eUnknown, "Macro function arguments are not valid");
539  }
540  }
541  else if (possible_types[0] == EMActionType::eRemoveDescr) {
542  if (func_info.size() == 1 && func_info[0].m_FieldTypeFrom == EMacroFieldType::eMiscDescriptorsToRmv) {
544  }
545  } else if (func_info.size() > 1 && !s_AreGoodPair(func_info)) {
546  if (macro_rep.GetForEachString() == macro::CMacroBioData::sm_BioSource) {
547  NCBI_THROW(CException, eUnknown, "Multiple editing actions are targeting BioSource qualifiers");
548  }
549  }
550  }
551  else if (possible_types.size() > 1) {
552  // check for multiple functions that should not be present
553  if (func_info.size() > 1 && !s_AreGoodPair(func_info)) {
554  if (macro_rep.GetForEachString() == macro::CMacroBioData::sm_BioSource) {
555  NCBI_THROW(CException, eUnknown, "Multiple editing actions are targeting BioSource qualifiers");
556  }
557  }
558  for (auto& fnc_it : func_info) {
559  if (fnc_it.m_FieldTypeFrom == EMacroFieldType::eNotSet) {
560  continue;
561  }
562 
563  if (fnc_it.m_FieldTypeFrom == EMacroFieldType::eBiosourceTax &&
564  (find(possible_types.begin(), possible_types.end(), EMActionType::eEditBsrcTax) != possible_types.end())) {
566  }
567  else if (fnc_it.m_FieldTypeFrom == EMacroFieldType::eBiosourceText &&
568  (find(possible_types.begin(), possible_types.end(), EMActionType::eEditBsrcText) != possible_types.end())) {
570  }
571  else if (fnc_it.m_FieldTypeFrom == EMacroFieldType::eMiscDescriptors &&
572  (find(possible_types.begin(), possible_types.end(), EMActionType::eApplyMisc) != possible_types.end())) {
574  }
575  else if (fnc_it.m_FieldTypeFrom == EMacroFieldType::eDescriptors &&
576  (find(possible_types.begin(), possible_types.end(), EMActionType::eRemoveDescr) != possible_types.end())) {
578  }
579  else if (fnc_it.m_FieldTypeFrom == EMacroFieldType::eOther) {
580  if (find(possible_types.begin(), possible_types.end(), EMActionType::eApplyMisc) != possible_types.end())
582  if (find(possible_types.begin(), possible_types.end(), EMActionType::eParseToBsrc) != possible_types.end())
584  else if (find(possible_types.begin(), possible_types.end(), EMActionType::eParseToCdsGeneProt) != possible_types.end())
586  else if (find(possible_types.begin(), possible_types.end(), EMActionType::eApplyMiscQualTable) != possible_types.end()) {
587  if (!macro_interpret.PostProcess(EMActionType::eApplyMiscQualTable)) {
588  NCBI_THROW(CException, eUnknown, "Macro function arguments are not valid");
589  }
591  }
592  }
593  else if (fnc_it.m_FieldTypeFrom == EMacroFieldType::eMolinfo&&
594  NStr::EqualNocase(fnc_it.m_FName, macro::CMacroFunction_SetQual::GetFuncName())) {
595  if (find(possible_types.begin(), possible_types.end(), EMActionType::eEditMolinfoFields) != possible_types.end())
596  if (!macro_interpret.PostProcess(EMActionType::eEditMolinfoFields)) {
597  NCBI_THROW(CException, eUnknown, "Macro function arguments are not valid");
598  }
600  }
601  else if (fnc_it.m_FieldTypeFrom == fnc_it.m_FieldTypeTo && fnc_it.m_FieldTypeFrom == EMacroFieldType::eRNA) {
602  if (find(possible_types.begin(), possible_types.end(), EMActionType::eConvertRNA) != possible_types.end())
604  else if (find(possible_types.begin(), possible_types.end(), EMActionType::eCopyRNA) != possible_types.end())
605  return EMActionType::eCopyRNA;
606  else if (find(possible_types.begin(), possible_types.end(), EMActionType::eParseRNA) != possible_types.end())
608  else if (find(possible_types.begin(), possible_types.end(), EMActionType::eSwapRNA) != possible_types.end())
609  return EMActionType::eSwapRNA;
610  }
611  else if ((fnc_it.m_FieldTypeFrom == EMacroFieldType::eGene && fnc_it.m_FieldTypeTo != EMacroFieldType::eFeatQualifiers) ||
612  (fnc_it.m_FieldTypeFrom == EMacroFieldType::eCdsGeneProt && fnc_it.m_FieldTypeTo != EMacroFieldType::eFeatQualifiers) ||
613  (fnc_it.m_FieldTypeTo == EMacroFieldType::eCdsGeneProt && fnc_it.m_FieldTypeFrom != EMacroFieldType::eFeatQualifiers)) {
614  if (find(possible_types.begin(), possible_types.end(), EMActionType::eConvertCdsGeneProt) != possible_types.end())
616  else if (find(possible_types.begin(), possible_types.end(), EMActionType::eCopyCdsGeneProt) != possible_types.end())
618  else if (find(possible_types.begin(), possible_types.end(), EMActionType::eParseCdsGeneProt) != possible_types.end())
620  else if (find(possible_types.begin(), possible_types.end(), EMActionType::eSwapCdsGeneProt) != possible_types.end())
622  else if (find(possible_types.begin(), possible_types.end(), EMActionType::eApplyGene) != possible_types.end())
624  else if (find(possible_types.begin(), possible_types.end(), EMActionType::eEditGene) != possible_types.end())
626  else if (find(possible_types.begin(), possible_types.end(), EMActionType::eRmvGene) != possible_types.end())
627  return EMActionType::eRmvGene;
628  else if (find(possible_types.begin(), possible_types.end(), EMActionType::eRmvOutsideGene) != possible_types.end())
630  else if (fnc_it.m_FieldTypeFrom == EMacroFieldType::eCdsGeneProt && fnc_it.m_FieldTypeTo == EMacroFieldType::eNotSet) {
631  if (find(possible_types.begin(), possible_types.end(), EMActionType::eApplyCDSGeneProtQualTable) != possible_types.end()) {
633  NCBI_THROW(CException, eUnknown, "Macro function arguments are not valid");
634  }
636  }
637  }
638  }
639  else if (fnc_it.m_FieldTypeFrom == EMacroFieldType::eRNA && fnc_it.m_FieldTypeTo == EMacroFieldType::eNotSet) {
640  auto qual_it = fnc_it.m_FArgs.find(NMacroArgs::kFeatQual);
641  if (qual_it != fnc_it.m_FArgs.end() && qual_it->second == "gene allele") {
642  NStr::ReplaceInPlace(qual_it->second, "gene ", "");
643  }
644  else {
645  if (find(possible_types.begin(), possible_types.end(), EMActionType::eApplyRNA) != possible_types.end())
647  else if (find(possible_types.begin(), possible_types.end(), EMActionType::eEditRNA) != possible_types.end())
648  return EMActionType::eEditRNA;
649  else if (find(possible_types.begin(), possible_types.end(), EMActionType::eRmvRNA) != possible_types.end())
650  return EMActionType::eRmvRNA;
651  else if (find(possible_types.begin(), possible_types.end(), EMActionType::eRmvOutsideRNA) != possible_types.end())
653  else if (find(possible_types.begin(), possible_types.end(), EMActionType::eApplyRNAQualTable) != possible_types.end()) {
654  if (!macro_interpret.PostProcess(EMActionType::eApplyRNAQualTable)) {
655  NCBI_THROW(CException, eUnknown, "Macro function arguments are not valid");
656  }
658  }
659  }
660  }
661  else if (fnc_it.m_FieldTypeFrom == EMacroFieldType::eProtein) {
662  if (find(possible_types.begin(), possible_types.end(), EMActionType::eProteinApply) != possible_types.end())
664  else if (find(possible_types.begin(), possible_types.end(), EMActionType::eProteinEdit) != possible_types.end())
666  else if (find(possible_types.begin(), possible_types.end(), EMActionType::eProteinRmv) != possible_types.end())
668  else if (find(possible_types.begin(), possible_types.end(), EMActionType::eProteinRmvOutside) != possible_types.end())
670 
671  if (fnc_it.m_FieldTypeTo == EMacroFieldType::eProtein) {
672  if (find(possible_types.begin(), possible_types.end(), EMActionType::eProteinConvert) != possible_types.end())
674  else if (find(possible_types.begin(), possible_types.end(), EMActionType::eProteinCopy) != possible_types.end())
676  else if (find(possible_types.begin(), possible_types.end(), EMActionType::eProteinParse) != possible_types.end())
678  else if (find(possible_types.begin(), possible_types.end(), EMActionType::eProteinSwap) != possible_types.end())
680  }
681  }
682  else if (fnc_it.m_FieldTypeFrom == EMacroFieldType::eMolinfo &&
683  find(possible_types.begin(), possible_types.end(), EMActionType::eApplyMolinfoQualTable) != possible_types.end()) {
684  if (!macro_interpret.PostProcess(EMActionType::eApplyMolinfoQualTable)) {
685  NCBI_THROW(CException, eUnknown, "Macro function arguments are not valid");
686  }
688  }
689  else if (fnc_it.m_FieldTypeFrom == EMacroFieldType::eMiscDescriptors &&
690  find(possible_types.begin(), possible_types.end(), EMActionType::eApplyMiscQualTable) != possible_types.end()) {
691  if (!macro_interpret.PostProcess(EMActionType::eApplyMiscQualTable)) {
692  NCBI_THROW(CException, eUnknown, "Macro function arguments are not valid");
693  }
695  }
696  else if (find(possible_types.begin(), possible_types.end(), EMActionType::eRemoveDbXref) != possible_types.end()) {
697  auto field_it = fnc_it.m_FArgs.find(NMacroArgs::kField);
698  if (field_it != fnc_it.m_FArgs.end() && field_it->second == "db-xref") {
699  if (macro_interpret.PostProcess(EMActionType::eRemoveDbXref)) {
701  }
702  else {
703  NCBI_THROW(CException, eUnknown, "Macro function arguments are not valid");
704  }
705  }
706  else {
708  }
709  }
710  }
711 
712  if (possible_types.size() == 2 &&
713  possible_types.front() == EMActionType::eApplyFeatQualTable &&
714  possible_types.back() == EMActionType::eApplyCDSGeneProtQualTable) {
716  NCBI_THROW(CException, eUnknown, "Macro function arguments are not valid");
717  }
718  if (macro_interpret.ActionHasCdsGeneProtQuals()) {
719  possible_types.erase(possible_types.begin());
720  }
721  }
722  }
723 
724  //TODO:
725  // RmvOutsideText - digits and letters check positions
726 
727  auto sel_type = possible_types.front();
728  if (sel_type == EMActionType::eApplyFeatQualTable) {
729  macro_interpret.NormalizeFieldForFeatPanel();
730  }
731  else if (sel_type == EMActionType::eApplyFeatQual ||
732  sel_type == EMActionType::eEditFeatQual ||
733  sel_type == EMActionType::eRmvFeatQual ||
734  sel_type == EMActionType::eRmvOutsideFeatQual) {
735  for (auto& fnc_it : func_info) {
736  auto field_it = fnc_it.m_FArgs.find(NMacroArgs::kFeatQual);
737  if (field_it == fnc_it.m_FArgs.end())
738  continue;
739  NMItemData::NormalizeFieldForFeatPanel(field_it->second);
740  }
741  }
742  else if (sel_type == EMActionType::eCopyFeatQual ||
743  sel_type == EMActionType::eConvertFeatQual ||
744  sel_type == EMActionType::eParseFeatQual ||
745  sel_type == EMActionType::eSwapFeatQual) {
746  for (auto& fnc_it : func_info) {
747  auto from_it = fnc_it.m_FArgs.find(NMacroArgs::kFromField);
748  if (from_it == fnc_it.m_FArgs.end())
749  continue;
751 
752  auto to_it = fnc_it.m_FArgs.find(NMacroArgs::kToField);
753  if (to_it == fnc_it.m_FArgs.end())
754  continue;
756  }
757  }
758  else if (sel_type == EMActionType::eCopyCdsGeneProt ||
759  sel_type == EMActionType::eConvertCdsGeneProt ||
760  sel_type == EMActionType::eParseCdsGeneProt ||
761  sel_type == EMActionType::eSwapCdsGeneProt) {
762  for (auto& fnc_it : func_info) {
763  if (fnc_it.m_FieldTypeFrom == EMacroFieldType::eRNA && fnc_it.m_FieldTypeTo == EMacroFieldType::eRNA) {
764  auto& fn_args = fnc_it.m_FArgs;
765  auto field_it = fn_args.find(NMacroArgs::kFromField);
766  if ((field_it != fn_args.end()) && (field_it->second == "comment" || field_it->second == "product")) {
767  field_it->second = "mRNA " + field_it->second;
768  }
769  field_it = fn_args.find(NMacroArgs::kToField);
770  if ((field_it != fn_args.end()) && (field_it->second == "comment" || field_it->second == "product")) {
771  field_it->second = "mRNA " + field_it->second;
772  }
773  }
774  }
775  }
776 
777  return sel_type;
778 }
779 
780 
781 namespace NMItemData {
782 
784 
785  void WrapInQuotes(string& str)
786  {
787  str = "\"" + str + "\"";
788  }
789 
790  void GetFeatureAndField(const string& field_name, string& feature, string& field)
791  {
792  if (field_name.empty()) return;
793 
794  if (macro::NMacroUtil::StringsAreEquivalent(field_name, "codon-start")) {
795  feature = "CDS";
796  field = field_name;
797  }
798 
799  SIZE_TYPE pos = field_name.find(" ");
800  if (pos == NPOS) {
801  field = field_name;
802  return;
803  }
804  feature = field_name.substr(0, pos);
805  field = field_name.substr(pos + 1);
806  }
807 
808  void GetRNASpecificFields(const string& field_name, string& rna_type, string& ncRNA_class, string& rna_qual)
809  {
810  rna_type = ncRNA_class = rna_qual = kEmptyStr;
812 
813  // special case: "gene comment"
814  const string kGeneComment = "gene comment";
815  if (find(rna_fields.begin(), rna_fields.end(), kGeneComment) != rna_fields.end() &&
816  NStr::EndsWith(field_name, kGeneComment)) {
817  rna_qual = kGeneComment;
818  if (kGeneComment.length() < field_name.length()) {
819  rna_type = field_name.substr(0, field_name.length() - kGeneComment.length());
820  NStr::TruncateSpacesInPlace(rna_type);
821  }
822  }
823  else {
824  for (auto&& it : rna_fields) {
825  if (NStr::EndsWith(field_name, it)) {
826  rna_qual = it;
827  if (it.length() < field_name.length()) {
828  rna_type = field_name.substr(0, field_name.length() - it.length());
829  NStr::TruncateSpacesInPlace(rna_type);
830  }
831  break;
832  }
833  }
834  }
835 
836  vector<string> rna_types = CMacroEditorContext::GetInstance().GetRNATypes();
837  if (!rna_qual.empty()) {
838  if (rna_type.empty()) {
839  rna_type = "any";
840  }
841  else {
842  string remainder = rna_type;
843  if (NStr::EqualNocase(rna_type, "misc_RNA")) {
844  rna_type = "miscRNA";
845  }
846  else if (NStr::EqualNocase(rna_type, "pre_RNA")) {
847  rna_type = "preRNA";
848  }
849  else {
850  for (auto&& it : rna_types) {
851  string major_type = it;
852  if (NStr::StartsWith(rna_type, major_type)) {
853  string remainder = rna_type.substr(major_type.length());
854  NStr::TruncateSpacesInPlace(remainder);
855  if (NStr::EqualNocase(major_type, "ncRNA")) {
856  ncRNA_class = remainder;
857  remainder = "";
858  if (ncRNA_class.empty()) {
859  ncRNA_class = "any";
860  }
861  }
862  rna_type = major_type;
863  break;
864  }
865  }
866  }
867  }
868  }
869  }
870 
871  void GetRNASpecificFieldsForTableReader(const string& field_name, string& rna_type, string& ncRNA_type, string& rna_qual)
872  {
873  string modified_field = field_name;
874  if (NStr::StartsWith(field_name, "RNA ")) {
875  modified_field = field_name.substr(4, NPOS);
876  }
877  else if (NStr::EqualNocase(field_name, "ncRNA class ncRNA class")) {
878  modified_field = "ncRNA ncRNA class";
879  }
880  return GetRNASpecificFields(modified_field, rna_type, ncRNA_type, rna_qual);
881  }
882 
883  string GetRNAFieldname(const string& rna_type, const string& ncRNA_type, const string& rna_qual)
884  {
885  string field;
886  if (rna_type == "any" && (ncRNA_type.empty() || ncRNA_type == "any")) {
887  field = rna_qual;
888  }
889  else if (rna_type == "mRNA" ||
890  rna_type == "tRNA" ||
891  rna_type == "rRNA" ||
892  rna_type == "tmRNA") {
893  field = rna_type + " " + rna_qual;
894  }
895  else if (rna_type == "miscRNA") {
896  field = string("misc_RNA") + " " + rna_qual;
897  }
898  else if (rna_type == "preRNA") {
899  field = string("pre_RNA") + " " + rna_qual;
900  }
901  else if (rna_type == "ncRNA") {
902  if (ncRNA_type.empty() || ncRNA_type == "any") {
903  field = rna_type + " " + rna_qual;
904  }
905  else {
906  field = rna_type + " " + ncRNA_type + " " + rna_qual;
907  }
908  }
909  return field;
910  }
911 
912 
913  void UpdateFeatureType(string& feature, const string& field)
914  {
915  if (feature == "CDS") {
916  if (field == "product" ||
917  field == "name" ||
918  field == "activity" ||
919  macro::NMacroUtil::StringsAreEquivalent(field, "EC-number")) {
920  feature = "Protein";
921  }
923  feature = "Gene";
924  }
925  }
926  }
927 
928  void GetMemberNames(const string& container, const string& field, string& member_type, string& member_name, string& main_qual_name)
929  {
930  member_type.resize(0);
931  member_name.resize(0);
932  main_qual_name = field;
933 
934  if (NStr::EqualNocase(container, "org.orgname.mod")) {
935  member_type = "subtype";
936  member_name = "subname";
937  }
938  else if (NStr::EqualNocase(container, "subtype")) {
939  member_type = "subtype";
940  member_name = "name";
941  }
943  field == "codons_recognized") {
944  member_type = "qual";
945  member_name = "val";
946  }
947  else if (macro::NMacroUtil::IsSatelliteSubfield(field)) {
948  member_type = "qual";
949  member_name = "val";
950  main_qual_name = "satellite";
951  }
953  member_type = "qual";
954  member_name = "val";
955  main_qual_name = macro::kMobileElementTQual;
956  }
957  else if (NStr::EqualNocase(container, "qual") ||
958  NStr::EqualNocase(container, "data.rna.ext.gen.quals")) {
959  member_type = "qual";
960  member_name = "val";
961  }
962  }
963 
964  string GetResolveFuncForQual(const string& container, const string& field, const string& rt_var, TConstraints& constraints, bool remove_constraint)
965  {
966  if (field.empty() || rt_var.empty() || container.empty()) {
967  return kEmptyStr;
968  }
969 
970  string field_type;
971  string member;
972  string main_qualifier = field;
973  GetMemberNames(container, field, field_type, member, main_qualifier);
974 
975  string func = rt_var + " = " + macro::CMacroFunction_Resolve::GetFuncName();
976  func += "(\"" + container + "\")";
977  func += " WHERE " + rt_var + "." + field_type + " = \"" + main_qualifier + "\"";
978 
979  if (constraints.empty()) {
980  // ends with a semicolon
981  func += ";\n";
982  return func;
983  }
984 
985  TConstraints::iterator it = constraints.begin();
986  while (it != constraints.end()) {
987  auto& field_ref = it->first;
988  if (field_ref.find(macro::CMacroFunction_StructVoucherPart::GetFuncName()) != NPOS) {
989  if (it->second.find(field) != NPOS) {
990  NStr::ReplaceInPlace(it->second, field, rt_var + "." + member);
991  func += " AND " + it->second;
992  if (remove_constraint) {
993  it = constraints.erase(it);
994  continue;
995  }
996  }
997  }
998  else if ((field == macro::kSatelliteName && field_ref.find(macro::CMacroFunction_SatelliteName::GetFuncName()) != NPOS) ||
999  (field == macro::kSatelliteType && field_ref.find(macro::CMacroFunction_SatelliteType::GetFuncName()) != NPOS)) {
1000  if (field_ref.find(macro::CMacroFunction_RelatedFeatures::GetFuncName()) == NPOS) {
1001  func += " AND " + it->second;
1002  if (remove_constraint) {
1003  it = constraints.erase(it);
1004  continue;
1005  }
1006  }
1007  }
1008  else if ((field == macro::kMobileElementTName && field_ref.find(macro::CMacroFunction_MobileElementName::GetFuncName()) != NPOS) ||
1009  (field == macro::kMobileElementTType && field_ref.find(macro::CMacroFunction_MobileElementType::GetFuncName()) != NPOS)) {
1010  if (field_ref.find(macro::CMacroFunction_RelatedFeatures::GetFuncName()) == NPOS) {
1011  func += " AND " + it->second;
1012  if (remove_constraint) {
1013  it = constraints.erase(it);
1014  continue;
1015  }
1016  }
1017  }
1018  else if (field_ref.find(',') != NPOS) {
1019  vector<string> tokens;
1020  NStr::Split(field_ref, ",", tokens);
1021  for (auto& word : tokens) {
1022  NStr::ReplaceInPlace(word, "\"", "");
1023  NStr::ReplaceInPlace(word, " ", "");
1024  }
1025  if (NStr::EqualNocase(tokens[0], container) &&
1026  NStr::EqualNocase(tokens[1], field)) {
1027  // found relevant constraint
1028  size_t pos = it->second.find(field_ref);
1029  if (pos != NPOS) {
1030  string new_field = "\"" + rt_var + "." + member + "\"";
1031  string new_constraint = it->second; // in case we need to keep the original constraint
1032  NStr::ReplaceInPlace(new_constraint, field_ref, new_field);
1033  func += " AND " + new_constraint;
1034  if (remove_constraint) {
1035  it = constraints.erase(it);
1036  continue;
1037  }
1038  }
1039  }
1040  }
1041  ++it;
1042  }
1043  // ends with a semicolon
1044  func += ";\n";
1045  return func;
1046  }
1047 
1048  string GetResolveFuncForMultiValuedQual(const string& field, const string& rt_var, TConstraints& constraints, bool remove_constraint)
1049  {
1050  if (field.empty() || rt_var.empty() || constraints.empty()) {
1051  return kEmptyStr;
1052  }
1053 
1054  string func;
1055  // if there are no relevant constraints, there is no need to define run-time variable
1056  TConstraints::iterator it = constraints.begin();
1057  while (it != constraints.end()) {
1058  if (it->first.find(field) != NPOS) {
1059  if (func.empty()) {
1060  func = rt_var + " = " + macro::CMacroFunction_Resolve::GetFuncName();
1061  func += "(\"" + field + "\") ";
1062  }
1063 
1064  if (func.find("WHERE") == NPOS) {
1065  func += "WHERE ";
1066  }
1067  else {
1068  func += "AND ";
1069  }
1070 
1071  string new_constraint = it->second;
1072  NStr::ReplaceInPlace(new_constraint, it->first, rt_var);
1073  func += new_constraint;
1074  if (remove_constraint) {
1075  it = constraints.erase(it);
1076  continue;
1077  }
1078  }
1079  ++it;
1080  }
1081 
1082  if (!func.empty()) {
1083  func += ";\n";
1084  }
1085  return func;
1086  }
1087 
1088  pair<string, string> GetResolveFuncForMultiValuedQuals(EMacroFieldType type, const string& fieldname, const string& rt_var, TConstraints& constraints, bool remove_constraint)
1089  {
1090  string path = CMacroEditorContext::GetInstance().GetAsnPathToFieldName(fieldname, type);
1091  string resolve_fnc, var_name = path;
1092  WrapInQuotes(var_name);
1093 
1094  if (MultipleValuesAllowed(path)) {
1095  resolve_fnc = GetResolveFuncForMultiValuedQual(path, rt_var, constraints, remove_constraint);
1096 
1097  if (!resolve_fnc.empty()) {
1098  var_name = rt_var;
1099  }
1100  }
1101  return make_pair(resolve_fnc, var_name);
1102  }
1103 
1104  pair<string, string> GetResolveFuncForSrcFeatQuals(const string& feature, const string& field, const string& rt_var, TConstraints& constraints, bool remove_constraint)
1105  {
1106  string path = CMacroEditorContext::GetInstance().GetAsnPathToFieldName(feature, field);
1107  string resolve_fnc, var_name = path;
1108  WrapInQuotes(var_name);
1109 
1110  if (path.find(',') != NPOS) {
1111  vector<string> tokens;
1112  NStr::Split(path, ",", tokens);
1113 
1114  if (!NStr::EqualNocase(feature, "gene") && CMacroEditorContext::s_IsGeneQualifier(tokens[1])) {
1115  resolve_fnc = GetResolveFuncForGeneQuals(tokens[0], tokens[1], rt_var, constraints);
1116  var_name = rt_var;
1117  }
1118  else {
1119  resolve_fnc = GetResolveFuncForQual(tokens[0], tokens[1], rt_var, constraints, true);
1120  if (!resolve_fnc.empty()) {
1121  var_name = GetEditableFieldForPair(tokens[1], rt_var, true);
1122  WrapInQuotes(var_name);
1123  }
1124  }
1125  }
1126  else if (MultipleValuesAllowed(path)) {
1127  resolve_fnc = GetResolveFuncForMultiValuedQual(path, rt_var, constraints, remove_constraint);
1128 
1129  if (!resolve_fnc.empty()) {
1130  var_name = rt_var;
1131  }
1132  } else if (path == "dbxref") {
1133  resolve_fnc = GetResolveFuncForDbXref(path, rt_var, constraints);
1134  if (!resolve_fnc.empty()) {
1135  var_name = rt_var;
1136  }
1137  }
1138  return make_pair(resolve_fnc, var_name);
1139  }
1140 
1141  pair<string, string> GetResolveFuncForDestFeatQuals(const string& feature, const string& field, const string& rt_var, TConstraints& constraints, bool remove_constraint)
1142  {
1143  string path = CMacroEditorContext::GetInstance().GetAsnPathToFieldName(feature, field);
1144  string resolve_fnc, var_name = path;
1145  WrapInQuotes(var_name);
1146 
1147  if (path.find(',') != NPOS) {
1148  vector<string> tokens;
1149  NStr::Split(path, ",", tokens);
1150 
1151  if (!NStr::EqualNocase(feature, "gene") && CMacroEditorContext::s_IsGeneQualifier(tokens[1])) {
1152  resolve_fnc = GetResolveFuncForGeneQuals(tokens[0], tokens[1], rt_var, constraints);
1153  var_name = rt_var;
1154  }
1155  else {
1156  resolve_fnc = GetResolveFuncForQual(tokens[0], tokens[1], rt_var, constraints, true);
1157  if (NStr::Find(resolve_fnc, "AND", NStr::eNocase) != NPOS) {
1158  // there is a constraint involving this field
1159  // In general, it's safe to assume that constraints do not involve destination fields (it's not a hard rule though)
1160  var_name = GetEditableFieldForPair(tokens[1], rt_var, true);
1161  } else {
1162  resolve_fnc.clear();
1163  var_name = tokens[1];
1164  }
1165  NMItemData::WrapInQuotes(var_name);
1166  }
1167  }
1168  else if (MultipleValuesAllowed(path)) {
1169  resolve_fnc = GetResolveFuncForMultiValuedQual(path, rt_var, constraints, remove_constraint);
1170 
1171  if (!resolve_fnc.empty()) {
1172  var_name = rt_var;
1173  }
1174  }
1175  else if (path == "dbxref") {
1176  resolve_fnc = GetResolveFuncForDbXref(path, rt_var, constraints);
1177  if (!resolve_fnc.empty()) {
1178  var_name = rt_var;
1179  }
1180  }
1181  return make_pair(resolve_fnc, var_name);
1182  }
1183 
1184  pair<string, string> GetResolveFuncForSwapFeatQuals(const string& feature, const string& field, const string& rt_var,
1185  TConstraints& constraints, bool remove_constraint, bool& is_gbqual)
1186  {
1187  string path = CMacroEditorContext::GetInstance().GetAsnPathToFieldName(feature, field);
1188  string resolve_fnc, var_name = path;
1189  NMItemData::WrapInQuotes(var_name);
1190 
1191  if (path.find(',') != NPOS) {
1192  is_gbqual = true;
1193  vector<string> tokens;
1194  NStr::Split(path, ",", tokens);
1195 
1196  if (!NStr::EqualNocase(feature, "gene") && CMacroEditorContext::s_IsGeneQualifier(tokens[1])) {
1197  resolve_fnc = NMItemData::GetResolveFuncForGeneQuals(tokens[0], tokens[1], rt_var, constraints);
1198  }
1199  else {
1200  resolve_fnc = NMItemData::GetResolveFuncForQual(tokens[0], tokens[1], rt_var, constraints, true);
1201  }
1202  var_name = tokens[1];
1203  NMItemData::WrapInQuotes(var_name);
1204 
1205  }
1206  else if (NMItemData::MultipleValuesAllowed(path)) {
1207  resolve_fnc = NMItemData::GetResolveFuncForMultiValuedQual(path, rt_var, constraints, remove_constraint);
1208 
1209  if (!resolve_fnc.empty()) {
1210  var_name = rt_var;
1211  }
1212  }
1213  return make_pair(resolve_fnc, var_name);
1214  }
1215 
1216  pair<string, string> GetResolveFuncForSrcCdsGeneProtQuals(const string& fieldname, const string& rt_var, TConstraints& constraints, bool remove_constraint)
1217  {
1219  string resolve_fnc, var_name = path;
1220  NMItemData::WrapInQuotes(var_name);
1221 
1222  if (path.find(',') != NPOS) {
1223  vector<string> tokens;
1224  NStr::Split(path, ",", tokens);
1225 
1226  resolve_fnc = NMItemData::GetResolveFuncForQual(tokens[0], tokens[1], rt_var, constraints, true);
1227  if (!resolve_fnc.empty()) {
1228  var_name = NMItemData::GetEditableFieldForPair(tokens[1], rt_var, true);
1229  NMItemData::WrapInQuotes(var_name);
1230  }
1231  }
1232  else if (NMItemData::MultipleValuesAllowed(path)) {
1233  resolve_fnc = NMItemData::GetResolveFuncForMultiValuedQual(path, rt_var, constraints, remove_constraint);
1234 
1235  if (!resolve_fnc.empty()) {
1236  var_name = rt_var;
1237  }
1238  }
1239  return make_pair(resolve_fnc, var_name);
1240  }
1241 
1242  pair<string, string> GetResolveFuncForDestCdsGeneProtQuals(const string& fieldname, const string& rt_var, TConstraints& constraints, bool remove_constraint)
1243  {
1245  string resolve_fnc, var_name = path;
1246  NMItemData::WrapInQuotes(var_name);
1247 
1248  if (path.find(',') != NPOS) {
1249  vector<string> tokens;
1250  NStr::Split(path, ",", tokens);
1251 
1252  resolve_fnc = NMItemData::GetResolveFuncForQual(tokens[0], tokens[1], rt_var, constraints, true);
1253  if (NStr::Find(resolve_fnc, "AND", NStr::eNocase) != NPOS) {
1254  // there is a constraint involving this field
1255  // In general, it's safe to assume that constraints do not involve destination fields (it's not a hard rule though)
1256  var_name = GetEditableFieldForPair(tokens[1], rt_var, true);
1257  }
1258  else {
1259  resolve_fnc.clear();
1260  var_name = tokens[1];
1261  }
1262  NMItemData::WrapInQuotes(var_name);
1263  }
1264  else if (NMItemData::MultipleValuesAllowed(path)) {
1265  resolve_fnc = NMItemData::GetResolveFuncForMultiValuedQual(path, rt_var, constraints, remove_constraint);
1266 
1267  if (!resolve_fnc.empty()) {
1268  var_name = rt_var;
1269  }
1270  }
1271  return make_pair(resolve_fnc, var_name);
1272  }
1273 
1274  pair<string, string> GetResolveFuncForRNAQuals(const string& fieldname, const string& rt_var, TConstraints& constraints, bool remove_constraint)
1275  {
1277  string resolve_fnc, var_name = path;
1278  NMItemData::WrapInQuotes(var_name);
1279 
1280  if (path.find(',') != NPOS) {
1281  vector<string> tokens;
1282  NStr::Split(path, ",", tokens);
1283 
1284  resolve_fnc = NMItemData::GetResolveFuncForQual(tokens[0], tokens[1], rt_var, constraints);
1285  var_name = NMItemData::GetEditableFieldForPair(tokens[1], rt_var, true);
1286  NMItemData::WrapInQuotes(var_name);
1287  }
1288  else if (NMItemData::MultipleValuesAllowed(path)) {
1289  resolve_fnc = NMItemData::GetResolveFuncForMultiValuedQual(path, rt_var, constraints, remove_constraint);
1290 
1291  if (!resolve_fnc.empty()) {
1292  var_name = rt_var;
1293  }
1294  }
1295  return make_pair(resolve_fnc, var_name);
1296  }
1297 
1298  pair<string, string> GetResolveFuncForSwapQuals(EMacroFieldType fieldtype, const string& fieldname,
1299  const string& rt_var, TConstraints& constraints, bool remove_constraint, bool& is_gbqual)
1300  {
1301  string path = CMacroEditorContext::GetInstance().GetAsnPathToFieldName(fieldname, fieldtype);
1302  string resolve_fnc, var_name = path;
1303  NMItemData::WrapInQuotes(var_name);
1304 
1305  if (path.find(',') != NPOS) {
1306  is_gbqual = true;
1307  vector<string> tokens;
1308  NStr::Split(path, ",", tokens);
1309  resolve_fnc = NMItemData::GetResolveFuncForQual(tokens[0], tokens[1], rt_var, constraints, true);
1310 
1311  var_name = tokens[1];
1312  NMItemData::WrapInQuotes(var_name);
1313  }
1314  else if (NMItemData::MultipleValuesAllowed(path)) {
1315  resolve_fnc = NMItemData::GetResolveFuncForMultiValuedQual(path, rt_var, constraints, remove_constraint);
1316 
1317  if (!resolve_fnc.empty()) {
1318  var_name = rt_var;
1319  }
1320  }
1321  return make_pair(resolve_fnc, var_name);
1322  }
1323 
1324  string GetEditableFieldForPair(const string& field, const string& rt_var, bool is_feature)
1325  {
1326  if (field.empty() || rt_var.empty()) {
1327  return kEmptyStr;
1328  }
1329 
1330  string lcl_field = field;
1331  NStr::ReplaceInPlace(lcl_field, "-", "_");;
1332 
1333  string member;
1334  if (!is_feature) {
1336  member = "subname";
1337  }
1339  member = "name";
1340  }
1342  member = "subname";
1343  }
1345  member = "name";
1346  }
1347  }
1349  field == "codons_recognized") {
1350  member = "val";
1351  }
1352 
1353  if (member.empty()) {
1354  return kEmptyStr;
1355  }
1356 
1357  return rt_var + '.' + member;
1358  }
1359 
1360  string GetResolveFuncForPubQual(const string& field, string& rt_var, TConstraints& constraints)
1361  {
1362  if (field.empty()) return kEmptyStr;
1363 
1364  rt_var.resize(0);
1366  CRegexp regexp("\\((.*)\\)");
1367  regexp.GetMatch(pub_func, 0, 0, CRegexp::eCompile_ignore_case, true);
1368  rt_var = regexp.GetSub(pub_func);
1369  if (rt_var == "()") {
1370  rt_var = pub_func.substr(4, NPOS);
1371  NStr::ToLower(rt_var);
1372  }
1373  else {
1374  NStr::ReplaceInPlace(rt_var, "\"", "");
1375  }
1376  NStr::ReplaceInPlace(rt_var, "(", "");
1377  NStr::ReplaceInPlace(rt_var, ")", "");
1378  NStr::ReplaceInPlace(rt_var, "-", "");
1379 
1380  string func;
1381  if (!rt_var.empty()) {
1382  func = rt_var + " = " + pub_func;
1383  }
1384  else {
1385  return kEmptyStr;
1386  }
1387 
1388  TConstraints::iterator it = constraints.begin();
1389  while (it != constraints.end()) {
1390  if (NStr::EqualNocase(it->first, pub_func)) {
1391  if (func.find("WHERE") == NPOS) {
1392  func += " WHERE ";
1393  }
1394  else {
1395  func += " AND ";
1396  }
1397 
1398  NStr::ReplaceInPlace(it->second, it->first, rt_var);
1399  func += it->second;
1400  it = constraints.erase(it);
1401  }
1402  else {
1403  ++it;
1404  }
1405  }
1406  // ends with semicolon
1407  func += ";\n";
1408  return func;
1409  }
1410 
1411  string GetResolveFuncForPubQualConst(const string& field, const string& rt_var, TConstraints& constraints, EMacroFieldType field_type)
1412  {
1413  if (field.empty() || rt_var.empty()) return kEmptyStr;
1414  string pub_func = CMacroEditorContext::GetInstance().GetAsnPathToFieldName(field, field_type);
1415  string func;
1416  if (!rt_var.empty()) {
1417  func = rt_var + " = " + pub_func;
1418  }
1419  else {
1420  return kEmptyStr;
1421  }
1422 
1423  TConstraints::iterator it = constraints.begin();
1424  while (it != constraints.end()) {
1425  if (NStr::EqualNocase(it->first, pub_func)) {
1426  if (func.find("WHERE") == NPOS) {
1427  func += " WHERE ";
1428  }
1429  else {
1430  func += " AND ";
1431  }
1432 
1433  NStr::ReplaceInPlace(it->second, it->first, rt_var);
1434  func += it->second;
1435  it = constraints.erase(it);
1436  }
1437  else {
1438  ++it;
1439  }
1440  }
1441  // ends with semicolon
1442  func += ";\n";
1443  return func;
1444  }
1445 
1447  {
1448  string func;
1449  func = rt_var + " = " + macro::CMacroFunction_PubFields::sm_PubAuthors + "()";
1450 
1451  TConstraints::iterator it = constraints.begin();
1452  while (it != constraints.end()) {
1458 
1459  size_t pos = NStr::Find(it->second, macro::CMacroFunction_PubFields::sm_PubAuthors);
1460  if (pos != NPOS) {
1461  string constr_field = CMacroEditorContext::GetInstance().GetAsnPathToAuthorFieldName(it->first);
1462  string search = macro::CMacroFunction_PubFields::sm_PubAuthors + string("(\"" + constr_field + "\")");
1463  string replace = "\"" + rt_var + "." + constr_field + "\"";
1464  NStr::ReplaceInPlace(it->second, search, replace);
1465 
1466  if (func.find("WHERE") == NPOS) {
1467  func += " WHERE ";
1468  }
1469  else {
1470  func += " AND ";
1471  }
1472  func += it->second;
1473  it = constraints.erase(it);
1474  continue;
1475  }
1476  }
1477  ++it;
1478  }
1479  // ends with a semicolon
1480  func += ";\n";
1481  return func;
1482  }
1483 
1484  string GetResolveFuncForDBLink(const string& field, string& rt_var, TConstraints& constraints, bool& found_constraint)
1485  {
1486  rt_var = "dblink_obj";
1487  string func = rt_var + " = " + macro::CMacroFunction_Resolve::GetFuncName();
1488  func += "(\"data\") WHERE EQUALS(\"" + rt_var + ".label.str\", \"" + field + "\", true);\n";
1489 
1490 
1491  string temp_rtvar = "data_obj";
1492  string temp_func = temp_rtvar + " = " + macro::CMacroFunction_Resolve::GetFuncName();
1493  temp_func += "(\"" + rt_var + ".data.strs\")";
1494  found_constraint = false;
1495 
1496  TConstraints::iterator it = constraints.begin();
1497  while (it != constraints.end()) {
1498  if (it->second.find(field) != NPOS) {
1499  auto pos = it->second.find("AND");
1500  if (pos != NPOS) {
1501  it->second = it->second.substr(pos + 4, NPOS);
1502  if (temp_func.find("WHERE") == NPOS) {
1503  temp_func += " WHERE ";
1504  }
1505  else {
1506  temp_func += " AND ";
1507  }
1508  temp_func += it->second;
1509  found_constraint = true;
1510  it = constraints.erase(it);
1511  continue;
1512  }
1513  else {
1514  string dblinktype_func = macro::CMacroFunction_GetDBLink::GetFuncName();
1515  dblinktype_func += "(\"" + field + "\")";
1516  auto pos = it->second.find(dblinktype_func);
1517  if (pos != NPOS) {
1518  NStr::ReplaceInPlace(it->second, dblinktype_func, temp_rtvar);
1519  if (temp_func.find("WHERE") == NPOS) {
1520  temp_func += " WHERE ";
1521  }
1522  else {
1523  temp_func += " AND ";
1524  }
1525  temp_func += it->second;
1526  found_constraint = true;
1527  it = constraints.erase(it);
1528  continue;
1529  }
1530  }
1531  }
1532  ++it;
1533  }
1534  // ends with semicolon
1535  temp_func += ";\n";
1536 
1537  if (found_constraint) {
1538  func += temp_func;
1539  rt_var = temp_rtvar;
1540  }
1541  return func;
1542  }
1543 
1544  string GetResolveFuncForDbXref(const string& path, const string& rt_var, TConstraints& constraints)
1545  {
1546  if (constraints.empty() || rt_var.empty()) {
1547  return kEmptyStr;
1548  }
1549  string func = rt_var + " = " + macro::CMacroFunction_Resolve::GetFuncName();
1550  func += "(\"" + path + "\")";
1551 
1552  bool found = false;
1553  TConstraints::iterator it = constraints.begin();
1554  while (it != constraints.end()) {
1555  string expr;
1556  if (it->second.find(macro::CMacroFunction_GetDBXref::GetFuncName()) != NPOS) {
1557  expr = macro::CMacroFunction_GetDBXref::GetFuncName() + "()";
1558  NStr::ReplaceInPlace(it->second, expr, "\"" + rt_var + ".db\"");
1559  }
1560  else if (path == "org.db" && it->second.find(path) != NPOS) {
1561  expr = path;
1562  NStr::ReplaceInPlace(it->second, expr, rt_var);
1563  }
1564  if (!expr.empty()) {
1565  if (func.find("WHERE") == NPOS) {
1566  func += " WHERE ";
1567  }
1568  else {
1569  func += " AND ";
1570  }
1571  func += it->second;
1572  it = constraints.erase(it);
1573  found = true;
1574  }
1575  else {
1576  ++it;
1577  }
1578  }
1579 
1580  return (found) ? func + ";\n" : kEmptyStr;
1581  // ends with semicolon
1582  }
1583 
1584  string GetResolveFuncForSVPart(const string& field, const string& rt_var, TConstraints& constraints, bool& found_constraint)
1585  {
1586  if (rt_var.empty()) {
1587  return kEmptyStr;
1588  }
1589 
1590  string func = rt_var + " = " + macro::CMacroFunction_Resolve::GetFuncName();
1591  func += "(\"org.orgname.mod\")";
1592 
1593  auto pos = field.find_last_of('-');
1594  auto subtype = field.substr(0, pos);
1595  func += " WHERE " + rt_var + ".subtype = \"" + subtype + "\"";
1596 
1597  found_constraint = false;
1598  TConstraints::iterator it = constraints.begin();
1599  while (it != constraints.end()) {
1600  if (it->second.find(subtype) != NPOS) {
1601  NStr::ReplaceInPlace(it->second, subtype, rt_var + ".subname");
1602  if (func.find("WHERE") == NPOS) {
1603  func += " WHERE ";
1604  }
1605  else {
1606  func += " AND ";
1607  }
1608  func += it->second;
1609  it = constraints.erase(it);
1610  found_constraint = true;
1611  }
1612  else {
1613  ++it;
1614  }
1615  }
1616  return func + ";\n";
1617  }
1618 
1619  string GetFuncFromTable_Depr(const string& rt_var, const string& filename, const string& col, TConstraints& constraints, string& warning)
1620  {
1621  string func;
1622  func = rt_var + " = " + macro::CMacroFunction_ValueFromTable::GetFuncName();
1623  func += "(" + kTableName + ", " + col + ");\n";
1624 
1625  TConstraints::iterator it = constraints.begin();
1626  while (it != constraints.end()) {
1627  if (it->second.find(macro::CMacroFunction_InTable::GetFuncName()) != NPOS) {
1628  if (it->second.find(filename) != NPOS) {
1629  string quoted = "\"" + filename + "\"";
1630  NStr::ReplaceInPlace(it->second, quoted, kTableName);
1631  }
1632  else {
1633  warning.assign("The given file names differ from each other");
1634  }
1635 
1636  if (NStr::EndsWith(it->second, CTempString(", " + col + ")")) ||
1637  NStr::EndsWith(it->second, CTempString("," + col + ")"))) {
1638  if (!warning.empty())
1639  warning += " and ";
1640  warning += "the same column number is specified twice";
1641  }
1642  }
1643  ++it;
1644  }
1645 
1646  return func;
1647  }
1648 
1649  void CheckTableNameAndColumns(const string& filename, const TStringPairsVector& values, TConstraints& constraints, string& warning)
1650  {
1651  TConstraints::iterator it = constraints.begin();
1652  while (it != constraints.end()) {
1653  if (it->second.find(macro::CMacroFunction_InTable::GetFuncName()) != NPOS) {
1654  if (it->second.find(filename) != NPOS) {
1655  string quoted = "\"" + filename + "\"";
1656  NStr::ReplaceInPlace(it->second, quoted, kTableName);
1657  }
1658  else if (it->second.find(kTableName) == NPOS) {
1659  warning.assign("The given file names differ from each other");
1660  }
1661 
1662  for (auto&& col_it : values) {
1663  if (NStr::EndsWith(it->second, CTempString(", " + col_it.second + ")")) ||
1664  NStr::EndsWith(it->second, CTempString("," + col_it.second + ")"))) {
1665  if (!warning.empty())
1666  warning += " and ";
1667  warning += "the same column number is specified twice";
1668  }
1669  }
1670 #if _DEBUG
1671  if (it->second.find("(\"\",") != NPOS) {
1672  warning += "InTable() field is empty";
1673  }
1674 #endif
1675  }
1676  ++it;
1677  }
1678  }
1679 
1680  string GetFuncFromTable(const string& rt_var, const string& col)
1681  {
1682  string func = rt_var + " = " + macro::CMacroFunction_ValueFromTable::GetFuncName();
1683  func += "(" + kTableName + ", " + col + ");\n";
1684  return func;
1685  }
1686 
1687  string GetPropertyFromInfo(const string& info, const string& property)
1688  {
1689  string value;
1690 
1691  string tag = "&" + property + "=";
1692  size_t tag_idx = info.find(tag);
1693 
1694  if (tag_idx != string::npos) {
1695  // End of value is the start of the next value qualifier (this allows
1696  // embedded blanks in values)
1697  size_t tag_end_idx = info.find_first_of("&", tag_idx + 1);
1698  size_t start_idx = tag_idx + string(tag).length();
1699 
1700  if (tag_end_idx == string::npos) {
1701  value = info.substr(start_idx, info.length() - start_idx);
1702  }
1703  else {
1704  value = info.substr(start_idx, tag_end_idx - start_idx);
1705  }
1706  }
1707 
1708  return value;
1709  }
1710 
1711  bool MultipleValuesAllowed(const string& field)
1712  {
1713  return (field == "data.prot.name" ||
1714  field == "data.prot.activity" ||
1715  field == "data.prot.ec" ||
1716  field == "data.gene.syn" ||
1717  field.find("genbank.keywords") != NPOS);
1718  }
1719 
1720  bool IsGeneField(const string& field_name)
1721  {
1722  static vector<string> gene_field_names{ "locus", "allele", "gene-comment", "gene-description" };
1723  return find(gene_field_names.begin(), gene_field_names.end(), field_name) != gene_field_names.end();
1724  }
1725 
1726  string GetResolveFuncForGeneQuals(const string& container, const string& field, const string& rt_var, TConstraints& constraints, bool remove_constraint)
1727  {
1728  if (container.empty() || field.empty() || rt_var.empty()) {
1729  return kEmptyStr;
1730  }
1731 
1732  string func = rt_var + " = " + macro::CMacroFunction_GeneQual::GetFuncName();
1733  func += "(\"" + field + "\")";
1734 
1735  if (constraints.empty()) {
1736  // ends with a semicolon
1737  func += ";\n";
1738  return func;
1739  }
1740 
1741  TConstraints::iterator it = constraints.begin();
1742  while (it != constraints.end()) {
1743  if (it->first.find(',') != NPOS) {
1744  vector<string> tokens;
1745  NStr::Split(it->first, ",", tokens);
1746  for (auto& word : tokens) {
1747  NStr::ReplaceInPlace(word, "\"", "");
1748  NStr::ReplaceInPlace(word, " ", "");
1749  }
1750  if (NStr::EqualNocase(tokens[0], container) &&
1751  NStr::EqualNocase(tokens[1], field)) {
1752  // found relevant constraint
1753  size_t pos = it->second.find(it->first);
1754  if (pos != NPOS) {
1755  string new_constraint = it->second; // in case we need to keep the original constraint
1756  NStr::ReplaceInPlace(new_constraint, it->first, rt_var);
1757  if (func.find("WHERE") == NPOS) {
1758  func += " WHERE ";
1759  }
1760  else {
1761  func += " AND ";
1762  }
1763 
1764  func += new_constraint;
1765  if (remove_constraint) {
1766  it = constraints.erase(it);
1767  continue;
1768  }
1769  }
1770  }
1771  }
1772  ++it;
1773  }
1774  // ends with a semicolon
1775  func += ";\n";
1776  return func;
1777  }
1778 
1779  string GetResolveFuncForStrCommQual(const string& field, const string& field_name, const string& rt_var, TConstraints& constraints)
1780  {
1781  if (field.empty() || rt_var.empty()) return kEmptyStr;
1782  string func;
1783  if (NStr::EqualNocase(field, "Field")) {
1784  if (field_name.empty()) return kEmptyStr;
1785  func = rt_var + " = " + macro::CMacroFunction_Resolve::GetFuncName();
1786  func += "(\"data\")";
1787  func += " WHERE EQUALS(\"" + rt_var + ".label.str\", \"" + field_name + "\", true)";
1788 
1789  string constraint_field = macro::CMacroFunction_StructCommField::GetFuncName();
1790  constraint_field += "(\"" + field_name + "\")";
1791 
1792  TConstraints::iterator it = constraints.begin();
1793  while (it != constraints.end()) {
1794  if (NStr::EqualNocase(it->first, constraint_field)) {
1795  NStr::ReplaceInPlace(it->second, constraint_field, "\"" + rt_var + ".data.str\"");
1796  if (func.find("WHERE") == NPOS) {
1797  func += " WHERE ";
1798  }
1799  else {
1800  func += " AND ";
1801  }
1802  func += it->second;
1803  it = constraints.erase(it);
1804  continue;
1805  }
1806  ++it;
1807  }
1808  }
1809  else if (NStr::EqualNocase(field, "Database name")) {
1810  func = rt_var + " = " + macro::CMacroFunction_Resolve::GetFuncName();
1811  func += "(\"data\")";
1812  func += " WHERE EQUALS(\"" + rt_var + ".label.str\", \"StructuredCommentPrefix\", true)";
1813  func += " OR EQUALS(\"" + rt_var + ".label.str\", \"StructuredCommentSuffix\", true)";
1814  }
1815  else if (NStr::EqualNocase(field, "Field name")) {
1816  func = rt_var + " = " + macro::CMacroFunction_Resolve::GetFuncName();
1817  func += "(\"data\")";
1818  func += " WHERE NOT EQUALS(\"" + rt_var + ".label.str\", \"StructuredCommentPrefix\", true)";
1819  func += " AND NOT EQUALS(\"" + rt_var + ".label.str\", \"StructuredCommentSuffix\", true)";
1820 
1821  string constraint_field = macro::CMacroFunction_StructCommFieldname::GetFuncName() + "()";
1822 
1823  TConstraints::iterator it = constraints.begin();
1824  while (it != constraints.end()) {
1825  if (NStr::EqualNocase(it->first, constraint_field)) {
1826  NStr::ReplaceInPlace(it->second, constraint_field, "\"" + rt_var + ".label.str\"");
1827  if (func.find("WHERE") == NPOS) {
1828  func += " WHERE ";
1829  }
1830  else {
1831  func += " AND ";
1832  }
1833  func += it->second;
1834  it = constraints.erase(it);
1835  continue;
1836  }
1837  ++it;
1838  }
1839  }
1840  func += ";\n";
1841  return func;
1842  }
1843 
1844  string GetDelimiterDescr(const string& del)
1845  {
1846  string descr;
1847  if (NStr::EqualNocase(del, "no separation")) {
1848  descr = "(no separator)";
1849  }
1850  else {
1851  descr = "separated by " + del;
1852  }
1853 
1854  return descr;
1855  }
1856 
1857  string GetExistingTextDescr(const CArgumentList& arg_list)
1858  {
1859  if (!arg_list.count(kExistingText) || !arg_list.count(kDelimiter))
1860  return kEmptyStr;
1861 
1862  const string& existing_text = arg_list[kExistingText].GetValue();
1863  const string& del = arg_list[kDelimiter].GetValue();
1864 
1865  string descr = " (";
1866  if (NStr::EqualNocase(existing_text, "overwrite")) {
1867  descr += "overwrite existing text";
1868  }
1869  else if (NStr::StartsWith(existing_text, "ignore", NStr::eNocase)) {
1870  descr += "ignore new text when existing text is present";
1871  }
1872  else if (NStr::StartsWith(existing_text, "add", NStr::eNocase)) {
1873  descr += "add new qualifier";
1874  } else {
1875  descr += existing_text;
1876  NStr::ToLower(descr);
1877  descr += " " + GetDelimiterDescr(del);
1878  }
1879  descr += ")";
1880  return descr;
1881  }
1882 
1883  string GetHandleOldValue(const string& type)
1884  {
1885  if ("replace" == type)
1886  return "eReplace";
1887  if ("add_new_qual" == type)
1888  return "eAddQual";
1889 
1890  static const TBimapStrings::relation existing_text_bm[] = {
1891  {"overwrite", "eReplace"},
1892  {"append", "eAppend"},
1893  {"prefix", "ePrepend"},
1894  {"ignore new value", "eLeaveOld"},
1895  {"add new qualifier", "eAddQual"} };
1896 
1897  TBimapStrings const data{ begin(existing_text_bm), end(existing_text_bm) };
1899  }
1900 
1901  string GetDelimiterChar(const string& del)
1902  {
1903  static const TBimapStrings::relation delimiter_bm[] = {
1904  {"semicolon", ";"},
1905  {"space", " "},
1906  {"colon", ":"},
1907  {"comma", ","},
1908  {"no separation", ""} };
1909 
1910  TBimapStrings const data{ begin(delimiter_bm), end(delimiter_bm) };
1911  return CMacroEditorContext::FindInBimapOrEmpty(del, data);
1912  }
1913 
1914  string GetHandleBlank(const string& str)
1915  {
1916  return (NStr::StartsWith(str, "ignore")) ? "false" : "true";
1917  }
1918 
1919  string GetBlankGUIText(const string& str)
1920  {
1921  return (str == "true") ? "Erase existing value" :
1922  (str == "false") ? "Ignore" : kEmptyStr;
1923  }
1924 
1925  string GetStructCommQualDescr(const CArgumentList& arg_list)
1926  {
1927  if (!arg_list.count(kField) || !arg_list.count(kStrCommField))
1928  return kEmptyStr;
1929 
1930  string descr = "structured comment ";
1931  const string& field = arg_list[kField].GetValue();
1932  if (NStr::EqualNocase(field, "Field")) {
1933  if (arg_list[kStrCommField].GetShown()) {
1934  descr += "field '" + arg_list[kStrCommField].GetValue() + "'";
1935  }
1936  }
1937  else if (NStr::EqualNocase(field, "Database name")) {
1938  descr += "database name";
1939  }
1940  else if (NStr::EqualNocase(field, "Field name")) {
1941  descr += "field names";
1942  }
1943  return descr;
1944  }
1945 
1946  void UpdateConstraintsForMisc(TConstraints& constraints, const string& fieldname, const string& target)
1947  {
1948  if (NStr::EqualNocase(fieldname, kGenomeProjectID)) {
1949  string new_constraint = macro::CMacroFunction_ChoiceType::GetFuncName();
1950  new_constraint += "(\"type\") = \"str\" AND type.str = \"" + CTempString(kGenProjIDUserType) + "\"";
1951  constraints.insert(constraints.begin(), make_pair("", new_constraint));
1952  }
1953  else {
1955  size_t pos = path.find(".keyword");
1956  if (pos != NPOS) {
1957  path = path.substr(0, pos);
1958  }
1959 
1960  string new_constraint = macro::CMacroFunction_ChoiceType::GetFuncName();
1961  new_constraint += "() = \"" + path + "\"";
1962  constraints.insert(constraints.begin(), make_pair("", new_constraint));
1963  }
1964  }
1965 
1966  CTempString UpdateTargetForMisc(const string& fieldname)
1967  {
1968  CTempString target = macro::CMacroBioData::sm_Seqdesc;
1969  if (NStr::EqualNocase(fieldname, kGenomeProjectID)) {
1970  target = macro::CMacroBioData::sm_UserObject;
1971  }
1972  return target;
1973  }
1974 
1975  CTempString UpdateTargetForMolinfo(const string& molinfo_type)
1976  {
1977  CTempString target = macro::CMacroBioData::sm_MolInfo;
1978  if (NStr::EqualNocase(molinfo_type, "class") ||
1979  NStr::EqualNocase(molinfo_type, "topology") ||
1980  NStr::EqualNocase(molinfo_type, "strand")) {
1981  target = macro::CMacroBioData::sm_Seq;
1982  }
1983  return target;
1984  }
1985 
1986  CTempString UpdateTargetForRnas(const string& rna_type)
1987  {
1988  CTempString target = macro::CMacroBioData::sm_RNA;
1989  if (NStr::EqualNocase(rna_type, "mRNA")) {
1990  target = macro::CMacroBioData::sm_mRNA;
1991  }
1992  else if (NStr::EqualNocase(rna_type, "rRNA")) {
1993  target = macro::CMacroBioData::sm_rRNA;
1994  }
1995  else if (NStr::EqualNocase(rna_type, "miscRNA")) {
1996  target = macro::CMacroBioData::sm_miscRNA;
1997  }
1998  return target;
1999  }
2000 
2001  CTempString UpdateTargetForDualRnas(const string& rna_type, const string& from_field)
2002  {
2003  CTempString target = macro::CMacroBioData::sm_RNA;
2004  if (NStr::StartsWith(from_field, "gene")) {
2005  // it's a gene field
2006  target = macro::CMacroBioData::sm_Gene;
2007  }
2008  else {
2009  target = UpdateTargetForRnas(rna_type);
2010  }
2011  return target;
2012  }
2013 
2014  CTempString UpdateTargetForFeatures(const string& feature, const string& qualifier, bool for_removal)
2015  {
2016  if (feature == "All") {
2017  if (for_removal) {
2018  return macro::CMacroBioData::sm_TSEntry;
2019  }
2020  else {
2021  return macro::CMacroBioData::sm_SeqFeat;
2022  }
2023  }
2024 
2025  // select FOR EACH target based on descriptor type:
2026  pair<int, int> feat_type = CMacroEditorContext::GetInstance().GetFeatureType(feature);
2028  CSeqFeatData::ESubtype subtype = CSeqFeatData::ESubtype(feat_type.second);
2029 
2030  // default target:
2031  CTempString target = macro::CMacroBioData::sm_SeqFeat;
2032 
2033  if (type == CSeqFeatData::e_Rna) {
2034  target = macro::CMacroBioData::sm_RNA;
2035  }
2036  else if (type == CSeqFeatData::e_Imp) {
2037  target = macro::CMacroBioData::sm_ImpFeat;
2038  }
2039 
2040  switch (subtype) {
2042  target = macro::CMacroBioData::sm_Gene;
2043  break;
2045  if (qualifier == "product" ||
2046  macro::NMacroUtil::StringsAreEquivalent(qualifier, "EC-number") ||
2047  qualifier == "activity") {
2048  target = macro::CMacroBioData::sm_Protein;
2049  }
2050  else {
2051  target = macro::CMacroBioData::sm_CdRegion;
2052  }
2053  break;
2055  target = macro::CMacroBioData::sm_Protein;
2056  break;
2058  target = macro::CMacroBioData::sm_ImpFeat;
2059  break;
2061  target = macro::CMacroBioData::sm_mRNA;
2062  break;
2064  target = macro::CMacroBioData::sm_rRNA;
2065  break;
2067  target = macro::CMacroBioData::sm_miscRNA;
2068  break;
2070  target = macro::CMacroBioData::sm_Miscfeat;
2071  break;
2072  default:
2073  break;
2074  }
2075 
2076  return target;
2077  }
2078 
2079  CTempString UpdateTargetForDualFeatures(const string& feature, const string& from_field)
2080  {
2081  // select FOR EACH target based on descriptor type:
2082  pair<int, int> feat_type = CMacroEditorContext::GetInstance().GetFeatureType(feature);
2084  CSeqFeatData::ESubtype subtype = CSeqFeatData::ESubtype(feat_type.second);
2085 
2086  // default target:
2087  CTempString target = macro::CMacroBioData::sm_SeqFeat;
2088 
2089  if (type == CSeqFeatData::e_Rna) {
2090  target = macro::CMacroBioData::sm_RNA;
2091  }
2092  else if (type == CSeqFeatData::e_Imp) {
2093  target = macro::CMacroBioData::sm_ImpFeat;
2094  }
2095 
2096  switch (subtype) {
2098  target = macro::CMacroBioData::sm_Gene;
2099  break;
2101  if (from_field == "product" ||
2102  from_field == "name" ||
2103  from_field == "activity" ||
2104  macro::NMacroUtil::StringsAreEquivalent(from_field, "EC-number")) {
2105  target = macro::CMacroBioData::sm_Protein;
2106  }
2107  else if (CMacroEditorContext::s_IsGeneQualifier(from_field)) {
2108  target = macro::CMacroBioData::sm_Gene;
2109  } else {
2110  target = macro::CMacroBioData::sm_CdRegion;
2111  }
2112  break;
2114  target = macro::CMacroBioData::sm_Protein;
2115  break;
2117  target = macro::CMacroBioData::sm_ImpFeat;
2118  break;
2120  target = macro::CMacroBioData::sm_mRNA;
2121  break;
2123  target = macro::CMacroBioData::sm_rRNA;
2124  break;
2126  target = macro::CMacroBioData::sm_miscRNA;
2127  break;
2129  target = macro::CMacroBioData::sm_Miscfeat;
2130  break;
2131  default:
2132  break;
2133  }
2134 
2135  return target;
2136  }
2137 
2138  CTempString UpdateTargetForCdsGeneProt(const string& fieldname)
2139  {
2140  CTempString target = macro::CMacroBioData::sm_Protein;
2141 
2142  if (NStr::StartsWith(fieldname, "CDS", NStr::eNocase) || fieldname == "codon-start") {
2143  target = macro::CMacroBioData::sm_CdRegion;
2144  }
2145  else if (NStr::StartsWith(fieldname, "gene")) {
2146  target = macro::CMacroBioData::sm_Gene;
2147  }
2148  else if (NStr::StartsWith(fieldname, "mRNA")) {
2149  target = macro::CMacroBioData::sm_mRNA;
2150  }
2151  else if (NStr::StartsWith(fieldname, "mat_peptide") || NStr::StartsWith(fieldname, "mat-peptide")) {
2152  target = macro::CMacroBioData::sm_SeqFeat;
2153  }
2154  return target;
2155  }
2156 
2157  void UpdateConstraintsForRnas(TConstraints& constraints, const CArgumentList& arg_list)
2158  {
2159  // add constraint if necessary
2160  const string& rna_type = arg_list[kRNAType].GetValue();
2161  string ncRNA_class;
2162  if (rna_type == "ncRNA" && arg_list[kncRNAClass].GetEnabled()) {
2163  ncRNA_class = arg_list[kncRNAClass].GetValue();
2164  }
2165  UpdateConstraintsForRnas(constraints, rna_type, ncRNA_class);
2166  }
2167 
2168  void UpdateConstraintsForRnas(TConstraints& constraints, const string& rna_type, const string& ncRNA_class)
2169  {
2170  vector<string> new_constraints;
2171 
2172  if (rna_type == "ncRNA") {
2173  new_constraints.push_back("data.rna.type = \"ncRNA\"");
2174  if (ncRNA_class != "any" && !ncRNA_class.empty()) {
2175  new_constraints.push_back("data.rna.ext.gen.class = \"" + ncRNA_class + "\"");
2176  }
2177  }
2178  else if (rna_type == "preRNA") {
2179  new_constraints.push_back("data.rna.type = \"premsg\"");
2180  }
2181  else if (rna_type == "tRNA") {
2182  new_constraints.push_back("data.rna.type = \"tRNA\"");
2183  }
2184  else if (rna_type == "tmRNA") {
2185  new_constraints.push_back("data.rna.type = \"tmRNA\"");
2186  }
2187 
2188  for (auto it = new_constraints.rbegin(); it != new_constraints.rend(); ++it) {
2189  constraints.insert(constraints.begin(), make_pair(kEmptyStr, *it));
2190  }
2191  }
2192 
2193  string GetGUIRNAType(const string& rna_type)
2194  {
2195  string ret;
2196  if (rna_type == "premsg")
2197  ret = "preRNA";
2198  else if (rna_type == "tRNA" || rna_type == "tmRNA" || rna_type == "ncRNA" ||
2199  rna_type == "scRNA" || rna_type == "snRNA") {
2200  ret = rna_type;
2201  }
2202  else if (rna_type == "snoRNA")
2203  ret = "sno_RNA";
2204  return ret;
2205  }
2206 
2207 
2208  void UpdateConstraintsForFeatures(TConstraints& constraints, const string& feature)
2209  {
2210  // add constraint if necessary
2211  pair<int, int> feat_type = CMacroEditorContext::GetInstance().GetFeatureType(feature);
2213 
2214  vector<string> new_constraints;
2215  string sel_feature = feature;
2216  if (type == CSeqFeatData::e_Imp && feature != "misc_feature") {
2217  new_constraints.push_back("data.imp.key = \"" + feature + "\"");
2218  }
2219 
2220  if (sel_feature == "preRNA" || sel_feature == "precursor_RNA") {
2221  new_constraints.push_back("data.rna.type = \"premsg\"");
2222  } else if (sel_feature == "ncRNA" ||
2223  sel_feature == "tRNA" ||
2224  sel_feature == "tmRNA") {
2225  new_constraints.push_back("data.rna.type = \"" + sel_feature + "\"");
2226  }
2227  else if (sel_feature == "scRNA" ||
2228  sel_feature == "snRNA" ||
2229  sel_feature == "snoRNA" ||
2230  sel_feature == "sno_RNA") {
2231  NStr::ReplaceInPlace(sel_feature, "_", "");
2232  new_constraints.push_back("data.rna.type = \"ncRNA\"");
2233  new_constraints.push_back("data.rna.ext.gen.class = \"" + sel_feature + "\"");
2234  }
2235 
2236  if (type == CSeqFeatData::e_Prot && sel_feature != "Protein") {
2237  new_constraints.push_back(macro::CMacroFunction_ChoiceType::GetFuncName() + "(\"data\") = \"prot\"");
2238  string prot_type;
2239  if (sel_feature == "ProProtein") {
2240  prot_type = "preprotein";
2241  }
2242  else if (NStr::EqualNocase(sel_feature, "mature peptide AA")) {
2243  prot_type = "mature";
2244  }
2245  else if (NStr::EqualNocase(sel_feature, "signal peptide AA")) {
2246  prot_type = "signal-peptide";
2247  }
2248  else if (NStr::EqualNocase(sel_feature, "transit peptide AA")) {
2249  prot_type = "transit-peptide";
2250  }
2251  else if (NStr::EqualNocase(sel_feature, "propeptide AA")) {
2252  prot_type = "propeptide";
2253  }
2254 
2255  if (!prot_type.empty()) {
2256  new_constraints.push_back("data.prot.processed = \"" + prot_type +"\"");
2257  }
2258  }
2259 
2260  if (type == CSeqFeatData::e_Org ||
2277  new_constraints.push_back(macro::CMacroFunction_ChoiceType::GetFuncName()
2278  + "(\"data\") = \"" + CSeqFeatData::SelectionName(type) + "\"");
2279  }
2280 
2281  for (auto it = new_constraints.rbegin(); it != new_constraints.rend(); ++it) {
2282  constraints.insert(constraints.begin(), make_pair(kEmptyStr, *it));
2283  }
2284  }
2285 
2286  void UpdateConstraintsForDualCdsGeneProt(TConstraints& constraints, const string& src_feat)
2287  {
2288  if (macro::NMacroUtil::StringsAreEquivalent(src_feat, "mat_peptide")) {
2289  string new_constraint = "data.prot.processed = \"mature\"";
2290  constraints.insert(constraints.begin(), make_pair(kEmptyStr, new_constraint));
2291  new_constraint = macro::CMacroFunction_ChoiceType::GetFuncName() + "(\"data\") = \"prot\"";
2292  constraints.insert(constraints.begin(), make_pair(kEmptyStr, new_constraint));
2293  }
2294  }
2295 
2296  void AddConstraintIgnoreNewText(const string& field, TConstraints& constraints, const CArgumentList& arg_list, const string& target)
2297  {
2298  try {
2299  if (NStr::StartsWith(arg_list[kExistingText].GetValue().get(), "ignore", NStr::eNocase)) {
2300  string corrected_field = field;
2301  vector<string> tokens;
2302  if (field.find(',') != NPOS) {
2303  NStr::Split(field, ",", tokens);
2304  NMItemData::WrapInQuotes(tokens[0]);
2305  NMItemData::WrapInQuotes(tokens[1]);
2306  corrected_field = tokens[0] + ", " + tokens[1];
2307  }
2308  else if (!NStr::StartsWith(field, "\"")) {
2309  NMItemData::WrapInQuotes(corrected_field);
2310  }
2311 
2312  string target_constr;
2313  if (!target.empty()) {
2314  target_constr = macro::CMacroFunction_RelatedFeatures::GetFuncName();
2315  target_constr += "(\"" + target + "\", " + corrected_field + ")";
2316  }
2317 
2318  string new_constraint = string("NOT ") + macro::CMacroFunction_IsPresent::GetFuncName();
2319  if (!target_constr.empty()) {
2320  new_constraint += "(" + target_constr + ")";
2321  }
2322  else {
2323  new_constraint += "(" + corrected_field + ")";
2324  }
2325 
2326  constraints.insert(constraints.begin(), make_pair(kEmptyStr, new_constraint));
2327  }
2328  }
2329  catch (const CException &ex) {
2330  NcbiMessageBox(ex.what());
2331  return;
2332  }
2333  }
2334 
2336  {
2337  if (arg.GetEnabled() && NStr::EqualNocase(arg.GetValue().get(), "true")) {
2338  return ", update mRNA product to match protein name";
2339  }
2340  return kEmptyStr;
2341  }
2342 
2343  string GetUpdatemRNAVar(const CArgumentList& arg_list)
2344  {
2345  bool update_mrna = arg_list[kUpdatemRNA].GetEnabled() && arg_list[kUpdatemRNA].IsTrue();
2346  return "\n" + kUpdatemRNA + " = %" + NStr::BoolToString(update_mrna) + "%";
2347  }
2348 
2349  void AppendUpdatemRNAFnc(bool update_mrna, string& function)
2350  {
2351  if (update_mrna) {
2352  function += "\n" + macro::CMacroFunction_UpdatemRNAProduct::GetFuncName() + "();";
2353  }
2354  }
2355 
2357  {
2358  try {
2359  if (arg.GetName() == kExistingText) {
2360  const string& existing_text = arg.GetValue();
2361  if (NStr::EqualNocase(existing_text, "append") ||
2362  NStr::EqualNocase(existing_text, "prefix")) {
2363  list[kDelimiter].SetEnabled() = true;
2364  }
2365  else {
2366  list[kDelimiter].SetEnabled() = false;
2367  }
2368  }
2369  }
2370  catch (const CException &ex) {
2371  NcbiMessageBox(ex.what());
2372  return;
2373  }
2374  }
2375 
2377  {
2378  try {
2379  bool enable = false;
2380  if (arg.GetName() == kFeatType) {
2381  const string& feature = arg.GetValue();
2382  if (NStr::EqualNocase(feature, "cds") || NStr::EqualNocase(feature, "protein")) {
2383  if (list[kFeatQual].GetValue() == "product" || list[kFeatQual].GetValue() == "name") {
2384  enable = true;
2385  }
2386  }
2387  list[kUpdatemRNA].SetEnabled() = enable;
2388  }
2389  else if (arg.GetName() == kField) {
2390  enable = NStr::EqualNocase(arg.GetValue().get(), "protein name");
2391  if (list.count(kUpdatemRNA) > 0) {
2392  list[kUpdatemRNA].SetEnabled() = enable;
2393  }
2394  if (list.count(kMoveToNote) > 0) {
2395  list[kMoveToNote].SetEnabled() = enable;
2396  }
2397  }
2398  }
2399  catch (const CException &ex) {
2400  NcbiMessageBox(ex.what());
2401  return;
2402  }
2403  }
2404 
2406  {
2407  try {
2408  if (arg.GetName() == kFromField) {
2409  if (NStr::EqualNocase(arg.GetValue().get(), "protein name")) {
2410  list[kUpdatemRNA].SetEnabled() = true;
2411  }
2412  else if (NStr::EqualNocase(list[kToField].GetValue().get(), "protein name")) {
2413  list[kUpdatemRNA].SetEnabled() = true;
2414  }
2415  else {
2416  list[kUpdatemRNA].SetEnabled() = false;
2417  }
2418  }
2419  }
2420  catch (const CException &ex) {
2421  NcbiMessageBox(ex.what());
2422  return;
2423  }
2424  }
2425 
2427  {
2428  try {
2429  bool enable = false;
2430  if (arg.GetName() == kFeatType) {
2431  if (arg.GetValue() == "CDS" || arg.GetValue() == "Protein") {
2432  const string& to_field = list[kToField].GetValue();
2433  const string& from_field = list[kFromField].GetValue();
2434  if (to_field == "product" || to_field == "name" ||
2435  from_field == "product" || from_field == "name") {
2436  enable = true;
2437  }
2438 
2439  }
2440  list[kUpdatemRNA].SetEnabled() = enable;
2441  }
2442  }
2443  catch (const CException& ex) {
2444  NcbiMessageBox(ex.what());
2445  return;
2446  }
2447  }
2448 
2450  {
2451  try {
2452  if (arg.GetName() == kRNAType) {
2453  list[kncRNAClass].SetEnabled() = NStr::EqualNocase(arg.GetValue().get(), "ncRNA");
2454  }
2455  }
2456  catch (const CException &ex) {
2457  NcbiMessageBox(ex.what());
2458  return;
2459  }
2460  }
2461 
2463  {
2464  try {
2465  if (arg.GetName() == kRNAType) {
2466  const string& rna_name = arg.GetValue();
2467  if (NStr::EqualNocase(rna_name, "miscRNA")) {
2468  list["miscRNA_comment1"].SetShown() = true;
2469  list["miscRNA_comment2"].SetShown() = true;
2470  }
2471  else {
2472  list["miscRNA_comment1"].SetShown() = false;
2473  list["miscRNA_comment2"].SetShown() = false;
2474  }
2475 
2476  if (NStr::EqualNocase(rna_name, "tRNA")
2477  || NStr::EqualNocase(rna_name, "mRNA")
2478  || NStr::EqualNocase(rna_name, "ncRNA")
2479  || NStr::EqualNocase(rna_name, "miscRNA")) {
2480  list["gene_symbol"].SetShown() = true;
2481  list["gene_descr"].SetShown() = true;
2482  list["gene_symbol_static"].SetShown() = true;
2483  list["gene_descr_static"].SetShown() = true;
2484  }
2485  else {
2486  list["gene_symbol"].SetShown() = false;
2487  list["gene_descr"].SetShown() = false;
2488  list["gene_symbol_static"].SetShown() = false;
2489  list["gene_descr_static"].SetShown() = false;
2490  }
2491  }
2492  }
2493  catch (const CException &ex) {
2494  NcbiMessageBox(ex.what());
2495  return;
2496  }
2497  }
2498 
2500  {
2501  try {
2502  if (arg.GetName() == kRmvParse) {
2503  if (arg.GetValue() == "true") {
2504  bool value = (list[kTextLeft].IsTrue() && !list[kDelLeft].Empty())
2505  || list[kDigitsLeft].IsTrue()
2506  || list[kLetterLeft].IsTrue();
2507  list[kRmvLeft].SetEnabled() = value;
2508 
2509  value = (list[kTextRight].IsTrue() && !list[kDelRight].Empty())
2510  || list[kDigitsRight].IsTrue()
2511  || list[kLetterRight].IsTrue();
2512  list[kRmvRight].SetEnabled() = value;
2513  }
2514  else {
2515  list[kRmvLeft].SetEnabled() = false;
2516  list[kRmvRight].SetEnabled() = false;
2517  }
2518  }
2519  }
2520  catch (const CException &ex) {
2521  NcbiMessageBox(ex.what());
2522  return;
2523  }
2524  }
2525 
2527  {
2528  try {
2529  if (arg.GetName() == kTextLeft) {
2530  list[kDelLeft].SetEnabled() = (arg.GetValue() == "true");
2531  }
2532  }
2533  catch (const CException &ex) {
2534  NcbiMessageBox(ex.what());
2535  return;
2536  }
2537  }
2538 
2540  {
2541  try {
2542  if (arg.GetName() == kTextRight) {
2543  list[kDelRight].SetEnabled() = (arg.GetValue() == "true");
2544  }
2545  }
2546  catch (const CException &ex) {
2547  NcbiMessageBox(ex.what());
2548  return;
2549  }
2550  }
2551 
2553  {
2554  try {
2555  if (arg.GetName() == kBefore) {
2556  bool value = (arg.GetValue() == "true");
2557  list[kTextLeft].SetEnabled() = value;
2558  list[kDigitsLeft].SetEnabled() = value;
2559  list[kLetterLeft].SetEnabled() = value;
2560  list[kDelLeft].SetEnabled() = value && list[kTextLeft].IsTrue();
2561  list[kRmvLeft].SetEnabled() = value;
2562  }
2563  }
2564  catch (const CException& ex) {
2565  NcbiMessageBox(ex.what());
2566  return;
2567  }
2568  }
2569 
2571  {
2572  try {
2573  if (arg.GetName() == kAfter) {
2574  bool value = (arg.GetValue() == "true");
2575  list[kTextRight].SetEnabled() = value;
2576  list[kDigitsRight].SetEnabled() = value;
2577  list[kLetterRight].SetEnabled() = value;
2578  list[kDelRight].SetEnabled() = value && list[kTextRight].IsTrue();
2579  list[kRmvRight].SetEnabled() = value;
2580  }
2581  }
2582  catch (const CException &ex) {
2583  NcbiMessageBox(ex.what());
2584  return;
2585  }
2586  }
2587 
2589  {
2590  try {
2591  if (arg.GetName() == kField) {
2592  list[kStrCommField].SetShown() = (arg.GetValue() == "Field");
2593  if (list.count(kTableEnable) > 0) {
2594  bool enable = NStr::EqualNocase(arg.GetValue().get(), "Field name") ? false : true;
2595  list[kTableEnable].SetEnabled() = enable;
2596  }
2597  }
2598  }
2599  catch (const CException &ex) {
2600  NcbiMessageBox(ex.what());
2601  return;
2602  }
2603  }
2604 
2606  {
2607  try {
2608  if (arg.GetName() == kToField) {
2609  list[kStrCommField].SetShown() = (arg.GetValue() == "Field");
2610  }
2611  }
2612  catch (const CException &ex) {
2613  NcbiMessageBox(ex.what());
2614  return;
2615  }
2616  }
2617 
2619  {
2620  try {
2621  if (arg.GetName() == kFromFeat) {
2622  bool value = (arg.GetValue() == "CDS");
2623  list[kRemmRNA].SetEnabled() = value;
2624  list[kRemGene].SetEnabled() = value;
2625  list[kRemTranscriptid].SetEnabled() = value;
2626  }
2627  }
2628  catch (const CException &ex) {
2629  NcbiMessageBox(ex.what());
2630  return;
2631  }
2632  }
2633 
2635  {
2636  try {
2637  if (arg.GetName() == kToFeat) {
2638  bool show_choices = (arg.GetValue() == "ncRNA" || arg.GetValue() == "bond" || arg.GetValue() == "site");
2639  list[kSelText].SetShown() = show_choices;
2640  list[kChoices].SetShown() = show_choices;
2641  list[kCreateOnProtein].SetShown() = (arg.GetValue() == "region");
2642  }
2643  }
2644  catch (const CException &ex) {
2645  NcbiMessageBox(ex.what());
2646  return;
2647  }
2648  }
2649 
2651  {
2652  try {
2653  if (arg.GetName() == kTableEnable) {
2654  bool checked = (arg.GetEnabled()) ? arg.IsTrue() : false;
2655  list[kTableName].SetShown() = checked;
2656  list[kTableLabel].SetShown() = checked;
2657  list[kTableCol].SetShown() = checked;
2658  list[kColLabel].SetShown() = checked;
2659  list[kOpenFile].SetShown() = checked;
2660  list[kNewValue].SetEnabled() = !checked;
2661  }
2662  }
2663  catch (const CException &ex) {
2664  NcbiMessageBox(ex.what());
2665  return;
2666  }
2667  }
2668 
2670  {
2671  try {
2672  if (list.count(kRmvOverlapGene) > 0 && arg.GetName() == kFeatType) {
2673  bool enable = true;
2674  const string val = arg.GetValue();
2675  if (NStr::EqualNocase(val, "all") || NStr::EndsWith(val, " AA")) {
2676  enable = false;
2677  }
2678  list[kRmvOverlapGene].SetEnabled() = enable;
2679  }
2680  }
2681  catch (const CException &ex) {
2682  NcbiMessageBox(ex.what());
2683  return;
2684  }
2685  }
2686 
2688  {
2689  try {
2690  if (arg.GetName() == kMiscFeatCheck) {
2691  list[kMiscFeatRule].SetEnabled() = arg.IsTrue();
2692  }
2693  }
2694  catch (const CException &ex) {
2695  NcbiMessageBox(ex.what());
2696  return;
2697  }
2698  }
2699 
2701  {
2702  try {
2703  if (arg.GetName() == kAutodefCompl) {
2704  list[kListFeatRule].SetEnabled() = !arg.IsTrue();
2705  }
2706  }
2707  catch (const CException& ex) {
2708  NcbiMessageBox(ex.what());
2709  }
2710  }
2711 
2713  {
2714  try {
2715  if (arg.GetName() == kIllegalDbxref) {
2716  list[kMoveToNote].SetEnabled() = arg.IsTrue();
2717  }
2718  }
2719  catch (const CException& ex) {
2720  NcbiMessageBox(ex.what());
2721  }
2722  }
2723 
2725  {
2726  try {
2727  if (arg.GetName() == kSameDoi) {
2728  list[kNewValue].SetEnabled() = arg.IsTrue();
2729  }
2730  }
2731  catch (const CException& ex) {
2732  NcbiMessageBox(ex.what());
2733  }
2734  }
2735 
2737  {
2739  try {
2740  if (arg_list[kBsrcText].IsTrue()) {
2742  }
2743  else if (arg_list[kBsrcTax].IsTrue()) {
2745  }
2746  else if (arg_list[kBsrcLoc].IsTrue()) {
2748  }
2749  else if (arg_list[kBsrcOrigin].IsTrue()) {
2751  }
2752  }
2753  catch (const CException &ex) {
2754  NcbiMessageBox(ex.what());
2755  }
2756 
2757  return type;
2758  }
2759 
2761  {
2763  try {
2764  if (dir == eFrom) {
2765  if (arg_list[kBsrcTextFrom].IsTrue()) {
2767  }
2768  else if (arg_list[kBsrcTaxFrom].IsTrue()) {
2770  }
2771  }
2772  else if (dir == eTo) {
2773  if (arg_list[kBsrcTextTo].IsTrue()) {
2775  }
2776  else if (arg_list[kBsrcTaxTo].IsTrue()) {
2778  }
2779  }
2780  }
2781  catch (const CException &ex) {
2782  NcbiMessageBox(ex.what());
2783  return type;
2784  }
2785  return type;
2786  }
2787 
2788  string GetSelectedCapType(const CArgumentList& arg_list)
2789  {
2790  string cap_change;
2791  try {
2792  if (arg_list[kNoChange].IsTrue()) {
2793  cap_change = "none";
2794  }
2795  else if (arg_list[kToUpper].IsTrue()) {
2796  cap_change = "toupper";
2797  }
2798  else if (arg_list[kToLower].IsTrue()) {
2799  cap_change = "tolower";
2800  }
2801  else if (arg_list[kCapNochange].IsTrue()) {
2802  cap_change = "firstcap-restnochange";
2803  }
2804  else if (arg_list[kCapAtSpaces].IsTrue()) {
2805  cap_change = "cap-word-space";
2806  }
2807  else if (arg_list[kFCapLower].IsTrue()) {
2808  cap_change = "firstcap";
2809  }
2810  else if (arg_list[kFlowerNochange].IsTrue()) {
2811  cap_change = "firstlower-restnochange";
2812  }
2813  else if (arg_list[kCapAtSpacesPunct].IsTrue()) {
2814  cap_change = "cap-word-space-punct";
2815  }
2816  }
2817  catch (const CException &ex) {
2818  NcbiMessageBox(ex.what());
2819  }
2820 
2821  _ASSERT(!cap_change.empty());
2822  if (cap_change.empty()) {
2823  LOG_POST(Error << "No capitalization was selected");
2824  }
2825  return cap_change;
2826  }
2827 
2828  string GetCapitalizationType(const string& cap_change)
2829  {
2830  static const TBimapStrings::relation cap_bm[] = {
2831  {kNoChange, "none"},
2832  {kToUpper, "toupper"},
2833  {kToLower, "tolower"},
2834  {kCapNochange, "firstcap-restnochange"},
2835  {kCapAtSpaces, "cap-word-space"},
2836  {kFCapLower, "firstcap"},
2837  {kFlowerNochange, "firstlower-restnochange"},
2838  {kCapAtSpacesPunct, "cap-word-space-punct"} };
2839 
2840  TBimapStrings const data{ begin(cap_bm), end(cap_bm) };
2841  return CMacroEditorContext::FindInBimapOrEmpty(cap_change, data);
2842  }
2843 
2844  string GetCapitalizationTypeFromChoice(const string& cap_change)
2845  {
2846  static const TBimapStrings::relation cap_gui_bm[] = {
2847  {"No change", "none"},
2848  {"To upper", "toupper"},
2849  {"To lower", "tolower"},
2850  {"First cap, rest no change", "firstcap-restnochange"},
2851  {"First cap, rest lower", "firstcap"},
2852  {"First lower, rest no change", "firstlower-restnochange"},
2853  {"Cap words, start at spaces", "cap-word-space"},
2854  {"Cap words, start at spaces or punct.", "cap-word-space-punct"} };
2855 
2856  TBimapStrings const data{ begin(cap_gui_bm), end(cap_gui_bm) };
2857  return CMacroEditorContext::FindInBimapOrEmpty(cap_change, data);
2858  }
2859 
2860  void NormalizeFieldForFeatPanel(string& field)
2861  {
2862  if (NStr::StartsWith(field, "gene ")) {
2863  NStr::ReplaceInPlace(field, "gene ", "");
2864  NStr::ReplaceInPlace(field, "_", "-");
2865  }
2866  if (field == "comment" || NStr::EndsWith(field, " comment", NStr::eNocase)) {
2867  field = "note";
2868  }
2869  else if (field == "cds inference") {
2870  field = "inference";
2871  }
2872  else if (field == "protein name") {
2873  field = "product";
2874  }
2875  else if (NStr::FindNoCase(field, "EC number") != NPOS ||
2876  NStr::FindNoCase(field, "EC_number") != NPOS ||
2877  NStr::FindNoCase(field, "EC-number") != NPOS) {
2878  field = "EC-number";
2879  }
2880  else if (macro::NMacroUtil::StringsAreEquivalent(field, "ncRNA class")) {
2881  field = "ncRNA-class";
2882  }
2883  }
2884 
2885 } // end of namespace
2886 
2887 
2888 
#define false
Definition: bool.h:36
bool SetData(const vector< CFuncWithArgs > &func_info)
bool SetData(const vector< CFuncWithArgs > &func_info)
virtual bool SetData(const vector< CFuncWithArgs > &func_info)
const TArguments & GetArguments() const
TArguments & SetArguments()
size_t count(const string &arg_name) const
const TStdStringPublisher & GetValue() const
const string & GetName() const
bool IsTrue() const
const TBoolPublisher & GetEnabled() const
const CTempString & GetTarget() const
EMActionType GetActionType() const
unordered_map< EMActionType, CMacroPanelItemData * > m_ActionMap
EMActionType GetMActionType(const macro::CMacroRep &macro_rep, const vector< EMActionType > &types, CMacroInterpreter &macro_interpret) const
wxTreeItemData * GetTreeItemData(const CMActionNode &node) const
EMacroFieldType m_FieldType
for actions such as appply/edit/etc.
vector< string > x_GetPubFunctions() const
virtual const vector< string > & GetKeywords() const
virtual void x_AddParamPanel(wxWindow *parent)
static bool s_IsGeneQualifier(const string &field)
boost::bimap< boost::bimaps::set_of< string, PNocase >, boost::bimaps::set_of< string, PNocase > > TBimapStrings
vector< string > GetRNATypes() const
pair< int, int > GetFeatureType(const string &name) const
string GetAsnPathToFieldName(const string &field, EMacroFieldType type, const string &target=kEmptyStr)
const vector< string > & GetKeywords(EMacroFieldType type) const
static CMacroEditorContext & GetInstance()
string GetAsnPathToAuthorFieldName(const string &author_name)
static string FindInBimapOrEmpty(const string &type, const TBimapStrings &str_bimap)
vector< string > GetFieldNames(EMacroFieldType type) const
bool PostProcess(EMActionType action_type)
vector< CFuncWithArgs > & SetInterpretedFunctions()
static bool s_IsTablePanel(ECustomPanelType &type)
@ eVocabulary_insdc
Definition: OrgMod.hpp:69
static bool IsValidSubtypeName(const string &str, EVocabulary vocabulary=eVocabulary_raw)
Definition: OrgMod.cpp:86
@ ePubFieldType_AuthorLastName
@ ePubFieldType_AuthorFirstName
@ ePubFieldType_AuthorConsortium
@ ePubFieldType_AuthorMiddleInitial
T const & get() const
CRegexp –.
Definition: regexp.hpp:70
static EQualifier GetQualifierType(CTempString qual)
convert qual string to enumerated value
static bool IsValidSubtypeName(const string &str, EVocabulary vocabulary=eVocabulary_raw)
Definition: SubSource.cpp:155
@ eVocabulary_insdc
Definition: SubSource.hpp:83
CTempString implements a light-weight string on top of a storage buffer whose lifetime management is ...
Definition: tempstr.hpp:65
bool SetData(const vector< CFuncWithArgs > &func_info)
bool SetData(const vector< CFuncWithArgs > &func_info)
ECustomPanelType GetCustomPanelType() const
virtual void x_AddParamPanel(wxWindow *parent)=0
string x_GetVariables(const vector< CTempString > &args) const
void x_LoadPanel(wxWindow *parent, const string &panel_name, const TArgumentsVector &arguments)
unique_ptr< CMacroPanelLoader > m_Panel
constructed panel for specifying function arguments
bool TransferDataToPanel(const vector< CFuncWithArgs > &func_info)
void CreateParamPanel(wxStaticBoxSizer &action_sizer, wxPanel *parent)
char value[7]
Definition: config.c:431
const char * kOrgModNote
const char * kGenomeProjectID
const char * kSubSourceNote
const char * kGenProjIDUserType
static int type
Definition: getdata.c:31
string
Definition: cgiapp.hpp:687
#define LOG_POST(message)
This macro is deprecated and it's strongly recomended to move in all projects (except tests) to macro...
Definition: ncbidiag.hpp:226
void Error(CExceptionArgs_Base &args)
Definition: ncbiexpt.hpp:1197
#define NCBI_THROW(exception_class, err_code, message)
Generic macro to throw an exception, given the exception class, error code and message string.
Definition: ncbiexpt.hpp:704
virtual const char * what(void) const noexcept
Standard report (includes full backlog).
Definition: ncbiexpt.cpp:342
void Info(CExceptionArgs_Base &args)
Definition: ncbiexpt.hpp:1185
bool StringsAreEquivalent(const string &name1, const string &name2)
Definition: macro_util.cpp:397
const char * kMobileElementTType
Definition: macro_util.cpp:938
const char * kSatelliteType
Definition: macro_util.cpp:935
const char * kSatelliteName
Definition: macro_util.cpp:936
bool IsSatelliteSubfield(const string &field)
Definition: macro_util.cpp:903
bool IsMobileElementTSubfield(const string &field)
Definition: macro_util.cpp:908
const char * kMobileElementTQual
Definition: macro_util.cpp:937
const char * kMobileElementTName
Definition: macro_util.cpp:939
EDialogReturnValue NcbiMessageBox(const string &message, TDialogType type=eDialog_Ok, EDialogIcon icon=eIcon_Exclamation, const string &title="Error", EDialogTextMode text_mode=eRaw)
Definition: message_box.cpp:48
CTempString GetSub(CTempString str, size_t idx=0) const
Get pattern/subpattern from previous GetMatch().
Definition: regexp.cpp:156
CTempString GetMatch(CTempString str, size_t offset=0, size_t idx=0, TMatch flags=fMatch_default, bool noreturn=false)
Get matching pattern and subpatterns.
Definition: regexp.cpp:182
@ eCompile_ignore_case
Definition: regexp.hpp:112
#define END_NCBI_SCOPE
End previously defined NCBI scope.
Definition: ncbistl.hpp:103
#define BEGIN_NCBI_SCOPE
Define ncbi namespace.
Definition: ncbistl.hpp:100
NCBI_NS_STD::string::size_type SIZE_TYPE
Definition: ncbistr.hpp:132
vector< pair< string, string > > TStringPairsVector
Definition: ncbistr.hpp:4810
#define kEmptyStr
Definition: ncbistr.hpp:123
static list< string > & Split(const CTempString str, const CTempString delim, list< string > &arr, TSplitFlags flags=0, vector< SIZE_TYPE > *token_pos=NULL)
Split a string using specified delimiters.
Definition: ncbistr.cpp:3457
static SIZE_TYPE FindNoCase(const CTempString str, const CTempString pattern, SIZE_TYPE start, SIZE_TYPE end, EOccurrence which=eFirst)
Find the pattern in the specified range of a string using a case insensitive search.
Definition: ncbistr.cpp:2989
static bool EndsWith(const CTempString str, const CTempString end, ECase use_case=eCase)
Check if a string ends with a specified suffix value.
Definition: ncbistr.hpp:5430
#define NPOS
Definition: ncbistr.hpp:133
static const string BoolToString(bool value)
Convert bool to string.
Definition: ncbistr.cpp:2813
static void TruncateSpacesInPlace(string &str, ETrunc where=eTrunc_Both)
Truncate spaces in a string (in-place)
Definition: ncbistr.cpp:3197
static SIZE_TYPE Find(const CTempString str, const CTempString pattern, ECase use_case=eCase, EDirection direction=eForwardSearch, SIZE_TYPE occurrence=0)
Find the pattern in the string.
Definition: ncbistr.cpp:2887
static bool StartsWith(const CTempString str, const CTempString start, ECase use_case=eCase)
Check if a string starts with a specified prefix value.
Definition: ncbistr.hpp:5412
CTempString substr(size_type pos) const
Obtain a substring from this string, beginning at a given offset.
Definition: tempstr.hpp:776
static bool EqualNocase(const CTempString s1, SIZE_TYPE pos, SIZE_TYPE n, const char *s2)
Case-insensitive equality of a substring with another string.
Definition: ncbistr.hpp:5353
static string & ReplaceInPlace(string &src, const string &search, const string &replace, SIZE_TYPE start_pos=0, SIZE_TYPE max_replace=0, SIZE_TYPE *num_replace=0)
Replace occurrences of a substring within a string.
Definition: ncbistr.cpp:3401
static string & ToLower(string &str)
Convert string to lower case – string& version.
Definition: ncbistr.cpp:405
@ eNocase
Case insensitive compare.
Definition: ncbistr.hpp:1206
E_Choice
Choice variants.
static string SelectionName(E_Choice index)
Retrieve selection name (for diagnostic purposes).
@ e_Het
cofactor, prosthetic grp, etc, bound to seq
@ e_Region
named region (globin locus)
@ e_Seq
to annotate origin from another seq
@ e_Txinit
transcription initiation
@ e_Num
a numbering system
@ e_Pub
publication applies to this seq
@ e_User
user defined structure
@ e_Rsite
restriction site (for maps really)
@ e_Comment
just a comment
@ e_Non_std_residue
non-standard residue here in seq
EMActionType
@ eApplyStrCommQualTable
@ eParseBsrcToStructComm
@ eTrimStopsFromCompleteCDS
@ eApplyCDSGeneProtQualTable
@ eApplyMolinfoQualTable
@ eAdjustConsensusSpliceSite
@ eSynchronizeCDSPartials
vector< macro::SArgMetaData > TArgumentsVector
Functions used in the DO/DONE section affecting the top seq-entry.
ECustomPanelType
static bool s_AreGoodPair(const vector< CFuncWithArgs > &func_info)
USING_SCOPE(objects)
static MDB_envinfo info
Definition: mdb_load.c:37
vector< string > GetDoFunctions(const macro::CMacroRep &macro_rep)
Returns the list of do-functions present in the DO clause of the macro - includes multiples.
pair< string, string > GetResolveFuncForDestCdsGeneProtQuals(const string &fieldname, const string &rt_var, TConstraints &constraints, bool remove_constraint)
void UpdateConstraintsForDualCdsGeneProt(TConstraints &constraints, const string &src_feat)
string GetResolveFuncForPubQualConst(const string &field, const string &rt_var, TConstraints &constraints, EMacroFieldType field_type)
IMacroScriptElements::TConstraints TConstraints
CTempString UpdateTargetForFeatures(const string &feature, const string &qualifier, bool for_removal=false)
string GetResolveFuncForDBLink(const string &field, string &rt_var, TConstraints &constraints, bool &found_constraint)
void OnRemoveFromParsedField(CArgumentList &list, CArgument &arg)
string GetResolveFuncForDbXref(const string &path, const string &rt_var, TConstraints &constraints)
void OnRightDigitsLettersInParsePanels(CArgumentList &list, CArgument &arg)
void OnLeftDigitsLettersInParsePanels(CArgumentList &list, CArgument &arg)
void OnStructCommFieldDblChanged(CArgumentList &list, CArgument &arg)
void OnIllegalDbXrefSelected(CArgumentList &list, CArgument &arg)
void OnStructCommFieldChanged(CArgumentList &list, CArgument &arg)
bool MultipleValuesAllowed(const string &field)
void UpdateConstraintsForFeatures(TConstraints &constraints, const string &feature)
EMacroFieldType GetSourceTypeInDoublePanel(const CArgumentList &arg_list, EDirType dir)
string GetStructCommQualDescr(const CArgumentList &arg_list)
string GetResolveFuncForSVPart(const string &field, const string &rt_var, TConstraints &constraints, bool &found_constraint)
CTempString UpdateTargetForMisc(const string &fieldname)
string GetResolveFuncForMultiValuedQual(const string &field, const string &rt_var, TConstraints &constraints, bool remove_constraint)
pair< string, string > GetResolveFuncForRNAQuals(const string &fieldname, const string &rt_var, TConstraints &constraints, bool remove_constraint)
void OnConvertFeatFromCDS(CArgumentList &list, CArgument &arg)
string GetResolveFuncForQual(const string &container, const string &field, const string &rt_var, TConstraints &constraints, bool remove_constraint=true)
Generates the definition of rt_var based on input "field".
string GetUpdatemRNADescription(const CArgument &arg)
void GetMemberNames(const string &container, const string &field, string &member_type, string &member_name, string &main_qual_name)
void OnDOILookupModeChanged(CArgumentList &list, CArgument &arg)
string GetFuncFromTable_Depr(const string &rt_var, const string &filename, const string &col, TConstraints &constraints, string &warning)
pair< string, string > GetResolveFuncForMultiValuedQuals(EMacroFieldType type, const string &fieldname, const string &rt_var, TConstraints &constraints, bool remove_constraint)
void CheckTableNameAndColumns(const string &filename, const TStringPairsVector &values, TConstraints &constraints, string &warning)
void AddConstraintIgnoreNewText(const string &field, TConstraints &constraints, const CArgumentList &arg_list, const string &target=kEmptyStr)
void OnProteinNameSingle(CArgumentList &list, CArgument &arg)
string GetCapitalizationType(const string &cap_change)
CTempString UpdateTargetForMolinfo(const string &molinfo_type)
void GetRNASpecificFieldsForTableReader(const string &field_name, string &rna_type, string &ncRNA_type, string &rna_qual)
CTempString UpdateTargetForDualFeatures(const string &feature, const string &from_field)
bool IsGeneField(const string &field_name)
pair< string, string > GetResolveFuncForSrcCdsGeneProtQuals(const string &fieldname, const string &rt_var, TConstraints &constraints, bool remove_constraint)
string GetGUIRNAType(const string &rna_type)
string GetResolveFuncForGeneQuals(const string &container, const string &field, const string &rt_var, TConstraints &constraints, bool remove_constraint=true)
void OnAfterCheck(CArgumentList &list, CArgument &arg)
string GetDelimiterDescr(const string &del)
void GetRNASpecificFields(const string &field_name, string &rna_type, string &ncRNA_type, string &rna_qual)
CTempString UpdateTargetForRnas(const string &rna_type)
string GetResolveFuncForApplyAuthors(CPubFieldType::EPubFieldType type, const string &rt_var, TConstraints &constraints)
void WrapInQuotes(string &str)
string GetEditableFieldForPair(const string &field, const string &rt_var, bool is_feature)
void OnProteinNameDouble(CArgumentList &list, CArgument &arg)
string GetResolveFuncForStrCommQual(const string &field, const string &field_name, const string &rt_var, TConstraints &constraints)
string GetCapitalizationTypeFromChoice(const string &cap_change)
CTempString UpdateTargetForDualRnas(const string &rna_type, const string &from_field)
pair< string, string > GetResolveFuncForSwapFeatQuals(const string &feature, const string &field, const string &rt_var, TConstraints &constraints, bool remove_constraint, bool &is_gbqual)
pair< string, string > GetResolveFuncForDestFeatQuals(const string &feature, const string &field, const string &rt_var, TConstraints &constraints, bool remove_constraint)
CMacroEditorContext::TBimapStrings TBimapStrings
void OnControlsAddRNAPanelSelected(CArgumentList &list, CArgument &arg)
pair< string, string > GetResolveFuncForSrcFeatQuals(const string &feature, const string &field, const string &rt_var, TConstraints &constraints, bool remove_constraint)
void OnAutodefCompleteSelected(CArgumentList &list, CArgument &arg)
void OnExistingTextChanged(CArgumentList &list, CArgument &arg)
pair< string, string > GetResolveFuncForSwapQuals(EMacroFieldType fieldtype, const string &fieldname, const string &rt_var, TConstraints &constraints, bool remove_constraint, bool &is_gbqual)
void NormalizeFieldForFeatPanel(string &field)
string GetHandleOldValue(const string &type)
string GetFuncFromTable(const string &rt_var, const string &col)
EMacroFieldType GetSourceTypeInSinglePanel(const CArgumentList &arg_list)
void OnRnaTypeChanged(CArgumentList &list, CArgument &arg)
void UpdateConstraintsForRnas(TConstraints &constraints, const CArgumentList &arg_list)
string GetBlankGUIText(const string &str)
void UpdateConstraintsForMisc(TConstraints &constraints, const string &fieldname, const string &target)
void OnSelectFeature(CArgumentList &list, CArgument &arg)
string GetDelimiterChar(const string &del)
void OnBeforeCheck(CArgumentList &list, CArgument &arg)
void OnSelectTable(CArgumentList &list, CArgument &arg)
void UpdateFeatureType(string &feature, const string &field)
void OnConvertFeatToChanged(CArgumentList &list, CArgument &arg)
CTempString UpdateTargetForCdsGeneProt(const string &fieldname)
string GetSelectedCapType(const CArgumentList &arg_list)
string GetRNAFieldname(const string &rna_type, const string &ncRNA_type, const string &rna_qual)
void OnProductDouble(CArgumentList &list, CArgument &arg)
string GetResolveFuncForPubQual(const string &field, string &rt_var, TConstraints &constraints)
void AppendUpdatemRNAFnc(bool update_mrna, string &function)
void OnMiscFeatRuleSelected(CArgumentList &list, CArgument &arg)
void GetFeatureAndField(const string &field_name, string &feature, string &field)
string GetHandleBlank(const string &str)
string GetPropertyFromInfo(const string &info, const string &property)
string GetExistingTextDescr(const CArgumentList &arg_list)
string GetUpdatemRNAVar(const CArgumentList &arg_list)
const string kCapAtSpaces
const string kSameDoi
const string kBsrcLoc
const string kNewValue
const string kColLabel
const string kBsrcOrigin
const string kMiscFeatCheck
const string kMoveToNote
const string kChoices
const string kDigitsRight
const string kMiscFeatRule
const string kCapAtSpacesPunct
const string kToUpper
const string kLetterRight
const string kTextLeft
const string kBsrcTaxTo
const string kRmvLeft
const string kToField
const string kListFeatRule
const string kFromField
const string kBefore
const string kFeatQual
const string kField
const string kTableName
const string kDigitsLeft
const string kAutodefCompl
const string kNoChange
const string kTableCol
const string kRemmRNA
const string kFromFeat
const string kLetterLeft
const string kAfter
const string kRmvOverlapGene
const string kRNAType
const string kFlowerNochange
const string kncRNAClass
const string kCreateOnProtein
const string kExistingText
const string kToLower
const string kTableLabel
const string kDelLeft
const string kFeatType
const string kOpenFile
const string kSelText
const string kDelRight
const string kCapNochange
const string kRmvParse
const string kBsrcText
const string kTextRight
const string kRemGene
const string kBsrcTextTo
const string kRmvRight
const string kRemTranscriptid
const string kUpdatemRNA
const string kBsrcTax
const string kIllegalDbxref
const string kTableEnable
const string kStrCommField
const string kBsrcTaxFrom
const string kBsrcTextFrom
const string kToFeat
const string kDelimiter
const string kFCapLower
constexpr auto sort(_Init &&init)
const char * tag
static const char * str(char *buf, int n)
Definition: stats.c:84
Definition: type.c:6
#define _ASSERT
static const struct type types[]
Definition: type.c:22
C++ wrappers for the Perl-compatible regular expression (PCRE) library.
Modified on Thu Mar 28 17:08:39 2024 by modify_doxy.py rev. 669887