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

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

生物技术

开发平台：

C/C++

Seq_loc.hpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: Seq_loc.hpp,v $
  4.  * PRODUCTION Revision 1000.3  2004/06/01 19:30:53  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.37
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. /* $Id: Seq_loc.hpp,v 1000.3 2004/06/01 19:30:53 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.  * Author:  Cliff Clausen, Eugene Vasilchenko
  36.  *
  37.  * File Description:
  38.  *   .......
  39.  *
  40.  * Remark:
  41.  *   This code was originally generated by application DATATOOL
  42.  *   using specifications from the ASN data definition file
  43.  *   'seqloc.asn'.
  44.  *
  45.  * ===========================================================================
  46.  */
  48. #ifndef OBJECTS_SEQLOC_SEQ_LOC_HPP
  49. #define OBJECTS_SEQLOC_SEQ_LOC_HPP
  52. // generated includes
  53. #include <objects/seqloc/Seq_loc_.hpp>
  54. #include <objects/seqloc/Seq_loc_mix.hpp>
  55. #include <objects/seqloc/Packed_seqpnt.hpp>
  56. #include <objects/seqloc/Packed_seqint.hpp>
  57. #include <objects/seqloc/Seq_id.hpp>
  59. #include <objects/general/Int_fuzz.hpp>
  61. //
  62. #include <corelib/ncbiexpt.hpp>
  63. #include <util/range.hpp>
  64. #include <vector>
  66. BEGIN_NCBI_SCOPE
  67. BEGIN_objects_SCOPE // namespace ncbi::objects::
  69. class NCBI_SEQLOC_EXPORT CSeq_loc : public CSeq_loc_Base
  70. {
  71. public:
  72.     typedef CSeq_loc_Base Tparent;
  73.     typedef CPacked_seqpnt_Base::TPoints TPoints;
  74.     typedef CPacked_seqint_Base::Tdata   TIntervals;
  75.     typedef CSeq_loc_mix_Base::Tdata     TLocations;
  76.     typedef CSeq_id                      TId;
  77.     typedef ENa_strand                   TStrand;
  78.     typedef TSeqPos                      TPoint;
  79.     typedef CPacked_seqint::TRanges      TRanges;
  81.     // constructor
  82.     CSeq_loc(void);
  83.     CSeq_loc(E_Choice index);
  84.     CSeq_loc(TId& id, TPoint point, TStrand strand = eNa_strand_unknown);
  85.     CSeq_loc(TId& id, const TPoints& points, TStrand strand = eNa_strand_unknown);
  86.     CSeq_loc(TId& id, TPoint from, TPoint to, TStrand strand = eNa_strand_unknown);
  87.     CSeq_loc(TId& id, TRanges ivals, TStrand strand = eNa_strand_unknown);
  89.     // destructor
  90.     virtual ~CSeq_loc(void);
  92.     // See related functions in util/sequence.hpp:
  93.     //
  94.     //   TSeqPos GetLength(const CSeq_loc&, CScope*)
  95.     //   bool IsOneBioseq(const CSeq_loc&, CScope*)
  96.     //   const CSeq_id& GetId(const CSeq_loc&, CScope*)
  97.     //   TSeqPos GetStart(const CSeq_loc&, CScope*)
  98.     //   sequence::ECompare Compare(const CSeq_loc&, CSeq_loc&, CScope*)
  99.     //   sequence::SeqLocMerge(...)
  100.     //
  102.     typedef CRange<TSeqPos> TRange;
  104.     TRange GetTotalRange(void) const;
  105.     void InvalidateTotalRangeCache(void);
  106.  
  107.     // Special case for circular sequences. No ID is checked for
  108.     // circular locations. If the sequence is not circular
  109.     // (seq_len == kInvalidSeqPos) all functions work like GetTotalRange()
  110.     TSeqPos GetStart(TSeqPos seq_len) const;
  111.     TSeqPos GetEnd(TSeqPos seq_len) const;
  112.     TSeqPos GetCircularLength(TSeqPos seq_len) const;
  114.     // Appends a label suitable for display (e.g., error messages)
  115.     // label must point to an existing string object
  116.     // Method just returns if label is null. Note this label is NOT
  117.     // GenBank-style.
  118.     void GetLabel(string* label) const;
  120.     // check left (5') or right (3') end of location for e_Lim fuzz
  121.     bool IsPartialLeft  (void) const;
  122.     bool IsPartialRight (void) const;
  124.     // set / remove e_Lim fuzz on left (5') or right (3') end
  125.     void SetPartialLeft (bool val);
  126.     void SetPartialRight(bool val);
  128.     // set the 'id' field in all parts of this location
  129.     void SetId(CSeq_id& id); // stores id
  130.     void SetId(const CSeq_id& id); // stores a new copy of id
  132.     // check that the 'id' field in all parts of the location is the same
  133.     // as the specifies id.
  134.     // if the id parameter is NULL will return the location's id (if unique)
  135.     void CheckId(const CSeq_id*& id) const;
  136.     void InvalidateIdCache(void);
  138.     virtual void Assign(const CSerialObject& source,
  139.                         ESerialRecursionMode how = eRecursive);
  140.     virtual bool Equals(const CSerialObject& object,
  141.                         ESerialRecursionMode how = eRecursive) const;
  143.     // Compare locations if they are defined on the same single sequence
  144.     // or throw exception.
  145.     int Compare(const CSeq_loc& loc) const;
  147.     void Add(const CSeq_loc& other);
  149. private:
  150.     // Prohibit copy constructor & assignment operator
  151.     CSeq_loc(const CSeq_loc&);
  152.     CSeq_loc& operator= (const CSeq_loc&);
  154.     TRange x_UpdateTotalRange(void) const;
  155.     TRange x_CalculateTotalRangeCheckId(const CSeq_id*& id) const;
  156.     void x_CheckId(const CSeq_id*& id) const;
  157.     void x_UpdateId(const CSeq_id*& total_id, const CSeq_id* id) const;
  158.     void x_ChangeToMix(const CSeq_loc& other);
  159.     void x_ChangeToPackedInt(const CSeq_loc& other);
  160.     void x_ChangeToPackedPnt(const CSeq_loc& other);
  161.     void x_InvalidateCache(void);
  163.     enum {
  164.         kDirtyCache = -2,
  165.         kSeveralIds = -3
  166.     };
  168.     mutable TRange m_TotalRangeCache;
  169.     // Seq-id for the whole seq-loc or null if multiple IDs were found
  170.     mutable const CSeq_id* m_IdCache;
  171. };
  175. // Seq-loc iterator class -- iterates all intervals from a seq-loc
  176. // in the correct order.
  177. class NCBI_SEQLOC_EXPORT CSeq_loc_CI
  178. {
  179. public:
  180.     // Options for empty locations processing
  181.     enum EEmptyFlag {
  182.         eEmpty_Skip,    // ignore empty locations
  183.         eEmpty_Allow    // treat empty locations as usual
  184.     };
  186.     CSeq_loc_CI(void);
  187.     CSeq_loc_CI(const CSeq_loc& loc, EEmptyFlag empty_flag = eEmpty_Skip);
  188.     ~CSeq_loc_CI(void);
  190.     CSeq_loc_CI(const CSeq_loc_CI& iter);
  191.     CSeq_loc_CI& operator= (const CSeq_loc_CI& iter);
  193.     CSeq_loc_CI& operator++ (void);
  194.     operator bool (void) const;
  196.     typedef CRange<TSeqPos> TRange;
  198.     // Get seq_id of the current location
  199.     const CSeq_id& GetSeq_id(void) const;
  200.     // Get the range
  201.     TRange         GetRange(void) const;
  202.     // Get strand
  203.     ENa_strand GetStrand(void) const;
  204.     // Get seq-loc for the current interval
  205.     const CSeq_loc& GetSeq_loc(void) const;
  207.     // Return null if non-fuzzy 
  208.     const CInt_fuzz* GetFuzzFrom(void) const;
  209.     const CInt_fuzz* GetFuzzTo  (void) const;
  211.     // True if the current location is a whole sequence
  212.     bool           IsWhole(void) const;
  213.     // True if the current location is empty
  214.     bool           IsEmpty(void) const;
  215.     // True if the current location is a single point
  216.     bool           IsPoint(void) const;
  218. private:
  219.     // Check the iterator position
  220.     bool x_IsValid(void) const;
  221.     // Check the position, throw exception if not valid
  222.     void x_CheckNotValid(const char* where) const;
  223.     void x_ThrowNotValid(const char* where) const;
  225.     // Process the location, fill the list
  226.     void x_ProcessLocation(const CSeq_loc& loc);
  228.     // Simple location structure: id/from/to
  229.     struct SLoc_Info {
  230.         SLoc_Info(void);
  232.         CConstRef<CSeq_id>  m_Id;
  233.         TRange              m_Range;
  234.         ENa_strand          m_Strand;
  235.         // The original seq-loc for the interval
  236.         CConstRef<CSeq_loc> m_Loc;
  237.         CConstRef<CInt_fuzz> m_Fuzz[2];
  238.     };
  240.     typedef list<SLoc_Info> TLocList;
  242.     // Prevent seq-loc destruction
  243.     CConstRef<CSeq_loc>      m_Location;
  244.     // List of intervals
  245.     TLocList                 m_LocList;
  246.     // Current interval
  247.     TLocList::const_iterator m_CurLoc;
  248.     // Empty locations processing option
  249.     EEmptyFlag               m_EmptyFlag;
  250. };
  254. /////////////////// CSeq_loc inline methods
  256. inline
  257. void CSeq_loc::InvalidateTotalRangeCache(void)
  258. {
  259.     m_TotalRangeCache.SetFrom(TSeqPos(kDirtyCache));
  260. }
  263. inline 
  264. void CSeq_loc::InvalidateIdCache(void)
  265. {
  266.     m_IdCache = 0;
  267. }
  270. inline 
  271. void CSeq_loc::x_InvalidateCache(void)
  272. {
  273.     InvalidateTotalRangeCache();
  274.     InvalidateIdCache();
  275. }
  278. // constructor
  279. inline
  280. CSeq_loc::CSeq_loc(void)
  281. {
  282.     x_InvalidateCache();
  283. }
  286. inline
  287. CSeq_loc::TRange CSeq_loc::GetTotalRange(void) const
  288. {
  289.     TRange range = m_TotalRangeCache;
  290.     if ( range.GetFrom() == TSeqPos(kDirtyCache) )
  291.         range = x_UpdateTotalRange();
  292.     return range;
  293. }
  296. inline
  297. void CSeq_loc::CheckId(const CSeq_id*& id) const
  298. {
  299.     const CSeq_id* my_id = m_IdCache;
  300.     if ( my_id == 0 ) {
  301.         x_CheckId(my_id);
  302.         m_IdCache = my_id;
  303.     }
  304.     x_UpdateId(id, my_id);
  305. }
  308. inline
  309. void CSeq_loc::SetId(const CSeq_id& id)
  310. {
  311.     InvalidateIdCache();
  312.     CRef<CSeq_id> nc_id(new CSeq_id);
  313.     nc_id->Assign(id);
  314.     SetId(*nc_id);
  315.     m_IdCache = nc_id.GetPointer();
  316. }
  319. inline
  320. int CSeq_loc::Compare(const CSeq_loc& loc) const
  321. {
  322.     CSeq_loc::TRange range1 = GetTotalRange();
  323.     CSeq_loc::TRange range2 = loc.GetTotalRange();
  324.     // smallest left extreme first
  325.     if ( range1.GetFrom() != range2.GetFrom() ) {
  326.         return range1.GetFrom() < range2.GetFrom()? -1: 1;
  327.     }
  329.     // longest first
  330.     if ( range1.GetToOpen() != range2.GetToOpen() ) {
  331.         return range1.GetToOpen() < range2.GetToOpen()? 1: -1;
  332.     }
  333.     return 0;
  334. }
  337. /////////////////// end of CSeq_loc inline methods
  339. /////////////////// CSeq_loc_CI inline methods
  341. inline
  342. CSeq_loc_CI::SLoc_Info::SLoc_Info(void)
  343.     : m_Id(0),
  344.       m_Strand(eNa_strand_unknown),
  345.       m_Loc(0)
  346. {
  347.     return;
  348. }
  350. inline
  351. CSeq_loc_CI& CSeq_loc_CI::operator++ (void)
  352. {
  353.     ++m_CurLoc;
  354.     return *this;
  355. }
  357. inline
  358. bool CSeq_loc_CI::x_IsValid(void) const
  359. {
  360.     return m_CurLoc != m_LocList.end();
  361. }
  363. inline
  364. CSeq_loc_CI::operator bool (void) const
  365. {
  366.     return x_IsValid();
  367. }
  369. inline
  370. void CSeq_loc_CI::x_CheckNotValid(const char* where) const
  371. {
  372.     if ( !x_IsValid() )
  373.         x_ThrowNotValid(where);
  374. }
  376. inline
  377. const CSeq_id& CSeq_loc_CI::GetSeq_id(void) const
  378. {
  379.     x_CheckNotValid("GetSeq_id()");
  380.     return *m_CurLoc->m_Id;
  381. }
  383. inline
  384. CSeq_loc_CI::TRange CSeq_loc_CI::GetRange(void) const
  385. {
  386.     x_CheckNotValid("GetRange()");
  387.     return m_CurLoc->m_Range;
  388. }
  390. inline
  391. ENa_strand CSeq_loc_CI::GetStrand(void) const
  392. {
  393.     x_CheckNotValid("GetStrand()");
  394.     return m_CurLoc->m_Strand;
  395. }
  397. inline
  398. const CSeq_loc& CSeq_loc_CI::GetSeq_loc(void) const
  399. {
  400.     x_CheckNotValid("GetSeq_loc()");
  401.     if ( !m_CurLoc->m_Loc ) {
  402.         NCBI_THROW(CException, eUnknown,
  403.             "CSeq_loc_CI::GetSeq_loc() -- NULL seq-loc");
  404.     }
  405.     return *m_CurLoc->m_Loc;
  406. }
  408. inline
  409. const CInt_fuzz* CSeq_loc_CI::GetFuzzFrom(void) const
  410. {
  411.     x_CheckNotValid("GetFuzzFrom()");
  412.     return m_CurLoc->m_Fuzz[0];
  413. }
  415. inline
  416. const CInt_fuzz* CSeq_loc_CI::GetFuzzTo(void) const
  417. {
  418.     x_CheckNotValid("GetFuzzTo()");
  419.     return m_CurLoc->m_Fuzz[1];
  420. }
  422. inline
  423. bool CSeq_loc_CI::IsWhole(void) const
  424. {
  425.     x_CheckNotValid("IsWhole()");
  426.     return m_CurLoc->m_Range.IsWhole();
  427. }
  429. inline
  430. bool CSeq_loc_CI::IsEmpty(void) const
  431. {
  432.     x_CheckNotValid("IsEmpty()");
  433.     return m_CurLoc->m_Range.Empty();
  434. }
  436. inline
  437. bool CSeq_loc_CI::IsPoint(void) const
  438. {
  439.     x_CheckNotValid("IsPoint()");
  440.     return m_CurLoc->m_Range.GetLength() == 1;
  441. }
  443. /////////////////// end of CSeq_loc_CI inline methods
  446. END_objects_SCOPE // namespace ncbi::objects::
  447. END_NCBI_SCOPE
  449. /*
  450.  * ===========================================================================
  451.  * $Log: Seq_loc.hpp,v $
  452.  * Revision 1000.3  2004/06/01 19:30:53  gouriano
  453.  * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.37
  454.  *
  455.  * Revision 1.37  2004/05/06 16:54:41  shomrat
  456.  * Added methods to set partial left and right
  457.  *
  458.  * Revision 1.36  2004/03/25 15:58:41  gouriano
  459.  * Added possibility to copy and compare serial object non-recursively
  460.  *
  461.  * Revision 1.35  2004/03/16 18:08:56  vasilche
  462.  * Use GetPointer() to avoid ambiguity
  463.  *
  464.  * Revision 1.34  2004/02/17 21:10:58  vasilche
  465.  * Fixed possible race condition in CSeq_loc::CheckId().
  466.  *
  467.  * Revision 1.33  2004/01/29 21:07:08  shomrat
  468.  * Made cache invalidation methods public
  469.  *
  470.  * Revision 1.32  2004/01/28 17:16:31  shomrat
  471.  * Added methods to ease the construction of objects
  472.  *
  473.  * Revision 1.31  2003/12/31 15:36:07  grichenk
  474.  * Moved CompareLocations() from CSeq_feat to CSeq_loc,
  475.  * renamed it to Compare().
  476.  *
  477.  * Revision 1.30  2003/11/21 14:45:00  grichenk
  478.  * Replaced runtime_error with CException
  479.  *
  480.  * Revision 1.29  2003/10/15 15:50:21  ucko
  481.  * CSeq_loc::SetId: add a version that takes a const ID and stores a new copy.
  482.  * CSeq_loc_CI: expose fuzz (if present).
  483.  *
  484.  * Revision 1.28  2003/10/14 16:49:53  dicuccio
  485.  * Added SetId()
  486.  *
  487.  * Revision 1.27  2003/09/22 18:38:13  grichenk
  488.  * Fixed circular seq-locs processing by TestForOverlap()
  489.  *
  490.  * Revision 1.26  2003/09/17 18:39:01  grichenk
  491.  * + GetStart(), GetEnd(), GetCircularLength()
  492.  *
  493.  * Revision 1.25  2003/06/18 16:00:07  vasilche
  494.  * Fixed GetTotalRange() in multithreaded app.
  495.  *
  496.  * Revision 1.24  2003/06/13 17:21:18  grichenk
  497.  * Added seq-id caching for single-id seq-locs
  498.  *
  499.  * Revision 1.23  2003/04/02 15:17:45  grichenk
  500.  * Added flag for CSeq_loc_CI to skip/include empty locations.
  501.  *
  502.  * Revision 1.22  2003/02/06 22:23:29  vasilche
  503.  * Added CSeq_id::Assign(), CSeq_loc::Assign().
  504.  * Added int CSeq_id::Compare() (not safe).
  505.  * Added caching of CSeq_loc::GetTotalRange().
  506.  *
  507.  * Revision 1.21  2003/02/04 16:04:12  dicuccio
  508.  * Changed postfix to prefix operator in op++() - marginally faster
  509.  *
  510.  * Revision 1.20  2003/02/04 15:15:11  grichenk
  511.  * Overrided Assign() for CSeq_loc and CSeq_id
  512.  *
  513.  * Revision 1.19  2003/01/22 20:13:57  vasilche
  514.  * Use more effective COpenRange<> methods.
  515.  *
  516.  * Revision 1.18  2002/12/30 19:37:02  vasilche
  517.  * Rewrote CSeq_loc::GetTotalRange() to avoid using CSeq_loc_CI -
  518.  * it's too expensive.
  519.  *
  520.  * Revision 1.17  2002/12/26 12:43:42  dicuccio
  521.  * Added Win32 export specifiers
  522.  *
  523.  * Revision 1.16  2002/12/23 17:19:26  grichenk
  524.  * Added GetSeq_loc() to CSeq_loc_CI
  525.  *
  526.  * Revision 1.15  2002/12/19 20:21:10  dicuccio
  527.  * Remove post-increment operator
  528.  *
  529.  * Revision 1.14  2002/12/19 20:11:20  grichenk
  530.  * Fixed error message
  531.  *
  532.  * Revision 1.13  2002/10/03 18:49:05  clausen
  533.  * Removed extra whitespace
  534.  *
  535.  * Revision 1.12  2002/10/03 16:37:39  clausen
  536.  * Added GetLabel()
  537.  *
  538.  * Revision 1.11  2002/09/12 21:16:14  kans
  539.  * added IsPartialLeft and IsPartialRight
  540.  *
  541.  * Revision 1.10  2002/06/07 11:54:34  clausen
  542.  * Added related functions comment
  543.  *
  544.  * Revision 1.9  2002/06/06 20:40:51  clausen
  545.  * Moved methods using object manager to objects/util
  546.  *
  547.  * Revision 1.8  2002/05/03 21:28:04  ucko
  548.  * Introduce T(Signed)SeqPos.
  549.  *
  550.  * Revision 1.7  2002/04/17 15:39:06  grichenk
  551.  * Moved CSeq_loc_CI to the seq-loc library
  552.  *
  553.  * Revision 1.6  2002/01/10 18:20:48  clausen
  554.  * Added IsOneBioseq, GetStart, and GetId
  555.  *
  556.  * Revision 1.5  2001/10/22 11:39:49  clausen
  557.  * Added Compare()
  558.  *
  559.  * Revision 1.4  2001/06/25 18:52:02  grichenk
  560.  * Prohibited copy constructor and assignment operator
  561.  *
  562.  * Revision 1.3  2001/01/05 20:11:41  vasilche
  563.  * CRange, CRangeMap were moved to util.
  564.  *
  565.  * Revision 1.2  2001/01/03 16:38:58  vasilche
  566.  * Added CAbstractObjectManager - stub for object manager.
  567.  * CRange extracted to separate file.
  568.  *
  569.  * Revision 1.1  2000/11/17 21:35:02  vasilche
  570.  * Added GetLength() method to CSeq_loc class.
  571.  *
  572.  *
  573.  * ===========================================================================
  574. */
  576. #endif // OBJECTS_SEQLOC_SEQ_LOC_HPP