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

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

生物技术

开发平台：

C/C++

annot_collector.hpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: annot_collector.hpp,v $
  4.  * PRODUCTION Revision 1000.2  2004/06/01 19:21:50  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.6
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. #ifndef ANNOT_COLLECTOR__HPP
  11. #define ANNOT_COLLECTOR__HPP
  13. /*  $Id: annot_collector.hpp,v 1000.2 2004/06/01 19:21:50 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. * Author: Aleksey Grichenko, Michael Kimelman, Eugene Vasilchenko
  39. *
  40. * File Description:
  41. *   Annotation collector for annot iterators
  42. *
  43. */
  45. #include <corelib/ncbiobj.hpp>
  46. #include <objmgr/scope.hpp>
  47. #include <objmgr/annot_selector.hpp>
  49. #include <objects/seqloc/Seq_loc.hpp>
  51. #include <set>
  52. #include <vector>
  53. #include <memory>
  55. BEGIN_NCBI_SCOPE
  57. class CReadLockGuard;
  59. BEGIN_SCOPE(objects)
  61. class CHandleRangeMap;
  62. class CHandleRange;
  63. struct SAnnotObject_Index;
  64. class CSeq_annot_SNP_Info;
  65. struct SSNP_Info;
  66. struct SIdAnnotObjs;
  67. class CSeq_loc_Conversion;
  68. class CSeq_loc_Conversion_Set;
  69. // class CSeq_align_Mapper;
  71. class NCBI_XOBJMGR_EXPORT CAnnotObject_Ref
  72. {
  73. public:
  74.     typedef CRange<TSeqPos> TRange;
  76.     CAnnotObject_Ref(void);
  77.     CAnnotObject_Ref(const CAnnotObject_Info& object);
  78.     CAnnotObject_Ref(const CSeq_annot_SNP_Info& snp_info, TSeqPos index);
  79.     ~CAnnotObject_Ref(void);
  81.     enum EObjectType {
  82.         eType_null,
  83.         eType_Seq_annot_Info,
  84.         eType_Seq_annot_SNP_Info
  85.     };
  87.     enum FMappedFlags {
  88.         fMapped_Partial   = 1<<0,
  89.         fMapped_Product   = 1<<1,
  90.         fMapped_Seq_point = 1<<2
  91.     };
  93.     enum EMappedObjectType {
  94.         eMappedObjType_not_set,
  95.         eMappedObjType_Seq_loc,
  96.         eMappedObjType_Seq_id,
  97.         eMappedObjType_Seq_align,
  98.         eMappedObjType_Seq_loc_Conv_Set
  99.     };
  101.     EObjectType GetObjectType(void) const;
  103.     const CSeq_annot_Info& GetSeq_annot_Info(void) const;
  104.     const CSeq_annot_SNP_Info& GetSeq_annot_SNP_Info(void) const;
  106.     const CAnnotObject_Info& GetAnnotObject_Info(void) const;
  107.     const SSNP_Info& GetSNP_Info(void) const;
  109.     EMappedObjectType GetMappedObjectType(void) const;
  111.     TSeqPos GetFrom(void) const;
  112.     TSeqPos GetToOpen(void) const;
  113.     const TRange& GetTotalRange(void) const;
  115.     bool IsPartial(void) const;
  116.     bool IsProduct(void) const;
  117.     bool IsMappedPoint(void) const;
  118.     void SetProduct(bool product);
  120.     ENa_strand GetMappedStrand(void) const;
  122.     bool IsFeat(void) const;
  123.     bool IsSNPFeat(void) const;
  124.     bool IsGraph(void) const;
  125.     bool IsAlign(void) const;
  126.     const CSeq_feat& GetFeat(void) const;
  127.     const CSeq_graph& GetGraph(void) const;
  128.     const CSeq_align& GetAlign(void) const;
  130.     bool IsMapped(void) const;
  131.     bool IsMappedLocation(void) const;
  132.     bool IsMappedProduct(void) const;
  134.     bool MappedSeq_locNeedsUpdate(void) const;
  136.     const CSeq_loc& GetMappedSeq_loc(void) const;
  137.     const CSeq_id& GetMappedSeq_id(void) const;
  138.     const CSeq_align& GetMappedSeq_align(void) const;
  140.     unsigned int GetAnnotObjectIndex(void) const;
  142.     void UpdateMappedSeq_loc(CRef<CSeq_loc>& loc) const;
  143.     void UpdateMappedSeq_loc(CRef<CSeq_loc>&      loc,
  144.                              CRef<CSeq_point>&    pnt_ref,
  145.                              CRef<CSeq_interval>& int_ref) const;
  147.     void SetAnnotObjectRange(const TRange& range, bool product);
  148.     void SetSNP_Point(const SSNP_Info& snp, CSeq_loc_Conversion* cvt);
  150.     void SetPartial(bool value);
  151.     void SetMappedSeq_loc(CSeq_loc& loc);
  152.     void SetMappedSeq_loc(CSeq_loc* loc);
  153.     void SetMappedSeq_id(CSeq_id& id);
  154.     void SetMappedPoint(bool point);
  155.     void SetMappedSeq_id(CSeq_id& id, bool point);
  156.     void SetMappedSeq_align(CSeq_align* align);
  157.     void SetMappedSeq_align_Cvts(CSeq_loc_Conversion_Set& cvts);
  158.     void SetTotalRange(const TRange& range);
  159.     void SetMappedStrand(ENa_strand strand);
  161.     void ResetLocation(void);
  162.     bool operator<(const CAnnotObject_Ref& ref) const; // sort by object
  164. private:
  165.     CConstRef<CObject>      m_Object;
  166.     CRef<CObject>           m_MappedObject; // master sequence coordinates
  167.     TRange                  m_TotalRange;
  168.     unsigned int            m_AnnotObject_Index;
  169.     Int1                    m_ObjectType; // EObjectType
  170.     Int1                    m_MappedFlags; // partial, product
  171.     Int1                    m_MappedObjectType;
  172.     Int1                    m_MappedStrand;
  173. };
  176. class CSeq_annot_Handle;
  179. class CAnnotMappingCollector;
  182. class CAnnot_Collector : public CObject
  183. {
  184. public:
  185.     CAnnot_Collector(const SAnnotSelector& selector,
  186.                         CScope&               scope);
  187.     ~CAnnot_Collector(void);
  189. private:
  190.     CAnnot_Collector(const CAnnot_Collector&);
  191.     CAnnot_Collector& operator= (const CAnnot_Collector&);
  193.     typedef CConstRef<CTSE_Info> TTSE_Lock;
  194.     typedef set<TTSE_Lock>       TTSE_LockSet;
  195.     typedef vector<CAnnotObject_Ref> TAnnotSet;
  197.     const TAnnotSet& GetAnnotSet(void) const;
  198.     CScope& GetScope(void) const;
  200.     SAnnotSelector& GetSelector(void);
  202.     void x_Clear(void);
  203.     void x_Initialize(const CBioseq_Handle& bioseq,
  204.                       TSeqPos start, TSeqPos stop);
  205.     void x_Initialize(const CHandleRangeMap& master_loc);
  206.     void x_Initialize(void);
  207.     void x_GetTSE_Info(void);
  208.     bool x_SearchMapped(const CSeqMap_CI& seg,
  209.                         CSeq_loc& master_loc_empty,
  210.                         const CSeq_id_Handle& master_id,
  211.                         const CHandleRange& master_hr);
  212.     bool x_Search(const CHandleRangeMap& loc,
  213.                   CSeq_loc_Conversion* cvt);
  214.     bool x_Search(const CSeq_id_Handle& id,
  215.                   const CBioseq_Handle& bh,
  216.                   const CHandleRange& hr,
  217.                   CSeq_loc_Conversion* cvt);
  218.     bool x_Search(const TTSE_LockSet& tse_set,
  219.                   const CSeq_id_Handle& id,
  220.                   const CHandleRange& hr,
  221.                   CSeq_loc_Conversion* cvt);
  222.     void x_Search(const CTSE_Info& tse_info,
  223.                   const SIdAnnotObjs* objs,
  224.                   CReadLockGuard& guard,
  225.                   const CAnnotName& name,
  226.                   const CSeq_id_Handle& id,
  227.                   const CHandleRange& hr,
  228.                   CSeq_loc_Conversion* cvt);
  229.     void x_SearchRange(const CTSE_Info& tse_info,
  230.                        const SIdAnnotObjs* objs,
  231.                        CReadLockGuard& guard,
  232.                        const CAnnotName& name,
  233.                        const CSeq_id_Handle& id,
  234.                        const CHandleRange& hr,
  235.                        CSeq_loc_Conversion* cvt,
  236.                        size_t from_idx, size_t to_idx);
  237.     void x_SearchAll(void);
  238.     void x_SearchAll(const CSeq_entry_Info& entry_info);
  239.     void x_SearchAll(const CSeq_annot_Info& annot_info);
  240.     void x_Sort(void);
  241.     
  242.     bool x_AddObjectMapping(CAnnotObject_Ref& object_ref,
  243.                             CSeq_loc_Conversion* cvt,
  244.                             unsigned int loc_index);
  245.     bool x_AddObject(CAnnotObject_Ref& object_ref);
  246.     bool x_AddObject(CAnnotObject_Ref& object_ref,
  247.                      CSeq_loc_Conversion* cvt,
  248.                      unsigned int loc_index);
  250.     // Release all locked resources TSE etc
  251.     void x_ReleaseAll(void);
  253.     bool x_NeedSNPs(void) const;
  254.     bool x_MatchLimitObject(const CAnnotObject_Info& annot_info) const;
  255.     bool x_MatchRange(const CHandleRange& hr,
  256.                       const CRange<TSeqPos>& range,
  257.                       const SAnnotObject_Index& index) const;
  258.     bool x_MatchLocIndex(const SAnnotObject_Index& index) const;
  260.     size_t x_GetAnnotCount(void) const;
  262.     SAnnotSelector                   m_Selector;
  263.     CHeapScope                       m_Scope;
  264.     // TSE set to keep all the TSEs locked
  265.     TTSE_LockSet                     m_TSE_LockSet;
  266.     auto_ptr<CAnnotMappingCollector> m_MappingCollector;
  267.     // Set of all the annotations found
  268.     TAnnotSet                        m_AnnotSet;
  270.     // Temporary objects to be re-used by iterators
  271.     CRef<CSeq_feat>      m_CreatedOriginalSeq_feat;
  272.     CRef<CSeq_point>     m_CreatedOriginalSeq_point;
  273.     CRef<CSeq_interval>  m_CreatedOriginalSeq_interval;
  274.     CRef<CSeq_feat>      m_CreatedMappedSeq_feat;
  275.     CRef<CSeq_loc>       m_CreatedMappedSeq_loc;
  276.     CRef<CSeq_point>     m_CreatedMappedSeq_point;
  277.     CRef<CSeq_interval>  m_CreatedMappedSeq_interval;
  279.     friend class CAnnotTypes_CI;
  280.     friend class CMappedFeat;
  281.     friend class CMappedGraph;
  282. };
  285. /////////////////////////////////////////////////////////////////////////////
  286. // CAnnotObject_Ref
  287. /////////////////////////////////////////////////////////////////////////////
  289. inline
  290. CAnnotObject_Ref::CAnnotObject_Ref(void)
  291.     : m_AnnotObject_Index(0),
  292.       m_ObjectType(eType_null),
  293.       m_MappedFlags(0),
  294.       m_MappedObjectType(CSeq_loc::e_not_set),
  295.       m_MappedStrand(eNa_strand_unknown)
  296. {
  297. }
  300. inline
  301. CAnnotObject_Ref::~CAnnotObject_Ref(void)
  302. {
  303. }
  306. inline
  307. CAnnotObject_Ref::EObjectType CAnnotObject_Ref::GetObjectType(void) const
  308. {
  309.     return EObjectType(m_ObjectType);
  310. }
  313. inline
  314. TSeqPos CAnnotObject_Ref::GetFrom(void) const
  315. {
  316.     return m_TotalRange.GetFrom();
  317. }
  320. inline
  321. TSeqPos CAnnotObject_Ref::GetToOpen(void) const
  322. {
  323.     return m_TotalRange.GetToOpen();
  324. }
  327. inline
  328. const CAnnotObject_Ref::TRange& CAnnotObject_Ref::GetTotalRange(void) const
  329. {
  330.     return m_TotalRange;
  331. }
  334. inline
  335. void CAnnotObject_Ref::SetTotalRange(const TRange& range)
  336. {
  337.     m_TotalRange = range;
  338. }
  341. inline
  342. unsigned int CAnnotObject_Ref::GetAnnotObjectIndex(void) const
  343. {
  344.     return m_AnnotObject_Index;
  345. }
  348. inline
  349. const CSeq_annot_Info& CAnnotObject_Ref::GetSeq_annot_Info(void) const
  350. {
  351.     _ASSERT(GetObjectType() == eType_Seq_annot_Info);
  352.     return reinterpret_cast<const CSeq_annot_Info&>(*m_Object);
  353. }
  356. inline
  357. const CSeq_annot_SNP_Info& CAnnotObject_Ref::GetSeq_annot_SNP_Info(void) const
  358. {
  359.     _ASSERT(GetObjectType() == eType_Seq_annot_SNP_Info);
  360.     return reinterpret_cast<const CSeq_annot_SNP_Info&>(*m_Object);
  361. }
  364. inline
  365. bool CAnnotObject_Ref::IsPartial(void) const
  366. {
  367.     return (m_MappedFlags & fMapped_Partial) != 0;
  368. }
  371. inline
  372. bool CAnnotObject_Ref::IsProduct(void) const
  373. {
  374.     return (m_MappedFlags & fMapped_Product) != 0;
  375. }
  378. inline
  379. ENa_strand CAnnotObject_Ref::GetMappedStrand(void) const
  380. {
  381.     return ENa_strand(m_MappedStrand);
  382. }
  385. inline
  386. void CAnnotObject_Ref::SetMappedStrand(ENa_strand strand)
  387. {
  388.     _ASSERT(IsMapped());
  389.     m_MappedStrand = strand;
  390. }
  393. inline
  394. CAnnotObject_Ref::EMappedObjectType
  395. CAnnotObject_Ref::GetMappedObjectType(void) const
  396. {
  397.     return EMappedObjectType(m_MappedObjectType);
  398. }
  401. inline
  402. bool CAnnotObject_Ref::IsMapped(void) const
  403. {
  404.     _ASSERT((GetMappedObjectType() == eMappedObjType_not_set) ==
  405.             !m_MappedObject);
  406.     return GetMappedObjectType() != eMappedObjType_not_set;
  408. }
  411. inline
  412. bool CAnnotObject_Ref::MappedSeq_locNeedsUpdate(void) const
  413. {
  414.     return GetMappedObjectType() == eMappedObjType_Seq_id;
  416. }
  419. inline
  420. bool CAnnotObject_Ref::IsMappedLocation(void) const
  421. {
  422.     return IsMapped() && !IsProduct();
  423. }
  426. inline
  427. bool CAnnotObject_Ref::IsMappedProduct(void) const
  428. {
  429.     return IsMapped() && IsProduct();
  430. }
  433. inline
  434. const CSeq_loc& CAnnotObject_Ref::GetMappedSeq_loc(void) const
  435. {
  436.     _ASSERT(GetMappedObjectType() == eMappedObjType_Seq_loc);
  437.     return static_cast<const CSeq_loc&>(*m_MappedObject);
  438. }
  441. inline
  442. const CSeq_id& CAnnotObject_Ref::GetMappedSeq_id(void) const
  443. {
  444.     _ASSERT(GetMappedObjectType() == eMappedObjType_Seq_id);
  445.     return static_cast<const CSeq_id&>(*m_MappedObject);
  446. }
  449. inline
  450. void CAnnotObject_Ref::SetMappedSeq_loc(CSeq_loc* loc)
  451. {
  452.     _ASSERT(!IsMapped());
  453.     m_MappedObject.Reset(loc);
  454.     m_MappedObjectType = loc? eMappedObjType_Seq_loc: eMappedObjType_not_set;
  455. }
  458. inline
  459. void CAnnotObject_Ref::SetMappedSeq_loc(CSeq_loc& loc)
  460. {
  461.     _ASSERT(!IsMapped());
  462.     m_MappedObject.Reset(&loc);
  463.     m_MappedObjectType = eMappedObjType_Seq_loc;
  464. }
  467. inline
  468. void CAnnotObject_Ref::SetMappedSeq_id(CSeq_id& id)
  469. {
  470.     _ASSERT(!IsMapped());
  471.     m_MappedObject.Reset(&id);
  472.     m_MappedObjectType = eMappedObjType_Seq_id;
  473. }
  476. inline
  477. void CAnnotObject_Ref::SetMappedPoint(bool point)
  478. {
  479.     _ASSERT(GetMappedObjectType() == eMappedObjType_Seq_id);
  480.     if ( point ) {
  481.         m_MappedFlags |= fMapped_Seq_point;
  482.     }
  483.     else {
  484.         m_MappedFlags &= ~fMapped_Seq_point;
  485.     }
  486. }
  489. inline
  490. bool CAnnotObject_Ref::IsMappedPoint(void) const
  491. {
  492.     _ASSERT(GetMappedObjectType() == eMappedObjType_Seq_id);
  493.     return (m_MappedFlags & fMapped_Seq_point) != 0;
  494. }
  497. inline
  498. void CAnnotObject_Ref::SetMappedSeq_id(CSeq_id& id, bool point)
  499. {
  500.     SetMappedSeq_id(id);
  501.     SetMappedPoint(point);
  502. }
  505. inline
  506. bool CAnnotObject_Ref::IsSNPFeat(void) const
  507. {
  508.     return GetObjectType() == eType_Seq_annot_SNP_Info;
  509. }
  512. inline
  513. void CAnnotObject_Ref::SetPartial(bool partial)
  514. {
  515.     if ( partial ) {
  516.         m_MappedFlags |= fMapped_Partial;
  517.     }
  518.     else {
  519.         m_MappedFlags &= ~fMapped_Partial;
  520.     }
  521. }
  524. inline
  525. void CAnnotObject_Ref::SetProduct(bool product)
  526. {
  527.     if ( product ) {
  528.         m_MappedFlags |= fMapped_Product;
  529.     }
  530.     else {
  531.         m_MappedFlags &= ~fMapped_Product;
  532.     }
  533. }
  536. inline
  537. void CAnnotObject_Ref::SetAnnotObjectRange(const TRange& range, bool product)
  538. {
  539.     m_TotalRange = range;
  540.     SetProduct(product);
  541. }
  544. inline
  545. void CAnnotObject_Ref::ResetLocation(void)
  546. {
  547.     m_TotalRange = TRange::GetEmpty();
  548.     m_MappedObject.Reset();
  549.     m_MappedObjectType = eMappedObjType_not_set;
  550.     m_MappedStrand = eNa_strand_unknown;
  551. }
  554. /////////////////////////////////////////////////////////////////////////////
  555. // CAnnot_Collector
  556. /////////////////////////////////////////////////////////////////////////////
  559. inline
  560. const CAnnot_Collector::TAnnotSet&
  561. CAnnot_Collector::GetAnnotSet(void) const
  562. {
  563.     return m_AnnotSet;
  564. }
  567. inline
  568. CScope& CAnnot_Collector::GetScope(void) const
  569. {
  570.     return m_Scope;
  571. }
  574. inline
  575. SAnnotSelector& CAnnot_Collector::GetSelector(void)
  576. {
  577.     return m_Selector;
  578. }
  581. END_SCOPE(objects)
  582. END_NCBI_SCOPE
  584. /*
  585. * ---------------------------------------------------------------------------
  586. * $Log: annot_collector.hpp,v $
  587. * Revision 1000.2  2004/06/01 19:21:50  gouriano
  588. * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.6
  589. *
  590. * Revision 1.6  2004/05/26 14:29:20  grichenk
  591. * Redesigned CSeq_align_Mapper: preserve non-mapping intervals,
  592. * fixed strands handling, improved performance.
  593. *
  594. * Revision 1.5  2004/05/11 17:45:24  grichenk
  595. * Removed declarations for SetMappedIndex() and SetMappedSeq_align_Mapper()
  596. *
  597. * Revision 1.4  2004/05/10 18:26:37  grichenk
  598. * Fixed 'not used' warnings
  599. *
  600. * Revision 1.3  2004/04/13 21:14:27  vasilche
  601. * Fixed wrong order of object deletion causing "tse is locked" error.
  602. *
  603. * Revision 1.2  2004/04/07 13:20:17  grichenk
  604. * Moved more data from iterators to CAnnot_Collector
  605. *
  606. * Revision 1.1  2004/04/05 15:54:25  grichenk
  607. * Initial revision
  608. *
  609. *
  610. * ===========================================================================
  611. */
  613. #endif  // ANNOT_COLLECTOR__HPP