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

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

生物技术

开发平台：

C/C++

seq_map_ci.cpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: seq_map_ci.cpp,v $
  4.  * PRODUCTION Revision 1000.3  2004/06/01 19:24:19  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.23
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. /*  $Id: seq_map_ci.cpp,v 1000.3 2004/06/01 19:24:19 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. * Authors:
  36. *           Eugene Vasilchenko
  37. *
  38. * File Description:
  39. *   Sequence map for the Object Manager. Describes sequence as a set of
  40. *   segments of different types (data, reference, gap or end).
  41. *
  42. */
  44. #include <ncbi_pch.hpp>
  45. #include <objmgr/seq_map_ci.hpp>
  46. #include <objmgr/seq_map.hpp>
  47. #include <objmgr/seq_entry_handle.hpp>
  48. #include <objmgr/impl/scope_impl.hpp>
  50. BEGIN_NCBI_SCOPE
  51. BEGIN_SCOPE(objects)
  54. /////////////////////////////////////////////////////////////////////////////
  55. // SSeqMapSelector
  56. /////////////////////////////////////////////////////////////////////////////
  58. SSeqMapSelector& SSeqMapSelector::SetLimitTSE(const CSeq_entry* tse)
  59. {
  60.     m_TSE.Reset(tse);
  61.     m_TSE_Info.Reset();
  62.     return *this;
  63. }
  65. SSeqMapSelector& SSeqMapSelector::SetLimitTSE(const CSeq_entry_Handle& tse)
  66. {
  67.     if ( tse ) {
  68.         m_TSE_Info = tse.GetTSE_Info();
  69.         m_TSE = tse.GetSeq_entryCore();
  70.     }
  71.     else {
  72.         m_TSE_Info.Reset();
  73.         m_TSE.Reset();
  74.     }
  75.     return *this;
  76. }
  79. ////////////////////////////////////////////////////////////////////
  80. // CSeqMap_CI_SegmentInfo
  83. bool CSeqMap_CI_SegmentInfo::x_Move(bool minusStrand, CScope* scope)
  84. {
  85.     const CSeqMap& seqMap = *m_SeqMap;
  86.     size_t index = m_Index;
  87.     const CSeqMap::CSegment& old_seg = seqMap.x_GetSegment(index);
  88.     if ( !minusStrand ) {
  89.         if ( old_seg.m_Position > m_LevelRangeEnd ||
  90.              index == seqMap.x_GetSegmentsCount() )
  91.             return false;
  92.         m_Index = ++index;
  93.         seqMap.x_GetSegmentLength(index, scope); // Update length of segment
  94.         return seqMap.x_GetSegmentPosition(index, scope) < m_LevelRangeEnd;
  95.     }
  96.     else {
  97.         if ( old_seg.m_Position + old_seg.m_Length < m_LevelRangePos ||
  98.              index == 0 )
  99.             return false;
  100.         m_Index = --index;
  101.         return old_seg.m_Position > m_LevelRangePos;
  102.     }
  103. }
  107. ////////////////////////////////////////////////////////////////////
  108. // CSeqMap_CI
  110. inline
  111. bool CSeqMap_CI::x_Push(TSeqPos pos)
  112. {
  113.     return x_Push(pos, m_Selector.CanResolve());
  114. }
  117. CSeqMap_CI::CSeqMap_CI(void)
  118. {
  119.     m_Selector.SetPosition(kInvalidSeqPos)
  120.         .SetResolveCount(0)
  121.         .SetFlags(CSeqMap::fDefaultFlags);
  122. }
  124. CSeqMap_CI::CSeqMap_CI(const CConstRef<CSeqMap>& seqMap,
  125.                        CScope* scope,
  126.                        TSeqPos pos,
  127.                        size_t maxResolveCount,
  128.                        TFlags flags)
  129.     : m_Scope(scope)
  130. {
  131.     m_Selector
  132.         .SetResolveCount(maxResolveCount)
  133.         .SetFlags(flags);
  134.     if (pos >= seqMap->GetLength(scope)) {
  135.         // Special case - end of seq map
  136.         m_Selector.SetRange(seqMap->GetLength(scope), 0);
  137.         TSegmentInfo push;
  138.         push.m_SeqMap = seqMap;
  139.         push.m_LevelRangePos = 0;
  140.         push.m_LevelRangeEnd = GetPosition();
  141.         push.m_MinusStrand = false;
  142.         push.m_Index = seqMap->x_GetSegmentsCount();
  143.         m_Stack.push_back(push);
  144.         return;
  145.     }
  146.     x_Push(seqMap, 0, seqMap->GetLength(scope), false, pos);
  147.     while ( !x_Found() ) {
  148.         if ( !x_Push(pos - GetPosition()) ) {
  149.             x_SettleNext();
  150.             break;
  151.         }
  152.     }
  153. }
  156. CSeqMap_CI::CSeqMap_CI(const CConstRef<CSeqMap>& seqMap,
  157.                        CScope* scope,
  158.                        TSeqPos pos,
  159.                        ENa_strand strand,
  160.                        size_t maxResolveCount,
  161.                        TFlags flags)
  162.     : m_Scope(scope)
  163. {
  164.     m_Selector
  165.         .SetResolveCount(maxResolveCount)
  166.         .SetFlags(flags);
  167.     if (pos >= seqMap->GetLength(scope)) {
  168.         // Special case - end of seq map
  169.         m_Selector.SetRange(seqMap->GetLength(scope), 0);
  170.         TSegmentInfo push;
  171.         push.m_SeqMap = seqMap;
  172.         push.m_LevelRangePos = 0;
  173.         push.m_LevelRangeEnd = GetPosition();
  174.         push.m_MinusStrand = false;
  175.         push.m_Index = seqMap->x_GetSegmentsCount();
  176.         m_Stack.push_back(push);
  177.         return;
  178.     }
  179.     x_Push(seqMap, 0, seqMap->GetLength(scope), IsReverse(strand), pos);
  180.     while ( !x_Found() ) {
  181.         if ( !x_Push(pos - GetPosition()) ) {
  182.             x_SettleNext();
  183.             break;
  184.         }
  185.     }
  186. }
  189. CSeqMap_CI::CSeqMap_CI(const CConstRef<CSeqMap>& seqMap,
  190.                        CScope* scope,
  191.                        SSeqMapSelector& selector,
  192.                        ENa_strand strand)
  193.     : m_Scope(scope),
  194.       m_Selector(selector)
  195. {
  196.     TSeqPos pos = GetPosition();
  197.     x_Push(seqMap,
  198.            m_Selector.m_Position,
  199.            m_Selector.m_Length,
  200.            IsReverse(strand), 0);
  201.     while ( !x_Found() ) {
  202.         if ( !x_Push(pos - GetPosition()) ) {
  203.             x_SettleNext();
  204.             break;
  205.         }
  206.     }
  207. }
  210. CSeqMap_CI::CSeqMap_CI(const CConstRef<CSeqMap>& seqMap,
  211.                        CScope* scope,
  212.                        SSeqMapSelector& selector)
  213.     : m_Scope(scope),
  214.       m_Selector(selector)
  215. {
  216.     TSeqPos pos = GetPosition();
  217.     if (m_Selector.m_Length == kInvalidSeqPos) {
  218.         m_Selector.SetRange(pos, seqMap->GetLength(scope));
  219.     }
  220.     x_Push(seqMap,
  221.            m_Selector.m_Position,
  222.            m_Selector.m_Length,
  223.            false, 0);
  224.     while ( !x_Found() ) {
  225.         if ( !x_Push(pos - GetPosition()) ) {
  226.             x_SettleNext();
  227.             break;
  228.         }
  229.     }
  230. }
  233. CSeqMap_CI::~CSeqMap_CI(void)
  234. {
  235. }
  238. const CSeq_data& CSeqMap_CI::GetData(void) const
  239. {
  240.     if ( !*this ) {
  241.         NCBI_THROW(CSeqMapException, eOutOfRange,
  242.                    "Iterator out of range");
  243.     }
  244.     if ( GetRefPosition() != 0 || GetRefMinusStrand() ) {
  245.         NCBI_THROW(CSeqMapException, eDataError,
  246.                    "Non standard Seq_data: use methods "
  247.                    "GetRefData/GetRefPosition/GetRefMinusStrand");
  248.     }
  249.     return GetRefData();
  250. }
  253. const CSeq_data& CSeqMap_CI::GetRefData(void) const
  254. {
  255.     if ( !*this ) {
  256.         NCBI_THROW(CSeqMapException, eOutOfRange,
  257.                    "Iterator out of range");
  258.     }
  259.     return x_GetSeqMap().x_GetSeq_data(x_GetSegment());
  260. }
  263. CSeq_id_Handle CSeqMap_CI::GetRefSeqid(void) const
  264. {
  265.     if ( !*this ) {
  266.         NCBI_THROW(CSeqMapException, eOutOfRange,
  267.                    "Iterator out of range");
  268.     }
  269.     return CSeq_id_Mapper::GetSeq_id_Mapper().
  270.         GetHandle(x_GetSeqMap().x_GetRefSeqid(x_GetSegment()));
  271. }
  274. TSeqPos CSeqMap_CI_SegmentInfo::GetRefPosition(void) const
  275. {
  276.     if ( !InRange() ) {
  277.         NCBI_THROW(CSeqMapException, eOutOfRange,
  278.                    "Iterator out of range");
  279.     }
  280.     const CSeqMap::CSegment& seg = x_GetSegment();
  281.     TSignedSeqPos skip;
  282.     if ( !seg.m_RefMinusStrand ) {
  283.         skip = m_LevelRangePos - seg.m_Position;
  284.     }
  285.     else {
  286.         skip = (seg.m_Position + seg.m_Length) - m_LevelRangeEnd;
  287.     }
  288.     if ( skip < 0 )
  289.         skip = 0;
  290.     return seg.m_RefPosition + skip;
  291. }
  294. TSeqPos CSeqMap_CI_SegmentInfo::x_GetTopOffset(void) const
  295. {
  296.     TSignedSeqPos offset;
  297.     if ( !m_MinusStrand ) {
  298.         offset = min(x_GetLevelRealPos(), m_LevelRangeEnd) - m_LevelRangePos;
  299.     }
  300.     else {
  301.         offset = m_LevelRangeEnd - max(x_GetLevelRealEnd(), m_LevelRangePos);
  302.     }
  303.     if ( offset < 0 )
  304.         offset = 0;
  305.     return offset;
  306. }
  309. TSeqPos CSeqMap_CI::x_GetTopOffset(void) const
  310. {
  311.     return x_GetSegmentInfo().x_GetTopOffset();
  312. }
  315. bool CSeqMap_CI::x_RefTSEMatch(const CSeqMap::CSegment& seg) const
  316. {
  317.     _ASSERT(m_Selector.m_TSE);
  318.     _ASSERT(CSeqMap::ESegmentType(seg.m_SegType) == CSeqMap::eSeqRef);
  319.     CSeq_id_Handle id = CSeq_id_Mapper::GetSeq_id_Mapper().
  320.         GetHandle(x_GetSeqMap().x_GetRefSeqid(seg));
  321.     CSeq_entry_Handle tse_info;
  322.     CScope& scope = *m_Scope;
  323.     if ( m_Selector.m_TSE_Info ) {
  324.         tse_info =
  325.             CSeq_entry_Handle(scope,
  326.                               static_cast<const CTSE_Info&>
  327.                               (*m_Selector.m_TSE_Info));
  328.     }
  329.     else {
  330.         tse_info = scope.GetSeq_entryHandle(*m_Selector.m_TSE);
  331.         const_cast<SSeqMapSelector&>(m_Selector).m_TSE_Info =
  332.             tse_info.GetTSE_Info();
  333.     }
  334.     return scope.GetBioseqHandleFromTSE(id, tse_info);
  335. }
  338. inline
  339. bool CSeqMap_CI::x_CanResolve(const CSeqMap::CSegment& seg) const
  340. {
  341.     return m_Selector.CanResolve() &&
  342.         (!m_Selector.m_TSE || x_RefTSEMatch(seg));
  343. }
  346. bool CSeqMap_CI::x_Push(TSeqPos pos, bool resolveExternal)
  347. {
  348.     const TSegmentInfo& info = x_GetSegmentInfo();
  349.     const CSeqMap::CSegment& seg = info.x_GetSegment();
  350.     CSeqMap::ESegmentType type = CSeqMap::ESegmentType(seg.m_SegType);
  351.     if ( !(type == CSeqMap::eSeqSubMap  ||
  352.            type == CSeqMap::eSeqRef  &&  resolveExternal) ) {
  353.         return false;
  354.     }
  355.     // Check TSE limit
  356.     if ( bool(m_Selector.m_TSE)  &&  !x_RefTSEMatch(seg) ) {
  357.         return false;
  358.     }
  359.     x_Push(info.m_SeqMap->x_GetSubSeqMap(seg, GetScope(), resolveExternal),
  360.            GetRefPosition(), GetLength(), GetRefMinusStrand(), pos);
  361.     if ( type == CSeqMap::eSeqRef ) {
  362.         m_Selector.PushResolve();
  363.     }
  364.     return true;
  365. }
  368. void CSeqMap_CI::x_Push(const CConstRef<CSeqMap>& seqMap,
  369.                         TSeqPos from, TSeqPos length,
  370.                         bool minusStrand,
  371.                         TSeqPos pos)
  372. {
  373.     TSegmentInfo push;
  374.     push.m_SeqMap = seqMap;
  375.     push.m_LevelRangePos = from;
  376.     push.m_LevelRangeEnd = from + length;
  377.     push.m_MinusStrand = minusStrand;
  378.     TSeqPos findOffset = !minusStrand? pos: length - 1 - pos;
  379.     push.m_Index = seqMap->x_FindSegment(from + findOffset, GetScope());
  380.     if ( push.m_Index == size_t(-1) ) {
  381.         _ASSERT(length == 0);
  382.         push.m_Index = !minusStrand? seqMap->x_GetSegmentsCount(): 0;
  383.     }
  384.     else {
  385.         _ASSERT(push.m_Index < seqMap->x_GetSegmentsCount());
  386.     }
  387.     // update length of current segment
  388.     seqMap->x_GetSegmentLength(push.m_Index, GetScope());
  389.     m_Stack.push_back(push);
  390.     // update position
  391.     m_Selector.m_Position += x_GetTopOffset();
  392.     // update length
  393.     m_Selector.m_Length = push.x_CalcLength();
  394. }
  397. bool CSeqMap_CI::x_Pop(void)
  398. {
  399.     if ( m_Stack.size() <= 1 ) {
  400.         return false;
  401.     }
  403.     m_Selector.m_Position -= x_GetTopOffset();
  404.     m_Stack.pop_back();
  405.     if ( x_GetSegment().m_SegType == CSeqMap::eSeqRef ) {
  406.         m_Selector.PopResolve();
  407.     }
  408.     m_Selector.m_Length = x_GetSegmentInfo().x_CalcLength();
  409.     return true;
  410. }
  413. bool CSeqMap_CI::x_TopNext(void)
  414. {
  415.     TSegmentInfo& top = x_GetSegmentInfo();
  416.     m_Selector.m_Position += m_Selector.m_Length;
  417.     if ( !top.x_Move(top.m_MinusStrand, GetScope()) ) {
  418.         m_Selector.m_Length = 0;
  419.         return false;
  420.     }
  421.     else {
  422.         m_Selector.m_Length = x_GetSegmentInfo().x_CalcLength();
  423.         return true;
  424.     }
  425. }
  428. bool CSeqMap_CI::x_TopPrev(void)
  429. {
  430.     TSegmentInfo& top = x_GetSegmentInfo();
  431.     if ( !top.x_Move(!top.m_MinusStrand, GetScope()) ) {
  432.         m_Selector.m_Length = 0;
  433.         return false;
  434.     }
  435.     else {
  436.         m_Selector.m_Length = x_GetSegmentInfo().x_CalcLength();
  437.         m_Selector.m_Position -= m_Selector.m_Length;
  438.         return true;
  439.     }
  440. }
  443. inline
  444. bool CSeqMap_CI::x_Next(void)
  445. {
  446.     return x_Next(m_Selector.CanResolve());
  447. }
  450. bool CSeqMap_CI::x_Next(bool resolveExternal)
  451. {
  452.     if ( x_Push(0, resolveExternal) ) {
  453.         return true;
  454.     }
  455.     do {
  456.         if ( x_TopNext() )
  457.             return true;
  458.     } while ( x_Pop() );
  459.     return false;
  460. }
  463. bool CSeqMap_CI::x_Prev(void)
  464. {
  465.     if ( !x_TopPrev() )
  466.         return x_Pop();
  467.     while ( x_Push(m_Selector.m_Length-1) ) {
  468.     }
  469.     return true;
  470. }
  473. bool CSeqMap_CI::x_Found(void) const
  474. {
  475.     switch ( x_GetSegment().m_SegType ) {
  476.     case CSeqMap::eSeqRef:
  477.         if ( (GetFlags() & CSeqMap::fFindLeafRef) != 0 ) {
  478.             if ( (GetFlags() & CSeqMap::fFindInnerRef) != 0 ) {
  479.                 // both
  480.                 return true;
  481.             }
  482.             else {
  483.                 // leaf only
  484.                 return !x_CanResolve(x_GetSegment());
  485.             }
  486.         }
  487.         else {
  488.             if ( (GetFlags() & CSeqMap::fFindInnerRef) != 0 ) {
  489.                 // inner only
  490.                 return x_CanResolve(x_GetSegment());
  491.             }
  492.             else {
  493.                 // none
  494.                 return false;
  495.             }
  496.         }
  497.     case CSeqMap::eSeqData:
  498.         return (GetFlags() & CSeqMap::fFindData) != 0;
  499.     case CSeqMap::eSeqGap:
  500.         return (GetFlags() & CSeqMap::fFindGap) != 0;
  501.     case CSeqMap::eSeqSubMap:
  502.         return false; // always skip submaps
  503.     default:
  504.         return true;
  505.     }
  506. }
  509. bool CSeqMap_CI::x_SettleNext(void)
  510. {
  511.     while ( !x_Found() ) {
  512.         if ( !x_Next() )
  513.             return false;
  514.     }
  515.     return true;
  516. }
  519. bool CSeqMap_CI::x_SettlePrev(void)
  520. {
  521.     while ( !x_Found() ) {
  522.         if ( !x_Prev() )
  523.             return false;
  524.     }
  525.     return true;
  526. }
  529. bool CSeqMap_CI::Next(bool resolveCurrentExternal)
  530. {
  531.     return x_Next(resolveCurrentExternal && m_Selector.CanResolve()) &&
  532.         x_SettleNext();
  533. }
  536. bool CSeqMap_CI::Prev(void)
  537. {
  538.     return x_Prev() && x_SettlePrev();
  539. }
  542. void CSeqMap_CI::SetFlags(TFlags flags)
  543. {
  544.     m_Selector.SetFlags(flags);
  545. }
  548. END_SCOPE(objects)
  549. END_NCBI_SCOPE
  552. /*
  553. * ---------------------------------------------------------------------------
  554. * $Log: seq_map_ci.cpp,v $
  555. * Revision 1000.3  2004/06/01 19:24:19  gouriano
  556. * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.23
  557. *
  558. * Revision 1.23  2004/05/21 21:42:13  gorelenk
  559. * Added PCH ncbi_pch.hpp
  560. *
  561. * Revision 1.22  2004/04/12 16:49:16  vasilche
  562. * Allow null scope in CSeqMap_CI and CSeqVector.
  563. *
  564. * Revision 1.21  2004/03/16 15:47:28  vasilche
  565. * Added CBioseq_set_Handle and set of EditHandles
  566. *
  567. * Revision 1.20  2003/11/10 18:12:09  grichenk
  568. * Removed extra EFlags declaration from seq_map_ci.hpp
  569. *
  570. * Revision 1.19  2003/09/30 16:22:04  vasilche
  571. * Updated internal object manager classes to be able to load ID2 data.
  572. * SNP blobs are loaded as ID2 split blobs - readers convert them automatically.
  573. * Scope caches results of requests for data to data loaders.
  574. * Optimized CSeq_id_Handle for gis.
  575. * Optimized bioseq lookup in scope.
  576. * Reduced object allocations in annotation iterators.
  577. * CScope is allowed to be destroyed before other objects using this scope are
  578. * deleted (feature iterators, bioseq handles etc).
  579. * Optimized lookup for matching Seq-ids in CSeq_id_Mapper.
  580. * Added 'adaptive' option to objmgr_demo application.
  581. *
  582. * Revision 1.18  2003/09/05 17:29:40  grichenk
  583. * Structurized Object Manager exceptions
  584. *
  585. * Revision 1.17  2003/08/27 14:27:19  vasilche
  586. * Use Reverse(ENa_strand) function.
  587. *
  588. * Revision 1.16  2003/07/17 22:51:31  vasilche
  589. * Fixed unused variables warnings.
  590. *
  591. * Revision 1.15  2003/07/14 21:13:26  grichenk
  592. * Added possibility to resolve seq-map iterator withing a single TSE
  593. * and to skip intermediate references during this resolving.
  594. *
  595. * Revision 1.14  2003/06/02 16:06:38  dicuccio
  596. * Rearranged src/objects/ subtree.  This includes the following shifts:
  597. *     - src/objects/asn2asn --> arc/app/asn2asn
  598. *     - src/objects/testmedline --> src/objects/ncbimime/test
  599. *     - src/objects/objmgr --> src/objmgr
  600. *     - src/objects/util --> src/objmgr/util
  601. *     - src/objects/alnmgr --> src/objtools/alnmgr
  602. *     - src/objects/flat --> src/objtools/flat
  603. *     - src/objects/validator --> src/objtools/validator
  604. *     - src/objects/cddalignview --> src/objtools/cddalignview
  605. * In addition, libseq now includes six of the objects/seq... libs, and libmmdb
  606. * replaces the three libmmdb? libs.
  607. *
  608. * Revision 1.13  2003/05/23 16:32:21  vasilche
  609. * Fixed backward traversal of CSeqMap_CI.
  610. *
  611. * Revision 1.12  2003/05/20 20:36:14  vasilche
  612. * Added FindResolved() with strand argument.
  613. *
  614. * Revision 1.11  2003/05/20 15:44:38  vasilche
  615. * Fixed interaction of CDataSource and CDataLoader in multithreaded app.
  616. * Fixed some warnings on WorkShop.
  617. * Added workaround for memory leak on WorkShop.
  618. *
  619. * Revision 1.10  2003/02/27 16:29:19  vasilche
  620. * Fixed lost features from first segment.
  621. *
  622. * Revision 1.9  2003/02/25 14:48:29  vasilche
  623. * Removed performance warning on Windows.
  624. *
  625. * Revision 1.8  2003/02/24 18:57:22  vasilche
  626. * Make feature gathering in one linear pass using CSeqMap iterator.
  627. * Do not use feture index by sub locations.
  628. * Sort features at the end of gathering in one vector.
  629. * Extracted some internal structures and classes in separate header.
  630. * Delay creation of mapped features.
  631. *
  632. * Revision 1.7  2003/02/11 19:26:18  vasilche
  633. * Fixed CSeqMap_CI with ending NULL segment.
  634. *
  635. * Revision 1.6  2003/02/05 17:59:17  dicuccio
  636. * Moved formerly private headers into include/objects/objmgr/impl
  637. *
  638. * Revision 1.5  2003/02/05 15:55:26  vasilche
  639. * Added eSeqEnd segment at the beginning of seq map.
  640. * Added flags to CSeqMap_CI to stop on data, gap, or references.
  641. *
  642. * Revision 1.4  2003/01/29 22:03:46  grichenk
  643. * Use single static CSeq_id_Mapper instead of per-OM model.
  644. *
  645. * Revision 1.3  2003/01/24 20:14:08  vasilche
  646. * Fixed processing zero length references.
  647. *
  648. * Revision 1.2  2003/01/22 20:11:54  vasilche
  649. * Merged functionality of CSeqMapResolved_CI to CSeqMap_CI.
  650. * CSeqMap_CI now supports resolution and iteration over sequence range.
  651. * Added several caches to CScope.
  652. * Optimized CSeqVector().
  653. * Added serveral variants of CBioseqHandle::GetSeqVector().
  654. * Tried to optimize annotations iterator (not much success).
  655. * Rewritten CHandleRange and CHandleRangeMap classes to avoid sorting of list.
  656. *
  657. * Revision 1.1  2002/12/26 16:39:24  vasilche
  658. * Object manager class CSeqMap rewritten.
  659. *
  660. *
  661. * ===========================================================================
  662. */