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

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

生物技术

开发平台：

C/C++

seq_loc_cvt.cpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: seq_loc_cvt.cpp,v $
  4.  * PRODUCTION Revision 1000.5  2004/06/01 19:24:09  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.29
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. /*  $Id: seq_loc_cvt.cpp,v 1000.5 2004/06/01 19:24:09 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: Eugene Vasilchenko
  36. *
  37. * File Description:
  38. *   Class for mapping Seq-loc petween sequences.
  39. *
  40. */
  42. #include <ncbi_pch.hpp>
  43. #include <objmgr/impl/seq_loc_cvt.hpp>
  45. #include <objmgr/impl/seq_align_mapper.hpp>
  46. #include <objmgr/seq_map_ci.hpp>
  47. #include <objmgr/impl/scope_impl.hpp>
  48. #include <objmgr/annot_types_ci.hpp>
  50. #include <objects/seqloc/Seq_loc.hpp>
  51. #include <objects/seqloc/Seq_interval.hpp>
  52. #include <objects/seqloc/Seq_point.hpp>
  53. #include <objects/seqloc/Seq_loc_equiv.hpp>
  54. #include <objects/seqloc/Seq_bond.hpp>
  55. #include <objects/seqfeat/Seq_feat.hpp>
  57. BEGIN_NCBI_SCOPE
  58. BEGIN_SCOPE(objects)
  60. /////////////////////////////////////////////////////////////////////////////
  61. // CSeq_loc_Conversion
  62. /////////////////////////////////////////////////////////////////////////////
  64. CSeq_loc_Conversion::CSeq_loc_Conversion(CSeq_loc& master_loc_empty,
  65.                                          const CSeq_id_Handle& dst_id,
  66.                                          const CSeqMap_CI& seg,
  67.                                          const CSeq_id_Handle& src_id,
  68.                                          CScope* scope)
  69.     : m_Src_id_Handle(src_id),
  70.       m_Src_from(0),
  71.       m_Src_to(0),
  72.       m_Shift(0),
  73.       m_Reverse(false),
  74.       m_Dst_id_Handle(dst_id),
  75.       m_Dst_loc_Empty(&master_loc_empty),
  76.       m_Partial(false),
  77.       m_LastType(eMappedObjType_not_set),
  78.       m_LastStrand(eNa_strand_unknown),
  79.       m_Scope(scope)
  80. {
  81.     SetConversion(seg);
  82.     Reset();
  83. }
  86. CSeq_loc_Conversion::CSeq_loc_Conversion(const CSeq_id_Handle& master_id,
  87.                                          CScope* scope)
  88.     : m_Src_id_Handle(master_id),
  89.       m_Src_from(0),
  90.       m_Src_to(kInvalidSeqPos - 1),
  91.       m_Shift(0),
  92.       m_Reverse(false),
  93.       m_Dst_id_Handle(master_id),
  94.       m_Dst_loc_Empty(0),
  95.       m_Partial(false),
  96.       m_LastType(eMappedObjType_not_set),
  97.       m_LastStrand(eNa_strand_unknown),
  98.       m_Scope(scope)
  99. {
  100.     m_Dst_loc_Empty.Reset(new CSeq_loc);
  101.     m_Dst_loc_Empty->SetEmpty().Assign(*master_id.GetSeqId());
  102.     Reset();
  103. }
  106. CSeq_loc_Conversion::~CSeq_loc_Conversion(void)
  107. {
  108.     _ASSERT(!IsSpecialLoc());
  109. }
  112. void CSeq_loc_Conversion::SetConversion(const CSeqMap_CI& seg)
  113. {
  114.     m_Src_from = seg.GetRefPosition();
  115.     m_Src_to = m_Src_from + seg.GetLength() - 1;
  116.     m_Reverse = seg.GetRefMinusStrand();
  117.     if ( !m_Reverse ) {
  118.         m_Shift = seg.GetPosition() - m_Src_from;
  119.     }
  120.     else {
  121.         m_Shift = seg.GetPosition() + m_Src_to;
  122.     }
  123. }
  126. bool CSeq_loc_Conversion::ConvertPoint(TSeqPos src_pos,
  127.                                        ENa_strand src_strand)
  128. {
  129.     _ASSERT(!IsSpecialLoc());
  130.     if ( src_pos < m_Src_from || src_pos > m_Src_to ) {
  131.         m_Partial = true;
  132.         return false;
  133.     }
  134.     TSeqPos dst_pos;
  135.     if ( !m_Reverse ) {
  136.         m_LastStrand = src_strand;
  137.         dst_pos = m_Shift + src_pos;
  138.     }
  139.     else {
  140.         m_LastStrand = Reverse(src_strand);
  141.         dst_pos = m_Shift - src_pos;
  142.     }
  143.     m_LastType = eMappedObjType_Seq_point;
  144.     m_TotalRange += m_LastRange.SetFrom(dst_pos).SetTo(dst_pos);
  145.     return true;
  146. }
  149. bool CSeq_loc_Conversion::ConvertInterval(TSeqPos src_from, TSeqPos src_to,
  150.                                           ENa_strand src_strand)
  151. {
  152.     _ASSERT(!IsSpecialLoc());
  153.     if ( src_from < m_Src_from ) {
  154.         m_Partial = true;
  155.         src_from = m_Src_from;
  156.     }
  157.     if ( src_to > m_Src_to ) {
  158.         m_Partial = true;
  159.         src_to = m_Src_to;
  160.     }
  161.     if ( src_from > src_to ) {
  162.         return false;
  163.     }
  164.     TSeqPos dst_from, dst_to;
  165.     if ( !m_Reverse ) {
  166.         m_LastStrand = src_strand;
  167.         dst_from = m_Shift + src_from;
  168.         dst_to = m_Shift + src_to;
  169.     }
  170.     else {
  171.         m_LastStrand = Reverse(src_strand);
  172.         dst_from = m_Shift - src_to;
  173.         dst_to = m_Shift - src_from;
  174.     }
  175.     m_LastType = eMappedObjType_Seq_interval;
  176.     m_TotalRange += m_LastRange.SetFrom(dst_from).SetTo(dst_to);
  177.     return true;
  178. }
  181. inline
  182. void CSeq_loc_Conversion::CheckDstInterval(void)
  183. {
  184.     if ( m_LastType != eMappedObjType_Seq_interval ) {
  185.         NCBI_THROW(CAnnotException, eBadLocation,
  186.                    "Wrong last location type");
  187.     }
  188.     m_LastType = eMappedObjType_not_set;
  189. }
  192. inline
  193. void CSeq_loc_Conversion::CheckDstPoint(void)
  194. {
  195.     if ( m_LastType != eMappedObjType_Seq_point ) {
  196.         NCBI_THROW(CAnnotException, eBadLocation,
  197.                    "Wrong last location type");
  198.     }
  199.     m_LastType = eMappedObjType_not_set;
  200. }
  203. CRef<CSeq_interval> CSeq_loc_Conversion::GetDstInterval(void)
  204. {
  205.     CheckDstInterval();
  206.     CRef<CSeq_interval> ret(new CSeq_interval);
  207.     CSeq_interval& interval = *ret;
  208.     interval.SetId(GetDstId());
  209.     interval.SetFrom(m_LastRange.GetFrom());
  210.     interval.SetTo(m_LastRange.GetTo());
  211.     if ( m_LastStrand != eNa_strand_unknown ) {
  212.         interval.SetStrand(m_LastStrand);
  213.     }
  214.     return ret;
  215. }
  218. CRef<CSeq_point> CSeq_loc_Conversion::GetDstPoint(void)
  219. {
  220.     CheckDstPoint();
  221.     _ASSERT(m_LastRange.GetLength() == 1);
  222.     CRef<CSeq_point> ret(new CSeq_point);
  223.     CSeq_point& point = *ret;
  224.     point.SetId(GetDstId());
  225.     point.SetPoint(m_LastRange.GetFrom());
  226.     if ( m_LastStrand != eNa_strand_unknown ) {
  227.         point.SetStrand(m_LastStrand);
  228.     }
  229.     return ret;
  230. }
  233. void CSeq_loc_Conversion::SetDstLoc(CRef<CSeq_loc>* dst)
  234. {
  235.     CSeq_loc* loc = 0;
  236.     if ( !(*dst) ) {
  237.         switch ( m_LastType ) {
  238.         case eMappedObjType_Seq_interval:
  239.             dst->Reset(loc = new CSeq_loc);
  240.             loc->SetInt(*GetDstInterval());
  241.             break;
  242.         case eMappedObjType_Seq_point:
  243.             dst->Reset(loc = new CSeq_loc);
  244.             loc->SetPnt(*GetDstPoint());
  245.             break;
  246.         default:
  247.             _ASSERT(0);
  248.             break;
  249.         }
  250.     }
  251.     else {
  252.         _ASSERT(!IsSpecialLoc());
  253.     }
  254. }
  257. bool CSeq_loc_Conversion::Convert(const CSeq_loc& src, CRef<CSeq_loc>* dst,
  258.                                   EConvertFlag flag)
  259. {
  260.     dst->Reset();
  261.     CSeq_loc* loc = 0;
  262.     _ASSERT(!IsSpecialLoc());
  263.     m_LastType = eMappedObjType_Seq_loc;
  264.     switch ( src.Which() ) {
  265.     case CSeq_loc::e_not_set:
  266.     case CSeq_loc::e_Feat:
  267.         // Nothing to do, although this should never happen --
  268.         // the seq_loc is intersecting with the conv. loc.
  269.         _ASSERT("this cannot happen" && 0);
  270.         break;
  271.     case CSeq_loc::e_Null:
  272.     {
  273.         dst->Reset(loc = new CSeq_loc);
  274.         loc->SetNull();
  275.         break;
  276.     }
  277.     case CSeq_loc::e_Empty:
  278.     {
  279.         if ( GoodSrcId(src.GetEmpty()) ) {
  280.             dst->Reset(loc = new CSeq_loc);
  281.             loc->SetEmpty(GetDstId());
  282.         }
  283.         break;
  284.     }
  285.     case CSeq_loc::e_Whole:
  286.     {
  287.         const CSeq_id& src_id = src.GetWhole();
  288.         // Convert to the allowed master seq interval
  289.         if ( GoodSrcId(src_id) ) {
  290.             CBioseq_Handle bh = m_Scope->GetBioseqHandle(src_id,
  291.                 CScope::eGetBioseq_All);
  292.             ConvertInterval(0, bh.GetBioseqLength()-1, eNa_strand_unknown);
  293.         }
  294.         break;
  295.     }
  296.     case CSeq_loc::e_Int:
  297.     {
  298.         ConvertInterval(src.GetInt());
  299.         break;
  300.     }
  301.     case CSeq_loc::e_Pnt:
  302.     {
  303.         ConvertPoint(src.GetPnt());
  304.         break;
  305.     }
  306.     case CSeq_loc::e_Packed_int:
  307.     {
  308.         const CPacked_seqint::Tdata& src_ints = src.GetPacked_int().Get();
  309.         CPacked_seqint::Tdata* dst_ints = 0;
  310.         ITERATE ( CPacked_seqint::Tdata, i, src_ints ) {
  311.             if ( ConvertInterval(**i) ) {
  312.                 if ( !dst_ints ) {
  313.                     dst->Reset(loc = new CSeq_loc);
  314.                     dst_ints = &loc->SetPacked_int().Set();
  315.                 }
  316.                 dst_ints->push_back(GetDstInterval());
  317.             }
  318.         }
  319.         break;
  320.     }
  321.     case CSeq_loc::e_Packed_pnt:
  322.     {
  323.         const CPacked_seqpnt& src_pack_pnts = src.GetPacked_pnt();
  324.         if ( !GoodSrcId(src_pack_pnts.GetId()) ) {
  325.             break;
  326.         }
  327.         const CPacked_seqpnt::TPoints& src_pnts = src_pack_pnts.GetPoints();
  328.         CPacked_seqpnt::TPoints* dst_pnts = 0;
  329.         ITERATE ( CPacked_seqpnt::TPoints, i, src_pnts ) {
  330.             TSeqPos dst_pos = ConvertPos(*i);
  331.             if ( dst_pos != kInvalidSeqPos ) {
  332.                 if ( !dst_pnts ) {
  333.                     dst->Reset(loc = new CSeq_loc);
  334.                     CPacked_seqpnt& pnts = loc->SetPacked_pnt();
  335.                     pnts.SetId(GetDstId());
  336.                     dst_pnts = &pnts.SetPoints();
  337.                     if ( src_pack_pnts.IsSetStrand() ) {
  338.                         pnts.SetStrand(ConvertStrand(src_pack_pnts.GetStrand()));
  339.                     }
  340.                 }
  341.                 dst_pnts->push_back(dst_pos);
  342.                 m_TotalRange += TRange(dst_pos, dst_pos);
  343.             }
  344.         }
  345.         break;
  346.     }
  347.     case CSeq_loc::e_Mix:
  348.     {
  349.         const CSeq_loc_mix::Tdata& src_mix = src.GetMix().Get();
  350.         CSeq_loc_mix::Tdata* dst_mix = 0;
  351.         CRef<CSeq_loc> dst_loc;
  352.         ITERATE ( CSeq_loc_mix::Tdata, i, src_mix ) {
  353.             if ( Convert(**i, &dst_loc, eCnvAlways) ) {
  354.                 if ( !dst_mix ) {
  355.                     dst->Reset(loc = new CSeq_loc);
  356.                     dst_mix = &loc->SetMix().Set();
  357.                 }
  358.                 _ASSERT(dst_loc);
  359.                 dst_mix->push_back(dst_loc);
  360.             }
  361.         }
  362.         break;
  363.     }
  364.     case CSeq_loc::e_Equiv:
  365.     {
  366.         const CSeq_loc_equiv::Tdata& src_equiv = src.GetEquiv().Get();
  367.         CSeq_loc_equiv::Tdata* dst_equiv = 0;
  368.         CRef<CSeq_loc> dst_loc;
  369.         ITERATE ( CSeq_loc_equiv::Tdata, i, src_equiv ) {
  370.             if ( Convert(**i, &dst_loc, eCnvAlways) ) {
  371.                 if ( !dst_equiv ) {
  372.                     dst->Reset(loc = new CSeq_loc);
  373.                     dst_equiv = &loc->SetEquiv().Set();
  374.                 }
  375.                 dst_equiv->push_back(dst_loc);
  376.             }
  377.         }
  378.         break;
  379.     }
  380.     case CSeq_loc::e_Bond:
  381.     {
  382.         const CSeq_bond& src_bond = src.GetBond();
  383.         CSeq_bond* dst_bond = 0;
  384.         if ( ConvertPoint(src_bond.GetA()) ) {
  385.             dst->Reset(loc = new CSeq_loc);
  386.             dst_bond = &loc->SetBond();
  387.             dst_bond->SetA(*GetDstPoint());
  388.             if ( src_bond.IsSetB() ) {
  389.                 dst_bond->SetB().Assign(src_bond.GetB());
  390.             }
  391.         }
  392.         if ( src_bond.IsSetB() ) {
  393.             if ( ConvertPoint(src_bond.GetB()) ) {
  394.                 if ( !dst_bond ) {
  395.                     dst->Reset(loc = new CSeq_loc);
  396.                     dst_bond = &loc->SetBond();
  397.                     dst_bond->SetA().Assign(src_bond.GetA());
  398.                 }
  399.                 dst_bond->SetB(*GetDstPoint());
  400.             }
  401.         }
  402.         break;
  403.     }
  404.     default:
  405.         NCBI_THROW(CAnnotException, eBadLocation,
  406.                    "Unsupported location type");
  407.     }
  408.     if ( flag == eCnvAlways && IsSpecialLoc() ) {
  409.         SetDstLoc(dst);
  410.     }
  411.     return *dst;
  412. }
  415. void CSeq_loc_Conversion::Convert(CAnnotObject_Ref& ref, ELocationType loctype)
  416. {
  417.     Reset();
  418.     const CAnnotObject_Info& obj = ref.GetAnnotObject_Info();
  419.     switch ( obj.Which() ) {
  420.     case CSeq_annot::C_Data::e_Ftable:
  421.     {
  422.         CRef<CSeq_loc> mapped_loc;
  423.         const CSeq_loc* src_loc;
  424.         if ( loctype != eProduct ) {
  425.             src_loc = &obj.GetFeatFast()->GetLocation();
  426.         }
  427.         else {
  428.             src_loc = &obj.GetFeatFast()->GetProduct();
  429.         }
  430.         Convert(*src_loc, &mapped_loc);
  431.         ref.SetMappedSeq_loc(mapped_loc.GetPointerOrNull());
  432.         break;
  433.     }
  434.     case CSeq_annot::C_Data::e_Graph:
  435.     {
  436.         CRef<CSeq_loc> mapped_loc;
  437.         Convert(obj.GetGraphFast()->GetLoc(), &mapped_loc);
  438.         ref.SetMappedSeq_loc(mapped_loc.GetPointerOrNull());
  439.         break;
  440.     }
  441.     default:
  442.         _ASSERT(0);
  443.         break;
  444.     }
  445.     SetMappedLocation(ref, loctype);
  446. }
  449. void CSeq_loc_Conversion::SetMappedLocation(CAnnotObject_Ref& ref,
  450.                                             ELocationType loctype)
  451. {
  452.     ref.SetProduct(loctype == eProduct);
  453.     ref.SetPartial(m_Partial || ref.IsPartial());
  454.     ref.SetTotalRange(m_TotalRange);
  455.     if ( IsSpecialLoc() ) {
  456.         // special interval or point
  457.         ref.SetMappedSeq_id(GetDstId(),
  458.                             m_LastType == eMappedObjType_Seq_point);
  459.         ref.SetMappedStrand(m_LastStrand);
  460.         m_LastType = eMappedObjType_not_set;
  461.     }
  462. }
  465. /////////////////////////////////////////////////////////////////////////////
  466. // CSeq_loc_Conversion_Set
  467. /////////////////////////////////////////////////////////////////////////////
  470. CSeq_loc_Conversion_Set::CSeq_loc_Conversion_Set(CHeapScope& scope)
  471.     : m_SingleConv(0),
  472.       m_SingleIndex(0),
  473.       m_Partial(false),
  474.       m_TotalRange(TRange::GetEmpty()),
  475.       m_Scope(scope)
  476. {
  477.     return;
  478. }
  481. void CSeq_loc_Conversion_Set::Add(CSeq_loc_Conversion& cvt,
  482.                                   unsigned int loc_index)
  483. {
  484.     if (!m_SingleConv) {
  485.         m_SingleConv.Reset(&cvt);
  486.         m_SingleIndex = loc_index;
  487.         return;
  488.     }
  489.     else {
  490.         TIdMap& id_map = m_CvtByIndex[m_SingleIndex];
  491.         TRangeMap& ranges = id_map[m_SingleConv->m_Src_id_Handle];
  492.         ranges.insert(TRangeMap::value_type
  493.                       (TRange(cvt.m_Src_from, cvt.m_Src_to),
  494.                        m_SingleConv));
  495.     }
  496.     TIdMap& id_map = m_CvtByIndex[loc_index];
  497.     TRangeMap& ranges = id_map[cvt.m_Src_id_Handle];
  498.     ranges.insert(TRangeMap::value_type(TRange(cvt.m_Src_from, cvt.m_Src_to),
  499.                                         Ref(&cvt)));
  500. }
  503. CSeq_loc_Conversion_Set::TRangeIterator
  504. CSeq_loc_Conversion_Set::BeginRanges(CSeq_id_Handle id,
  505.                                      TSeqPos from,
  506.                                      TSeqPos to,
  507.                                      unsigned int loc_index)
  508. {
  509.     TIdMap::iterator ranges = m_CvtByIndex[loc_index].find(id);
  510.     if (ranges == m_CvtByIndex[loc_index].end()) {
  511.         return TRangeIterator();
  512.     }
  513.     return ranges->second.begin(TRange(from, to));
  514. }
  517. void CSeq_loc_Conversion_Set::Convert(CAnnotObject_Ref& ref,
  518.                                       CSeq_loc_Conversion::ELocationType
  519.                                       loctype)
  520. {
  521.     _ASSERT(m_SingleConv);
  522.     if (m_CvtByIndex.size() == 0  &&
  523.         !ref.IsAlign()) {
  524.         // No multiple mappings
  525.         m_SingleConv->Convert(ref, loctype);
  526.         return;
  527.     }
  528.     const CAnnotObject_Info& obj = ref.GetAnnotObject_Info();
  529.     switch ( obj.Which() ) {
  530.     case CSeq_annot::C_Data::e_Ftable:
  531.     {
  532.         CRef<CSeq_loc> mapped_loc;
  533.         const CSeq_loc* src_loc;
  534.         unsigned int loc_index = 0;
  535.         if ( loctype != CSeq_loc_Conversion::eProduct ) {
  536.             src_loc = &obj.GetFeatFast()->GetLocation();
  537.         }
  538.         else {
  539.             src_loc = &obj.GetFeatFast()->GetProduct();
  540.             loc_index = 1;
  541.         }
  542.         Convert(*src_loc, &mapped_loc, loc_index);
  543.         ref.SetMappedSeq_loc(mapped_loc.GetPointerOrNull());
  544.         break;
  545.     }
  546.     case CSeq_annot::C_Data::e_Graph:
  547.     {
  548.         CRef<CSeq_loc> mapped_loc;
  549.         Convert(obj.GetGraphFast()->GetLoc(), &mapped_loc, 0);
  550.         ref.SetMappedSeq_loc(mapped_loc.GetPointerOrNull());
  551.         break;
  552.     }
  553.     case CSeq_annot::C_Data::e_Align:
  554.     {
  555.         ref.SetMappedSeq_align_Cvts(*this);
  556.         break;
  557.     }
  558.     default:
  559.         _ASSERT(0);
  560.         break;
  561.     }
  562.     ref.SetProduct(loctype == CSeq_loc_Conversion::eProduct);
  563.     ref.SetPartial(m_Partial);
  564.     ref.SetTotalRange(m_TotalRange);
  565. }
  568. bool CSeq_loc_Conversion_Set::ConvertPoint(const CSeq_point& src,
  569.                                            CRef<CSeq_loc>* dst,
  570.                                            unsigned int loc_index)
  571. {
  572.     _ASSERT(*dst);
  573.     bool res = false;
  574.     TRangeIterator mit = BeginRanges(CSeq_id_Handle::GetHandle(src.GetId()),
  575.         src.GetPoint(), src.GetPoint(), loc_index);
  576.     for ( ; mit; ++mit) {
  577.         CSeq_loc_Conversion& cvt = *mit->second;
  578.         cvt.Reset();
  579.         if (cvt.ConvertPoint(src)) {
  580.             (*dst)->SetPnt(*cvt.GetDstPoint());
  581.             m_TotalRange += cvt.GetTotalRange();
  582.             res = true;
  583.             break;
  584.         }
  585.     }
  586.     m_Partial |= !res;
  587.     return res;
  588. }
  591. bool CSeq_loc_Conversion_Set::ConvertInterval(const CSeq_interval& src,
  592.                                               CRef<CSeq_loc>* dst,
  593.                                               unsigned int loc_index)
  594. {
  595.     _ASSERT(*dst);
  596.     CRef<CSeq_loc> tmp(new CSeq_loc);
  597.     CPacked_seqint::Tdata& ints = tmp->SetPacked_int().Set();
  598.     TRange total_range(TRange::GetEmpty());
  599.     bool revert_order = (src.IsSetStrand()
  600.         && src.GetStrand() == eNa_strand_minus);
  601.     bool res = false;
  602.     TRangeIterator mit = BeginRanges(CSeq_id_Handle::GetHandle(src.GetId()),
  603.         src.GetFrom(), src.GetTo(), loc_index);
  604.     for ( ; mit; ++mit) {
  605.         CSeq_loc_Conversion& cvt = *mit->second;
  606.         cvt.Reset();
  607.         if (cvt.ConvertInterval(src)) {
  608.             if (revert_order) {
  609.                 ints.push_front(cvt.GetDstInterval());
  610.             }
  611.             else {
  612.                 ints.push_back(cvt.GetDstInterval());
  613.             }
  614.             total_range += cvt.GetTotalRange();
  615.             res = true;
  616.         }
  617.     }
  618.     if (ints.size() > 1) {
  619.         dst->Reset(tmp);
  620.     }
  621.     else if (ints.size() == 1) {
  622.         (*dst)->SetInt(**ints.begin());
  623.     }
  624.     m_TotalRange += total_range;
  625.     // does not guarantee the whole interval is mapped, but should work
  626.     // in normal situations
  627.     m_Partial |= (!res  || src.GetLength() > total_range.GetLength());
  628.     return res;
  629. }
  632. bool CSeq_loc_Conversion_Set::Convert(const CSeq_loc& src,
  633.                                       CRef<CSeq_loc>* dst,
  634.                                       unsigned int loc_index)
  635. {
  636.     dst->Reset(new CSeq_loc);
  637.     bool res = false;
  638.     switch ( src.Which() ) {
  639.     case CSeq_loc::e_not_set:
  640.     case CSeq_loc::e_Feat:
  641.         // Nothing to do, although this should never happen --
  642.         // the seq_loc is intersecting with the conv. loc.
  643.         _ASSERT("this cannot happen" && 0);
  644.         break;
  645.     case CSeq_loc::e_Null:
  646.     {
  647.         (*dst)->SetNull();
  648.         res = true;
  649.         break;
  650.     }
  651.     case CSeq_loc::e_Empty:
  652.     {
  653.         TRangeIterator mit = BeginRanges(CSeq_id_Handle::GetHandle(src.GetEmpty()),
  654.                                          TRange::GetWhole().GetFrom(),
  655.                                          TRange::GetWhole().GetTo(),
  656.                                          loc_index);
  657.         for ( ; mit; ++mit) {
  658.             CSeq_loc_Conversion& cvt = *mit->second;
  659.             cvt.Reset();
  660.             if ( cvt.GoodSrcId(src.GetEmpty()) ) {
  661.                 (*dst)->SetEmpty(cvt.GetDstId());
  662.                 res = true;
  663.                 break;
  664.             }
  665.         }
  666.         break;
  667.     }
  668.     case CSeq_loc::e_Whole:
  669.     {
  670.         const CSeq_id& src_id = src.GetWhole();
  671.         // Convert to the allowed master seq interval
  672.         CSeq_interval whole_int;
  673.         whole_int.SetId().Assign(src_id);
  674.         whole_int.SetFrom(0);
  675.         CBioseq_Handle bh = m_Scope->GetBioseqHandle(src_id,
  676.             CScope::eGetBioseq_All);
  677.         whole_int.SetTo(bh.GetBioseqLength());
  678.         res = ConvertInterval(whole_int, dst, loc_index);
  679.         break;
  680.     }
  681.     case CSeq_loc::e_Int:
  682.     {
  683.         res = ConvertInterval(src.GetInt(), dst, loc_index);
  684.         break;
  685.     }
  686.     case CSeq_loc::e_Pnt:
  687.     {
  688.         res = ConvertPoint(src.GetPnt(), dst, loc_index);
  689.         break;
  690.     }
  691.     case CSeq_loc::e_Packed_int:
  692.     {
  693.         const CPacked_seqint::Tdata& src_ints = src.GetPacked_int().Get();
  694.         CPacked_seqint::Tdata& dst_ints = (*dst)->SetPacked_int().Set();
  695.         ITERATE ( CPacked_seqint::Tdata, i, src_ints ) {
  696.             CRef<CSeq_loc> dst_int(new CSeq_loc);
  697.             bool mapped = ConvertInterval(**i, &dst_int, loc_index);
  698.             if (mapped) {
  699.                 if ( dst_int->IsInt() ) {
  700.                     dst_ints.push_back(CRef<CSeq_interval>(&dst_int->SetInt()));
  701.                 }
  702.                 else if ( dst_int->IsPacked_int() ) {
  703.                     CPacked_seqint::Tdata& splitted = dst_int->SetPacked_int().Set();
  704.                     dst_ints.merge(splitted);
  705.                 }
  706.                 else {
  707.                     _ASSERT("this cannot happen" && 0);
  708.                 }
  709.             }
  710.             m_Partial |= !mapped;
  711.             res |= mapped;
  712.         }
  713.         break;
  714.     }
  715.     case CSeq_loc::e_Packed_pnt:
  716.     {
  717.         const CPacked_seqpnt& src_pack_pnts = src.GetPacked_pnt();
  718.         const CPacked_seqpnt::TPoints& src_pnts = src_pack_pnts.GetPoints();
  719.         CRef<CSeq_loc> tmp(new CSeq_loc);
  720.         // using mix, not point, since mappings may have
  721.         // different strand, fuzz etc.
  722.         CSeq_loc_mix::Tdata& locs = tmp->SetMix().Set();
  723.         ITERATE ( CPacked_seqpnt::TPoints, i, src_pnts ) {
  724.             bool mapped = false;
  725.             TRangeIterator mit = BeginRanges(
  726.                 CSeq_id_Handle::GetHandle(src_pack_pnts.GetId()),
  727.                 *i, *i,
  728.                 loc_index);
  729.             for ( ; mit; ++mit) {
  730.                 CSeq_loc_Conversion& cvt = *mit->second;
  731.                 cvt.Reset();
  732.                 if ( !cvt.GoodSrcId(src_pack_pnts.GetId()) ) {
  733.                     continue;
  734.                 }
  735.                 TSeqPos dst_pos = cvt.ConvertPos(*i);
  736.                 if ( dst_pos != kInvalidSeqPos ) {
  737.                     CRef<CSeq_loc> pnt(new CSeq_loc);
  738.                     pnt->SetPnt(*cvt.GetDstPoint());
  739.                     _ASSERT(pnt);
  740.                     locs.push_back(pnt);
  741.                     m_TotalRange += cvt.GetTotalRange();
  742.                     mapped = true;
  743.                     break;
  744.                 }
  745.             }
  746.             m_Partial |= !mapped;
  747.             res |= mapped;
  748.         }
  749.         break;
  750.     }
  751.     case CSeq_loc::e_Mix:
  752.     {
  753.         const CSeq_loc_mix::Tdata& src_mix = src.GetMix().Get();
  754.         CRef<CSeq_loc> dst_loc;
  755.         CSeq_loc_mix::Tdata& dst_mix = (*dst)->SetMix().Set();
  756.         ITERATE ( CSeq_loc_mix::Tdata, i, src_mix ) {
  757.             dst_loc.Reset(new CSeq_loc);
  758.             if ( Convert(**i, &dst_loc, loc_index) ) {
  759.                 _ASSERT(dst_loc);
  760.                 dst_mix.push_back(dst_loc);
  761.                 res = true;
  762.             }
  763.         }
  764.         m_Partial |= !res;
  765.         break;
  766.     }
  767.     case CSeq_loc::e_Equiv:
  768.     {
  769.         const CSeq_loc_equiv::Tdata& src_equiv = src.GetEquiv().Get();
  770.         CRef<CSeq_loc> dst_loc;
  771.         CSeq_loc_equiv::Tdata& dst_equiv = (*dst)->SetEquiv().Set();
  772.         ITERATE ( CSeq_loc_equiv::Tdata, i, src_equiv ) {
  773.             if ( Convert(**i, &dst_loc, loc_index) ) {
  774.                 dst_equiv.push_back(dst_loc);
  775.                 res = true;
  776.             }
  777.         }
  778.         m_Partial |= !res;
  779.         break;
  780.     }
  781.     case CSeq_loc::e_Bond:
  782.     {
  783.         const CSeq_bond& src_bond = src.GetBond();
  784.         // using mix, not bond, since mappings may have
  785.         // different strand, fuzz etc.
  786.         (*dst)->SetBond();
  787.         CRef<CSeq_point> pntA;
  788.         CRef<CSeq_point> pntB;
  789.         {{
  790.             TRangeIterator mit = BeginRanges(
  791.                 CSeq_id_Handle::GetHandle(src_bond.GetA().GetId()),
  792.                 src_bond.GetA().GetPoint(), src_bond.GetA().GetPoint(),
  793.                 loc_index);
  794.             for ( ; mit  &&  !bool(pntA); ++mit) {
  795.                 CSeq_loc_Conversion& cvt = *mit->second;
  796.                 cvt.Reset();
  797.                 if (cvt.ConvertPoint(src_bond.GetA())) {
  798.                     pntA = cvt.GetDstPoint();
  799.                     m_TotalRange += cvt.GetTotalRange();
  800.                     res = true;
  801.                 }
  802.             }
  803.         }}
  804.         if ( src_bond.IsSetB() ) {
  805.             TRangeIterator mit = BeginRanges(
  806.                 CSeq_id_Handle::GetHandle(src_bond.GetB().GetId()),
  807.                 src_bond.GetB().GetPoint(), src_bond.GetB().GetPoint(),
  808.                 loc_index);
  809.             for ( ; mit  &&  !bool(pntB); ++mit) {
  810.                 CSeq_loc_Conversion& cvt = *mit->second;
  811.                 cvt.Reset();
  812.                 if (!bool(pntB)  &&  cvt.ConvertPoint(src_bond.GetB())) {
  813.                     pntB = cvt.GetDstPoint();
  814.                     m_TotalRange += cvt.GetTotalRange();
  815.                     res = true;
  816.                 }
  817.             }
  818.         }
  819.         CSeq_bond& dst_bond = (*dst)->SetBond();
  820.         if ( bool(pntA)  ||  bool(pntB) ) {
  821.             if ( bool(pntA) ) {
  822.                 dst_bond.SetA(*pntA);
  823.             }
  824.             else {
  825.                 dst_bond.SetA().Assign(src_bond.GetA());
  826.             }
  827.             if ( bool(pntB) ) {
  828.                 dst_bond.SetB(*pntB);
  829.             }
  830.             else if ( src_bond.IsSetB() ) {
  831.                 dst_bond.SetB().Assign(src_bond.GetB());
  832.             }
  833.         }
  834.         m_Partial |= (!bool(pntA)  ||  !bool(pntB));
  835.         break;
  836.     }
  837.     default:
  838.         NCBI_THROW(CAnnotException, eBadLocation,
  839.                    "Unsupported location type");
  840.     }
  841.     return res;
  842. }
  845. void CSeq_loc_Conversion_Set::Convert(const CSeq_align& src,
  846.                                       CRef<CSeq_align>* dst)
  847. {
  848.     CRef<CSeq_align_Mapper> mapper(new CSeq_align_Mapper(src));
  849.     mapper->Convert(*this);
  850.     *dst = mapper->GetDstAlign();
  851. }
  854. END_SCOPE(objects)
  855. END_NCBI_SCOPE
  857. /*
  858. * ---------------------------------------------------------------------------
  859. * $Log: seq_loc_cvt.cpp,v $
  860. * Revision 1000.5  2004/06/01 19:24:09  gouriano
  861. * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.29
  862. *
  863. * Revision 1.29  2004/05/26 14:29:20  grichenk
  864. * Redesigned CSeq_align_Mapper: preserve non-mapping intervals,
  865. * fixed strands handling, improved performance.
  866. *
  867. * Revision 1.28  2004/05/21 21:42:13  gorelenk
  868. * Added PCH ncbi_pch.hpp
  869. *
  870. * Revision 1.27  2004/05/10 18:26:37  grichenk
  871. * Fixed 'not used' warnings
  872. *
  873. * Revision 1.26  2004/04/13 15:59:35  grichenk
  874. * Added CScope::GetBioseqHandle() with id resolving flag.
  875. *
  876. * Revision 1.25  2004/03/30 21:21:09  grichenk
  877. * Reduced number of includes.
  878. *
  879. * Revision 1.24  2004/03/30 15:42:33  grichenk
  880. * Moved alignment mapper to separate file, added alignment mapping
  881. * to CSeq_loc_Mapper.
  882. *
  883. * Revision 1.23  2004/03/16 15:47:28  vasilche
  884. * Added CBioseq_set_Handle and set of EditHandles
  885. *
  886. * Revision 1.22  2004/02/23 15:23:16  grichenk
  887. * Removed unused members
  888. *
  889. * Revision 1.21  2004/02/19 19:25:09  vasilche
  890. * Hidded implementation of CAnnotObject_Ref.
  891. * Added necessary access methods.
  892. *
  893. * Revision 1.20  2004/02/19 17:18:44  vasilche
  894. * Formatting + use CRef<> assignment directly.
  895. *
  896. * Revision 1.19  2004/02/06 16:07:27  grichenk
  897. * Added CBioseq_Handle::GetSeq_entry_Handle()
  898. * Fixed MapLocation()
  899. *
  900. * Revision 1.18  2004/02/05 22:49:19  grichenk
  901. * Added default cases in switches
  902. *
  903. * Revision 1.17  2004/02/05 20:18:37  grichenk
  904. * Fixed std-segs processing
  905. *
  906. * Revision 1.16  2004/02/02 14:44:54  vasilche
  907. * Removed several compilation warnings.
  908. *
  909. * Revision 1.15  2004/01/30 15:25:45  grichenk
  910. * Fixed alignments mapping and sorting
  911. *
  912. * Revision 1.14  2004/01/28 22:09:35  grichenk
  913. * Added CSeq_align_Mapper initialization for e_Disc
  914. *
  915. * Revision 1.13  2004/01/28 20:54:36  vasilche
  916. * Fixed mapping of annotations.
  917. *
  918. * Revision 1.12  2004/01/23 22:13:48  ucko
  919. * Fix variable shadowing that some compilers treated as an error.
  920. *
  921. * Revision 1.11  2004/01/23 16:14:48  grichenk
  922. * Implemented alignment mapping
  923. *
  924. * Revision 1.10  2004/01/02 16:06:53  grichenk
  925. * Skip location mapping for seq-aligns
  926. *
  927. * Revision 1.9  2003/12/04 20:04:24  grichenk
  928. * Fixed bugs in seq-loc converters.
  929. *
  930. * Revision 1.8  2003/11/10 18:11:04  grichenk
  931. * Moved CSeq_loc_Conversion_Set to seq_loc_cvt
  932. *
  933. * Revision 1.7  2003/11/04 16:21:37  grichenk
  934. * Updated CAnnotTypes_CI to map whole features instead of splitting
  935. * them by sequence segments.
  936. *
  937. * Revision 1.6  2003/10/29 19:55:47  vasilche
  938. * Avoid making 'whole' features on 'whole' segment partial (by Aleksey Grichenko)
  939. *
  940. * Revision 1.5  2003/09/30 16:22:03  vasilche
  941. * Updated internal object manager classes to be able to load ID2 data.
  942. * SNP blobs are loaded as ID2 split blobs - readers convert them automatically.
  943. * Scope caches results of requests for data to data loaders.
  944. * Optimized CSeq_id_Handle for gis.
  945. * Optimized bioseq lookup in scope.
  946. * Reduced object allocations in annotation iterators.
  947. * CScope is allowed to be destroyed before other objects using this scope are
  948. * deleted (feature iterators, bioseq handles etc).
  949. * Optimized lookup for matching Seq-ids in CSeq_id_Mapper.
  950. * Added 'adaptive' option to objmgr_demo application.
  951. *
  952. * Revision 1.4  2003/09/05 17:29:40  grichenk
  953. * Structurized Object Manager exceptions
  954. *
  955. * Revision 1.3  2003/08/27 14:29:52  vasilche
  956. * Reduce object allocations in feature iterator.
  957. *
  958. * Revision 1.2  2003/08/15 19:19:16  vasilche
  959. * Fixed memory leak in string packing hooks.
  960. * Fixed processing of 'partial' flag of features.
  961. * Allow table packing of non-point SNP.
  962. * Allow table packing of SNP with long alleles.
  963. *
  964. * Revision 1.1  2003/08/14 20:05:19  vasilche
  965. * Simple SNP features are stored as table internally.
  966. * They are recreated when needed using CFeat_CI.
  967. *
  968. * ===========================================================================
  969. */