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

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

生物技术

开发平台：

C/C++

scope_impl.cpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: scope_impl.cpp,v $
  4.  * PRODUCTION Revision 1000.3  2004/06/01 19:23:39  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.15
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. /*  $Id: scope_impl.cpp,v 1000.3 2004/06/01 19:23:39 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. *           Andrei Gourianov
  37. *           Aleksey Grichenko
  38. *           Michael Kimelman
  39. *           Denis Vakatov
  40. *           Eugene Vasilchenko
  41. *
  42. * File Description:
  43. *           Scope is top-level object available to a client.
  44. *           Its purpose is to define a scope of visibility and reference
  45. *           resolution and provide access to the bio sequence data
  46. *
  47. */
  49. #include <ncbi_pch.hpp>
  50. #include <objmgr/scope.hpp>
  51. #include <objmgr/bioseq_handle.hpp>
  52. #include <objmgr/seq_entry_handle.hpp>
  53. #include <objmgr/seq_annot_handle.hpp>
  54. #include <objmgr/bioseq_set_handle.hpp>
  55. #include <objmgr/object_manager.hpp>
  56. #include <objmgr/seqmatch_info.hpp>
  57. #include <objmgr/objmgr_exception.hpp>
  59. #include <objmgr/impl/data_source.hpp>
  60. #include <objmgr/impl/tse_info.hpp>
  61. #include <objmgr/impl/scope_info.hpp>
  62. #include <objmgr/impl/bioseq_info.hpp>
  63. #include <objmgr/impl/bioseq_set_info.hpp>
  64. #include <objmgr/impl/seq_annot_info.hpp>
  65. #include <objmgr/impl/priority.hpp>
  66. #include <objmgr/impl/synonyms.hpp>
  68. #include <objects/seq/Bioseq.hpp>
  69. #include <objects/seq/Delta_seq.hpp>
  70. #include <objects/seq/Seq_literal.hpp>
  71. #include <objects/seqloc/Seq_loc.hpp>
  72. #include <objects/seqloc/Textseq_id.hpp>
  73. #include <objects/seqset/Seq_entry.hpp>
  75. #include <objmgr/impl/scope_impl.hpp>
  77. BEGIN_NCBI_SCOPE
  78. BEGIN_SCOPE(objects)
  81. /////////////////////////////////////////////////////////////////////////////
  82. //
  83. //  CScope_Impl
  84. //
  85. /////////////////////////////////////////////////////////////////////////////
  88. CScope_Impl::CScope_Impl(CObjectManager& objmgr)
  89.     : m_HeapScope(0), m_pObjMgr(0)
  90. {
  91.     TWriteLockGuard guard(m_Scope_Conf_RWLock);
  92.     x_AttachToOM(objmgr);
  93. }
  96. CScope_Impl::~CScope_Impl(void)
  97. {
  98.     TWriteLockGuard guard(m_Scope_Conf_RWLock);
  99.     x_DetachFromOM();
  100. }
  102. void CScope_Impl::x_AttachToOM(CObjectManager& objmgr)
  103. {
  104.     if ( m_pObjMgr != &objmgr ) {
  105.         x_DetachFromOM();
  106.         
  107.         m_pObjMgr = &objmgr;
  108.         m_pObjMgr->RegisterScope(*this);
  109.     }
  110. }
  113. void CScope_Impl::x_DetachFromOM(void)
  114. {
  115.     if ( m_pObjMgr ) {
  116.         // Drop and release all TSEs
  117.         x_ResetHistory();
  118.         m_pObjMgr->RevokeScope(*this);
  119.         for (CPriority_I it(m_setDataSrc); it; ++it) {
  120.             _ASSERT(it->m_DataSource);
  121.             m_pObjMgr->ReleaseDataSource(it->m_DataSource);
  122.             _ASSERT(!it->m_DataSource);
  123.         }
  124.         m_pObjMgr = 0;
  125.     }
  126. }
  129. void CScope_Impl::AddDefaults(TPriority priority)
  130. {
  131.     CObjectManager::TDataSourcesLock ds_set;
  132.     m_pObjMgr->AcquireDefaultDataSources(ds_set);
  134.     TWriteLockGuard guard(m_Scope_Conf_RWLock);
  135.     NON_CONST_ITERATE( CObjectManager::TDataSourcesLock, it, ds_set ) {
  136.         m_setDataSrc.Insert(const_cast<CDataSource&>(**it),
  137.             (priority == kPriority_NotSet) ?
  138.             (*it)->GetDefaultPriority() : priority);
  139.     }
  140.     x_ClearCacheOnNewData();
  141. }
  144. void CScope_Impl::AddDataLoader (const string& loader_name,
  145.                                  TPriority priority)
  146. {
  147.     CRef<CDataSource> ds = m_pObjMgr->AcquireDataLoader(loader_name);
  149.     TWriteLockGuard guard(m_Scope_Conf_RWLock);
  150.     m_setDataSrc.Insert(*ds, (priority == kPriority_NotSet) ?
  151.         ds->GetDefaultPriority() : priority);
  152.     x_ClearCacheOnNewData();
  153. }
  156. CSeq_entry_Handle CScope_Impl::AddTopLevelSeqEntry(CSeq_entry& top_entry,
  157.                                                    TPriority priority)
  158. {
  159.     CRef<CDataSource> ds = m_pObjMgr->AcquireTopLevelSeqEntry(top_entry);
  160.     TWriteLockGuard guard(m_Scope_Conf_RWLock);
  161.     m_setDataSrc.Insert(*ds, (priority == kPriority_NotSet) ?
  162.         ds->GetDefaultPriority() : priority);
  163.     x_ClearCacheOnNewData();
  164.     return CSeq_entry_Handle(*m_HeapScope, *x_GetSeq_entry_Info(top_entry));
  165. }
  168. void CScope_Impl::AddScope(CScope_Impl& scope,
  169.                            TPriority priority)
  170. {
  171.     TReadLockGuard src_guard(scope.m_Scope_Conf_RWLock);
  172.     CPriorityTree tree(scope.m_setDataSrc);
  173.     src_guard.Release();
  174.     
  175.     TWriteLockGuard guard(m_Scope_Conf_RWLock);
  176.     m_setDataSrc.Insert(tree, priority);
  177.     x_ClearCacheOnNewData();
  178. }
  181. CBioseq_Handle CScope_Impl::AddBioseq(CBioseq& bioseq,
  182.                                       TPriority priority)
  183. {
  184.     CRef<CSeq_entry> entry(new CSeq_entry);
  185.     entry->SetSeq(bioseq);
  186.     return AddTopLevelSeqEntry(*entry, priority).GetSeq();
  187. }
  190. CSeq_entry_EditHandle
  191. CScope_Impl::x_AttachEntry(const CBioseq_set_EditHandle& seqset,
  192.                            CRef<CSeq_entry_Info> entry,
  193.                            int index)
  194. {
  195.     _ASSERT(seqset && bool(entry));
  197.     TWriteLockGuard guard(m_Scope_Conf_RWLock);
  199.     //seqset.GetDataSource().AttachEntry(seqset, entry, index);
  200.     seqset.x_GetInfo().AddEntry(entry, index);
  202.     x_ClearCacheOnNewData();
  204.     return CSeq_entry_EditHandle(*m_HeapScope, *entry);
  205. }
  208. CBioseq_EditHandle
  209. CScope_Impl::x_SelectSeq(const CSeq_entry_EditHandle& entry,
  210.                          CRef<CBioseq_Info> bioseq)
  211. {
  212.     _ASSERT(entry && bool(bioseq));
  213.     _ASSERT(entry.Which() == CSeq_entry::e_not_set);
  215.     TWriteLockGuard guard(m_Scope_Conf_RWLock);
  217.     // duplicate bioseq info
  218.     entry.x_GetInfo().SelectSeq(*bioseq);
  220.     x_ClearCacheOnNewData();
  222.     return GetBioseqHandle(*bioseq).GetEditHandle();
  223. }
  226. CBioseq_set_EditHandle
  227. CScope_Impl::x_SelectSet(const CSeq_entry_EditHandle& entry,
  228.                          CRef<CBioseq_set_Info> seqset)
  229. {
  230.     _ASSERT(entry && bool(seqset));
  231.     _ASSERT(entry.Which() == CSeq_entry::e_not_set);
  233.     TWriteLockGuard guard(m_Scope_Conf_RWLock);
  235.     // duplicate bioseq info
  236.     entry.x_GetInfo().SelectSet(*seqset);
  238.     x_ClearCacheOnNewData();
  240.     return CBioseq_set_EditHandle(*m_HeapScope, *seqset);
  241. }
  244. CSeq_annot_EditHandle
  245. CScope_Impl::x_AttachAnnot(const CSeq_entry_EditHandle& entry,
  246.                            CRef<CSeq_annot_Info> annot)
  247. {
  248.     _ASSERT(entry && bool(annot));
  250.     TWriteLockGuard guard(m_Scope_Conf_RWLock);
  252.     entry.x_GetInfo().AddAnnot(annot);
  254.     x_ClearAnnotCache();
  256.     return CSeq_annot_EditHandle(*m_HeapScope, *annot);
  257. }
  260. CSeq_entry_EditHandle
  261. CScope_Impl::AttachEntry(const CBioseq_set_EditHandle& seqset,
  262.                          CSeq_entry& entry,
  263.                          int index)
  264. {
  265.     return x_AttachEntry(seqset, Ref(new CSeq_entry_Info(entry)), index);
  266. }
  269. CSeq_entry_EditHandle
  270. CScope_Impl::CopyEntry(const CBioseq_set_EditHandle& seqset,
  271.                        const CSeq_entry_Handle& entry,
  272.                        int index)
  273. {
  274.     return x_AttachEntry(seqset, Ref(new CSeq_entry_Info(entry.x_GetInfo())),
  275.                          index);
  276. }
  279. CSeq_entry_EditHandle
  280. CScope_Impl::TakeEntry(const CBioseq_set_EditHandle& seqset,
  281.                        const CSeq_entry_EditHandle& entry,
  282.                        int index)
  283. {
  284.     CRef<CSeq_entry_Info> info(&entry.x_GetInfo());
  285.     entry.Remove();
  286.     return x_AttachEntry(seqset, info, index);
  287. }
  290. CBioseq_EditHandle CScope_Impl::SelectSeq(const CSeq_entry_EditHandle& entry,
  291.                                           CBioseq& seq)
  292. {
  293.     return x_SelectSeq(entry, Ref(new CBioseq_Info(seq)));
  294. }
  297. CBioseq_EditHandle CScope_Impl::CopySeq(const CSeq_entry_EditHandle& entry,
  298.                                         const CBioseq_Handle& seq)
  299. {
  300.     return x_SelectSeq(entry, Ref(new CBioseq_Info(seq.x_GetInfo())));
  301. }
  304. CBioseq_EditHandle CScope_Impl::TakeSeq(const CSeq_entry_EditHandle& entry,
  305.                                         const CBioseq_EditHandle& seq)
  306. {
  307.     CRef<CBioseq_Info> info(&seq.x_GetInfo());
  308.     seq.Remove();
  309.     return x_SelectSeq(entry, info);
  310. }
  313. CBioseq_set_EditHandle
  314. CScope_Impl::SelectSet(const CSeq_entry_EditHandle& entry,
  315.                        CBioseq_set& seqset)
  316. {
  317.     return x_SelectSet(entry, Ref(new CBioseq_set_Info(seqset)));
  318. }
  321. CBioseq_set_EditHandle
  322. CScope_Impl::CopySet(const CSeq_entry_EditHandle& entry,
  323.                      const CBioseq_set_Handle& seqset)
  324. {
  325.     return x_SelectSet(entry, Ref(new CBioseq_set_Info(seqset.x_GetInfo())));
  326. }
  329. CBioseq_set_EditHandle
  330. CScope_Impl::TakeSet(const CSeq_entry_EditHandle& entry,
  331.                      const CBioseq_set_EditHandle& seqset)
  332. {
  333.     CRef<CBioseq_set_Info> info(&seqset.x_GetInfo());
  334.     seqset.Remove();
  335.     return x_SelectSet(entry, info);
  336. }
  339. CSeq_annot_EditHandle
  340. CScope_Impl::AttachAnnot(const CSeq_entry_EditHandle& entry,
  341.                          const CSeq_annot& annot)
  342. {
  343.     return x_AttachAnnot(entry, Ref(new CSeq_annot_Info(annot)));
  344. }
  347. CSeq_annot_EditHandle
  348. CScope_Impl::CopyAnnot(const CSeq_entry_EditHandle& entry,
  349.                        const CSeq_annot_Handle& annot)
  350. {
  351.     return x_AttachAnnot(entry, Ref(new CSeq_annot_Info(annot.x_GetInfo())));
  352. }
  355. CSeq_annot_EditHandle
  356. CScope_Impl::TakeAnnot(const CSeq_entry_EditHandle& entry,
  357.                        const CSeq_annot_EditHandle& annot)
  358. {
  359.     CRef<CSeq_annot_Info> info(&annot.x_GetInfo());
  360.     annot.Remove();
  361.     return x_AttachAnnot(entry, info);
  362. }
  365. void CScope_Impl::x_ClearCacheOnNewData(void)
  366. {
  367.     // Clear unresolved bioseq handles
  368.     // Clear annot cache
  369.     if (!m_Seq_idMap.empty()) {
  370.         LOG_POST(Info <<
  371.             "CScope_Impl: -- "
  372.             "adding new data to a scope with non-empty cache "
  373.             "may cause the cached data to become inconsistent");
  374.     }
  375.     NON_CONST_ITERATE ( TSeq_idMap, it, m_Seq_idMap ) {
  376.         if ( it->second.m_Bioseq_Info &&
  377.              !it->second.m_Bioseq_Info->HasBioseq() ) {
  378.             it->second.m_Bioseq_Info->m_SynCache.Reset();
  379.             it->second.m_Bioseq_Info.Reset();
  380.         }
  381.         it->second.m_AllAnnotRef_Info.Reset();
  382.     }
  383. }
  386. void CScope_Impl::x_ClearAnnotCache(void)
  387. {
  388.     // Clear annot cache
  389.     NON_CONST_ITERATE ( TSeq_idMap, it, m_Seq_idMap ) {
  390.         it->second.m_AllAnnotRef_Info.Reset();
  391.     }
  392. }
  395. void CScope_Impl::x_ClearCacheOnRemoveData(const CSeq_entry_Info& info)
  396. {
  397.     if ( info.IsSeq() ) {
  398.         x_ClearCacheOnRemoveData(info.GetSeq());
  399.     }
  400.     else {
  401.         x_ClearCacheOnRemoveData(info.GetSet());
  402.     }
  403. }
  406. void CScope_Impl::x_ClearCacheOnRemoveData(const CBioseq_Info& seq)
  407. {
  408.     // Clear bioseq from the scope cache
  409.     ITERATE ( CBioseq_Info::TId, si, seq.GetId() ) {
  410.         TSeq_idMap::iterator bs_id = m_Seq_idMap.find(*si);
  411.         if (bs_id != m_Seq_idMap.end()) {
  412.             if ( bs_id->second.m_Bioseq_Info ) {
  413.                 // detaching from scope
  414.                 bs_id->second.m_Bioseq_Info->m_ScopeInfo = 0;
  415.                 // breaking the link
  416.                 bs_id->second.m_Bioseq_Info->m_SynCache.Reset();
  417.             }
  418.             m_Seq_idMap.erase(bs_id);
  419.         }
  420.         m_BioseqMap.erase(&seq);
  421.     }
  422. }
  425. void CScope_Impl::x_ClearCacheOnRemoveData(const CBioseq_set_Info& seqset)
  426. {
  427.     ITERATE( CBioseq_set_Info::TSeq_set, ei, seqset.GetSeq_set() ) {
  428.         x_ClearCacheOnRemoveData(**ei);
  429.     }
  430. }
  433. CSeq_entry_Handle CScope_Impl::GetSeq_entryHandle(const CSeq_entry& entry)
  434. {
  435.     TReadLockGuard guard(m_Scope_Conf_RWLock);
  436.     return CSeq_entry_Handle(*m_HeapScope, *x_GetSeq_entry_Info(entry));
  437. }
  440. CSeq_annot_Handle CScope_Impl::GetSeq_annotHandle(const CSeq_annot& annot)
  441. {
  442.     TReadLockGuard guard(m_Scope_Conf_RWLock);
  443.     return CSeq_annot_Handle(*m_HeapScope, *x_GetSeq_annot_Info(annot));
  444. }
  447. CBioseq_Handle CScope_Impl::GetBioseqHandle(const CBioseq& seq)
  448. {
  449.     CBioseq_Handle ret;
  450.     {{
  451.         TReadLockGuard guard(m_Scope_Conf_RWLock);
  452.         CConstRef<CBioseq_Info> info = x_GetBioseq_Info(seq);
  453.         ITERATE ( CBioseq_Info::TId, id, info->GetId() ) {
  454.             ret = x_GetBioseqHandleFromTSE(*id, info->GetTSE_Info());
  455.             if ( ret ) {
  456.                 _ASSERT(ret.GetBioseqCore() == &seq);
  457.                 break;
  458.             }
  459.         }
  460.     }}
  461.     return ret;
  462. }
  465. CConstRef<CTSE_Info>
  466. CScope_Impl::x_GetTSE_Info(const CSeq_entry& tse)
  467. {
  468.     for (CPriority_I it(m_setDataSrc); it; ++it) {
  469.         CConstRef<CTSE_Info> info = it->GetDataSource().FindTSEInfo(tse);
  470.         if ( info ) {
  471.             {{
  472.                 CFastMutexGuard guard(it->GetMutex());
  473.                 it->AddTSE(*info);
  474.             }}
  475.             return info;
  476.         }
  477.     }
  478.     NCBI_THROW(CObjMgrException, eFindFailed,
  479.                "CScope_Impl::x_GetTSE_Info: entry is not attached");
  480. }
  483. CConstRef<CSeq_entry_Info>
  484. CScope_Impl::x_GetSeq_entry_Info(const CSeq_entry& entry)
  485. {
  486.     for (CPriority_I it(m_setDataSrc); it; ++it) {
  487.         CConstRef<CSeq_entry_Info> info =
  488.             it->GetDataSource().FindSeq_entry_Info(entry);
  489.         if ( info ) {
  490.             {{
  491.                 CFastMutexGuard guard(it->GetMutex());
  492.                 it->AddTSE(info->GetTSE_Info());
  493.             }}
  494.             return info;
  495.         }
  496.     }
  497.     NCBI_THROW(CObjMgrException, eFindFailed,
  498.                "CScope_Impl::x_GetSeq_entry_Info: entry is not attached");
  499. }
  502. CConstRef<CSeq_annot_Info>
  503. CScope_Impl::x_GetSeq_annot_Info(const CSeq_annot& annot)
  504. {
  505.     for (CPriority_I it(m_setDataSrc); it; ++it) {
  506.         CConstRef<CSeq_annot_Info> info =
  507.             it->GetDataSource().FindSeq_annot_Info(annot);
  508.         if ( info ) {
  509.             {{
  510.                 CFastMutexGuard guard(it->GetMutex());
  511.                 it->AddTSE(info->GetTSE_Info());
  512.             }}
  513.             return info;
  514.         }
  515.     }
  516.     NCBI_THROW(CObjMgrException, eFindFailed,
  517.                "CScope_Impl::x_GetSeq_annot_Info: annot is not attached");
  518. }
  521. CConstRef<CBioseq_Info>
  522. CScope_Impl::x_GetBioseq_Info(const CBioseq& bioseq)
  523. {
  524.     for (CPriority_I it(m_setDataSrc); it; ++it) {
  525.         CConstRef<CBioseq_Info> info =
  526.             it->GetDataSource().FindBioseq_Info(bioseq);
  527.         if ( info ) {
  528.             {{
  529.                 CFastMutexGuard guard(it->GetMutex());
  530.                 it->AddTSE(info->GetTSE_Info());
  531.             }}
  532.             return info;
  533.         }
  534.     }
  535.     NCBI_THROW(CObjMgrException, eFindFailed,
  536.                "CScope_Impl::x_GetBioseq_Info: bioseq is not attached");
  537. }
  540. void CScope_Impl::RemoveAnnot(const CSeq_annot_EditHandle& annot)
  541. {
  542.     TWriteLockGuard guard(m_Scope_Conf_RWLock);
  544.     CSeq_annot_Info& info = annot.x_GetInfo();
  545.     info.GetDataSource().RemoveAnnot(info);
  547.     x_ClearAnnotCache();
  548. }
  551. void CScope_Impl::SelectNone(const CSeq_entry_EditHandle& entry)
  552. {
  553.     _ASSERT(entry);
  555.     TWriteLockGuard guard(m_Scope_Conf_RWLock);
  557.     CSeq_entry_Info& info = entry.x_GetInfo();
  558.     x_ClearAnnotCache();
  559.     switch ( info.Which() ) {
  560.     case CSeq_entry::e_Set:
  561.         x_ClearCacheOnRemoveData(info.GetSet());
  562.         break;
  563.     case CSeq_entry::e_Seq:
  564.         x_ClearCacheOnRemoveData(info.GetSeq());
  565.         break;
  566.     default:
  567.         break;
  568.     }
  569.     // duplicate bioseq info
  570.     info.Reset();
  571. }
  574. void CScope_Impl::RemoveEntry(const CSeq_entry_EditHandle& entry)
  575. {
  576.     TWriteLockGuard guard(m_Scope_Conf_RWLock);
  578.     CSeq_entry_Info& info = entry.x_GetInfo();
  579.     x_ClearAnnotCache();
  580.     x_ClearCacheOnRemoveData(info);
  582.     if ( entry.GetParentEntry() ) {
  583.         info.GetDataSource().RemoveEntry(info);
  584.     }
  585.     else {
  586.         // top level entry
  587.         CDataSource_ScopeInfo* ds_info = 0;
  588.         for (CPriority_I it(m_setDataSrc); it; ++it) {
  589.             if ( &it->GetDataSource() == &info.GetDataSource() ) {
  590.                 ds_info = &*it;
  591.                 break;
  592.             }
  593.         }
  594.         if ( ds_info ) {
  595.             m_setDataSrc.Erase(*ds_info);
  596.         }
  597.         else {
  598.             // not found...
  599.             NCBI_THROW(CObjMgrException, eModifyDataError,
  600.                        "CScope::RemoveEntry(): cannot find data source");
  601.         }
  602.     }
  603. }
  606. void CScope_Impl::RemoveBioseq(const CBioseq_EditHandle& seq)
  607. {
  608.     TWriteLockGuard guard(m_Scope_Conf_RWLock);
  610.     CBioseq_Info& info = seq.x_GetInfo();
  611.     x_ClearAnnotCache();
  612.     x_ClearCacheOnRemoveData(info);
  614.     info.GetParentSeq_entry_Info().Reset();
  615. }
  618. void CScope_Impl::RemoveBioseq_set(const CBioseq_set_EditHandle& seqset)
  619. {
  620.     TWriteLockGuard guard(m_Scope_Conf_RWLock);
  622.     CBioseq_set_Info& info = seqset.x_GetInfo();
  623.     x_ClearAnnotCache();
  624.     x_ClearCacheOnRemoveData(info);
  626.     info.GetParentSeq_entry_Info().Reset();
  627. }
  630. CScope_Impl::TSeq_idMapValue&
  631. CScope_Impl::x_GetSeq_id_Info(const CSeq_id_Handle& id)
  632. {
  633.     {{
  634.         TReadLockGuard guard(m_Seq_idMapLock);
  635.         TSeq_idMap::iterator it = m_Seq_idMap.lower_bound(id);
  636.         if ( it != m_Seq_idMap.end() && it->first == id )
  637.             return *it;
  638.     }}
  639.     {{
  640.         TWriteLockGuard guard(m_Seq_idMapLock);
  641.         return *m_Seq_idMap.insert(
  642.             TSeq_idMapValue(id, SSeq_id_ScopeInfo(m_HeapScope))).first;
  643.     }}
  644. }
  647. inline
  648. CScope_Impl::TSeq_idMapValue&
  649. CScope_Impl::x_GetSeq_id_Info(const CBioseq_Handle& bh)
  650. {
  651.     TSeq_idMapValue* info = bh.x_GetScopeInfo().m_ScopeInfo;
  652.     if ( info->first != bh.GetSeq_id_Handle() ) {
  653.         info = &x_GetSeq_id_Info(bh.GetSeq_id_Handle());
  654.     }
  655.     return *info;
  656. }
  659. CScope_Impl::TSeq_idMapValue*
  660. CScope_Impl::x_FindSeq_id_Info(const CSeq_id_Handle& id)
  661. {
  662.     TReadLockGuard guard(m_Seq_idMapLock);
  663.     TSeq_idMap::iterator it = m_Seq_idMap.lower_bound(id);
  664.     if ( it != m_Seq_idMap.end() && it->first == id )
  665.         return &*it;
  666.     return 0;
  667. }
  670. CRef<CBioseq_ScopeInfo>
  671. CScope_Impl::x_InitBioseq_Info(TSeq_idMapValue& info, int get_flag)
  672. {
  673.     if (get_flag != CScope::eGetBioseq_Resolved) {
  674.         // Resolve only if the flag allows
  675.         CInitGuard init(info.second.m_Bioseq_Info, m_MutexPool);
  676.         if ( init ) {
  677.             x_ResolveSeq_id(info, get_flag);
  678.         }
  679.     }
  680.     //_ASSERT(info.second.m_Bioseq_Info);
  681.     return info.second.m_Bioseq_Info;
  682. }
  685. bool CScope_Impl::x_InitBioseq_Info(TSeq_idMapValue& info,
  686.                                     CBioseq_ScopeInfo& bioseq_info)
  687. {
  688.     {{
  689.         CInitGuard init(info.second.m_Bioseq_Info, m_MutexPool);
  690.         if ( init ) {
  691.             _ASSERT(!info.second.m_Bioseq_Info);
  692.             info.second.m_Bioseq_Info.Reset(&bioseq_info);
  693.             return true;
  694.         }
  695.     }}
  696.     return info.second.m_Bioseq_Info.GetPointerOrNull() == &bioseq_info;
  697. }
  700. CRef<CBioseq_ScopeInfo>
  701. CScope_Impl::x_GetBioseq_Info(const CSeq_id_Handle& id, int get_flag)
  702. {
  703.     return x_InitBioseq_Info(x_GetSeq_id_Info(id), get_flag);
  704. }
  707. CRef<CBioseq_ScopeInfo>
  708. CScope_Impl::x_FindBioseq_Info(const CSeq_id_Handle& id, int get_flag)
  709. {
  710.     CRef<CBioseq_ScopeInfo> ret;
  711.     TSeq_idMapValue* info = x_FindSeq_id_Info(id);
  712.     if ( info ) {
  713.         ret = x_InitBioseq_Info(*info, get_flag);
  714.     }
  715.     return ret;
  716. }
  719. CBioseq_Handle CScope_Impl::x_GetBioseqHandleFromTSE(const CSeq_id_Handle& id,
  720.                                                      const CTSE_Info& tse)
  721. {
  722.     CBioseq_Handle ret;
  723.     TReadLockGuard rguard(m_Scope_Conf_RWLock);
  724.     CRef<CBioseq_ScopeInfo> info = x_FindBioseq_Info(id, CScope::eGetBioseq_Loaded);
  725.     if ( bool(info)  &&  info->HasBioseq() ) {
  726.         if ( &info->GetTSE_Info() == &tse ) {
  727.             ret.m_Bioseq_Info = info.GetPointer();
  728.         }
  729.     }
  730.     else {
  731.         // new bioseq - try to find it in source TSE
  732.         {{
  733.             // first try main id
  734.             CSeqMatch_Info match(id, tse);
  735.             CConstRef<CBioseq_Info> bioseq = match.GetBioseq_Info();
  736.             if ( bioseq ) {
  737.                 _ASSERT(m_HeapScope);
  738.                 CBioseq_Handle bh =
  739.                     GetBioseqHandle(id, CScope::eGetBioseq_Loaded);
  740.                 if ( bh && &bh.x_GetInfo().GetTSE_Info() == &tse ) {
  741.                     ret = bh;
  742.                     return ret;
  743.                 }
  744.             }
  745.         }}
  746.         
  747.         CSeq_id_Mapper& mapper = CSeq_id_Mapper::GetSeq_id_Mapper();
  748.         if ( mapper.HaveMatchingHandles(id) ) {
  749.             // than try matching handles
  750.             TSeq_id_HandleSet hset;
  751.             mapper.GetMatchingHandles(id, hset);
  752.             ITERATE ( TSeq_id_HandleSet, hit, hset ) {
  753.                 if ( *hit == id ) // already checked
  754.                     continue;
  755.                 CSeqMatch_Info match(*hit, tse);
  756.                 CConstRef<CBioseq_Info> bioseq = match.GetBioseq_Info();
  757.                 if ( bioseq ) {
  758.                     _ASSERT(m_HeapScope);
  759.                     CBioseq_Handle bh = GetBioseqHandle(*hit,
  760.                         CScope::eGetBioseq_Loaded);
  761.                     if ( bh && &bh.x_GetInfo().GetTSE_Info() == &tse ) {
  762.                         ret = bh;
  763.                         break;
  764.                     }
  765.                 }
  766.             }
  767.         }
  768.     }
  769.     ret.m_Seq_id = id;
  770.     ret.m_Scope.Set(m_HeapScope);
  771.     return ret;
  772. }
  775. CBioseq_Handle CScope_Impl::GetBioseqHandle(const CSeq_id_Handle& id,
  776.                                             int get_flag)
  777. {
  778.     CBioseq_Handle ret;
  779.     if ( id )  {
  780.         {{
  781.             TReadLockGuard rguard(m_Scope_Conf_RWLock);
  782.             ret.m_Bioseq_Info = x_GetBioseq_Info(id, get_flag).GetPointer();
  783.         }}
  784.         if ( bool(ret.m_Bioseq_Info) && !ret.x_GetScopeInfo().HasBioseq() ) {
  785.             ret.m_Bioseq_Info.Reset();
  786.         }
  787.         ret.m_Seq_id = id;
  788.     }
  789.     ret.m_Scope.Set(m_HeapScope);
  790.     return ret;
  791. }
  794. CBioseq_EditHandle CScope_Impl::GetEditHandle(const CBioseq_Handle& h)
  795. {
  796.     if ( !h ) {
  797.         NCBI_THROW(CObjMgrException, eInvalidHandle,
  798.                    "CScope::GetEditHandle: null handle");
  799.     }
  800.     
  801.     if ( h.x_GetInfo().GetDataSource().GetDataLoader() ) {
  802.         NCBI_THROW(CObjMgrException, eNotImplemented,
  803.                    "CScope::GetEditHandle: detach is not implemented");
  804.     }
  805.     
  806.     return CBioseq_EditHandle(h);
  807. }
  810. CSeq_entry_EditHandle CScope_Impl::GetEditHandle(const CSeq_entry_Handle& h)
  811. {
  812.     if ( !h ) {
  813.         NCBI_THROW(CObjMgrException, eInvalidHandle,
  814.                    "CScope::GetEditHandle: null handle");
  815.     }
  816.     
  817.     if ( h.x_GetInfo().GetDataSource().GetDataLoader() ) {
  818.         NCBI_THROW(CObjMgrException, eNotImplemented,
  819.                    "CScope::GetEditHandle: detach is not implemented");
  820.     }
  821.     
  822.     return CSeq_entry_EditHandle(h);
  823. }
  826. CSeq_annot_EditHandle CScope_Impl::GetEditHandle(const CSeq_annot_Handle& h)
  827. {
  828.     if ( !h ) {
  829.         NCBI_THROW(CObjMgrException, eInvalidHandle,
  830.                    "CScope::GetEditHandle: null handle");
  831.     }
  832.     
  833.     if ( h.x_GetInfo().GetDataSource().GetDataLoader() ) {
  834.         NCBI_THROW(CObjMgrException, eNotImplemented,
  835.                    "CScope::GetEditHandle: detach is not implemented");
  836.     }
  837.     
  838.     return CSeq_annot_EditHandle(h);
  839. }
  842. CBioseq_set_EditHandle CScope_Impl::GetEditHandle(const CBioseq_set_Handle& h)
  843. {
  844.     if ( !h ) {
  845.         NCBI_THROW(CObjMgrException, eInvalidHandle,
  846.                    "CScope::GetEditHandle: null handle");
  847.     }
  848.     
  849.     if ( h.x_GetInfo().GetDataSource().GetDataLoader() ) {
  850.         NCBI_THROW(CObjMgrException, eNotImplemented,
  851.                    "CScope::GetEditHandle: detach is not implemented");
  852.     }
  853.     
  854.     return CBioseq_set_EditHandle(h);
  855. }
  858. CBioseq_Handle CScope_Impl::GetBioseqHandle(const CSeq_id& id, int get_flag)
  859. {
  860.     return GetBioseqHandle(CSeq_id_Handle::GetHandle(id), get_flag);
  861. }
  864. CBioseq_Handle
  865. CScope_Impl::GetBioseqHandleFromTSE(const CSeq_id_Handle& id,
  866.                                     const CBioseq_Handle& bh)
  867. {
  868.     CBioseq_Handle ret;
  869.     if ( bh ) {
  870.         ret = x_GetBioseqHandleFromTSE(id, bh.x_GetInfo().GetTSE_Info());
  871.     }
  872.     else {
  873.         ret.m_Seq_id = id;
  874.         ret.m_Scope.Set(m_HeapScope);
  875.     }
  876.     return ret;
  877. }
  880. CBioseq_Handle
  881. CScope_Impl::GetBioseqHandleFromTSE(const CSeq_id_Handle& id,
  882.                                     const CSeq_entry_Handle& seh)
  883. {
  884.     CBioseq_Handle ret;
  885.     if ( seh ) {
  886.         ret = x_GetBioseqHandleFromTSE(id, seh.x_GetInfo().GetTSE_Info());
  887.     }
  888.     else {
  889.         ret.m_Seq_id = id;
  890.         ret.m_Scope.Set(m_HeapScope);
  891.     }
  892.     return ret;
  893. }
  896. CBioseq_Handle
  897. CScope_Impl::GetBioseqHandleFromTSE(const CSeq_id& id,
  898.                                     const CBioseq_Handle& bh)
  899. {
  900.     return GetBioseqHandleFromTSE(CSeq_id_Handle::GetHandle(id), bh);
  901. }
  904. CBioseq_Handle
  905. CScope_Impl::GetBioseqHandleFromTSE(const CSeq_id& id,
  906.                                     const CSeq_entry_Handle& seh)
  907. {
  908.     return GetBioseqHandleFromTSE(CSeq_id_Handle::GetHandle(id), seh);
  909. }
  912. CBioseq_Handle CScope_Impl::GetBioseqHandle(const CSeq_loc& loc, int get_flag)
  913. {
  914.     CBioseq_Handle bh;
  915.     for (CSeq_loc_CI citer (loc); citer; ++citer) {
  916.         bh = GetBioseqHandle(citer.GetSeq_id(), get_flag);
  917.         if ( bh ) {
  918.             break;
  919.         }
  920.     }
  921.     return bh;
  922. }
  925. CBioseq_Handle CScope_Impl::GetBioseqHandle(const CBioseq_Info& seq)
  926. {
  927.     CBioseq_Handle ret;
  928.     {{
  929.         TReadLockGuard guard(m_Scope_Conf_RWLock);
  930.         ret = x_GetBioseqHandle(seq);
  931.     }}
  932.     return ret;
  933. }
  936. CBioseq_Handle CScope_Impl::x_GetBioseqHandle(const CBioseq_Info& seq)
  937. {
  938.     CBioseq_Handle ret;
  939.     ITERATE ( CBioseq_Info::TId, id, seq.GetId() ) {
  940.         CBioseq_Handle bh = x_GetBioseqHandleFromTSE(*id, seq.GetTSE_Info());
  941.         if ( bh && &bh.x_GetInfo() == &seq ) {
  942.             ret = bh;
  943.             break;
  944.         }
  945.     }
  946.     return ret;
  947. }
  950. CDataSource_ScopeInfo*
  951. CScope_Impl::x_FindBioseqInfo(const CPriorityTree& tree,
  952.                               const CSeq_id_Handle& idh,
  953.                               const TSeq_id_HandleSet* hset,
  954.                               CSeqMatch_Info& match_info,
  955.                               int get_flag)
  956. {
  957.     CDataSource_ScopeInfo* ret = 0;
  958.     // Process sub-tree
  959.     TPriority last_priority = 0;
  960.     ITERATE( CPriorityTree::TPriorityMap, mit, tree.GetTree() ) {
  961.         // Search in all nodes of the same priority regardless
  962.         // of previous results
  963.         TPriority new_priority = mit->first;
  964.         if ( new_priority != last_priority ) {
  965.             // Don't process lower priority nodes if something
  966.             // was found
  967.             if ( ret ) {
  968.                 break;
  969.             }
  970.             last_priority = new_priority;
  971.         }
  972.         CDataSource_ScopeInfo* new_ret =
  973.             x_FindBioseqInfo(mit->second, idh, hset, match_info, get_flag);
  974.         if ( new_ret ) {
  975.             _ASSERT(!ret); // should be checked by match_info already
  976.             ret = new_ret;
  977.         }
  978.     }
  979.     return ret;
  980. }
  983. CDataSource_ScopeInfo*
  984. CScope_Impl::x_FindBioseqInfo(CDataSource_ScopeInfo& ds_info,
  985.                               const CSeq_id_Handle& main_idh,
  986.                               const TSeq_id_HandleSet* hset,
  987.                               CSeqMatch_Info& match_info,
  988.                               int get_flag)
  989. {
  990.     // skip already matched CDataSource
  991.     CDataSource& ds = ds_info.GetDataSource();
  992.     if ( match_info && &match_info.GetDataSource() == &ds ) {
  993.         return 0;
  994.     }
  995.     CSeqMatch_Info info;
  996.     {{
  997.         CFastMutexGuard guard(ds_info.GetMutex());
  998.         info = ds.HistoryResolve(main_idh, ds_info.GetTSESet());
  999.         if ( !info && hset ) {
  1000.             ITERATE(TSeq_id_HandleSet, hit, *hset) {
  1001.                 if ( *hit == main_idh ) // already checked
  1002.                     continue;
  1003.                 if ( info  &&  info.GetIdHandle().IsBetter(*hit) ) // worse hit
  1004.                     continue;
  1005.                 CSeqMatch_Info new_info =
  1006.                     ds.HistoryResolve(*hit, ds_info.GetTSESet());
  1007.                 if ( !new_info )
  1008.                     continue;
  1009.                 _ASSERT(&new_info.GetDataSource() == &ds);
  1010.                 if ( !info ) {
  1011.                     info = new_info;
  1012.                     continue;
  1013.                 }
  1014.                 CSeqMatch_Info* best_info =
  1015.                     ds.ResolveConflict(main_idh, info, new_info);
  1016.                 if (best_info) {
  1017.                     info = *best_info;
  1018.                     continue;
  1019.                 }
  1020.                 x_ThrowConflict(eConflict_History, info, new_info);
  1021.             }
  1022.         }
  1023.     }}
  1024.     if ( !info  &&  get_flag == CScope::eGetBioseq_All ) {
  1025.         // Try to load the sequence from the data source
  1026.         info = ds_info.GetDataSource().BestResolve(main_idh);
  1027.     }
  1028.     if ( info ) {
  1029.         if ( match_info ) {
  1030.             x_ThrowConflict(eConflict_Live, match_info, info);
  1031.         }
  1032.         match_info = info;
  1033.         return &ds_info;
  1034.     }
  1035.     return 0;
  1036. }
  1039. CDataSource_ScopeInfo*
  1040. CScope_Impl::x_FindBioseqInfo(const CPriorityNode& node,
  1041.                               const CSeq_id_Handle& idh,
  1042.                               const TSeq_id_HandleSet* hset,
  1043.                               CSeqMatch_Info& match_info,
  1044.                               int get_flag)
  1045. {
  1046.     if ( node.IsTree() ) {
  1047.         // Process sub-tree
  1048.         return x_FindBioseqInfo(node.GetTree(), idh, hset, match_info, get_flag);
  1049.     }
  1050.     else if ( node.IsLeaf() ) {
  1051.         return x_FindBioseqInfo(const_cast<CDataSource_ScopeInfo&>(node.GetLeaf()),
  1052.                                 idh, hset, match_info, get_flag);
  1053.     }
  1054.     return 0;
  1055. }
  1058. void CScope_Impl::x_ResolveSeq_id(TSeq_idMapValue& id_info, int get_flag)
  1059. {
  1060.     // Use priority, do not scan all DSs - find the first one.
  1061.     // Protected by m_Scope_Conf_RWLock in upper-level functions
  1062.     CSeqMatch_Info match_info;
  1063.     auto_ptr<TSeq_id_HandleSet> hset;
  1064.     CSeq_id_Mapper& mapper = CSeq_id_Mapper::GetSeq_id_Mapper();
  1065.     if ( mapper.HaveMatchingHandles(id_info.first) ) {
  1066.         hset.reset(new TSeq_id_HandleSet);
  1067.         mapper.GetMatchingHandles(id_info.first, *hset);
  1068.         hset->erase(id_info.first);
  1069.         if ( hset->empty() )
  1070.             hset.reset();
  1071.     }
  1072.     CDataSource_ScopeInfo* ds_info =
  1073.         x_FindBioseqInfo(m_setDataSrc, id_info.first, hset.get(), match_info,
  1074.         get_flag);
  1075.     if ( !ds_info ) {
  1076.         // Map unresoved ids only if loading was requested
  1077.         if (get_flag == CScope::eGetBioseq_All) {
  1078.             _ASSERT(m_HeapScope);
  1079.             id_info.second.m_Bioseq_Info.Reset(new CBioseq_ScopeInfo(&id_info));
  1080.         }
  1081.     }
  1082.     else {
  1083.         {{
  1084.             CFastMutexGuard guard(ds_info->GetMutex());
  1085.             ds_info->AddTSE(match_info.GetTSE_Info());
  1086.         }}
  1088.         CConstRef<CBioseq_Info> info = match_info.GetBioseq_Info();
  1089.         {{
  1090.             TReadLockGuard guard(m_BioseqMapLock);
  1091.             TBioseqMap::const_iterator bm_it = m_BioseqMap.find(&*info);
  1092.             if ( bm_it != m_BioseqMap.end() ) {
  1093.                 id_info.second.m_Bioseq_Info = bm_it->second;
  1094.                 return;
  1095.             }
  1096.         }}
  1097.         {{
  1098.             TWriteLockGuard guard(m_BioseqMapLock);
  1099.             pair<TBioseqMap::iterator, bool> ins = m_BioseqMap
  1100.                 .insert(TBioseqMap::value_type(&*info,
  1101.                                                CRef<CBioseq_ScopeInfo>()));
  1102.             if ( ins.second ) { // new
  1103.                 _ASSERT(m_HeapScope);
  1104.                 ins.first->second.Reset(new CBioseq_ScopeInfo(&id_info, info));
  1105.             }
  1106.             id_info.second.m_Bioseq_Info = ins.first->second;
  1107.         }}
  1108.     }
  1109. }
  1112. void CScope_Impl::UpdateAnnotIndex(const CSeq_annot& annot)
  1113. {
  1114.     UpdateAnnotIndex(GetSeq_annotHandle(annot));
  1115. }
  1118. void CScope_Impl::UpdateAnnotIndex(const CSeq_annot_Handle& annot)
  1119. {
  1120.     TReadLockGuard rguard(m_Scope_Conf_RWLock);
  1121.     const CSeq_annot_Info& info = annot.x_GetInfo();
  1122.     info.GetDataSource().UpdateAnnotIndex(info);
  1123. }
  1126. CConstRef<CScope_Impl::TAnnotRefSet>
  1127. CScope_Impl::GetTSESetWithAnnots(const CSeq_id_Handle& idh)
  1128. {
  1129.     TReadLockGuard rguard(m_Scope_Conf_RWLock);
  1130.     TSeq_idMapValue& info = x_GetSeq_id_Info(idh);
  1131.     CRef<CBioseq_ScopeInfo> binfo = x_InitBioseq_Info(info,
  1132.         CScope::eGetBioseq_All);
  1133.     {{
  1134.         CInitGuard init(info.second.m_AllAnnotRef_Info, m_MutexPool);
  1135.         if ( init ) {
  1136.             CRef<TAnnotRefSet> ref_set(new TAnnotRefSet);
  1137.             TTSE_LockSet& tse_set = *ref_set;
  1139.             if ( binfo->HasBioseq() ) {
  1140.                 TTSE_Lock tse(&binfo->GetTSE_Info());
  1141.                 tse_set.insert(tse);
  1142.             }
  1144.             TTSE_LockSet with_ref;
  1145.             for (CPriority_I it(m_setDataSrc); it; ++it) {
  1146.                 it->GetDataSource().GetTSESetWithAnnots(idh, with_ref);
  1147.                 CFastMutexGuard guard(it->GetMutex());
  1148.                 const TTSE_LockSet& tse_cache = it->GetTSESet();
  1149.                 ITERATE(TTSE_LockSet, ref_it, with_ref) {
  1150.                     if ( (*ref_it)->IsDead() &&
  1151.                          tse_cache.find(*ref_it) == tse_cache.end() ) {
  1152.                         continue;
  1153.                     }
  1154.                     tse_set.insert(*ref_it);
  1155.                 }
  1156.                 with_ref.clear();
  1157.             }
  1158.             info.second.m_AllAnnotRef_Info = ref_set;
  1159.         }
  1160.     }}
  1161.     return info.second.m_AllAnnotRef_Info;
  1162. }
  1165. CConstRef<CScope_Impl::TAnnotRefSet>
  1166. CScope_Impl::GetTSESetWithAnnots(const CBioseq_Handle& bh)
  1167. {
  1168.     TReadLockGuard rguard(m_Scope_Conf_RWLock);
  1169.     TSeq_idMapValue& info = x_GetSeq_id_Info(bh);
  1170.     _ASSERT(info.second.m_Bioseq_Info);
  1171.     CRef<CBioseq_ScopeInfo> binfo = info.second.m_Bioseq_Info;
  1172.     {{
  1173.         CInitGuard init(info.second.m_AllAnnotRef_Info, m_MutexPool);
  1174.         if ( init ) {
  1175.             CRef<TAnnotRefSet> ref_set(new TAnnotRefSet);
  1176.             TTSE_LockSet& tse_set = *ref_set;
  1178.             if ( binfo->HasBioseq() ) {
  1179.                 TTSE_Lock tse(&binfo->GetTSE_Info());
  1180.                 
  1181.                 tse_set.insert(tse);
  1182.             }
  1184.             TTSE_LockSet with_ref;
  1185.             for (CPriority_I it(m_setDataSrc); it; ++it) {
  1186.                 it->GetDataSource().GetTSESetWithAnnots(info.first, with_ref);
  1187.                 CFastMutexGuard guard(it->GetMutex());
  1188.                 const TTSE_LockSet& tse_cache = it->GetTSESet();
  1189.                 ITERATE(TTSE_LockSet, ref_it, with_ref) {
  1190.                     if ( (*ref_it)->IsDead() &&
  1191.                          tse_cache.find(*ref_it) == tse_cache.end() ) {
  1192.                         continue;
  1193.                     }
  1195.                     tse_set.insert(*ref_it);
  1196.                 }
  1197.                 with_ref.clear();
  1198.             }
  1199.             info.second.m_AllAnnotRef_Info = ref_set;
  1200.         }
  1201.     }}
  1202.     return info.second.m_AllAnnotRef_Info;
  1203. }
  1206. void CScope_Impl::x_ThrowConflict(EConflict conflict_type,
  1207.                                   const CSeqMatch_Info& info1,
  1208.                                   const CSeqMatch_Info& info2) const
  1209. {
  1210.     const char* msg_type =
  1211.         conflict_type == eConflict_History? "history": "live TSE";
  1212.     CNcbiOstrstream s;
  1213.     s << "CScope_Impl -- multiple " << msg_type << " matches: " <<
  1214.         info1.GetDataSource().GetName() << "::" <<
  1215.         info1.GetIdHandle().AsString() <<
  1216.         " vs " <<
  1217.         info2.GetDataSource().GetName() << "::" <<
  1218.         info2.GetIdHandle().AsString();
  1219.     string msg = CNcbiOstrstreamToString(s);
  1220.     NCBI_THROW(CObjMgrException, eFindConflict, msg);
  1221. }
  1224. void CScope_Impl::ResetHistory(void)
  1225. {
  1226.     TWriteLockGuard guard(m_Scope_Conf_RWLock);
  1227.     x_ResetHistory();
  1228. }
  1231. void CScope_Impl::x_ResetHistory(void)
  1232. {
  1233.     // 1. detach all CBbioseq_Handle objects from scope, and
  1234.     // 2. break circular link:
  1235.     // CBioseq_ScopeInfo-> CSynonymsSet-> SSeq_id_ScopeInfo-> CBioseq_ScopeInfo
  1236.     NON_CONST_ITERATE ( TSeq_idMap, it, m_Seq_idMap ) {
  1237.         if ( it->second.m_Bioseq_Info ) {
  1238.             it->second.m_Bioseq_Info->m_ScopeInfo = 0; // detaching from scope
  1239.             it->second.m_Bioseq_Info->m_SynCache.Reset(); // breaking the link
  1240.         }
  1241.     }
  1242.     m_Seq_idMap.clear();
  1243.     m_BioseqMap.clear();
  1244.     for (CPriority_I it(m_setDataSrc); it; ++it) {
  1245.         it->m_TSE_LockSet.clear();
  1246.     }
  1247. }
  1250. void CScope_Impl::x_PopulateBioseq_HandleSet(const CSeq_entry_Handle& seh,
  1251.                                              TBioseq_HandleSet& handles,
  1252.                                              CSeq_inst::EMol filter,
  1253.                                              TBioseqLevelFlag level)
  1254. {
  1255.     if ( seh ) {
  1256.         TReadLockGuard rguard(m_Scope_Conf_RWLock);
  1257.         const CSeq_entry_Info& info = seh.x_GetInfo();
  1258.         CDataSource::TBioseq_InfoSet info_set;
  1259.         info.GetDataSource().GetBioseqs(info, info_set, filter, level);
  1260.         // Convert each bioseq info into bioseq handle
  1261.         ITERATE (CDataSource::TBioseq_InfoSet, iit, info_set) {
  1262.             CBioseq_Handle bh = x_GetBioseqHandle(**iit);
  1263.             if ( bh ) {
  1264.                 handles.push_back(bh);
  1265.             }
  1266.         }
  1267.     }
  1268. }
  1271. CConstRef<CSynonymsSet> CScope_Impl::GetSynonyms(const CSeq_id& id)
  1272. {
  1273.     return GetSynonyms(CSeq_id_Handle::GetHandle(id));
  1274. }
  1277. CConstRef<CSynonymsSet> CScope_Impl::GetSynonyms(const CSeq_id_Handle& id)
  1278. {
  1279.     _ASSERT(id);
  1280.     TReadLockGuard rguard(m_Scope_Conf_RWLock);
  1281.     return x_GetSynonyms(*x_GetBioseq_Info(id, CScope::eGetBioseq_All));
  1282. }
  1285. CConstRef<CSynonymsSet> CScope_Impl::GetSynonyms(const CBioseq_Handle& bh)
  1286. {
  1287.     if ( !bh ) {
  1288.         return CConstRef<CSynonymsSet>();
  1289.     }
  1290.     TReadLockGuard rguard(m_Scope_Conf_RWLock);
  1291.     return x_GetSynonyms(const_cast<CBioseq_ScopeInfo&>(bh.x_GetScopeInfo()));
  1292. }
  1295. void CScope_Impl::x_AddSynonym(const CSeq_id_Handle& idh,
  1296.                                CSynonymsSet& syn_set,
  1297.                                CBioseq_ScopeInfo& info)
  1298. {
  1299.     // Check current ID for conflicts, add to the set.
  1300.     TSeq_idMapValue& seq_id_info = x_GetSeq_id_Info(idh);
  1301.     if ( x_InitBioseq_Info(seq_id_info, info) ) {
  1302.         // the same bioseq - add synonym
  1303.         if ( !syn_set.ContainsSynonym(seq_id_info.first) ) {
  1304.             syn_set.AddSynonym(&seq_id_info);
  1305.         }
  1306.     }
  1307.     else {
  1308.         CRef<CBioseq_ScopeInfo> info2 = seq_id_info.second.m_Bioseq_Info;
  1309.         _ASSERT(info2 != &info);
  1310.         LOG_POST(Warning << "CScope::GetSynonyms: Bioseq["<<
  1311.                  info.GetBioseq_Info().IdString()<<"]: id "<<
  1312.                  idh.AsString()<<" is resolved to another Bioseq["<<
  1313.                  info2->GetBioseq_Info().IdString()<<"]");
  1314.     }
  1315. }
  1318. CConstRef<CSynonymsSet>
  1319. CScope_Impl::x_GetSynonyms(CBioseq_ScopeInfo& info)
  1320. {
  1321.     {{
  1322.         CInitGuard init(info.m_SynCache, m_MutexPool);
  1323.         if ( init ) {
  1324.             // It's OK to use CRef, at least one copy should be kept
  1325.             // alive by the id cache (for the ID requested).
  1326.             CRef<CSynonymsSet> syn_set(new CSynonymsSet);
  1327.             //syn_set->AddSynonym(id);
  1328.             if ( info.HasBioseq() ) {
  1329.                 ITERATE(CBioseq_Info::TId, it, info.GetBioseq_Info().GetId()) {
  1330.                     CSeq_id_Mapper& mapper=CSeq_id_Mapper::GetSeq_id_Mapper();
  1331.                     if ( mapper.HaveReverseMatch(*it) ) {
  1332.                         TSeq_id_HandleSet hset;
  1333.                         mapper.GetReverseMatchingHandles(*it, hset);
  1334.                         ITERATE(TSeq_id_HandleSet, mit, hset) {
  1335.                             x_AddSynonym(*mit, *syn_set, info);
  1336.                         }
  1337.                     }
  1338.                     else {
  1339.                         x_AddSynonym(*it, *syn_set, info);
  1340.                     }
  1341.                 }
  1342.             }
  1343.             info.m_SynCache = syn_set;
  1344.         }
  1345.     }}
  1346.     return info.m_SynCache;
  1347. }
  1350. void CScope_Impl::GetAllTSEs(TTSE_Handles& tses, int kind)
  1351. {
  1352.     TReadLockGuard rguard(m_Scope_Conf_RWLock);
  1353.     for (CPriority_I it(m_setDataSrc); it; ++it) {
  1354.         if (it->GetDataLoader() &&  kind == CScope::eManualTSEs) {
  1355.             // Skip data sources with loaders
  1356.             continue;
  1357.         }
  1358.         CFastMutexGuard guard(it->GetMutex());
  1359.         const TTSE_LockSet& tse_cache = it->GetTSESet();
  1360.         ITERATE(TTSE_LockSet, tse_it, tse_cache) {
  1361.             tses.push_back(CSeq_entry_Handle(*m_HeapScope, **tse_it));
  1362.         }
  1363.     }
  1364. }
  1367. CDataSource* CScope_Impl::GetFirstLoaderSource(void)
  1368. {
  1369.     TReadLockGuard rguard(m_Scope_Conf_RWLock);
  1370.     for (CPriority_I it(m_setDataSrc); it; ++it) {
  1371.         if ( it->GetDataLoader() ) {
  1372.             return &it->GetDataSource();
  1373.         }
  1374.     }
  1375.     return 0;
  1376. }
  1379. void CScope_Impl::DebugDump(CDebugDumpContext ddc, unsigned int depth) const
  1380. {
  1381.     ddc.SetFrame("CScope_Impl");
  1382.     CObject::DebugDump( ddc, depth);
  1384.     ddc.Log("m_pObjMgr", m_pObjMgr,0);
  1385.     if (depth == 0) {
  1386.     } else {
  1387.         DebugDumpValue(ddc,"m_setDataSrc.type", "set<CDataSource*>");
  1388.     }
  1389. }
  1392. END_SCOPE(objects)
  1393. END_NCBI_SCOPE
  1395. /*
  1396. * ---------------------------------------------------------------------------
  1397. * $Log: scope_impl.cpp,v $
  1398. * Revision 1000.3  2004/06/01 19:23:39  gouriano
  1399. * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.15
  1400. *
  1401. * Revision 1.15  2004/05/21 21:42:12  gorelenk
  1402. * Added PCH ncbi_pch.hpp
  1403. *
  1404. * Revision 1.14  2004/04/16 13:31:47  grichenk
  1405. * Added data pre-fetching functions.
  1406. *
  1407. * Revision 1.13  2004/04/14 19:12:12  vasilche
  1408. * Added storing TSE in history when returning CSeq_entry or CSeq_annot handles.
  1409. * Added test for main id before matching handles in GetBioseqHandleFromTSE().
  1410. *
  1411. * Revision 1.12  2004/04/13 15:59:35  grichenk
  1412. * Added CScope::GetBioseqHandle() with id resolving flag.
  1413. *
  1414. * Revision 1.11  2004/04/12 19:35:59  grichenk
  1415. * Added locks in GetAllTSEs()
  1416. *
  1417. * Revision 1.10  2004/04/12 18:40:24  grichenk
  1418. * Added GetAllTSEs()
  1419. *
  1420. * Revision 1.9  2004/03/31 19:54:08  vasilche
  1421. * Fixed removal of bioseqs and bioseq-sets.
  1422. *
  1423. * Revision 1.8  2004/03/31 19:23:13  vasilche
  1424. * Fixed scope in CBioseq_Handle::GetEditHandle().
  1425. *
  1426. * Revision 1.7  2004/03/31 17:08:07  vasilche
  1427. * Implemented ConvertSeqToSet and ConvertSetToSeq.
  1428. *
  1429. * Revision 1.6  2004/03/29 20:51:19  vasilche
  1430. * Fixed ambiguity on MSVC.
  1431. *
  1432. * Revision 1.5  2004/03/29 20:13:06  vasilche
  1433. * Implemented whole set of methods to modify Seq-entry object tree.
  1434. * Added CBioseq_Handle::GetExactComplexityLevel().
  1435. *
  1436. * Revision 1.4  2004/03/25 19:27:44  vasilche
  1437. * Implemented MoveTo and CopyTo methods of handles.
  1438. *
  1439. * Revision 1.3  2004/03/24 18:30:30  vasilche
  1440. * Fixed edit API.
  1441. * Every *_Info object has its own shallow copy of original object.
  1442. *
  1443. * Revision 1.2  2004/03/16 18:09:10  vasilche
  1444. * Use GetPointer() to avoid ambiguity
  1445. *
  1446. * Revision 1.1  2004/03/16 15:47:28  vasilche
  1447. * Added CBioseq_set_Handle and set of EditHandles
  1448. *
  1449. * Revision 1.101  2004/02/19 17:23:01  vasilche
  1450. * Changed order of deletion of heap scope and scope impl objects.
  1451. * Reduce number of calls to x_ResetHistory().
  1452. *
  1453. * Revision 1.100  2004/02/10 21:15:16  grichenk
  1454. * Added reverse ID matching.
  1455. *
  1456. * Revision 1.99  2004/02/09 14:42:46  vasilche
  1457. * Temporary fix in GetSynonyms() to get accession without version.
  1458. *
  1459. * Revision 1.98  2004/02/02 14:46:43  vasilche
  1460. * Several performance fixed - do not iterate whole tse set in CDataSource.
  1461. *
  1462. * Revision 1.97  2004/01/29 20:33:28  vasilche
  1463. * Do not resolve any Seq-ids in CScope::GetSynonyms() -
  1464. * assume all not resolved Seq-id as synonym.
  1465. * Seq-id conflict messages made clearer.
  1466. *
  1467. * Revision 1.96  2004/01/28 20:50:49  vasilche
  1468. * Fixed NULL pointer exception in GetSynonyms() when matching Seq-id w/o version.
  1469. *
  1470. * Revision 1.95  2004/01/07 20:42:01  grichenk
  1471. * Fixed matching of accession to accession.version
  1472. *
  1473. * Revision 1.94  2003/12/18 16:38:07  grichenk
  1474. * Added CScope::RemoveEntry()
  1475. *
  1476. * Revision 1.93  2003/12/12 16:59:51  grichenk
  1477. * Fixed conflicts resolving (ask data source).
  1478. *
  1479. * Revision 1.92  2003/12/03 20:55:12  grichenk
  1480. * Check value returned by x_GetBioseq_Info()
  1481. *
  1482. * Revision 1.91  2003/11/21 20:33:03  grichenk
  1483. * Added GetBioseqHandleFromTSE(CSeq_id, CSeq_entry)
  1484. *
  1485. * Revision 1.90  2003/11/19 22:18:03  grichenk
  1486. * All exceptions are now CException-derived. Catch "exception" rather
  1487. * than "runtime_error".
  1488. *
  1489. * Revision 1.89  2003/11/12 15:49:39  vasilche
  1490. * Added loading annotations on non gi Seq-id.
  1491. *
  1492. * Revision 1.88  2003/10/23 13:47:27  vasilche
  1493. * Check CSeq_id_Handle for null in CScope::GetBioseqHandle().
  1494. *
  1495. * Revision 1.87  2003/10/22 14:08:15  vasilche
  1496. * Detach all CBbioseq_Handle objects from scope in CScope::ResetHistory().
  1497. *
  1498. * Revision 1.86  2003/10/22 13:54:36  vasilche
  1499. * All CScope::GetBioseqHandle() methods return 'null' CBioseq_Handle object
  1500. * instead of throwing an exception.
  1501. *
  1502. * Revision 1.85  2003/10/20 18:23:54  vasilche
  1503. * Make CScope::GetSynonyms() to skip conflicting ids.
  1504. *
  1505. * Revision 1.84  2003/10/09 13:58:21  vasilche
  1506. * Fixed conflict when the same datasource appears twice with equal priorities.
  1507. *
  1508. * Revision 1.83  2003/10/07 13:43:23  vasilche
  1509. * Added proper handling of named Seq-annots.
  1510. * Added feature search from named Seq-annots.
  1511. * Added configurable adaptive annotation search (default: gene, cds, mrna).
  1512. * Fixed selection of blobs for loading from GenBank.
  1513. * Added debug checks to CSeq_id_Mapper for easier finding lost CSeq_id_Handles.
  1514. * Fixed leaked split chunks annotation stubs.
  1515. * Moved some classes definitions in separate *.cpp files.
  1516. *
  1517. * Revision 1.82  2003/09/30 16:22:03  vasilche
  1518. * Updated internal object manager classes to be able to load ID2 data.
  1519. * SNP blobs are loaded as ID2 split blobs - readers convert them automatically.
  1520. * Scope caches results of requests for data to data loaders.
  1521. * Optimized CSeq_id_Handle for gis.
  1522. * Optimized bioseq lookup in scope.
  1523. * Reduced object allocations in annotation iterators.
  1524. * CScope is allowed to be destroyed before other objects using this scope are
  1525. * deleted (feature iterators, bioseq handles etc).
  1526. * Optimized lookup for matching Seq-ids in CSeq_id_Mapper.
  1527. * Added 'adaptive' option to objmgr_demo application.
  1528. *
  1529. * Revision 1.81  2003/09/05 20:50:26  grichenk
  1530. * +AddBioseq(CBioseq&)
  1531. *
  1532. * Revision 1.80  2003/09/05 17:29:40  grichenk
  1533. * Structurized Object Manager exceptions
  1534. *
  1535. * Revision 1.79  2003/09/03 20:00:02  grichenk
  1536. * Added sequence filtering by level (mains/parts/all)
  1537. *
  1538. * Revision 1.78  2003/08/04 17:03:01  grichenk
  1539. * Added constructors to iterate all annotations from a
  1540. * seq-entry or seq-annot.
  1541. *
  1542. * Revision 1.77  2003/07/25 15:25:25  grichenk
  1543. * Added CSeq_annot_CI class
  1544. *
  1545. * Revision 1.76  2003/07/17 20:07:56  vasilche
  1546. * Reduced memory usage by feature indexes.
  1547. * SNP data is loaded separately through PUBSEQ_OS.
  1548. * String compression for SNP data.
  1549. *
  1550. * Revision 1.75  2003/07/14 21:13:59  grichenk
  1551. * Added seq-loc dump in GetBioseqHandle(CSeqLoc)
  1552. *
  1553. * Revision 1.74  2003/06/30 18:42:10  vasilche
  1554. * CPriority_I made to use less memory allocations/deallocations.
  1555. *
  1556. * Revision 1.73  2003/06/24 14:25:18  vasilche
  1557. * Removed obsolete CTSE_Guard class.
  1558. * Used separate mutexes for bioseq and annot maps.
  1559. *
  1560. * Revision 1.72  2003/06/19 18:23:46  vasilche
  1561. * Added several CXxx_ScopeInfo classes for CScope related information.
  1562. * CBioseq_Handle now uses reference to CBioseq_ScopeInfo.
  1563. * Some fine tuning of locking in CScope.
  1564. *
  1565. * Revision 1.69  2003/05/27 19:44:06  grichenk
  1566. * Added CSeqVector_CI class
  1567. *
  1568. * Revision 1.68  2003/05/20 15:44:37  vasilche
  1569. * Fixed interaction of CDataSource and CDataLoader in multithreaded app.
  1570. * Fixed some warnings on WorkShop.
  1571. * Added workaround for memory leak on WorkShop.
  1572. *
  1573. * Revision 1.67  2003/05/14 18:39:28  grichenk
  1574. * Simplified TSE caching and filtering in CScope, removed
  1575. * some obsolete members and functions.
  1576. *
  1577. * Revision 1.66  2003/05/13 18:33:01  vasilche
  1578. * Fixed CScope::GetTSESetWithAnnots() conflict resolution.
  1579. *
  1580. * Revision 1.65  2003/05/12 19:18:29  vasilche
  1581. * Fixed locking of object manager classes in multi-threaded application.
  1582. *
  1583. * Revision 1.64  2003/05/09 20:28:03  grichenk
  1584. * Changed warnings to info
  1585. *
  1586. * Revision 1.63  2003/05/06 18:54:09  grichenk
  1587. * Moved TSE filtering from CDataSource to CScope, changed
  1588. * some filtering rules (e.g. priority is now more important
  1589. * than scope history). Added more caches to CScope.
  1590. *
  1591. * Revision 1.62  2003/04/29 19:51:13  vasilche
  1592. * Fixed interaction of Data Loader garbage collector and TSE locking mechanism.
  1593. * Made some typedefs more consistent.
  1594. *
  1595. * Revision 1.61  2003/04/24 16:12:38  vasilche
  1596. * Object manager internal structures are splitted more straightforward.
  1597. * Removed excessive header dependencies.
  1598. *
  1599. * Revision 1.60  2003/04/15 14:21:52  vasilche
  1600. * Removed unnecessary assignment.
  1601. *
  1602. * Revision 1.59  2003/04/14 21:32:18  grichenk
  1603. * Avoid passing CScope as an argument to CDataSource methods
  1604. *
  1605. * Revision 1.58  2003/04/09 16:04:32  grichenk
  1606. * SDataSourceRec replaced with CPriorityNode
  1607. * Added CScope::AddScope(scope, priority) to allow scope nesting
  1608. *
  1609. * Revision 1.57  2003/04/03 14:18:09  vasilche
  1610. * Added public GetSynonyms() method.
  1611. *
  1612. * Revision 1.56  2003/03/26 21:00:19  grichenk
  1613. * Added seq-id -> tse with annotation cache to CScope
  1614. *
  1615. * Revision 1.55  2003/03/24 21:26:45  grichenk
  1616. * Added support for CTSE_CI
  1617. *
  1618. * Revision 1.54  2003/03/21 19:22:51  grichenk
  1619. * Redesigned TSE locking, replaced CTSE_Lock with CRef<CTSE_Info>.
  1620. *
  1621. * Revision 1.53  2003/03/19 21:55:50  grichenk
  1622. * Avoid re-mapping TSEs in x_AddToHistory() if already indexed
  1623. *
  1624. * Revision 1.52  2003/03/18 14:52:59  grichenk
  1625. * Removed obsolete methods, replaced seq-id with seq-id handle
  1626. * where possible. Added argument to limit annotations update to
  1627. * a single seq-entry.
  1628. *
  1629. * Revision 1.51  2003/03/12 20:09:34  grichenk
  1630. * Redistributed members between CBioseq_Handle, CBioseq_Info and CTSE_Info
  1631. *
  1632. * Revision 1.50  2003/03/11 15:51:06  kuznets
  1633. * iterate -> ITERATE
  1634. *
  1635. * Revision 1.49  2003/03/11 14:15:52  grichenk
  1636. * +Data-source priority
  1637. *
  1638. * Revision 1.48  2003/03/10 16:55:17  vasilche
  1639. * Cleaned SAnnotSelector structure.
  1640. * Added shortcut when features are limited to one TSE.
  1641. *
  1642. * Revision 1.47  2003/03/05 20:55:29  vasilche
  1643. * Added cache cleaning in CScope::ResetHistory().
  1644. *
  1645. * Revision 1.46  2003/03/03 20:32:47  vasilche
  1646. * Removed obsolete method GetSynonyms().
  1647. *
  1648. * Revision 1.45  2003/02/28 21:54:18  grichenk
  1649. * +CSynonymsSet::empty(), removed _ASSERT() in CScope::GetSynonyms()
  1650. *
  1651. * Revision 1.44  2003/02/28 20:02:37  grichenk
  1652. * Added synonyms cache and x_GetSynonyms()
  1653. *
  1654. * Revision 1.43  2003/02/27 14:35:31  vasilche
  1655. * Splitted PopulateTSESet() by logically independent parts.
  1656. *
  1657. * Revision 1.42  2003/02/24 18:57:22  vasilche
  1658. * Make feature gathering in one linear pass using CSeqMap iterator.
  1659. * Do not use feture index by sub locations.
  1660. * Sort features at the end of gathering in one vector.
  1661. * Extracted some internal structures and classes in separate header.
  1662. * Delay creation of mapped features.
  1663. *
  1664. * Revision 1.41  2003/02/05 17:59:17  dicuccio
  1665. * Moved formerly private headers into include/objects/objmgr/impl
  1666. *
  1667. * Revision 1.40  2003/01/29 22:03:46  grichenk
  1668. * Use single static CSeq_id_Mapper instead of per-OM model.
  1669. *
  1670. * Revision 1.39  2003/01/22 20:11:54  vasilche
  1671. * Merged functionality of CSeqMapResolved_CI to CSeqMap_CI.
  1672. * CSeqMap_CI now supports resolution and iteration over sequence range.
  1673. * Added several caches to CScope.
  1674. * Optimized CSeqVector().
  1675. * Added serveral variants of CBioseqHandle::GetSeqVector().
  1676. * Tried to optimize annotations iterator (not much success).
  1677. * Rewritten CHandleRange and CHandleRangeMap classes to avoid sorting of list.
  1678. *
  1679. * Revision 1.38  2002/12/26 20:55:18  dicuccio
  1680. * Moved seq_id_mapper.hpp, tse_info.hpp, and bioseq_info.hpp -> include/ tree
  1681. *
  1682. * Revision 1.37  2002/12/26 16:39:24  vasilche
  1683. * Object manager class CSeqMap rewritten.
  1684. *
  1685. * Revision 1.36  2002/11/08 22:15:51  grichenk
  1686. * Added methods for removing/replacing annotations
  1687. *
  1688. * Revision 1.35  2002/11/08 19:43:35  grichenk
  1689. * CConstRef<> constructor made explicit
  1690. *
  1691. * Revision 1.34  2002/11/04 21:29:12  grichenk
  1692. * Fixed usage of const CRef<> and CRef<> constructor
  1693. *
  1694. * Revision 1.33  2002/11/01 05:34:32  kans
  1695. * added GetBioseqHandle taking CBioseq parameter
  1696. *
  1697. * Revision 1.32  2002/10/31 22:25:42  kans
  1698. * added GetBioseqHandle taking CSeq_loc parameter
  1699. *
  1700. * Revision 1.31  2002/10/18 19:12:40  grichenk
  1701. * Removed mutex pools, converted most static mutexes to non-static.
  1702. * Protected CSeqMap::x_Resolve() with mutex. Modified code to prevent
  1703. * dead-locks.
  1704. *
  1705. * Revision 1.30  2002/10/16 20:44:29  ucko
  1706. * *** empty log message ***
  1707. *
  1708. * Revision 1.29  2002/10/02 17:58:23  grichenk
  1709. * Added sequence type filter to CBioseq_CI
  1710. *
  1711. * Revision 1.28  2002/09/30 20:01:19  grichenk
  1712. * Added methods to support CBioseq_CI
  1713. *
  1714. * Revision 1.27  2002/08/09 14:59:00  ucko
  1715. * Restrict template <> to MIPSpro for now, as it also leads to link
  1716. * errors with Compaq's compiler.  (Sigh.)
  1717. *
  1718. * Revision 1.26  2002/08/08 19:51:24  ucko
  1719. * Omit EMPTY_TEMPLATE for GCC and KCC, as it evidently leads to link errors(!)
  1720. *
  1721. * Revision 1.25  2002/08/08 14:28:00  ucko
  1722. * Add EMPTY_TEMPLATE to explicit instantiations.
  1723. *
  1724. * Revision 1.24  2002/08/07 18:21:57  ucko
  1725. * Explicitly instantiate CMutexPool_Base<CScope>::sm_Pool
  1726. *
  1727. * Revision 1.23  2002/07/08 20:51:02  grichenk
  1728. * Moved log to the end of file
  1729. * Replaced static mutex (in CScope, CDataSource) with the mutex
  1730. * pool. Redesigned CDataSource data locking.
  1731. *
  1732. * Revision 1.22  2002/06/04 17:18:33  kimelman
  1733. * memory cleanup :  new/delete/Cref rearrangements
  1734. *
  1735. * Revision 1.21  2002/05/28 18:00:43  gouriano
  1736. * DebugDump added
  1737. *
  1738. * Revision 1.20  2002/05/14 20:06:26  grichenk
  1739. * Improved CTSE_Info locking by CDataSource and CDataLoader
  1740. *
  1741. * Revision 1.19  2002/05/06 03:28:47  vakatov
  1742. * OM/OM1 renaming
  1743. *
  1744. * Revision 1.18  2002/04/22 20:04:39  grichenk
  1745. * Fixed TSE dropping, removed commented code
  1746. *
  1747. * Revision 1.17  2002/04/17 21:09:40  grichenk
  1748. * Fixed annotations loading
  1749. *
  1750. * Revision 1.16  2002/03/28 14:02:31  grichenk
  1751. * Added scope history checks to CDataSource::x_FindBestTSE()
  1752. *
  1753. * Revision 1.15  2002/03/27 18:45:44  gouriano
  1754. * three functions made public
  1755. *
  1756. * Revision 1.14  2002/03/20 21:20:39  grichenk
  1757. * +CScope::ResetHistory()
  1758. *
  1759. * Revision 1.13  2002/02/28 20:53:32  grichenk
  1760. * Implemented attaching segmented sequence data. Fixed minor bugs.
  1761. *
  1762. * Revision 1.12  2002/02/25 21:05:29  grichenk
  1763. * Removed seq-data references caching. Increased MT-safety. Fixed typos.
  1764. *
  1765. * Revision 1.11  2002/02/21 19:27:06  grichenk
  1766. * Rearranged includes. Added scope history. Added searching for the
  1767. * best seq-id match in data sources and scopes. Updated tests.
  1768. *
  1769. * Revision 1.10  2002/02/07 21:27:35  grichenk
  1770. * Redesigned CDataSource indexing: seq-id handle -> TSE -> seq/annot
  1771. *
  1772. * Revision 1.9  2002/02/06 21:46:11  gouriano
  1773. * *** empty log message ***
  1774. *
  1775. * Revision 1.8  2002/02/05 21:46:28  gouriano
  1776. * added FindSeqid function, minor tuneup in CSeq_id_mapper
  1777. *
  1778. * Revision 1.7  2002/01/29 17:45:34  grichenk
  1779. * Removed debug output
  1780. *
  1781. * Revision 1.6  2002/01/28 19:44:49  gouriano
  1782. * changed the interface of BioseqHandle: two functions moved from Scope
  1783. *
  1784. * Revision 1.5  2002/01/23 21:59:31  grichenk
  1785. * Redesigned seq-id handles and mapper
  1786. *
  1787. * Revision 1.4  2002/01/18 17:06:29  gouriano
  1788. * renamed CScope::GetSequence to CScope::GetSeqVector
  1789. *
  1790. * Revision 1.3  2002/01/18 15:54:14  gouriano
  1791. * changed DropTopLevelSeqEntry()
  1792. *
  1793. * Revision 1.2  2002/01/16 16:25:57  gouriano
  1794. * restructured objmgr
  1795. *
  1796. * Revision 1.1  2002/01/11 19:06:22  gouriano
  1797. * restructured objmgr
  1798. *
  1799. *
  1800. * ===========================================================================
  1801. */