restriction_sites.cpp
上传用户:yhdzpy8989
上传日期:2007-06-13
资源大小:13604k
文件大小:23k
源码类别:

生物技术

开发平台:

C/C++

  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: restriction_sites.cpp,v $
  4.  * PRODUCTION Revision 1000.5  2004/06/01 20:55:43  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.32
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  9. /*  $Id: restriction_sites.cpp,v 1000.5 2004/06/01 20:55:43 gouriano Exp $
  10.  * ===========================================================================
  11.  *
  12.  *                            PUBLIC DOMAIN NOTICE
  13.  *               National Center for Biotechnology Information
  14.  *
  15.  *  This software/database is a "United States Government Work" under the
  16.  *  terms of the United States Copyright Act.  It was written as part of
  17.  *  the author's official duties as a United States Government employee and
  18.  *  thus cannot be copyrighted.  This software/database is freely available
  19.  *  to the public for use. The National Library of Medicine and the U.S.
  20.  *  Government have not placed any restriction on its use or reproduction.
  21.  *
  22.  *  Although all reasonable efforts have been taken to ensure the accuracy
  23.  *  and reliability of the software and data, the NLM and the U.S.
  24.  *  Government do not and cannot warrant the performance or results that
  25.  *  may be obtained by using this software or data. The NLM and the U.S.
  26.  *  Government disclaim all warranties, express or implied, including
  27.  *  warranties of performance, merchantability or fitness for any particular
  28.  *  purpose.
  29.  *
  30.  *  Please cite the author in any work or product based on this material.
  31.  *
  32.  * ===========================================================================
  33.  *
  34.  * Authors:  Josh Cherry
  35.  *
  36.  * File Description:  gbench plugin for finding restriction sites
  37.  *
  38.  */
  39. #include <ncbi_pch.hpp>
  40. #include "restriction_sites.hpp"
  41. #include "rebase.hpp"
  42. #include <algo/sequence/restriction.hpp>
  43. #include <algo/sequence/seq_match.hpp>
  44. #include <algorithm>
  45. #include <corelib/ncbiapp.hpp>
  46. #include <corelib/ncbireg.hpp>
  47. #include <gui/core/plugin_utils.hpp>
  48. #include <gui/utils/system_path.hpp>
  49. #include <gui/core/version.hpp>
  50. #include <gui/dialogs/col/multi_col_dlg.hpp>
  51. #include <gui/plugin/PluginCommandSet.hpp>
  52. #include <gui/plugin/PluginInfo.hpp>
  53. #include <gui/plugin/PluginRequest.hpp>
  54. #include <gui/plugin/PluginValueConstraint.hpp>
  55. #include <gui/utils/message_box.hpp>
  56. #include <gui/objutils/utils.hpp>
  57. #include <objects/general/Dbtag.hpp>
  58. #include <objects/general/Object_id.hpp>
  59. #include <objects/seqfeat/Rsite_ref.hpp>
  60. #include <objects/seqloc/Seq_point.hpp>
  61. #include <objmgr/seq_vector.hpp>
  62. #include <objmgr/util/sequence.hpp>
  63. BEGIN_NCBI_SCOPE
  64. CAlgoPlugin_RestrictionSites::~CAlgoPlugin_RestrictionSites()
  65. {
  66. }
  67. // standard plugin announce bopilerplate
  68. void CAlgoPlugin_RestrictionSites::GetInfo(CPluginInfo& info)
  69. {
  70.     info.Reset();
  71.     
  72.     // version info macro
  73.     info.SetInfo(CPluginVersion::eMajor, CPluginVersion::eMinor, 0,
  74.                  string(__DATE__) + " " + string(__TIME__),
  75.                  "CAlgoPlugin_RestrictionSites", "Search/Find restriction sites",
  76.                  "Search a DNA sequence for restriction sites",
  77.                  "");
  78.     // command info
  79.     CPluginCommandSet& cmds = info.SetCommands();
  80.     CPluginCommand&    args = cmds.AddAlgoCommand(eAlgoCommand_run);
  81.     args.AddArgument("locs", "Locations to evaluate",
  82.                      CSeq_loc::GetTypeInfo(),
  83.                      CPluginArg::TData::e_Array);
  84.     args.SetConstraint("locs",
  85.                        (*CPluginValueConstraint::CreateSeqMol(),
  86.                         CSeq_inst::eMol_na,
  87.                         CSeq_inst::eMol_dna,
  88.                         CSeq_inst::eMol_rna));
  89.     args.AddDefaultArgument("which_enzymes", "Which restriction enzymes",
  90.                             CPluginArg::eString, "commercially available");
  91.     args.SetConstraint("which_enzymes", (*CPluginValueConstraint::CreateSet(),
  92.                                 "commercially available",
  93.                                 "prototypes", "all"));
  94.     args.AddDefaultArgument("combine_isoschizomers",
  95.                             "Combine isoschizomers",
  96.                             CPluginArg::eBoolean, "true");
  97.     args.AddArgument("sort_by_number_of_sites",
  98.                      "Sort results by number of (definite) cuts by enzyme",
  99.                      CPluginArg::eBoolean);
  100. }
  101. // helper functor for sorting CRef<CREnzResult> by the enzyme name
  102. struct SEnzymeNameCompare
  103. {
  104.     bool operator()
  105.         (const CRef<CREnzResult>& lhs, const CRef<CREnzResult>& rhs) const
  106.     {
  107.         return lhs->GetEnzymeName() < rhs->GetEnzymeName();
  108.     }
  109. };
  110. // helper functor for sorting CREnzyme by the enzyme name
  111. struct SNameCompare
  112. {
  113.     bool operator()
  114.         (const CREnzyme& lhs, const CREnzyme& rhs) const
  115.     {
  116.         return lhs.GetName() < rhs.GetName();
  117.     }
  118. };
  119. // helper functor for sorting by the number of definite sites
  120. struct SLessDefSites
  121. {
  122.     bool operator() 
  123.         (const CRef<CREnzResult>& lhs, const CRef<CREnzResult>& rhs) const
  124.     {
  125.         return lhs->GetDefiniteSites().size() < rhs->GetDefiniteSites().size();
  126.     }
  127. };
  128. // helper functor for sorting CRef<CSeq_loc>s by location
  129. struct SLessSeq_loc
  130. {
  131.     bool operator() 
  132.         (const CRef<CSeq_loc>& lhs, const CRef<CSeq_loc>& rhs) const
  133.     {
  134.         return (lhs->Compare(*rhs) < 0);
  135.     }
  136. };
  137. static
  138. void s_AddSitesToAnnot(const vector<CRSite>& sites,
  139.                        const CREnzResult&    result,
  140.                        CSeq_annot&           annot,
  141.                        const CSeq_loc&       parent_loc,
  142.                        bool                  definite = true)
  143. {
  144.     const CSeq_id& id = sequence::GetId(parent_loc);
  145.     ITERATE (vector<CRSite>, site, sites) {
  146.         // create feature
  147.         CRef<CSeq_feat> feat(new CSeq_feat());
  148.         // start to set up Rsite
  149.         feat->SetData().SetRsite().SetDb().SetDb("REBASE");
  150.         feat->SetData().SetRsite().SetDb()
  151.             .SetTag().SetStr("REBASE");
  152.         string str(result.GetEnzymeName());
  153.         if ( !definite ) {
  154.             str = "Possible " + str;
  155.         }
  156.         feat->SetData().SetRsite().SetStr(str);
  157.         //
  158.         // build our location
  159.         //
  160.         vector< CRef<CSeq_loc> > locs;
  161.         // a loc for the recognition site
  162.         CRef<CSeq_loc> recog_site(new CSeq_loc);
  163.         recog_site->SetInt().SetFrom(site->GetStart());
  164.         recog_site->SetInt().SetTo  (site->GetEnd());
  165.         recog_site->SetId(id);
  166.         locs.push_back(recog_site);
  167.         // locs for the cleavage sites
  168.         int negative_cut_locs = 0;  // count these exceptions
  169.         ITERATE (vector<int>, cut, site->GetPlusCuts()) {
  170.             if (*cut >= 0 ) {
  171.                 CRef<CSeq_loc> cut_site(new CSeq_loc);
  172.                 cut_site->SetPnt().SetPoint(*cut);
  173.                 // indicate that the cut is to the "left"
  174.                 cut_site->SetPnt()
  175.                     .SetFuzz().SetLim(CInt_fuzz::eLim_tl);
  176.                 cut_site->SetPnt().SetStrand(eNa_strand_plus);
  177.                 cut_site->SetId(id);
  178.                 locs.push_back(cut_site);
  179.             } else {
  180.                 negative_cut_locs++;
  181.             }
  182.         }
  183.         ITERATE (vector<int>, cut, site->GetMinusCuts()) {
  184.             if (*cut >= 0 ) {
  185.                 CRef<CSeq_loc> cut_site(new CSeq_loc);
  186.                 cut_site->SetPnt().SetPoint(*cut);
  187.                 // indicate that the cut is to the "left"
  188.                 cut_site->SetPnt()
  189.                     .SetFuzz().SetLim(CInt_fuzz::eLim_tl);
  190.                 cut_site->SetPnt().SetStrand(eNa_strand_minus);
  191.                 cut_site->SetId(id);
  192.                 locs.push_back(cut_site);
  193.             } else {
  194.                 negative_cut_locs++;
  195.             }
  196.         }
  197.         // comment for those few cases where there are
  198.         // cuts before the sequence begins
  199.         if (negative_cut_locs > 0) {
  200.             string a_comm = NStr::IntToString(negative_cut_locs)
  201.                 + " cleavage sites are located before the"
  202.                 " beginning of the sequence and are not reported";
  203.             feat->SetComment(a_comm);
  204.         }
  205.         sort(locs.begin(), locs.end(), SLessSeq_loc());
  206.         copy(locs.begin(), locs.end(),
  207.              back_inserter(feat->SetLocation().SetMix().Set()));
  208.         feat->SetLocation
  209.             (*CSeqUtils::RemapChildToParent(parent_loc, feat->GetLocation()));
  210.         // save in annot
  211.         annot.SetData().SetFtable().push_back(feat);
  212.     }
  213. }
  214. void CAlgoPlugin_RestrictionSites::RunCommand(CPluginMessage& msg)
  215. {
  216.     const CPluginCommand& args = msg.GetRequest().GetCommand();
  217.     CPluginReply& reply = msg.SetReply();
  218.     _TRACE("CAlgoPlugin_RestrictionSites::RunCommand()");
  219.     
  220.     // load patterns from file
  221.     CRebase::EEnzymesToLoad which_enzymes 
  222.         = x_DecodeWhichEnzymes(args["which_enzymes"].AsString());
  223.     vector<CREnzyme> enzymes;
  224.     try {
  225.         x_LoadREnzymeData(enzymes, which_enzymes);
  226.     }
  227.     catch (const exception& e) {
  228.         NcbiMessageBox(e.what());
  229.         reply.SetStatus(eMessageStatus_failed);
  230.         return;
  231.     }
  232.     // optionally lump together all enzymes with identical specificities
  233.     if (args["combine_isoschizomers"].AsBoolean()) {
  234.         // first sort alphabetically by enzyme name
  235.         sort(enzymes.begin(), enzymes.end(), SNameCompare());
  236.         // now combine isoschizomers
  237.         CREnzyme::CombineIsoschizomers(enzymes);
  238.     }
  239.     if ( !m_Dialog.get() ) {
  240.         m_Dialog.reset(new CMultiColDlg());
  241.         m_Dialog->SetWindowSize(1000, 500);
  242.         m_Dialog->SetTitle("Restriction Sites");
  243.         
  244.         m_Dialog->SetColumn(0, "Sequence", FL_ALIGN_LEFT, 0.3f);
  245.         m_Dialog->SetColumn(1, "Location", FL_ALIGN_LEFT, 0.5f);
  246.         m_Dialog->SetColumn(2, "Enzyme", FL_ALIGN_LEFT, 0.4f);
  247.         m_Dialog->SetColumn(3, "Number of Sites", FL_ALIGN_CENTER, 0.5f);
  248.         m_Dialog->SetColumn(4, "Recog. Site Loc.", FL_ALIGN_CENTER, 0.75f);
  249.         m_Dialog->SetColumn(5, "Plus Strand Cuts", FL_ALIGN_CENTER, 0.75f);
  250.         m_Dialog->SetColumn(6, "Minus Strand Cuts", FL_ALIGN_CENTER, 0.75f);
  251.     }
  252.     m_Dialog->SetRows(0);  // to clear any previous contents
  253.     int row = 0;
  254.     plugin_args::TLocList locs;
  255.     GetArgValue(args["locs"], locs);
  256.     ITERATE (plugin_args::TLocList, iter, locs) {
  257.         const CSeq_loc&  loc = *iter->second;
  258.         const IDocument& doc = *iter->first;
  259.         // find the best ID for this bioseq
  260.         try {
  261.             CBioseq_Handle handle = doc.GetScope().GetBioseqHandle(loc);
  262.             // get sequence in binary (8na) form
  263.             CSeqVector vec =
  264.                 handle.GetSequenceView(loc,
  265.                                        CBioseq_Handle::eViewConstructed,
  266.                                        CBioseq_Handle::eCoding_Ncbi);
  267.             string& id_str  = m_Dialog->SetCell(row, 0);
  268.             string& loc_str = m_Dialog->SetCell(row, 1);
  269.             const CSeq_id& best_id =
  270.                 sequence::GetId(handle, sequence::eGetId_Best);
  271.             id_str.erase();
  272.             best_id.GetLabel(&id_str);
  273.             loc_str = CPluginUtils::GetLabel(loc, &doc.GetScope());
  274.             // a new feature table
  275.             CRef<CSeq_annot> annot(new CSeq_annot());
  276.             // a place to store results (one per enzyme)
  277.             typedef vector<CRef<CREnzResult> > TResults;
  278.             TResults results;
  279.             // do the big search
  280.             CFindRSites::Find(vec, enzymes, results);
  281.             // add description to annot
  282.             annot->SetName("Restriction sites");
  283.             // deal with stored enzyme results
  284.             sort(results.begin(), results.end(), SEnzymeNameCompare());
  285.             if (args["sort_by_number_of_sites"].AsBoolean()) {
  286.                 // do a stablesort so alphabetical order preserved
  287.                 // within sets with the same number of sites
  288.                 stable_sort(results.begin(), results.end(), SLessDefSites());
  289.             }
  290.             // count the number of definite and possible sites
  291.             int total_definite_sites = 0, total_possible_sites = 0;
  292.             int total_non_cutters = 0;
  293.             ITERATE (TResults, result, results) {
  294.                 total_definite_sites += (*result)->GetDefiniteSites().size();
  295.                 total_possible_sites += (*result)->GetPossibleSites().size();
  296.                 if ((*result)->GetDefiniteSites().size()
  297.                     + (*result)->GetPossibleSites().size() == 0) {
  298.                     total_non_cutters++;
  299.                 }
  300.             }
  301.             _TRACE("Found " << total_definite_sites << " definite and "
  302.                    << total_possible_sites << " possible sites");
  303.             // in order to build dialog efficiently,
  304.             // pre-allocate rows
  305.             int total_rows = total_definite_sites + total_possible_sites
  306.                 + total_non_cutters;
  307.             m_Dialog->SetRows(row + total_rows);
  308.             ITERATE (TResults, result, results) {
  309.                 
  310.                 //
  311.                 // add sites to dialog
  312.                 //
  313.                 int starting_row = row;
  314.                 m_Dialog->SetCell(row, 2) = (*result)->GetEnzymeName();
  315.                 string num_sites =
  316.                     NStr::IntToString((*result)->GetDefiniteSites().size());
  317.                 if (!(*result)->GetPossibleSites().empty()) {
  318.                     num_sites += "+";
  319.                     num_sites +=
  320.                         NStr::IntToString((*result)
  321.                                           ->GetPossibleSites().size());
  322.                     num_sites += "?";
  323.                 }
  324.                 m_Dialog->SetCell(row, 3) = num_sites;
  325.                 const vector<CRSite>& definite_sites
  326.                     = (*result)->GetDefiniteSites();
  327.                 ITERATE (vector<CRSite>, site, definite_sites) {
  328.                     string& pos_str = m_Dialog->SetCell(row, 4);
  329.                     pos_str = NStr::IntToString(site->GetStart() + 1) + " - "
  330.                         + NStr::IntToString(site->GetEnd() + 1);
  331.                     string plus_cuts;
  332.                     const vector<int>& pcuts = site->GetPlusCuts();
  333.                     ITERATE (vector<int>, cut, pcuts) {
  334.                         if (!plus_cuts.empty()) {
  335.                             plus_cuts += ", ";
  336.                         }
  337.                         plus_cuts += NStr::IntToString(*cut);
  338.                     }
  339.                     m_Dialog->SetCell(row, 5) = plus_cuts;
  340.                     string minus_cuts;
  341.                     const vector<int>& mcuts = site->GetMinusCuts();
  342.                     ITERATE (vector<int>, cut, mcuts) {
  343.                         if (!minus_cuts.empty()) {
  344.                             minus_cuts += ", ";
  345.                         }
  346.                         minus_cuts += NStr::IntToString(*cut);
  347.                     }
  348.                     m_Dialog->SetCell(row, 6) = minus_cuts;
  349.                     ++row;
  350.                 }
  351.                 const vector<CRSite>& possible_sites
  352.                     = (*result)->GetPossibleSites();
  353.                 ITERATE (vector<CRSite>, site, possible_sites) {
  354.                     string& pos_str = m_Dialog->SetCell(row, 4);
  355.                     pos_str = string("???")
  356.                         + NStr::IntToString(site->GetStart() + 1) + " - "
  357.                         + NStr::IntToString(site->GetEnd() + 1);
  358.                     string plus_cuts;
  359.                     const vector<int>& pcuts = site->GetPlusCuts();
  360.                     ITERATE (vector<int>, cut, pcuts) {
  361.                         if (!plus_cuts.empty()) {
  362.                             plus_cuts += ", ";
  363.                         }
  364.                         plus_cuts += NStr::IntToString(*cut);
  365.                     }
  366.                     m_Dialog->SetCell(row, 5) = plus_cuts;
  367.                     string minus_cuts;
  368.                     const vector<int>& mcuts = site->GetMinusCuts();
  369.                     ITERATE (vector<int>, cut, mcuts) {
  370.                         if (!minus_cuts.empty()) {
  371.                             minus_cuts += ", ";
  372.                         }
  373.                         minus_cuts += NStr::IntToString(*cut);
  374.                     }
  375.                     m_Dialog->SetCell(row, 6) = minus_cuts;
  376.                     ++row;
  377.                 }
  378.                 if (row == starting_row) {
  379.                     row++;
  380.                 }
  381.                 //
  382.                 // add features to annot
  383.                 //
  384.                 s_AddSitesToAnnot(definite_sites, **result, *annot, loc);
  385.                 s_AddSitesToAnnot(possible_sites, **result, *annot, loc, false);
  386.             }
  387.             // attach annot to doc
  388.             //const_cast<IDocument&>(doc).AttachAnnot(*annot);
  389.             //const_cast<IDocument&>(doc).UpdateAllViews(fDocumentChanged);
  390.             reply.AddObject(doc, *annot);
  391.         }
  392.         catch (exception& e) {
  393.             LOG_POST(Error << e.what());
  394.             string str = CPluginUtils::GetLabel(loc, &doc.GetScope());
  395.             LOG_POST(Error << "Error processing location " << str);
  396.         }
  397. #ifndef _DEBUG
  398.         catch (...) {
  399.             string str = CPluginUtils::GetLabel(loc, &doc.GetScope());
  400.             LOG_POST(Error << "Error processing location " << str);
  401.         }
  402. #endif
  403.     }
  404.     // update all views
  405.     //CDocManager::UpdateAllViews();
  406.     //
  407.     // prepare our dialog box
  408.     //
  409.     m_Dialog->SetLabel(string("A search for restriction sites for ")
  410.                        + NStr::IntToString(enzymes.size())
  411.                        + " enzymes produced:");
  412.     m_Dialog->Show();
  413.     reply.SetStatus(eMessageStatus_success);
  414.     reply.AddAction(CPluginReplyAction::e_Add_to_document);
  415. }
  416. void 
  417. CAlgoPlugin_RestrictionSites::x_LoadREnzymeData(vector<CREnzyme>& enzymes,
  418.                                      CRebase::EEnzymesToLoad which_enzymes)
  419. {
  420.     CNcbiApplication* app = CNcbiApplication::Instance();
  421.     _ASSERT(app);
  422.     CNcbiRegistry& registry = app->GetConfig();
  423.     string fname;
  424.     // By default the rebase "NAR format" file 
  425.     // is assumed to be <std>/etc/rebase.nar.
  426.     // This can be overridden in gbench.ini, via the application registry
  427.     // variable [RESTRICTION_SITES] RebaseData.
  428.     fname = registry.GetString("RESTRICTION_SITES", "RebaseData", "");
  429.     if ( !fname.empty() ) {
  430.         fname += ", ";
  431.     }
  432.     fname += "<home>/etc/rebase.nar, <std>/etc/rebase.nar";
  433.     fname = CSystemPath::ResolvePathExisting(fname);
  434.     if ( fname.empty() ) {
  435.         throw runtime_error("Couldn't open REBASE file ");
  436.     }
  437.     ifstream refile(fname.c_str());
  438.     CRebase::ReadNARFormat(refile, enzymes, which_enzymes);
  439. }
  440. // helper function to decode a parameter
  441. CRebase::EEnzymesToLoad
  442. CAlgoPlugin_RestrictionSites::x_DecodeWhichEnzymes(const string& s)
  443. {
  444.     if (s == "commercially available") {
  445.         return CRebase::eCommercial;
  446.     } else if (s == "prototypes") {
  447.         return CRebase::ePrototype;
  448.     } else if (s == "all") {
  449.         return CRebase::eAll;
  450.     } else {
  451.         throw runtime_error(string("Invalid "which_enzymes" string: ")
  452.                             + s);
  453.     }
  454. }
  455. END_NCBI_SCOPE
  456. /*
  457.  * ===========================================================================
  458.  * $Log: restriction_sites.cpp,v $
  459.  * Revision 1000.5  2004/06/01 20:55:43  gouriano
  460.  * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.32
  461.  *
  462.  * Revision 1.32  2004/05/21 22:27:47  gorelenk
  463.  * Added PCH ncbi_pch.hpp
  464.  *
  465.  * Revision 1.31  2004/05/03 13:05:42  dicuccio
  466.  * gui/utils --> gui/objutils where needed
  467.  *
  468.  * Revision 1.30  2004/03/05 17:35:37  dicuccio
  469.  * Use sequence::GetId() instead of CSeq_id::GetStringDescr()
  470.  *
  471.  * Revision 1.29  2004/02/17 20:35:25  rsmith
  472.  * moved core/settings.[ch]pp and core/system_path.[ch]pp to config and utils, respectively.
  473.  *
  474.  * Revision 1.28  2004/01/27 18:38:09  dicuccio
  475.  * Code clean-up.  Use standard names for plugins.  Removed unnecessary #includes
  476.  *
  477.  * Revision 1.27  2004/01/07 15:50:39  dicuccio
  478.  * Adjusted for API change in CPluginUtils::GetLabel().  Standardized exception
  479.  * reporting in algorithms.
  480.  *
  481.  * Revision 1.26  2003/12/31 15:36:08  grichenk
  482.  * Moved CompareLocations() from CSeq_feat to CSeq_loc,
  483.  * renamed it to Compare().
  484.  *
  485.  * Revision 1.25  2003/11/24 15:45:28  dicuccio
  486.  * Renamed CVersion to CPluginVersion
  487.  *
  488.  * Revision 1.24  2003/11/18 17:48:38  dicuccio
  489.  * Added standard processing of return values
  490.  *
  491.  * Revision 1.23  2003/11/04 17:49:23  dicuccio
  492.  * Changed calling parameters for plugins - pass CPluginMessage instead of paired
  493.  * CPluginCommand/CPluginReply
  494.  *
  495.  * Revision 1.22  2003/10/27 17:46:49  dicuccio
  496.  * Removed dead #includes
  497.  *
  498.  * Revision 1.21  2003/10/17 19:10:42  dicuccio
  499.  * Code clean-up.  Refactored feature building into a more modular function.
  500.  * Fixed list sorting - replaced with sorting of a vector to work around lack of
  501.  * support for list::sort(functor) in MSVC
  502.  *
  503.  * Revision 1.20  2003/10/17 18:07:47  jcherry
  504.  * Sort Seq-locs in mix by location.  Remap features for possible sites too.
  505.  *
  506.  * Revision 1.19  2003/10/15 13:40:26  dicuccio
  507.  * Mkae sure to set the 'id' for the seq-locs before calling RemapChildToParent()
  508.  *
  509.  * Revision 1.18  2003/10/14 16:24:02  dicuccio
  510.  * Added correct remapping of scanned locations to the parent location.  Cleaned
  511.  * up code to look for data file - added hierarchichal search through path in INI,
  512.  * user's home directory, and finally system installed path.
  513.  *
  514.  * Revision 1.17  2003/10/07 13:47:00  dicuccio
  515.  * Renamed CPluginURL* to CPluginValue*
  516.  *
  517.  * Revision 1.16  2003/09/25 17:21:35  jcherry
  518.  * Added name to annot
  519.  *
  520.  * Revision 1.15  2003/09/04 14:05:24  dicuccio
  521.  * Use IDocument instead of CDocument
  522.  *
  523.  * Revision 1.14  2003/09/03 14:46:53  rsmith
  524.  * change namespace name from args to plugin_args to avoid clashes with variable names.
  525.  *
  526.  * Revision 1.13  2003/08/22 15:47:45  dicuccio
  527.  * Added 'objects::' where necessary
  528.  *
  529.  * Revision 1.12  2003/08/21 19:24:16  jcherry
  530.  * Moved restriction site finding to algo/sequence
  531.  *
  532.  * Revision 1.11  2003/08/21 18:38:32  jcherry
  533.  * Overloaded CFindRSites::Find to take several sequence containers.
  534.  * Added option to lump together enzymes with identical specificities.
  535.  *
  536.  * Revision 1.10  2003/08/21 12:03:07  dicuccio
  537.  * Make use of new typedef in plugin_utils.hpp for argument values.
  538.  *
  539.  * Revision 1.9  2003/08/20 22:57:44  jcherry
  540.  * Reimplemented restriction site finding using finite state machine
  541.  *
  542.  * Revision 1.8  2003/08/18 19:24:15  jcherry
  543.  * Moved orf and seq_match to algo/sequence
  544.  *
  545.  * Revision 1.7  2003/08/15 16:57:17  jcherry
  546.  * For consecutive enzymes with identical specificities, reuse
  547.  * search results.  This saves a bunch of time.
  548.  *
  549.  * Revision 1.6  2003/08/15 16:33:40  jcherry
  550.  * Fixed typo
  551.  *
  552.  * Revision 1.5  2003/08/15 15:26:12  jcherry
  553.  * Changed so that restriction site searching (CFindRSites::Find) returns
  554.  * a vector of CRefs rather than a vector of objects.  This speeds sorting.
  555.  *
  556.  * Revision 1.4  2003/08/14 18:33:32  jcherry
  557.  * Use an rsite feature type (rather than a region).
  558.  * Also include cleavage sites in feature location.
  559.  *
  560.  * Revision 1.3  2003/08/13 17:40:26  dicuccio
  561.  * Formatting fixes.  Changes some pass-by-val to pass-by-reference.  Fixed
  562.  * complement table
  563.  *
  564.  * Revision 1.2  2003/08/13 12:37:58  dicuccio
  565.  * Partial compilation fixes for Windows
  566.  *
  567.  * Revision 1.1  2003/08/12 18:52:58  jcherry
  568.  * Initial version
  569.  *
  570.  * ===========================================================================
  571.  */