开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数值算法/人工智能 > 生物技术 > 查看源码
plugin_utils.cpp
资源名称：ncbi_cxx_win--Jul_08_2004.zip　[点击查看]
上传用户：yhdzpy8989
上传日期：2007-06-13
资源大小：13604k
文件大小：53k
源码类别：

生物技术

开发平台：

C/C++

plugin_utils.cpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: plugin_utils.cpp,v $
  4.  * PRODUCTION Revision 1000.5  2004/06/01 20:44:35  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.69
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. /*  $Id: plugin_utils.cpp,v 1000.5 2004/06/01 20:44:35 gouriano Exp $
  11.  * ===========================================================================
  12.  *
  13.  *                            PUBLIC DOMAIN NOTICE
  14.  *               National Center for Biotechnology Information
  15.  *
  16.  *  This software/database is a "United States Government Work" under the
  17.  *  terms of the United States Copyright Act.  It was written as part of
  18.  *  the author's official duties as a United States Government employee and
  19.  *  thus cannot be copyrighted.  This software/database is freely available
  20.  *  to the public for use. The National Library of Medicine and the U.S.
  21.  *  Government have not placed any restriction on its use or reproduction.
  22.  *
  23.  *  Although all reasonable efforts have been taken to ensure the accuracy
  24.  *  and reliability of the software and data, the NLM and the U.S.
  25.  *  Government do not and cannot warrant the performance or results that
  26.  *  may be obtained by using this software or data. The NLM and the U.S.
  27.  *  Government disclaim all warranties, express or implied, including
  28.  *  warranties of performance, merchantability or fitness for any particular
  29.  *  purpose.
  30.  *
  31.  *  Please cite the author in any work or product based on this material.
  32.  *
  33.  * ===========================================================================
  34.  *
  35.  * Authors:  Mike DiCuccio
  36.  *
  37.  * File Description:
  38.  *    CPluginUtils -- utilities for managing the interface between the plugin
  39.  *                    architecture and the GBENCH framework
  40.  */
  42. #include <ncbi_pch.hpp>
  43. #include <gui/core/idocument.hpp>
  44. #include <gui/core/obj_convert.hpp>
  45. #include <gui/plugin/PluginValue.hpp>
  46. #include <gui/plugin/PluginValueConstraint.hpp>
  47. #include <gui/plugin/PluginValueRangeConstraint.hpp>
  48. #include <gui/plugin/PluginReply.hpp>
  49. #include <gui/plugin/PluginMessage.hpp>
  50. #include <gui/core/plugin_registry.hpp>
  51. #include <gui/core/plugin_utils.hpp>
  52. #include <gui/core/message_queue.hpp>
  53. #include <gui/core/doc_manager.hpp>
  54. #include <gui/objutils/label.hpp>
  55. #include <gui/utils/message_box.hpp>
  57. #include <gui/core/plugin_arg_dialog.hpp>
  59. #include <serial/iterator.hpp>
  61. #include <objects/seq/Bioseq.hpp>
  62. #include <objects/seq/Seq_annot.hpp>
  63. #include <objects/seqloc/Seq_loc.hpp>
  64. #include <objects/seqloc/Seq_point.hpp>
  65. #include <objects/seqset/Seq_entry.hpp>
  66. #include <objects/seqset/Seq_entry.hpp>
  67. #include <objects/seqalign/Seq_align.hpp>
  68. #include <objmgr/seq_vector.hpp>
  69. #include <objmgr/util/sequence.hpp>
  70. #include <objmgr/util/feature.hpp>
  71. #include <objmgr/annot_selector.hpp>
  72. #include <objmgr/annot_ci.hpp>
  73. #include <objmgr/align_ci.hpp>
  75. #include <algorithm>
  77. BEGIN_NCBI_SCOPE
  78. USING_SCOPE(objects);
  82. // simple functor to return the best argument in a list of arguments
  83. // 'best' is determined by a simple user-supplied rank
  84. struct SChoiceRank
  85. {
  86.     const vector<int>& m_Ranks;
  87.     SChoiceRank(const vector<int>& ranks)
  88.         : m_Ranks(ranks) {}
  90.     int operator() (CConstRef<CPluginArg> arg) const
  91.     {
  92.         if ( !arg ) {
  93.             return m_Ranks.size();
  94.         }
  95.         return m_Ranks[ arg->GetType() ];
  96.     }
  97. };
  100. //
  101. // call a plugin by name, passing in a selection buffer
  102. //
  103. template <class Command>
  104. void s_CallPlugin(const string& plugin_name, Command cmd,
  105.                   const CSelectionBuffer& selections,
  106.                   IReporter* reporter,
  107.                   const string& ctx_name,
  108.                   CPluginUtils::EDispatchWhen when)
  109. {
  110.     // prepare a plugin message to handle our command
  111.     CRef<objects::CPluginMessage> msg(new objects::CPluginMessage());
  112.     msg->SetDestination(plugin_name);
  113.     if ( !ctx_name.empty() ) {
  114.         msg->SetContext(ctx_name);
  115.     }
  116.     msg->SetReporter(reporter);
  118.     objects::CPluginRequest& request = msg->SetRequest();
  119.     objects::CPluginCommand& args    = request.SetCommand(cmd);
  121.     // don't forget to fill in our default arguments
  122.     CPluginHandle handle =
  123.         CPluginRegistry::GetPlugin(plugin_name);
  124.     if ( !handle ) {
  125.         LOG_POST(Error << "CallPlugin(): failed to find plugin named "
  126.                  << plugin_name);
  127.         return;
  128.     }
  129.     handle.FillDefaults(cmd, args);
  131.     // now, pass off to internal processing
  132.     CPluginUtils::CallPlugin(*msg, selections.DecomposeToPairs(), when);
  133. }
  136. //
  137. // call a plugin by name, passing in a document
  138. //
  139. template <class Command>
  140. void s_CallPlugin(const string& plugin_name, Command cmd,
  141.                   const IDocument* doc,
  142.                   IReporter* reporter,
  143.                   const string& ctx_name,
  144.                   CPluginUtils::EDispatchWhen when)
  145. {
  146.     CRef<CSelectionBuffer> buffer(new CSelectionBuffer());
  147.     if (doc) {
  148.         buffer->AddSelection(const_cast<IDocument*>(doc));
  149.     }
  151.     // pass off to a more intelligent CallPlugin() command
  152.     CPluginUtils::CallPlugin(plugin_name, cmd, *buffer,
  153.                              reporter, ctx_name, when);
  154. }
  157. void CPluginUtils::CallPlugin(const string& name, EAlgoCommand cmd,
  158.                               const CSelectionBuffer& buffer,
  159.                               IReporter* reporter,
  160.                               const string& ctx_name,
  161.                               EDispatchWhen when)
  162. {
  163.     s_CallPlugin(name, cmd, buffer, reporter, ctx_name, when);
  164. }
  167. void CPluginUtils::CallPlugin(const string& name, EDataCommand cmd,
  168.                               const CSelectionBuffer& buffer,
  169.                               IReporter* reporter,
  170.                               const string& ctx_name,
  171.                               EDispatchWhen when)
  172. {
  173.     s_CallPlugin(name, cmd, buffer, reporter, ctx_name, when);
  174. }
  177. void CPluginUtils::CallPlugin(const string& name, EViewCommand cmd,
  178.                               const CSelectionBuffer& buffer,
  179.                               IReporter* reporter,
  180.                               const string& ctx_name,
  181.                               EDispatchWhen when)
  182. {
  183.     s_CallPlugin(name, cmd, buffer, reporter, ctx_name, when);
  184. }
  187. void CPluginUtils::CallPlugin(const string& name, EAlgoCommand cmd,
  188.                               const IDocument* doc,
  189.                               IReporter* reporter,
  190.                               const string& ctx_name,
  191.                               EDispatchWhen when)
  192. {
  193.     s_CallPlugin(name, cmd, doc, reporter, ctx_name, when);
  194. }
  197. void CPluginUtils::CallPlugin(const string& name, EDataCommand cmd,
  198.                               const IDocument* doc,
  199.                               IReporter* reporter,
  200.                               const string& ctx_name,
  201.                               EDispatchWhen when)
  202. {
  203.     s_CallPlugin(name, cmd, doc, reporter, ctx_name, when);
  204. }
  207. void CPluginUtils::CallPlugin(const string& name, EViewCommand cmd,
  208.                               const IDocument* doc,
  209.                               IReporter* reporter,
  210.                               const string& ctx_name,
  211.                               EDispatchWhen when)
  212. {
  213.     s_CallPlugin(name, cmd, doc, reporter, ctx_name, when);
  214. }
  218. //
  219. // internal handler for plugin requests that use the CPluginMessage interface
  220. //
  221. void CPluginUtils::CallPlugin(CPluginMessage& msg,
  222.                               EDispatchWhen when)
  223. {
  224.     switch (when) {
  225.     case eDispatch_Deferred:
  226.         // now, place the request message in the message queue.
  227.         CPluginMessageQueue::Add(msg);
  228.         break;
  230.     case eDispatch_Now:
  231.         CPluginMessageQueue::ProcessMessage(msg);
  232.         break;
  233.     }
  234. }
  237. //
  238. // internal handler for all plugin requests
  239. //
  240. void CPluginUtils::CallPlugin(CPluginMessage& msg,
  241.                               const TConstScopedObjects& selections,
  242.                               EDispatchWhen when)
  243. {
  244.     try {
  245.         // first, fill our default values
  246.         string          plugin_name = msg.GetDestination();
  247.         CPluginHandle   handle      = CPluginRegistry::GetPlugin(plugin_name);
  248.         CPluginRequest& request     = msg.SetRequest();
  249.         CPluginCommand& cmd         = request.SetCommand();
  250.         CPluginArgSet&  args        = cmd.SetArgs();
  252.         // give the plugin the opportunity to modify it aguments
  253.         handle.FinalizeArgs(msg);
  255.         // now, try and add any object arguments to our list
  256.         if ( FillArgs(args, selections)  ||  !CPluginUtils::IsValid(args) ) {
  257.             // we have remaining arguments that need to be addressed
  258.             // pop up a form dialog to handle these
  259.             CPluginArgDialog dlg(handle, args, selections);
  260.             if (dlg.ShowModal() == eCancel) {
  261.                 msg.SetReply().SetStatus(eMessageStatus_ignored);
  262.                 return;
  263.             }
  264.         }
  266.         // now, place the request message in the message queue.
  267.         CallPlugin(msg, when);
  268.     }
  269.     catch (CException& e) {
  270.         NcbiMessageBox("Failed to execute plugin:n" + e.GetMsg());
  271.     }
  272.     catch (exception& e) {
  273.         NcbiMessageBox(string("Failed to execute plugin:n") + e.what());
  274.     }
  275. #ifndef _DEBUG
  276.     catch (...) {
  277.         NcbiMessageBox("Failed to execute plugin:nUnknown error");
  278.     }
  279. #endif
  280. }
  283. //
  284. // verify that a set of arguments is valid
  285. //
  286. bool CPluginUtils::IsValid(const CPluginArgSet& arg)
  287. {
  288.     ITERATE(CPluginArgSet::Tdata, iter, arg.Get()) {
  289.         if ( !IsValid(**iter) ) {
  290.             return false;
  291.         }
  292.     }
  294.     return true;
  295. }
  298. //
  299. // verify that a given argument's values are consistent with the argument's
  300. // specifications
  301. //
  302. bool CPluginUtils::IsValid(const CPluginArg& arg)
  303. {
  304.     if (arg.IsSetHidden()  && arg.GetHidden()) {
  305.         // hidden arguments are ignored for the sake of validity
  306.         return true;
  307.     }
  309.     CTypeConstIterator<CPluginValue> iter(arg);
  310.     if ( !iter ) {
  311.         return false;
  312.     }
  314.     CPluginValue::E_Choice type = iter->Which();
  315.     string subtype = iter->GetObjectSubtype();
  316.     for ( ;  iter;  ++iter) {
  317.         if (iter->Which() != type  ||
  318.             iter->GetObjectSubtype() != subtype) {
  319.             return false;
  320.         }
  322.         if ( !IsValid(*iter) ) {
  323.             return false;
  324.         }
  325.     }
  327.     return CheckConstraints(arg);
  328. }
  331. //
  332. // verify that a single plugin value is valid
  333. //
  334. bool CPluginUtils::IsValid(const CPluginValue& val)
  335. {
  336.     switch (val.Which()) {
  337.     default:
  338.     case CPluginValue::e_not_set:
  339.         return false;
  341.     case CPluginValue::e_Integer:
  342.     case CPluginValue::e_String:
  343.     case CPluginValue::e_Double:
  344.     case CPluginValue::e_Boolean:
  345.     case CPluginValue::e_File:
  346.         return !val.IsEmpty();
  348.     case CPluginValue::e_Document:
  349.         {{
  350.             const IDocument* doc = val.GetDocument();
  351.             const CObject*   obj = val.GetObject();
  352.             if ( !doc  ||  !obj ) {
  353.                 return false;
  354.             }
  356.             doc = dynamic_cast<const IDocument*>(obj);
  357.             if ( !doc ) {
  358.                 return false;
  359.             }
  360.             return true;
  361.         }}
  362.         break;
  364.     case CPluginValue::e_Object:
  365.         {{
  366.             const IDocument* doc = val.GetDocument();
  367.             const CObject*   obj = val.GetObject();
  368.             if ( !doc  ||  !obj ) {
  369.                 return false;
  370.             }
  372.             if (val.GetObjectSubtype() == "Document") {
  373.                 doc = dynamic_cast<const IDocument*>(obj);
  374.                 if ( !doc ) {
  375.                     return false;
  376.                 }
  377.                 return true;
  378.             } else if (val.GetObjectSubtype() == "Object") {
  379.                 return true;
  380.             } else {
  381.                 const CSerialObject* o =
  382.                     dynamic_cast<const CSerialObject*>(obj);
  383.                 if (o) {
  384.                     return (val.GetObjectSubtype() ==
  385.                             o->GetThisTypeInfo()->GetName());
  386.                 } else {
  387.                     return false;
  388.                 }
  389.             }
  390.         }}
  391.         break;
  392.     }
  394.     return true;
  395. }
  398. //
  399. // check to see that a plugin argument's values match a plugin
  400. // argument's constraints
  401. //
  402. bool CPluginUtils::CheckConstraints(const CPluginArg& arg,
  403.                                     CConvertCache* cache)
  404. {
  405.     // we always succeed if the constraint is not set
  406.     if ( !arg.IsSetConstraint()  ||  arg.GetConstraint().size() == 0) {
  407.         return true;
  408.     }
  410.     switch (arg.GetType()) {
  411.     case CPluginArg::eInteger:
  412.         if (arg.GetConstraint().size() > 1) {
  413.             // we support only a single constraint for built-in types
  414.             LOG_POST(Error <<
  415.                      "CPluginArg::CheckConstraint(): "
  416.                      "built-in types support only one concurrent constraint");
  417.             return false;
  418.         } else {
  419.             const CPluginValueConstraint& cons = *arg.GetConstraint().front();
  421.             //
  422.             // integral types may be constrained by lower, upper, range,
  423.             // or set constraints
  424.             //
  425.             switch (cons.Which()) {
  426.             case CPluginValueConstraint::e_Lower:
  427.                 // greater than or equal to the lower range
  428.                 return (arg.AsInteger() >=
  429.                         NStr::StringToInt(cons.GetLower()));
  431.             case CPluginValueConstraint::e_Upper:
  432.                 // less than or equal to the lower range
  433.                 return (arg.AsInteger() <=
  434.                         NStr::StringToInt(cons.GetUpper()));
  436.             case CPluginValueConstraint::e_Range:
  437.                 // bounded by the range of values specified
  438.                 {{
  439.                      int val = arg.AsInteger();
  440.                      int lower =
  441.                          NStr::StringToInt(cons.GetRange().GetLower());
  442.                      if (val < lower) {
  443.                          return false;
  444.                      }
  446.                      int upper =
  447.                          NStr::StringToInt(cons.GetRange().GetUpper());
  448.                      return (val <= upper);
  449.                  }}
  451.             case CPluginValueConstraint::e_Set:
  452.                 // must match an item in the set
  453.                 // FIXME: we use a linear scan here
  454.                 {{
  455.                      int val = arg.AsInteger();
  456.                      string val_str = NStr::IntToString(val);
  457.                      CPluginValueConstraint::TSet::const_iterator iter =
  458.                          std::find(cons.GetSet().begin(),
  459.                                    cons.GetSet().end(),
  460.                                    val_str);
  461.                      return (iter != cons.GetSet().end());
  462.                  }}
  464.             default:
  465.                 LOG_POST(Error <<
  466.                          "CPluginArg::CheckConstraint(): "
  467.                          "invalid constraint type for " <<
  468.                          arg.GetName() << ": " << (int)cons.Which());
  469.                 return false;
  470.             }
  471.         }
  472.         break;
  474.     case CPluginArg::eDouble:
  475.         if (arg.GetConstraint().size() > 1) {
  476.             // we support only a single constraint for built-in types
  477.             LOG_POST(Error <<
  478.                      "CPluginArg::CheckConstraint(): "
  479.                      "built-in types support only one concurrent constraint");
  480.             return false;
  481.         } else {
  482.             const CPluginValueConstraint& cons = *arg.GetConstraint().front();
  484.             //
  485.             // real types may be constrained by lower, upper, range, or set
  486.             // constraints
  487.             //
  488.             switch (cons.Which()) {
  489.             case CPluginValueConstraint::e_Lower:
  490.                 // greater than or equal to the lower range
  491.                 return (arg.AsDouble() >=
  492.                         NStr::StringToDouble(cons.GetLower()));
  494.             case CPluginValueConstraint::e_Upper:
  495.                 // less than or equal to the lower range
  496.                 return (arg.AsDouble() <=
  497.                         NStr::StringToDouble(cons.GetUpper()));
  499.             case CPluginValueConstraint::e_Range:
  500.                 // bounded by the range of values specified
  501.                 {{
  502.                      double val = arg.AsDouble();
  503.                      double lower =
  504.                          NStr::StringToDouble(cons.GetRange().GetLower());
  505.                      if (val < lower) {
  506.                          return false;
  507.                      }
  509.                      double upper =
  510.                          NStr::StringToDouble(cons.GetRange().GetUpper());
  511.                      return (val <= upper);
  512.                  }}
  514.             case CPluginValueConstraint::e_Set:
  515.                 // must match an item in the set
  516.                 // FIXME: we use a linear scan here
  517.                 {{
  518.                      double val = arg.AsDouble();
  519.                      string val_str = NStr::DoubleToString(val);
  520.                      CPluginValueConstraint::TSet::const_iterator iter =
  521.                          std::find(cons.GetSet().begin(),
  522.                                    cons.GetSet().end(),
  523.                                    val_str);
  524.                      return (iter != cons.GetSet().end());
  525.                  }}
  527.             default:
  528.                 LOG_POST(Error <<
  529.                          "CPluginArg::CheckConstraint(): "
  530.                          "invalid constraint type for " <<
  531.                          arg.GetName() << ": " << (int)cons.Which());
  532.                 return false;
  533.             }
  534.         }
  535.         break;
  537.     case CPluginArg::eString:
  538.         if (arg.GetConstraint().size() > 1) {
  539.             // we support only a single constraint for built-in types
  540.             LOG_POST(Error <<
  541.                      "CPluginArg::CheckConstraint(): "
  542.                      "built-in types support only one concurrent constraint");
  543.             return false;
  544.         } else {
  545.             const CPluginValueConstraint& cons = *arg.GetConstraint().front();
  547.             //
  548.             // integral types may be constrained by lower, upper, range, or set
  549.             // constraints
  550.             //
  551.             switch (cons.Which()) {
  552.             case CPluginValueConstraint::e_Lower:
  553.                 // greater than or equal to the lower range
  554.                 return (arg.AsString() >= cons.GetLower());
  556.             case CPluginValueConstraint::e_Upper:
  557.                 // less than or equal to the lower range
  558.                 return (arg.AsString() <= cons.GetUpper());
  560.             case CPluginValueConstraint::e_Range:
  561.                 // bounded by the range of values specified
  562.                 {{
  563.                      string val = arg.AsString();
  564.                      string lower = cons.GetRange().GetLower();
  565.                      if (val < lower) {
  566.                          return false;
  567.                      }
  569.                      string upper = cons.GetRange().GetUpper();
  570.                      return (val <= upper);
  571.                  }}
  573.             case CPluginValueConstraint::e_Set:
  574.                 // must match an item in the set
  575.                 // FIXME: we use a linear scan here
  576.                 {{
  577.                      string val = arg.AsString();
  578.                      CPluginValueConstraint::TSet::const_iterator iter =
  579.                          std::find(cons.GetSet().begin(),
  580.                                    cons.GetSet().end(),
  581.                                    val);
  582.                      return (iter != cons.GetSet().end());
  583.                  }}
  585.             default:
  586.                 LOG_POST(Error <<
  587.                          "CPluginArg::CheckConstraint(): "
  588.                          "invalid constraint type for " <<
  589.                          arg.GetName() << ": " << (int)cons.Which());
  590.                 return false;
  591.             }
  592.         }
  593.         break;
  595.     case CPluginArg::eBoolean:
  596.         // no constraints make sense for boolean arguments
  597.         LOG_POST(Error << "CPluginArg::CheckConstraint(): "
  598.                  "constraints are invalid for Boolean arguments");
  599.         return false;
  601.     case CPluginArg::eObject:
  602.     case CPluginArg::eDocument:
  603.         {{
  604.              CTypeConstIterator<CPluginValue> iter(arg);
  605.              for ( ;  iter;  ++iter) {
  606.                  const CObject* obj = iter->GetObject();
  607.                  const IDocument* doc = iter->GetDocument();
  608.                  if ( !obj  ||  !doc ) {
  609.                      return false;
  610.                  }
  612.                  CScope& scope = doc->GetScope();
  613.                  if ( !CheckConstraints(arg, scope, *obj, cache) ) {
  614.                      return false;
  615.                  }
  616.              }
  617.              return true;
  618.          }}
  620.     default:
  621.         LOG_POST(Error << "CPluginUtils::CheckConstraint(): "
  622.                  "unhandled argument type");
  623.         break;
  624.     }
  625.     return false;
  626. }
  629. bool CPluginUtils::CheckConstraints(const CPluginArg& arg,
  630.                                     CScope& scope,
  631.                                     const CObject& obj,
  632.                                     CConvertCache* cache)
  633. {
  634.     //
  635.     // we may have multiple constraints, to answer questions such as "Give
  636.     // me all sequences that are proteins of at least 100 bases" and "Give
  637.     // me a set of sequences, all of the same molecule type, that are of
  638.     // sequence type raw"
  639.     //
  641.     ITERATE (CPluginArg::TConstraint, c_iter, arg.GetConstraint()) {
  642.         const CPluginValueConstraint& cons = **c_iter;
  643.         switch (cons.Which()) {
  644.             //
  645.             // constraints for bioseq types
  646.             //
  647.         case CPluginValueConstraint::e_Seq_repr:
  648.             // constrain the sequence representation to be of a certain type
  649.             {{
  650.                  CObjConverter::TObjList bioseqs;
  651.                  CObjectConverter::Convert(scope, obj, CBioseq::GetTypeInfo(),
  652.                                            bioseqs);
  654.                  ITERATE(CObjConverter::TObjList, iter, bioseqs) {
  655.                      const CBioseq* bioseq =
  656.                          dynamic_cast<const CBioseq*>(iter->GetPointer());
  657.                      if ( !bioseq ) {
  658.                          return false;
  659.                      }
  661.                      if (std::find(cons.GetSeq_repr().begin(),
  662.                                    cons.GetSeq_repr().end(),
  663.                                    bioseq->GetInst().GetRepr()) ==
  664.                          cons.GetSeq_repr().end() ) {
  665.                          return false;
  666.                      }
  667.                  }
  668.              }}
  669.             break;
  671.         case CPluginValueConstraint::e_Seq_mol:
  672.             // constrain the molecule type to be of a certain type
  673.             {{
  674.                  CObjConverter::TObjList bioseqs;
  675.                  CObjectConverter::Convert(scope, obj, CBioseq::GetTypeInfo(),
  676.                                            bioseqs);
  677.                  ITERATE(CObjConverter::TObjList, iter, bioseqs) {
  678.                      const CBioseq* bioseq =
  679.                          dynamic_cast<const CBioseq*>(iter->GetPointer());
  680.                      if ( !bioseq ) {
  681.                          return false;
  682.                      }
  684.                      if (std::find(cons.GetSeq_mol().begin(),
  685.                                    cons.GetSeq_mol().end(),
  686.                                    bioseq->GetInst().GetMol()) ==
  687.                          cons.GetSeq_mol().end() ) {
  688.                          return false;
  689.                      }
  690.                  }
  691.              }}
  692.             break;
  694.         case CPluginValueConstraint::e_Seq_mol_same_type:
  695.             // constrain a set of values such that their molecule types are all
  696.             // the same
  697.             {{
  698.                  const CBioseq* prev = NULL;
  699.                  CObjConverter::TObjList bioseqs;
  700.                  CObjectConverter::Convert(scope, obj, CBioseq::GetTypeInfo(),
  701.                                            bioseqs);
  702.                  ITERATE(CObjConverter::TObjList, iter, bioseqs) {
  703.                      const CBioseq* bioseq =
  704.                          dynamic_cast<const CBioseq*>(iter->GetPointer());
  705.                      if ( !bioseq ) {
  706.                          return false;
  707.                      }
  709.                      if ( !prev ) {
  710.                          prev = bioseq;
  711.                      } else {
  712.                          if (prev->GetInst().GetMol() !=
  713.                              bioseq->GetInst().GetMol()) {
  714.                              return false;
  715.                          }
  716.                      }
  717.                  }
  718.              }}
  719.             break;
  721.         case CPluginValueConstraint::e_Seq_length_lower:
  722.             // constrain a set of sequences such that their lengths are at
  723.             // least some bound
  724.             {{
  725.                  TSeqPos min_len = cons.GetSeq_length_lower();
  726.                  CObjConverter::TObjList bioseqs;
  727.                  CObjectConverter::Convert(scope, obj, CBioseq::GetTypeInfo(),
  728.                                            bioseqs);
  729.                  ITERATE(CObjConverter::TObjList, iter, bioseqs) {
  730.                      const CBioseq* bioseq =
  731.                          dynamic_cast<const CBioseq*>(iter->GetPointer());
  732.                      if ( !bioseq ) {
  733.                          return false;
  734.                      }
  736.                      if (bioseq->GetInst().GetLength() < min_len) {
  737.                          return false;
  738.                      }
  739.                  }
  740.              }}
  741.             break;
  743.         case CPluginValueConstraint::e_Seq_length_upper:
  744.             // constrain a set of sequences such that their lengths are no
  745.             // greater than some bound
  746.             {{
  747.                  TSeqPos max_len = cons.GetSeq_length_upper();
  748.                  CObjConverter::TObjList bioseqs;
  749.                  CObjectConverter::Convert(scope, obj, CBioseq::GetTypeInfo(),
  750.                                            bioseqs);
  751.                  ITERATE(CObjConverter::TObjList, iter, bioseqs) {
  752.                      const CBioseq* bioseq =
  753.                          dynamic_cast<const CBioseq*>(iter->GetPointer());
  754.                      if ( !bioseq ) {
  755.                          return false;
  756.                      }
  758.                      if (bioseq->GetInst().GetLength() > max_len) {
  759.                          return false;
  760.                      }
  761.                  }
  762.              }}
  763.             break;
  765.         case CPluginValueConstraint::e_Seq_length_range:
  766.             // constrain a set of sequences such that their lengths are at
  767.             // least some bound
  768.             {{
  769.                  TSeqPos min_len =
  770.                      NStr::StringToInt(cons.GetSeq_length_range().GetLower());
  771.                  TSeqPos max_len =
  772.                      NStr::StringToInt(cons.GetSeq_length_range().GetUpper());
  773.                  CObjConverter::TObjList bioseqs;
  774.                  CObjectConverter::Convert(scope, obj, CBioseq::GetTypeInfo(),
  775.                                            bioseqs);
  776.                  ITERATE(CObjConverter::TObjList, iter, bioseqs) {
  777.                      const CBioseq* bioseq =
  778.                          dynamic_cast<const CBioseq*>(iter->GetPointer());
  779.                      if ( !bioseq ) {
  780.                          return false;
  781.                      }
  783.                      if (bioseq->GetInst().GetLength() < min_len  ||
  784.                          bioseq->GetInst().GetLength() > max_len) {
  785.                          return false;
  786.                      }
  787.                  }
  788.              }}
  789.             break;
  791.         case CPluginValueConstraint::e_Seq_length_same:
  792.             _TRACE("x_CheckObjectConstraint(): failed: "
  793.                    "seq-inst.length: same length constraint not implemented");
  794.             break;
  796.             //
  797.             // constraints for seq-entry types
  798.             //
  799.         case CPluginValueConstraint::e_Entry_type:
  800.             // constrain a set of values such that their molecule types are all
  801.             // the same
  802.             {{
  803.                  CObjConverter::TObjList entries;
  804.                  CObjectConverter::Convert(scope, obj,
  805.                                            CSeq_entry::GetTypeInfo(), entries);
  806.                  ITERATE(CObjConverter::TObjList, iter, entries) {
  807.                      const CSeq_entry* entry=
  808.                          dynamic_cast<const CSeq_entry*>(iter->GetPointer());
  809.                      if ( !entry ) {
  810.                          return false;
  811.                      }
  813.                      if ( !entry->IsSet()  ||
  814.                           !entry->GetSet().IsSetClass()  ||
  815.                           !entry->GetSet().GetClass() == cons.GetEntry_type()) {
  816.                          return false;
  817.                      }
  818.                  }
  819.              }}
  820.             break;
  822.             //
  823.             // constraints for seq-annot types
  824.             //
  825.         case CPluginValueConstraint::e_Annot_type:
  826.             // constrain the sequence representation to be of a certain type
  827.             {{
  828.                  CObjConverter::TObjList annots;
  829.                  CObjectConverter::Convert(scope, obj,
  830.                                            CSeq_annot::GetTypeInfo(), annots);
  831.                  ITERATE(CObjConverter::TObjList, iter, annots) {
  832.                      const CSeq_annot* annot=
  833.                          dynamic_cast<const CSeq_annot*>(iter->GetPointer());
  834.                      if ( !annot ) {
  835.                          return false;
  836.                      }
  838.                      if (annot->GetData().Which() != cons.GetAnnot_type()) {
  839.                          return false;
  840.                      }
  841.                  }
  842.              }}
  843.             break;
  845.             //
  846.             // constraints for seq-feat types
  847.             //
  848.         case CPluginValueConstraint::e_Feat_type:
  849.             // constrain the sequence representation to be of a certain type
  850.             {{
  851.                  CObjConverter::TObjList feats;
  852.                  CObjectConverter::Convert(scope, obj,
  853.                                            CSeq_feat::GetTypeInfo(), feats);
  854.                  ITERATE(CObjConverter::TObjList, iter, feats) {
  855.                      const CSeq_feat* feat=
  856.                          dynamic_cast<const CSeq_feat*>(iter->GetPointer());
  857.                      if ( !feat ) {
  858.                          return false;
  859.                      }
  861.                      if (std::find(cons.GetFeat_type().begin(),
  862.                                    cons.GetFeat_type().end(), 
  863.                                    feat->GetData().Which()) ==
  864.                          cons.GetFeat_type().end()) {
  865.                          return false;
  866.                      }
  867.                  }
  868.              }}
  869.             break;
  871.             //
  872.             // constraints for seq-feat subtypes
  873.             //
  874.         case CPluginValueConstraint::e_Feat_subtype:
  875.             // constrain the sequence representation to be of a certain type
  876.             {{
  877.                  CObjConverter::TObjList feats;
  878.                  CObjectConverter::Convert(scope, obj,
  879.                                            CSeq_feat::GetTypeInfo(), feats);
  880.                  ITERATE(CObjConverter::TObjList, iter, feats) {
  881.                      const CSeq_feat* feat=
  882.                          dynamic_cast<const CSeq_feat*>(iter->GetPointer());
  883.                      if ( !feat ) {
  884.                          return false;
  885.                      }
  887.                      string label;
  888.                      feature::GetLabel(*feat, &label, feature::eBoth, &scope);
  889.                      if (std::find(cons.GetFeat_subtype().begin(),
  890.                                    cons.GetFeat_subtype().end(),
  891.                                    feat->GetData().GetSubtype()) ==
  892.                          cons.GetFeat_subtype().end()) {
  893.                          return false;
  894.                      }
  895.                  }
  896.              }}
  897.             break;
  899.             //
  900.             // constraints for seq-feats that have products set
  901.             //
  902.         case CPluginValueConstraint::e_Feat_has_product:
  903.             // constrain the sequence representation to be of a certain type
  904.             {{
  905.                  CObjConverter::TObjList feats;
  906.                  CObjectConverter::Convert(scope, obj,
  907.                                            CSeq_feat::GetTypeInfo(), feats);
  908.                  ITERATE(CObjConverter::TObjList, iter, feats) {
  909.                      const CSeq_feat* feat=
  910.                          dynamic_cast<const CSeq_feat*>(iter->GetPointer());
  911.                      if ( !feat ) {
  912.                          return false;
  913.                      }
  915.                      if ( !feat->IsSetProduct() ) {
  916.                          return false;
  917.                      }
  918.                  }
  919.              }}
  920.             break;
  922.         default:
  923.             LOG_POST(Error <<
  924.                      "CPluginArg::CheckConstraint():"
  925.                      " unhandled constraint type: " << (int)cons.Which());
  926.             return false;
  927.             break;
  928.         }
  929.     }
  931.     return true;
  932. }
  935. //
  936. // utility function to convert a set of selections into a set of arguments
  937. //
  938. int CPluginUtils::FillArgs(CPluginArgSet& args, const IDocument& doc)
  939. {
  940.     TConstScopedObjects sels;
  941.     sels.push_back(SConstScopedObject(doc, doc.GetScope()));
  942.     return FillArgs(args, sels);
  943. }
  946. int CPluginUtils::FillArgs(CPluginArgSet& args,
  947.                            const CPluginArg::TData::TArray& objs)
  948. {
  949.     // step 1: clear any object-based arguments
  950.     NON_CONST_ITERATE (CPluginArgSet::Tdata, iter, args.Set()) {
  951.         CPluginArg& arg = **iter;
  952.         arg.ClearObjects();
  953.     }
  955.     CSelectionBuffer buffer;
  956.     ITERATE (CPluginArg::TData::TArray, iter, objs) {
  957.         const CPluginValue& val = **iter;
  958.         if ( !val.GetObject() ) {
  959.             continue;
  960.         }
  962.         if ( val.IsObject() ) {
  963.             const CSerialObject* obj =
  964.                 dynamic_cast<const CSerialObject*>(val.GetObject());
  965.             IDocument* doc =
  966.                 const_cast<IDocument*>(
  967.                 dynamic_cast<const IDocument*>(val.GetDocument()));
  968.             if (obj  &&  doc) {
  969.                 buffer.AddSelection(doc, *obj);
  970.             }
  971.         } else if ( val.IsDocument() ) {
  972.             IDocument* doc =
  973.                 const_cast<IDocument*>(
  974.                 dynamic_cast<const IDocument*>(val.GetObject()));
  975.             if (doc) {
  976.                 buffer.AddSelection(doc);
  977.             }
  978.         }
  979.     }
  981.     return FillArgs(args, buffer.DecomposeToPairs());
  982. }
  985. int CPluginUtils::FillArgs(CPluginArgSet& args,
  986.                            const TConstScopedObjects& sels)
  987. {
  988.     // easy out: no arguments to fill
  989.     if (args.Get().size() == 0) {
  990.         return 0;
  991.     }
  993.     // we plan to handle one case automatically: the set of arguments has
  994.     // one argument that takes a data model object.  Other cases are left
  995.     // to the user to clarify because these are too complex to guess
  996.     int visible_args = 0;
  997.     int obj_args = 0;
  998.     CRef<CPluginArg> arg_to_fill;
  999.     NON_CONST_ITERATE (CPluginArgSet::Tdata, iter, args.Set()) {
  1000.         CPluginArg& arg = **iter;
  1001.         if (arg.IsSetHidden()  && arg.GetHidden()) {
  1002.             continue;
  1003.         }
  1004.         ++visible_args;
  1005.         CPluginArg::EType type = arg.GetType();
  1006.         if (type == CPluginArg::eObject  ||
  1007.             type == CPluginArg::eDocument) {
  1008.             ++obj_args;
  1009.             // clear object argument
  1010.             arg.ClearObjects();
  1011.             arg_to_fill.Reset(&arg);
  1012.         }
  1013.     }
  1015.     // make sure we actually can address this argument
  1016.     if ( obj_args > 1  ||  !arg_to_fill ) {
  1017.         return visible_args;
  1018.     }
  1020.     // now, convert as many objects as possible into the requested format
  1021.     // here we plan to support automatic assignments to data model objects
  1022.     // only; CObject assignments can be made for these, but this must be
  1023.     // done under user direction
  1024.     switch (arg_to_fill->GetData().Which()) {
  1025.     case CPluginArg::TData::e_Single:
  1026.         //
  1027.         // make sure we have exactly one selection
  1028.         //
  1029.         if (sels.size() == 1) {
  1030.             const string& target_type = arg_to_fill->GetObjectSubtype();
  1032.             SConstScopedObject cso = sels.front();
  1033.             CScope& scope = *cso.scope;
  1034.             IDocument* doc = CDocManager::GetDocumentFromScope(scope);
  1035.             if ( !doc ) {
  1036.                 break;
  1037.             }
  1039.             CObjConverter::TObjList obj_list;
  1040.             CObjectConverter::Convert(scope, *cso.object,
  1041.                                       target_type, obj_list);
  1042.             if (obj_list.size() != 1) {
  1043.                 break;
  1044.             }
  1046.             arg_to_fill->SetObject(*doc, *obj_list.front());
  1047.             if (CPluginUtils::CheckConstraints(*arg_to_fill)) {
  1048.                 return visible_args - 1;
  1049.             }
  1050.         }
  1051.         break;
  1053.     case CPluginArg::TData::e_Array:
  1054.         {{
  1055.              // make sure we preserve existing values
  1056.              CPluginArg::TValues value_list;
  1057.              arg_to_fill->AsList(value_list);
  1059.              // we can assign many objects
  1060.              // first, we do a one-to-many conversion, based on the target type
  1061.              const string& target_type = arg_to_fill->GetObjectSubtype();
  1063.              // now, iterate our selections and convert as necessary
  1064.              ITERATE (TConstScopedObjects, iter, sels) {
  1065.                  SConstScopedObject cso = sels.front();
  1066.                  CScope& scope = *cso.scope;
  1067.                  IDocument* doc = CDocManager::GetDocumentFromScope(scope);
  1068.                  if ( !doc ) {
  1069.                      continue;
  1070.                  }
  1072.                  CObjectConverter::TObjList obj_list;
  1073.                  CObjectConverter::Convert(scope, *iter->object,
  1074.                                            target_type, obj_list);
  1075.                  ITERATE(CObjectConverter::TObjList, obj_iter, obj_list) {
  1076.                      CRef<CPluginValue> value(new CPluginValue());
  1077.                      value->SetObject(*doc, **obj_iter);
  1078.                      value_list.push_back(value);
  1079.                  }
  1080.              }
  1082.              // make sure all of our arguments are valid
  1083.              // we do this such that any unfilled argument will be passed on
  1084.              // if we added nothing to this argument, then our size is 1
  1085.              if (value_list.size() > 1) {
  1086.                  CPluginArg::TValues::iterator iter     = value_list.begin();
  1087.                  CPluginArg::TValues::iterator end_iter = value_list.end();
  1088.                  for ( ;  iter != end_iter;  ) {
  1089.                      const CPluginValue& value = **iter;
  1090.                      if ( !IsValid(value) ) {
  1091.                          iter = value_list.erase(iter);
  1092.                      } else {
  1093.                          ++iter;
  1094.                      }
  1095.                  }
  1096.              }
  1098.              arg_to_fill->SetList(value_list);
  1099.              if (CPluginUtils::CheckConstraints(*arg_to_fill)) {
  1100.                  return visible_args - 1;
  1101.              }
  1102.          }}
  1103.         break;
  1105.     default:
  1106.         break;
  1107.     }
  1109.     return visible_args;
  1110. }
  1113. // this function performs a similar task to FillArgs(); however, instead of
  1114. // actually filling the set of arguments automatically, it returns true if any
  1115. // of the selections indicated *can* fit.  The primary use of this is to
  1116. // determine if a set of plugins could accept some of the selections
  1117. bool CPluginUtils::CanFitArgs(const CPluginArgSet& args,
  1118.                               const IDocument& doc,
  1119.                               CConvertCache* cache)
  1120. {
  1121.     TConstScopedObjects sels;
  1122.     sels.push_back(SConstScopedObject(doc, doc.GetScope()));
  1123.     return CanFitArgs(args, sels, cache);
  1124. }
  1127. bool CPluginUtils::CanFitArgs(const CPluginArgSet& args,
  1128.                               const CSelectionBuffer& sels,
  1129.                               CConvertCache* cache)
  1130. {
  1131.     return CanFitArgs(args, sels.DecomposeToPairs(), cache);
  1132. }
  1135. bool CPluginUtils::CanFitArgs(const CPluginArgSet& args,
  1136.                               const TConstScopedObjects& sels,
  1137.                               CConvertCache* cache)
  1138. {
  1139.     // easy out: no arguments to fill
  1140.     // we're always valid here
  1141.     if (args.Get().size() == 0) {
  1142.         return true;
  1143.     }
  1145.     // we plan to handle one case automatically: the set of arguments has
  1146.     // one argument that takes a data model object.  Other cases are left
  1147.     // to the user to clarify because these are too complex to guess
  1148.     int obj_args = 0;
  1149.     ITERATE (CPluginArgSet::Tdata, iter, args.Get()) {
  1150.         const CPluginArg& arg = **iter;
  1152.         switch (arg.GetType()) {
  1153.         case CPluginArg::eObject:
  1154.         case CPluginArg::eDocument:
  1155.             {{
  1156.                  ++obj_args;
  1157.                  const string& target_type = arg.GetObjectSubtype();
  1159.                  // are there any selections that might support this object
  1160.                  // type?  if so, we can return true
  1161.                  ITERATE (TConstScopedObjects, iter, sels) {
  1162.                      SConstScopedObject cso = *iter;
  1163.                      CScope& scope = *cso.scope;
  1164.                      CObjConverter::TObjList obj_list;
  1165.                      /**
  1166.                      if (cache) {
  1167.                          obj_list =
  1168.                              cache->Convert(scope,
  1169.                                             *iter->m_Object.GetPointer(),
  1170.                                             target_type);
  1171.                      } else **/{
  1172.                          CObjectConverter::Convert(scope,
  1173.                                                    *cso.object,
  1174.                                                    target_type, obj_list);
  1175.                      }
  1177.                      if (obj_list.size() == 0) {
  1178.                          continue;
  1179.                      }
  1181.                      ITERATE (CObjConverter::TObjList, obj_iter, obj_list) {
  1182.                          if ( CheckConstraints(arg, scope, **obj_iter) ) {
  1183.                              return true;
  1184.                          }
  1185.                      }
  1186.                  }
  1188.              }}
  1189.             break;
  1191.         default:
  1192.             break;
  1193.         }
  1194.     }
  1196.     // we failed to match any selection to an argument type
  1197.     // the only case we let pass is that there are no object argument types
  1198.     return (obj_args == 0);
  1199. }
  1202. vector<string> CPluginUtils::ArgToStringVec(const CPluginArg& arg)
  1203. {
  1204.     if (arg.GetType() != CPluginArg::eString) {
  1205.         NCBI_THROW(CPluginException, eInvalidArg,
  1206.                    "CPluginUtil::ArgToStringVec(): "
  1207.                    "Argument is not of type String");
  1208.     }
  1210.     vector<string> vals;
  1211.     CTypeConstIterator<CPluginValue> iter(arg);
  1212.     for ( ;  iter;  ++iter) {
  1213.         vals.push_back(iter->AsString());
  1214.     }
  1216.     return vals;
  1217. }
  1220. //
  1221. // return the label of an object based on its type (arg.m_Subtype)
  1222. //
  1223. string CPluginUtils::GetLabel(const CObject& obj, CScope* scope)
  1224. {
  1225.     {{
  1226.         // generic document handling
  1227.         const IDocument* doc = dynamic_cast<const IDocument*> (&obj);
  1228.         if (doc) {
  1229.             return doc->GetTitle();
  1230.         }
  1231.     }}
  1233.     string label;
  1234.     CLabel::GetLabel(obj, &label, CLabel::eDefault, scope);
  1235.     return label;
  1236. }
  1239. //
  1240. // retrieve the CPluginInfo object associated with a named plugin
  1241. //
  1242. const CPluginInfo& CPluginUtils::GetInfo(const string& plugin_name)
  1243. {
  1244.     CPluginHandle handle = CPluginRegistry::GetPlugin(plugin_name);
  1245.     if ( !handle ) {
  1246.         NCBI_THROW(CPluginException, eInvalidArg,
  1247.                    "Invalid plugin name " + plugin_name);
  1248.     }
  1249.     return handle.GetInfo();
  1250. }
  1253. END_NCBI_SCOPE
  1256. /*
  1257.  * ===========================================================================
  1258.  * $Log: plugin_utils.cpp,v $
  1259.  * Revision 1000.5  2004/06/01 20:44:35  gouriano
  1260.  * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.69
  1261.  *
  1262.  * Revision 1.69  2004/06/01 18:03:45  dicuccio
  1263.  * Allocate temporary CSelectionBuffer objects on the heap, not on the stack
  1264.  *
  1265.  * Revision 1.68  2004/05/21 22:27:40  gorelenk
  1266.  * Added PCH ncbi_pch.hpp
  1267.  *
  1268.  * Revision 1.67  2004/05/07 15:41:27  dicuccio
  1269.  * Use CLabel instead of CSeqUtils::GetLabel()
  1270.  *
  1271.  * Revision 1.66  2004/05/03 12:49:28  dicuccio
  1272.  * gui/utils --> gui/objutils where needed
  1273.  *
  1274.  * Revision 1.65  2004/04/07 12:47:31  dicuccio
  1275.  * Use TConstScopedObjects instead of CSelectionBuffer::TSelList.  Changed
  1276.  * CallPlugin API to include an IReporter interface.
  1277.  *
  1278.  * Revision 1.64  2004/03/08 20:21:05  jcherry
  1279.  * Fixed object argument clearing
  1280.  *
  1281.  * Revision 1.63  2004/02/04 14:09:04  dicuccio
  1282.  * Enable clearing of objects
  1283.  *
  1284.  * Revision 1.62  2004/02/03 23:08:13  ucko
  1285.  * Temporarily remove call to ClearObjects, which doesn't seem to be
  1286.  * implemented yet.
  1287.  *
  1288.  * Revision 1.61  2004/02/03 21:24:31  dicuccio
  1289.  * Clear objects from plugin argument sets prior to filling with new objects
  1290.  *
  1291.  * Revision 1.60  2004/01/30 17:18:11  dicuccio
  1292.  * Moved most of GetLabel() to CSeqUtils - CPluginUtils::GetLabel() only handles
  1293.  * IDocument directly
  1294.  *
  1295.  * Revision 1.59  2004/01/21 12:38:18  dicuccio
  1296.  * redesigned CObjectCOnverter API to eliminate temporary object creation
  1297.  *
  1298.  * Revision 1.58  2004/01/20 18:13:28  dicuccio
  1299.  * Make sure to check for bioseq handle validity before requesting information
  1300.  * from it
  1301.  *
  1302.  * Revision 1.57  2004/01/15 22:50:17  jcherry
  1303.  * Added FinalizeArgs() for plugins
  1304.  *
  1305.  * Revision 1.56  2004/01/07 15:48:10  dicuccio
  1306.  * Renamed GetObjectLabel() to GetLabel().  Dropped use of CSeq_loc::GetLabel() in
  1307.  * favor of internal location processing
  1308.  *
  1309.  * Revision 1.55  2004/01/05 19:10:31  dicuccio
  1310.  * Move comment marker
  1311.  *
  1312.  * Revision 1.54  2003/12/22 19:21:16  dicuccio
  1313.  * GetObjectLabel(): format a nicer string for seq-ids when possible
  1314.  *
  1315.  * Revision 1.53  2003/11/26 17:08:22  dicuccio
  1316.  * Fixed two thinkos:
  1317.  * - in s_CallPlugin(), check to make sure the plugin handle is valid before
  1318.  *   calling FillDefaults()
  1319.  * - make sure that FillArgs() doesn't dereference a NULL pointer
  1320.  *
  1321.  * Revision 1.52  2003/11/18 17:44:31  dicuccio
  1322.  * Added new API for FitArgs() to take a set of CPluginValue objects
  1323.  *
  1324.  * Revision 1.51  2003/11/06 20:04:56  dicuccio
  1325.  * Added context parameter to PluginMessage.  Added APIs to CallPlugin() to permit
  1326.  * passing the context parameter
  1327.  *
  1328.  * Revision 1.50  2003/11/04 17:19:41  dicuccio
  1329.  * Made templateed calls to registry private.  Changed to match API change in
  1330.  * CPluginMessage.
  1331.  *
  1332.  * Revision 1.49  2003/10/27 17:39:54  dicuccio
  1333.  * Changed to match new API for CPluginValue variant
  1334.  *
  1335.  * Revision 1.48  2003/10/23 16:18:09  dicuccio
  1336.  * Fixed to match API change for CPluginArgDialog
  1337.  *
  1338.  * Revision 1.47  2003/10/15 18:28:45  dicuccio
  1339.  * Added handling for new constraint types
  1340.  *
  1341.  * Revision 1.46  2003/10/10 17:15:58  dicuccio
  1342.  * Changed protoypes for CanFitArgs() - take optional conversion cache
  1343.  *
  1344.  * Revision 1.45  2003/10/10 15:57:28  friedman
  1345.  * Changed all CPluginUtils::Convert to use CObjectConverter::Convert.
  1346.  * Label for SeqFeat changed to include the document id and document short title.
  1347.  *
  1348.  * Revision 1.44  2003/10/07 13:36:09  dicuccio
  1349.  * Renamed CPluginURL* to CPluginValue*.  Moved validation code into CPluginUtils
  1350.  *
  1351.  * Revision 1.43  2003/10/01 12:07:35  ucko
  1352.  * +<algorithm> for find()
  1353.  *
  1354.  * Revision 1.42  2003/09/16 14:02:07  dicuccio
  1355.  * Replaced conversion code with calls to new class (CObjectConverter)
  1356.  *
  1357.  * Revision 1.41  2003/09/04 14:01:51  dicuccio
  1358.  * Introduce IDocument and IView as abstract base classes for CDocument and CView
  1359.  *
  1360.  * Revision 1.40  2003/09/02 20:36:26  dicuccio
  1361.  * Corrected x_DocToSeqAnnot to handle the case of a seq-annot-as-document
  1362.  *
  1363.  * Revision 1.39  2003/08/28 15:55:51  ucko
  1364.  * GetObjectLabel: return CNcbiOstrstreamToString(label) rather than
  1365.  * label.str() to ensure proper cleanup and termination.
  1366.  *
  1367.  * Revision 1.38  2003/08/28 00:09:08  ucko
  1368.  * x_SeqLocToSeqAnnot: adjust for latest objmgr API.
  1369.  *
  1370.  * Revision 1.37  2003/08/22 17:28:10  dicuccio
  1371.  * FIxed seq-annot conversions - all now pass through x_SeqLocToSeqAnnot
  1372.  *
  1373.  * Revision 1.36  2003/08/22 17:05:05  dicuccio
  1374.  * Temporary compilation fix: disable annotation conversion
  1375.  *
  1376.  * Revision 1.35  2003/08/22 15:45:12  dicuccio
  1377.  * Removed a number of unnecessary _TRACE() statemens
  1378.  *
  1379.  * Revision 1.34  2003/08/19 18:52:16  friedman
  1380.  * Added the follwing conversion functionclality to Convert:
  1381.  *     doc -> seq-annot, bioseq -> seq-annot, seq-id -> seq-annot,
  1382.  *     seq-loc -> seq-annot, seq-entry -> seq-annot, doc -> seq-align
  1383.  *
  1384.  * Added seq-annot and seq-align label formatting to GetObjectLabel
  1385.  *
  1386.  * Revision 1.33  2003/08/18 19:16:47  dicuccio
  1387.  * Fixed another (hopefully last!) thinko in CanFitArgs() - must pass the logic
  1388.  * "return true if any of our selections matches an object argument or if there
  1389.  * are no object arguments"
  1390.  *
  1391.  * Revision 1.32  2003/08/15 19:34:33  dicuccio
  1392.  * Added early break to loop on failure
  1393.  *
  1394.  * Revision 1.31  2003/08/13 13:33:23  dicuccio
  1395.  * Fixed another thinko - always pass objects regardless of whether the argument is of type single or of type array
  1396.  *
  1397.  * Revision 1.30  2003/08/12 21:41:24  ucko
  1398.  * Fix typo
  1399.  *
  1400.  * Revision 1.29  2003/08/12 19:51:23  dicuccio
  1401.  * Fixed thinko in CanFitArgs() - rather than return false for any failure, return
  1402.  * true for any success
  1403.  *
  1404.  * Revision 1.28  2003/08/11 19:26:21  dicuccio
  1405.  * Favor member insert to std::copy()
  1406.  *
  1407.  * Revision 1.27  2003/08/06 14:38:55  friedman
  1408.  * Add Seq-entry label formatting to GetObjectLabel
  1409.  *
  1410.  * Revision 1.26  2003/08/05 17:07:15  dicuccio
  1411.  * Changed calling semantics for the message queue - pass by reference, not
  1412.  * CConstRef<>
  1413.  *
  1414.  * Revision 1.25  2003/07/31 16:56:06  dicuccio
  1415.  * Changed name of plugin message queue.  Correctly account for hidden arguments
  1416.  * to plugins.
  1417.  *
  1418.  * Revision 1.24  2003/07/24 13:12:29  dicuccio
  1419.  * Added basic bioseq conversion routines
  1420.  *
  1421.  * Revision 1.23  2003/07/23 19:14:08  dicuccio
  1422.  * Moved logic for validating plugin arguments into CPluginUtils.
  1423.  *
  1424.  * Revision 1.22  2003/07/22 17:01:14  dicuccio
  1425.  * Fixed compilation error - return TObjList instead of NULL
  1426.  *
  1427.  * Revision 1.21  2003/07/22 15:29:54  dicuccio
  1428.  * Dropped CSeqVector as an explicitly managed type.  Changed Convert() to perform
  1429.  * a one-to-many conversion
  1430.  *
  1431.  * Revision 1.20  2003/07/21 19:29:17  dicuccio
  1432.  * Changed to match API changes in CSelectionBuffer.  Added CanFitArgs() version
  1433.  * to work with selection buffers
  1434.  *
  1435.  * Revision 1.19  2003/07/17 03:20:19  friedman
  1436.  * Added passing in a TConstScopedObjects to CPluginArgDialog
  1437.  *
  1438.  * Revision 1.18  2003/07/14 11:01:20  shomrat
  1439.  * Plugin messageing system related changes
  1440.  *
  1441.  * Revision 1.17  2003/06/30 13:33:41  dicuccio
  1442.  * Added API to call a plugin with a raw CPluginRequest object
  1443.  *
  1444.  * Revision 1.16  2003/06/25 17:02:54  dicuccio
  1445.  * Split CPluginHandle into a handle (pointer-to-implementation) and
  1446.  * implementation file.  Lots of #include file clean-ups.
  1447.  *
  1448.  * Revision 1.15  2003/06/02 16:06:17  dicuccio
  1449.  * Rearranged src/objects/ subtree.  This includes the following shifts:
  1450.  *     - src/objects/asn2asn --> arc/app/asn2asn
  1451.  *     - src/objects/testmedline --> src/objects/ncbimime/test
  1452.  *     - src/objects/objmgr --> src/objmgr
  1453.  *     - src/objects/util --> src/objmgr/util
  1454.  *     - src/objects/alnmgr --> src/objtools/alnmgr
  1455.  *     - src/objects/flat --> src/objtools/flat
  1456.  *     - src/objects/validator --> src/objtools/validator
  1457.  *     - src/objects/cddalignview --> src/objtools/cddalignview
  1458.  * In addition, libseq now includes six of the objects/seq... libs, and libmmdb
  1459.  * replaces the three libmmdb? libs.
  1460.  *
  1461.  * Revision 1.14  2003/05/19 13:35:59  dicuccio
  1462.  * Moved gui/core/plugin/ -> gui/plugin/.  Merged gui/core/algo, gui/core/doc/,
  1463.  * and gui/core/view/ into one library (gui/core/)
  1464.  *
  1465.  * Revision 1.13  2003/05/06 15:55:16  dicuccio
  1466.  * Dropped identity object conversion in favor of a generic approach
  1467.  *
  1468.  * Revision 1.12  2003/05/05 12:42:48  dicuccio
  1469.  * Added new interface function (CanFitArgs()) to determine if a given set of
  1470.  * objects could possibly apply to a set of arguments
  1471.  *
  1472.  * Revision 1.11  2003/05/01 12:53:36  dicuccio
  1473.  * Added conversion routines for {doc,seq-id,seq-loc,seq-feat} --> seq-entry
  1474.  *
  1475.  * Revision 1.10  2003/04/29 14:44:16  dicuccio
  1476.  * Fixed bungled commit - deleted dead, poorly formatted code that affected
  1477.  * indentation
  1478.  *
  1479.  * Revision 1.9  2003/04/29 14:42:43  dicuccio
  1480.  * Changed SelectionsToArgs() -> FillArgs().  Added API for filling arguments
  1481.  * based solely on the contents of a document.  Made main type conversion
  1482.  * routine public.  Added API for converting objects based on CTypeInfo.  Added
  1483.  * prototype function for conversion of an argument to a vector of strings.
  1484.  *
  1485.  * Revision 1.8  2003/04/24 16:31:07  dicuccio
  1486.  * Large changes.  Added many new interface functions for objects
  1487.  * cast/conversion.  Changed SelBufferToArgs() -> more generic FillArgs().
  1488.  * Changed internals of filling out plugin arguments automatically to avoid
  1489.  * faulty assumptions about argument contents.
  1490.  *
  1491.  * Revision 1.7  2003/04/16 18:21:27  dicuccio
  1492.  * Added generic plugin launch mechanism (CallPlugin()).  Modified
  1493.  * document-to-argument resolution to permit empty documents to be passed as
  1494.  * documents
  1495.  *
  1496.  * Revision 1.6  2003/03/25 13:11:32  dicuccio
  1497.  * Changed FillArgs() to return the number of unset arguments
  1498.  *
  1499.  * Revision 1.5  2003/03/10 22:58:51  kuznets
  1500.  * iterate -> ITERATE
  1501.  *
  1502.  * Revision 1.4  2003/02/26 14:24:36  dicuccio
  1503.  * Major rewrite of selection-to-argument handling code - most cases should be
  1504.  * handled automatically now, but there is still no manual fall-back.
  1505.  *
  1506.  * Revision 1.3  2003/02/25 14:46:52  dicuccio
  1507.  * Intermediate fix.  Still not working, but at least it compiles.
  1508.  *
  1509.  * Revision 1.2  2003/02/24 13:03:15  dicuccio
  1510.  * Renamed classes in plugin spec:
  1511.  *     CArgSeg --> CPluginArgSet
  1512.  *     CArgument --> CPluginArg
  1513.  *     CPluginArgs --> CPluginCommand
  1514.  *     CPluginCommands --> CPluginCommandSet
  1515.  *
  1516.  * Revision 1.1  2003/02/20 19:49:56  dicuccio
  1517.  * Created new plugin architecture, based on ASN.1 spec.  Moved GBENCH frameowrk
  1518.  * over to use new plugin architecture.
  1519.  *
  1520.  * ===========================================================================
  1521.  */
  1522.