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

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

生物技术

开发平台：

C/C++

seq_map.hpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: seq_map.hpp,v $
  4.  * PRODUCTION Revision 1000.2  2004/04/12 17:27:48  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [CATCHUP_003] Dev-tree R1.44
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. #ifndef OBJECTS_OBJMGR___SEQ_MAP__HPP
  11. #define OBJECTS_OBJMGR___SEQ_MAP__HPP
  13. /*  $Id: seq_map.hpp,v 1000.2 2004/04/12 17:27:48 gouriano Exp $
  14. * ===========================================================================
  15. *
  16. *                            PUBLIC DOMAIN NOTICE
  17. *               National Center for Biotechnology Information
  18. *
  19. *  This software/database is a "United States Government Work" under the
  20. *  terms of the United States Copyright Act.  It was written as part of
  21. *  the author's official duties as a United States Government employee and
  22. *  thus cannot be copyrighted.  This software/database is freely available
  23. *  to the public for use. The National Library of Medicine and the U.S.
  24. *  Government have not placed any restriction on its use or reproduction.
  25. *
  26. *  Although all reasonable efforts have been taken to ensure the accuracy
  27. *  and reliability of the software and data, the NLM and the U.S.
  28. *  Government do not and cannot warrant the performance or results that
  29. *  may be obtained by using this software or data. The NLM and the U.S.
  30. *  Government disclaim all warranties, express or implied, including
  31. *  warranties of performance, merchantability or fitness for any particular
  32. *  purpose.
  33. *
  34. *  Please cite the author in any work or product based on this material.
  35. *
  36. * ===========================================================================
  37. *
  38. * Authors:
  39. *           Aleksey Grichenko
  40. *           Michael Kimelman
  41. *           Andrei Gourianov
  42. *           Eugene Vasilchenko
  43. *
  44. * File Description:
  45. *   CSeqMap -- formal sequence map to describe sequence parts in general,
  46. *   i.e. location and type only, without providing real data
  47. *
  48. */
  50. #include <objmgr/seq_id_handle.hpp>
  51. #include <objmgr/objmgr_exception.hpp>
  52. #include <objects/seqloc/Na_strand.hpp>
  53. #include <objects/seq/Seq_inst.hpp>
  54. #include <corelib/ncbimtx.hpp>
  55. #include <vector>
  56. #include <list>
  58. BEGIN_NCBI_SCOPE
  59. BEGIN_SCOPE(objects)
  61. class CBioseq;
  62. class CDelta_seq;
  63. class CSeq_loc;
  64. class CSeq_point;
  65. class CSeq_interval;
  66. class CSeq_loc_mix;
  67. class CSeq_loc_equiv;
  68. class CSeq_literal;
  69. class CSeq_data;
  70. class CPacked_seqint;
  71. class CPacked_seqpnt;
  73. // Provided for compatibility with old code; new code should just use TSeqPos.
  74. typedef TSeqPos TSeqPosition;
  75. typedef TSeqPos TSeqLength;
  78. ////////////////////////////////////////////////////////////////////
  79. //  CSeqMap::
  80. //     Formal sequence map -- to describe sequence parts in general --
  81. //     location and type only, without providing real data
  84. class CScope;
  85. class CBioseq_Handle;
  86. class CSegmentPtr;
  87. class CSeqMap_CI;
  88. class CSeqMap_CI_SegmentInfo;
  89. class CSeqMap_Delta_seqs;
  91. class NCBI_XOBJMGR_EXPORT CSeqMap : public CObject
  92. {
  93. public:
  94.     // typedefs
  95.     enum ESegmentType {
  96.         eSeqGap,              // gap
  97.         eSeqData,             // real sequence data
  98.         eSeqSubMap,           // sub seqmap
  99.         eSeqRef,              // reference to Bioseq
  100.         eSeqEnd
  101.     };
  103.     typedef CSeq_inst::TMol TMol;
  105. protected:
  106.     class CSegment;
  107.     class SPosLessSegment;
  109.     friend class CSegment;
  110.     friend class SPosLessSegment;
  111.     friend class CSeqMap_SeqPoss;
  113.     class CSegment
  114.     {
  115.     public:
  116.         CSegment(ESegmentType seg_type = eSeqEnd,
  117.                  TSeqPos length = kInvalidSeqPos);
  119.         // Relative position of the segment in seqmap
  120.         mutable TSeqPos      m_Position;
  121.         // Length of the segment (kInvalidSeqPos if unresolved)
  122.         mutable TSeqPos      m_Length;
  124.         // Segment type
  125.         char                 m_SegType;
  127.         // reference info, valid for eSeqData, eSeqSubMap, eSeqRef
  128.         bool                 m_RefMinusStrand;
  129.         TSeqPos              m_RefPosition;
  130.         CConstRef<CObject>   m_RefObject; // CSeq_data, CSeqMap, CSeq_id
  132.         typedef list<TSeqPos>::iterator TList0_I;
  133.         TList0_I m_Iterator;
  134.     };
  136.     class SPosLessSegment
  137.     {
  138.     public:
  139.         bool operator()(TSeqPos pos, const CSegment& seg)
  140.             {
  141.                 return pos < seg.m_Position + seg.m_Length;
  142.             }
  143.     };
  145. public:
  146.     typedef CSeqMap_CI CSegmentInfo; // for compatibility
  148.     typedef CSeqMap_CI const_iterator;
  149.     typedef CSeqMap_CI TSegment_CI;
  150.     
  151.     ~CSeqMap(void);
  153.     TSeqPos GetLength(CScope* scope = 0) const;
  154.     TMol GetMol(void) const;    
  156.     // new interface
  157.     // STL style methods
  158.     const_iterator begin(CScope* scope = 0) const;
  159.     const_iterator end(CScope* scope = 0) const;
  160.     const_iterator find(TSeqPos pos, CScope* scope = 0) const;
  161.     // NCBI style methods
  162.     TSegment_CI Begin(CScope* scope = 0) const;
  163.     TSegment_CI End(CScope* scope = 0) const;
  164.     TSegment_CI FindSegment(TSeqPos pos, CScope* scope = 0) const;
  166.     enum EFlags {
  167.         fFindData     = (1<<0),
  168.         fFindGap      = (1<<1),
  169.         fFindLeafRef  = (1<<2),
  170.         fFindInnerRef = (1<<3),
  171.         fFindRef      = (fFindLeafRef | fFindInnerRef),
  172.         fFindAny      = fFindData | fFindGap | fFindRef,
  173.         fFindAnyLeaf  = fFindData | fFindGap | fFindLeafRef,
  174.         fDefaultFlags = fFindAnyLeaf
  175.     };
  176.     typedef int TFlags;
  178.     // resolved iterators
  179.     const_iterator begin_resolved(CScope* scope,
  180.                                   size_t maxResolveCount = size_t(-1),
  181.                                   TFlags flags = fDefaultFlags) const;
  182.     const_iterator find_resolved(TSeqPos pos, CScope* scope,
  183.                                  size_t maxResolveCount = size_t(-1),
  184.                                  TFlags flags = fDefaultFlags) const;
  185.     const_iterator find_resolved(TSeqPos pos, CScope* scope,
  186.                                  ENa_strand strand,
  187.                                  size_t maxResolveCount,
  188.                                  TFlags flags) const;
  189.     const_iterator end_resolved(CScope* scope,
  190.                                 size_t maxResolveCount = size_t(-1),
  191.                                 TFlags flags = fDefaultFlags) const;
  193.     TSegment_CI BeginResolved(CScope* scope,
  194.                               size_t maxResolveCount = size_t(-1),
  195.                               TFlags flags = fDefaultFlags) const;
  196.     TSegment_CI FindResolved(TSeqPos pos, CScope* scope,
  197.                              size_t maxResolveCount = size_t(-1),
  198.                              TFlags flags = fDefaultFlags) const;
  199.     TSegment_CI FindResolved(TSeqPos pos, CScope* scope,
  200.                              ENa_strand strand,
  201.                              size_t maxResolveCount = size_t(-1),
  202.                              TFlags flags = fDefaultFlags) const;
  203.     TSegment_CI EndResolved(CScope* scope,
  204.                             size_t maxResolveCount = size_t(-1),
  205.                             TFlags flags = fDefaultFlags) const;
  207.     // iterate range with plus strand coordinates
  208.     TSegment_CI ResolvedRangeIterator(CScope* scope,
  209.                                       TSeqPos from,
  210.                                       TSeqPos length,
  211.                                       ENa_strand strand = eNa_strand_plus,
  212.                                       size_t maxResolve = size_t(-1),
  213.                                       TFlags flags = fDefaultFlags) const;
  214.     // iterate range with specified strand coordinates
  215.     TSegment_CI ResolvedRangeIterator(CScope* scope,
  216.                                       ENa_strand strand,
  217.                                       TSeqPos from,
  218.                                       TSeqPos length,
  219.                                       size_t maxResolve = size_t(-1),
  220.                                       TFlags flags = fDefaultFlags) const;
  221.     
  222.     bool CanResolveRange(CScope* scope,
  223.                          TSeqPos from,
  224.                          TSeqPos length,
  225.                          ENa_strand strand = eNa_strand_plus) const;
  227.     virtual void DebugDump(CDebugDumpContext ddc, unsigned int depth) const;
  229.     static CConstRef<CSeqMap> CreateSeqMapForBioseq(const CBioseq& seq);
  230.     static CConstRef<CSeqMap> CreateSeqMapForSeq_loc(const CSeq_loc& loc,
  231.                                                      CScope* scope);
  232.     static CConstRef<CSeqMap> CreateSeqMapForStrand(CConstRef<CSeqMap> seqMap,
  233.                                                     ENa_strand strand);
  235.     static TSeqPos ResolveBioseqLength(const CSeq_id& id, CScope* scope);
  237. protected:
  238.     // 'ctors
  239.     CSeqMap(CSeqMap* parent, size_t index);
  240.     CSeqMap(void);
  241.     CSeqMap(const CSeq_data& data, TSeqPos len);
  242.     CSeqMap(const CSeq_loc& ref);
  243.     CSeqMap(TSeqPos len); // gap
  245.     void x_AddEnd(void);
  246.     CSegment& x_AddSegment(ESegmentType type, TSeqPos len);
  247.     CSegment& x_AddSegment(ESegmentType type, TSeqPos len, const CObject* object);
  248.     CSegment& x_AddSegment(ESegmentType type, const CObject* object,
  249.                            TSeqPos refPos, TSeqPos len,
  250.                            ENa_strand strand = eNa_strand_plus);
  251.     CSegment& x_AddGap(TSeqPos len);
  252.     CSegment& x_Add(CSeqMap* submap);
  253.     CSegment& x_Add(const CSeq_data& data, TSeqPos len);
  254.     CSegment& x_Add(const CPacked_seqint& seq);
  255.     CSegment& x_Add(const CPacked_seqpnt& seq);
  256.     CSegment& x_Add(const CSeq_loc_mix& seq);
  257.     CSegment& x_Add(const CSeq_loc_equiv& seq);
  258.     CSegment& x_Add(const CSeq_literal& seq);
  259.     CSegment& x_Add(const CDelta_seq& seq);
  260.     CSegment& x_Add(const CSeq_loc& seq);
  261.     CSegment& x_Add(const CSeq_id& seq);
  262.     CSegment& x_Add(const CSeq_point& seq);
  263.     CSegment& x_Add(const CSeq_interval& seq);
  264.     CSegment& x_AddUnloadedSubMap(TSeqPos len);
  265.     CSegment& x_AddUnloadedSeq_data(TSeqPos len);
  267. private:
  268.     void ResolveAll(void) const;
  269.     
  270. private:
  271.     // Prohibit copy operator and constructor
  272.     CSeqMap(const CSeqMap&);
  273.     CSeqMap& operator= (const CSeqMap&);
  274.     
  275. protected:    
  276.     // interface for iterators
  277.     size_t x_GetSegmentsCount(void) const;
  278.     const CSegment& x_GetSegment(size_t index) const;
  279.     void x_GetSegmentException(size_t index) const;
  280.     CSegment& x_SetSegment(size_t index);
  281.     size_t x_FindSegment(TSeqPos position, CScope* scope) const;
  282.     
  283.     TSeqPos x_GetSegmentLength(size_t index, CScope* scope) const;
  284.     TSeqPos x_GetSegmentPosition(size_t index, CScope* scope) const;
  285.     TSeqPos x_ResolveSegmentLength(size_t index, CScope* scope) const;
  286.     TSeqPos x_ResolveSegmentPosition(size_t index, CScope* scope) const;
  287.     CBioseq_Handle x_GetBioseqHandle(const CSegment& seg, CScope* scope) const;
  289.     CConstRef<CSeqMap> x_GetSubSeqMap(const CSegment& seg, CScope* scope,
  290.                                       bool resolveExternal = false) const;
  291.     virtual const CSeq_data& x_GetSeq_data(const CSegment& seg) const;
  292.     virtual const CSeq_id& x_GetRefSeqid(const CSegment& seg) const;
  293.     virtual TSeqPos x_GetRefPosition(const CSegment& seg) const;
  294.     virtual bool x_GetRefMinusStrand(const CSegment& seg) const;
  295.     
  296.     void x_LoadObject(const CSegment& seg) const;
  297.     const CObject* x_GetObject(const CSegment& seg) const;
  298.     CObject* x_GetObject(CSegment& seg);
  299.     virtual void x_SetSeq_data(size_t index, CSeq_data& data);
  300.     virtual void x_SetSubSeqMap(size_t index, CSeqMap_Delta_seqs* subMap);
  302.     typedef vector<CSegment> TSegments;
  303.     
  304.     // segments in this seqmap
  305.     vector<CSegment> m_Segments;
  306.     
  307.     // index of last resolved segment position
  308.     mutable size_t   m_Resolved;
  309.     
  310.     CRef<CObject>    m_Delta;
  312.     // Molecule type from seq-inst
  313.     TMol    m_Mol;
  314.     // Sequence length
  315.     mutable TSeqPos m_SeqLength;
  317.     // MT-protection
  318.     mutable CFastMutex   m_SeqMap_Mtx;
  319.     
  320.     friend class CSeqMap_CI;
  321.     friend class CSeqMap_CI_SegmentInfo;
  322. };
  325. #include <objmgr/seq_map.inl>
  328. END_SCOPE(objects)
  329. END_NCBI_SCOPE
  331. /*
  332. * ---------------------------------------------------------------------------
  333. * $Log: seq_map.hpp,v $
  334. * Revision 1000.2  2004/04/12 17:27:48  gouriano
  335. * PRODUCTION: UPGRADED [CATCHUP_003] Dev-tree R1.44
  336. *
  337. * Revision 1.44  2004/03/16 15:47:26  vasilche
  338. * Added CBioseq_set_Handle and set of EditHandles
  339. *
  340. * Revision 1.43  2003/11/12 16:53:16  grichenk
  341. * Modified CSeqMap to work with const objects (CBioseq, CSeq_loc etc.)
  342. *
  343. * Revision 1.42  2003/09/30 16:21:59  vasilche
  344. * Updated internal object manager classes to be able to load ID2 data.
  345. * SNP blobs are loaded as ID2 split blobs - readers convert them automatically.
  346. * Scope caches results of requests for data to data loaders.
  347. * Optimized CSeq_id_Handle for gis.
  348. * Optimized bioseq lookup in scope.
  349. * Reduced object allocations in annotation iterators.
  350. * CScope is allowed to be destroyed before other objects using this scope are
  351. * deleted (feature iterators, bioseq handles etc).
  352. * Optimized lookup for matching Seq-ids in CSeq_id_Mapper.
  353. * Added 'adaptive' option to objmgr_demo application.
  354. *
  355. * Revision 1.41  2003/09/05 17:29:39  grichenk
  356. * Structurized Object Manager exceptions
  357. *
  358. * Revision 1.40  2003/07/17 19:10:27  grichenk
  359. * Added methods for seq-map and seq-vector validation,
  360. * updated demo.
  361. *
  362. * Revision 1.39  2003/06/26 19:47:25  grichenk
  363. * Added sequence length cache
  364. *
  365. * Revision 1.38  2003/06/24 14:22:46  vasilche
  366. * Fixed CSeqMap constructor from CSeq_loc.
  367. *
  368. * Revision 1.37  2003/06/11 19:32:53  grichenk
  369. * Added molecule type caching to CSeqMap, simplified
  370. * coding and sequence type calculations in CSeqVector.
  371. *
  372. * Revision 1.36  2003/06/10 19:06:34  vasilche
  373. * Simplified CSeq_id_Mapper and CSeq_id_Handle.
  374. *
  375. * Revision 1.35  2003/06/02 16:01:36  dicuccio
  376. * Rearranged include/objects/ subtree.  This includes the following shifts:
  377. *     - include/objects/alnmgr --> include/objtools/alnmgr
  378. *     - include/objects/cddalignview --> include/objtools/cddalignview
  379. *     - include/objects/flat --> include/objtools/flat
  380. *     - include/objects/objmgr/ --> include/objmgr/
  381. *     - include/objects/util/ --> include/objmgr/util/
  382. *     - include/objects/validator --> include/objtools/validator
  383. *
  384. * Revision 1.34  2003/05/20 20:36:13  vasilche
  385. * Added FindResolved() with strand argument.
  386. *
  387. * Revision 1.33  2003/02/24 18:57:21  vasilche
  388. * Make feature gathering in one linear pass using CSeqMap iterator.
  389. * Do not use feture index by sub locations.
  390. * Sort features at the end of gathering in one vector.
  391. * Extracted some internal structures and classes in separate header.
  392. * Delay creation of mapped features.
  393. *
  394. * Revision 1.32  2003/02/05 15:55:26  vasilche
  395. * Added eSeqEnd segment at the beginning of seq map.
  396. * Added flags to CSeqMap_CI to stop on data, gap, or references.
  397. *
  398. * Revision 1.31  2003/01/28 17:16:22  vasilche
  399. * Added CSeqMap::ResolvedRangeIterator with strand coordinate translation.
  400. *
  401. * Revision 1.30  2003/01/22 20:11:53  vasilche
  402. * Merged functionality of CSeqMapResolved_CI to CSeqMap_CI.
  403. * CSeqMap_CI now supports resolution and iteration over sequence range.
  404. * Added several caches to CScope.
  405. * Optimized CSeqVector().
  406. * Added serveral variants of CBioseqHandle::GetSeqVector().
  407. * Tried to optimize annotations iterator (not much success).
  408. * Rewritten CHandleRange and CHandleRangeMap classes to avoid sorting of list.
  409. *
  410. * Revision 1.29  2002/12/30 19:35:47  vasilche
  411. * Removed redundant friend declarations.
  412. *
  413. * Revision 1.28  2002/12/27 21:11:09  kuznets
  414. * Fixed Windows specific syntax problem in class CSeqMap::CSegment member
  415. * m_Iterator was an unnamed structure. For correct MSVC compilation must have
  416. * a type name.
  417. *
  418. * Revision 1.27  2002/12/27 19:32:46  ucko
  419. * Add forward declarations for nested classes so they can stay protected.
  420. *
  421. * Revision 1.26  2002/12/27 19:29:41  vasilche
  422. * Fixed access to protected class on WorkShop.
  423. *
  424. * Revision 1.25  2002/12/27 19:04:46  vasilche
  425. * Fixed segmentation fault on 64 bit platforms.
  426. *
  427. * Revision 1.24  2002/12/26 20:49:28  dicuccio
  428. * Wrapped previous unimplemented ctor in #ifdef for MSWIN only
  429. *
  430. * Revision 1.22  2002/12/26 16:39:21  vasilche
  431. * Object manager class CSeqMap rewritten.
  432. *
  433. * Revision 1.21  2002/10/18 19:12:39  grichenk
  434. * Removed mutex pools, converted most static mutexes to non-static.
  435. * Protected CSeqMap::x_Resolve() with mutex. Modified code to prevent
  436. * dead-locks.
  437. *
  438. * Revision 1.20  2002/07/08 20:50:56  grichenk
  439. * Moved log to the end of file
  440. * Replaced static mutex (in CScope, CDataSource) with the mutex
  441. * pool. Redesigned CDataSource data locking.
  442. *
  443. * Revision 1.19  2002/06/30 03:27:38  vakatov
  444. * Get rid of warnings, ident the code, move CVS logs to the end of file
  445. *
  446. * Revision 1.18  2002/05/29 21:19:57  gouriano
  447. * added debug dump
  448. *
  449. * Revision 1.17  2002/05/21 18:40:15  grichenk
  450. * Prohibited copy constructor and operator =()
  451. *
  452. * Revision 1.16  2002/05/06 03:30:36  vakatov
  453. * OM/OM1 renaming
  454. *
  455. * Revision 1.15  2002/05/03 21:28:02  ucko
  456. * Introduce T(Signed)SeqPos.
  457. *
  458. * Revision 1.14  2002/04/30 18:54:50  gouriano
  459. * added GetRefSeqid function
  460. *
  461. * Revision 1.13  2002/04/11 12:07:28  grichenk
  462. * Redesigned CAnnotTypes_CI to resolve segmented sequences correctly.
  463. *
  464. * Revision 1.12  2002/04/05 21:26:17  grichenk
  465. * Enabled iteration over annotations defined on segments of a
  466. * delta-sequence.
  467. *
  468. * Revision 1.11  2002/04/02 16:40:53  grichenk
  469. * Fixed literal segments handling
  470. *
  471. * Revision 1.10  2002/03/27 15:07:53  grichenk
  472. * Fixed CSeqMap::CSegmentInfo::operator==()
  473. *
  474. * Revision 1.9  2002/03/15 18:10:05  grichenk
  475. * Removed CRef<CSeq_id> from CSeq_id_Handle, added
  476. * key to seq-id map th CSeq_id_Mapper
  477. *
  478. * Revision 1.8  2002/03/08 21:25:30  gouriano
  479. * fixed errors with unresolvable references
  480. *
  481. * Revision 1.7  2002/02/25 21:05:26  grichenk
  482. * Removed seq-data references caching. Increased MT-safety. Fixed typos.
  483. *
  484. * Revision 1.6  2002/02/21 19:27:00  grichenk
  485. * Rearranged includes. Added scope history. Added searching for the
  486. * best seq-id match in data sources and scopes. Updated tests.
  487. *
  488. * Revision 1.5  2002/02/15 20:36:29  gouriano
  489. * changed implementation of HandleRangeMap
  490. *
  491. * Revision 1.4  2002/01/30 22:08:47  gouriano
  492. * changed CSeqMap interface
  493. *
  494. * Revision 1.3  2002/01/23 21:59:29  grichenk
  495. * Redesigned seq-id handles and mapper
  496. *
  497. * Revision 1.2  2002/01/16 16:26:37  gouriano
  498. * restructured objmgr
  499. *
  500. * Revision 1.1  2002/01/11 19:04:04  gouriano
  501. * restructured objmgr
  502. *
  503. * ===========================================================================
  504. */
  506. #endif  // OBJECTS_OBJMGR___SEQ_MAP__HPP