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

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

生物技术

开发平台：

C/C++

plugin_registry.cpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: plugin_registry.cpp,v $
  4.  * PRODUCTION Revision 1000.8  2004/06/01 20:44:30  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.45
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. /*  $Id: plugin_registry.cpp,v 1000.8 2004/06/01 20:44:30 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.  *
  39.  */
  41. #include <ncbi_pch.hpp>
  42. #include <corelib/ncbidll.hpp>
  43. #include <corelib/ncbifile.hpp>
  44. #include <corelib/ncbimtx.hpp>
  46. #include <gui/core/algo_factory.hpp>
  47. #include <gui/core/obj_convert.hpp>
  48. #include <gui/core/plugin_exception.hpp>
  49. #include <gui/core/plugin_factory.hpp>
  50. #include <gui/core/plugin_registry.hpp>
  51. #include <gui/core/plugin_utils.hpp>
  52. #include <gui/core/version.hpp>
  53. #include <gui/plugin/PluginCache.hpp>
  54. #include <gui/plugin/PluginInfo.hpp>
  55. #include <gui/plugin/PluginLibInfo.hpp>
  56. #include <gui/utils/message_box.hpp>
  58. #include <serial/objostr.hpp>
  59. #include <serial/objistr.hpp>
  60. #include <serial/serial.hpp>
  62. #include "plugin_handle_impl.hpp"
  64. #include <algorithm>
  66. BEGIN_NCBI_SCOPE
  67. USING_SCOPE(objects);
  71. // typedef for our handle types (internal use only)
  72. typedef CRef<CPluginHandle_Impl> TPluginImpl;
  74. // functor for sorting plugin handles by content
  75. struct SPluginLessByClassName {
  76.     bool operator() (const TPluginImpl& h0, const TPluginImpl& h1) const
  77.     {
  78.         return (h0->GetClassName() < h1->GetClassName());
  79.     }
  80. };
  82. // functor for sorting plugin handles by menu name
  83. struct SPluginLessByMenuItem {
  84.     bool operator()(const TPluginImpl& h1, const TPluginImpl& h2) const
  85.     {
  86.         // sort first by menu item
  87.         if (h1->GetMenuItem() < h2->GetMenuItem()) {
  88.             return true;
  89.         }
  91.         if (h1->GetMenuItem() > h2->GetMenuItem()) {
  92.             return false;
  93.         }
  95.         // we always pass empty menu items - their sort order is unimportant
  96.         if (h1->GetMenuItem().empty()) {
  97.             return true;
  98.         }
  100.         // sort next by class name
  101.         if (h1->GetClassName() < h2->GetClassName()) {
  102.             return true;
  103.         }
  105.         if (h1->GetClassName() > h2->GetClassName()) {
  106.             return false;
  107.         }
  109.         // sort finally by class name
  110.         return (h1->GetCommand() < h2->GetCommand());
  111.     }
  112. };
  115. typedef set<TPluginImpl, SPluginLessByMenuItem> TPluginRegistry;
  117. // our plugin registry
  118. static TPluginRegistry s_PluginRegistry;
  120. // mutex protecting access to the registry
  121. DEFINE_STATIC_MUTEX(s_PluginRegistryMutex);
  124. //
  125. // read the plugin cache in the specified directory and add its contents to the
  126. // current registry
  127. //
  128. void CPluginRegistry::InitPlugins(const string& path)
  129. {
  130.     string cache_file(path + CDirEntry::GetPathSeparator() + "plugin-cache");
  132.     {{
  133.          // first, check to see if the plugin cache exists
  134.          CFile file(cache_file);
  135.          if ( !file.Exists() ) {
  136.              LOG_POST(Info <<
  137.                       "CPluginRegistry::InitPlugins(): "
  138.                       "no plugin cache found at " << cache_file);
  139.              return;
  140.          }
  141.      }}
  143.     // try reading in ASN.1 text format
  144.     try {
  145.         auto_ptr<CObjectIStream> is
  146.             (CObjectIStream::Open(eSerial_AsnText, cache_file));
  147.         CRef<CPluginCache> cache(new CPluginCache());
  148.         *is >> *cache;
  149.         LOG_POST(Info
  150.                  << "CPluginRegistry::InitPlugins(): plugin cache found in "
  151.                  << path);
  152.         x_InitPlugins(path, *cache);
  153.         return;
  154.     }
  155.     catch (CException& _DEBUG_ARG(e)) {
  156.         _TRACE("read of ASN.1 text plugin cache in "
  157.                << path << " failed: " << e.what());
  158.     }
  160.     // on error, try reading in ASN.1 binary format
  161.     try {
  162.         auto_ptr<CObjectIStream> is
  163.             (CObjectIStream::Open(eSerial_AsnBinary, cache_file));
  164.         CRef<CPluginCache> cache(new CPluginCache());
  165.         *is >> *cache;
  166.         LOG_POST(Info
  167.                  << "CPluginRegistry::InitPlugins(): plugin cache found in "
  168.                  << path);
  169.         x_InitPlugins(path, *cache);
  170.         return;
  171.     }
  172.     catch (CException& _DEBUG_ARG(e)) {
  173.         _TRACE("read of ASN.1 binary plugin cache in "
  174.                << path << " failed: " << e.what());
  175.     }
  177.     // if not, try reading in XML
  178.     try {
  179.         auto_ptr<CObjectIStream> is
  180.             (CObjectIStream::Open(eSerial_Xml, cache_file));
  181.         CRef<CPluginCache> cache(new CPluginCache());
  182.         *is >> *cache;
  183.         LOG_POST(Info
  184.                  << "CPluginRegistry::InitPlugins(): plugin cache found in "
  185.                  << path);
  186.         x_InitPlugins(path, *cache);
  187.         return;
  188.     }
  189.     catch (CException& _DEBUG_ARG(e)) {
  190.         _TRACE("read of XML plugin cache in "
  191.                << path << " failed: " << e.what());
  192.     }
  194.     // log an error and continue...
  195.     LOG_POST(Error
  196.              << "CPluginRegistry: No plugins found in directory " << path);
  197. }
  200. void CPluginRegistry::x_InitPlugins(const string& path, CPluginCache& cache)
  201. {
  202.     CMutexGuard LOCK(s_PluginRegistryMutex);
  204.     //
  205.     // now, process our plugin info objects
  206.     //
  207.     TPlugins plugins;
  208.     int plug_count = s_PluginRegistry.size();
  209.     NON_CONST_ITERATE (CPluginCache::Tdata, iter, cache.Set()) {
  210.         CPluginLibInfo& libinfo = **iter;
  211.         string lib_path = (path + CDirEntry::GetPathSeparator() +
  212.                            libinfo.GetLibrary());
  213.         libinfo.SetLibrary(lib_path);
  214.         CPluginHandle handle = AddPlugin(libinfo, eNonPersistent);
  215.         plugins.push_back(handle);
  216.     }
  218.     //
  219.     // ping any autoload commands now
  220.     //
  221.     NON_CONST_ITERATE (TPlugins, iter, plugins) {
  222.         CPluginHandle handle = *iter;
  223.         if ( !handle.GetInfo().CanGetAutorun()  ||
  224.              !handle.GetInfo().GetAutorun() ) {
  225.             continue;
  226.         }
  227.         _TRACE("autoloading " << handle.GetInfo().GetClass_name());
  228.         const CPluginInfo::TCommands& cmds =
  229.             handle.GetInfo().GetCommands();
  232.         try {
  234.             switch (cmds.Which()) {
  235.             case CPluginCommandSet::e_Algo:
  236.                 ITERATE (CPluginInfo::TCommands::TAlgo, cmd_iter,
  237.                          cmds.GetAlgo()) {
  238.                     CRef<CPluginMessage> msg(new CPluginMessage);        
  239.                     CPluginRequest& request = msg->SetRequest();
  241.                     handle.FillDefaults
  242.                         ((EAlgoCommand)(*cmd_iter)->GetCommand(),
  243.                          request.SetAlgo());
  244.                     handle.Execute(*msg);
  245.                 }
  246.                 break;
  248.             case CPluginCommandSet::e_View:
  249.                 break;
  251.             case CPluginCommandSet::e_Data:
  252.                 break;
  254.             default:
  255.                 break;
  256.             }
  257.         }
  258.         catch (CException& e) {
  259.             LOG_POST(Error << "Error running autoload commands: "
  260.                      << e.what());
  261.         }
  262. #ifndef _DEBUG
  263.         catch (...) {
  264.             LOG_POST(Error << "Unknown error running autoload commands");
  265.         }
  266. #endif
  267.     }
  269.     LOG_POST(Info << "  registered "
  270.              << s_PluginRegistry.size() - plug_count
  271.              << " plugins in path " << path);
  272. }
  275. void CPluginRegistry::Clear(void)
  276. {
  277.     CMutexGuard LOCK(s_PluginRegistryMutex);
  278.     s_PluginRegistry.clear();
  279. }
  282. void CPluginRegistry::RegisterPlugin(CRef<CPluginInfo> info,
  283.                                      CPluginFactoryBase *factory)
  284. {
  285.     CMutexGuard LOCK(s_PluginRegistryMutex);
  287.     // build a PluginLibInfo from info
  288.     CRef<CPluginLibInfo> libinfo(new CPluginLibInfo);
  289.     libinfo->SetInfo(*info);
  290.     string lib_path = "NONE";
  291.     libinfo->SetLibrary(lib_path);
  293.     // make a plugin handle from this
  294.     TPluginImpl handle(new CPluginHandle_Impl(*libinfo));
  296.     // set the factory
  297.     handle->x_SetFactory(factory);
  299.     // register the plugin
  300.     TPluginRegistry::iterator reg_iter = s_PluginRegistry.find(handle);
  301.     if (reg_iter != s_PluginRegistry.end()) {
  302.         LOG_POST(Warning
  303.                  << "Overriding "
  304.                  << libinfo->GetInfo().GetClass_name()
  305.                  << " with equivalent plugin from "
  306.                  << libinfo->GetLibrary());
  307.         s_PluginRegistry.erase(reg_iter);
  308.     }
  309.     s_PluginRegistry.insert(handle);
  310. }
  313. CPluginHandle CPluginRegistry::AddPlugin(CPluginLibInfo& libinfo,
  314.                                          EUserPlugin mode)
  315. {
  316.     TPluginImpl impl(new CPluginHandle_Impl(libinfo));
  318.     TPluginRegistry::iterator reg_iter = s_PluginRegistry.find(impl);
  319.     if (reg_iter != s_PluginRegistry.end()) {
  320.         LOG_POST(Warning
  321.                  << "Overriding "
  322.                  << libinfo.GetInfo().GetClass_name()
  323.                  << " with equivalent plugin from "
  324.                  << libinfo.GetLibrary());
  325.         s_PluginRegistry.erase(reg_iter);
  326.     }
  327.     s_PluginRegistry.insert(impl);
  329.     switch (mode) {
  330.     case ePersistent:
  331.         break;
  333.     default:
  334.     case eNonPersistent:
  335.         break;
  336.     }
  338.     return impl->GetHandle();
  339. }
  342. template <class Command, class BufferObj>
  343. CPluginRegistry::TPlugins
  344. s_GetPlugins(const TPluginRegistry& registry, Command cmd,
  345.              const BufferObj* obj, int flags)
  346. {
  347.     // Some compilers (*cough*WorkShop*cough*) don't allow templates
  348.     // to access statics, so we must use registry rather than
  349.     // s_PluginRegistry here.
  350.     CConvertCache cache;
  352.     CPluginRegistry::TPlugins plugins;
  353.     ITERATE (TPluginRegistry, iter, registry) {
  354.         const CPluginHandle_Impl& handle = **iter;
  355.         CPluginCommand args;
  356.         if ( !handle.IsEnabled() ) {
  357.             continue;
  358.         }
  360.         if ( (flags & CPluginRegistry::fHidden) == 0  &&
  361.              handle.GetMenuItem().empty()) {
  362.             continue;
  363.         }
  365.         if ( !handle.FillDefaults(cmd, args) ) {
  366.             continue;
  367.         }
  369.         /**
  370.         FIXME: this causes too many problems, and will be temporarily disabled
  371.         it is *very* time-consuming on large records
  372.         if (CPluginUtils::CanFitArgs(args.SetArgs(), *obj, &cache)) {
  373.             plugins.push_back((*iter)->GetHandle());
  374.         }
  375.         **/
  376.         plugins.push_back((*iter)->GetHandle());
  377.     }
  378.     return plugins;
  379. }
  381. //
  382. // retrieve plugins specific for a given command and valid for a given document
  383. //
  385. CPluginRegistry::TPlugins
  386. CPluginRegistry::GetPlugins(EAlgoCommand cmd, TFlags flags)
  387. {
  388.     CMutexGuard LOCK(s_PluginRegistryMutex);
  389.     return s_GetPlugins(s_PluginRegistry, cmd, (const IDocument*)NULL, flags);
  390. }
  393. CPluginRegistry::TPlugins
  394. CPluginRegistry::GetPlugins(EDataCommand cmd, const IDocument* doc,
  395.                             TFlags flags)
  396. {
  397.     CMutexGuard LOCK(s_PluginRegistryMutex);
  398.     return s_GetPlugins(s_PluginRegistry, cmd, doc, flags);
  399. }
  402. CPluginRegistry::TPlugins
  403. CPluginRegistry::GetPlugins(EViewCommand cmd, TFlags flags)
  404. {
  405.     CMutexGuard LOCK(s_PluginRegistryMutex);
  406.     return s_GetPlugins(s_PluginRegistry, cmd, (const IDocument*)NULL, flags);
  407. }
  410. //
  411. // retrieve plugins specific for a set of objects
  412. //
  414. CPluginRegistry::TPlugins
  415. CPluginRegistry::GetPlugins(EDataCommand cmd, const CSelectionBuffer& buf,
  416.                             TFlags flags)
  417. {
  418.     CMutexGuard LOCK(s_PluginRegistryMutex);
  419.     return s_GetPlugins(s_PluginRegistry, cmd, &buf, flags);
  420. }
  423. //
  424. // retrieve all plugins
  425. //
  426. CPluginHandle CPluginRegistry::GetPlugin(const string& name)
  427. {
  428.     CMutexGuard LOCK(s_PluginRegistryMutex);
  429.     ITERATE (TPluginRegistry, iter, s_PluginRegistry) {
  430.         if ((*iter)->IsEnabled()  &&  (*iter)->GetClassName() == name) {
  431.             return (*iter)->GetHandle();
  432.         }
  433.     }
  434.     _TRACE("CPluginRegistry::GetPlugin(): failed to find plugin " << name);
  435.     return CPluginHandle();
  436. }
  439. //
  440. // retrieve all plugins
  441. //
  442. CPluginRegistry::TPlugins CPluginRegistry::GetPlugins(TFlags flags)
  443. {
  444.     CMutexGuard LOCK(s_PluginRegistryMutex);
  445.     TPlugins plugins;
  446.     ITERATE (TPluginRegistry, iter, s_PluginRegistry) {
  447.         if ( (flags & fHidden) == 0  && (*iter)->GetMenuItem().empty()) {
  448.             continue;
  449.         }
  451.         if ((*iter)->IsEnabled()) {
  452.             plugins.push_back((*iter)->GetHandle());
  453.         }
  454.     }
  455.     return plugins;
  456. }
  459. //
  460. // retrieve plugins valid for a given command type
  461. //
  462. CPluginRegistry::TPlugins
  463. CPluginRegistry::GetPlugins(CPluginCommandSet::E_Choice cmd, TFlags flags)
  464. {
  465.     CMutexGuard LOCK(s_PluginRegistryMutex);
  466.     TPlugins plugins;
  467.     ITERATE (TPluginRegistry, iter, s_PluginRegistry) {
  468.         if ( (flags & fHidden) == 0  && (*iter)->GetMenuItem().empty()) {
  469.             continue;
  470.         }
  472.         if ( (*iter)->GetCommand() == cmd  &&  (*iter)->IsEnabled()) {
  473.             plugins.push_back((*iter)->GetHandle());
  474.         }
  475.     }
  476.     return plugins;
  477. }
  480. void CPluginRegistry::x_LoadLibrary(const string& lib)
  481. {
  482.     CMutexGuard LOCK(s_PluginRegistryMutex);
  484.     string dir;
  485.     string base;
  486.     string ext;
  487.     CDirEntry::SplitPath(lib, &dir, &base, &ext);
  489.     CDll dll(dir, base + ext, CDll::eLoadLater);
  490.     try {
  491.         dll.Load();
  492.         LOG_POST(Info << "loaded plugin library " << base + ext);
  494.         // grab the single entry point
  495.         list<CPluginFactoryBase*> plugins;
  496.         CPluginFactoryBase::FPluginEntryPoint get_plugins =
  497.             dll.GetEntryPoint_Func("NCBIGBenchGetPlugins", &get_plugins);
  499.         if ( !get_plugins ) {
  500.             NCBI_THROW(CPluginException, ePluginLoadFailed,
  501.                        "Library is not a valid plug-in");
  502.         }
  504.         // grab our plugin factories
  505.         get_plugins(plugins);
  506.         ITERATE (list<CPluginFactoryBase*>, iter, plugins) {
  507.             CPluginFactoryBase* factory = *iter;
  508.             if ( !factory ) {
  509.                 continue;
  510.             }
  512.             // check for version information
  514.             //CPluginRequest request;
  515.             //request.SetInfo();
  516.             //CPluginReply reply;
  517.             //factory->RunCommand(request, reply);
  518.             //if ( reply.GetStatus() != eRequestStatus_success  ||
  519.             //     !reply.GetAction().IsInfo() ) {
  520.             //    // the plugin factory doesn't support the 'info' command
  521.             //    continue;
  522.             //}
  524.             // make sure our library is set...
  525.             CPluginInfo info;
  526.             (*iter)->GetInfo(info);
  527.             //const CPluginInfo& info = reply.GetAction().GetInfo();
  529.             if ( !CPluginVersion::CheckVersion(info.GetVer_major(),
  530.                                                info.GetVer_minor()) ) {
  531.                 string msg = "Version Mismatch:nframework version ";
  532.                 msg += NStr::IntToString(CPluginVersion::eMajor);
  533.                 msg += "." + NStr::IntToString(CPluginVersion::eMinor);
  534.                 msg += " : plugin version ";
  535.                 msg += NStr::IntToString(info.GetVer_major());
  536.                 msg += "." + NStr::IntToString(info.GetVer_minor());
  537.                 msg += ", rev " + NStr::IntToString(info.GetVer_revision());
  538.                 msg += "nplugin build date: " + info.GetVer_build_date();
  539.                 NCBI_THROW(CPluginException, eVersionMismatch, msg);
  540.             }
  542.             // retrieve and process all commands
  543.             // we will fill in details for plugin handles as we go
  544.             TPluginRegistry::iterator plug_iter = s_PluginRegistry.begin();
  545.             for ( ;  plug_iter != s_PluginRegistry.end();  ++plug_iter) {
  546.                 if ( (*plug_iter)->GetClassName() == info.GetClass_name() ) {
  547.                     (*plug_iter)->x_SetFactory(factory);
  548.                     LOG_POST(Info
  549.                              << "registering plugin " << info.GetClass_name());
  550.                     break;
  551.                 }
  552.             }
  554.             if (plug_iter == s_PluginRegistry.end()) {
  555.                 LOG_POST(Warning
  556.                          << "failed to register plugin "
  557.                          << (*plug_iter)->GetClassName());
  558.             }
  559.         }
  560.     }
  561.     catch(CException& e) {
  562.         dll.Unload();
  563.         string msg("Failed to load plugin library ");
  564.         msg += base + ext;
  565.         msg += ":n";
  566.         msg += e.GetMsg();
  567.         NcbiMessageBox(msg);
  568.     }
  569. #ifndef _DEBUG
  570.     catch (...) {
  571.         dll.Unload();
  572.         string msg("Failed to load plugin library ");
  573.         msg += base + ext;
  574.         msg += ":nUnknown error.";
  575.         NcbiMessageBox(msg);
  576.     }
  577. #endif
  578. }
  581. END_NCBI_SCOPE
  584. /*
  585.  * ===========================================================================
  586.  * $Log: plugin_registry.cpp,v $
  587.  * Revision 1000.8  2004/06/01 20:44:30  gouriano
  588.  * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.45
  589.  *
  590.  * Revision 1.45  2004/05/21 22:27:40  gorelenk
  591.  * Added PCH ncbi_pch.hpp
  592.  *
  593.  * Revision 1.44  2004/04/16 14:38:28  dicuccio
  594.  * Eliminated APIs from GetPlugins() that would perform selection-based sieving -
  595.  * they were not used
  596.  *
  597.  * Revision 1.43  2004/03/16 15:59:50  vasilche
  598.  * Removed warning about unused exception variable
  599.  *
  600.  * Revision 1.42  2004/01/27 18:32:10  dicuccio
  601.  * Added default handler to switch
  602.  *
  603.  * Revision 1.41  2004/01/06 14:24:03  dicuccio
  604.  * Temporarily disable the use of CanFitArgs() inside of GetPlugins() when all
  605.  * that is known is a document - the search is very expensive on big records.
  606.  *
  607.  * Revision 1.40  2003/12/09 15:44:53  dicuccio
  608.  * Use CException::GetMsg() instead of what()
  609.  *
  610.  * Revision 1.39  2003/12/03 12:40:05  dicuccio
  611.  * Restore auto-processing of autorun plugins
  612.  *
  613.  * Revision 1.38  2003/11/26 17:06:56  dicuccio
  614.  * Dropped autoloading of plugins - favor explicit initialization
  615.  *
  616.  * Revision 1.37  2003/11/24 15:39:40  dicuccio
  617.  * Renamed CVersion to CPluginVersion
  618.  *
  619.  * Revision 1.36  2003/11/19 18:15:14  ucko
  620.  * Adjust for CDll API change.
  621.  *
  622.  * Revision 1.35  2003/11/06 20:06:29  dicuccio
  623.  * Moved USING_SCOPE(objects) to implementation files
  624.  *
  625.  * Revision 1.34  2003/11/04 17:19:07  dicuccio
  626.  * Added Clear().  CHanged to patch API change in CPluginMessage
  627.  *
  628.  * Revision 1.33  2003/10/27 17:37:51  dicuccio
  629.  * Better diagnostics for exceptions in reading plugin cache
  630.  *
  631.  * Revision 1.32  2003/10/25 16:03:37  dicuccio
  632.  * Removed debugging output that disabled plugin reading on Unix
  633.  *
  634.  * Revision 1.31  2003/10/23 16:17:03  dicuccio
  635.  * Added API to add user-defined plugins
  636.  *
  637.  * Revision 1.30  2003/10/10 17:15:33  dicuccio
  638.  * Changed sort params for plugin handles - now, sort by menu item.  Added object
  639.  * conversion cache to plugin retrieval.  Removed unnecessary sort()s.
  640.  *
  641.  * Revision 1.29  2003/09/30 23:48:04  ucko
  642.  * s_GetPlugins: re-fixed WorkShop build, and added a comment explaining
  643.  * how to stay out of trouble.
  644.  *
  645.  * Revision 1.28  2003/09/30 13:40:12  dicuccio
  646.  * Added sorting of plugins by menu name
  647.  *
  648.  * Revision 1.27  2003/09/04 14:01:51  dicuccio
  649.  * Introduce IDocument and IView as abstract base classes for CDocument and CView
  650.  *
  651.  * Revision 1.26  2003/08/05 17:07:15  dicuccio
  652.  * Changed calling semantics for the message queue - pass by reference, not
  653.  * CConstRef<>
  654.  *
  655.  * Revision 1.25  2003/07/28 18:27:38  jcherry
  656.  * Added CPluginRegistry::RegisterPlugin for registering external
  657.  * (executable) plugins
  658.  *
  659.  * Revision 1.24  2003/07/25 19:45:22  shomrat
  660.  * Immediately execute autorun plugins
  661.  *
  662.  * Revision 1.23  2003/07/21 19:28:37  dicuccio
  663.  * Added retrieval of plugins based on contents of a selection buffer
  664.  *
  665.  * Revision 1.22  2003/07/14 11:01:16  shomrat
  666.  * Plugin messageing system related changes
  667.  *
  668.  * Revision 1.21  2003/07/09 12:29:21  dicuccio
  669.  * (Finally!) fixed build issues on WorkShop - removed accessing of all static
  670.  * variables from inside local templated functions
  671.  *
  672.  * Revision 1.20  2003/06/30 13:33:15  dicuccio
  673.  * Added API to screen out "empty" plugins
  674.  *
  675.  * Revision 1.19  2003/06/30 11:29:34  dicuccio
  676.  * Moved access of mutex out of template (WorkShop compiler doesn't like this)
  677.  *
  678.  * Revision 1.18  2003/06/29 13:10:17  dicuccio
  679.  * Use DEFINE_STATIC_MUTEX() instead of static member variables
  680.  *
  681.  * Revision 1.17  2003/06/25 17:02:54  dicuccio
  682.  * Split CPluginHandle into a handle (pointer-to-implementation) and
  683.  * implementation file.  Lots of #include file clean-ups.
  684.  *
  685.  * Revision 1.16  2003/06/20 14:47:41  dicuccio
  686.  * Revised handling of plugin registration (moved GetInfo() out of plugin
  687.  * factory and into each handler as a static function)
  688.  *
  689.  * Revision 1.15  2003/05/30 14:15:41  dicuccio
  690.  * Renamed MessageBox to NcbiMessageBox because brain-dead MSVC thinks this is
  691.  * ::MessageBox and rewrites the symbol as MessageBoxA, which results in an
  692.  * unresolved external and conflict with the Win32 API :(.
  693.  *
  694.  * Revision 1.14  2003/05/30 12:56:50  dicuccio
  695.  * Converted code to use MessageBox() instead of
  696.  * fl_ask()/fl_message()/fl_alert()
  697.  *
  698.  * Revision 1.13  2003/05/19 13:35:59  dicuccio
  699.  * Moved gui/core/plugin/ -> gui/plugin/.  Merged gui/core/algo, gui/core/doc/,
  700.  * and gui/core/view/ into one library (gui/core/)
  701.  *
  702.  * Revision 1.12  2003/05/08 16:18:59  dicuccio
  703. * Changed CFastMutex --> CMutex - guards against recursive locking
  704. *
  705. * Revision 1.11  2003/05/06 15:54:51  dicuccio
  706. * Added mutex to guard access to plugin registry
  707. *
  708. * Revision 1.10  2003/04/29 14:41:18  dicuccio
  709. * Removed old GetPlugins() call - use new command-based API
  710. *
  711. * Revision 1.9  2003/03/31 13:47:50  dicuccio
  712. * Changed standard start-up messages to be more comprehensible
  713. *
  714. * Revision 1.8  2003/03/25 13:11:10  dicuccio
  715. * Fixed compilation issue on compaq compiler - don't redeclare loop variable
  716. * 'iter' inside of loop
  717. *
  718. * Revision 1.7  2003/03/13 18:15:48  dicuccio
  719. * Added accessor for a single, named plugin.  Changed registration to
  720. * explicitly allow overriding of plugins
  721. *
  722. * Revision 1.6  2003/03/10 22:58:51  kuznets
  723. * iterate -> ITERATE
  724. *
  725. * Revision 1.5  2003/02/28 15:06:55  dicuccio
  726. * Added check to see if a plugin is enabled
  727. *
  728. * Revision 1.4  2003/02/24 13:03:15  dicuccio
  729. * Renamed classes in plugin spec:
  730. *     CArgSeg --> CPluginArgSet
  731. *     CArgument --> CPluginArg
  732. *     CPluginArgs --> CPluginCommand
  733. *     CPluginCommands --> CPluginCommandSet
  734. *
  735. * Revision 1.3  2003/02/21 17:16:52  dicuccio
  736. * Fixed compilation errors related to changes in plugin architecture
  737. *
  738. * Revision 1.2  2003/02/20 20:35:45  dicuccio
  739. * Fixed compilation errors after commit of plugin architecture changes
  740. *
  741. * Revision 1.1  2003/02/20 19:49:56  dicuccio
  742. * Created new plugin architecture, based on ASN.1 spec.  Moved GBENCH frameowrk
  743. * over to use new plugin architecture.
  744. *
  745. * ===========================================================================
  746. */