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

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

生物技术

开发平台：

C/C++

tse_info.cpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: tse_info.cpp,v $
  4.  * PRODUCTION Revision 1000.4  2004/06/01 19:24:36  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.44
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. /*  $Id: tse_info.cpp,v 1000.4 2004/06/01 19:24:36 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. *   TSE info -- entry for data source seq-id to TSE map
  39. *
  40. */
  43. #include <ncbi_pch.hpp>
  44. #include <objmgr/impl/tse_info.hpp>
  45. #include <objmgr/impl/annot_type_index.hpp>
  46. #include <objmgr/impl/tse_chunk_info.hpp>
  47. #include <objmgr/impl/bioseq_info.hpp>
  48. #include <objmgr/impl/annot_object.hpp>
  49. #include <objmgr/impl/seq_annot_info.hpp>
  50. #include <objmgr/impl/snp_annot_info.hpp>
  51. #include <objmgr/impl/data_source.hpp>
  52. #include <objmgr/impl/handle_range.hpp>
  53. #include <objects/seqset/Seq_entry.hpp>
  54. #include <objmgr/objmgr_exception.hpp>
  56. BEGIN_NCBI_SCOPE
  57. BEGIN_SCOPE(objects)
  60. SIdAnnotObjs::SIdAnnotObjs(void)
  61. {
  62. }
  65. SIdAnnotObjs::~SIdAnnotObjs(void)
  66. {
  67. }
  70. SIdAnnotObjs::SIdAnnotObjs(const SIdAnnotObjs& _DEBUG_ARG(objs))
  71. {
  72.     _ASSERT(objs.m_AnnotSet.empty());
  73.     _ASSERT(objs.m_SNPSet.empty());
  74. }
  77. ////////////////////////////////////////////////////////////////////
  78. //
  79. //  CTSE_Info::
  80. //
  81. //    General information and indexes for top level seq-entries
  82. //
  85. CTSE_Info::CTSE_Info(CSeq_entry& entry,
  86.                      bool dead,
  87.                      const CObject* blob_id)
  88.     : m_DataSource(0),
  89.       m_Dead(dead),
  90.       m_Blob_ID(blob_id)
  91. {
  92.     entry.Parentize();
  93.     x_SetObject(entry);
  94.     x_TSEAttach(*this);
  95. }
  98. CTSE_Info::CTSE_Info(const CTSE_Info& info)
  99.     : TParent(info),
  100.       m_DataSource(0),
  101.       m_Dead(false),
  102.       m_Name(info.m_Name)
  103. {
  104.     x_TSEAttach(*this);
  105. }
  108. CTSE_Info::~CTSE_Info(void)
  109. {
  110. }
  113. void CTSE_Info::SetBlobId(const CObject* blob_id)
  114. {
  115.     m_Blob_ID.Reset(blob_id);
  116. }
  119. void CTSE_Info::SetName(const CAnnotName& name)
  120. {
  121.     m_Name = name;
  122. }
  125. bool CTSE_Info::HasAnnot(const CAnnotName& name) const
  126. {
  127.     _ASSERT(!x_DirtyAnnotIndex());
  128.     return m_NamedAnnotObjs.find(name) != m_NamedAnnotObjs.end();
  129. }
  132. bool CTSE_Info::HasNamedAnnot(const string& name) const
  133. {
  134.     return HasAnnot(CAnnotName(name));
  135. }
  138. bool CTSE_Info::HasUnnamedAnnot(void) const
  139. {
  140.     return HasAnnot(CAnnotName());
  141. }
  144. CConstRef<CSeq_entry> CTSE_Info::GetCompleteTSE(void) const
  145. {
  146.     return GetCompleteSeq_entry();
  147. }
  150. CConstRef<CSeq_entry> CTSE_Info::GetTSECore(void) const
  151. {
  152.     return GetSeq_entryCore();
  153. }
  156. void CTSE_Info::x_DSAttachContents(CDataSource& ds)
  157. {
  158.     _ASSERT(!m_DataSource);
  160.     m_DataSource = &ds;
  161.     TParent::x_DSAttachContents(ds);
  162.     ITERATE ( TBioseqs, it, m_Bioseqs ) {
  163.         ds.x_IndexSeqTSE(it->first, this);
  164.     }
  165.     ds.x_IndexAnnotTSEs(this);
  166. }
  169. void CTSE_Info::x_DSDetachContents(CDataSource& ds)
  170. {
  171.     _ASSERT(m_DataSource == &ds);
  173.     ITERATE ( TBioseqs, it, m_Bioseqs ) {
  174.         ds.x_UnindexSeqTSE(it->first, this);
  175.     }
  176.     ds.x_UnindexAnnotTSEs(this);
  177.     TParent::x_DSDetachContents(ds);
  178.     m_DataSource = 0;
  179. }
  182. void CTSE_Info::x_DSMapObject(CConstRef<TObject> obj, CDataSource& ds)
  183. {
  184.     ds.x_Map(obj, this);
  185.     TParent::x_DSMapObject(obj, ds);
  186. }
  189. void CTSE_Info::x_DSUnmapObject(CConstRef<TObject> obj, CDataSource& ds)
  190. {
  191.     ds.x_Unmap(obj, this);
  192.     TParent::x_DSUnmapObject(obj, ds);
  193. }
  196. inline
  197. void CTSE_Info::x_IndexSeqTSE(const CSeq_id_Handle& id)
  198. {
  199.     if ( HasDataSource() ) {
  200.         GetDataSource().x_IndexSeqTSE(id, this);
  201.     }
  202. }
  205. inline
  206. void CTSE_Info::x_UnindexSeqTSE(const CSeq_id_Handle& id)
  207. {
  208.     if ( HasDataSource() ) {
  209.         GetDataSource().x_UnindexSeqTSE(id, this);
  210.     }
  211. }
  214. void CTSE_Info::x_IndexAnnotTSE(const CAnnotName& name,
  215.                                 const CSeq_id_Handle& id)
  216. {
  217.     TSeqIdToNames::iterator iter = m_SeqIdToNames.lower_bound(id);
  218.     if ( iter == m_SeqIdToNames.end() || iter->first != id ) {
  219.         iter = m_SeqIdToNames.insert(iter,
  220.                                      TSeqIdToNames::value_type(id, TNames()));
  221.         if ( HasDataSource() ) {
  222.             GetDataSource().x_IndexAnnotTSE(id, this);
  223.         }
  224.     }
  225.     _VERIFY(iter->second.insert(name).second);
  226. }
  229. void CTSE_Info::x_UnindexAnnotTSE(const CAnnotName& name,
  230.                                   const CSeq_id_Handle& id)
  231. {
  232.     TSeqIdToNames::iterator iter = m_SeqIdToNames.lower_bound(id);
  233.     _ASSERT(iter != m_SeqIdToNames.end() && iter->first == id);
  234.     _VERIFY(iter->second.erase(name) == 1);
  235.     if ( iter->second.empty() ) {
  236.         m_SeqIdToNames.erase(iter);
  237.         if ( HasDataSource() ) {
  238.             GetDataSource().x_UnindexAnnotTSE(id, this);
  239.         }
  240.     }
  241. }
  244. CConstRef<CBioseq_Info> CTSE_Info::FindBioseq(const CSeq_id_Handle& id) const
  245. {
  246.     CConstRef<CBioseq_Info> ret;
  247.     //CFastMutexGuard guard(m_BioseqsLock);
  248.     TBioseqs::const_iterator it = m_Bioseqs.find(id);
  249.     if ( it != m_Bioseqs.end() ) {
  250.         ret = it->second;
  251.     }
  252.     return ret;
  253. }
  256. bool CTSE_Info::ContainsSeqid(const CSeq_id_Handle& id) const
  257. {
  258.     //CFastMutexGuard guard(m_BioseqsLock);
  259.     return m_Bioseqs.find(id) != m_Bioseqs.end();
  260. }
  263. void CTSE_Info::x_SetBioseqId(const CSeq_id_Handle& key,
  264.                               CBioseq_Info* info)
  265. {
  266.     //CFastMutexGuard guard(m_BioseqsLock);
  267.     pair<TBioseqs::iterator, bool> ins =
  268.         m_Bioseqs.insert(TBioseqs::value_type(key, info));
  269.     if ( ins.second ) {
  270.         // register this TSE in data source as containing the sequence
  271.         x_IndexSeqTSE(key);
  272.     }
  273.     else {
  274.         // No duplicate bioseqs in the same TSE
  275.         NCBI_THROW(CObjMgrException, eAddDataError,
  276.                    " duplicate Bioseq id '"+key.AsString()+"' present in"+
  277.                    "n  seq1: " + ins.first->second->IdString() +
  278.                    "n  seq2: " + info->IdString());
  279.     }
  280. }
  283. void CTSE_Info::x_ResetBioseqId(const CSeq_id_Handle& key,
  284.                                 CBioseq_Info* _DEBUG_ARG(info))
  285. {
  286.     //CFastMutexGuard guard(m_BioseqsLock);
  287.     TBioseqs::iterator iter = m_Bioseqs.lower_bound(key);
  288.     if ( iter != m_Bioseqs.end() && iter->first == key ) {
  289.         _ASSERT(iter->second == info);
  290.         m_Bioseqs.erase(iter);
  291.         x_UnindexSeqTSE(key);
  292.     }
  293. }
  296. void CTSE_Info::x_SetBioseq_setId(int key,
  297.                                   CBioseq_set_Info* info)
  298. {
  299.     //CFastMutexGuard guard(m_BioseqsLock);
  300.     pair<TBioseq_sets::iterator, bool> ins =
  301.         m_Bioseq_sets.insert(TBioseq_sets::value_type(key, info));
  302.     if ( ins.second ) {
  303.         // everything is fine
  304.     }
  305.     else {
  306.         // No duplicate bioseqs in the same TSE
  307.         NCBI_THROW(CObjMgrException, eAddDataError,
  308.                    " duplicate Bioseq_set id '"+NStr::IntToString(key));
  309.     }
  310. }
  313. void CTSE_Info::x_ResetBioseq_setId(int key,
  314.                                     CBioseq_set_Info* _DEBUG_ARG(info))
  315. {
  316.     //CFastMutexGuard guard(m_BioseqsLock);
  317.     TBioseq_sets::iterator iter = m_Bioseq_sets.lower_bound(key);
  318.     if ( iter != m_Bioseq_sets.end() && iter->first == key ) {
  319.         _ASSERT(iter->second == info);
  320.         m_Bioseq_sets.erase(iter);
  321.     }
  322. }
  325. void CTSE_Info::x_SetDirtyAnnotIndexNoParent(void)
  326. {
  327.     if ( HasDataSource() ) {
  328.         GetDataSource().x_SetDirtyAnnotIndex(*this);
  329.     }
  330. }
  333. void CTSE_Info::x_ResetDirtyAnnotIndexNoParent(void)
  334. {
  335.     if ( HasDataSource() ) {
  336.         GetDataSource().x_ResetDirtyAnnotIndex(*this);
  337.     }
  338. }
  341. void CTSE_Info::UpdateAnnotIndex(void) const
  342. {
  343.     const_cast<CTSE_Info*>(this)->UpdateAnnotIndex();
  344.     _ASSERT(!x_DirtyAnnotIndex());
  345. }
  348. void CTSE_Info::UpdateAnnotIndex(const CTSE_Info_Object& object) const
  349. {
  350.     const_cast<CTSE_Info*>(this)->
  351.         UpdateAnnotIndex(const_cast<CTSE_Info_Object&>(object));
  352.     _ASSERT(!object.x_DirtyAnnotIndex());
  353. }
  356. void CTSE_Info::UpdateAnnotIndex(void)
  357. {
  358.     UpdateAnnotIndex(*this);
  359. }
  362. void CTSE_Info::UpdateAnnotIndex(CTSE_Info_Object& object)
  363. {
  364.     _ASSERT(&object.GetTSE_Info() == this);
  365.     CTSE_Info::TAnnotWriteLockGuard guard(m_AnnotObjsLock);
  366.     NON_CONST_ITERATE ( TChunks, it, m_Chunks ) {
  367.         it->second->x_UpdateAnnotIndex(*this);
  368.     }
  369.     object.x_UpdateAnnotIndex(*this);
  370.     _ASSERT(!object.x_DirtyAnnotIndex());
  371. }
  374. CRef<CTSE_Chunk_Info> CTSE_Info::GetNotLoadedChunk(void)
  375. {
  376.     NON_CONST_ITERATE ( TChunks, it, m_Chunks ) {
  377.         if ( it->second->NotLoaded() ) {
  378.             return it->second;
  379.         }
  380.     }
  381.     return CRef<CTSE_Chunk_Info>();
  382. }
  385. void CTSE_Info::LoadAllChunks(void)
  386. {
  387.     NON_CONST_ITERATE ( TChunks, it, m_Chunks ) {
  388.         it->second->Load();
  389.     }
  390. }
  393. CTSE_Info::TAnnotObjs& CTSE_Info::x_SetAnnotObjs(const CAnnotName& name)
  394. {
  395.     TNamedAnnotObjs::iterator iter = m_NamedAnnotObjs.lower_bound(name);
  396.     if ( iter == m_NamedAnnotObjs.end() || iter->first != name ) {
  397.         typedef TNamedAnnotObjs::value_type value_type;
  398.         iter = m_NamedAnnotObjs.insert(iter, value_type(name, TAnnotObjs()));
  399.     }
  400.     return iter->second;
  401. }
  404. void CTSE_Info::x_RemoveAnnotObjs(const CAnnotName& name)
  405. {
  406.     m_NamedAnnotObjs.erase(name);
  407. }
  410. const CTSE_Info::TAnnotObjs*
  411. CTSE_Info::x_GetAnnotObjs(const CAnnotName& name) const
  412. {
  413.     TNamedAnnotObjs::const_iterator iter = m_NamedAnnotObjs.lower_bound(name);
  414.     if ( iter == m_NamedAnnotObjs.end() || iter->first != name ) {
  415.         return 0;
  416.     }
  417.     return &iter->second;
  418. }
  421. const CTSE_Info::TAnnotObjs*
  422. CTSE_Info::x_GetUnnamedAnnotObjs(void) const
  423. {
  424.     TNamedAnnotObjs::const_iterator iter = m_NamedAnnotObjs.begin();
  425.     if ( iter == m_NamedAnnotObjs.end() || iter->first.IsNamed() ) {
  426.         return 0;
  427.     }
  428.     return &iter->second;
  429. }
  432. SIdAnnotObjs& CTSE_Info::x_SetIdObjects(TAnnotObjs& objs,
  433.                                         const CAnnotName& name,
  434.                                         const CSeq_id_Handle& id)
  435. {
  436.     // repeat for more generic types of selector
  437.     TAnnotObjs::iterator it = objs.lower_bound(id);
  438.     if ( it == objs.end() || it->first != id ) {
  439.         // new id
  440.         it = objs.insert(it, TAnnotObjs::value_type(id, SIdAnnotObjs()));
  441.         x_IndexAnnotTSE(name, id);
  442.     }
  443.     _ASSERT(it != objs.end() && it->first == id);
  444.     return it->second;
  445. }
  448. SIdAnnotObjs& CTSE_Info::x_SetIdObjects(const CAnnotName& name,
  449.                                         const CSeq_id_Handle& id)
  450. {
  451.     return x_SetIdObjects(x_SetAnnotObjs(name), name, id);
  452. }
  455. const SIdAnnotObjs* CTSE_Info::x_GetIdObjects(const TAnnotObjs& objs,
  456.                                               const CSeq_id_Handle& idh) const
  457. {
  458.     TAnnotObjs::const_iterator it = objs.lower_bound(idh);
  459.     if ( it == objs.end() || it->first != idh ) {
  460.         return 0;
  461.     }
  462.     return &it->second;
  463. }
  466. const SIdAnnotObjs* CTSE_Info::x_GetIdObjects(const CAnnotName& name,
  467.                                               const CSeq_id_Handle& idh) const
  468. {
  469.     const TAnnotObjs* objs = x_GetAnnotObjs(name);
  470.     if ( !objs ) {
  471.         return 0;
  472.     }
  473.     return x_GetIdObjects(*objs, idh);
  474. }
  477. const SIdAnnotObjs*
  478. CTSE_Info::x_GetUnnamedIdObjects(const CSeq_id_Handle& idh) const
  479. {
  480.     const TAnnotObjs* objs = x_GetUnnamedAnnotObjs();
  481.     if ( !objs ) {
  482.         return 0;
  483.     }
  484.     return x_GetIdObjects(*objs, idh);
  485. }
  488. inline
  489. void CTSE_Info::x_MapAnnotObject(TRangeMap& rangeMap,
  490.                                  const SAnnotObject_Key& key,
  491.                                  const SAnnotObject_Index& annotRef)
  492. {
  493.     _ASSERT(annotRef.m_AnnotObject_Info == key.m_AnnotObject_Info);
  494.     rangeMap.insert(TRangeMap::value_type(key.m_Range, annotRef));
  495. }
  498. inline
  499. bool CTSE_Info::x_UnmapAnnotObject(TRangeMap& rangeMap,
  500.                                    const SAnnotObject_Key& key)
  501. {
  502.     for ( TRangeMap::iterator it = rangeMap.find(key.m_Range);
  503.           it && it->first == key.m_Range; ++it ) {
  504.         if ( it->second.m_AnnotObject_Info == key.m_AnnotObject_Info ) {
  505.             rangeMap.erase(it);
  506.             return rangeMap.empty();
  507.         }
  508.     }
  509.     _ASSERT(0);
  510.     return rangeMap.empty();
  511. }
  514. void CTSE_Info::x_MapAnnotObject(SIdAnnotObjs& objs,
  515.                                  const SAnnotObject_Key& key,
  516.                                  const SAnnotObject_Index& annotRef)
  517. {
  518.     size_t index = CAnnotType_Index::GetTypeIndex(key);
  519.     if ( index >= objs.m_AnnotSet.size() ) {
  520.         objs.m_AnnotSet.resize(index+1);
  521.     }
  522.     x_MapAnnotObject(objs.m_AnnotSet[index], key, annotRef);
  523. }
  526. bool CTSE_Info::x_UnmapAnnotObject(SIdAnnotObjs& objs,
  527.                                    const SAnnotObject_Key& key)
  528. {
  529.     size_t index = CAnnotType_Index::GetTypeIndex(key);
  530.     _ASSERT(index < objs.m_AnnotSet.size());
  531.     if ( x_UnmapAnnotObject(objs.m_AnnotSet[index], key) ) {
  532.         while ( objs.m_AnnotSet.back().empty() ) {
  533.             objs.m_AnnotSet.pop_back();
  534.             if ( objs.m_AnnotSet.empty() ) {
  535.                 return objs.m_SNPSet.empty();
  536.             }
  537.         }
  538.     }
  539.     return false;
  540. }
  543. void CTSE_Info::x_MapAnnotObject(TAnnotObjs& objs,
  544.                                  const CAnnotName& name,
  545.                                  const SAnnotObject_Key& key,
  546.                                  const SAnnotObject_Index& annotRef)
  547. {
  548.     x_MapAnnotObject(x_SetIdObjects(objs, name, key.m_Handle), key, annotRef);
  549. }
  552. bool CTSE_Info::x_UnmapAnnotObject(TAnnotObjs& objs,
  553.                                    const CAnnotName& name,
  554.                                    const SAnnotObject_Key& key)
  555. {
  556.     TAnnotObjs::iterator it = objs.find(key.m_Handle);
  557.     _ASSERT(it != objs.end() && it->first == key.m_Handle);
  558.     if ( x_UnmapAnnotObject(it->second, key) ) {
  559.         x_UnindexAnnotTSE(name, key.m_Handle);
  560.         objs.erase(it);
  561.         return objs.empty();
  562.     }
  563.     return false;
  564. }
  567. void CTSE_Info::x_MapSNP_Table(const CAnnotName& name,
  568.                                const CSeq_id_Handle& key,
  569.                                const CSeq_annot_SNP_Info& snp_info)
  570. {
  571.     SIdAnnotObjs& objs = x_SetIdObjects(name, key);
  572.     objs.m_SNPSet.push_back(ConstRef(&snp_info));
  573. }
  576. void CTSE_Info::x_UnmapSNP_Table(const CAnnotName& name,
  577.                                  const CSeq_id_Handle& key,
  578.                                  const CSeq_annot_SNP_Info& snp_info)
  579. {
  580.     SIdAnnotObjs& objs = x_SetIdObjects(name, key);
  581.     TSNPSet::iterator iter = find(objs.m_SNPSet.begin(),
  582.                                   objs.m_SNPSet.end(),
  583.                                   ConstRef(&snp_info));
  584.     if ( iter != objs.m_SNPSet.end() ) {
  585.         objs.m_SNPSet.erase(iter);
  586.     }
  587. }
  590. void CTSE_Info::x_MapAnnotObject(TAnnotObjs& index,
  591.                                  const SAnnotObject_Key& key,
  592.                                  const SAnnotObject_Index& annotRef,
  593.                                  SAnnotObjects_Info& infos)
  594. {
  595.     _ASSERT(&index == x_GetAnnotObjs(infos.GetName()));
  596.     infos.AddKey(key);
  597.     x_MapAnnotObject(index, infos.GetName(), key, annotRef);
  598. }
  601. void CTSE_Info::x_MapAnnotObject(const SAnnotObject_Key& key,
  602.                                  const SAnnotObject_Index& annotRef,
  603.                                  SAnnotObjects_Info& infos)
  604. {
  605.     x_MapAnnotObject(x_SetAnnotObjs(infos.GetName()), key, annotRef, infos);
  606. }
  609. void CTSE_Info::x_UnmapAnnotObjects(SAnnotObjects_Info& infos)
  610. {
  611.     TAnnotObjs& index = x_SetAnnotObjs(infos.GetName());
  613.     ITERATE( SAnnotObjects_Info::TObjectKeys, it, infos.GetKeys() ) {
  614.         x_UnmapAnnotObject(index, infos.GetName(), *it);
  615.     }
  617.     if ( index.empty() ) {
  618.         x_RemoveAnnotObjs(infos.GetName());
  619.     }
  621.     infos.Clear();
  622. }
  625. CBioseq_set_Info& CTSE_Info::GetBioseq_set(int id)
  626. {
  627.     TBioseq_sets::iterator iter = m_Bioseq_sets.find(id);
  628.     if ( iter == m_Bioseq_sets.end() ) {
  629.         NCBI_THROW(CObjMgrException, eRegisterError,
  630.                    "cannot find Bioseq-set by local id");
  631.     }
  632.     return *iter->second;
  633. }
  636. CBioseq_Info& CTSE_Info::GetBioseq(int gi)
  637. {
  638.     TBioseqs::iterator iter = m_Bioseqs.find(CSeq_id_Handle::GetGiHandle(gi));
  639.     if ( iter == m_Bioseqs.end() ) {
  640.         NCBI_THROW(CObjMgrException, eRegisterError,
  641.                    "cannot find Bioseq by gi");
  642.     }
  643.     return *iter->second;
  644. }
  647. void CTSE_Info::DebugDump(CDebugDumpContext /*ddc*/, unsigned int /*depth*/) const
  648. {
  649. #if 0
  650.     ddc.SetFrame("CTSE_Info");
  651.     CObject::DebugDump( ddc, depth);
  653.     ddc.Log("m_TSE", m_Seq_entry.GetPointer(),0);
  654.     ddc.Log("m_Dead", m_Dead);
  655.     if (depth == 0) {
  656.         DebugDumpValue(ddc, "m_Bioseqs.size()", m_Bioseqs.size());
  657.         DebugDumpValue(ddc, "m_AnnotObjs.size()",  m_AnnotObjs.size());
  658.     } else {
  659.         unsigned int depth2 = depth-1;
  660.         { //--- m_Bioseqs
  661.             DebugDumpValue(ddc, "m_Bioseqs.type",
  662.                 "map<CSeq_id_Handle, CRef<CBioseq_Info>>");
  663.             CDebugDumpContext ddc2(ddc,"m_Bioseqs");
  664.             TBioseqs::const_iterator it;
  665.             for (it=m_Bioseqs.begin(); it!=m_Bioseqs.end(); ++it) {
  666.                 string member_name = "m_Bioseqs[ " +
  667.                     (it->first).AsString() +" ]";
  668.                 ddc2.Log(member_name, (it->second).GetPointer(),depth2);
  669.             }
  670.         }
  671.         { //--- m_AnnotObjs_ByInt
  672.             DebugDumpValue(ddc, "m_AnnotObjs_ByInt.type",
  673.                 "map<CSeq_id_Handle, CRangeMultimap<CRef<CAnnotObject>,"
  674.                 "CRange<TSeqPos>::position_type>>");
  676.             CDebugDumpContext ddc2(ddc,"m_AnnotObjs_ByInt");
  677.             TAnnotObjs::const_iterator it;
  678.             for (it=m_AnnotObjs.begin(); it!=m_AnnotObjs.end(); ++it) {
  679.                 string member_name = "m_AnnotObjs[ " +
  680.                     (it->first).AsString() +" ]";
  681.                 if (depth2 == 0) {
  682. /*
  683.                     member_name += "size()";
  684.                     DebugDumpValue(ddc2, member_name, (it->second).size());
  685. */
  686.                 } else {
  687. /*
  688.                     // CRangeMultimap
  689.                     CDebugDumpContext ddc3(ddc2, member_name);
  690.                     ITERATE( TRangeMap, itrm, it->second ) {
  691.                         // CRange as string
  692.                         string rg;
  693.                         if (itrm->first.Empty()) {
  694.                             rg += "empty";
  695.                         } else if (itrm->first.IsWhole()) {
  696.                             rg += "whole";
  697.                         } else if (itrm->first.IsWholeTo()) {
  698.                             rg += "unknown";
  699.                         } else {
  700.                             rg +=
  701.                                 NStr::UIntToString(itrm->first.GetFrom()) +
  702.                                 "..." +
  703.                                 NStr::UIntToString(itrm->first.GetTo());
  704.                         }
  705.                         string rm_name = member_name + "[ " + rg + " ]";
  706.                         // CAnnotObject
  707.                         ddc3.Log(rm_name, itrm->second, depth2-1);
  708.                     }
  709. */
  710.                 }
  711.             }
  712.         }
  713.     }
  714.     // DebugDumpValue(ddc, "CMutableAtomicCounter::Get()", Get());
  715. #endif
  716. }
  719. END_SCOPE(objects)
  720. END_NCBI_SCOPE
  722. /*
  723. * ---------------------------------------------------------------------------
  724. * $Log: tse_info.cpp,v $
  725. * Revision 1000.4  2004/06/01 19:24:36  gouriano
  726. * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.44
  727. *
  728. * Revision 1.44  2004/05/21 21:42:13  gorelenk
  729. * Added PCH ncbi_pch.hpp
  730. *
  731. * Revision 1.43  2004/03/24 18:30:30  vasilche
  732. * Fixed edit API.
  733. * Every *_Info object has its own shallow copy of original object.
  734. *
  735. * Revision 1.42  2004/03/23 15:14:00  vasilche
  736. * Restored automatic call to Parentize() for Seq-entries in object manager.
  737. *
  738. * Revision 1.41  2004/03/16 15:47:28  vasilche
  739. * Added CBioseq_set_Handle and set of EditHandles
  740. *
  741. * Revision 1.40  2004/02/19 17:13:42  vasilche
  742. * Removed 'unused argument' warnings.
  743. *
  744. * Revision 1.39  2004/02/04 18:05:39  grichenk
  745. * Added annotation filtering by set of types/subtypes.
  746. * Renamed *Choice to *Type in SAnnotSelector.
  747. *
  748. * Revision 1.38  2004/02/03 19:02:19  vasilche
  749. * Fixed broken 'dirty annot index' state after RemoveEntry().
  750. *
  751. * Revision 1.37  2004/01/22 20:10:41  vasilche
  752. * 1. Splitted ID2 specs to two parts.
  753. * ID2 now specifies only protocol.
  754. * Specification of ID2 split data is moved to seqsplit ASN module.
  755. * For now they are still reside in one resulting library as before - libid2.
  756. * As the result split specific headers are now in objects/seqsplit.
  757. * 2. Moved ID2 and ID1 specific code out of object manager.
  758. * Protocol is processed by corresponding readers.
  759. * ID2 split parsing is processed by ncbi_xreader library - used by all readers.
  760. * 3. Updated OBJMGR_LIBS correspondingly.
  761. *
  762. * Revision 1.36  2003/11/26 17:56:00  vasilche
  763. * Implemented ID2 split in ID1 cache.
  764. * Fixed loading of splitted annotations.
  765. *
  766. * Revision 1.35  2003/11/19 22:18:04  grichenk
  767. * All exceptions are now CException-derived. Catch "exception" rather
  768. * than "runtime_error".
  769. *
  770. * Revision 1.34  2003/10/27 16:47:12  vasilche
  771. * Fixed error:
  772. * src/objmgr/data_source.cpp", line 913: Fatal: Assertion failed: (it != tse_map.end() && it->first == id)
  773. *
  774. * Revision 1.33  2003/10/09 20:20:58  vasilche
  775. * Added possibility to include and exclude Seq-annot names to annot iterator.
  776. * Fixed adaptive search. It looked only on selected set of annot names before.
  777. *
  778. * Revision 1.32  2003/10/07 13:43:23  vasilche
  779. * Added proper handling of named Seq-annots.
  780. * Added feature search from named Seq-annots.
  781. * Added configurable adaptive annotation search (default: gene, cds, mrna).
  782. * Fixed selection of blobs for loading from GenBank.
  783. * Added debug checks to CSeq_id_Mapper for easier finding lost CSeq_id_Handles.
  784. * Fixed leaked split chunks annotation stubs.
  785. * Moved some classes definitions in separate *.cpp files.
  786. *
  787. * Revision 1.31  2003/09/30 16:22:04  vasilche
  788. * Updated internal object manager classes to be able to load ID2 data.
  789. * SNP blobs are loaded as ID2 split blobs - readers convert them automatically.
  790. * Scope caches results of requests for data to data loaders.
  791. * Optimized CSeq_id_Handle for gis.
  792. * Optimized bioseq lookup in scope.
  793. * Reduced object allocations in annotation iterators.
  794. * CScope is allowed to be destroyed before other objects using this scope are
  795. * deleted (feature iterators, bioseq handles etc).
  796. * Optimized lookup for matching Seq-ids in CSeq_id_Mapper.
  797. * Added 'adaptive' option to objmgr_demo application.
  798. *
  799. * Revision 1.30  2003/09/16 14:21:48  grichenk
  800. * Added feature indexing and searching by subtype.
  801. *
  802. * Revision 1.29  2003/08/14 20:05:19  vasilche
  803. * Simple SNP features are stored as table internally.
  804. * They are recreated when needed using CFeat_CI.
  805. *
  806. * Revision 1.28  2003/07/17 20:07:56  vasilche
  807. * Reduced memory usage by feature indexes.
  808. * SNP data is loaded separately through PUBSEQ_OS.
  809. * String compression for SNP data.
  810. *
  811. * Revision 1.27  2003/06/24 14:25:18  vasilche
  812. * Removed obsolete CTSE_Guard class.
  813. * Used separate mutexes for bioseq and annot maps.
  814. *
  815. * Revision 1.26  2003/06/02 16:06:38  dicuccio
  816. * Rearranged src/objects/ subtree.  This includes the following shifts:
  817. *     - src/objects/asn2asn --> arc/app/asn2asn
  818. *     - src/objects/testmedline --> src/objects/ncbimime/test
  819. *     - src/objects/objmgr --> src/objmgr
  820. *     - src/objects/util --> src/objmgr/util
  821. *     - src/objects/alnmgr --> src/objtools/alnmgr
  822. *     - src/objects/flat --> src/objtools/flat
  823. *     - src/objects/validator --> src/objtools/validator
  824. *     - src/objects/cddalignview --> src/objtools/cddalignview
  825. * In addition, libseq now includes six of the objects/seq... libs, and libmmdb
  826. * replaces the three libmmdb? libs.
  827. *
  828. * Revision 1.25  2003/05/20 15:44:38  vasilche
  829. * Fixed interaction of CDataSource and CDataLoader in multithreaded app.
  830. * Fixed some warnings on WorkShop.
  831. * Added workaround for memory leak on WorkShop.
  832. *
  833. * Revision 1.24  2003/04/25 14:23:26  vasilche
  834. * Added explicit constructors, destructor and assignment operator to make it compilable on MSVC DLL.
  835. *
  836. * Revision 1.23  2003/04/24 16:12:38  vasilche
  837. * Object manager internal structures are splitted more straightforward.
  838. * Removed excessive header dependencies.
  839. *
  840. * Revision 1.22  2003/03/21 19:22:51  grichenk
  841. * Redesigned TSE locking, replaced CTSE_Lock with CRef<CTSE_Info>.
  842. *
  843. * Revision 1.21  2003/03/12 20:09:34  grichenk
  844. * Redistributed members between CBioseq_Handle, CBioseq_Info and CTSE_Info
  845. *
  846. * Revision 1.20  2003/03/11 15:51:06  kuznets
  847. * iterate -> ITERATE
  848. *
  849. * Revision 1.19  2003/03/10 16:55:17  vasilche
  850. * Cleaned SAnnotSelector structure.
  851. * Added shortcut when features are limited to one TSE.
  852. *
  853. * Revision 1.18  2003/03/05 20:56:43  vasilche
  854. * SAnnotSelector now holds all parameters of annotation iterators.
  855. *
  856. * Revision 1.17  2003/02/25 20:10:40  grichenk
  857. * Reverted to single total-range index for annotations
  858. *
  859. * Revision 1.16  2003/02/24 18:57:22  vasilche
  860. * Make feature gathering in one linear pass using CSeqMap iterator.
  861. * Do not use feture index by sub locations.
  862. * Sort features at the end of gathering in one vector.
  863. * Extracted some internal structures and classes in separate header.
  864. * Delay creation of mapped features.
  865. *
  866. * Revision 1.15  2003/02/05 17:59:17  dicuccio
  867. * Moved formerly private headers into include/objects/objmgr/impl
  868. *
  869. * Revision 1.14  2003/02/04 21:46:32  grichenk
  870. * Added map of annotations by intervals (the old one was
  871. * by total ranges)
  872. *
  873. * Revision 1.13  2003/01/29 17:45:03  vasilche
  874. * Annotaions index is split by annotation/feature type.
  875. *
  876. * Revision 1.12  2003/01/22 20:11:54  vasilche
  877. * Merged functionality of CSeqMapResolved_CI to CSeqMap_CI.
  878. * CSeqMap_CI now supports resolution and iteration over sequence range.
  879. * Added several caches to CScope.
  880. * Optimized CSeqVector().
  881. * Added serveral variants of CBioseqHandle::GetSeqVector().
  882. * Tried to optimize annotations iterator (not much success).
  883. * Rewritten CHandleRange and CHandleRangeMap classes to avoid sorting of list.
  884. *
  885. * Revision 1.11  2002/12/26 20:55:18  dicuccio
  886. * Moved seq_id_mapper.hpp, tse_info.hpp, and bioseq_info.hpp -> include/ tree
  887. *
  888. * Revision 1.10  2002/12/26 16:39:24  vasilche
  889. * Object manager class CSeqMap rewritten.
  890. *
  891. * Revision 1.9  2002/10/18 19:12:40  grichenk
  892. * Removed mutex pools, converted most static mutexes to non-static.
  893. * Protected CSeqMap::x_Resolve() with mutex. Modified code to prevent
  894. * dead-locks.
  895. *
  896. * Revision 1.8  2002/07/10 16:50:33  grichenk
  897. * Fixed bug with duplicate and uninitialized atomic counters
  898. *
  899. * Revision 1.7  2002/07/08 20:51:02  grichenk
  900. * Moved log to the end of file
  901. * Replaced static mutex (in CScope, CDataSource) with the mutex
  902. * pool. Redesigned CDataSource data locking.
  903. *
  904. * Revision 1.6  2002/07/01 15:32:30  grichenk
  905. * Fixed 'unused variable depth3' warning
  906. *
  907. * Revision 1.5  2002/05/31 17:53:00  grichenk
  908. * Optimized for better performance (CTSE_Info uses atomic counter,
  909. * delayed annotations indexing, no location convertions in
  910. * CAnnot_Types_CI if no references resolution is required etc.)
  911. *
  912. * Revision 1.4  2002/05/29 21:21:13  gouriano
  913. * added debug dump
  914. *
  915. * Revision 1.3  2002/03/14 18:39:13  gouriano
  916. * added mutex for MT protection
  917. *
  918. * Revision 1.2  2002/02/21 19:27:06  grichenk
  919. * Rearranged includes. Added scope history. Added searching for the
  920. * best seq-id match in data sources and scopes. Updated tests.
  921. *
  922. * Revision 1.1  2002/02/07 21:25:05  grichenk
  923. * Initial revision
  924. *
  925. *
  926. * ===========================================================================
  927. */