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

生物技术

开发平台:

C/C++

  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: restriction.hpp,v $
  4.  * PRODUCTION Revision 1000.0  2003/10/29 19:28:55  gouriano
  5.  * PRODUCTION PRODUCTION: IMPORTED [ORIGINAL] Dev-tree R1.14
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  9. /*  $Id: restriction.hpp,v 1000.0 2003/10/29 19:28:55 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:  Classes for representing and finding restriction sites
  37.  *
  38.  */
  39. #ifndef ALGO_SEQUENCE___RESTRICTION__HPP
  40. #define ALGO_SEQUENCE___RESTRICTION__HPP
  41. #include <corelib/ncbistd.hpp>
  42. #include <corelib/ncbiobj.hpp>
  43. #include <objmgr/bioseq_handle.hpp>
  44. #include <algo/sequence/seq_match.hpp>
  45. #include <util/strsearch.hpp>
  46. BEGIN_NCBI_SCOPE
  47. USING_SCOPE(objects);
  48. ///
  49. /// This class represents a particular occurrence of a restriction
  50. /// site on a sequence (not to be confused with a CRSpec, which
  51. /// represents a *type* of restriction site).
  52. /// Contains the locations of beginning and end of recognition site,
  53. /// and vectors of cut sites on plus and minus strands.
  54. ///
  55. class NCBI_XALGOSEQ_EXPORT CRSite
  56. {
  57. public:
  58.     CRSite(int start, int end);
  59.     // location of recognition sequence
  60.     void SetStart(const int pos);
  61.     int GetStart(void) const;
  62.     void SetEnd(const int pos);
  63.     int GetEnd(void) const;
  64.     // cleavage locations
  65.     // 0 is the bond just before the recognition sequence
  66.     vector<int>&       SetPlusCuts(void);
  67.     const vector<int>& GetPlusCuts(void) const;
  68.     vector<int>&       SetMinusCuts(void);
  69.     const vector<int>& GetMinusCuts(void) const;
  70. private:
  71.     int m_Start;
  72.     int m_End;
  73.     vector<int> m_PlusCuts;
  74.     vector<int> m_MinusCuts;
  75. };
  76. NCBI_XALGOSEQ_EXPORT ostream& operator<<(ostream& os, const CRSite& site);
  77. ///////////////////////////////////////////////////////////
  78. ///////////////////// inline methods //////////////////////
  79. ///////////////////////////////////////////////////////////
  80. inline
  81. CRSite::CRSite(int start, int end)
  82. {
  83.     m_Start = start;
  84.     m_End = end;
  85. }
  86. inline
  87. vector<int>& CRSite::SetPlusCuts(void)
  88. {
  89.     return m_PlusCuts;
  90. }
  91. inline
  92. const vector<int>& CRSite::GetPlusCuts(void) const
  93. {
  94.     return m_PlusCuts;
  95. }
  96. inline
  97. vector<int>& CRSite::SetMinusCuts(void)
  98. {
  99.     return m_MinusCuts;
  100. }
  101. inline
  102. const vector<int>& CRSite::GetMinusCuts(void) const
  103. {
  104.     return m_MinusCuts;
  105. }
  106. inline
  107. void CRSite::SetStart(int pos)
  108. {
  109.     m_Start = pos;
  110. }
  111. inline
  112. int CRSite::GetStart(void) const
  113. {
  114.     return m_Start;
  115. }
  116. inline
  117. void CRSite::SetEnd(int pos)
  118. {
  119.     m_End = pos;
  120. }
  121. inline
  122. int CRSite::GetEnd(void) const
  123. {
  124.     return m_End;
  125. }
  126. ///
  127. /// This class represents a restriction enzyme specificity,
  128. /// i.e., a sequence recognition pattern and vectors of cleavage
  129. /// sites on the two strands.
  130. /// Some known enzymes (e.g., BaeI) have two cleavage sites on each
  131. /// strand.  Some will be represented as having zero because the
  132. /// cut locations are unknown.
  133. /// An enzyme may have more than one specificity (TaqII).
  134. ///
  135. class NCBI_XALGOSEQ_EXPORT CRSpec
  136. {
  137. public:
  138.     // recognition sequence
  139.     void SetSeq(const string& s);
  140.     string& SetSeq(void);
  141.     const string& GetSeq(void) const;
  142.     // cleavage locations
  143.     // 0 is the bond just before the recognition sequence
  144.     vector<int>&       SetPlusCuts(void);
  145.     const vector<int>& GetPlusCuts(void) const;
  146.     vector<int>&       SetMinusCuts(void);
  147.     const vector<int>& GetMinusCuts(void) const;
  148.     // compare
  149.     bool operator==(const CRSpec& rhs) const {
  150.         return m_Seq == rhs.m_Seq 
  151.             && m_PlusCuts == rhs.m_PlusCuts
  152.             && m_MinusCuts == rhs.m_MinusCuts;
  153.     }
  154.     bool operator!=(const CRSpec& rhs) const {
  155.         return !(*this == rhs);
  156.     }
  157.     bool operator<(const CRSpec& rhs) const;
  158.     // reset everything
  159.     void Reset(void);
  160. private:
  161.     string m_Seq;
  162.     vector<int> m_PlusCuts;
  163.     vector<int> m_MinusCuts;
  164. };
  165. ///////////////////////////////////////////////////////////
  166. ///////////////////// inline methods //////////////////////
  167. ///////////////////////////////////////////////////////////
  168. inline
  169. void CRSpec::SetSeq(const string& s)
  170. {
  171.     m_Seq = s;
  172. }
  173. inline
  174. string& CRSpec::SetSeq(void)
  175. {
  176.     return m_Seq;
  177. }
  178. inline
  179. const string& CRSpec::GetSeq(void) const
  180. {
  181.     return m_Seq;
  182. }
  183. inline
  184. vector<int>& CRSpec::SetPlusCuts(void)
  185. {
  186.     return m_PlusCuts;
  187. }
  188. inline
  189. const vector<int>& CRSpec::GetPlusCuts(void) const
  190. {
  191.     return m_PlusCuts;
  192. }
  193. inline
  194. vector<int>& CRSpec::SetMinusCuts(void)
  195. {
  196.     return m_MinusCuts;
  197. }
  198. inline
  199. const vector<int>& CRSpec::GetMinusCuts(void) const
  200. {
  201.     return m_MinusCuts;
  202. }
  203. ///
  204. /// This class represents a restriction enzyme
  205. /// (an enzyme name and a vector of cleavage specificities)
  206. ///
  207. class NCBI_XALGOSEQ_EXPORT CREnzyme
  208. {
  209. public:
  210.     // name of enzyme
  211.     void SetName(const string& s);
  212.     string& SetName(void);
  213.     const string& GetName(void) const;
  214.     // cleavage specificities
  215.     // (usually just one, but TaqII has two)
  216.     vector<CRSpec>& SetSpecs(void);
  217.     const vector<CRSpec>& GetSpecs(void) const;
  218.     // reset everything
  219.     void Reset(void);
  220.     // Given a vector of CREnzyme, lump together all
  221.     // enzymes with identical specificities.
  222.     // The cleavage sites must be the same for specificities
  223.     // to be considered indentical (in addition to the
  224.     // recognition sequenence).
  225.     static void CombineIsoschizomers(vector<CREnzyme>& enzymes);
  226. private:
  227.     string m_Name;
  228.     vector<CRSpec> m_Specs;
  229. };
  230. ///////////////////////////////////////////////////////////
  231. ///////////////////// inline methods //////////////////////
  232. ///////////////////////////////////////////////////////////
  233. inline
  234. void CREnzyme::SetName(const string& s)
  235. {
  236.     m_Name = s;
  237. }
  238. inline
  239. string& CREnzyme::SetName(void)
  240. {
  241.     return m_Name;
  242. }
  243. inline
  244. const string& CREnzyme::GetName(void) const
  245. {
  246.     return m_Name;
  247. }
  248. inline
  249. vector<CRSpec>& CREnzyme::SetSpecs(void)
  250. {
  251.     return m_Specs;
  252. }
  253. inline
  254. const vector<CRSpec>& CREnzyme::GetSpecs(void) const
  255. {
  256.     return m_Specs;
  257. }
  258. ///
  259. /// This class represents the results of a search for sites
  260. /// of a particular enzyme.
  261. /// It merely packages an enzyme name, a vector of
  262. /// definite sites, and a vector of possible sites
  263. ///
  264. class CREnzResult : public CObject
  265. {
  266. public:
  267.     CREnzResult(const string& enzyme_name) : m_EnzymeName(enzyme_name) {}
  268.     CREnzResult(const string& enzyme_name,
  269.                 const vector<CRSite>& definite_sites,
  270.                 const vector<CRSite>& possible_sites);
  271.     // member access functions
  272.     const string& GetEnzymeName(void) const {return m_EnzymeName;}
  273.     vector<CRSite>& SetDefiniteSites(void) {return m_DefiniteSites;}
  274.     const vector<CRSite>& GetDefiniteSites(void) const
  275.     {
  276.         return m_DefiniteSites;
  277.     }
  278.     vector<CRSite>& SetPossibleSites(void) {return m_PossibleSites;}
  279.     const vector<CRSite>& GetPossibleSites(void) const
  280.     {
  281.         return m_PossibleSites;
  282.     }
  283. private:
  284.     string m_EnzymeName;
  285.     vector<CRSite> m_DefiniteSites;
  286.     vector<CRSite> m_PossibleSites;
  287. };
  288. NCBI_XALGOSEQ_EXPORT ostream& operator<<(ostream& os, const CREnzResult& er);
  289. ///////////////////////////////////////////////////////////
  290. ///////////////////// inline methods //////////////////////
  291. ///////////////////////////////////////////////////////////
  292. inline
  293. CREnzResult::CREnzResult(const string& enzyme_name,
  294.                          const vector<CRSite>& definite_sites,
  295.                          const vector<CRSite>& possible_sites)
  296. {
  297.     m_EnzymeName = enzyme_name;
  298.     m_DefiniteSites = definite_sites;
  299.     m_PossibleSites = possible_sites;
  300. }
  301. /// this class contains the static member functions Find,
  302. /// which find restriction sites in a sequence
  303. class NCBI_XALGOSEQ_EXPORT CFindRSites
  304. {
  305. public:
  306.     static void Find(const string& seq,
  307.                      const vector<CREnzyme>& enzymes,
  308.                      vector<CRef<CREnzResult> >& results);
  309.     static void Find(const vector<char>& seq,
  310.                      const vector<CREnzyme>& enzymes,
  311.                      vector<CRef<CREnzResult> >& results);
  312.     static void Find(const CSeqVector& seq,
  313.                      const vector<CREnzyme>& enzymes,
  314.                      vector<CRef<CREnzResult> >& results);
  315. private:
  316.     static void x_ExpandRecursion(string& s, unsigned int pos,
  317.                                   CTextFsm<int>& fsm, int match_value);
  318.     static void x_AddPattern(const string& pat, CTextFsm<int>& fsm,
  319.                              int match_value);
  320.     static bool x_IsAmbig(char nuc);
  321.     template<class Seq>
  322.     friend void x_FindRSite(const Seq& seq, const vector<CREnzyme>& enzymes,
  323.                             vector<CRef<CREnzResult> >& results);
  324. };
  325. END_NCBI_SCOPE
  326. #endif   // ALGO_SEQUENCE___RESTRICTION__HPP
  327. /*
  328.  * ===========================================================================
  329.  * $Log: restriction.hpp,v $
  330.  * Revision 1000.0  2003/10/29 19:28:55  gouriano
  331.  * PRODUCTION: IMPORTED [ORIGINAL] Dev-tree R1.14
  332.  *
  333.  * Revision 1.14  2003/08/22 14:25:53  ucko
  334.  * Fix for MSVC, which seems to have problems with member templates.
  335.  *
  336.  * Revision 1.13  2003/08/22 02:17:13  ucko
  337.  * Fix WorkShop compilation.
  338.  *
  339.  * Revision 1.12  2003/08/21 19:21:44  jcherry
  340.  * Moved restriction site finding to algo/sequence
  341.  *
  342.  * Revision 1.11  2003/08/21 18:38:31  jcherry
  343.  * Overloaded CFindRSites::Find to take several sequence containers.
  344.  * Added option to lump together enzymes with identical specificities.
  345.  *
  346.  * Revision 1.10  2003/08/20 22:57:44  jcherry
  347.  * Reimplemented restriction site finding using finite state machine
  348.  *
  349.  * Revision 1.9  2003/08/18 19:24:15  jcherry
  350.  * Moved orf and seq_match to algo/sequence
  351.  *
  352.  * Revision 1.8  2003/08/18 13:52:22  jcherry
  353.  * Added operator!= for CRSpec (possible fix for MIPS, which seems to
  354.  * use != in computing vector ==)
  355.  *
  356.  * Revision 1.7  2003/08/17 19:25:30  jcherry
  357.  * Changed member variable names to follow convention
  358.  *
  359.  * Revision 1.6  2003/08/15 16:57:17  jcherry
  360.  * For consecutive enzymes with identical specificities, reuse
  361.  * search results.  This saves a bunch of time.
  362.  *
  363.  * Revision 1.5  2003/08/15 15:26:12  jcherry
  364.  * Changed so that restriction site searching (CFindRSites::Find) returns
  365.  * a vector of CRefs rather than a vector of objects.  This speeds sorting.
  366.  *
  367.  * Revision 1.4  2003/08/13 17:40:26  dicuccio
  368.  * Formatting fixes.  Changes some pass-by-val to pass-by-reference.  Fixed
  369.  * complement table
  370.  *
  371.  * Revision 1.3  2003/08/13 16:42:11  dicuccio
  372.  * Compilation fixes for MSVC
  373.  *
  374.  * Revision 1.2  2003/08/13 12:37:58  dicuccio
  375.  * Partial compilation fixes for Windows
  376.  *
  377.  * Revision 1.1  2003/08/12 18:52:58  jcherry
  378.  * Initial version
  379.  *
  380.  * ===========================================================================
  381.  */