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

生物技术

开发平台:

C/C++

  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: seq_loc_cvt.hpp,v $
  4.  * PRODUCTION Revision 1000.4  2004/06/01 19:22:10  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.17
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  9. #ifndef SEQ_LOC_CVT__HPP
  10. #define SEQ_LOC_CVT__HPP
  11. /*  $Id: seq_loc_cvt.hpp,v 1000.4 2004/06/01 19:22:10 gouriano Exp $
  12. * ===========================================================================
  13. *
  14. *                            PUBLIC DOMAIN NOTICE
  15. *               National Center for Biotechnology Information
  16. *
  17. *  This software/database is a "United States Government Work" under the
  18. *  terms of the United States Copyright Act.  It was written as part of
  19. *  the author's official duties as a United States Government employee and
  20. *  thus cannot be copyrighted.  This software/database is freely available
  21. *  to the public for use. The National Library of Medicine and the U.S.
  22. *  Government have not placed any restriction on its use or reproduction.
  23. *
  24. *  Although all reasonable efforts have been taken to ensure the accuracy
  25. *  and reliability of the software and data, the NLM and the U.S.
  26. *  Government do not and cannot warrant the performance or results that
  27. *  may be obtained by using this software or data. The NLM and the U.S.
  28. *  Government disclaim all warranties, express or implied, including
  29. *  warranties of performance, merchantability or fitness for any particular
  30. *  purpose.
  31. *
  32. *  Please cite the author in any work or product based on this material.
  33. *
  34. * ===========================================================================
  35. *
  36. * Author: Aleksey Grichenko, Michael Kimelman, Eugene Vasilchenko
  37. *
  38. * File Description:
  39. *   Object manager iterators
  40. *
  41. */
  42. #include <corelib/ncbiobj.hpp>
  43. #include <util/range.hpp>
  44. #include <util/rangemap.hpp>
  45. #include <objmgr/seq_id_handle.hpp>
  46. #include <objmgr/impl/heap_scope.hpp>
  47. #include <objects/seqloc/Na_strand.hpp>
  48. #include <objects/seqloc/Seq_loc.hpp>
  49. #include <objects/seqloc/Seq_point.hpp>
  50. #include <objects/seqloc/Seq_interval.hpp>
  51. BEGIN_NCBI_SCOPE
  52. BEGIN_SCOPE(objects)
  53. class CSeqMap_CI;
  54. class CScope;
  55. class CSeq_align_Mapper;
  56. class CAnnotObject_Ref;
  57. class CSeq_id;
  58. class CSeq_loc;
  59. class CSeq_interval;
  60. class CSeq_point;
  61. class CSeq_align;
  62. class CDense_seg;
  63. class CPacked_seg;
  64. class CSeq_align_set;
  65. /////////////////////////////////////////////////////////////////////////////
  66. // CSeq_loc_Conversion
  67. /////////////////////////////////////////////////////////////////////////////
  68. class CSeq_loc_Conversion : public CObject
  69. {
  70. public:
  71.     typedef CRange<TSeqPos> TRange;
  72.     CSeq_loc_Conversion(CSeq_loc& master_loc_empty,
  73.                         const CSeq_id_Handle& dst_id,
  74.                         const CSeqMap_CI& seg,
  75.                         const CSeq_id_Handle& src_id,
  76.                         CScope* scope);
  77.     // Create conversion, mapping an ID to itself
  78.     CSeq_loc_Conversion(const CSeq_id_Handle& master_id,
  79.                         CScope* scope);
  80.     ~CSeq_loc_Conversion(void);
  81.     TSeqPos ConvertPos(TSeqPos src_pos);
  82.     bool GoodSrcId(const CSeq_id& id);
  83.     bool MinusStrand(void) const
  84.         {
  85.             return m_Reverse;
  86.         }
  87.     bool ConvertPoint(TSeqPos src_pos, ENa_strand src_strand);
  88.     bool ConvertPoint(const CSeq_point& src);
  89.     bool ConvertInterval(TSeqPos src_from, TSeqPos src_to,
  90.                          ENa_strand src_strand);
  91.     bool ConvertInterval(const CSeq_interval& src);
  92.     enum EConvertFlag {
  93.         eCnvDefault,
  94.         eCnvAlways
  95.     };
  96.     enum ELocationType {
  97.         eLocation,
  98.         eProduct
  99.     };
  100.     bool Convert(const CSeq_loc& src, CRef<CSeq_loc>* dst,
  101.                  EConvertFlag flag = eCnvDefault);
  102.     void Convert(CAnnotObject_Ref& obj, ELocationType loctype);
  103.     void Reset(void);
  104.     bool IsPartial(void) const
  105.         {
  106.             return m_Partial;
  107.         }
  108.     void SetSrcId(const CSeq_id_Handle& src)
  109.         {
  110.             m_Src_id_Handle = src;
  111.         }
  112.     void SetConversion(const CSeqMap_CI& seg);
  113.     const TRange& GetTotalRange(void) const
  114.         {
  115.             return m_TotalRange;
  116.         }
  117.     
  118.     ENa_strand ConvertStrand(ENa_strand strand) const;
  119.     void SetMappedLocation(CAnnotObject_Ref& ref, ELocationType loctype);
  120. private:
  121.     void CheckDstInterval(void);
  122.     void CheckDstPoint(void);
  123.     CRef<CSeq_interval> GetDstInterval(void);
  124.     CRef<CSeq_point> GetDstPoint(void);
  125.     void SetDstLoc(CRef<CSeq_loc>* loc);
  126.     bool IsSpecialLoc(void) const;
  127.     CSeq_loc& GetDstLocEmpty(void)
  128.         {
  129.             return *m_Dst_loc_Empty;
  130.         }
  131.     CSeq_id& GetDstId(void)
  132.         {
  133.             return m_Dst_loc_Empty->SetEmpty();
  134.         }
  135.     // Translation parameters:
  136.     //   Source id and bounds:
  137.     CSeq_id_Handle m_Src_id_Handle;
  138.     TSeqPos        m_Src_from;
  139.     TSeqPos        m_Src_to;
  140.     //   Source to destination shift:
  141.     TSignedSeqPos  m_Shift;
  142.     bool           m_Reverse;
  143.     //   Destination id:
  144.     CSeq_id_Handle m_Dst_id_Handle;
  145.     CRef<CSeq_loc> m_Dst_loc_Empty;
  146.     // Results:
  147.     //   Cumulative results on destination:
  148.     TRange         m_TotalRange;
  149.     bool           m_Partial;
  150.     
  151.     //   Last Point, Interval or other simple location's conversion result:
  152.     enum EMappedObjectType {
  153.         eMappedObjType_not_set,
  154.         eMappedObjType_Seq_loc,
  155.         eMappedObjType_Seq_point,
  156.         eMappedObjType_Seq_interval
  157.     };
  158.     EMappedObjectType m_LastType;
  159.     TRange         m_LastRange;
  160.     ENa_strand     m_LastStrand;
  161.     // Scope for id resolution:
  162.     CHeapScope     m_Scope;
  163.     friend class CSeq_loc_Conversion_Set;
  164.     friend class CSeq_align_Mapper;
  165.     friend struct CConversionRef_Less;
  166. };
  167. class CSeq_loc_Conversion_Set : public CObject
  168. {
  169. public:
  170.     CSeq_loc_Conversion_Set(CHeapScope& scope);
  171.     typedef CRange<TSeqPos> TRange;
  172.     typedef CRangeMultimap<CRef<CSeq_loc_Conversion>, TSeqPos> TRangeMap;
  173.     typedef TRangeMap::iterator TRangeIterator;
  174.     typedef map<CSeq_id_Handle, TRangeMap> TIdMap;
  175.     // Conversions by location index
  176.     typedef map<unsigned int, TIdMap> TConvByIndex;
  177.     void Add(CSeq_loc_Conversion& cvt, unsigned int loc_index);
  178.     TRangeIterator BeginRanges(CSeq_id_Handle id,
  179.                                TSeqPos from,
  180.                                TSeqPos to,
  181.                                unsigned int loc_index);
  182.     void Convert(CAnnotObject_Ref& obj,
  183.                  CSeq_loc_Conversion::ELocationType loctype);
  184.     bool Convert(const CSeq_loc& src,
  185.                  CRef<CSeq_loc>* dst,
  186.                  unsigned int loc_index);
  187.     void Convert(const CSeq_align& src, CRef<CSeq_align>* dst);
  188. private:
  189.     friend class CSeq_align_Mapper;
  190.     bool ConvertPoint(const CSeq_point& src,
  191.                       CRef<CSeq_loc>* dst,
  192.                       unsigned int loc_index);
  193.     bool ConvertInterval(const CSeq_interval& src,
  194.                          CRef<CSeq_loc>* dst,
  195.                          unsigned int loc_index);
  196.     CRef<CSeq_loc_Conversion> m_SingleConv;
  197.     unsigned int              m_SingleIndex;
  198.     TConvByIndex m_CvtByIndex;
  199.     bool         m_Partial;
  200.     TRange       m_TotalRange;
  201.     CHeapScope   m_Scope;
  202. };
  203. inline
  204. bool CSeq_loc_Conversion::IsSpecialLoc(void) const
  205. {
  206.     return m_LastType == eMappedObjType_Seq_point ||
  207.         m_LastType == eMappedObjType_Seq_interval;
  208. }
  209. inline
  210. void CSeq_loc_Conversion::Reset(void)
  211. {
  212.     _ASSERT(!IsSpecialLoc());
  213.     m_TotalRange = TRange::GetEmpty();
  214.     m_Partial = false;
  215. }
  216. inline
  217. TSeqPos CSeq_loc_Conversion::ConvertPos(TSeqPos src_pos)
  218. {
  219.     if ( src_pos < m_Src_from || src_pos > m_Src_to ) {
  220.         m_Partial = true;
  221.         return kInvalidSeqPos;
  222.     }
  223.     TSeqPos dst_pos;
  224.     if ( !m_Reverse ) {
  225.         dst_pos = m_Shift + src_pos;
  226.     }
  227.     else {
  228.         dst_pos = m_Shift - src_pos;
  229.     }
  230.     return dst_pos;
  231. }
  232. inline
  233. bool CSeq_loc_Conversion::GoodSrcId(const CSeq_id& id)
  234. {
  235.     bool good = (m_Src_id_Handle == id);
  236.     if ( !good ) {
  237.         m_Partial = true;
  238.     }
  239.     return good;
  240. }
  241. inline
  242. ENa_strand CSeq_loc_Conversion::ConvertStrand(ENa_strand strand) const
  243. {
  244.     if ( m_Reverse ) {
  245.         strand = Reverse(strand);
  246.     }
  247.     return strand;
  248. }
  249. inline
  250. bool CSeq_loc_Conversion::ConvertPoint(const CSeq_point& src)
  251. {
  252.     ENa_strand strand = src.IsSetStrand()? src.GetStrand(): eNa_strand_unknown;
  253.     return GoodSrcId(src.GetId()) && ConvertPoint(src.GetPoint(), strand);
  254. }
  255. inline
  256. bool CSeq_loc_Conversion::ConvertInterval(const CSeq_interval& src)
  257. {
  258.     ENa_strand strand = src.IsSetStrand()? src.GetStrand(): eNa_strand_unknown;
  259.     return GoodSrcId(src.GetId()) && ConvertInterval(src.GetFrom(), src.GetTo(), strand);
  260. }
  261. END_SCOPE(objects)
  262. END_NCBI_SCOPE
  263. /*
  264. * ---------------------------------------------------------------------------
  265. * $Log: seq_loc_cvt.hpp,v $
  266. * Revision 1000.4  2004/06/01 19:22:10  gouriano
  267. * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.17
  268. *
  269. * Revision 1.17  2004/05/26 14:29:20  grichenk
  270. * Redesigned CSeq_align_Mapper: preserve non-mapping intervals,
  271. * fixed strands handling, improved performance.
  272. *
  273. * Revision 1.16  2004/05/10 18:26:37  grichenk
  274. * Fixed 'not used' warnings
  275. *
  276. * Revision 1.15  2004/03/30 21:21:09  grichenk
  277. * Reduced number of includes.
  278. *
  279. * Revision 1.14  2004/03/30 15:42:33  grichenk
  280. * Moved alignment mapper to separate file, added alignment mapping
  281. * to CSeq_loc_Mapper.
  282. *
  283. * Revision 1.13  2004/03/16 15:47:27  vasilche
  284. * Added CBioseq_set_Handle and set of EditHandles
  285. *
  286. * Revision 1.12  2004/02/23 15:23:16  grichenk
  287. * Removed unused members
  288. *
  289. * Revision 1.11  2004/02/06 16:07:26  grichenk
  290. * Added CBioseq_Handle::GetSeq_entry_Handle()
  291. * Fixed MapLocation()
  292. *
  293. * Revision 1.10  2004/01/30 15:25:44  grichenk
  294. * Fixed alignments mapping and sorting
  295. *
  296. * Revision 1.9  2004/01/28 20:54:35  vasilche
  297. * Fixed mapping of annotations.
  298. *
  299. * Revision 1.8  2004/01/23 16:14:46  grichenk
  300. * Implemented alignment mapping
  301. *
  302. * Revision 1.7  2003/11/10 18:11:03  grichenk
  303. * Moved CSeq_loc_Conversion_Set to seq_loc_cvt
  304. *
  305. * Revision 1.6  2003/11/04 16:21:36  grichenk
  306. * Updated CAnnotTypes_CI to map whole features instead of splitting
  307. * them by sequence segments.
  308. *
  309. * Revision 1.5  2003/10/27 20:07:10  vasilche
  310. * Started implementation of full annotations' mapping.
  311. *
  312. * Revision 1.4  2003/09/30 16:22:01  vasilche
  313. * Updated internal object manager classes to be able to load ID2 data.
  314. * SNP blobs are loaded as ID2 split blobs - readers convert them automatically.
  315. * Scope caches results of requests for data to data loaders.
  316. * Optimized CSeq_id_Handle for gis.
  317. * Optimized bioseq lookup in scope.
  318. * Reduced object allocations in annotation iterators.
  319. * CScope is allowed to be destroyed before other objects using this scope are
  320. * deleted (feature iterators, bioseq handles etc).
  321. * Optimized lookup for matching Seq-ids in CSeq_id_Mapper.
  322. * Added 'adaptive' option to objmgr_demo application.
  323. *
  324. * Revision 1.3  2003/08/27 14:28:51  vasilche
  325. * Reduce amount of object allocations in feature iteration.
  326. *
  327. * Revision 1.2  2003/08/15 19:19:15  vasilche
  328. * Fixed memory leak in string packing hooks.
  329. * Fixed processing of 'partial' flag of features.
  330. * Allow table packing of non-point SNP.
  331. * Allow table packing of SNP with long alleles.
  332. *
  333. * Revision 1.1  2003/08/14 20:05:18  vasilche
  334. * Simple SNP features are stored as table internally.
  335. * They are recreated when needed using CFeat_CI.
  336. *
  337. * ===========================================================================
  338. */
  339. #endif  // ANNOT_TYPES_CI__HPP