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

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

生物技术

开发平台：

C/C++

annot_selector.hpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: annot_selector.hpp,v $
  4.  * PRODUCTION Revision 1000.2  2004/04/12 17:26:57  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [CATCHUP_003] Dev-tree R1.30
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. #ifndef ANNOT_SELECTOR__HPP
  11. #define ANNOT_SELECTOR__HPP
  13. /*  $Id: annot_selector.hpp,v 1000.2 2004/04/12 17:26:57 gouriano Exp $
  14. * ===========================================================================
  15. *
  16. *                            PUBLIC DOMAIN NOTICE
  17. *               National Center for Biotechnology Information
  18. *
  19. *  This software/database is a "United States Government Work" under the
  20. *  terms of the United States Copyright Act.  It was written as part of
  21. *  the author's official duties as a United States Government employee and
  22. *  thus cannot be copyrighted.  This software/database is freely available
  23. *  to the public for use. The National Library of Medicine and the U.S.
  24. *  Government have not placed any restriction on its use or reproduction.
  25. *
  26. *  Although all reasonable efforts have been taken to ensure the accuracy
  27. *  and reliability of the software and data, the NLM and the U.S.
  28. *  Government do not and cannot warrant the performance or results that
  29. *  may be obtained by using this software or data. The NLM and the U.S.
  30. *  Government disclaim all warranties, express or implied, including
  31. *  warranties of performance, merchantability or fitness for any particular
  32. *  purpose.
  33. *
  34. *  Please cite the author in any work or product based on this material.
  35. *
  36. * ===========================================================================
  37. *
  38. * Author: Aleksey Grichenko, Michael Kimelman, Eugene Vasilchenko
  39. *
  40. * File Description:
  41. *   Annotations selector structure.
  42. *
  43. */
  46. #include <corelib/ncbi_limits.h>
  47. #include <objects/seq/Seq_annot.hpp>
  48. #include <objects/seqfeat/SeqFeatData.hpp>
  50. #include <vector>
  52. BEGIN_NCBI_SCOPE
  53. BEGIN_SCOPE(objects)
  55. class CSeq_entry;
  56. class CSeq_annot;
  58. class CSeq_entry_Handle;
  59. class CSeq_annot_Handle;
  60. class CAnnotObject_Info;
  62. class CAnnotName
  63. {
  64. public:
  65.     CAnnotName(void)
  66.         : m_Named(false)
  67.         {
  68.         }
  69.     CAnnotName(const string& name)
  70.         : m_Named(true), m_Name(name)
  71.         {
  72.         }
  73.     CAnnotName(const char* name)
  74.         : m_Named(true), m_Name(name)
  75.         {
  76.         }
  78.     bool IsNamed(void) const
  79.         {
  80.             return m_Named;
  81.         }
  82.     const string& GetName(void) const
  83.         {
  84.             _ASSERT(m_Named);
  85.             return m_Name;
  86.         }
  88.     void SetUnnamed(void)
  89.         {
  90.             m_Named = false;
  91.             m_Name.erase();
  92.         }
  93.     void SetNamed(const string& name)
  94.         {
  95.             m_Name = name;
  96.             m_Named = true;
  97.         }
  99.     bool operator<(const CAnnotName& name) const
  100.         {
  101.             return name.m_Named && (!m_Named || name.m_Name > m_Name);
  102.         }
  103.     bool operator==(const CAnnotName& name) const
  104.         {
  105.             return name.m_Named == m_Named && name.m_Name == m_Name;
  106.         }
  107.     bool operator!=(const CAnnotName& name) const
  108.         {
  109.             return name.m_Named != m_Named || name.m_Name != m_Name;
  110.         }
  112. private:
  113.     bool   m_Named;
  114.     string m_Name;
  115. };
  118. struct SAnnotTypeSelector
  119. {
  120.     typedef CSeq_annot::C_Data::E_Choice TAnnotType;
  121.     typedef CSeqFeatData::E_Choice       TFeatType;
  122.     typedef CSeqFeatData::ESubtype       TFeatSubtype;
  124.     SAnnotTypeSelector(TAnnotType annot = CSeq_annot::C_Data::e_not_set)
  125.         : m_FeatSubtype(CSeqFeatData::eSubtype_any),
  126.           m_FeatType(CSeqFeatData::e_not_set),
  127.           m_AnnotType(annot)
  128.     {
  129.     }
  131.     SAnnotTypeSelector(TFeatType  feat)
  132.         : m_FeatSubtype(CSeqFeatData::eSubtype_any),
  133.           m_FeatType(feat),
  134.           m_AnnotType(CSeq_annot::C_Data::e_Ftable)
  135.     {
  136.     }
  138.     SAnnotTypeSelector(TFeatSubtype feat_subtype)
  139.         : m_FeatSubtype(feat_subtype),
  140.           m_FeatType(CSeqFeatData::GetTypeFromSubtype(feat_subtype)),
  141.           m_AnnotType(CSeq_annot::C_Data::e_Ftable)
  142.     {
  143.     }
  144.    
  145.     TAnnotType GetAnnotType(void) const
  146.         {
  147.             return TAnnotType(m_AnnotType);
  148.         }
  150.     TFeatType GetFeatType(void) const
  151.         {
  152.             return TFeatType(m_FeatType);
  153.         }
  155.     TFeatSubtype GetFeatSubtype(void) const
  156.         {
  157.             return TFeatSubtype(m_FeatSubtype);
  158.         }
  160.     bool operator<(const SAnnotTypeSelector& s) const
  161.         {
  162.             if ( m_AnnotType != s.m_AnnotType )
  163.                 return m_AnnotType < s.m_AnnotType;
  164.             if ( m_FeatType != s.m_FeatType )
  165.                 return m_FeatType < s.m_FeatType;
  166.             return m_FeatSubtype < s.m_FeatSubtype;
  167.         }
  169.     bool operator==(const SAnnotTypeSelector& s) const
  170.         {
  171.             return m_AnnotType == s.m_AnnotType &&
  172.                 m_FeatType == s.m_FeatType &&
  173.                 m_FeatSubtype == s.m_FeatSubtype;
  174.         }
  176.     bool operator!=(const SAnnotTypeSelector& s) const
  177.         {
  178.             return m_AnnotType != s.m_AnnotType ||
  179.                 m_FeatType != s.m_FeatType ||
  180.                 m_FeatSubtype != s.m_FeatSubtype;
  181.         }
  183.     void SetAnnotType(TAnnotType type)
  184.         {
  185.             m_AnnotType = type;
  186.             // Reset feature type/subtype
  187.             if (m_AnnotType != CSeq_annot::C_Data::e_Ftable) {
  188.                 m_FeatType = CSeqFeatData::e_not_set;
  189.                 m_FeatSubtype = CSeqFeatData::eSubtype_any;
  190.             }
  191.         }
  193.     void SetFeatType(TFeatType type)
  194.         {
  195.             m_FeatType = type;
  196.             // Adjust annot type and feature subtype
  197.             m_AnnotType = CSeq_annot::C_Data::e_Ftable;
  198.             m_FeatSubtype = CSeqFeatData::eSubtype_any;
  199.         }
  201.     void SetFeatSubtype(TFeatSubtype subtype)
  202.         {
  203.             m_FeatSubtype = subtype;
  204.             // Adjust annot type and feature type
  205.             m_AnnotType = CSeq_annot::C_Data::e_Ftable;
  206.             if (m_FeatSubtype != CSeqFeatData::eSubtype_any) {
  207.                 m_FeatType =
  208.                     CSeqFeatData::GetTypeFromSubtype(GetFeatSubtype());
  209.             }
  210.         }
  212. private:
  213.     Uint2           m_FeatSubtype;  // Seq-feat subtype
  214.     Uint1           m_FeatType;   // Seq-feat type
  215.     Uint1           m_AnnotType;  // Annotation type
  216. };
  218. // Structure to select type of Seq-annot
  219. struct NCBI_XOBJMGR_EXPORT SAnnotSelector : public SAnnotTypeSelector
  220. {
  221.     // Flag to indicate location overlapping method
  222.     enum EOverlapType {
  223.         eOverlap_Intervals,  // default - overlapping of individual intervals
  224.         eOverlap_TotalRange  // overlapping of total ranges only
  225.     };
  226.     // Flag to indicate references resolution method
  227.     enum EResolveMethod {
  228.         eResolve_None, // Do not search annotations on segments
  229.         eResolve_TSE,  // default - search only on segments in the same TSE
  230.         eResolve_All   // Search annotations for all referenced sequences
  231.     };
  232.     // Flag to indicate adaptive segment selection
  233.     enum ESegmentSelect {
  234.         eSegmentSelect_All,
  235.         eSegmentSelect_First,
  236.         eSegmentSelect_Last
  237.     };
  238.     // Flag to indicate sorting method
  239.     enum ESortOrder {
  240.         eSortOrder_None,    // do not sort annotations for faster retrieval
  241.         eSortOrder_Normal,  // default - increasing start, decreasing length
  242.         eSortOrder_Reverse  // decresing end, decreasing length
  243.     };
  244.     // Flag to indicate joining feature visible through multiple segments
  245.     enum ECombineMethod {
  246.         eCombine_None,       // default - do not combine feature from segments
  247.         eCombine_All         // combine feature from different segments
  248.     };
  249.     enum EIdResolving {
  250.         eLoadedOnly,       // Resolve only ids already loaded into the scope
  251.         eIgnoreUnresolved, // Ignore unresolved ids (default)
  252.         eFailUnresolved    // Throw exception for unresolved ids
  253.     };
  255.     SAnnotSelector(TAnnotType annot = CSeq_annot::C_Data::e_not_set,
  256.                    TFeatType  feat  = CSeqFeatData::e_not_set);
  257.     SAnnotSelector(TFeatType  feat);
  258.     SAnnotSelector(TAnnotType annot, TFeatType  feat, bool feat_product);
  259.     SAnnotSelector(TFeatType  feat, bool feat_product);
  260.     SAnnotSelector(const SAnnotSelector& sel);
  261.     SAnnotSelector& operator=(const SAnnotSelector& sel);
  262.     ~SAnnotSelector(void);
  263.     
  264.     SAnnotSelector& SetAnnotType(TAnnotType type)
  265.         {
  266.             x_ClearAnnotTypesSet();
  267.             SAnnotTypeSelector::SetAnnotType(type);
  268.             return *this;
  269.         }
  271.     SAnnotSelector& SetFeatType(TFeatType type)
  272.         {
  273.             x_ClearAnnotTypesSet();
  274.             SAnnotTypeSelector::SetFeatType(type);
  275.             return *this;
  276.         }
  278.     SAnnotSelector& SetFeatSubtype(TFeatSubtype subtype)
  279.         {
  280.             x_ClearAnnotTypesSet();
  281.             SAnnotTypeSelector::SetFeatSubtype(subtype);
  282.             return *this;
  283.         }
  285.     SAnnotSelector& IncludeAnnotType(TAnnotType type);
  286.     SAnnotSelector& ExcludeAnnotType(TAnnotType type);
  287.     SAnnotSelector& IncludeFeatType(TFeatType type);
  288.     SAnnotSelector& ExcludeFeatType(TFeatType type);
  289.     SAnnotSelector& IncludeFeatSubtype(TFeatSubtype subtype);
  290.     SAnnotSelector& ExcludeFeatSubtype(TFeatSubtype subtype);
  292.     // Set type if not set yet, else do nothing.
  293.     SAnnotSelector& CheckAnnotType(TAnnotType type);
  295.     // Return true if at least one subtype of the type is included
  296.     // or selected type is not set (any).
  297.     bool IncludedAnnotType(TAnnotType type) const;
  298.     bool IncludedFeatType(TFeatType type) const;
  299.     bool IncludedFeatSubtype(TFeatSubtype subtype) const;
  301.     bool MatchType(const CAnnotObject_Info& annot_info) const;
  303.     bool GetFeatProduct(void) const
  304.         {
  305.             return m_FeatProduct;
  306.         }
  307.     SAnnotSelector& SetByProduct(bool byProduct = true)
  308.         {
  309.             m_FeatProduct = byProduct;
  310.             return *this;
  311.         }
  313.     SAnnotSelector& SetOverlapType(EOverlapType overlap_type)
  314.         {
  315.             m_OverlapType = overlap_type;
  316.             return *this;
  317.         }
  318.     SAnnotSelector& SetOverlapIntervals(void)
  319.         {
  320.             return SetOverlapType(eOverlap_Intervals);
  321.         }
  322.     SAnnotSelector& SetOverlapTotalRange(void)
  323.         {
  324.             return SetOverlapType(eOverlap_TotalRange);
  325.         }
  327.     SAnnotSelector& SetSortOrder(ESortOrder sort_order)
  328.         {
  329.             m_SortOrder = sort_order;
  330.             return *this;
  331.         }
  333.     SAnnotSelector& SetCombineMethod(ECombineMethod combine_method)
  334.         {
  335.             m_CombineMethod = combine_method;
  336.             return *this;
  337.         }
  339.     SAnnotSelector& SetResolveMethod(EResolveMethod resolve_method)
  340.         {
  341.             m_ResolveMethod = resolve_method;
  342.             return *this;
  343.         }
  344.     SAnnotSelector& SetResolveNone(void)
  345.         {
  346.             return SetResolveMethod(eResolve_None);
  347.         }
  348.     SAnnotSelector& SetResolveTSE(void)
  349.         {
  350.             return SetResolveMethod(eResolve_TSE);
  351.         }
  352.     SAnnotSelector& SetResolveAll(void)
  353.         {
  354.             return SetResolveMethod(eResolve_All);
  355.         }
  357.     SAnnotSelector& SetResolveDepth(int depth)
  358.         {
  359.             m_ResolveDepth = depth;
  360.             return *this;
  361.         }
  363.     typedef vector<SAnnotTypeSelector> TAdaptiveTriggers;
  364.     SAnnotSelector& SetAdaptiveDepth(bool value = true)
  365.         {
  366.             m_AdaptiveDepth = value;
  367.             return *this;
  368.         }
  369.     SAnnotSelector& SetAdaptiveTrigger(const SAnnotTypeSelector& sel);
  371.     // set maximum count of annotations to find
  372.     // if max_size == 0 - no limit
  373.     SAnnotSelector& SetMaxSize(size_t max_size)
  374.         {
  375.             m_MaxSize = max_size? max_size: kMax_UInt;
  376.             return *this;
  377.         }
  379.     SAnnotSelector& SetSegmentSelect(ESegmentSelect ss)
  380.         {
  381.             m_SegmentSelect = ss;
  382.             return *this;
  383.         }
  384.     SAnnotSelector& SetSegmentSelectAll(void)
  385.         {
  386.             return SetSegmentSelect(eSegmentSelect_All);
  387.         }
  388.     SAnnotSelector& SetSegmentSelectFirst(void)
  389.         {
  390.             return SetSegmentSelect(eSegmentSelect_First);
  391.         }
  392.     SAnnotSelector& SetSegmentSelectLast(void)
  393.         {
  394.             return SetSegmentSelect(eSegmentSelect_Last);
  395.         }
  397.     SAnnotSelector& SetLimitNone(void);
  398.     SAnnotSelector& SetLimitTSE(const CSeq_entry* limit);
  399.     SAnnotSelector& SetLimitSeqEntry(const CSeq_entry* limit);
  400.     SAnnotSelector& SetLimitSeqAnnot(const CSeq_annot* limit);
  401.     SAnnotSelector& SetLimitTSE(const CSeq_entry_Handle& limit);
  402.     SAnnotSelector& SetLimitSeqEntry(const CSeq_entry_Handle& limit);
  403.     SAnnotSelector& SetLimitSeqAnnot(const CSeq_annot_Handle& limit);
  405.     SAnnotSelector& SetIdResolvingLoaded(void)
  406.         {
  407.             m_IdResolving = eLoadedOnly;
  408.             return *this;
  409.         }
  410.     SAnnotSelector& SetIdResolvingIgnore(void)
  411.         {
  412.             m_IdResolving = eIgnoreUnresolved;
  413.             return *this;
  414.         }
  415.     SAnnotSelector& SetIdResolvingFail(void)
  416.         {
  417.             m_IdResolving = eFailUnresolved;
  418.             return *this;
  419.         }
  421.     typedef vector<CAnnotName> TAnnotsNames;
  422.     /// Select annotations from all Seq-annots
  423.     SAnnotSelector& ResetAnnotsNames(void);
  424.     /// Add unnamed annots to set of annots names to look for
  425.     SAnnotSelector& AddUnnamedAnnots(void);
  426.     /// Add named annot to set of annots names to look for
  427.     SAnnotSelector& AddNamedAnnots(const CAnnotName& name);
  428.     SAnnotSelector& AddNamedAnnots(const char* name);
  429.     /// Add unnamed annots to set of annots names to exclude
  430.     SAnnotSelector& ExcludeUnnamedAnnots(void);
  431.     /// Add named annot to set of annots names to exclude
  432.     SAnnotSelector& ExcludeNamedAnnots(const CAnnotName& name);
  433.     SAnnotSelector& ExcludeNamedAnnots(const char* name);
  434.     /// Look for all named Seq-annots
  435.     SAnnotSelector& SetAllNamedAnnots(void);
  436.     // Compatibility:
  437.     /// Look for named annot.
  438.     /// If name is empty ("") look for unnamed annots too.
  439.     SAnnotSelector& SetDataSource(const string& name);
  441.     // Access methods for iterator
  442.     bool IsSetAnnotsNames(void) const
  443.         {
  444.             return
  445.                 !m_IncludeAnnotsNames.empty() ||
  446.                 !m_ExcludeAnnotsNames.empty();
  447.         }
  448.     bool IncludedAnnotName(const CAnnotName& name) const;
  449.     bool ExcludedAnnotName(const CAnnotName& name) const;
  451.     // Limit search with a set of TSEs
  452.     typedef vector<CSeq_entry_Handle> TTSE_Limits;
  453.     SAnnotSelector& ExcludeTSE(const CSeq_entry_Handle& tse);
  454.     SAnnotSelector& ResetExcludedTSE(void);
  455.     bool ExcludedTSE(const CSeq_entry_Handle& tse) const;
  457.     // No locations mapping flag. Set to true by CAnnot_CI.
  458.     SAnnotSelector& SetNoMapping(bool value = true)
  459.         {
  460.             m_NoMapping = value;
  461.             return *this;
  462.         }
  464. protected:
  465.     friend class CAnnot_Collector;
  467.     static bool x_Has(const TAnnotsNames& names, const CAnnotName& name);
  468.     static void x_Add(TAnnotsNames& names, const CAnnotName& name);
  469.     static void x_Del(TAnnotsNames& names, const CAnnotName& name);
  470.     void x_InitializeAnnotTypesSet(bool default_value);
  471.     void x_ClearAnnotTypesSet(void);
  473.     typedef vector<bool> TAnnotTypesSet;
  475.     bool                  m_FeatProduct;  // "true" for searching products
  476.     int                   m_ResolveDepth;
  477.     EOverlapType          m_OverlapType;
  478.     EResolveMethod        m_ResolveMethod;
  479.     ESegmentSelect        m_SegmentSelect;
  480.     ESortOrder            m_SortOrder;
  481.     ECombineMethod        m_CombineMethod;
  483.     enum ELimitObject {
  484.         eLimit_None,
  485.         eLimit_TSE_Info,
  486.         eLimit_Seq_entry_Info,
  487.         eLimit_Seq_annot_Info,
  488.         eLimit_TSE,
  489.         eLimit_Seq_entry,
  490.         eLimit_Seq_annot
  491.     };
  492.     ELimitObject          m_LimitObjectType;
  493.     EIdResolving          m_IdResolving;
  494.     CConstRef<CObject>    m_LimitObject;
  495.     size_t                m_MaxSize; //
  496.     TAnnotsNames          m_IncludeAnnotsNames;
  497.     TAnnotsNames          m_ExcludeAnnotsNames;
  498.     bool                  m_NoMapping;
  499.     bool                  m_AdaptiveDepth;
  500.     TAdaptiveTriggers     m_AdaptiveTriggers;
  501.     TTSE_Limits           m_ExcludedTSE;
  502.     TAnnotTypesSet        m_AnnotTypesSet;
  503. };
  506. END_SCOPE(objects)
  507. END_NCBI_SCOPE
  509. /*
  510. * ---------------------------------------------------------------------------
  511. * $Log: annot_selector.hpp,v $
  512. * Revision 1000.2  2004/04/12 17:26:57  gouriano
  513. * PRODUCTION: UPGRADED [CATCHUP_003] Dev-tree R1.30
  514. *
  515. * Revision 1.30  2004/04/05 15:56:13  grichenk
  516. * Redesigned CAnnotTypes_CI: moved all data and data collecting
  517. * functions to CAnnotDataCollector. CAnnotTypes_CI is no more
  518. * inherited from SAnnotSelector.
  519. *
  520. * Revision 1.29  2004/03/17 16:03:42  vasilche
  521. * Removed Windows EOL
  522. *
  523. * Revision 1.28  2004/03/16 15:47:25  vasilche
  524. * Added CBioseq_set_Handle and set of EditHandles
  525. *
  526. * Revision 1.27  2004/02/26 14:41:40  grichenk
  527. * Fixed types excluding in SAnnotSelector and multiple types search
  528. * in CAnnotTypes_CI.
  529. *
  530. * Revision 1.26  2004/02/11 22:19:23  grichenk
  531. * Fixed annot type initialization in iterators
  532. *
  533. * Revision 1.25  2004/02/05 19:53:39  grichenk
  534. * Fixed type matching in SAnnotSelector. Added IncludeAnnotType().
  535. *
  536. * Revision 1.24  2004/02/04 18:05:31  grichenk
  537. * Added annotation filtering by set of types/subtypes.
  538. * Renamed *Choice to *Type in SAnnotSelector.
  539. *
  540. * Revision 1.23  2004/01/23 16:14:45  grichenk
  541. * Implemented alignment mapping
  542. *
  543. * Revision 1.22  2003/11/13 19:12:51  grichenk
  544. * Added possibility to exclude TSEs from annotations request.
  545. *
  546. * Revision 1.21  2003/10/09 20:20:59  vasilche
  547. * Added possibility to include and exclude Seq-annot names to annot iterator.
  548. * Fixed adaptive search. It looked only on selected set of annot names before.
  549. *
  550. * Revision 1.20  2003/10/07 13:43:22  vasilche
  551. * Added proper handling of named Seq-annots.
  552. * Added feature search from named Seq-annots.
  553. * Added configurable adaptive annotation search (default: gene, cds, mrna).
  554. * Fixed selection of blobs for loading from GenBank.
  555. * Added debug checks to CSeq_id_Mapper for easier finding lost CSeq_id_Handles.
  556. * Fixed leaked split chunks annotation stubs.
  557. * Moved some classes definitions in separate *.cpp files.
  558. *
  559. * Revision 1.19  2003/10/01 15:08:48  vasilche
  560. * Do not reset feature type if feature subtype is set to 'any'.
  561. *
  562. * Revision 1.18  2003/09/30 16:21:59  vasilche
  563. * Updated internal object manager classes to be able to load ID2 data.
  564. * SNP blobs are loaded as ID2 split blobs - readers convert them automatically.
  565. * Scope caches results of requests for data to data loaders.
  566. * Optimized CSeq_id_Handle for gis.
  567. * Optimized bioseq lookup in scope.
  568. * Reduced object allocations in annotation iterators.
  569. * CScope is allowed to be destroyed before other objects using this scope are
  570. * deleted (feature iterators, bioseq handles etc).
  571. * Optimized lookup for matching Seq-ids in CSeq_id_Mapper.
  572. * Added 'adaptive' option to objmgr_demo application.
  573. *
  574. * Revision 1.17  2003/09/16 14:21:46  grichenk
  575. * Added feature indexing and searching by subtype.
  576. *
  577. * Revision 1.16  2003/09/11 17:45:06  grichenk
  578. * Added adaptive-depth option to annot-iterators.
  579. *
  580. * Revision 1.15  2003/08/22 14:58:55  grichenk
  581. * Added NoMapping flag (to be used by CAnnot_CI for faster fetching).
  582. * Added GetScope().
  583. *
  584. * Revision 1.14  2003/07/17 21:01:43  vasilche
  585. * Fixed ambiguity on Windows
  586. *
  587. * Revision 1.13  2003/07/17 20:07:55  vasilche
  588. * Reduced memory usage by feature indexes.
  589. * SNP data is loaded separately through PUBSEQ_OS.
  590. * String compression for SNP data.
  591. *
  592. * Revision 1.12  2003/06/25 20:56:29  grichenk
  593. * Added max number of annotations to annot-selector, updated demo.
  594. *
  595. * Revision 1.11  2003/06/17 20:34:02  grichenk
  596. * Added flag to ignore sorting
  597. *
  598. * Revision 1.10  2003/04/28 14:59:58  vasilche
  599. * Added missing initialization.
  600. *
  601. * Revision 1.9  2003/04/24 16:12:37  vasilche
  602. * Object manager internal structures are splitted more straightforward.
  603. * Removed excessive header dependencies.
  604. *
  605. * Revision 1.8  2003/03/31 21:48:17  grichenk
  606. * Added possibility to select feature subtype through SAnnotSelector.
  607. *
  608. * Revision 1.7  2003/03/18 14:46:35  grichenk
  609. * Set limit object type to "none" if the object is null.
  610. *
  611. * Revision 1.6  2003/03/14 20:39:26  ucko
  612. * return *this from SetIdResolvingXxx().
  613. *
  614. * Revision 1.5  2003/03/14 19:10:33  grichenk
  615. * + SAnnotSelector::EIdResolving; fixed operator=() for several classes
  616. *
  617. * Revision 1.4  2003/03/10 16:55:16  vasilche
  618. * Cleaned SAnnotSelector structure.
  619. * Added shortcut when features are limited to one TSE.
  620. *
  621. * Revision 1.3  2003/03/05 20:56:42  vasilche
  622. * SAnnotSelector now holds all parameters of annotation iterators.
  623. *
  624. * Revision 1.2  2003/02/25 14:48:06  vasilche
  625. * Added Win32 export modifier to object manager classes.
  626. *
  627. * Revision 1.1  2003/02/24 19:36:19  vasilche
  628. * Added missing annot_selector.hpp.
  629. *
  630. *
  631. * ===========================================================================
  632. */
  634. #endif  // ANNOT_SELECTOR__HPP