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

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

生物技术

开发平台：

C/C++

annot_selector.cpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: annot_selector.cpp,v $
  4.  * PRODUCTION Revision 1000.3  2004/06/01 19:22:41  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.12
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. /*  $Id: annot_selector.cpp,v 1000.3 2004/06/01 19:22:41 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. *
  39. */
  41. #include <ncbi_pch.hpp>
  42. #include <objmgr/annot_selector.hpp>
  43. #include <objmgr/impl/tse_info.hpp>
  44. #include <objmgr/impl/seq_entry_info.hpp>
  45. #include <objmgr/impl/seq_annot_info.hpp>
  46. #include <objmgr/impl/annot_type_index.hpp>
  48. #include <objmgr/seq_entry_handle.hpp>
  49. #include <objmgr/seq_annot_handle.hpp>
  51. #include <objects/seqset/Seq_entry.hpp>
  52. #include <objects/seq/Seq_annot.hpp>
  54. #include <algorithm>
  56. BEGIN_NCBI_SCOPE
  57. BEGIN_SCOPE(objects)
  59. ////////////////////////////////////////////////////////////////////
  60. //
  61. //  SAnnotSelector
  62. //
  64. SAnnotSelector::SAnnotSelector(TAnnotType annot,
  65.                                TFeatType feat)
  66.     : SAnnotTypeSelector(annot),
  67.       m_FeatProduct(false),
  68.       m_ResolveDepth(kMax_Int),
  69.       m_OverlapType(eOverlap_Intervals),
  70.       m_ResolveMethod(eResolve_TSE),
  71.       m_SegmentSelect(eSegmentSelect_All),
  72.       m_SortOrder(eSortOrder_Normal),
  73.       m_CombineMethod(eCombine_None),
  74.       m_LimitObjectType(eLimit_None),
  75.       m_IdResolving(eIgnoreUnresolved),
  76.       m_MaxSize(kMax_UInt),
  77.       m_NoMapping(false),
  78.       m_AdaptiveDepth(false)
  79. {
  80.     if ( feat != CSeqFeatData::e_not_set ) {
  81.         SetFeatType(feat);
  82.     }
  83. }
  85. SAnnotSelector::SAnnotSelector(TFeatType feat)
  86.     : SAnnotTypeSelector(feat),
  87.       m_FeatProduct(false),
  88.       m_ResolveDepth(kMax_Int),
  89.       m_OverlapType(eOverlap_Intervals),
  90.       m_ResolveMethod(eResolve_TSE),
  91.       m_SegmentSelect(eSegmentSelect_All),
  92.       m_SortOrder(eSortOrder_Normal),
  93.       m_CombineMethod(eCombine_None),
  94.       m_LimitObjectType(eLimit_None),
  95.       m_IdResolving(eIgnoreUnresolved),
  96.       m_MaxSize(kMax_UInt),
  97.       m_NoMapping(false),
  98.       m_AdaptiveDepth(false)
  99. {
  100. }
  103. SAnnotSelector::SAnnotSelector(TAnnotType annot,
  104.                                TFeatType feat,
  105.                                bool feat_product)
  106.     : SAnnotTypeSelector(annot),
  107.       m_FeatProduct(feat_product),
  108.       m_ResolveDepth(kMax_Int),
  109.       m_OverlapType(eOverlap_Intervals),
  110.       m_ResolveMethod(eResolve_TSE),
  111.       m_SegmentSelect(eSegmentSelect_All),
  112.       m_SortOrder(eSortOrder_Normal),
  113.       m_CombineMethod(eCombine_None),
  114.       m_LimitObjectType(eLimit_None),
  115.       m_IdResolving(eIgnoreUnresolved),
  116.       m_MaxSize(kMax_UInt),
  117.       m_NoMapping(false),
  118.       m_AdaptiveDepth(false)
  119. {
  120.     if ( feat != CSeqFeatData::e_not_set ) {
  121.         SetFeatType(feat);
  122.     }
  123. }
  125. SAnnotSelector::SAnnotSelector(TFeatType feat,
  126.                                bool feat_product)
  127.     : SAnnotTypeSelector(feat),
  128.       m_FeatProduct(feat_product),
  129.       m_ResolveDepth(kMax_Int),
  130.       m_OverlapType(eOverlap_Intervals),
  131.       m_ResolveMethod(eResolve_TSE),
  132.       m_SegmentSelect(eSegmentSelect_All),
  133.       m_SortOrder(eSortOrder_Normal),
  134.       m_CombineMethod(eCombine_None),
  135.       m_LimitObjectType(eLimit_None),
  136.       m_IdResolving(eIgnoreUnresolved),
  137.       m_MaxSize(kMax_UInt),
  138.       m_NoMapping(false),
  139.       m_AdaptiveDepth(false)
  140. {
  141. }
  144. SAnnotSelector::SAnnotSelector(const SAnnotSelector& sel)
  145. {
  146.     *this = sel;
  147. }
  150. SAnnotSelector& SAnnotSelector::operator=(const SAnnotSelector& sel)
  151. {
  152.     if ( this != &sel ) {
  153.         static_cast<SAnnotTypeSelector&>(*this) = sel;
  154.         m_FeatProduct = sel.m_FeatProduct;
  155.         m_ResolveDepth = sel.m_ResolveDepth;
  156.         m_OverlapType = sel.m_OverlapType;
  157.         m_ResolveMethod = sel.m_ResolveMethod;
  158.         m_SegmentSelect = sel.m_SegmentSelect;
  159.         m_SortOrder = sel.m_SortOrder;
  160.         m_CombineMethod = sel.m_CombineMethod;
  161.         m_LimitObjectType = sel.m_LimitObjectType;
  162.         m_IdResolving = sel.m_IdResolving;
  163.         m_LimitObject = sel.m_LimitObject;
  164.         m_MaxSize = sel.m_MaxSize;
  165.         m_IncludeAnnotsNames = sel.m_IncludeAnnotsNames;
  166.         m_ExcludeAnnotsNames = sel.m_ExcludeAnnotsNames;
  167.         m_NoMapping = sel.m_NoMapping;
  168.         m_AdaptiveDepth = sel.m_AdaptiveDepth;
  169.         m_AdaptiveTriggers = sel.m_AdaptiveTriggers;
  170.         m_ExcludedTSE = sel.m_ExcludedTSE;
  171.         m_AnnotTypesSet = sel.m_AnnotTypesSet;
  172.     }
  173.     return *this;
  174. }
  177. SAnnotSelector::~SAnnotSelector(void)
  178. {
  179. }
  182. SAnnotSelector& SAnnotSelector::SetLimitNone(void)
  183. {
  184.     m_LimitObjectType = eLimit_None;
  185.     m_LimitObject.Reset();
  186.     return *this;
  187. }
  190. SAnnotSelector&
  191. SAnnotSelector::SetLimitTSE(const CSeq_entry_Handle& limit)
  192. {
  193.     if ( !limit )
  194.         return SetLimitNone();
  195.     
  196.     const CTSE_Info& info = limit.x_GetInfo().GetTSE_Info();
  197.     m_LimitObjectType = eLimit_TSE_Info;
  198.     m_LimitObject.Reset(&info);
  199.     return *this;
  200. }
  203. SAnnotSelector&
  204. SAnnotSelector::SetLimitSeqEntry(const CSeq_entry_Handle& limit)
  205. {
  206.     if ( !limit )
  207.         return SetLimitNone();
  208.     
  209.     const CSeq_entry_Info& info = limit.x_GetInfo();
  210.     m_LimitObjectType = eLimit_Seq_entry_Info;
  211.     m_LimitObject.Reset(&info);
  212.     return *this;
  213. }
  216. SAnnotSelector&
  217. SAnnotSelector::SetLimitSeqAnnot(const CSeq_annot_Handle& limit)
  218. {
  219.     if ( !limit )
  220.         return SetLimitNone();
  221.     
  222.     const CSeq_annot_Info& info = limit.x_GetInfo();
  223.     m_LimitObjectType = eLimit_Seq_annot_Info;
  224.     m_LimitObject.Reset(&info);
  225.     return *this;
  226. }
  229. SAnnotSelector&
  230. SAnnotSelector::SetLimitTSE(const CSeq_entry* limit)
  231. {
  232.     if ( !limit )
  233.         return SetLimitNone();
  234.     
  235.     m_LimitObjectType = eLimit_TSE;
  236.     m_LimitObject.Reset(limit);
  237.     return *this;
  238. }
  241. SAnnotSelector&
  242. SAnnotSelector::SetLimitSeqEntry(const CSeq_entry* limit)
  243. {
  244.     if ( !limit )
  245.         return SetLimitNone();
  246.     
  247.     m_LimitObjectType = eLimit_Seq_entry;
  248.     m_LimitObject.Reset(limit);
  249.     return *this;
  250. }
  253. SAnnotSelector&
  254. SAnnotSelector::SetLimitSeqAnnot(const CSeq_annot* limit)
  255. {
  256.     if ( !limit )
  257.         return SetLimitNone();
  258.     
  259.     m_LimitObjectType = eLimit_Seq_annot;
  260.     m_LimitObject.Reset(limit);
  261.     return *this;
  262. }
  265. bool SAnnotSelector::x_Has(const TAnnotsNames& names, const CAnnotName& name)
  266. {
  267.     return find(names.begin(), names.end(), name) != names.end();
  268. }
  271. void SAnnotSelector::x_Add(TAnnotsNames& names, const CAnnotName& name)
  272. {
  273.     if ( !x_Has(names, name) ) {
  274.         names.push_back(name);
  275.     }
  276. }
  279. void SAnnotSelector::x_Del(TAnnotsNames& names, const CAnnotName& name)
  280. {
  281.     NON_CONST_ITERATE( TAnnotsNames, it, names ) {
  282.         if ( *it == name ) {
  283.             names.erase(it);
  284.             return;
  285.         }
  286.     }
  287. }
  290. bool SAnnotSelector::IncludedAnnotName(const CAnnotName& name) const
  291. {
  292.     return x_Has(m_IncludeAnnotsNames, name);
  293. }
  296. bool SAnnotSelector::ExcludedAnnotName(const CAnnotName& name) const
  297. {
  298.     return x_Has(m_ExcludeAnnotsNames, name);
  299. }
  302. SAnnotSelector& SAnnotSelector::ResetAnnotsNames(void)
  303. {
  304.     m_IncludeAnnotsNames.clear();
  305.     m_ExcludeAnnotsNames.clear();
  306.     return *this;
  307. }
  310. SAnnotSelector& SAnnotSelector::AddNamedAnnots(const CAnnotName& name)
  311. {
  312.     x_Add(m_IncludeAnnotsNames, name);
  313.     x_Del(m_ExcludeAnnotsNames, name);
  314.     return *this;
  315. }
  318. SAnnotSelector& SAnnotSelector::AddNamedAnnots(const char* name)
  319. {
  320.     return AddNamedAnnots(CAnnotName(name));
  321. }
  324. SAnnotSelector& SAnnotSelector::AddUnnamedAnnots(void)
  325. {
  326.     return AddNamedAnnots(CAnnotName());
  327. }
  330. SAnnotSelector& SAnnotSelector::ExcludeNamedAnnots(const CAnnotName& name)
  331. {
  332.     x_Add(m_ExcludeAnnotsNames, name);
  333.     x_Del(m_IncludeAnnotsNames, name);
  334.     return *this;
  335. }
  338. SAnnotSelector& SAnnotSelector::ExcludeNamedAnnots(const char* name)
  339. {
  340.     return ExcludeNamedAnnots(CAnnotName(name));
  341. }
  344. SAnnotSelector& SAnnotSelector::ExcludeUnnamedAnnots(void)
  345. {
  346.     return ExcludeNamedAnnots(CAnnotName());
  347. }
  350. SAnnotSelector& SAnnotSelector::SetAllNamedAnnots(void)
  351. {
  352.     ResetAnnotsNames();
  353.     ExcludeUnnamedAnnots();
  354.     return *this;
  355. }
  358. SAnnotSelector& SAnnotSelector::SetDataSource(const string& source)
  359. {
  360.     if ( source.empty() ) {
  361.         AddUnnamedAnnots();
  362.     }
  363.     return AddNamedAnnots(source);
  364. }
  367. SAnnotSelector&
  368. SAnnotSelector::SetAdaptiveTrigger(const SAnnotTypeSelector& sel)
  369. {
  370.     ITERATE ( TAdaptiveTriggers, it, m_AdaptiveTriggers ) {
  371.         if ( *it == sel ) {
  372.             return *this;
  373.         }
  374.     }
  375.     m_AdaptiveTriggers.push_back(sel);
  376.     return *this;
  377. }
  380. SAnnotSelector&
  381. SAnnotSelector::ExcludeTSE(const CSeq_entry_Handle& tse)
  382. {
  383.     if ( !ExcludedTSE(tse) ) {
  384.         m_ExcludedTSE.push_back(tse);
  385.     }
  386.     return *this;
  387. }
  390. SAnnotSelector&
  391. SAnnotSelector::ResetExcludedTSE(void)
  392. {
  393.     m_ExcludedTSE.clear();
  394.     return *this;
  395. }
  398. bool SAnnotSelector::ExcludedTSE(const CSeq_entry_Handle& tse) const
  399. {
  400.     return find(m_ExcludedTSE.begin(), m_ExcludedTSE.end(), tse)
  401.         != m_ExcludedTSE.end();
  402. }
  405. void SAnnotSelector::x_ClearAnnotTypesSet(void)
  406. {
  407.     m_AnnotTypesSet.clear();
  408. }
  411. void SAnnotSelector::x_InitializeAnnotTypesSet(bool default_value)
  412. {
  413.     if (m_AnnotTypesSet.size() > 0) {
  414.         return;
  415.     }
  416.     m_AnnotTypesSet.resize(CAnnotType_Index::GetAnnotTypeRange(
  417.         CSeq_annot::C_Data::e_Ftable).second, default_value);
  418.     // Do not try to use flags from an uninitialized selector
  419.     if (GetAnnotType() != CSeq_annot::C_Data::e_not_set) {
  420.         // Copy current state to the set
  421.         CAnnotType_Index::TIndexRange range =
  422.             CAnnotType_Index::GetIndexRange(*this);
  423.         for (size_t i = range.first; i < range.second; ++i) {
  424.             m_AnnotTypesSet[i] = true;
  425.         }
  426.     }
  427.     // Do not call this->SetAnnotType() -- it will reset the types set.
  428.     // Set type to Ftable -- only feature types/subtypes may be selected.
  429.     SAnnotTypeSelector::SetAnnotType(CSeq_annot::C_Data::e_Ftable);
  430. }
  433. SAnnotSelector& SAnnotSelector::IncludeAnnotType(TAnnotType type)
  434. {
  435.     if (GetAnnotType() == CSeq_annot::C_Data::e_not_set) {
  436.         SAnnotTypeSelector::SetAnnotType(type);
  437.     }
  438.     else if (m_AnnotTypesSet.size() > 0  ||  !IncludedAnnotType(type)) {
  439.         x_InitializeAnnotTypesSet(false);
  440.         CAnnotType_Index::TIndexRange range =
  441.             CAnnotType_Index::GetAnnotTypeRange(type);
  442.         for (size_t i = range.first; i < range.second; ++i) {
  443.             m_AnnotTypesSet[i] = true;
  444.         }
  445.     }
  446.     return *this;
  447. }
  450. SAnnotSelector& SAnnotSelector::ExcludeAnnotType(TAnnotType type)
  451. {
  452.     if (GetAnnotType() == CSeq_annot::C_Data::e_not_set
  453.         ||  m_AnnotTypesSet.size() > 0  ||  IncludedAnnotType(type)) {
  454.         x_InitializeAnnotTypesSet(true);
  455.         CAnnotType_Index::TIndexRange range =
  456.             CAnnotType_Index::GetAnnotTypeRange(type);
  457.         for (size_t i = range.first; i < range.second; ++i) {
  458.             m_AnnotTypesSet[i] = false;
  459.         }
  460.     }
  461.     return *this;
  462. }
  465. SAnnotSelector& SAnnotSelector::IncludeFeatType(TFeatType type)
  466. {
  467.     if (GetAnnotType() == CSeq_annot::C_Data::e_not_set) {
  468.         SAnnotTypeSelector::SetFeatType(type);
  469.     }
  470.     else if (m_AnnotTypesSet.size() > 0  ||  !IncludedFeatType(type)) {
  471.         x_InitializeAnnotTypesSet(false);
  472.         CAnnotType_Index::TIndexRange range =
  473.             CAnnotType_Index::GetFeatTypeRange(type);
  474.         for (size_t i = range.first; i < range.second; ++i) {
  475.             m_AnnotTypesSet[i] = true;
  476.         }
  477.     }
  478.     return *this;
  479. }
  482. SAnnotSelector& SAnnotSelector::ExcludeFeatType(TFeatType type)
  483. {
  484.     if (GetAnnotType() == CSeq_annot::C_Data::e_not_set
  485.         ||  m_AnnotTypesSet.size() > 0  ||  IncludedFeatType(type)) {
  486.         x_InitializeAnnotTypesSet(true);
  487.         CAnnotType_Index::TIndexRange range =
  488.             CAnnotType_Index::GetFeatTypeRange(type);
  489.         for (size_t i = range.first; i < range.second; ++i) {
  490.             m_AnnotTypesSet[i] = false;
  491.         }
  492.     }
  493.     return *this;
  494. }
  497. SAnnotSelector& SAnnotSelector::IncludeFeatSubtype(TFeatSubtype subtype)
  498. {
  499.     if (GetAnnotType() == CSeq_annot::C_Data::e_not_set) {
  500.         SAnnotTypeSelector::SetFeatSubtype(subtype);
  501.     }
  502.     else if (m_AnnotTypesSet.size() > 0  ||  !IncludedFeatSubtype(subtype)) {
  503.         x_InitializeAnnotTypesSet(false);
  504.         m_AnnotTypesSet[CAnnotType_Index::GetSubtypeIndex(subtype)] = true;
  505.     }
  506.     return *this;
  507. }
  510. SAnnotSelector& SAnnotSelector::ExcludeFeatSubtype(TFeatSubtype subtype)
  511. {
  512.     if (GetAnnotType() == CSeq_annot::C_Data::e_not_set
  513.         ||  m_AnnotTypesSet.size() > 0  ||  IncludedFeatSubtype(subtype)) {
  514.         x_InitializeAnnotTypesSet(true);
  515.         m_AnnotTypesSet[CAnnotType_Index::GetSubtypeIndex(subtype)] = false;
  516.     }
  517.     return *this;
  518. }
  521. SAnnotSelector& SAnnotSelector::CheckAnnotType(TAnnotType type)
  522. {
  523.     if (GetAnnotType() == CSeq_annot::C_Data::e_not_set) {
  524.         SetAnnotType(type);
  525.     }
  526.     _ASSERT(GetAnnotType() == type);
  527.     if (m_AnnotTypesSet.size() > 0) {
  528.         CAnnotType_Index::TIndexRange range =
  529.             CAnnotType_Index::GetAnnotTypeRange(type);
  530.         for (size_t i = 0; i < range.first; ++i) {
  531.             m_AnnotTypesSet[i] = false;
  532.         }
  533.         for (size_t i = range.second; i < m_AnnotTypesSet.size(); ++i) {
  534.             m_AnnotTypesSet[i] = false;
  535.         }
  536.     }
  537.     return *this;
  538. }
  541. bool SAnnotSelector::IncludedAnnotType(TAnnotType type) const
  542. {
  543.     if (m_AnnotTypesSet.size() > 0) {
  544.         CAnnotType_Index::TIndexRange range =
  545.             CAnnotType_Index::GetAnnotTypeRange(type);
  546.         for (size_t i = range.first; i < range.second; ++i) {
  547.             if (m_AnnotTypesSet[i]) {
  548.                 return true;
  549.             }
  550.         }
  551.         return false;
  552.     }
  553.     return GetAnnotType() == CSeq_annot::C_Data::e_not_set
  554.         || GetAnnotType() == type;
  555. }
  558. bool SAnnotSelector::IncludedFeatType(TFeatType type) const
  559. {
  560.     if (m_AnnotTypesSet.size() > 0) {
  561.         CAnnotType_Index::TIndexRange range =
  562.             CAnnotType_Index::GetFeatTypeRange(type);
  563.         for (size_t i = range.first; i < range.second; ++i) {
  564.             if (m_AnnotTypesSet[i]) {
  565.                 return true;
  566.             }
  567.         }
  568.         return false;
  569.     }
  570.     return GetFeatType() == CSeqFeatData::e_not_set
  571.         || GetFeatType() == type;
  572. }
  575. bool SAnnotSelector::IncludedFeatSubtype(TFeatSubtype subtype) const
  576. {
  577.     if (m_AnnotTypesSet.size() > 0) {
  578.         return m_AnnotTypesSet[CAnnotType_Index::GetSubtypeIndex(subtype)];
  579.     }
  580.     return GetFeatSubtype() == subtype
  581.         ||  GetFeatSubtype() == CSeqFeatData::eSubtype_any;
  582. }
  585. bool SAnnotSelector::MatchType(const CAnnotObject_Info& annot_info) const
  586. {
  587.     if (annot_info.GetFeatSubtype() != CSeqFeatData::eSubtype_any) {
  588.         return IncludedFeatSubtype(annot_info.GetFeatSubtype());
  589.     }
  590.     if (annot_info.GetFeatType() != CSeqFeatData::e_not_set) {
  591.         return IncludedFeatType(annot_info.GetFeatType());
  592.     }
  593.     return IncludedAnnotType(annot_info.GetAnnotType());
  594. }
  597. END_SCOPE(objects)
  598. END_NCBI_SCOPE
  600. /*
  601. * ---------------------------------------------------------------------------
  602. * $Log: annot_selector.cpp,v $
  603. * Revision 1000.3  2004/06/01 19:22:41  gouriano
  604. * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.12
  605. *
  606. * Revision 1.12  2004/05/21 21:42:12  gorelenk
  607. * Added PCH ncbi_pch.hpp
  608. *
  609. * Revision 1.11  2004/03/17 16:04:26  vasilche
  610. * IRIX CC doesn't allow explicit call of implicit operator=()
  611. *
  612. * Revision 1.10  2004/03/16 15:47:27  vasilche
  613. * Added CBioseq_set_Handle and set of EditHandles
  614. *
  615. * Revision 1.9  2004/02/26 14:41:40  grichenk
  616. * Fixed types excluding in SAnnotSelector and multiple types search
  617. * in CAnnotTypes_CI.
  618. *
  619. * Revision 1.8  2004/02/11 22:19:24  grichenk
  620. * Fixed annot type initialization in iterators
  621. *
  622. * Revision 1.7  2004/02/05 19:53:40  grichenk
  623. * Fixed type matching in SAnnotSelector. Added IncludeAnnotType().
  624. *
  625. * Revision 1.6  2004/02/05 16:05:49  vasilche
  626. * Fixed int <-> unsigned warning.
  627. *
  628. * Revision 1.5  2004/02/04 18:05:38  grichenk
  629. * Added annotation filtering by set of types/subtypes.
  630. * Renamed *Choice to *Type in SAnnotSelector.
  631. *
  632. * Revision 1.4  2004/01/23 16:14:47  grichenk
  633. * Implemented alignment mapping
  634. *
  635. * Revision 1.3  2003/11/13 19:12:52  grichenk
  636. * Added possibility to exclude TSEs from annotations request.
  637. *
  638. * Revision 1.2  2003/10/09 20:20:58  vasilche
  639. * Added possibility to include and exclude Seq-annot names to annot iterator.
  640. * Fixed adaptive search. It looked only on selected set of annot names before.
  641. *
  642. * Revision 1.1  2003/10/07 13:43:23  vasilche
  643. * Added proper handling of named Seq-annots.
  644. * Added feature search from named Seq-annots.
  645. * Added configurable adaptive annotation search (default: gene, cds, mrna).
  646. * Fixed selection of blobs for loading from GenBank.
  647. * Added debug checks to CSeq_id_Mapper for easier finding lost CSeq_id_Handles.
  648. * Fixed leaked split chunks annotation stubs.
  649. * Moved some classes definitions in separate *.cpp files.
  650. *
  651. * Revision 1.27  2003/09/30 16:22:02  vasilche
  652. * Updated internal object manager classes to be able to load ID2 data.
  653. * SNP blobs are loaded as ID2 split blobs - readers convert them automatically.
  654. * Scope caches results of requests for data to data loaders.
  655. * Optimized CSeq_id_Handle for gis.
  656. * Optimized bioseq lookup in scope.
  657. * Reduced object allocations in annotation iterators.
  658. * CScope is allowed to be destroyed before other objects using this scope are
  659. * deleted (feature iterators, bioseq handles etc).
  660. * Optimized lookup for matching Seq-ids in CSeq_id_Mapper.
  661. * Added 'adaptive' option to objmgr_demo application.
  662. *
  663. * Revision 1.26  2003/08/27 21:24:51  vasilche
  664. * Reordered member initializers.
  665. *
  666. * Revision 1.25  2003/08/27 14:29:52  vasilche
  667. * Reduce object allocations in feature iterator.
  668. *
  669. * Revision 1.24  2003/08/26 21:28:47  grichenk
  670. * Added seq-align verification
  671. *
  672. * Revision 1.23  2003/07/18 16:58:23  grichenk
  673. * Fixed alignment coordinates
  674. *
  675. * Revision 1.22  2003/07/17 20:07:55  vasilche
  676. * Reduced memory usage by feature indexes.
  677. * SNP data is loaded separately through PUBSEQ_OS.
  678. * String compression for SNP data.
  679. *
  680. * Revision 1.21  2003/06/02 16:06:37  dicuccio
  681. * Rearranged src/objects/ subtree.  This includes the following shifts:
  682. *     - src/objects/asn2asn --> arc/app/asn2asn
  683. *     - src/objects/testmedline --> src/objects/ncbimime/test
  684. *     - src/objects/objmgr --> src/objmgr
  685. *     - src/objects/util --> src/objmgr/util
  686. *     - src/objects/alnmgr --> src/objtools/alnmgr
  687. *     - src/objects/flat --> src/objtools/flat
  688. *     - src/objects/validator --> src/objtools/validator
  689. *     - src/objects/cddalignview --> src/objtools/cddalignview
  690. * In addition, libseq now includes six of the objects/seq... libs, and libmmdb
  691. * replaces the three libmmdb? libs.
  692. *
  693. * Revision 1.20  2003/04/24 16:12:38  vasilche
  694. * Object manager internal structures are splitted more straightforward.
  695. * Removed excessive header dependencies.
  696. *
  697. * Revision 1.19  2003/03/11 15:51:06  kuznets
  698. * iterate -> ITERATE
  699. *
  700. * Revision 1.18  2003/02/24 18:57:22  vasilche
  701. * Make feature gathering in one linear pass using CSeqMap iterator.
  702. * Do not use feture index by sub locations.
  703. * Sort features at the end of gathering in one vector.
  704. * Extracted some internal structures and classes in separate header.
  705. * Delay creation of mapped features.
  706. *
  707. * Revision 1.17  2003/02/13 14:34:34  grichenk
  708. * Renamed CAnnotObject -> CAnnotObject_Info
  709. * + CSeq_annot_Info and CAnnotObject_Ref
  710. * Moved some members of CAnnotObject to CSeq_annot_Info
  711. * and CAnnotObject_Ref.
  712. * Added feat/align/graph to CAnnotObject_Info map
  713. * to CDataSource.
  714. *
  715. * Revision 1.16  2003/02/04 18:53:36  dicuccio
  716. * Include file clean-up
  717. *
  718. * Revision 1.15  2003/01/22 20:11:54  vasilche
  719. * Merged functionality of CSeqMapResolved_CI to CSeqMap_CI.
  720. * CSeqMap_CI now supports resolution and iteration over sequence range.
  721. * Added several caches to CScope.
  722. * Optimized CSeqVector().
  723. * Added serveral variants of CBioseqHandle::GetSeqVector().
  724. * Tried to optimize annotations iterator (not much success).
  725. * Rewritten CHandleRange and CHandleRangeMap classes to avoid sorting of list.
  726. *
  727. * Revision 1.14  2002/09/13 15:20:30  dicuccio
  728. * Fix memory leak (static deleted before termination).
  729. *
  730. * Revision 1.13  2002/09/11 16:08:26  dicuccio
  731. * Fixed memory leak in x_PrepareAlign().
  732. *
  733. * Revision 1.12  2002/09/03 17:45:45  ucko
  734. * Avoid overrunning alignment data when the claimed dimensions are too high.
  735. *
  736. * Revision 1.11  2002/07/25 15:01:51  grichenk
  737. * Replaced non-const GetXXX() with SetXXX()
  738. *
  739. * Revision 1.10  2002/07/08 20:51:00  grichenk
  740. * Moved log to the end of file
  741. * Replaced static mutex (in CScope, CDataSource) with the mutex
  742. * pool. Redesigned CDataSource data locking.
  743. *
  744. * Revision 1.9  2002/07/01 15:31:57  grichenk
  745. * Fixed 'enumeration value e_not_set...' warning
  746. *
  747. * Revision 1.8  2002/05/29 21:21:13  gouriano
  748. * added debug dump
  749. *
  750. * Revision 1.7  2002/05/24 14:57:12  grichenk
  751. * SerialAssign<>() -> CSerialObject::Assign()
  752. *
  753. * Revision 1.6  2002/05/03 21:28:08  ucko
  754. * Introduce T(Signed)SeqPos.
  755. *
  756. * Revision 1.5  2002/04/05 21:26:19  grichenk
  757. * Enabled iteration over annotations defined on segments of a
  758. * delta-sequence.
  759. *
  760. * Revision 1.4  2002/02/21 19:27:04  grichenk
  761. * Rearranged includes. Added scope history. Added searching for the
  762. * best seq-id match in data sources and scopes. Updated tests.
  763. *
  764. * Revision 1.3  2002/01/23 21:59:31  grichenk
  765. * Redesigned seq-id handles and mapper
  766. *
  767. * Revision 1.2  2002/01/16 16:25:56  gouriano
  768. * restructured objmgr
  769. *
  770. * Revision 1.1  2002/01/11 19:06:16  gouriano
  771. * restructured objmgr
  772. *
  773. *
  774. * ===========================================================================
  775. */