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

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

生物技术

开发平台：

C/C++

data_source.cpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: data_source.cpp,v $
  4.  * PRODUCTION Revision 1000.4  2004/06/01 19:23:11  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.133
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. /*  $Id: data_source.cpp,v 1000.4 2004/06/01 19:23:11 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. *   DataSource for object manager
  39. *
  40. */
  43. #include <ncbi_pch.hpp>
  44. #include <objmgr/impl/data_source.hpp>
  46. #include <objmgr/impl/annot_object.hpp>
  47. #include <objmgr/impl/handle_range_map.hpp>
  48. #include <objmgr/impl/seq_entry_info.hpp>
  49. #include <objmgr/impl/seq_annot_info.hpp>
  50. #include <objmgr/impl/bioseq_info.hpp>
  51. #include <objmgr/impl/bioseq_set_info.hpp>
  52. #include <objmgr/impl/tse_info.hpp>
  53. #include <objmgr/seqmatch_info.hpp>
  54. #include <objmgr/data_loader.hpp>
  55. #include <objmgr/seq_map.hpp>
  56. #include <objmgr/objmgr_exception.hpp>
  57. #include <objmgr/bioseq_ci.hpp> // for CBioseq_CI_Base
  59. #include <objects/seqloc/Seq_loc.hpp>
  60. #include <objects/seqloc/Seq_interval.hpp>
  61. #include <objects/seqloc/Seq_point.hpp>
  62. #include <objects/seqloc/Seq_loc_equiv.hpp>
  64. #include <objects/seq/Bioseq.hpp>
  65. #include <objects/seq/seqport_util.hpp>
  67. #include <objects/seqset/Seq_entry.hpp>
  68. #include <objects/seqset/Bioseq_set.hpp>
  70. #include <objects/seqalign/Seq_align.hpp>
  71. #include <objects/seqfeat/Seq_feat.hpp>
  72. #include <objects/seqres/Seq_graph.hpp>
  74. #include <objmgr/impl/prefetch_impl.hpp>
  75. #include <corelib/ncbimtx.hpp>
  77. BEGIN_NCBI_SCOPE
  78. BEGIN_SCOPE(objects)
  81. CTSE_LockingSet::CTSE_LockingSet(void)
  82.     : m_LockCount(0)
  83. {
  84. }
  87. CTSE_LockingSet::CTSE_LockingSet(const CTSE_LockingSet& tse_set)
  88.     : m_LockCount(0), m_TSE_set(tse_set.m_TSE_set)
  89. {
  90. }
  93. CTSE_LockingSet::~CTSE_LockingSet(void)
  94. {
  95.     _ASSERT(!x_Locked());
  96. }
  99. DEFINE_CLASS_STATIC_FAST_MUTEX(CTSE_LockingSet::sm_Mutex);
  101. CTSE_LockingSet& CTSE_LockingSet::operator=(const CTSE_LockingSet& tse_set)
  102. {
  103.     CFastMutexGuard guard(sm_Mutex);
  104.     _ASSERT(!x_Locked());
  105.     m_TSE_set = tse_set.m_TSE_set;
  106.     return *this;
  107. }
  110. bool CTSE_LockingSet::insert(CTSE_Info* tse)
  111. {
  112.     CFastMutexGuard guard(sm_Mutex);
  113.     bool ins = m_TSE_set.insert(tse).second;
  114.     if ( ins && x_Locked() ) {
  115.         tse->AddReference();
  116.     }
  117.     return ins;
  118. }
  121. bool CTSE_LockingSet::erase(CTSE_Info* tse)
  122. {
  123.     CFastMutexGuard guard(sm_Mutex);
  124.     if ( m_TSE_set.erase(tse) ) {
  125.         if ( x_Locked() ) {
  126.             tse->RemoveReference();
  127.         }
  128.         return true;
  129.     }
  130.     return false;
  131. }
  134. void CTSE_LockingSet::x_Lock(void)
  135. {
  136.     CFastMutexGuard guard(sm_Mutex);
  137.     if ( m_LockCount++ == 0 ) {
  138.         NON_CONST_ITERATE( TTSESet, it, m_TSE_set ) {
  139.             (*it)->AddReference();
  140.         }
  141.     }
  142.     _ASSERT(m_LockCount > 0);
  143. }
  146. void CTSE_LockingSet::x_Unlock(void)
  147. {
  148.     CFastMutexGuard guard(sm_Mutex);
  149.     _ASSERT(m_LockCount > 0);
  150.     if ( --m_LockCount == 0 ) {
  151.         NON_CONST_ITERATE( TTSESet, it, m_TSE_set ) {
  152.             (*it)->RemoveReference();
  153.         }
  154.     }
  155. }
  158. CDataSource::CDataSource(CDataLoader& loader, CObjectManager& objmgr)
  159.     : m_Loader(&loader),
  160.       m_ObjMgr(&objmgr),
  161.       m_DefaultPriority(99)
  162. {
  163.     m_Loader->SetTargetDataSource(*this);
  164. }
  167. CDataSource::CDataSource(CSeq_entry& entry, CObjectManager& objmgr)
  168.     : m_Loader(0),
  169.       m_pTopEntry(&entry),
  170.       m_ObjMgr(&objmgr),
  171.       m_DefaultPriority(9)
  172. {
  173.     AddTSE(entry, false);
  174. }
  177. CDataSource::~CDataSource(void)
  178. {
  179.     if (m_PrefetchThread) {
  180.         // Wait for the prefetch thread to stop
  181.         m_PrefetchThread->Terminate();
  182.         m_PrefetchThread->Join();
  183.     }
  184.     DropAllTSEs();
  185.     m_Loader.Reset();
  186. }
  189. CConstRef<CTSE_Info> CDataSource::GetTopEntry_Info(void)
  190. {
  191.     CConstRef<CTSE_Info> ret;
  192.     {{
  193.         TMainReadLockGuard guard(m_DSMainLock);    
  194.         ITERATE ( TTSE_Set, it, m_TSE_Set ) {
  195.             if ( (*it)->GetSeq_entryCore() == m_pTopEntry ) {
  196.                 ret = *it;
  197.                 break;
  198.             }
  199.         }
  200.     }}
  201.     return ret;
  202. }
  205. void CDataSource::DropAllTSEs(void)
  206. {
  207.     // Lock indexes
  208.     TMainWriteLockGuard guard(m_DSMainLock);    
  210.     ITERATE ( TTSE_Set, it, m_TSE_Set ) {
  211.         if ( (*it)->Locked() ) {
  212.             ERR_POST("CDataSource::DropAllTSEs: tse is locked");
  213.             NCBI_THROW(CObjMgrException, eOtherError,
  214.                        "CDataSource::DropAllTSEs: tse is locked");
  215.         }
  216.     }
  218.     if ( m_Loader ) {
  219.         NON_CONST_ITERATE ( TTSE_Set, it, m_TSE_Set ) {
  220.             m_Loader->DropTSE(**it);
  221.         }
  222.     }
  224.     //m_Bioseq_InfoMap.clear();
  225.     //m_Seq_annot_InfoMap.clear();
  226.     //m_Seq_entry_InfoMap.clear();
  227.     //m_TSE_InfoMap.clear();
  228.     m_TSE_Set.clear();
  229.     m_pTopEntry.Reset();
  230.     m_TSE_seq.clear();
  232.     {{
  233.         TAnnotWriteLockGuard guard2(m_DSAnnotLock);
  234.         m_TSE_annot.clear();
  235.         m_DirtyAnnot_TSEs.clear();
  236.     }}
  237. }
  240. TTSE_Lock CDataSource::x_FindBestTSE(const CSeq_id_Handle& handle) const
  241. {
  242.     TTSE_LockSet all_tse;
  243.     size_t all_count = 0;
  244.     {{
  245.         TMainReadLockGuard guard(m_DSMainLock);
  246.         TTSEMap::const_iterator tse_set = m_TSE_seq.find(handle);
  247.         if ( tse_set == m_TSE_seq.end() ) {
  248.             return TTSE_Lock();
  249.         }
  250.         ITERATE ( CTSE_LockingSet, it, tse_set->second ) {
  251.             if ( all_tse.insert(TTSE_Lock(*it)).second )
  252.                 ++all_count;
  253.         }
  254.         if ( all_count == 0 ) {
  255.             return TTSE_Lock();
  256.         }
  257.     }}
  258.     if ( all_count == 1 ) {
  259.         // There is only one TSE, no matter live or dead
  260.         return TTSE_Lock(*all_tse.begin());
  261.     }
  262.     // The map should not contain empty entries
  263.     _ASSERT(!all_tse.empty());
  264.     TTSE_LockSet live_tse;
  265.     size_t live_count = 0;
  266.     ITERATE ( TTSE_LockSet, tse, all_tse ) {
  267.         // Find live TSEs
  268.         if ( !(*tse)->IsDead() ) {
  269.             live_tse.insert(*tse);
  270.             ++live_count;
  271.         }
  272.     }
  274.     // Check live
  275.     if ( live_count == 1 ) {
  276.         // There is only one live TSE -- ok to use it
  277.         return *live_tse.begin();
  278.     }
  279.     else if ( live_count == 0 ) {
  280.         if ( m_Loader ) {
  281.             TTSE_Lock best(GetDataLoader()->ResolveConflict(handle, all_tse));
  282.             if ( best ) {
  283.                 return best;
  284.             }
  285.         }
  286.         // No live TSEs -- try to select the best dead TSE
  287.         NCBI_THROW(CObjMgrException, eFindConflict,
  288.                    "Multiple seq-id matches found");
  289.     }
  290.     if ( m_Loader ) {
  291.         // Multiple live TSEs - try to resolve the conflict (the status of some
  292.         // TSEs may change)
  293.         TTSE_Lock best(GetDataLoader()->ResolveConflict(handle, live_tse));
  294.         if ( best ) {
  295.             return best;
  296.         }
  297.     }
  298.     NCBI_THROW(CObjMgrException, eFindConflict,
  299.                "Multiple live entries found");
  300. }
  303. TTSE_Lock CDataSource::GetBlobById(const CSeq_id_Handle& idh)
  304. {
  305.     TMainReadLockGuard guard(m_DSMainLock);
  306.     TTSEMap::iterator tse_set = m_TSE_seq.find(idh);
  307.     if (tse_set == m_TSE_seq.end()) {
  308.         // Request TSE-info from loader if any
  309.         if ( m_Loader ) {
  310.             //
  311.         }
  312.         else {
  313.             // No such blob, no loader to call
  314.             return TTSE_Lock();
  315.         }
  316. //###
  317.     }
  318. //###
  319.     return TTSE_Lock();
  320. }
  323. CConstRef<CBioseq_Info> CDataSource::GetBioseq_Info(const CSeqMatch_Info& info)
  324. {
  325.     CRef<CBioseq_Info> ret;
  326.     // The TSE is locked by the scope, so, it can not be deleted.
  327.     CTSE_Info::TBioseqs::const_iterator found =
  328.         info.GetTSE_Info().m_Bioseqs.find(info.GetIdHandle());
  329.     if ( found != info.GetTSE_Info().m_Bioseqs.end() ) {
  330.         ret = found->second;
  331.     }
  332.     return ret;
  333. }
  336. CRef<CTSE_Info> CDataSource::AddTSE(CSeq_entry& tse,
  337.                                     bool dead,
  338.                                     const CObject* blob_id)
  339. {
  340.     CRef<CTSE_Info> info(new CTSE_Info(tse, dead, blob_id));
  341.     AddTSE(info);
  342.     return info;
  343. }
  346. void CDataSource::AddTSE(CRef<CTSE_Info> info)
  347. {
  348.     TMainWriteLockGuard guard(m_DSMainLock);
  349.     _VERIFY(m_TSE_Set.insert(info).second);
  350.     info->x_DSAttach(*this);
  352. }
  355. bool CDataSource::DropTSE(CTSE_Info& info)
  356. {
  357.     TMainWriteLockGuard guard(m_DSMainLock);
  359.     if ( info.Locked() ) {
  360.         _TRACE("DropTSE: DS="<<this<<" TSE_Info="<<&info<<" - locked");
  361.         return false; // Not really dropped, although found
  362.     }
  363.     CRef<CTSE_Info> info_lock(&info);
  364.     x_DropTSE(info);
  365.     return true;
  366. }
  369. void CDataSource::x_DropTSE(CTSE_Info& info)
  370. {
  371.     if ( m_Loader ) {
  372.         m_Loader->DropTSE(info);
  373.     }
  374.     info.x_DSDetach(*this);
  375.     _VERIFY(m_TSE_Set.erase(Ref(&info)));
  376.     {{
  377.         TAnnotWriteLockGuard guard2(m_DSAnnotLock);
  378.         m_DirtyAnnot_TSEs.erase(&info);
  379.     }}
  380. }
  383. template<class Map, class Ref, class Info>
  384. inline
  385. void x_MapObject(Map& info_map, const Ref& ref, const Info& info)
  386. {
  387.     typedef typename Map::value_type value_type;
  388.     if ( !info_map.insert(value_type(ref, info)).second ) {
  389.         NCBI_THROW(CObjMgrException, eOtherError,
  390.                    "CDataSource::x_Map(): object already mapped");
  391.     }
  392. }
  395. template<class Map, class Ref, class Info>
  396. inline
  397. void x_UnmapObject(Map& info_map, const Ref& ref, const Info& _DEBUG_ARG(info))
  398. {
  399.     typename Map::iterator iter = info_map.lower_bound(ref);
  400.     if ( iter != info_map.end() && iter->first == ref ) {
  401.         _ASSERT(iter->second == info);
  402.         info_map.erase(iter);
  403.     }
  404. }
  407. void CDataSource::x_Map(CConstRef<CSeq_entry> obj, CTSE_Info* info)
  408. {
  409.     x_MapObject(m_TSE_InfoMap, obj, info);
  410. }
  413. void CDataSource::x_Unmap(CConstRef<CSeq_entry> obj, CTSE_Info* info)
  414. {
  415.     x_UnmapObject(m_TSE_InfoMap, obj, info);
  416. }
  419. void CDataSource::x_Map(CConstRef<CSeq_entry> obj, CSeq_entry_Info* info)
  420. {
  421.     x_MapObject(m_Seq_entry_InfoMap, obj, info);
  422. }
  425. void CDataSource::x_Unmap(CConstRef<CSeq_entry> obj, CSeq_entry_Info* info)
  426. {
  427.     x_UnmapObject(m_Seq_entry_InfoMap, obj, info);
  428. }
  431. void CDataSource::x_Map(CConstRef<CSeq_annot> obj, CSeq_annot_Info* info)
  432. {
  433.     x_MapObject(m_Seq_annot_InfoMap, obj, info);
  434. }
  437. void CDataSource::x_Unmap(CConstRef<CSeq_annot> obj, CSeq_annot_Info* info)
  438. {
  439.     x_UnmapObject(m_Seq_annot_InfoMap, obj, info);
  440. }
  443. void CDataSource::x_Map(CConstRef<CBioseq> obj, CBioseq_Info* info)
  444. {
  445.     x_MapObject(m_Bioseq_InfoMap, obj, info);
  446. }
  449. void CDataSource::x_Unmap(CConstRef<CBioseq> obj, CBioseq_Info* info)
  450. {
  451.     x_UnmapObject(m_Bioseq_InfoMap, obj, info);
  452. }
  455. /////////////////////////////////////////////////////////////////////////////
  456. //   mapping of various XXX_Info
  457. // CDataSource must be guarded by mutex
  458. /////////////////////////////////////////////////////////////////////////////
  460. CConstRef<CTSE_Info>
  461. CDataSource::FindTSEInfo(const CSeq_entry& tse)
  462. {
  463.     TMainReadLockGuard guard(m_DSMainLock);
  464.     return x_FindTSE_Info(tse);
  465. }
  468. CConstRef<CSeq_entry_Info>
  469. CDataSource::FindSeq_entry_Info(const CSeq_entry& entry)
  470. {
  471.     TMainReadLockGuard guard(m_DSMainLock);
  472.     return x_FindSeq_entry_Info(entry);
  473. }
  476. CConstRef<CSeq_annot_Info>
  477. CDataSource::FindSeq_annot_Info(const CSeq_annot& annot)
  478. {
  479.     TMainReadLockGuard guard(m_DSMainLock);
  480.     return x_FindSeq_annot_Info(annot);
  481. }
  484. CConstRef<CBioseq_Info>
  485. CDataSource::FindBioseq_Info(const CBioseq& bioseq)
  486. {
  487.     TMainReadLockGuard guard(m_DSMainLock);
  488.     return x_FindBioseq_Info(bioseq);
  489. }
  492. CConstRef<CTSE_Info>
  493. CDataSource::x_FindTSE_Info(const CSeq_entry& obj)
  494. {
  495.     CConstRef<CTSE_Info> ret;
  496.     TTSE_InfoMap::iterator found = m_TSE_InfoMap.find(ConstRef(&obj));
  497.     if ( found != m_TSE_InfoMap.end() ) {
  498.         ret.Reset(found->second);
  499.     }
  500.     return ret;
  501. }
  504. CConstRef<CSeq_entry_Info>
  505. CDataSource::x_FindSeq_entry_Info(const CSeq_entry& obj)
  506. {
  507.     CConstRef<CSeq_entry_Info> ret;
  508.     TSeq_entry_InfoMap::iterator found =
  509.         m_Seq_entry_InfoMap.find(ConstRef(&obj));
  510.     if ( found != m_Seq_entry_InfoMap.end() ) {
  511.         ret.Reset(found->second);
  512.     }
  513.     return ret;
  514. }
  517. CConstRef<CSeq_annot_Info>
  518. CDataSource::x_FindSeq_annot_Info(const CSeq_annot& obj)
  519. {
  520.     CConstRef<CSeq_annot_Info> ret;
  521.     TSeq_annot_InfoMap::iterator found =
  522.         m_Seq_annot_InfoMap.find(ConstRef(&obj));
  523.     if ( found != m_Seq_annot_InfoMap.end() ) {
  524.         ret.Reset(found->second);
  525.     }
  526.     return ret;
  527. }
  530. CConstRef<CBioseq_Info>
  531. CDataSource::x_FindBioseq_Info(const CBioseq& obj)
  532. {
  533.     CConstRef<CBioseq_Info> ret;
  534.     TBioseq_InfoMap::iterator found =
  535.         m_Bioseq_InfoMap.find(ConstRef(&obj));
  536.     if ( found != m_Bioseq_InfoMap.end() ) {
  537.         ret.Reset(found->second);
  538.     }
  539.     return ret;
  540. }
  542. /////////////////////////////////////////////////////////////////////////////
  545. CRef<CSeq_entry_Info> CDataSource::AttachEntry(CBioseq_set_Info& parent,
  546.                                                CSeq_entry& entry,
  547.                                                int index)
  548. {
  549.     if ( m_Loader ) {
  550.         NCBI_THROW(CObjMgrException, eModifyDataError,
  551.                    "Can not remove a loaded entry");
  552.     }
  553.     TMainWriteLockGuard guard(m_DSMainLock);
  554.     return parent.AddEntry(entry, index);
  555. }
  558. void CDataSource::RemoveEntry(CSeq_entry_Info& entry)
  559. {
  560.     if ( m_Loader ) {
  561.         NCBI_THROW(CObjMgrException, eModifyDataError,
  562.                    "Can not remove a loaded entry");
  563.     }
  564.     if ( !entry.HasParent_Info() ) {
  565.         // Top level entry
  566.         NCBI_THROW(CObjMgrException, eModifyDataError,
  567.                    "Can not remove top level seq-entry from a data source");
  568.     }
  570.     TMainWriteLockGuard guard(m_DSMainLock);
  571.     CBioseq_set_Info& parent = entry.GetParentBioseq_set_Info();
  572.     parent.RemoveEntry(Ref(&entry));
  573. }
  576. CRef<CSeq_annot_Info> CDataSource::AttachAnnot(CSeq_entry_Info& entry_info,
  577.                                                const CSeq_annot& annot)
  578. {
  579.     if ( m_Loader ) {
  580.         NCBI_THROW(CObjMgrException, eModifyDataError,
  581.                    "Can not modify a loaded entry");
  582.     }
  584.     TMainWriteLockGuard guard(m_DSMainLock);
  585.     return entry_info.AddAnnot(annot);
  586. }
  589. CRef<CSeq_annot_Info> CDataSource::AttachAnnot(CBioseq_Base_Info& parent,
  590.                                                const CSeq_annot& annot)
  591. {
  592.     if ( m_Loader ) {
  593.         NCBI_THROW(CObjMgrException, eModifyDataError,
  594.                    "Can not modify a loaded entry");
  595.     }
  597.     TMainWriteLockGuard guard(m_DSMainLock);
  598.     return parent.AddAnnot(annot);
  599. }
  602. void CDataSource::RemoveAnnot(CSeq_annot_Info& annot)
  603. {
  604.     if ( m_Loader ) {
  605.         NCBI_THROW(CObjMgrException, eModifyDataError,
  606.                    "Can not modify a loaded entry");
  607.     }
  609.     TMainWriteLockGuard guard(m_DSMainLock);
  610.     CBioseq_Base_Info& parent = annot.GetParentBioseq_Base_Info();
  611.     parent.RemoveAnnot(Ref(&annot));
  612. }
  615. CRef<CSeq_annot_Info> CDataSource::ReplaceAnnot(CSeq_annot_Info& old_annot,
  616.                                                 const CSeq_annot& new_annot)
  617. {
  618.     if ( m_Loader ) {
  619.         NCBI_THROW(CObjMgrException, eModifyDataError,
  620.                    "Can not modify a loaded entry");
  621.     }
  623.     TMainWriteLockGuard guard(m_DSMainLock);
  624.     CBioseq_Base_Info& parent = old_annot.GetParentBioseq_Base_Info();
  625.     parent.RemoveAnnot(Ref(&old_annot));
  626.     return parent.AddAnnot(new_annot);
  627. }
  630. void PrintSeqMap(const string& /*id*/, const CSeqMap& /*smap*/)
  631. {
  632. #if _DEBUG && 0
  633.     _TRACE("CSeqMap("<<id<<"):");
  634.     ITERATE ( CSeqMap, it, smap ) {
  635.         switch ( it.GetType() ) {
  636.         case CSeqMap::eSeqGap:
  637.             _TRACE("    gap: "<<it.GetLength());
  638.             break;
  639.         case CSeqMap::eSeqData:
  640.             _TRACE("    data: "<<it.GetLength());
  641.             break;
  642.         case CSeqMap::eSeqRef:
  643.             _TRACE("    ref: "<<it.GetRefSeqid().AsString()<<' '<<
  644.                    it.GetRefPosition()<<' '<<it.GetLength()<<' '<<
  645.                    it.GetRefMinusStrand());
  646.             break;
  647.         default:
  648.             _TRACE("    bad: "<<it.GetType()<<' '<<it.GetLength());
  649.             break;
  650.         }
  651.     }
  652.     _TRACE("end of CSeqMap "<<id);
  653. #endif
  654. }
  657. void CDataSource::x_SetDirtyAnnotIndex(CTSE_Info& tse)
  658. {
  659.     _ASSERT(tse.x_DirtyAnnotIndex());
  660.     TAnnotWriteLockGuard guard(m_DSAnnotLock);
  661.     _VERIFY(m_DirtyAnnot_TSEs.insert(&tse).second);
  662. }
  665. void CDataSource::x_ResetDirtyAnnotIndex(CTSE_Info& tse)
  666. {
  667.     _ASSERT(!tse.x_DirtyAnnotIndex());
  668.     _VERIFY(m_DirtyAnnot_TSEs.erase(&tse));
  669. }
  672. void CDataSource::UpdateAnnotIndex(void)
  673. {
  674.     TMainWriteLockGuard guard(m_DSMainLock);
  675.     while ( !m_DirtyAnnot_TSEs.empty() ) {
  676.         CTSE_Info* tse_info = *m_DirtyAnnot_TSEs.begin();
  677.         tse_info->UpdateAnnotIndex();
  678.         _ASSERT(m_DirtyAnnot_TSEs.empty() ||
  679.                 *m_DirtyAnnot_TSEs.begin() != tse_info);
  681.     }
  682. }
  685. void CDataSource::UpdateAnnotIndex(const CSeq_entry_Info& entry_info)
  686. {
  687.     TMainWriteLockGuard guard(m_DSMainLock);
  688.     entry_info.UpdateAnnotIndex();
  689. }
  692. void CDataSource::UpdateAnnotIndex(const CSeq_annot_Info& annot_info)
  693. {
  694.     TMainWriteLockGuard guard(m_DSMainLock);
  695.     annot_info.UpdateAnnotIndex();
  696. }
  699. void CDataSource::GetTSESetWithAnnots(const CSeq_id_Handle& idh,
  700.                                       TTSE_LockSet& with_ref)
  701. {
  702.     // load all relevant TSEs
  703.     if ( m_Loader ) {
  704.         m_Loader->GetRecords(idh, CDataLoader::eAnnot);
  705.     }
  707.     UpdateAnnotIndex();
  709.     // collect all relevant TSEs
  710.     TTSEMap::const_iterator rtse_it = m_TSE_annot.find(idh);
  711.     if ( rtse_it != m_TSE_annot.end() ) {
  712.         ITERATE(CTSE_LockingSet::TTSESet, tse, rtse_it->second) {
  713.             if ( (*tse)->ContainsSeqid(idh) ) {
  714.                 // skip TSE containing sequence
  715.                 continue;
  716.             }
  717.             with_ref.insert(TTSE_Lock(*tse));
  718.         }
  719.     }
  720. }
  723. void CDataSource::GetSynonyms(const CSeq_id_Handle& main_idh,
  724.                               set<CSeq_id_Handle>& syns)
  725. {
  726.     //### The TSE returns locked, unlock it
  727.     CSeq_id_Handle idh = main_idh;
  728.     TTSE_Lock tse_info(x_FindBestTSE(main_idh));
  729.     if ( !tse_info ) {
  730.         // Try to find the best matching id (not exactly equal)
  731.         CSeq_id_Mapper& mapper = CSeq_id_Mapper::GetSeq_id_Mapper();
  732.         if ( mapper.HaveMatchingHandles(idh) ) {
  733.             TSeq_id_HandleSet hset;
  734.             mapper.GetMatchingHandles(idh, hset);
  735.             ITERATE(TSeq_id_HandleSet, hit, hset) {
  736.                 if ( *hit == main_idh ) // already checked
  737.                     continue;
  738.                 if ( bool(tse_info)  &&  idh.IsBetter(*hit) ) // worse hit
  739.                     continue;
  740.                 TTSE_Lock tmp_tse(x_FindBestTSE(*hit));
  741.                 if ( tmp_tse ) {
  742.                     tse_info = tmp_tse;
  743.                     idh = *hit;
  744.                 }
  745.             }
  746.         }
  747.     }
  748.     // At this point the tse_info (if not null) should be locked
  749.     if ( tse_info ) {
  750.         CTSE_Info::TBioseqs::const_iterator info =
  751.             tse_info->m_Bioseqs.find(idh);
  752.         if (info == tse_info->m_Bioseqs.end()) {
  753.             // Just copy the existing id
  754.             syns.insert(main_idh);
  755.         }
  756.         else {
  757.             // Create range list for each synonym of a seq_id
  758.             const CBioseq_Info::TId& syn = info->second->GetId();
  759.             ITERATE ( CBioseq_Info::TId, syn_it, syn ) {
  760.                 syns.insert(*syn_it);
  761.             }
  762.         }
  763.     }
  764.     else {
  765.         // Just copy the existing range map
  766.         syns.insert(main_idh);
  767.     }
  768. }
  771. void CDataSource::x_IndexTSE(TTSEMap& tse_map,
  772.                              const CSeq_id_Handle& id,
  773.                              CTSE_Info* tse_info)
  774. {
  775.     TTSEMap::iterator it = tse_map.lower_bound(id);
  776.     if ( it == tse_map.end() || it->first != id ) {
  777.         it = tse_map.insert(it, TTSEMap::value_type(id, CTSE_LockingSet()));
  778.     }
  779.     _ASSERT(it != tse_map.end() && it->first == id);
  780.     it->second.insert(tse_info);
  781. }
  784. void CDataSource::x_UnindexTSE(TTSEMap& tse_map,
  785.                                const CSeq_id_Handle& id,
  786.                                CTSE_Info* tse_info)
  787. {
  788.     TTSEMap::iterator it = tse_map.find(id);
  789.     _ASSERT(it != tse_map.end() && it->first == id);
  790.     it->second.erase(tse_info);
  791.     if ( it->second.empty() ) {
  792.         tse_map.erase(it);
  793.     }
  794. }
  797. void CDataSource::x_IndexSeqTSE(const CSeq_id_Handle& id,
  798.                                 CTSE_Info* tse_info)
  799. {
  800.     // no need to lock as it's locked by callers
  801.     x_IndexTSE(m_TSE_seq, id, tse_info);
  802. }
  805. void CDataSource::x_UnindexSeqTSE(const CSeq_id_Handle& id,
  806.                                   CTSE_Info* tse_info)
  807. {
  808.     // no need to lock as it's locked by callers
  809.     x_UnindexTSE(m_TSE_seq, id, tse_info);
  810. }
  813. void CDataSource::x_IndexAnnotTSE(const CSeq_id_Handle& id,
  814.                                   CTSE_Info* tse_info)
  815. {
  816.     TAnnotWriteLockGuard guard(m_DSAnnotLock);
  817.     x_IndexTSE(m_TSE_annot, id, tse_info);
  818. }
  821. void CDataSource::x_UnindexAnnotTSE(const CSeq_id_Handle& id,
  822.                                     CTSE_Info* tse_info)
  823. {
  824.     TAnnotWriteLockGuard guard(m_DSAnnotLock);
  825.     x_UnindexTSE(m_TSE_annot, id, tse_info);
  826. }
  829. void CDataSource::x_IndexAnnotTSEs(CTSE_Info* tse_info)
  830. {
  831.     TAnnotWriteLockGuard guard(m_DSAnnotLock);
  832.     ITERATE ( CTSE_Info::TSeqIdToNames, it, tse_info->m_SeqIdToNames ) {
  833.         x_IndexTSE(m_TSE_annot, it->first, tse_info);
  834.     }
  835.     if ( tse_info->x_DirtyAnnotIndex() ) {
  836.         _VERIFY(m_DirtyAnnot_TSEs.insert(tse_info).second);
  837.     }
  838. }
  841. void CDataSource::x_UnindexAnnotTSEs(CTSE_Info* tse_info)
  842. {
  843.     TAnnotWriteLockGuard guard(m_DSAnnotLock);
  844.     ITERATE ( CTSE_Info::TSeqIdToNames, it, tse_info->m_SeqIdToNames ) {
  845.         x_UnindexTSE(m_TSE_annot, it->first, tse_info);
  846.     }
  847. }
  850. void CDataSource::x_CleanupUnusedEntries(void)
  851. {
  852.     // Lock indexes
  853.     TMainWriteLockGuard guard(m_DSMainLock);    
  855.     bool broken = true;
  856.     while ( broken ) {
  857.         broken = false;
  858.         NON_CONST_ITERATE( TTSE_Set, it, m_TSE_Set ) {
  859.             if ( !(*it)->Locked() ) {
  860.                 //### Lock the entry and check again
  861.                 x_DropTSE(const_cast<CTSE_Info&>(**it));
  862.                 broken = true;
  863.                 break;
  864.             }
  865.         }
  866.     }
  867. }
  870. void CDataSource::x_UpdateTSEStatus(CTSE_Info& tse, bool dead)
  871. {
  872.     tse.m_Dead = dead;
  873. }
  876. CSeqMatch_Info CDataSource::BestResolve(CSeq_id_Handle idh)
  877. {
  878.     //### Lock all TSEs found, unlock all filtered out in the end.
  879.     CTSE_LockingSetLock lock;
  880.     {{
  881.         TMainWriteLockGuard guard(m_DSMainLock);
  882.         lock.Lock(m_TSE_seq[idh]);
  883.     }}
  884.     if ( m_Loader ) {
  885.         // Send request to the loader
  886.         m_Loader->GetRecords(idh, CDataLoader::eBioseqCore);
  887.     }
  888.     CSeqMatch_Info match;
  889.     TTSE_Lock tse(x_FindBestTSE(idh));
  890.     if ( !tse ) {
  891.         // Try to find the best matching id (not exactly equal)
  892.         CSeq_id_Mapper& mapper = CSeq_id_Mapper::GetSeq_id_Mapper();
  893.         if ( mapper.HaveMatchingHandles(idh) ) {
  894.             TSeq_id_HandleSet hset;
  895.             mapper.GetMatchingHandles(idh, hset);
  896.             ITERATE(TSeq_id_HandleSet, hit, hset) {
  897.                 if ( *hit == idh ) // already checked
  898.                     continue;
  899.                 if ( bool(tse)  &&  idh.IsBetter(*hit) ) // worse hit
  900.                     continue;
  901.                 TTSE_Lock tmp_tse(x_FindBestTSE(*hit));
  902.                 if ( tmp_tse ) {
  903.                     tse = tmp_tse;
  904.                     idh = *hit;
  905.                 }
  906.             }
  907.         }
  908.     }
  909.     if ( tse ) {
  910.         match = CSeqMatch_Info(idh, *tse);
  911.     }
  912.     return match;
  913. }
  916. CSeqMatch_Info CDataSource::HistoryResolve(CSeq_id_Handle idh,
  917.                                            const TTSE_LockSet& history)
  918. {
  919.     CSeqMatch_Info match;
  920.     {{
  921.         TMainReadLockGuard guard(m_DSMainLock);
  922.         TTSEMap::const_iterator tse_set = m_TSE_seq.find(idh);
  923.         if ( tse_set != m_TSE_seq.end() ) {
  924.             ITERATE ( CTSE_LockingSet, it, tse_set->second ) {
  925.                 if ( history.find(TTSE_Lock(*it)) == history.end() ) {
  926.                     continue;
  927.                 }
  928.                 
  929.                 CSeqMatch_Info new_match(idh, **it);
  930.                 _ASSERT(new_match.GetBioseq_Info());
  931.                 if ( !match ) {
  932.                     match = new_match;
  933.                     continue;
  934.                 }
  936.                 CNcbiOstrstream s;
  937.                 s << "CDataSource("<<GetName()<<"): "
  938.                     "multiple history matches: Seq-id="<<idh.AsString()<<
  939.                     ": seq1=["<<match.GetBioseq_Info()->IdString()<<
  940.                     "] seq2=["<<new_match.GetBioseq_Info()->IdString()<<"]";
  941.                 string msg = CNcbiOstrstreamToString(s);
  942.                 NCBI_THROW(CObjMgrException, eFindConflict, msg);
  943.             }
  944.         }
  945.     }}
  946.     return match;
  947. }
  950. CSeqMatch_Info* CDataSource::ResolveConflict(const CSeq_id_Handle& id,
  951.                                              CSeqMatch_Info& info1,
  952.                                              CSeqMatch_Info& info2)
  953. {
  954.     if (&info1.GetDataSource() != this  ||
  955.         &info2.GetDataSource() != this) {
  956.         // Can not compare TSEs from different data sources or
  957.         // without a loader.
  958.         return 0;
  959.     }
  960.     if (!m_Loader) {
  961.         if ( info1.GetIdHandle().IsBetter(info2.GetIdHandle()) ) {
  962.             return &info1;
  963.         }
  964.         if ( info2.GetIdHandle().IsBetter(info1.GetIdHandle()) ) {
  965.             return &info2;
  966.         }
  967.         return 0;
  968.     }
  969.     TTSE_LockSet tse_set;
  970.     tse_set.insert(TTSE_Lock(&info1.GetTSE_Info()));
  971.     tse_set.insert(TTSE_Lock(&info2.GetTSE_Info()));
  972.     CConstRef<CTSE_Info> tse = m_Loader->ResolveConflict(id, tse_set);
  973.     if (tse == &info1.GetTSE_Info()) {
  974.         return &info1;
  975.     }
  976.     if (tse == &info2.GetTSE_Info()) {
  977.         return &info2;
  978.     }
  979.     return 0;
  980. }
  983. string CDataSource::GetName(void) const
  984. {
  985.     if ( m_Loader )
  986.         return m_Loader->GetName();
  987.     else
  988.         return kEmptyStr;
  989. }
  992. void CDataSource::GetBioseqs(const CSeq_entry_Info& entry,
  993.                              TBioseq_InfoSet& bioseqs,
  994.                              CSeq_inst::EMol filter,
  995.                              TBioseqLevelFlag level)
  996. {
  997.     // Find TSE_Info
  998.     x_CollectBioseqs(entry, bioseqs, filter, level);
  999. }
  1002. void CDataSource::x_CollectBioseqs(const CSeq_entry_Info& info,
  1003.                                    TBioseq_InfoSet& bioseqs,
  1004.                                    CSeq_inst::EMol filter,
  1005.                                    TBioseqLevelFlag level)
  1006. {
  1007.     // parts should be changed to all before adding bioseqs to the list
  1008.     if ( info.IsSeq() ) {
  1009.         const CBioseq_Info& seq = info.GetSeq();
  1010.         if ( level != CBioseq_CI_Base::eLevel_Parts &&
  1011.              (filter == CSeq_inst::eMol_not_set ||
  1012.               seq.GetInst_Mol() == filter) ) {
  1013.             bioseqs.push_back(ConstRef(&seq));
  1014.         }
  1015.     }
  1016.     else {
  1017.         const CBioseq_set_Info& set = info.GetSet();
  1018.         ITERATE( CBioseq_set_Info::TSeq_set, it, set.GetSeq_set() ) {
  1019.             const CSeq_entry_Info& sub_info = **it;
  1020.             TBioseqLevelFlag local_level = level;
  1021.             if ( sub_info.IsSet() &&
  1022.                  sub_info.GetSet().GetClass() == CBioseq_set::eClass_parts ) {
  1023.                 switch (level) {
  1024.                 case CBioseq_CI_Base::eLevel_Mains:
  1025.                     // Skip parts
  1026.                     continue;
  1027.                 case CBioseq_CI_Base::eLevel_Parts:
  1028.                     // Allow adding bioseqs from lower levels
  1029.                     local_level = CBioseq_CI_Base::eLevel_All;
  1030.                     break;
  1031.                 default:
  1032.                     break;
  1033.                 }
  1034.             }
  1035.             x_CollectBioseqs(sub_info, bioseqs, filter, local_level);
  1036.         }
  1037.     }
  1038. }
  1041. void CDataSource::Prefetch(CPrefetchToken_Impl& token)
  1042. {
  1043. #if !defined(NCBI_NO_THREADS)
  1044.     if (!m_PrefetchThread) {
  1045.         CFastMutexGuard guard(m_PrefetchLock);
  1046.         // Check againi
  1047.         if (!m_PrefetchThread) {
  1048.             m_PrefetchThread.Reset(new CPrefetchThread(*this));
  1049.             m_PrefetchThread->Run();
  1050.         }
  1051.     }
  1052.     _ASSERT(m_PrefetchThread);
  1053.     m_PrefetchThread->AddRequest(token);
  1054. #endif
  1055. }
  1058. void CDataSource::DebugDump(CDebugDumpContext /*ddc*/,
  1059.                             unsigned int /*depth*/) const
  1060. {
  1061. }
  1064. END_SCOPE(objects)
  1065. END_NCBI_SCOPE
  1067. /*
  1068. * ---------------------------------------------------------------------------
  1069. * $Log: data_source.cpp,v $
  1070. * Revision 1000.4  2004/06/01 19:23:11  gouriano
  1071. * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.133
  1072. *
  1073. * Revision 1.133  2004/05/21 21:42:12  gorelenk
  1074. * Added PCH ncbi_pch.hpp
  1075. *
  1076. * Revision 1.132  2004/04/16 13:31:47  grichenk
  1077. * Added data pre-fetching functions.
  1078. *
  1079. * Revision 1.131  2004/03/31 17:08:07  vasilche
  1080. * Implemented ConvertSeqToSet and ConvertSetToSeq.
  1081. *
  1082. * Revision 1.130  2004/03/24 18:30:29  vasilche
  1083. * Fixed edit API.
  1084. * Every *_Info object has its own shallow copy of original object.
  1085. *
  1086. * Revision 1.129  2004/03/16 15:47:27  vasilche
  1087. * Added CBioseq_set_Handle and set of EditHandles
  1088. *
  1089. * Revision 1.128  2004/02/25 19:23:46  shomrat
  1090. * Use of entry_info instead of tse_info to allow collection of bioseqs on non-tse entries
  1091. *
  1092. * Revision 1.127  2004/02/03 19:02:17  vasilche
  1093. * Fixed broken 'dirty annot index' state after RemoveEntry().
  1094. *
  1095. * Revision 1.126  2004/02/02 15:27:20  dicuccio
  1096. * +<algorithm> for find
  1097. *
  1098. * Revision 1.125  2004/02/02 14:46:43  vasilche
  1099. * Several performance fixed - do not iterate whole tse set in CDataSource.
  1100. *
  1101. * Revision 1.124  2003/12/18 16:38:06  grichenk
  1102. * Added CScope::RemoveEntry()
  1103. *
  1104. * Revision 1.123  2003/11/26 17:55:57  vasilche
  1105. * Implemented ID2 split in ID1 cache.
  1106. * Fixed loading of splitted annotations.
  1107. *
  1108. * Revision 1.122  2003/10/27 16:47:12  vasilche
  1109. * Fixed error:
  1110. * src/objmgr/data_source.cpp", line 913: Fatal: Assertion failed: (it != tse_map.end() && it->first == id)
  1111. *
  1112. * Revision 1.121  2003/10/07 13:43:23  vasilche
  1113. * Added proper handling of named Seq-annots.
  1114. * Added feature search from named Seq-annots.
  1115. * Added configurable adaptive annotation search (default: gene, cds, mrna).
  1116. * Fixed selection of blobs for loading from GenBank.
  1117. * Added debug checks to CSeq_id_Mapper for easier finding lost CSeq_id_Handles.
  1118. * Fixed leaked split chunks annotation stubs.
  1119. * Moved some classes definitions in separate *.cpp files.
  1120. *
  1121. * Revision 1.120  2003/09/30 16:22:02  vasilche
  1122. * Updated internal object manager classes to be able to load ID2 data.
  1123. * SNP blobs are loaded as ID2 split blobs - readers convert them automatically.
  1124. * Scope caches results of requests for data to data loaders.
  1125. * Optimized CSeq_id_Handle for gis.
  1126. * Optimized bioseq lookup in scope.
  1127. * Reduced object allocations in annotation iterators.
  1128. * CScope is allowed to be destroyed before other objects using this scope are
  1129. * deleted (feature iterators, bioseq handles etc).
  1130. * Optimized lookup for matching Seq-ids in CSeq_id_Mapper.
  1131. * Added 'adaptive' option to objmgr_demo application.
  1132. *
  1133. * Revision 1.119  2003/09/05 17:29:40  grichenk
  1134. * Structurized Object Manager exceptions
  1135. *
  1136. * Revision 1.118  2003/09/03 20:00:02  grichenk
  1137. * Added sequence filtering by level (mains/parts/all)
  1138. *
  1139. * Revision 1.117  2003/08/14 20:05:19  vasilche
  1140. * Simple SNP features are stored as table internally.
  1141. * They are recreated when needed using CFeat_CI.
  1142. *
  1143. * Revision 1.116  2003/08/04 17:04:31  grichenk
  1144. * Added default data-source priority assignment.
  1145. * Added support for iterating all annotations from a
  1146. * seq-entry or seq-annot.
  1147. *
  1148. * Revision 1.115  2003/07/17 22:51:31  vasilche
  1149. * Fixed unused variables warnings.
  1150. *
  1151. * Revision 1.114  2003/07/17 20:07:56  vasilche
  1152. * Reduced memory usage by feature indexes.
  1153. * SNP data is loaded separately through PUBSEQ_OS.
  1154. * String compression for SNP data.
  1155. *
  1156. * Revision 1.113  2003/07/09 17:54:29  dicuccio
  1157. * Fixed uninitialized variables in CDataSource and CSeq_annot_Info
  1158. *
  1159. * Revision 1.112  2003/07/01 18:01:08  vasilche
  1160. * Added check for null m_SeqMap pointer.
  1161. *
  1162. * Revision 1.111  2003/06/24 14:35:01  vasilche
  1163. * Fixed compilation in debug mode.
  1164. *
  1165. * Revision 1.110  2003/06/24 14:25:18  vasilche
  1166. * Removed obsolete CTSE_Guard class.
  1167. * Used separate mutexes for bioseq and annot maps.
  1168. *
  1169. * Revision 1.109  2003/06/19 18:23:45  vasilche
  1170. * Added several CXxx_ScopeInfo classes for CScope related information.
  1171. * CBioseq_Handle now uses reference to CBioseq_ScopeInfo.
  1172. * Some fine tuning of locking in CScope.
  1173. *
  1174. * Revision 1.104  2003/05/20 15:44:37  vasilche
  1175. * Fixed interaction of CDataSource and CDataLoader in multithreaded app.
  1176. * Fixed some warnings on WorkShop.
  1177. * Added workaround for memory leak on WorkShop.
  1178. *
  1179. * Revision 1.103  2003/05/14 18:39:28  grichenk
  1180. * Simplified TSE caching and filtering in CScope, removed
  1181. * some obsolete members and functions.
  1182. *
  1183. * Revision 1.102  2003/05/12 19:18:29  vasilche
  1184. * Fixed locking of object manager classes in multi-threaded application.
  1185. *
  1186. * Revision 1.101  2003/05/06 18:54:09  grichenk
  1187. * Moved TSE filtering from CDataSource to CScope, changed
  1188. * some filtering rules (e.g. priority is now more important
  1189. * than scope history). Added more caches to CScope.
  1190. *
  1191. * Revision 1.100  2003/05/05 20:59:47  vasilche
  1192. * Use one static mutex for all instances of CTSE_LockingSet.
  1193. *
  1194. * Revision 1.99  2003/04/29 19:51:13  vasilche
  1195. * Fixed interaction of Data Loader garbage collector and TSE locking mechanism.
  1196. * Made some typedefs more consistent.
  1197. *
  1198. * Revision 1.98  2003/04/24 16:12:38  vasilche
  1199. * Object manager internal structures are splitted more straightforward.
  1200. * Removed excessive header dependencies.
  1201. *
  1202. * Revision 1.97  2003/04/14 21:32:18  grichenk
  1203. * Avoid passing CScope as an argument to CDataSource methods
  1204. *
  1205. * Revision 1.96  2003/03/24 21:26:45  grichenk
  1206. * Added support for CTSE_CI
  1207. *
  1208. * Revision 1.95  2003/03/21 21:08:53  grichenk
  1209. * Fixed TTSE_Lock initialization
  1210. *
  1211. * Revision 1.93  2003/03/21 19:22:51  grichenk
  1212. * Redesigned TSE locking, replaced CTSE_Lock with CRef<CTSE_Info>.
  1213. *
  1214. * Revision 1.92  2003/03/18 14:52:59  grichenk
  1215. * Removed obsolete methods, replaced seq-id with seq-id handle
  1216. * where possible. Added argument to limit annotations update to
  1217. * a single seq-entry.
  1218. *
  1219. * Revision 1.91  2003/03/12 20:09:34  grichenk
  1220. * Redistributed members between CBioseq_Handle, CBioseq_Info and CTSE_Info
  1221. *
  1222. * Revision 1.90  2003/03/11 15:51:06  kuznets
  1223. * iterate -> ITERATE
  1224. *
  1225. * Revision 1.89  2003/03/11 14:15:52  grichenk
  1226. * +Data-source priority
  1227. *
  1228. * Revision 1.88  2003/03/10 16:55:17  vasilche
  1229. * Cleaned SAnnotSelector structure.
  1230. * Added shortcut when features are limited to one TSE.
  1231. *
  1232. * Revision 1.87  2003/03/05 20:56:43  vasilche
  1233. * SAnnotSelector now holds all parameters of annotation iterators.
  1234. *
  1235. * Revision 1.86  2003/03/03 20:31:08  vasilche
  1236. * Removed obsolete method PopulateTSESet().
  1237. *
  1238. * Revision 1.85  2003/02/27 14:35:31  vasilche
  1239. * Splitted PopulateTSESet() by logically independent parts.
  1240. *
  1241. * Revision 1.84  2003/02/25 20:10:40  grichenk
  1242. * Reverted to single total-range index for annotations
  1243. *
  1244. * Revision 1.83  2003/02/24 18:57:22  vasilche
  1245. * Make feature gathering in one linear pass using CSeqMap iterator.
  1246. * Do not use feture index by sub locations.
  1247. * Sort features at the end of gathering in one vector.
  1248. * Extracted some internal structures and classes in separate header.
  1249. * Delay creation of mapped features.
  1250. *
  1251. * Revision 1.82  2003/02/24 14:51:11  grichenk
  1252. * Minor improvements in annot indexing
  1253. *
  1254. * Revision 1.81  2003/02/13 14:34:34  grichenk
  1255. * Renamed CAnnotObject -> CAnnotObject_Info
  1256. * + CSeq_annot_Info and CAnnotObject_Ref
  1257. * Moved some members of CAnnotObject to CSeq_annot_Info
  1258. * and CAnnotObject_Ref.
  1259. * Added feat/align/graph to CAnnotObject_Info map
  1260. * to CDataSource.
  1261. *
  1262. * Revision 1.80  2003/02/05 17:59:17  dicuccio
  1263. * Moved formerly private headers into include/objects/objmgr/impl
  1264. *
  1265. * Revision 1.79  2003/02/04 22:01:26  grichenk
  1266. * Fixed annotations loading/indexing order
  1267. *
  1268. * Revision 1.78  2003/02/04 21:46:32  grichenk
  1269. * Added map of annotations by intervals (the old one was
  1270. * by total ranges)
  1271. *
  1272. * Revision 1.77  2003/01/29 22:03:46  grichenk
  1273. * Use single static CSeq_id_Mapper instead of per-OM model.
  1274. *
  1275. * Revision 1.76  2003/01/29 17:45:02  vasilche
  1276. * Annotaions index is split by annotation/feature type.
  1277. *
  1278. * Revision 1.75  2003/01/22 20:11:54  vasilche
  1279. * Merged functionality of CSeqMapResolved_CI to CSeqMap_CI.
  1280. * CSeqMap_CI now supports resolution and iteration over sequence range.
  1281. * Added several caches to CScope.
  1282. * Optimized CSeqVector().
  1283. * Added serveral variants of CBioseqHandle::GetSeqVector().
  1284. * Tried to optimize annotations iterator (not much success).
  1285. * Rewritten CHandleRange and CHandleRangeMap classes to avoid sorting of list.
  1286. *
  1287. * Revision 1.74  2002/12/26 16:39:24  vasilche
  1288. * Object manager class CSeqMap rewritten.
  1289. *
  1290. * Revision 1.73  2002/12/20 20:54:24  grichenk
  1291. * Added optional location/product switch to CFeat_CI
  1292. *
  1293. * Revision 1.72  2002/12/19 20:16:39  grichenk
  1294. * Fixed locations on minus strand
  1295. *
  1296. * Revision 1.71  2002/12/06 15:36:00  grichenk
  1297. * Added overlap type for annot-iterators
  1298. *
  1299. * Revision 1.70  2002/11/08 22:15:51  grichenk
  1300. * Added methods for removing/replacing annotations
  1301. *
  1302. * Revision 1.69  2002/11/08 21:03:30  ucko
  1303. * CConstRef<> now requires an explicit constructor.
  1304. *
  1305. * Revision 1.68  2002/11/04 21:29:12  grichenk
  1306. * Fixed usage of const CRef<> and CRef<> constructor
  1307. *
  1308. * Revision 1.67  2002/10/18 19:12:40  grichenk
  1309. * Removed mutex pools, converted most static mutexes to non-static.
  1310. * Protected CSeqMap::x_Resolve() with mutex. Modified code to prevent
  1311. * dead-locks.
  1312. *
  1313. * Revision 1.66  2002/10/16 20:44:16  ucko
  1314. * MIPSpro: use #pragma instantiate rather than template<>, as the latter
  1315. * ended up giving rld errors for CMutexPool_Base<*>::sm_Pool.  (Sigh.)
  1316. *
  1317. * Revision 1.65  2002/10/02 17:58:23  grichenk
  1318. * Added sequence type filter to CBioseq_CI
  1319. *
  1320. * Revision 1.64  2002/09/30 20:01:19  grichenk
  1321. * Added methods to support CBioseq_CI
  1322. *
  1323. * Revision 1.63  2002/09/16 19:59:36  grichenk
  1324. * Fixed getting reference to a gap on minus strand
  1325. *
  1326. * Revision 1.62  2002/09/10 19:55:49  grichenk
  1327. * Throw exception when unable to create resolved seq-map
  1328. *
  1329. * Revision 1.61  2002/08/09 14:58:50  ucko
  1330. * Restrict template <> to MIPSpro for now, as it also leads to link
  1331. * errors with Compaq's compiler.  (Sigh.)
  1332. *
  1333. * Revision 1.60  2002/08/08 19:51:16  ucko
  1334. * Omit EMPTY_TEMPLATE for GCC and KCC, as it evidently leads to link errors(!)
  1335. *
  1336. * Revision 1.59  2002/08/08 14:28:00  ucko
  1337. * Add EMPTY_TEMPLATE to explicit instantiations.
  1338. *
  1339. * Revision 1.58  2002/08/07 18:22:48  ucko
  1340. * Explicitly instantiate CMutexPool_Base<{CDataSource,TTSESet}>::sm_Pool
  1341. *
  1342. * Revision 1.57  2002/07/25 15:01:51  grichenk
  1343. * Replaced non-const GetXXX() with SetXXX()
  1344. *
  1345. * Revision 1.56  2002/07/08 20:51:01  grichenk
  1346. * Moved log to the end of file
  1347. * Replaced static mutex (in CScope, CDataSource) with the mutex
  1348. * pool. Redesigned CDataSource data locking.
  1349. *
  1350. * Revision 1.55  2002/07/01 15:44:51  grichenk
  1351. * Fixed typos
  1352. *
  1353. * Revision 1.54  2002/07/01 15:40:58  grichenk
  1354. * Fixed 'tse_set' warning.
  1355. * Removed duplicate call to tse_set.begin().
  1356. * Fixed version resolving for annotation iterators.
  1357. * Fixed strstream bug in KCC.
  1358. *
  1359. * Revision 1.53  2002/06/28 17:30:42  grichenk
  1360. * Duplicate seq-id: ERR_POST() -> THROW1_TRACE() with the seq-id
  1361. * list.
  1362. * Fixed x_CleanupUnusedEntries().
  1363. * Fixed a bug with not found sequences.
  1364. * Do not copy bioseq data in GetBioseqCore().
  1365. *
  1366. * Revision 1.52  2002/06/21 15:12:15  grichenk
  1367. * Added resolving seq-id to the best version
  1368. *
  1369. * Revision 1.51  2002/06/12 14:39:53  grichenk
  1370. * Performance improvements
  1371. *
  1372. * Revision 1.50  2002/06/04 17:18:33  kimelman
  1373. * memory cleanup :  new/delete/Cref rearrangements
  1374. *
  1375. * Revision 1.49  2002/05/31 17:53:00  grichenk
  1376. * Optimized for better performance (CTSE_Info uses atomic counter,
  1377. * delayed annotations indexing, no location convertions in
  1378. * CAnnot_Types_CI if no references resolution is required etc.)
  1379. *
  1380. * Revision 1.48  2002/05/29 21:21:13  gouriano
  1381. * added debug dump
  1382. *
  1383. * Revision 1.47  2002/05/28 18:00:43  gouriano
  1384. * DebugDump added
  1385. *
  1386. * Revision 1.46  2002/05/24 14:57:12  grichenk
  1387. * SerialAssign<>() -> CSerialObject::Assign()
  1388. *
  1389. * Revision 1.45  2002/05/21 18:57:25  grichenk
  1390. * Fixed annotations dropping
  1391. *
  1392. * Revision 1.44  2002/05/21 18:40:50  grichenk
  1393. * Fixed annotations droppping
  1394. *
  1395. * Revision 1.43  2002/05/14 20:06:25  grichenk
  1396. * Improved CTSE_Info locking by CDataSource and CDataLoader
  1397. *
  1398. * Revision 1.42  2002/05/13 15:28:27  grichenk
  1399. * Fixed seqmap for virtual sequences
  1400. *
  1401. * Revision 1.41  2002/05/09 14:18:15  grichenk
  1402. * More TSE conflict resolving rules for annotations
  1403. *
  1404. * Revision 1.40  2002/05/06 03:28:46  vakatov
  1405. * OM/OM1 renaming
  1406. *
  1407. * Revision 1.39  2002/05/03 21:28:09  ucko
  1408. * Introduce T(Signed)SeqPos.
  1409. *
  1410. * Revision 1.38  2002/05/02 20:42:37  grichenk
  1411. * throw -> THROW1_TRACE
  1412. *
  1413. * Revision 1.37  2002/04/22 20:05:08  grichenk
  1414. * Fixed minor bug in GetSequence()
  1415. *
  1416. * Revision 1.36  2002/04/19 18:02:47  kimelman
  1417. * add verify to catch coredump
  1418. *
  1419. * Revision 1.35  2002/04/17 21:09:14  grichenk
  1420. * Fixed annotations loading
  1421. * +IsSynonym()
  1422. *
  1423. * Revision 1.34  2002/04/11 18:45:39  ucko
  1424. * Pull in extra headers to make KCC happy.
  1425. *
  1426. * Revision 1.33  2002/04/11 12:08:21  grichenk
  1427. * Fixed GetResolvedSeqMap() implementation
  1428. *
  1429. * Revision 1.32  2002/04/05 21:23:08  grichenk
  1430. * More duplicate id warnings fixed
  1431. *
  1432. * Revision 1.31  2002/04/05 20:27:52  grichenk
  1433. * Fixed duplicate identifier warning
  1434. *
  1435. * Revision 1.30  2002/04/04 21:33:13  grichenk
  1436. * Fixed GetSequence() for sequences with unresolved segments
  1437. *
  1438. * Revision 1.29  2002/04/03 18:06:47  grichenk
  1439. * Fixed segmented sequence bugs (invalid positioning of literals
  1440. * and gaps). Improved CSeqVector performance.
  1441. *
  1442. * Revision 1.27  2002/03/28 14:02:31  grichenk
  1443. * Added scope history checks to CDataSource::x_FindBestTSE()
  1444. *
  1445. * Revision 1.26  2002/03/22 17:24:12  gouriano
  1446. * loader-related fix in DropTSE()
  1447. *
  1448. * Revision 1.25  2002/03/21 21:39:48  grichenk
  1449. * garbage collector bugfix
  1450. *
  1451. * Revision 1.24  2002/03/20 21:24:59  gouriano
  1452. * *** empty log message ***
  1453. *
  1454. * Revision 1.23  2002/03/15 18:10:08  grichenk
  1455. * Removed CRef<CSeq_id> from CSeq_id_Handle, added
  1456. * key to seq-id map th CSeq_id_Mapper
  1457. *
  1458. * Revision 1.22  2002/03/11 21:10:13  grichenk
  1459. * +CDataLoader::ResolveConflict()
  1460. *
  1461. * Revision 1.21  2002/03/07 21:25:33  grichenk
  1462. * +GetSeq_annot() in annotation iterators
  1463. *
  1464. * Revision 1.20  2002/03/06 19:37:19  grichenk
  1465. * Fixed minor bugs and comments
  1466. *
  1467. * Revision 1.19  2002/03/05 18:44:55  grichenk
  1468. * +x_UpdateTSEStatus()
  1469. *
  1470. * Revision 1.18  2002/03/05 16:09:10  grichenk
  1471. * Added x_CleanupUnusedEntries()
  1472. *
  1473. * Revision 1.17  2002/03/04 15:09:27  grichenk
  1474. * Improved MT-safety. Added live/dead flag to CDataSource methods.
  1475. *
  1476. * Revision 1.16  2002/02/28 20:53:31  grichenk
  1477. * Implemented attaching segmented sequence data. Fixed minor bugs.
  1478. *
  1479. * Revision 1.15  2002/02/25 21:05:29  grichenk
  1480. * Removed seq-data references caching. Increased MT-safety. Fixed typos.
  1481. *
  1482. * Revision 1.14  2002/02/21 19:27:05  grichenk
  1483. * Rearranged includes. Added scope history. Added searching for the
  1484. * best seq-id match in data sources and scopes. Updated tests.
  1485. *
  1486. * Revision 1.13  2002/02/20 20:23:27  gouriano
  1487. * corrected FilterSeqid()
  1488. *
  1489. * Revision 1.12  2002/02/15 20:35:38  gouriano
  1490. * changed implementation of HandleRangeMap
  1491. *
  1492. * Revision 1.11  2002/02/12 19:41:42  grichenk
  1493. * Seq-id handles lock/unlock moved to CSeq_id_Handle 'ctors.
  1494. *
  1495. * Revision 1.10  2002/02/07 21:27:35  grichenk
  1496. * Redesigned CDataSource indexing: seq-id handle -> TSE -> seq/annot
  1497. *
  1498. * Revision 1.9  2002/02/06 21:46:11  gouriano
  1499. * *** empty log message ***
  1500. *
  1501. * Revision 1.8  2002/02/05 21:46:28  gouriano
  1502. * added FindSeqid function, minor tuneup in CSeq_id_mapper
  1503. *
  1504. * Revision 1.7  2002/01/30 22:09:28  gouriano
  1505. * changed CSeqMap interface
  1506. *
  1507. * Revision 1.6  2002/01/29 17:45:00  grichenk
  1508. * Added seq-id handles locking
  1509. *
  1510. * Revision 1.5  2002/01/28 19:44:49  gouriano
  1511. * changed the interface of BioseqHandle: two functions moved from Scope
  1512. *
  1513. * Revision 1.4  2002/01/23 21:59:31  grichenk
  1514. * Redesigned seq-id handles and mapper
  1515. *
  1516. * Revision 1.3  2002/01/18 15:56:23  gouriano
  1517. * changed TSeqMaps definition
  1518. *
  1519. * Revision 1.2  2002/01/16 16:25:57  gouriano
  1520. * restructured objmgr
  1521. *
  1522. * Revision 1.1  2002/01/11 19:06:18  gouriano
  1523. * restructured objmgr
  1524. *
  1525. *
  1526. * ===========================================================================
  1527. */