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

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

生物技术

开发平台：

C/C++

annot_collector.cpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: annot_collector.cpp,v $
  4.  * PRODUCTION Revision 1000.3  2004/06/01 19:22:32  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.7
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. /*  $Id: annot_collector.cpp,v 1000.3 2004/06/01 19:22:32 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: Aleksey Grichenko, Eugene Vasilchenko
  36. *
  37. * File Description:
  38. *   Annotation collector for annot iterators
  39. *
  40. */
  42. #include <ncbi_pch.hpp>
  43. #include <objmgr/impl/annot_collector.hpp>
  45. #include <objmgr/scope.hpp>
  46. #include <objmgr/bioseq_handle.hpp>
  47. #include <objmgr/seq_entry_handle.hpp>
  48. #include <objmgr/seq_annot_handle.hpp>
  49. #include <objmgr/seq_map_ci.hpp>
  50. #include <objmgr/impl/annot_object.hpp>
  51. #include <objmgr/impl/tse_info.hpp>
  52. #include <objmgr/impl/annot_type_index.hpp>
  53. #include <objmgr/impl/tse_chunk_info.hpp>
  54. #include <objmgr/impl/data_source.hpp>
  55. #include <objmgr/impl/seq_annot_info.hpp>
  56. #include <objmgr/impl/bioseq_set_info.hpp>
  57. #include <objmgr/impl/handle_range_map.hpp>
  58. #include <objmgr/impl/synonyms.hpp>
  59. #include <objmgr/impl/seq_loc_cvt.hpp>
  60. #include <objmgr/impl/seq_align_mapper.hpp>
  61. #include <objmgr/impl/snp_annot_info.hpp>
  62. #include <objmgr/impl/scope_impl.hpp>
  63. #include <objmgr/objmgr_exception.hpp>
  65. #include <objects/seq/Bioseq.hpp>
  66. #include <objects/seqloc/Seq_loc.hpp>
  67. #include <objects/seqset/Seq_entry.hpp>
  68. #include <objects/seqalign/Seq_align.hpp>
  69. #include <objects/seqfeat/Seq_feat.hpp>
  70. #include <objects/seqres/Seq_graph.hpp>
  71. #include <objects/seqfeat/SeqFeatData.hpp>
  72. #include <objects/seqloc/Seq_loc_equiv.hpp>
  73. #include <objects/seqloc/Seq_bond.hpp>
  75. #include <serial/typeinfo.hpp>
  76. #include <serial/objostr.hpp>
  77. #include <serial/objostrasn.hpp>
  78. #include <serial/serial.hpp>
  79. #include <serial/serialutil.hpp>
  81. #include <algorithm>
  82. #include <typeinfo>
  84. BEGIN_NCBI_SCOPE
  85. BEGIN_SCOPE(objects)
  88. /////////////////////////////////////////////////////////////////////////////
  89. // CAnnotObject_Ref
  90. /////////////////////////////////////////////////////////////////////////////
  93. inline
  94. CAnnotObject_Ref::CAnnotObject_Ref(const CAnnotObject_Info& object)
  95.     : m_Object(&object.GetSeq_annot_Info()),
  96.       m_AnnotObject_Index(object.GetSeq_annot_Info()
  97.                           .GetAnnotObjectIndex(object)),
  98.       m_ObjectType(eType_Seq_annot_Info),
  99.       m_MappedFlags(0),
  100.       m_MappedObjectType(eMappedObjType_not_set),
  101.       m_MappedStrand(eNa_strand_unknown)
  102. {
  103.     if ( object.IsFeat() ) {
  104.         const CSeq_feat& feat = *object.GetFeatFast();
  105.         if ( feat.IsSetPartial() ) {
  106.             SetPartial(feat.GetPartial());
  107.         }
  108.     }
  109. }
  112. inline
  113. CAnnotObject_Ref::CAnnotObject_Ref(const CSeq_annot_SNP_Info& snp_annot,
  114.                                    TSeqPos index)
  115.     : m_Object(&snp_annot),
  116.       m_AnnotObject_Index(index),
  117.       m_ObjectType(eType_Seq_annot_SNP_Info),
  118.       m_MappedFlags(0),
  119.       m_MappedObjectType(eMappedObjType_not_set),
  120.       m_MappedStrand(eNa_strand_unknown)
  121. {
  122. }
  125. const CAnnotObject_Info& CAnnotObject_Ref::GetAnnotObject_Info(void) const
  126. {
  127.     return GetSeq_annot_Info().GetAnnotObject_Info(GetAnnotObjectIndex());
  128. }
  131. const SSNP_Info& CAnnotObject_Ref::GetSNP_Info(void) const
  132. {
  133.     return GetSeq_annot_SNP_Info().GetSNP_Info(GetAnnotObjectIndex());
  134. }
  137. bool CAnnotObject_Ref::IsFeat(void) const
  138. {
  139.     return GetObjectType() == eType_Seq_annot_SNP_Info ||
  140.         (GetObjectType() == eType_Seq_annot_Info &&
  141.          GetAnnotObject_Info().IsFeat());
  142. }
  145. bool CAnnotObject_Ref::IsGraph(void) const
  146. {
  147.     return GetObjectType() == eType_Seq_annot_Info &&
  148.         GetAnnotObject_Info().IsGraph();
  149. }
  152. bool CAnnotObject_Ref::IsAlign(void) const
  153. {
  154.     return GetObjectType() == eType_Seq_annot_Info &&
  155.         GetAnnotObject_Info().IsAlign();
  156. }
  159. const CSeq_feat& CAnnotObject_Ref::GetFeat(void) const
  160. {
  161.     return GetAnnotObject_Info().GetFeat();
  162. }
  165. const CSeq_graph& CAnnotObject_Ref::GetGraph(void) const
  166. {
  167.     return GetAnnotObject_Info().GetGraph();
  168. }
  171. const CSeq_align& CAnnotObject_Ref::GetAlign(void) const
  172. {
  173.     return GetAnnotObject_Info().GetAlign();
  174. }
  177. inline
  178. void CAnnotObject_Ref::SetSNP_Point(const SSNP_Info& snp,
  179.                                     CSeq_loc_Conversion* cvt)
  180. {
  181.     _ASSERT(GetObjectType() == eType_Seq_annot_SNP_Info);
  182.     TSeqPos src_from = snp.GetFrom(), src_to = snp.GetTo();
  183.     ENa_strand src_strand =
  184.         snp.MinusStrand()? eNa_strand_minus: eNa_strand_plus;
  185.     if ( !cvt ) {
  186.         SetTotalRange(TRange(src_from, src_to));
  187.         SetMappedSeq_id(const_cast<CSeq_id&>(GetSeq_annot_SNP_Info().                                             GetSeq_id()),
  188.                         true);
  189.         SetMappedStrand(src_strand);
  190.         return;
  191.     }
  193.     cvt->Reset();
  194.     if ( src_from == src_to ) {
  195.         // point
  196.         _VERIFY(cvt->ConvertPoint(src_from, src_strand));
  197.     }
  198.     else {
  199.         // interval
  200.         _VERIFY(cvt->ConvertInterval(src_from, src_to, src_strand));
  201.     }
  202.     cvt->SetMappedLocation(*this, CSeq_loc_Conversion::eLocation);
  203. }
  206. const CSeq_align&
  207. CAnnotObject_Ref::GetMappedSeq_align(void) const
  208. {
  209.     if (m_MappedObjectType == eMappedObjType_Seq_loc_Conv_Set) {
  210.         // Map the alignment, replace conv-set with the mapped align
  211.         CSeq_loc_Conversion_Set& cvts =
  212.             const_cast<CSeq_loc_Conversion_Set&>(
  213.             *CTypeConverter<CSeq_loc_Conversion_Set>::
  214.             SafeCast(m_MappedObject.GetPointer()));
  215.         CRef<CSeq_align> dst;
  216.         cvts.Convert(GetAlign(), &dst);
  217.         const_cast<CAnnotObject_Ref&>(*this).
  218.             SetMappedSeq_align(dst.GetPointerOrNull());
  219.     }
  220.     _ASSERT(m_MappedObjectType == eMappedObjType_Seq_align);
  221.     return *CTypeConverter<CSeq_align>::
  222.         SafeCast(m_MappedObject.GetPointer());
  223. }
  226. void CAnnotObject_Ref::SetMappedSeq_align_Cvts(CSeq_loc_Conversion_Set& cvts)
  227. {
  228.     _ASSERT(!IsMapped());
  229.     m_MappedObject.Reset(&cvts);
  230.     m_MappedObjectType = eMappedObjType_Seq_loc_Conv_Set;
  231. }
  234. void CAnnotObject_Ref::SetMappedSeq_align(CSeq_align* align)
  235. {
  236.     _ASSERT(m_MappedObjectType == eMappedObjType_Seq_loc_Conv_Set);
  237.     m_MappedObject.Reset(align);
  238.     m_MappedObjectType =
  239.         align? eMappedObjType_Seq_align: eMappedObjType_not_set;
  240. }
  243. void CAnnotObject_Ref::UpdateMappedSeq_loc(CRef<CSeq_loc>& loc) const
  244. {
  245.     _ASSERT(MappedSeq_locNeedsUpdate());
  246.     
  247.     CSeq_id& id = const_cast<CSeq_id&>(GetMappedSeq_id());
  248.     if ( !loc || !loc->ReferencedOnlyOnce() ) {
  249.         loc.Reset(new CSeq_loc);
  250.     }
  251.     else {
  252.         loc->InvalidateTotalRangeCache();
  253.     }
  254.     if ( IsMappedPoint() ) {
  255.         CSeq_point& point = loc->SetPnt();
  256.         point.SetId(id);
  257.         point.SetPoint(m_TotalRange.GetFrom());
  258.         if ( GetMappedStrand() != eNa_strand_unknown )
  259.             point.SetStrand(GetMappedStrand());
  260.         else
  261.             point.ResetStrand();
  262.     }
  263.     else {
  264.         CSeq_interval& interval = loc->SetInt();
  265.         interval.SetId(id);
  266.         interval.SetFrom(GetTotalRange().GetFrom());
  267.         interval.SetTo(GetTotalRange().GetTo());
  268.         if ( GetMappedStrand() != eNa_strand_unknown )
  269.             interval.SetStrand(GetMappedStrand());
  270.         else
  271.             interval.ResetStrand();
  272.     }
  273. }
  276. void CAnnotObject_Ref::UpdateMappedSeq_loc(CRef<CSeq_loc>& loc,
  277.                                            CRef<CSeq_point>& pnt_ref,
  278.                                            CRef<CSeq_interval>& int_ref) const
  279. {
  280.     _ASSERT(MappedSeq_locNeedsUpdate());
  282.     CSeq_id& id = const_cast<CSeq_id&>(GetMappedSeq_id());
  283.     if ( !loc || !loc->ReferencedOnlyOnce() ) {
  284.         loc.Reset(new CSeq_loc);
  285.     }
  286.     else {
  287.         loc->Reset();
  288.         loc->InvalidateTotalRangeCache();
  289.     }
  290.     if ( IsMappedPoint() ) {
  291.         if ( !pnt_ref || !pnt_ref->ReferencedOnlyOnce() ) {
  292.             pnt_ref.Reset(new CSeq_point);
  293.         }
  294.         CSeq_point& point = *pnt_ref;
  295.         loc->SetPnt(point);
  296.         point.SetId(id);
  297.         point.SetPoint(m_TotalRange.GetFrom());
  298.         if ( GetMappedStrand() != eNa_strand_unknown )
  299.             point.SetStrand(GetMappedStrand());
  300.         else
  301.             point.ResetStrand();
  302.     }
  303.     else {
  304.         if ( !int_ref || !int_ref->ReferencedOnlyOnce() ) {
  305.             int_ref.Reset(new CSeq_interval);
  306.         }
  307.         CSeq_interval& interval = *int_ref;
  308.         loc->SetInt(interval);
  309.         interval.SetId(id);
  310.         interval.SetFrom(m_TotalRange.GetFrom());
  311.         interval.SetTo(m_TotalRange.GetTo());
  312.         if ( GetMappedStrand() != eNa_strand_unknown )
  313.             interval.SetStrand(GetMappedStrand());
  314.         else
  315.             interval.ResetStrand();
  316.     }
  317. }
  320. bool CAnnotObject_Ref::operator<(const CAnnotObject_Ref& ref) const
  321. {
  322.     if ( m_Object != ref.m_Object ) {
  323.         return m_Object < ref.m_Object;
  324.     }
  325.     return GetAnnotObjectIndex() < ref.GetAnnotObjectIndex();
  326. }
  329. /////////////////////////////////////////////////////////////////////////////
  330. // CAnnotObject_Ref comparision
  331. /////////////////////////////////////////////////////////////////////////////
  333. struct CAnnotObjectType_Less
  334. {
  335.     bool operator()(const CAnnotObject_Ref& x,
  336.                     const CAnnotObject_Ref& y) const;
  338.     static const CSeq_loc& GetLocation(const CAnnotObject_Ref& ref,
  339.                                        const CSeq_feat& feat);
  340. };
  343. const CSeq_loc& CAnnotObjectType_Less::GetLocation(const CAnnotObject_Ref& ref,
  344.                                                    const CSeq_feat& feat)
  345. {
  346.     if ( ref.GetMappedObjectType() == ref.eMappedObjType_Seq_loc &&
  347.          !ref.IsProduct() ) {
  348.         return ref.GetMappedSeq_loc();
  349.     }
  350.     else {
  351.         return feat.GetLocation();
  352.     }
  353. }
  356. bool CAnnotObjectType_Less::operator()(const CAnnotObject_Ref& x,
  357.                                        const CAnnotObject_Ref& y) const
  358. {
  359.     // gather x annotation type
  360.     const CAnnotObject_Info* x_info;
  361.     CSeq_annot::C_Data::E_Choice x_annot_type;
  362.     if ( !x.IsSNPFeat() ) {
  363.         const CSeq_annot_Info& x_annot = x.GetSeq_annot_Info();
  364.         x_info = &x_annot.GetAnnotObject_Info(x.GetAnnotObjectIndex());
  365.         x_annot_type = x_info->GetAnnotType();
  366.     }
  367.     else {
  368.         x_info = 0;
  369.         x_annot_type = CSeq_annot::C_Data::e_Ftable;
  370.     }
  372.     // gather y annotation type
  373.     const CAnnotObject_Info* y_info;
  374.     CSeq_annot::C_Data::E_Choice y_annot_type;
  375.     if ( !y.IsSNPFeat() ) {
  376.         const CSeq_annot_Info& y_annot = y.GetSeq_annot_Info();
  377.         y_info = &y_annot.GetAnnotObject_Info(y.GetAnnotObjectIndex());
  378.         y_annot_type = y_info->GetAnnotType();
  379.     }
  380.     else {
  381.         y_info = 0;
  382.         y_annot_type = CSeq_annot::C_Data::e_Ftable;
  383.     }
  385.     // compare by annotation type (feature, align, graph)
  386.     if ( x_annot_type != y_annot_type ) {
  387.         return x_annot_type < y_annot_type;
  388.     }
  390.     if ( x_annot_type == CSeq_annot::C_Data::e_Ftable ) {
  391.         // compare features by type
  392.         if ( !x_info != !y_info ) {
  393.             CSeqFeatData::E_Choice x_feat_type = CSeqFeatData::e_Imp;
  394.             CSeqFeatData::ESubtype x_feat_subtype =
  395.                 CSeqFeatData::eSubtype_variation;
  396.             if ( x_info ) {
  397.                 x_feat_type = x_info->GetFeatType();
  398.                 x_feat_subtype = x_info->GetFeatSubtype();
  399.             }
  401.             CSeqFeatData::E_Choice y_feat_type = CSeqFeatData::e_Imp;
  402.             CSeqFeatData::ESubtype y_feat_subtype =
  403.                 CSeqFeatData::eSubtype_variation;
  404.             if ( y_info ) {
  405.                 y_feat_type = y_info->GetFeatType();
  406.                 y_feat_subtype = y_info->GetFeatSubtype();
  407.             }
  409.             // one is simple SNP feature, another is some complex feature
  410.             if ( x_feat_type != y_feat_type ) {
  411.                 int x_order = CSeq_feat::GetTypeSortingOrder(x_feat_type);
  412.                 int y_order = CSeq_feat::GetTypeSortingOrder(y_feat_type);
  413.                 if ( x_order != y_order ) {
  414.                     return x_order < y_order;
  415.                 }
  416.             }
  418.             // non-variations first
  419.             if ( x_feat_subtype != y_feat_subtype ) {
  420.                 return x_feat_subtype < y_feat_subtype;
  421.             }
  423.             // both are variations but one is simple and another is not.
  424.             // required order: simple first.
  425.             // if !x_info == true -> x - simple, y - complex -> return true
  426.             // if !x_info == false -> x - complex, y - simple -> return false
  427.             return !x_info;
  428.         }
  430.         if ( x_info ) {
  431.             // both are complex features
  432.             try {
  433.                 const CSeq_feat* x_feat = x_info->GetFeatFast();
  434.                 const CSeq_feat* y_feat = y_info->GetFeatFast();
  435.                 _ASSERT(x_feat && y_feat);
  436.                 int diff = x_feat->CompareNonLocation(*y_feat,
  437.                                                       GetLocation(x, *x_feat),
  438.                                                       GetLocation(y, *y_feat));
  439.                 if ( diff != 0 ) {
  440.                     return diff < 0;
  441.                 }
  442.             }
  443.             catch ( exception& /*ignored*/ ) {
  444.                 // do not fail sort when compare function throws an exception
  445.             }
  446.         }
  447.     }
  448.     return x < y;
  449. }
  452. struct CAnnotObject_Less
  453. {
  454.     // Compare CRef-s: both must be features
  455.     bool operator()(const CAnnotObject_Ref& x,
  456.                     const CAnnotObject_Ref& y) const
  457.         {
  458.             {
  459.                 // smallest left extreme first
  460.                 TSeqPos x_from = x.GetFrom();
  461.                 TSeqPos y_from = y.GetFrom();
  462.                 if ( x_from != y_from ) {
  463.                     return x_from < y_from;
  464.                 }
  465.             }
  466.             {
  467.                 // longest feature first
  468.                 TSeqPos x_to = x.GetToOpen();
  469.                 TSeqPos y_to = y.GetToOpen();
  470.                 if ( x_to != y_to ) {
  471.                     return x_to > y_to;
  472.                 }
  473.             }
  474.             return type_less(x, y);
  475.         }
  476.     CAnnotObjectType_Less type_less;
  477. };
  480. struct CAnnotObject_LessReverse
  481. {
  482.     // Compare CRef-s: both must be features
  483.     bool operator()(const CAnnotObject_Ref& x,
  484.                     const CAnnotObject_Ref& y) const
  485.         {
  486.             {
  487.                 // largest right extreme first
  488.                 TSeqPos x_to = x.GetToOpen();
  489.                 TSeqPos y_to = y.GetToOpen();
  490.                 if ( x_to != y_to ) {
  491.                     return x_to > y_to;
  492.                 }
  493.             }
  494.             {
  495.                 // longest feature first
  496.                 TSeqPos x_from = x.GetFrom();
  497.                 TSeqPos y_from = y.GetFrom();
  498.                 if ( x_from != y_from ) {
  499.                     return x_from < y_from;
  500.                 }
  501.             }
  502.             return type_less(x, y);
  503.         }
  504.     CAnnotObjectType_Less type_less;
  505. };
  508. /////////////////////////////////////////////////////////////////////////////
  509. // CAnnot_Collector, CAnnotMappingCollector
  510. /////////////////////////////////////////////////////////////////////////////
  513. class CAnnotMappingCollector
  514. {
  515. public:
  516.     typedef map<CAnnotObject_Ref,
  517.                 CRef<CSeq_loc_Conversion_Set> > TAnnotMappingSet;
  518.     // Set of annotations for complex remapping
  519.     TAnnotMappingSet              m_AnnotMappingSet;
  520.     // info of limit object
  521.     CConstRef<CObject>            m_LimitObjectInfo;
  522. };
  525. CAnnot_Collector::CAnnot_Collector(const SAnnotSelector& selector,
  526.                                          CScope&               scope)
  527.     : m_Selector(selector),
  528.       m_Scope(scope),
  529.       m_MappingCollector(new CAnnotMappingCollector)
  530. {
  531.     return;
  532. }
  534. CAnnot_Collector::~CAnnot_Collector(void)
  535. {
  536.     x_Clear();
  537. }
  540. inline
  541. size_t CAnnot_Collector::x_GetAnnotCount(void) const
  542. {
  543.     return m_AnnotSet.size() +
  544.         (m_MappingCollector.get() ?
  545.         m_MappingCollector->m_AnnotMappingSet.size() : 0);
  546. }
  549. void CAnnot_Collector::x_Clear(void)
  550. {
  551.     m_AnnotSet.clear();
  552.     if ( m_MappingCollector.get() ) {
  553.         m_MappingCollector.reset();
  554.     }
  555.     m_TSE_LockSet.clear();
  556.     m_Scope = CHeapScope();
  557. }
  560. void CAnnot_Collector::x_Initialize(const CBioseq_Handle& bioseq,
  561.                                        TSeqPos start, TSeqPos stop)
  562. {
  563.     try {
  564.         if ( start == 0 && stop == 0 ) {
  565.             stop = bioseq.GetBioseqLength()-1;
  566.         }
  567.         CHandleRangeMap master_loc;
  568.         master_loc.AddRange(bioseq.GetSeq_id_Handle(),
  569.                             CHandleRange::TRange(start, stop),
  570.                             eNa_strand_unknown);
  571.         x_Initialize(master_loc);
  572.     } catch (...) {
  573.         // clear all members - GCC 3.0.4 does not do it
  574.         x_Clear();
  575.         throw;
  576.     }
  577. }
  580. void CAnnot_Collector::x_Initialize(const CHandleRangeMap& master_loc)
  581. {
  582.     try {
  583.         if ( !m_Selector.m_LimitObject ) {
  584.             m_Selector.m_LimitObjectType = SAnnotSelector::eLimit_None;
  585.         }
  586.         if ( m_Selector.m_LimitObjectType != SAnnotSelector::eLimit_None ) {
  587.             x_GetTSE_Info();
  588.         }
  590.         bool found = x_Search(master_loc, 0);
  591.         bool deeper = !(found && m_Selector.m_AdaptiveDepth) &&
  592.             m_Selector.m_ResolveMethod != SAnnotSelector::eResolve_None  &&
  593.             m_Selector.m_ResolveDepth > 0;
  594.         if ( deeper ) {
  595.             ITERATE ( CHandleRangeMap::TLocMap, idit, master_loc.GetMap() ) {
  596.                 //### Check for eLoadedOnly
  597.                 CBioseq_Handle bh = m_Scope->GetBioseqHandle(idit->first,
  598.                     CScope::eGetBioseq_All);
  599.                 if ( !bh ) {
  600.                     if (m_Selector.m_IdResolving ==
  601.                         SAnnotSelector::eFailUnresolved) {
  602.                         // resolve by Seq-id only
  603.                         NCBI_THROW(CAnnotException, eFindFailed,
  604.                                    "Cannot resolve master id");
  605.                     }
  606.                     continue; // Do not crash - just skip unresolvable IDs
  607.                 }
  609.                 CRef<CSeq_loc> master_loc_empty(new CSeq_loc);
  610.                 master_loc_empty->SetEmpty(
  611.                     const_cast<CSeq_id&>(*idit->first.GetSeqId()));
  612.                 
  613.                 CHandleRange::TRange idrange =
  614.                     idit->second.GetOverlappingRange();
  615.                 const CSeqMap& seqMap = bh.GetSeqMap();
  616.                 CSeqMap_CI smit(seqMap.FindResolved(idrange.GetFrom(),
  617.                                                     m_Scope,
  618.                                                     m_Selector.m_ResolveDepth-1,
  619.                                                     CSeqMap::fFindRef));
  620.                 while ( smit && smit.GetPosition() < idrange.GetToOpen() ) {
  621.                     _ASSERT(smit.GetType() == CSeqMap::eSeqRef);
  622.                     if ( m_Selector.m_ResolveMethod ==
  623.                         SAnnotSelector::eResolve_TSE &&
  624.                         !m_Scope->GetBioseqHandleFromTSE(smit.GetRefSeqid(),
  625.                                                          bh) ) {
  626.                         smit.Next(false);
  627.                         continue;
  628.                     }
  629.                     found = x_SearchMapped(smit,
  630.                                            *master_loc_empty,
  631.                                            idit->first,
  632.                                            idit->second);
  633.                     deeper = !(found && m_Selector.m_AdaptiveDepth);
  634.                     smit.Next(deeper);
  635.                 }
  636.             }
  637.         }
  638.         NON_CONST_ITERATE(CAnnotMappingCollector::TAnnotMappingSet, amit,
  639.             m_MappingCollector->m_AnnotMappingSet) {
  640.             CAnnotObject_Ref annot_ref = amit->first;
  641.             amit->second->Convert(annot_ref,
  642.                 m_Selector.m_FeatProduct ? CSeq_loc_Conversion::eProduct :
  643.                 CSeq_loc_Conversion::eLocation);
  644.             m_AnnotSet.push_back(annot_ref);
  645.         }
  646.         m_MappingCollector->m_AnnotMappingSet.clear();
  647.         x_Sort();
  648.         m_MappingCollector.reset();
  649.     }
  650.     catch (...) {
  651.         // clear all members - GCC 3.0.4 does not do it
  652.         x_Clear();
  653.         throw;
  654.     }
  655. }
  658. void CAnnot_Collector::x_Initialize(void)
  659. {
  660.     try {
  661.         // Limit must be set, resolving is obsolete
  662.         _ASSERT(m_Selector.m_LimitObjectType != SAnnotSelector::eLimit_None);
  663.         _ASSERT(m_Selector.m_LimitObject);
  664.         _ASSERT(m_Selector.m_ResolveMethod == SAnnotSelector::eResolve_None);
  665.         x_GetTSE_Info();
  667.         x_SearchAll();
  668.         x_Sort();
  669.         m_MappingCollector.reset();
  670.     }
  671.     catch (...) {
  672.         // clear all members - GCC 3.0.4 does not do it
  673.         x_Clear();
  674.         throw;
  675.     }
  676. }
  679. void CAnnot_Collector::x_Sort(void)
  680. {
  681.     _ASSERT(m_MappingCollector->m_AnnotMappingSet.empty());
  682.     switch ( m_Selector.m_SortOrder ) {
  683.     case SAnnotSelector::eSortOrder_Normal:
  684.         sort(m_AnnotSet.begin(), m_AnnotSet.end(), CAnnotObject_Less());
  685.         break;
  686.     case SAnnotSelector::eSortOrder_Reverse:
  687.         sort(m_AnnotSet.begin(), m_AnnotSet.end(), CAnnotObject_LessReverse());
  688.         break;
  689.     default:
  690.         // do nothing
  691.         break;
  692.     }
  693. }
  696. inline
  697. bool
  698. CAnnot_Collector::x_MatchLimitObject(const CAnnotObject_Info& object_info) const
  699. {
  700.     if ( m_Selector.m_LimitObjectType == SAnnotSelector::eLimit_Seq_entry_Info ) {
  701.         const CSeq_entry_Info* info = &object_info.GetSeq_entry_Info();
  702.         _ASSERT(m_MappingCollector->m_LimitObjectInfo);
  703.         _ASSERT(info);
  704.         for ( ;; ) {
  705.             if ( info == m_MappingCollector->m_LimitObjectInfo.GetPointer() ) {
  706.                 return true;
  707.             }
  708.             if ( !info->HasParent_Info() ) {
  709.                 return false;
  710.             }
  711.             info = &info->GetParentSeq_entry_Info();
  712.         }
  713.     }
  714.     else if ( m_Selector.m_LimitObjectType ==
  715.         SAnnotSelector::eLimit_Seq_annot_Info ) {
  716.         const CSeq_annot_Info* info = &object_info.GetSeq_annot_Info();
  717.         _ASSERT(m_MappingCollector->m_LimitObjectInfo);
  718.         return info == m_MappingCollector->m_LimitObjectInfo.GetPointer();
  719.     }
  720.     return true;
  721. }
  724. inline
  725. bool CAnnot_Collector::x_NeedSNPs(void) const
  726. {
  727.     if ( m_Selector.GetAnnotType() != CSeq_annot::C_Data::e_not_set ) {
  728.         if ( m_Selector.GetAnnotType() != CSeq_annot::C_Data::e_Ftable ) {
  729.             return false;
  730.         }
  731.         if ( !m_Selector.IncludedFeatSubtype(
  732.             CSeqFeatData::eSubtype_variation) ) {
  733.             return false;
  734.         }
  735.         else if ( !m_Selector.IncludedFeatType(CSeqFeatData::e_Imp) ) {
  736.             return false;
  737.         }
  738.     }
  739.     return true;
  740. }
  743. inline
  744. bool CAnnot_Collector::x_MatchLocIndex(const SAnnotObject_Index& index) const
  745. {
  746.     return index.m_AnnotObject_Info->IsAlign()  ||
  747.         m_Selector.m_FeatProduct == (index.m_AnnotLocationIndex == 1);
  748. }
  751. inline
  752. bool CAnnot_Collector::x_MatchRange(const CHandleRange& hr,
  753.                                        const CRange<TSeqPos>& range,
  754.                                        const SAnnotObject_Index& index) const
  755. {
  756.     if ( m_Selector.m_OverlapType == SAnnotSelector::eOverlap_Intervals ) {
  757.         if ( index.m_HandleRange ) {
  758.             if ( !hr.IntersectingWith(*index.m_HandleRange) ) {
  759.                 return false;
  760.             }
  761.         }
  762.         else {
  763.             if ( !hr.IntersectingWith(range) ) {
  764.                 return false;
  765.             }
  766.         }
  767.     }
  768.     if ( !x_MatchLocIndex(index) ) {
  769.         return false;
  770.     }
  771.     return true;
  772. }
  775. void CAnnot_Collector::x_GetTSE_Info(void)
  776. {
  777.     // only one TSE is needed
  778.     _ASSERT(m_TSE_LockSet.empty());
  779.     _ASSERT(m_Selector.m_LimitObjectType != SAnnotSelector::eLimit_None);
  780.     _ASSERT(m_Selector.m_LimitObject);
  781.     
  782.     TTSE_Lock tse_info;
  783.     switch ( m_Selector.m_LimitObjectType ) {
  784.     case SAnnotSelector::eLimit_TSE:
  785.     {
  786.         const CSeq_entry* object = CTypeConverter<CSeq_entry>::
  787.             SafeCast(m_Selector.m_LimitObject.GetPointer());
  788.         CSeq_entry_Handle handle = m_Scope->GetSeq_entryHandle(*object);
  789.         if ( !handle ) {
  790.             NCBI_THROW(CAnnotException, eLimitError,
  791.                        "CAnnot_Collector::x_GetTSE_Info: "
  792.                        "unknown top level Seq-entry");
  793.         }
  794.         const CTSE_Info& info = handle.x_GetInfo().GetTSE_Info();
  795.         tse_info.Reset(&info);
  797.         // normalize TSE -> TSE_Info
  798.         m_Selector.m_LimitObjectType = SAnnotSelector::eLimit_TSE_Info;
  799.         m_Selector.m_LimitObject.Reset(&info);
  800.         m_MappingCollector->m_LimitObjectInfo.Reset(&info);
  801.         break;
  802.     }
  803.     case SAnnotSelector::eLimit_Seq_entry:
  804.     {
  805.         const CSeq_entry* object = CTypeConverter<CSeq_entry>::
  806.             SafeCast(m_Selector.m_LimitObject.GetPointer());
  807.         CSeq_entry_Handle handle = m_Scope->GetSeq_entryHandle(*object);
  808.         if ( !handle ) {
  809.             NCBI_THROW(CAnnotException, eLimitError,
  810.                        "CAnnot_Collector::x_GetTSE_Info: "
  811.                        "unknown Seq-entry");
  812.         }
  813.         const CSeq_entry_Info& info = handle.x_GetInfo();
  814.         tse_info.Reset(&info.GetTSE_Info());
  816.         // normalize Seq_entry -> Seq_entry_Info
  817.         m_Selector.m_LimitObjectType = SAnnotSelector::eLimit_Seq_entry_Info;
  818.         m_Selector.m_LimitObject.Reset(&info);
  819.         m_MappingCollector->m_LimitObjectInfo.Reset(&info);
  820.         break;
  821.     }
  822.     case SAnnotSelector::eLimit_Seq_annot:
  823.     {
  824.         const CSeq_annot* object = CTypeConverter<CSeq_annot>::
  825.             SafeCast(m_Selector.m_LimitObject.GetPointer());
  826.         CSeq_annot_Handle handle = m_Scope->GetSeq_annotHandle(*object);
  827.         if ( !handle ) {
  828.             NCBI_THROW(CAnnotException, eLimitError,
  829.                        "CAnnot_Collector::x_GetTSE_Info: "
  830.                        "unknown Seq-annot");
  831.         }
  832.         const CSeq_annot_Info& info = handle.x_GetInfo();
  833.         tse_info.Reset(&info.GetTSE_Info());
  835.         // normalize Seq_annot -> Seq_annot_Info
  836.         m_Selector.m_LimitObjectType = SAnnotSelector::eLimit_Seq_annot_Info;
  837.         m_Selector.m_LimitObject.Reset(&info);
  838.         m_MappingCollector->m_LimitObjectInfo.Reset(&info);
  839.         break;
  840.     }
  841.     case SAnnotSelector::eLimit_TSE_Info:
  842.     {
  843.         const CTSE_Info* info = CTypeConverter<CTSE_Info>::
  844.             SafeCast(m_Selector.m_LimitObject.GetPointer());
  845.         tse_info.Reset(info);
  846.         m_MappingCollector->m_LimitObjectInfo.Reset(info);
  847.         break;
  848.     }
  849.     case SAnnotSelector::eLimit_Seq_entry_Info:
  850.     {
  851.         const CSeq_entry_Info* info = CTypeConverter<CSeq_entry_Info>::
  852.             SafeCast(m_Selector.m_LimitObject.GetPointer());
  853.         tse_info.Reset(&info->GetTSE_Info());
  854.         m_MappingCollector->m_LimitObjectInfo.Reset(info);
  855.         break;
  856.     }
  857.     case SAnnotSelector::eLimit_Seq_annot_Info:
  858.     {
  859.         const CSeq_annot_Info* info = CTypeConverter<CSeq_annot_Info>::
  860.             SafeCast(m_Selector.m_LimitObject.GetPointer());
  861.         tse_info.Reset(&info->GetTSE_Info());
  862.         m_MappingCollector->m_LimitObjectInfo.Reset(info);
  863.         break;
  864.     }
  865.     default:
  866.         // no limit object -> do nothing
  867.         break;
  868.     }
  869.     _ASSERT(m_MappingCollector->m_LimitObjectInfo);
  870.     _ASSERT(tse_info);
  871.     tse_info->UpdateAnnotIndex();
  872.     //if ( !IsSetAnnotsNames() || x_MatchAnnotName(*tse_info) ) {
  873.         m_TSE_LockSet.insert(tse_info);
  874.     //}
  875. }
  878. bool CAnnot_Collector::x_Search(const CSeq_id_Handle& id,
  879.                                    const CBioseq_Handle& bh,
  880.                                    const CHandleRange& hr,
  881.                                    CSeq_loc_Conversion* cvt)
  882. {
  883.     if ( cvt )
  884.         cvt->SetSrcId(id);
  886.     bool found = false;
  887.     if ( m_Selector.m_LimitObjectType == SAnnotSelector::eLimit_None ) {
  888.         // any data source
  889.         CConstRef<CScope_Impl::TAnnotRefSet> tse_set;
  890.         if ( bh ) {
  891.             tse_set = m_Scope->GetTSESetWithAnnots(bh);
  892.         }
  893.         else {
  894.             tse_set = m_Scope->GetTSESetWithAnnots(id);
  895.         }
  896.         if ( tse_set ) {
  897.             found = x_Search(*tse_set, id, hr, cvt) || found;
  898.         }
  899.     }
  900.     else {
  901.         found = x_Search(m_TSE_LockSet, id, hr, cvt) || found;
  902.     }
  903.     return found;
  904. }
  907. static CSeqFeatData::ESubtype s_DefaultAdaptiveTriggers[] = {
  908.     CSeqFeatData::eSubtype_gene,
  909.     CSeqFeatData::eSubtype_cdregion,
  910.     CSeqFeatData::eSubtype_mRNA
  911. };
  914. bool CAnnot_Collector::x_Search(const TTSE_LockSet& tse_set,
  915.                                    const CSeq_id_Handle& id,
  916.                                    const CHandleRange& hr,
  917.                                    CSeq_loc_Conversion* cvt)
  918. {
  919.     bool found = false;
  920.     ITERATE ( TTSE_LockSet, tse_it, tse_set ) {
  921.         const CTSE_Info& tse = **tse_it;
  923.         CTSE_Info::TAnnotReadLockGuard guard(tse.m_AnnotObjsLock);
  925.         // Skip excluded TSEs
  926.         //if ( ExcludedTSE(tse) ) {
  927.         //continue;
  928.         //}
  930.         if ( m_Selector.m_AdaptiveDepth && tse.ContainsSeqid(id) ) {
  931.             const SIdAnnotObjs* objs = tse.x_GetUnnamedIdObjects(id);
  932.             if ( objs ) {
  933.                 vector<char> indexes;
  934.                 if ( m_Selector.m_AdaptiveTriggers.empty() ) {
  935.                     const size_t count =
  936.                         sizeof(s_DefaultAdaptiveTriggers)/
  937.                         sizeof(s_DefaultAdaptiveTriggers[0]);
  938.                     for ( int i = count - 1; i >= 0; --i ) {
  939.                         CSeqFeatData::ESubtype subtype =
  940.                             s_DefaultAdaptiveTriggers[i];
  941.                         size_t index = CAnnotType_Index::GetSubtypeIndex(subtype);
  942.                         if ( index ) {
  943.                             indexes.resize(max(indexes.size(), index + 1));
  944.                             indexes[index] = 1;
  945.                         }
  946.                     }
  947.                 }
  948.                 else {
  949.                     ITERATE ( SAnnotSelector::TAdaptiveTriggers, it,
  950.                         m_Selector.m_AdaptiveTriggers ) {
  951.                         pair<size_t, size_t> idxs =
  952.                             CAnnotType_Index::GetIndexRange(*it);
  953.                         indexes.resize(max(indexes.size(), idxs.second));
  954.                         for ( size_t i = idxs.first; i < idxs.second; ++i ) {
  955.                             indexes[i] = 1;
  956.                         }
  957.                     }
  958.                 }
  959.                 for ( size_t index = 0; index < indexes.size(); ++index ) {
  960.                     if ( !indexes[index] ) {
  961.                         continue;
  962.                     }
  963.                     if ( index >= objs->m_AnnotSet.size() ) {
  964.                         break;
  965.                     }
  966.                     if ( !objs->m_AnnotSet[index].empty() ) {
  967.                         found = true;
  968.                         break;
  969.                     }
  970.                 }
  971.             }
  972.         }
  973.         
  974.         if ( !m_Selector.m_IncludeAnnotsNames.empty() ) {
  975.             // only 'included' annots
  976.             ITERATE ( SAnnotSelector::TAnnotsNames, iter,
  977.                 m_Selector.m_IncludeAnnotsNames ) {
  978.                 _ASSERT(!m_Selector.ExcludedAnnotName(*iter)); // consistency check
  979.                 const SIdAnnotObjs* objs = tse.x_GetIdObjects(*iter, id);
  980.                 if ( objs ) {
  981.                     x_Search(tse, objs, guard, *iter, id, hr, cvt);
  982.                 }
  983.             }
  984.         }
  985.         else {
  986.             // all annots, skipping 'excluded'
  987.             ITERATE (CTSE_Info::TNamedAnnotObjs, iter, tse.m_NamedAnnotObjs) {
  988.                 if ( m_Selector.ExcludedAnnotName(iter->first) ) {
  989.                     continue;
  990.                 }
  991.                 const SIdAnnotObjs* objs =
  992.                     tse.x_GetIdObjects(iter->second, id);
  993.                 if ( objs ) {
  994.                     x_Search(tse, objs, guard, iter->first, id, hr, cvt);
  995.                 }
  996.             }
  997.         }
  998.     }
  999.     return found;
  1000. }
  1003. bool CAnnot_Collector::x_AddObjectMapping(CAnnotObject_Ref& object_ref,
  1004.                                           CSeq_loc_Conversion* cvt,
  1005.                                           unsigned int loc_index)
  1006. {
  1007.     _ASSERT(object_ref.GetAnnotObject_Info().GetMultiIdFlags()
  1008.             || cvt->IsPartial()
  1009.             || object_ref.IsAlign() );
  1010.     object_ref.ResetLocation();
  1011.     CRef<CSeq_loc_Conversion_Set>& mapping_set =
  1012.         m_MappingCollector->m_AnnotMappingSet[object_ref];
  1013.     if ( !mapping_set ) {
  1014.         mapping_set.Reset(new CSeq_loc_Conversion_Set(m_Scope));
  1015.     }
  1016.     CRef<CSeq_loc_Conversion> cvt_copy(new CSeq_loc_Conversion(*cvt));
  1017.     mapping_set->Add(*cvt_copy, loc_index);
  1018.     return x_GetAnnotCount() >= m_Selector.m_MaxSize;
  1019. }
  1022. inline
  1023. bool CAnnot_Collector::x_AddObject(CAnnotObject_Ref& object_ref)
  1024. {
  1025.     m_AnnotSet.push_back(object_ref);
  1026.     return x_GetAnnotCount() >= m_Selector.m_MaxSize;
  1027. }
  1030. inline
  1031. bool CAnnot_Collector::x_AddObject(CAnnotObject_Ref& object_ref,
  1032.                                    CSeq_loc_Conversion* cvt,
  1033.                                    unsigned int loc_index)
  1034. {
  1035.     // Always map aligns through conv. set
  1036.     return ( cvt && (cvt->IsPartial() || object_ref.IsAlign()) )?
  1037.         x_AddObjectMapping(object_ref, cvt, loc_index)
  1038.         : x_AddObject(object_ref);
  1039. }
  1042. void CAnnot_Collector::x_Search(const CTSE_Info& tse,
  1043.                                    const SIdAnnotObjs* objs,
  1044.                                    CReadLockGuard& guard,
  1045.                                    const CAnnotName& annot_name,
  1046.                                    const CSeq_id_Handle& id,
  1047.                                    const CHandleRange& hr,
  1048.                                    CSeq_loc_Conversion* cvt)
  1049. {
  1050.     if (m_Selector.m_AnnotTypesSet.size() == 0) {
  1051.         pair<size_t, size_t> range =
  1052.             CAnnotType_Index::GetIndexRange(m_Selector, *objs);
  1053.         if ( range.first < range.second ) {
  1054.             x_SearchRange(tse, objs, guard, annot_name, id, hr, cvt,
  1055.                 range.first, range.second);
  1056.         }
  1057.     }
  1058.     else {
  1059.         pair<size_t, size_t> range(0, 0);
  1060.         bool last_bit = false;
  1061.         bool cur_bit;
  1062.         for (size_t idx = 0; idx < objs->m_AnnotSet.size(); ++idx) {
  1063.             cur_bit = m_Selector.m_AnnotTypesSet[idx];
  1064.             if (!last_bit  &&  cur_bit) {
  1065.                 // open range
  1066.                 range.first = idx;
  1067.             }
  1068.             else if (last_bit  &&  !cur_bit) {
  1069.                 // close and search range
  1070.                 range.second = idx;
  1071.                 x_SearchRange(tse, objs, guard, annot_name, id, hr, cvt,
  1072.                     range.first, range.second);
  1073.             }
  1074.             last_bit = cur_bit;
  1075.         }
  1076.         if (last_bit) {
  1077.             // search to the end of annot set
  1078.             x_SearchRange(tse, objs, guard, annot_name, id, hr, cvt,
  1079.                 range.first, objs->m_AnnotSet.size());
  1080.         }
  1081.     }
  1083.     if ( x_NeedSNPs() ) {
  1084.         CHandleRange::TRange range = hr.GetOverlappingRange();
  1085.         ITERATE ( CTSE_Info::TSNPSet, snp_annot_it, objs->m_SNPSet ) {
  1086.             const CSeq_annot_SNP_Info& snp_annot = **snp_annot_it;
  1087.             CSeq_annot_SNP_Info::const_iterator snp_it =
  1088.                 snp_annot.FirstIn(range);
  1089.             if ( snp_it != snp_annot.end() ) {
  1090.                 m_TSE_LockSet.insert(ConstRef(&tse));
  1091.                 TSeqPos index = snp_it - snp_annot.begin() - 1;
  1092.                 do {
  1093.                     ++index;
  1094.                     const SSNP_Info& snp = *snp_it;
  1095.                     if ( snp.NoMore(range) ) {
  1096.                         break;
  1097.                     }
  1098.                     if ( snp.NotThis(range) ) {
  1099.                         continue;
  1100.                     }
  1102.                     CAnnotObject_Ref annot_ref(snp_annot, index);
  1103.                     annot_ref.SetSNP_Point(snp, cvt);
  1104.                     if ( x_AddObject(annot_ref, cvt, 0) ) {
  1105.                         return;
  1106.                     }
  1107.                 } while ( ++snp_it != snp_annot.end() );
  1108.             }
  1109.         }
  1110.     }
  1111. }
  1114. void CAnnot_Collector::x_SearchRange(const CTSE_Info& tse,
  1115.                                         const SIdAnnotObjs* objs,
  1116.                                         CReadLockGuard& guard,
  1117.                                         const CAnnotName& annot_name,
  1118.                                         const CSeq_id_Handle& id,
  1119.                                         const CHandleRange& hr,
  1120.                                         CSeq_loc_Conversion* cvt,
  1121.                                         size_t from_idx, size_t to_idx)
  1122. {
  1123.     _ASSERT(objs);
  1125.     CHandleRange::TRange range = hr.GetOverlappingRange();
  1127.     m_TSE_LockSet.insert(ConstRef(&tse));
  1129.     for ( size_t index = from_idx; index < to_idx; ++index ) {
  1130.         size_t start_size = m_AnnotSet.size(); // for rollback
  1131.         
  1132.         const CTSE_Info::TRangeMap& rmap = objs->m_AnnotSet[index];
  1133.         if ( rmap.empty() ) {
  1134.             continue;
  1135.         }
  1137.         for ( CTSE_Info::TRangeMap::const_iterator aoit(rmap.begin(range));
  1138.               aoit; ++aoit ) {
  1139.             const CAnnotObject_Info& annot_info =
  1140.                 *aoit->second.m_AnnotObject_Info;
  1142.             _ASSERT(m_Selector.MatchType(annot_info));
  1144.             if ( annot_info.IsChunkStub() ) {
  1145.                 const CTSE_Chunk_Info& chunk = annot_info.GetChunk_Info();
  1146.                 if ( chunk.NotLoaded() ) {
  1147.                     // New annot objects are to be loaded,
  1148.                     // so we'll need to restart scan of current range.
  1150.                     // Forget already found object
  1151.                     // as they will be found again:
  1152.                     m_AnnotSet.resize(start_size);
  1154.                     CAnnotName name(annot_name);
  1156.                     // Release lock for tse update:
  1157.                     guard.Release();
  1158.                         
  1159.                     // Load the stub:
  1160.                     const_cast<CTSE_Chunk_Info&>(chunk).Load();
  1162.                     // Acquire the lock again:
  1163.                     guard.Guard(tse.m_AnnotObjsLock);
  1165.                     // Reget range map pointer as it may change:
  1166.                     objs = tse.x_GetIdObjects(name, id);
  1167.                     _ASSERT(objs);
  1169.                     // Restart this index again:
  1170.                     --index;
  1171.                     break;
  1172.                 }
  1173.                 else {
  1174.                     // Skip chunk stub
  1175.                     continue;
  1176.                 }
  1177.             }
  1179.             if ( !x_MatchLimitObject(annot_info) ) {
  1180.                 continue;
  1181.             }
  1182.                 
  1183.             if ( !x_MatchRange(hr, aoit->first, aoit->second) ) {
  1184.                 continue;
  1185.             }
  1187.             CAnnotObject_Ref annot_ref(annot_info);
  1188.             if (!cvt  &&  annot_info.GetMultiIdFlags()) {
  1189.                 // Create self-conversion, add to conversion set
  1190.                 CRef<CSeq_loc_Conversion> cvt_ref
  1191.                     (new CSeq_loc_Conversion(id, m_Scope));
  1192.                 if (x_AddObjectMapping(annot_ref,
  1193.                     &*cvt_ref, aoit->second.m_AnnotLocationIndex)) {
  1194.                     return;
  1195.                 }
  1196.             }
  1197.             else {
  1198.                 if (cvt  &&  !annot_ref.IsAlign() ) {
  1199.                     cvt->Convert
  1200.                         (annot_ref,
  1201.                          m_Selector.m_FeatProduct ?
  1202.                          CSeq_loc_Conversion::eProduct :
  1203.                          CSeq_loc_Conversion::eLocation);
  1204.                 }
  1205.                 else {
  1206.                     annot_ref.SetAnnotObjectRange(aoit->first,
  1207.                                                   m_Selector.m_FeatProduct);
  1208.                 }
  1209.                 if ( x_AddObject(annot_ref, cvt,
  1210.                     aoit->second.m_AnnotLocationIndex) ) {
  1211.                     return;
  1212.                 }
  1213.             }
  1214.         }
  1215.     }
  1216. }
  1219. bool CAnnot_Collector::x_Search(const CHandleRangeMap& loc,
  1220.                                    CSeq_loc_Conversion* cvt)
  1221. {
  1222.     bool found = false;
  1223.     ITERATE ( CHandleRangeMap, idit, loc ) {
  1224.         if ( idit->second.Empty() ) {
  1225.             continue;
  1226.         }
  1228.         bool have_main = false;
  1229.         CConstRef<CSynonymsSet> syns = m_Scope->GetSynonyms(idit->first);
  1230.         if ( !syns ) {
  1231.             if (m_Selector.m_IdResolving == SAnnotSelector::eFailUnresolved) {
  1232.                 NCBI_THROW(CAnnotException, eFindFailed,
  1233.                            "Cannot find id synonyms");
  1234.             }
  1235.         }
  1236.         else {
  1237.             ITERATE ( CSynonymsSet, synit, *syns ) {
  1238.                 CSeq_id_Handle idh = CSynonymsSet::GetSeq_id_Handle(synit);
  1239.                 if ( !have_main ) {
  1240.                     have_main = idit->first == idh;
  1241.                 }
  1242.                 found = x_Search(idh, CSynonymsSet::GetBioseqHandle(synit),
  1243.                                  idit->second, cvt)  ||  found;
  1244.             }
  1245.         }
  1246.         if ( !have_main ) {
  1247.             found = x_Search(idit->first, CBioseq_Handle(),
  1248.                              idit->second, cvt)  ||  found;
  1249.         }
  1250.     }
  1251.     return found;
  1252. }
  1255. void CAnnot_Collector::x_SearchAll(void)
  1256. {
  1257.     _ASSERT(m_Selector.m_LimitObjectType != SAnnotSelector::eLimit_None);
  1258.     _ASSERT(m_Selector.m_LimitObject);
  1259.     _ASSERT(m_MappingCollector->m_LimitObjectInfo);
  1260.     if ( m_TSE_LockSet.empty() ) {
  1261.         // data source name not matched
  1262.         return;
  1263.     }
  1264.     switch ( m_Selector.m_LimitObjectType ) {
  1265.     case SAnnotSelector::eLimit_TSE_Info:
  1266.         x_SearchAll(*CTypeConverter<CTSE_Info>::
  1267.                     SafeCast(m_MappingCollector->
  1268.                     m_LimitObjectInfo.GetPointer()));
  1269.         break;
  1270.     case SAnnotSelector::eLimit_Seq_entry_Info:
  1271.         x_SearchAll(*CTypeConverter<CSeq_entry_Info>::
  1272.                     SafeCast(m_MappingCollector->
  1273.                     m_LimitObjectInfo.GetPointer()));
  1274.         break;
  1275.     case SAnnotSelector::eLimit_Seq_annot_Info:
  1276.         x_SearchAll(*CTypeConverter<CSeq_annot_Info>::
  1277.                     SafeCast(m_MappingCollector->
  1278.                     m_LimitObjectInfo.GetPointer()));
  1279.         break;
  1280.     default:
  1281.         // no limit object -> do nothing
  1282.         break;
  1283.     }
  1284. }
  1287. void CAnnot_Collector::x_SearchAll(const CSeq_entry_Info& entry_info)
  1288. {
  1289.     {{
  1290.         CConstRef<CBioseq_Base_Info> base = entry_info.m_Contents;
  1291.         // Collect all annotations from the entry
  1292.         ITERATE( CBioseq_Base_Info::TAnnot, ait, base->GetAnnot() ) {
  1293.             x_SearchAll(**ait);
  1294.             if ( x_GetAnnotCount() >= m_Selector.m_MaxSize )
  1295.                 return;
  1296.         }
  1297.     }}
  1299.     if ( entry_info.IsSet() ) {
  1300.         CConstRef<CBioseq_set_Info> set(&entry_info.GetSet());
  1301.         // Collect annotations from all children
  1302.         ITERATE( CBioseq_set_Info::TSeq_set, cit, set->GetSeq_set() ) {
  1303.             x_SearchAll(**cit);
  1304.             if ( x_GetAnnotCount() >= m_Selector.m_MaxSize )
  1305.                 return;
  1306.         }
  1307.     }
  1308. }
  1311. void CAnnot_Collector::x_SearchAll(const CSeq_annot_Info& annot_info)
  1312. {
  1313.     // Collect all annotations from the annot
  1314.     ITERATE ( SAnnotObjects_Info::TObjectInfos, aoit,
  1315.               annot_info.m_ObjectInfos.GetInfos() ) {
  1316.         if ( !m_Selector.MatchType(*aoit) ) {
  1317.             continue;
  1318.         }
  1319.         CAnnotObject_Ref annot_ref(*aoit);
  1320.         if ( x_AddObject(annot_ref) ) {
  1321.             return;
  1322.         }
  1323.     }
  1325.     if ( x_NeedSNPs() && annot_info.x_HasSNP_annot_Info() ) {
  1326.         const CSeq_annot_SNP_Info& snp_annot =
  1327.             annot_info.x_GetSNP_annot_Info();
  1328.         TSeqPos index = 0;
  1329.         ITERATE ( CSeq_annot_SNP_Info, snp_it, snp_annot ) {
  1330.             const SSNP_Info& snp = *snp_it;
  1331.             CAnnotObject_Ref annot_ref(snp_annot, index);
  1332.             annot_ref.SetSNP_Point(snp, 0);
  1333.             if ( x_AddObject(annot_ref) ) {
  1334.                 return;
  1335.             }
  1336.             ++index;
  1337.         }
  1338.     }
  1339. }
  1342. bool CAnnot_Collector::x_SearchMapped(const CSeqMap_CI& seg,
  1343.                                       CSeq_loc& master_loc_empty,
  1344.                                       const CSeq_id_Handle& master_id,
  1345.                                       const CHandleRange& master_hr)
  1346. {
  1347.     CHandleRange::TOpenRange master_seg_range(seg.GetPosition(),
  1348.                                               seg.GetEndPosition());
  1349.     CHandleRange::TOpenRange ref_seg_range(seg.GetRefPosition(),
  1350.                                            seg.GetRefEndPosition());
  1351.     bool reversed = seg.GetRefMinusStrand();
  1352.     TSignedSeqPos shift;
  1353.     if ( !reversed ) {
  1354.         shift = ref_seg_range.GetFrom() - master_seg_range.GetFrom();
  1355.     }
  1356.     else {
  1357.         shift = ref_seg_range.GetTo() + master_seg_range.GetFrom();
  1358.     }
  1359.     CSeq_id_Handle ref_id = seg.GetRefSeqid();
  1360.     CHandleRangeMap ref_loc;
  1361.     {{ // translate master_loc to ref_loc
  1362.         CHandleRange& hr = ref_loc.AddRanges(ref_id);
  1363.         ITERATE ( CHandleRange, mlit, master_hr ) {
  1364.             CHandleRange::TOpenRange range =
  1365.                 master_seg_range.IntersectionWith(mlit->first);
  1366.             if ( !range.Empty() ) {
  1367.                 ENa_strand strand = mlit->second;
  1368.                 if ( !reversed ) {
  1369.                     range.SetOpen(range.GetFrom() + shift,
  1370.                                   range.GetToOpen() + shift);
  1371.                 }
  1372.                 else {
  1373.                     strand = Reverse(strand);
  1374.                     range.Set(shift - range.GetTo(), shift - range.GetFrom());
  1375.                 }
  1376.                 hr.AddRange(range, strand);
  1377.             }
  1378.         }
  1379.         if ( hr.Empty() )
  1380.             return false;
  1381.     }}
  1383.     if (m_Selector.m_NoMapping) {
  1384.         return x_Search(ref_loc, 0);
  1385.     }
  1386.     else {
  1387.         CRef<CSeq_loc_Conversion> cvt(new CSeq_loc_Conversion(master_loc_empty,
  1388.                                                               master_id,
  1389.                                                               seg,
  1390.                                                               ref_id,
  1391.                                                               m_Scope));
  1392.         return x_Search(ref_loc, &*cvt);
  1393.     }
  1394. }
  1397. END_SCOPE(objects)
  1398. END_NCBI_SCOPE
  1400. /*
  1401. * ---------------------------------------------------------------------------
  1402. * $Log: annot_collector.cpp,v $
  1403. * Revision 1000.3  2004/06/01 19:22:32  gouriano
  1404. * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.7
  1405. *
  1406. * Revision 1.7  2004/05/26 14:29:20  grichenk
  1407. * Redesigned CSeq_align_Mapper: preserve non-mapping intervals,
  1408. * fixed strands handling, improved performance.
  1409. *
  1410. * Revision 1.6  2004/05/21 21:42:12  gorelenk
  1411. * Added PCH ncbi_pch.hpp
  1412. *
  1413. * Revision 1.5  2004/05/10 18:26:37  grichenk
  1414. * Fixed 'not used' warnings
  1415. *
  1416. * Revision 1.4  2004/05/03 17:01:03  grichenk
  1417. * Invalidate total range before reusing seq-loc.
  1418. *
  1419. * Revision 1.3  2004/04/13 21:14:27  vasilche
  1420. * Fixed wrong order of object deletion causing "tse is locked" error.
  1421. *
  1422. * Revision 1.2  2004/04/13 15:59:35  grichenk
  1423. * Added CScope::GetBioseqHandle() with id resolving flag.
  1424. *
  1425. * Revision 1.1  2004/04/05 15:54:26  grichenk
  1426. * Initial revision
  1427. *
  1428. *
  1429. * ===========================================================================
  1430. */