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

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

生物技术

开发平台：

C/C++

gbloader.cpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: gbloader.cpp,v $
  4.  * PRODUCTION Revision 1000.1  2004/06/01 19:41:37  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.106
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. /*  $Id: gbloader.cpp,v 1000.1 2004/06/01 19:41:37 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: Michael Kimelman, Eugene Vasilchenko
  36. *
  37. *  File Description: GenBank Data loader
  38. *
  39. */
  41. #include <ncbi_pch.hpp>
  42. #include <objtools/data_loaders/genbank/gbloader.hpp>
  43. #include <objtools/data_loaders/genbank/reader.hpp>
  45. // TODO: remove the following two includes
  46. # include <objtools/data_loaders/genbank/readers/id1/reader_id1.hpp>
  47. #if defined(HAVE_PUBSEQ_OS)
  48. # include <objtools/data_loaders/genbank/readers/pubseqos/reader_pubseq.hpp>
  49. #endif
  51. #include <objmgr/objmgr_exception.hpp>
  52. #include <objmgr/annot_selector.hpp>
  54. #include <objmgr/impl/tse_info.hpp>
  55. #include <objmgr/impl/tse_chunk_info.hpp>
  56. #include <objmgr/impl/handle_range_map.hpp>
  57. #include <objmgr/impl/data_source.hpp>
  58. #include <objmgr/impl/annot_object.hpp>
  60. #include <objects/seqloc/Seq_loc.hpp>
  61. #include <objects/seqloc/Seq_id.hpp>
  62. #include <objects/seqset/Seq_entry.hpp>
  63. #include <objects/seq/Seq_annot.hpp>
  65. #include <dbapi/driver/exception.hpp>
  66. #include <dbapi/driver/interfaces.hpp>
  68. BEGIN_NCBI_SCOPE
  69. BEGIN_SCOPE(objects)
  71. static int x_Request2SeqrefMask(CGBDataLoader::EChoice choice);
  73. //=======================================================================
  74. //   GBLoader sub classes 
  75. //
  77. //=======================================================================
  78. // GBLoader Public interface 
  79. // 
  81. static const char* const DRV_ENV_VAR = "GENBANK_LOADER_METHOD";
  82. static const char* const DEFAULT_DRV_ORDER = "PUBSEQOS:ID1";
  83. static const char* const DRV_PUBSEQOS = "PUBSEQOS";
  84. static const char* const DRV_ID1 = "ID1";
  87. SSeqrefs::SSeqrefs(const CSeq_id_Handle& h)
  88.     : m_Handle(h)
  89. {
  90. }
  93. SSeqrefs::~SSeqrefs(void)
  94. {
  95. }
  98. CGBDataLoader::STSEinfo::STSEinfo()
  99.     : next(0), prev(0), locked(0), tseinfop(0), m_LoadState(eLoadStateNone)
  100. {
  101. }
  104. CGBDataLoader::STSEinfo::~STSEinfo()
  105. {
  106. }
  109. #define TSE(stse) CSeqref::printTSE((stse).key)
  110. #define DUMP(stse) CSeqref::printTSE((stse).key) << 
  111.     " stse=" << &(stse) << 
  112.     " tsei=" << (stse).tseinfop << 
  113.     " tse=" << ((stse).tseinfop? (stse).tseinfop->GetSeq_entryCore().GetPointer(): 0)
  116. // Create driver specified in "env"
  117. /*
  118. CReader* s_CreateReader(string env)
  119. {
  120. #if defined(HAVE_PUBSEQ_OS)
  121.     if (env == DRV_PUBSEQOS) {
  122.         try {
  123.             return new CPubseqReader;
  124.         }
  125.         catch ( exception& e ) {
  126.             GBLOG_POST("CPubseqReader is not available ::" << e.what());
  127.             return 0;
  128.         }
  129.         catch ( ... ) {
  130.             LOG_POST("CPubseqReader:: unable to init ");
  131.             return 0;
  132.         }
  133.     }
  134. #endif
  135.     if (env == DRV_ID1) {
  136.         return new CId1Reader;
  137.     }
  138.     return 0;
  139. }
  140. */
  142. CGBDataLoader::CGBDataLoader(const string& loader_name, CReader *driver,
  143.                              int gc_threshold)
  144.   : CDataLoader(loader_name),
  145.     m_Driver(driver),
  146.     m_ReaderPluginManager(0),
  147.     m_UseListHead(0),
  148.     m_UseListTail(0)
  149. {
  150.     GBLOG_POST( "CGBDataLoader");
  151.     if ( !m_Driver ) {
  152.         x_CreateDriver();
  153. // Commented out by kuznets Dec 03, 2003
  154. /*
  155.         const char* env = ::getenv(DRV_ENV_VAR);
  156.         if (!env) {
  157.             env = DEFAULT_DRV_ORDER; // default drivers' order
  158.         }
  159.         list<string> drivers;
  160.         NStr::Split(env, ":", drivers);
  161.         ITERATE ( list<string>, drv, drivers ) {
  162.             m_Driver = s_CreateReader(*drv);
  163.             if ( m_Driver )
  164.                 break;
  165.         }
  166.         if(!m_Driver) {
  167.             NCBI_THROW(CLoaderException, eNoConnection,
  168.                        "Could not create driver: " + string(env));
  169.         }
  170. */
  171.     }
  172.   
  173.     size_t i = m_Driver->GetParallelLevel();
  174.     m_Locks.m_Pool.SetSize(i<=0?10:i);
  175.     m_Locks.m_SlowTraverseMode=0;
  176.   
  177.     m_TseCount=0;
  178.     m_TseGC_Threshhold=gc_threshold;
  179.     m_InvokeGC=false;
  180.     //GBLOG_POST( "CGBDataLoader("<<loader_name<<"::" <<gc_threshold << ")" );
  181. }
  183. CGBDataLoader::CGBDataLoader(const string& loader_name,
  184.                              TReader_PluginManager *plugin_manager,
  185.                              EOwnership  take_plugin_manager,
  186.                              int gc_threshold)
  187.   : CDataLoader(loader_name),
  188.     m_Driver(0),
  189.     m_ReaderPluginManager(plugin_manager),
  190.     m_OwnReaderPluginManager(take_plugin_manager),
  191.     m_UseListHead(0),
  192.     m_UseListTail(0)
  193. {
  194.     GBLOG_POST( "CGBDataLoader");
  195.     if (!m_ReaderPluginManager) {
  196.         x_CreateReaderPluginManager();
  197.     }
  198.     x_CreateDriver();
  200.     size_t i = m_Driver->GetParallelLevel();
  201.     m_Locks.m_Pool.SetSize(i<=0?10:i);
  202.     m_Locks.m_SlowTraverseMode=0;
  203.   
  204.     m_TseCount=0;
  205.     m_TseGC_Threshhold=gc_threshold;
  206.     m_InvokeGC=false;
  207. }
  209. void CGBDataLoader::x_CreateReaderPluginManager(void)
  210. {
  211.     if (m_OwnReaderPluginManager == eTakeOwnership) {
  212.         delete m_ReaderPluginManager;
  213.         m_ReaderPluginManager = 0;
  214.     }
  216.     m_ReaderPluginManager = new TReader_PluginManager;
  217.     m_OwnReaderPluginManager = eTakeOwnership;
  219.     TReader_PluginManager::FNCBI_EntryPoint ep1 = NCBI_EntryPoint_Id1Reader;
  220.     m_ReaderPluginManager->RegisterWithEntryPoint(ep1);
  222. #if defined(HAVE_PUBSEQ_OS)
  223.     TReader_PluginManager::FNCBI_EntryPoint ep2 = NCBI_EntryPoint_Reader_Pubseqos;
  224.     m_ReaderPluginManager->RegisterWithEntryPoint(ep2);
  225. #endif
  227. }
  230. void CGBDataLoader::x_CreateDriver(void)
  231. {
  232.     if (!m_ReaderPluginManager) {
  233.         x_CreateReaderPluginManager();
  234.         _ASSERT(m_ReaderPluginManager);
  235.     }
  237.     const char* env = ::getenv(DRV_ENV_VAR);
  238.     if (!env) {
  239.         env = DEFAULT_DRV_ORDER; // default drivers' order
  240.     }
  241.     list<string> drivers;
  242.     NStr::Split(env, ":", drivers);
  243.     ITERATE ( list<string>, drv, drivers ) {
  244.         m_Driver = x_CreateReader(*drv);
  245.         if ( m_Driver )
  246.             break;
  247.     }
  249.     if (!m_Driver) {
  250.         NCBI_THROW(CLoaderException, eNoConnection,
  251.                    "Could not create driver: " + string(env));
  252.     }
  254. }
  257. CReader* CGBDataLoader::x_CreateReader(const string& env)
  258. {
  259.     _ASSERT(m_ReaderPluginManager);
  261. #if defined(HAVE_PUBSEQ_OS)
  262.     if (env == DRV_PUBSEQOS) {
  263.         try {
  264.             return m_ReaderPluginManager->CreateInstance("pubseq_reader");
  265.         }
  266.         catch ( exception& e ) {
  267.             GBLOG_POST("CPubseqReader is not available ::" << e.what());
  268.             return 0;
  269.         }
  270.         catch ( ... ) {
  271.             LOG_POST("CPubseqReader:: unable to init ");
  272.             return 0;
  273.         }
  274.     }
  275. #endif
  276.     if (env == DRV_ID1) {
  277.         try {
  278.             return m_ReaderPluginManager->CreateInstance("id1_reader");
  279.         }
  280.         catch ( exception& e ) {
  281.             LOG_POST("CId1Reader is not available ::" << e.what());
  282.             return 0;
  283.         }
  284.         catch ( ... ) {
  285.             LOG_POST("CId1Reader:: unable to init ");
  286.             return 0;
  287.         }
  288.     }
  289.     return 0;
  291. }
  294. CGBDataLoader::~CGBDataLoader(void)
  295. {
  296.     GBLOG_POST( "~CGBDataLoader");
  297.     CGBLGuard g(m_Locks,"~CGBDataLoader");
  298.     while ( m_UseListHead ) {
  299.         if ( m_UseListHead->tseinfop ) {
  300.             ERR_POST("CGBDataLoader::~CGBDataLoader: TSE not dropped: "<<
  301.                      TSE(*m_UseListHead));
  302.         }
  303.         x_DropTSEinfo(m_UseListHead);
  304.     }
  305.     m_Bs2Sr.clear();
  306.     if (m_OwnReaderPluginManager == eTakeOwnership) {
  307.         delete m_ReaderPluginManager;
  308.     }
  309. }
  312. static const char* const s_ChoiceName[] = {
  313.     "eBlob",
  314.     "eBioseq",
  315.     "eCore",
  316.     "eBioseqCore",
  317.     "eSequence",
  318.     "eFeatures",
  319.     "eGraph",
  320.     "eAlign",
  321.     "eAll",
  322.     "eAnnot",
  323.     "???"
  324. };
  326. static
  327. const size_t kChoiceNameCount = sizeof(s_ChoiceName)/sizeof(s_ChoiceName[0]);
  330. void CGBDataLoader::GetRecords(const CSeq_id_Handle& idh,
  331.                                const EChoice choice)
  332. {
  333.     if ( choice == eAnnot && !idh.IsGi() ) {
  334.         // no external annots available on non-gi ids
  335.         return;
  336.     }
  337.     CMutexGuard guard(m_Locks.m_Lookup);
  338.     x_GetRecords(s_ChoiceName[min(size_t(choice), kChoiceNameCount-1)],
  339.                  idh, x_Request2SeqrefMask(choice));
  340. }
  343. void CGBDataLoader::GetChunk(CTSE_Chunk_Info& chunk_info)
  344. {
  345.     CMutexGuard guard(m_Locks.m_Lookup);
  346.     x_GetChunk(GetTSEinfo(chunk_info.GetTSE_Info()), chunk_info);
  347. }
  350. CConstRef<CSeqref> CGBDataLoader::GetSatSatkey(const CSeq_id& id)
  351. {
  352.     return GetSatSatkey(CSeq_id_Handle::GetHandle(id));
  353. }
  356. CConstRef<CSeqref> CGBDataLoader::GetSatSatkey(const CSeq_id_Handle& idh)
  357. {
  358.     CConstRef<CSeqref> ret;
  359.     {{
  360.         CMutexGuard guard(m_Locks.m_Lookup);
  361.         CRef<SSeqrefs> srs = x_ResolveHandle(idh);
  362.         ITERATE ( SSeqrefs::TSeqrefs, it, srs->m_Sr ) {
  363.             const CSeqref& sr = **it;
  364.             if ( sr.GetFlags() & CSeqref::fHasCore ) {
  365.                 ret = &sr;
  366.                 break;
  367.             }
  368.         }
  369.     }}
  370.     return ret;
  371. }
  374. void CGBDataLoader::x_GetRecords(const char*
  375. #ifdef DEBUG_SYNC
  376.                                  type_name
  377. #endif
  378.                                  ,
  379.                                  const CSeq_id_Handle& idh,
  380.                                  TMask sr_mask)
  381. {
  382.     GC();
  384.     char s[100];
  385. #ifdef DEBUG_SYNC
  386.     memset(s,0,sizeof(s));
  387.     {
  388.         strstream ss(s,sizeof(s));
  389.         ss << "GetRecords(" << type_name <<")";
  390.     }
  391. #else
  392.     s[0] = 0;
  393. #endif
  395.     CGBLGuard g(m_Locks,s);
  396.     x_GetRecords(idh, sr_mask);
  397. }
  400. #if !defined(_DEBUG)
  401. inline
  402. #endif
  403. void
  404. CGBDataLoader::x_Check(const STSEinfo* _DEBUG_ARG(me))
  405. {
  406. #if defined(_DEBUG)
  407.     unsigned c = 0;
  408.     bool tse_found=false;
  409.     const STSEinfo* tse2 = m_UseListHead;
  410.     const STSEinfo* t1 = 0;
  411.     while ( tse2 ) {
  412.         c++;
  413.         if( tse2 == me )
  414.             tse_found = true;
  415.         t1 = tse2;
  416.         tse2 = tse2->next;
  417.     }
  418.     _ASSERT(t1 == m_UseListTail);
  419.     _ASSERT(m_Sr2TseInfo.size() == m_TseCount ||
  420.             m_Sr2TseInfo.size() == m_TseCount + 1);
  421.     _ASSERT(c  <= m_TseCount);
  422.     //_ASSERT(m_Tse2TseInfo.size() <= m_TseCount);
  423.     if(me) {
  424.         //GBLOG_POST("check tse " << me << " by " << CThread::GetSelf() );
  425.         _ASSERT(tse_found);
  426.     }
  427. #endif
  428. }
  431. CRef<CGBDataLoader::STSEinfo>
  432. CGBDataLoader::GetTSEinfo(const CTSE_Info& tse_info)
  433. {
  434.     return CRef<STSEinfo>(const_cast<STSEinfo*>
  435.                           (dynamic_cast<const STSEinfo*>
  436.                            (tse_info.GetBlobId().GetPointerOrNull())));
  437. }
  440. void CGBDataLoader::DropTSE(const CTSE_Info& tse_info)
  441. {
  442.     CGBLGuard g(m_Locks,"drop_tse");
  443.     //TTse2TSEinfo::iterator it = m_Tse2TseInfo.find(sep);
  444.     //if (it == m_Tse2TseInfo.end()) // oops - apprently already done;
  445.     //    return true;
  446.     CRef<STSEinfo> tse = GetTSEinfo(tse_info);
  447.     if ( !tse )
  448.         return;
  449.     g.Lock(&*tse);
  450.     _ASSERT(tse);
  451.     x_Check(tse);
  452.   
  453.     //m_Tse2TseInfo.erase(it);
  454.     x_DropTSEinfo(tse);
  455. }
  458. CConstRef<CTSE_Info>
  459. CGBDataLoader::ResolveConflict(const CSeq_id_Handle& handle,
  460.                                const TTSE_LockSet& tse_set)
  461. {
  462.     bool         conflict=false;
  464. #ifdef _DEBUG  
  465.     {{
  466.         CNcbiOstrstream s;
  467.         s << "CGBDataLoader::ResolveConflict("<<handle.AsString();
  468.         ITERATE ( TTSE_LockSet, it, tse_set ) {
  469.             CRef<STSEinfo> ti = GetTSEinfo(**it);
  470.             s << ", " << DUMP(*ti);
  471.         }
  472.         _TRACE(string(CNcbiOstrstreamToString(s)));
  473.     }}
  474. #endif
  476.     GBLOG_POST( "ResolveConflict" );
  477.     CGBLGuard g(m_Locks,"ResolveConflict");
  478.     CRef<SSeqrefs> sr;
  479.     CConstRef<CTSE_Info> best;
  480.     {
  481.         int cnt = 5;
  482.         while ( !(sr = x_ResolveHandle(handle))  && cnt>0 )
  483.             cnt --;
  484.         if ( !sr )
  485.             return best;
  486.     }
  488.     ITERATE(TTSE_LockSet, sit, tse_set) {
  489.         CConstRef<CTSE_Info> ti = *sit;
  490.         CRef<STSEinfo> tse = GetTSEinfo(*ti);
  491.         if ( !tse )
  492.             continue;
  493.       
  494.         x_Check(tse);
  496.         g.Lock(&*tse);
  498.         if(tse->mode.test(STSEinfo::eDead) && !ti->IsDead()) {
  499.             GetDataSource()->x_UpdateTSEStatus(const_cast<CTSE_Info&>(*ti),
  500.                                                true);
  501.         }
  502.         if(tse->m_SeqIds.find(handle)!=tse->m_SeqIds.end()) {
  503.             // listed for given TSE
  504.             if(!best) {
  505.                 best=ti; conflict=false;
  506.             }
  507.             else if(!ti->IsDead() && best->IsDead()) {
  508.                 best=ti; conflict=false;
  509.             }
  510.             else if(ti->IsDead() && best->IsDead()) {
  511.                 conflict=true;
  512.             }
  513.             else if(ti->IsDead() && !best->IsDead()) {
  514.             }
  515.             else {
  516.                 conflict=true;
  517.                 //_ASSERT(ti->IsDead() || best->IsDead());
  518.             }
  519.         }
  520.         g.Unlock(&*tse);
  521.     }
  523.     if ( !best || conflict ) {
  524.         // try harder
  525.         
  526.         best.Reset();conflict=false;
  527.         ITERATE (SSeqrefs::TSeqrefs, srp, sr->m_Sr) {
  528.             TSr2TSEinfo::iterator tsep =
  529.                 m_Sr2TseInfo.find((*srp)->GetKeyByTSE());
  530.             if (tsep == m_Sr2TseInfo.end()) continue;
  531.             ITERATE(TTSE_LockSet, sit, tse_set) {
  532.                 CConstRef<CTSE_Info> ti = *sit;
  533.                 //TTse2TSEinfo::iterator it =
  534.                 //    m_Tse2TseInfo.find(&ti->GetSeq_entry());
  535.                 //if(it==m_Tse2TseInfo.end()) continue;
  536.                 CRef<STSEinfo> tinfo = GetTSEinfo(*ti);
  537.                 if ( !tinfo )
  538.                     continue;
  540.                 if(tinfo==tsep->second) {
  541.                     if ( !best )
  542.                         best=ti;
  543.                     else if (ti != best)
  544.                         conflict=true;
  545.                 }
  546.             }
  547.         }
  548.         if(conflict)
  549.             best.Reset();
  550.     }
  551.     if ( !best ) {
  552.         _TRACE("CGBDataLoader::ResolveConflict("<<handle.AsString()<<
  553.                ") - conflict");
  554.     }
  555.     return best;
  556. }
  558. //=======================================================================
  559. // GBLoader private interface
  560. // 
  562. void CGBDataLoader::x_ExcludeFromDropList(STSEinfo* tse)
  563. {
  564.     _ASSERT(tse);
  565.     _TRACE("x_ExcludeFromDropList("<<DUMP(*tse)<<")");
  566.     STSEinfo* next = tse->next;
  567.     STSEinfo* prev = tse->prev;
  568.     if ( next || prev ) {
  569.         x_Check(tse);
  570.         if ( next ) {
  571.             _ASSERT(tse != m_UseListTail);
  572.             _ASSERT(tse == next->prev);
  573.             next->prev = prev;
  574.         }
  575.         else {
  576.             _ASSERT(tse == m_UseListTail);
  577.             m_UseListTail = prev;
  578.         }
  579.         if ( prev ) {
  580.             _ASSERT(tse != m_UseListHead);
  581.             _ASSERT(tse == prev->next);
  582.             prev->next = next;
  583.         }
  584.         else {
  585.             _ASSERT(tse == m_UseListHead);
  586.             m_UseListHead = next;
  587.         }
  588.         tse->prev = tse->next = 0;
  589.         --m_TseCount;
  590.     }
  591.     else if ( tse == m_UseListHead ) {
  592.         _ASSERT(tse == m_UseListTail);
  593.         x_Check(tse);
  594.         m_UseListHead = m_UseListTail = 0;
  595.         --m_TseCount;
  596.     }
  597.     else {
  598.         _ASSERT(tse != m_UseListTail);
  599.     }
  600.     x_Check();
  601. }
  604. void CGBDataLoader::x_AppendToDropList(STSEinfo* tse)
  605. {
  606.     _ASSERT(tse);
  607.     _TRACE("x_AppendToDropList("<<DUMP(*tse)<<")");
  608.     _ASSERT(m_Sr2TseInfo[tse->key] == tse);
  609.     x_Check();
  610.     _ASSERT(!tse->next && !tse->prev);
  611.     if ( m_UseListTail ) {
  612.         tse->prev = m_UseListTail;
  613.         m_UseListTail->next = tse;
  614.         m_UseListTail = tse;
  615.     }
  616.     else {
  617.         _ASSERT(!m_UseListHead);
  618.         m_UseListHead = m_UseListTail = tse;
  619.     }
  620.     ++m_TseCount;
  621.     x_Check(tse);
  622. }
  625. void CGBDataLoader::x_UpdateDropList(STSEinfo* tse)
  626. {
  627.     _ASSERT(tse);
  628.     // reset LRU links
  629.     if(tse == m_UseListTail) // already the last one
  630.         return;
  631.   
  632.     // Unlink from current place
  633.     x_ExcludeFromDropList(tse);
  634.     x_AppendToDropList(tse);
  635. }
  638. void CGBDataLoader::x_DropTSEinfo(STSEinfo* tse)
  639. {
  640.     if(!tse) return;
  641.     _TRACE( "DropBlob(" << DUMP(*tse) << ")" );
  642.   
  643.     ITERATE(STSEinfo::TSeqids,sih_it,tse->m_SeqIds) {
  644.         m_Bs2Sr.erase(*sih_it);
  645.     }
  647.     x_ExcludeFromDropList(tse);
  648.     m_Sr2TseInfo.erase(tse->key);
  649. }
  652. void CGBDataLoader::GC(void)
  653. {
  654.     //LOG_POST("X_GC "<<m_TseCount<<","<<m_TseGC_Threshhold<<","<< m_InvokeGC);
  655.     // dirty read - but that ok for garbage collector
  656.     if(!m_InvokeGC || m_TseCount==0) return ;
  657.     if(m_TseCount < m_TseGC_Threshhold) {
  658.         if(m_TseCount < 0.5*m_TseGC_Threshhold)
  659.             m_TseGC_Threshhold = (m_TseCount + 3*m_TseGC_Threshhold)/4;
  660.         return;
  661.     }
  662.     GBLOG_POST( "X_GC " << m_TseCount);
  663.     //GetDataSource()->x_CleanupUnusedEntries();
  665.     CGBLGuard g(m_Locks,"GC");
  666.     x_Check();
  668.     unsigned skip=0;
  669.     // scan 10% of least recently used pile before giving up:
  670.     unsigned skip_max = (int)(0.1*m_TseCount + 1);
  671.     STSEinfo* cur_tse = m_UseListHead;
  672.     while ( cur_tse && skip<skip_max) {
  673.         STSEinfo* tse_to_drop = cur_tse;
  674.         cur_tse = cur_tse->next;
  675.         ++skip;
  676.         // fast checks
  677.         if (tse_to_drop->locked) continue;
  678.         if (tse_to_drop->tseinfop && tse_to_drop->tseinfop->Locked()) continue;
  679.         //CRef<CTSE_Info> tse_info(tse_to_drop->tseinfop);
  681.         if ( !tse_to_drop->tseinfop ) {
  682.             // not loaded yet
  683.             if ( tse_to_drop->m_LoadState != STSEinfo::eLoadStateNone ) {
  684.                 // no data
  685.                 g.Lock(tse_to_drop);
  686.                 GBLOG_POST("X_GC:: drop nonexistent tse " << tse_to_drop);
  687.                 CRef<STSEinfo> tse_ref(tse_to_drop);
  688.                 x_DropTSEinfo(tse_to_drop);
  689.                 g.Unlock(tse_to_drop);
  690.                 --skip;
  691.             }
  692.             continue;
  693.         }
  694.         //if(m_Tse2TseInfo.find(sep) == m_Tse2TseInfo.end()) continue;
  695.         
  696.         GBLOG_POST("X_GC::DropTSE("<<TSE(*tse_to_drop)<<")");
  697.         //g.Unlock();
  698.         g.Lock(tse_to_drop);
  699.         if( GetDataSource()->DropTSE(*tse_to_drop->tseinfop) ) {
  700.             --skip;
  701.             m_InvokeGC=false;
  702.         }
  703.         g.Unlock(tse_to_drop);
  704.         //g.Lock();
  705. #if defined(NCBI_THREADS)
  706.         unsigned i=0;
  707.         for(cur_tse = m_UseListHead; cur_tse && i<skip; ++i) {
  708.             cur_tse = cur_tse->next;
  709.         }
  710. #endif
  711.     }
  712.     if(m_InvokeGC) { // nothing has been cleaned up
  713.         //assert(m_TseGC_Threshhold<=m_TseCount); // GC entrance condition
  714.         m_TseGC_Threshhold = m_TseCount+2; // do not even try until next load
  715.     } else if(m_TseCount < 0.5*m_TseGC_Threshhold) {
  716.         m_TseGC_Threshhold = (m_TseCount + m_TseGC_Threshhold)/2;
  717.     }
  718. }
  721. CSeqref::TFlags x_Request2SeqrefMask(CGBDataLoader::EChoice choice)
  722. {
  723.     switch(choice) {
  724.     case CGBDataLoader::eBlob:
  725.     case CGBDataLoader::eBioseq:
  726.     case CGBDataLoader::eAll:
  727.         // whole bioseq
  728.         return CSeqref::fHasAllLocal;
  729.     case CGBDataLoader::eCore:
  730.     case CGBDataLoader::eBioseqCore:
  731.         // everything except bioseqs & annotations
  732.         return CSeqref::fHasCore;
  733.     case CGBDataLoader::eSequence:
  734.         // seq data
  735.         return CSeqref::fHasSeqMap|CSeqref::fHasSeqData;
  736.     case CGBDataLoader::eFeatures:
  737.         // SeqFeatures
  738.         return CSeqref::fHasFeatures;
  739.     case CGBDataLoader::eGraph:
  740.         // SeqGraph
  741.         return CSeqref::fHasGraph;
  742.     case CGBDataLoader::eAlign:
  743.         // SeqGraph
  744.         return CSeqref::fHasAlign;
  745.     case CGBDataLoader::eAnnot:
  746.         // all annotations
  747.         return CSeqref::fHasAlign | CSeqref::fHasGraph |
  748.             CSeqref::fHasFeatures | CSeqref::fHasExternal;
  749.     default:
  750.         return 0;
  751.     }
  752. }
  755. void CGBDataLoader::x_GetRecords(const CSeq_id_Handle& sih,
  756.                                  TMask sr_mask)
  757. {
  758.     int attempt_count = 3, attempt;
  759.     for ( attempt = 0; attempt < attempt_count; ++attempt ) {
  760.         CRef<SSeqrefs> sr = x_ResolveHandle(sih);
  761.         _ASSERT(sr);
  762.         try {
  763.             ITERATE ( SSeqrefs::TSeqrefs, srp, sr->m_Sr ) {
  764.                 // skip TSE which doesn't contain requested type of info
  765.                 if( ((*srp)->GetFlags() & sr_mask) == 0 )
  766.                     continue;
  767.                 
  768.                 // find TSE info for each seqref
  769.                 TSr2TSEinfo::iterator tsep =
  770.                     m_Sr2TseInfo.find((*srp)->GetKeyByTSE());
  771.                 CRef<STSEinfo> tse;
  772.                 if (tsep != m_Sr2TseInfo.end()) {
  773.                     tse = tsep->second;
  774.                 }
  775.                 else {
  776.                     tse.Reset(new STSEinfo());
  777.                     tse->seqref = *srp;
  778.                     tse->key = tse->seqref->GetKeyByTSE();
  779.                     m_Sr2TseInfo[tse->key] = tse;
  780.                     x_AppendToDropList(tse.GetPointer());
  781.                     GBLOG_POST("x_GetRecords-newTSE(" << tse << ")");
  782.                 }
  783.                 
  784.                 CGBLGuard g(m_Locks,CGBLGuard::eMain,"x_GetRecords");
  785.                 g.Lock(&*tse);
  786.                 {{ // make sure we have reverse reference to handle
  787.                     STSEinfo::TSeqids &sid = tse->m_SeqIds;
  788.                     if (sid.find(sih) == sid.end())
  789.                         sid.insert(sih);
  790.                 }}
  791.                 
  792.                 if( !x_NeedMoreData(*tse) )
  793.                     continue;
  794.                 // need update
  795.                 _ASSERT(tse->m_LoadState != STSEinfo::eLoadStateDone);
  796.                 tse->locked++;
  797.                 g.Local();
  799.                 CReader::TConn conn = m_Locks.m_Pool.Select(&*tse);
  800.                 try {
  801.                     x_GetData(tse, conn);
  802.                 }
  803.                 catch ( CLoaderException& e ) {
  804.                     g.Lock();
  805.                     g.Lock(&*tse);
  806.                     tse->locked--;
  807.                     x_UpdateDropList(&*tse); // move up as just checked
  808.                     switch ( e.GetErrCode() ) {
  809.                     case CLoaderException::eNoConnection:
  810.                         throw;
  811.                     case CLoaderException::ePrivateData:
  812.                         // no need to reconnect
  813.                         // no need to wait more
  814.                         break;
  815.                     case CLoaderException::eNoData:
  816.                         // no need to reconnect
  817.                         throw;
  818.                     default:
  819.                         ERR_POST("GenBank connection failed: Reconnecting...");
  820.                         m_Driver->Reconnect(conn);
  821.                         throw;
  822.                     }
  823.                 }
  824.                 catch ( ... ) {
  825.                     g.Lock();
  826.                     g.Lock(&*tse);
  827.                     tse->locked--;
  828.                     x_UpdateDropList(&*tse); // move up as just checked
  829.                     ERR_POST("GenBank connection failed: Reconnecting...");
  830.                     m_Driver->Reconnect(conn);
  831.                     throw;
  832.                 }
  833.                 _ASSERT(!x_NeedMoreData(*tse));
  834.                 g.Lock();
  835.                 g.Lock(&*tse);
  836.                 tse->locked--;
  837.                 x_UpdateDropList(&*tse); // move up as just checked
  839.                 x_Check(&*tse);
  840.                 x_Check();
  841.             }
  842.             // everything is loaded, break the attempt loop
  843.             break;
  844.         }
  845.         catch ( CLoaderException& e ) {
  846.             ERR_POST(e.what());
  847.             if ( e.GetErrCode() == e.eNoConnection ) {
  848.                 throw;
  849.             }
  850.         }
  851.         catch ( exception& e ) {
  852.             ERR_POST(e.what());
  853.         }
  854.         catch ( ... ) {
  855.             ERR_POST(CThread::GetSelf()<<":: Data request failed....");
  856.             throw;
  857.         }
  858.         // something is not loaded
  859.         // in case of any error we'll force reloading seqrefs
  860.         
  861.         CGBLGuard g(m_Locks,CGBLGuard::eMain,"x_ResolveHandle");
  862.         g.Lock();
  863.         sr->m_Timer.Reset();
  864.         m_Driver->PurgeSeqrefs(sr->m_Sr, *sih.GetSeqId());
  865.     }
  866.     if ( attempt >= attempt_count ) {
  867.         ERR_POST("CGBLoader:GetData: data request failed: "
  868.                  "exceeded maximum attempts count");
  869.         NCBI_THROW(CLoaderException, eLoaderFailed,
  870.                    "Multiple attempts to retrieve data failed");
  871.     }
  872. }
  875. void CGBDataLoader::x_GetChunk(CRef<STSEinfo> tse,
  876.                                CTSE_Chunk_Info& chunk_info)
  877. {
  878.     CGBLGuard g(m_Locks,"x_GetChunk");
  879.     g.Lock(&*tse);
  880.     tse->locked++;
  881.     g.Local();
  883.     bool done = false;
  884.     int try_cnt = 3;
  885.     while( !done && try_cnt-- > 0 ) {
  886.         CReader::TConn conn = m_Locks.m_Pool.Select(&*tse);
  887.         try {
  888.             x_GetChunk(tse, conn, chunk_info);
  889.             done = true;
  890.             break;
  891.         }
  892.         catch ( CLoaderException& e ) {
  893.             if ( e.GetErrCode() == CLoaderException::eNoConnection ) {
  894.                 g.Lock();
  895.                 g.Lock(&*tse);
  896.                 tse->locked--;
  897.                 x_UpdateDropList(&*tse); // move up as just checked
  898.                 throw;
  899.             }
  900.             LOG_POST(e.what());
  901.             LOG_POST("GenBank connection failed: Reconnecting....");
  902.             m_Driver->Reconnect(conn);
  903.         }
  904.         catch ( const exception &e ) {
  905.             LOG_POST(e.what());
  906.             LOG_POST("GenBank connection failed: Reconnecting....");
  907.             m_Driver->Reconnect(conn);
  908.         }
  909.         catch ( ... ) {
  910.             LOG_POST("GenBank connection failed: Reconnecting....");
  911.             m_Driver->Reconnect(conn);
  912.             g.Lock();
  913.             g.Lock(&*tse);
  914.             tse->locked--;
  915.             x_UpdateDropList(&*tse); // move up as just checked
  916.             throw;
  917.         }
  918.     }
  919.     if ( !done ) {
  920.         ERR_POST("CGBLoader:GetChunk: data request failed: "
  921.                  "exceeded maximum attempts count");
  922.         g.Lock();
  923.         g.Lock(&*tse);
  924.         tse->locked--;
  925.         x_UpdateDropList(&*tse); // move up as just checked
  926.         NCBI_THROW(CLoaderException, eLoaderFailed,
  927.                    "Multiple attempts to retrieve data failed");
  928.     }
  929.     g.Lock();
  930.     g.Lock(&*tse);
  931.     x_UpdateDropList(&*tse);
  932.     if( done ) {
  933.         x_Check();
  934.         _ASSERT(tse->tseinfop);
  935.     }
  936.     tse->locked--;
  937.     x_Check(&*tse);
  938. }
  941. class CTimerGuard
  942. {
  943.     CTimer *t;
  944.     bool    calibrating;
  945. public:
  946.     CTimerGuard(CTimer& x)
  947.         : t(&x), calibrating(x.NeedCalibration())
  948.         {
  949.             if ( calibrating ) {
  950.                 t->Start();
  951.             }
  952.         }
  953.     ~CTimerGuard(void)
  954.         {
  955.             if ( calibrating ) {
  956.                 t->Stop();
  957.             }
  958.         }
  959. };
  962. CRef<SSeqrefs> CGBDataLoader::x_ResolveHandle(const CSeq_id_Handle& h)
  963. {
  964.     CGBLGuard g(m_Locks,CGBLGuard::eMain,"x_ResolveHandle");
  966.     CRef<SSeqrefs> sr;
  967.     TSeqId2Seqrefs::iterator bsit = m_Bs2Sr.find(h);
  968.     if (bsit == m_Bs2Sr.end() ) {
  969.         sr.Reset(new SSeqrefs(h));
  970.         m_Bs2Sr[h] = sr;
  971.     }
  972.     else {
  973.         sr = bsit->second;
  974.     }
  976.     int key = sr->m_Handle.GetHash();
  977.     g.Lock(key);
  978.     if( !sr->m_Timer.NeedRefresh(m_Timer) )
  979.         return sr;
  980.     g.Local();
  982.     SSeqrefs::TSeqrefs osr;
  983.     bool got = false;
  985.     CConstRef<CSeq_id> seq_id = h.GetSeqId();
  986.     for ( int try_cnt = 3; !got && try_cnt > 0; --try_cnt ) {
  987.         osr.clear();
  988.         CTimerGuard tg(m_Timer);
  989.         CReader::TConn conn = m_Locks.m_Pool.Select(key);
  990.         try {
  991.             m_Driver->ResolveSeq_id(osr, *seq_id, conn);
  992.             got = true;
  993.             break;
  994.         }
  995.         catch ( CLoaderException& e ) {
  996.             if ( e.GetErrCode() == CLoaderException::eNoConnection ) {
  997.                 throw;
  998.             }
  999.             LOG_POST(e.what());
  1000.         }
  1001.         catch ( const exception &e ) {
  1002.             LOG_POST(e.what());
  1003.         }
  1004.         LOG_POST("GenBank connection failed: Reconnecting....");
  1005.         m_Driver->Reconnect(conn);
  1006.     }
  1007.     if ( !got ) {
  1008.         ERR_POST("CGBLoader:x_ResolveHandle: Seq-id resolve failed: "
  1009.                  "exceeded maximum attempts count");
  1010.         NCBI_THROW(CLoaderException, eLoaderFailed,
  1011.                    "Multiple attempts to resolve Seq-id failed");
  1012.     }
  1014.     g.Lock(); // will unlock everything and lock lookupMutex again 
  1016.     swap(sr->m_Sr, osr);
  1017.     sr->m_Timer.Reset(m_Timer);
  1018.   
  1019.     GBLOG_POST( "ResolveHandle(" << h << ") " << sr->m_Sr.size() );
  1020.     ITERATE(SSeqrefs::TSeqrefs, srp, sr->m_Sr) {
  1021.         GBLOG_POST( (*srp)->print());
  1022.     }
  1023.     
  1024.     if ( !osr.empty() ) {
  1025.         bsit = m_Bs2Sr.find(h);
  1026.         // make sure we are not deleted in the unlocked time 
  1027.         if (bsit != m_Bs2Sr.end()) {
  1028.             SSeqrefs::TSeqrefs& nsr=bsit->second->m_Sr;
  1029.           
  1030.             // catch dissolving TSE and mark them dead
  1031.             //GBLOG_POST( "old seqrefs");
  1032.             ITERATE ( SSeqrefs::TSeqrefs, srp, osr ) {
  1033.                 //(*srp)->print(); cout);
  1034.                 bool found=false;
  1035.                 ITERATE ( SSeqrefs::TSeqrefs, nsrp, nsr ) {
  1036.                     if( (*srp)->SameTSE(**nsrp) ) {
  1037.                         found=true;
  1038.                         break;
  1039.                     }
  1040.                 }
  1041.                 if ( found ) {
  1042.                     continue;
  1043.                 }
  1044.                 TSr2TSEinfo::iterator tsep =
  1045.                     m_Sr2TseInfo.find((*srp)->GetKeyByTSE());
  1046.                 if (tsep == m_Sr2TseInfo.end()) {
  1047.                     continue;
  1048.                 }
  1049.               
  1050.                 // update TSE info 
  1051.                 CRef<STSEinfo> tse = tsep->second;
  1052.                 g.Lock(&*tse);
  1053.                 bool mark_dead  = tse->mode.test(STSEinfo::eDead);
  1054.                 if ( mark_dead ) {
  1055.                     tse->mode.set(STSEinfo::eDead);
  1056.                 }
  1057.                 tse->m_SeqIds.erase(h); // drop h as refewrenced seqid
  1058.                 g.Unlock(&*tse);
  1059.                 if ( mark_dead && tse->tseinfop ) {
  1060.                     // inform data_source :: make sure to avoid deadlocks
  1061.                     tse->tseinfop->SetDead(true);
  1062.                 }
  1063.             }
  1064.         }
  1065.     }
  1066.     return sr;
  1067. }
  1069. bool CGBDataLoader::x_NeedMoreData(const STSEinfo& tse)
  1070. {
  1071.     bool need_data=true;
  1072.   
  1073.     if (tse.m_LoadState==STSEinfo::eLoadStateDone)
  1074.         need_data=false;
  1075.     if (tse.m_LoadState==STSEinfo::eLoadStatePartial) {
  1076.         // split code : check tree for presence of data and
  1077.         // return from routine if all data already loaded
  1078.         // present;
  1079.     }
  1080.     return need_data;
  1081. }
  1084. void CGBDataLoader::x_GetData(CRef<STSEinfo> tse,
  1085.                               CReader::TConn conn)
  1086. {
  1087.     try {
  1088.         if ( x_NeedMoreData(*tse) ) {
  1089.             GBLOG_POST("GetBlob("<<TSE(*tse)<<") "<<":="<<tse->m_LoadState);
  1090.             
  1091.             _ASSERT(tse->m_LoadState != STSEinfo::eLoadStateDone);
  1092.             if (tse->m_LoadState == STSEinfo::eLoadStateNone) {
  1093.                 CRef<CTSE_Info> tse_info =
  1094.                     m_Driver->GetBlob(*tse->seqref, conn);
  1095.                 GBLOG_POST("GetBlob("<<TSE(*tse)<<")");
  1096.                 m_InvokeGC=true;
  1097.                 _ASSERT(tse_info);
  1098.                 tse->m_LoadState   = STSEinfo::eLoadStateDone;
  1099.                 tse_info->SetBlobId(tse);
  1100.                 GetDataSource()->AddTSE(tse_info);
  1101.                 tse->tseinfop = tse_info.GetPointer();
  1102.                 _TRACE("GetBlob("<<DUMP(*tse)<<") - whole blob retrieved");
  1103.             }
  1104.         }
  1105.     }
  1106.     catch ( CLoaderException& e ) {
  1107.         if ( e.GetErrCode() == e.ePrivateData ) {
  1108.             LOG_POST("GI("<<tse->seqref->GetGi()<<") is private");
  1109.             tse->m_LoadState = STSEinfo::eLoadStateDone;
  1110.         }
  1111.         else if ( e.GetErrCode() == e.eNoData ) {
  1112.             if ( (tse->seqref->GetFlags() & CSeqref::fPossible) ) {
  1113.                 tse->m_LoadState   = STSEinfo::eLoadStateDone;
  1114.             }
  1115.             else {
  1116.                 LOG_POST("ERROR: can not retrive sequence: "<<TSE(*tse));
  1117.                 throw;
  1118.             }
  1119.         }
  1120.         else {
  1121.             throw;
  1122.         }
  1123.     }
  1124.     _ASSERT(!x_NeedMoreData(*tse));
  1125. }
  1128. void CGBDataLoader::x_GetChunk(CRef<STSEinfo> tse,
  1129.                                CReader::TConn conn,
  1130.                                CTSE_Chunk_Info& chunk_info)
  1131. {
  1132.     GBLOG_POST("GetChunk("<<TSE(*tse)<<") "<<":="<<chunk_info.GetChunkId());
  1133.   
  1134.     _ASSERT(tse->m_LoadState == STSEinfo::eLoadStateDone);
  1135.     
  1136.     CRef<CTSE_Info> tse_info =
  1137.         m_Driver->GetBlob(*tse->seqref, conn, &chunk_info);
  1138.     GBLOG_POST("GetChunk("<<TSE(*tse)<<")");
  1139.     m_InvokeGC=true;
  1140.     _ASSERT(!tse_info);
  1141.     _TRACE("GetChunk("<<DUMP(*tse)<<") - chunk retrieved");
  1142. }
  1145. const CSeqref& CGBDataLoader::GetSeqref(const CTSE_Info& tse_info)
  1146. {
  1147.     if ( &tse_info.GetDataSource() != GetDataSource() ) {
  1148.         NCBI_THROW(CLoaderException, eLoaderFailed,
  1149.                    "not mine TSE");
  1150.     }
  1151.     CRef<CGBDataLoader::STSEinfo> info(GetTSEinfo(tse_info));
  1152.     return *info->seqref;
  1153. }
  1156. void
  1157. CGBDataLoader::DebugDump(CDebugDumpContext ddc, unsigned int /*depth*/) const
  1158. {
  1159.     ddc.SetFrame("CGBLoader");
  1160.     // CObject::DebugDump( ddc, depth);
  1161.     DebugDumpValue(ddc,"m_TseCount", m_TseCount);
  1162.     DebugDumpValue(ddc,"m_TseGC_Threshhold", m_TseGC_Threshhold);
  1163. }
  1166. END_SCOPE(objects)
  1167. END_NCBI_SCOPE
  1171. /* ---------------------------------------------------------------------------
  1172. * $Log: gbloader.cpp,v $
  1173. * Revision 1000.1  2004/06/01 19:41:37  gouriano
  1174. * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.106
  1175. *
  1176. * Revision 1.106  2004/05/21 21:42:52  gorelenk
  1177. * Added PCH ncbi_pch.hpp
  1178. *
  1179. * Revision 1.105  2004/03/16 15:47:29  vasilche
  1180. * Added CBioseq_set_Handle and set of EditHandles
  1181. *
  1182. * Revision 1.104  2004/02/17 21:17:53  vasilche
  1183. * Fixed 'non-const reference to temporary' warning.
  1184. *
  1185. * Revision 1.103  2004/02/04 20:59:46  ucko
  1186. * Fix the PubSeq entry point name to something that actually exists....
  1187. *
  1188. * Revision 1.102  2004/02/04 17:47:40  kuznets
  1189. * Fixed naming of entry points
  1190. *
  1191. * Revision 1.101  2004/01/22 20:10:35  vasilche
  1192. * 1. Splitted ID2 specs to two parts.
  1193. * ID2 now specifies only protocol.
  1194. * Specification of ID2 split data is moved to seqsplit ASN module.
  1195. * For now they are still reside in one resulting library as before - libid2.
  1196. * As the result split specific headers are now in objects/seqsplit.
  1197. * 2. Moved ID2 and ID1 specific code out of object manager.
  1198. * Protocol is processed by corresponding readers.
  1199. * ID2 split parsing is processed by ncbi_xreader library - used by all readers.
  1200. * 3. Updated OBJMGR_LIBS correspondingly.
  1201. *
  1202. * Revision 1.100  2004/01/13 21:52:06  vasilche
  1203. * Resurrected new version.
  1204. *
  1205. * Revision 1.4  2004/01/13 16:55:55  vasilche
  1206. * CReader, CSeqref and some more classes moved from xobjmgr to separate lib.
  1207. * Headers moved from include/objmgr to include/objtools/data_loaders/genbank.
  1208. *
  1209. * Revision 1.3  2003/12/30 22:14:41  vasilche
  1210. * Updated genbank loader and readers plugins.
  1211. *
  1212. * Revision 1.98  2003/12/30 19:51:24  vasilche
  1213. * Implemented CGBDataLoader::GetSatSatkey() method.
  1214. *
  1215. * Revision 1.97  2003/12/30 17:43:17  vasilche
  1216. * Fixed warning about unused variable.
  1217. *
  1218. * Revision 1.96  2003/12/30 16:41:19  vasilche
  1219. * Removed warning about unused variable.
  1220. *
  1221. * Revision 1.95  2003/12/19 19:49:21  vasilche
  1222. * Use direct Seq-id -> sat/satkey resolution without intermediate gi.
  1223. *
  1224. * Revision 1.94  2003/12/03 15:14:05  kuznets
  1225. * CReader management re-written to use plugin manager
  1226. *
  1227. * Revision 1.93  2003/12/02 23:17:34  vasilche
  1228. * Fixed exception in ID1 reader when invalid Seq-id is supplied.
  1229. *
  1230. * Revision 1.92  2003/12/01 23:42:29  vasilche
  1231. * Temporary fix for segfault in genbank data loader in multithreaded applications.
  1232. *
  1233. * Revision 1.91  2003/11/26 17:55:58  vasilche
  1234. * Implemented ID2 split in ID1 cache.
  1235. * Fixed loading of splitted annotations.
  1236. *
  1237. * Revision 1.90  2003/10/27 19:28:02  vasilche
  1238. * Removed debug message.
  1239. *
  1240. * Revision 1.89  2003/10/27 18:50:49  vasilche
  1241. * Detect 'private' blobs in ID1 reader.
  1242. * Avoid reconnecting after ID1 server replied with error packet.
  1243. *
  1244. * Revision 1.88  2003/10/27 15:05:41  vasilche
  1245. * Added correct recovery of cached ID1 loader if gi->sat/satkey cache is invalid.
  1246. * Added recognition of ID1 error codes: private, etc.
  1247. * Some formatting of old code.
  1248. *
  1249. * Revision 1.87  2003/10/22 16:12:37  vasilche
  1250. * Added CLoaderException::eNoConnection.
  1251. * Added check for 'fail' state of ID1 connection stream.
  1252. * CLoaderException::eNoConnection will be rethrown from CGBLoader.
  1253. *
  1254. * Revision 1.86  2003/10/07 13:43:23  vasilche
  1255. * Added proper handling of named Seq-annots.
  1256. * Added feature search from named Seq-annots.
  1257. * Added configurable adaptive annotation search (default: gene, cds, mrna).
  1258. * Fixed selection of blobs for loading from GenBank.
  1259. * Added debug checks to CSeq_id_Mapper for easier finding lost CSeq_id_Handles.
  1260. * Fixed leaked split chunks annotation stubs.
  1261. * Moved some classes definitions in separate *.cpp files.
  1262. *
  1263. * Revision 1.85  2003/09/30 16:22:02  vasilche
  1264. * Updated internal object manager classes to be able to load ID2 data.
  1265. * SNP blobs are loaded as ID2 split blobs - readers convert them automatically.
  1266. * Scope caches results of requests for data to data loaders.
  1267. * Optimized CSeq_id_Handle for gis.
  1268. * Optimized bioseq lookup in scope.
  1269. * Reduced object allocations in annotation iterators.
  1270. * CScope is allowed to be destroyed before other objects using this scope are
  1271. * deleted (feature iterators, bioseq handles etc).
  1272. * Optimized lookup for matching Seq-ids in CSeq_id_Mapper.
  1273. * Added 'adaptive' option to objmgr_demo application.
  1274. *
  1275. * Revision 1.84  2003/09/05 17:29:40  grichenk
  1276. * Structurized Object Manager exceptions
  1277. *
  1278. * Revision 1.83  2003/08/27 14:25:22  vasilche
  1279. * Simplified CCmpTSE class.
  1280. *
  1281. * Revision 1.82  2003/08/14 20:05:19  vasilche
  1282. * Simple SNP features are stored as table internally.
  1283. * They are recreated when needed using CFeat_CI.
  1284. *
  1285. * Revision 1.81  2003/07/24 19:28:09  vasilche
  1286. * Implemented SNP split for ID1 loader.
  1287. *
  1288. * Revision 1.80  2003/07/22 22:01:43  vasilche
  1289. * Removed use of HAVE_LIBDL.
  1290. *
  1291. * Revision 1.79  2003/07/17 22:51:31  vasilche
  1292. * Fixed unused variables warnings.
  1293. *
  1294. * Revision 1.78  2003/07/17 20:07:56  vasilche
  1295. * Reduced memory usage by feature indexes.
  1296. * SNP data is loaded separately through PUBSEQ_OS.
  1297. * String compression for SNP data.
  1298. *
  1299. * Revision 1.77  2003/06/24 14:25:18  vasilche
  1300. * Removed obsolete CTSE_Guard class.
  1301. * Used separate mutexes for bioseq and annot maps.
  1302. *
  1303. * Revision 1.76  2003/06/11 14:54:06  vasilche
  1304. * Fixed wrong error message in CGBDataLoader destructor when
  1305. * some data requests were failed.
  1306. *
  1307. * Revision 1.75  2003/06/10 19:01:07  vasilche
  1308. * Fixed loader methods string.
  1309. *
  1310. * Revision 1.74  2003/06/10 15:25:33  vasilche
  1311. * Changed wrong _ASSERT to _VERIFY
  1312. *
  1313. * Revision 1.73  2003/06/02 16:06:37  dicuccio
  1314. * Rearranged src/objects/ subtree.  This includes the following shifts:
  1315. *     - src/objects/asn2asn --> arc/app/asn2asn
  1316. *     - src/objects/testmedline --> src/objects/ncbimime/test
  1317. *     - src/objects/objmgr --> src/objmgr
  1318. *     - src/objects/util --> src/objmgr/util
  1319. *     - src/objects/alnmgr --> src/objtools/alnmgr
  1320. *     - src/objects/flat --> src/objtools/flat
  1321. *     - src/objects/validator --> src/objtools/validator
  1322. *     - src/objects/cddalignview --> src/objtools/cddalignview
  1323. * In addition, libseq now includes six of the objects/seq... libs, and libmmdb
  1324. * replaces the three libmmdb? libs.
  1325. *
  1326. * Revision 1.72  2003/05/20 21:13:02  vasilche
  1327. * Fixed ambiguity on MSVC.
  1328. *
  1329. * Revision 1.71  2003/05/20 18:27:29  vasilche
  1330. * Fixed ambiguity on MSVC.
  1331. *
  1332. * Revision 1.70  2003/05/20 16:18:42  vasilche
  1333. * Fixed compilation errors on GCC.
  1334. *
  1335. * Revision 1.69  2003/05/20 15:44:37  vasilche
  1336. * Fixed interaction of CDataSource and CDataLoader in multithreaded app.
  1337. * Fixed some warnings on WorkShop.
  1338. * Added workaround for memory leak on WorkShop.
  1339. *
  1340. * Revision 1.68  2003/05/13 20:27:05  vasilche
  1341. * Added lost SAT SATKEY info in error message.
  1342. *
  1343. * Revision 1.67  2003/05/13 20:21:10  vasilche
  1344. * *** empty log message ***
  1345. *
  1346. * Revision 1.66  2003/05/13 20:14:40  vasilche
  1347. * Catching exceptions and reconnection were moved from readers to genbank loader.
  1348. *
  1349. * Revision 1.65  2003/05/13 18:32:29  vasilche
  1350. * Fixed use of GBLOG_POST() macro.
  1351. *
  1352. * Revision 1.64  2003/05/12 19:18:29  vasilche
  1353. * Fixed locking of object manager classes in multi-threaded application.
  1354. *
  1355. * Revision 1.63  2003/05/12 18:26:08  vasilche
  1356. * Removed buggy _ASSERT() on reconnection.
  1357. *
  1358. * Revision 1.62  2003/05/06 16:52:28  vasilche
  1359. * Try to reconnect to genbank on any exception.
  1360. *
  1361. * Revision 1.61  2003/04/29 19:51:13  vasilche
  1362. * Fixed interaction of Data Loader garbage collector and TSE locking mechanism.
  1363. * Made some typedefs more consistent.
  1364. *
  1365. * Revision 1.60  2003/04/24 16:12:38  vasilche
  1366. * Object manager internal structures are splitted more straightforward.
  1367. * Removed excessive header dependencies.
  1368. *
  1369. * Revision 1.59  2003/04/18 17:38:01  grichenk
  1370. * Use GENBANK_LOADER_METHOD env. variable to specify GB readers.
  1371. * Default is "PUBSEQOS:ID1".
  1372. *
  1373. * Revision 1.58  2003/04/15 16:32:29  dicuccio
  1374. * Added include for I_DriverContext from DBAPI library - avoids concerning
  1375. * warning about deletion of unknwon type.
  1376. *
  1377. * Revision 1.57  2003/04/15 15:30:15  vasilche
  1378. * Added include <memory> when needed.
  1379. * Removed buggy buffer in printing methods.
  1380. * Removed unnecessary include of stream_util.hpp.
  1381. *
  1382. * Revision 1.56  2003/04/15 14:24:08  vasilche
  1383. * Changed CReader interface to not to use fake streams.
  1384. *
  1385. * Revision 1.55  2003/03/21 19:22:51  grichenk
  1386. * Redesigned TSE locking, replaced CTSE_Lock with CRef<CTSE_Info>.
  1387. *
  1388. * Revision 1.54  2003/03/11 15:51:06  kuznets
  1389. * iterate -> ITERATE
  1390. *
  1391. * Revision 1.53  2003/03/05 20:54:41  vasilche
  1392. * Commented out wrong assert().
  1393. *
  1394. * Revision 1.52  2003/03/03 20:34:51  vasilche
  1395. * Added NCBI_THREADS macro - it's opposite to NCBI_NO_THREADS.
  1396. * Avoid using _REENTRANT macro - use NCBI_THREADS instead.
  1397. *
  1398. * Revision 1.51  2003/03/01 23:07:42  kimelman
  1399. * bugfix: MTsafe
  1400. *
  1401. * Revision 1.50  2003/03/01 22:27:57  kimelman
  1402. * performance fixes
  1403. *
  1404. * Revision 1.49  2003/02/27 21:58:26  vasilche
  1405. * Fixed performance of Object Manager's garbage collector.
  1406. *
  1407. * Revision 1.48  2003/02/26 18:03:31  vasilche
  1408. * Added some error check.
  1409. * Fixed formatting.
  1410. *
  1411. * Revision 1.47  2003/02/24 18:57:22  vasilche
  1412. * Make feature gathering in one linear pass using CSeqMap iterator.
  1413. * Do not use feture index by sub locations.
  1414. * Sort features at the end of gathering in one vector.
  1415. * Extracted some internal structures and classes in separate header.
  1416. * Delay creation of mapped features.
  1417. *
  1418. * Revision 1.46  2003/02/05 17:59:17  dicuccio
  1419. * Moved formerly private headers into include/objects/objmgr/impl
  1420. *
  1421. * Revision 1.45  2003/01/22 20:11:54  vasilche
  1422. * Merged functionality of CSeqMapResolved_CI to CSeqMap_CI.
  1423. * CSeqMap_CI now supports resolution and iteration over sequence range.
  1424. * Added several caches to CScope.
  1425. * Optimized CSeqVector().
  1426. * Added serveral variants of CBioseqHandle::GetSeqVector().
  1427. * Tried to optimize annotations iterator (not much success).
  1428. * Rewritten CHandleRange and CHandleRangeMap classes to avoid sorting of list.
  1429. *
  1430. * Revision 1.44  2002/12/26 20:53:02  dicuccio
  1431. * Moved tse_info.hpp -> include/ tree.  Minor tweaks to relieve compiler
  1432. * warnings in MSVC.
  1433. *
  1434. * Revision 1.43  2002/11/08 19:43:35  grichenk
  1435. * CConstRef<> constructor made explicit
  1436. *
  1437. * Revision 1.42  2002/11/04 21:29:12  grichenk
  1438. * Fixed usage of const CRef<> and CRef<> constructor
  1439. *
  1440. * Revision 1.41  2002/09/09 16:12:43  dicuccio
  1441. * Fixed minor typo ("conneciton" -> "connection").
  1442. *
  1443. * Revision 1.40  2002/07/24 20:30:27  ucko
  1444. * Move CTimerGuard out to file scope to fix a MIPSpro compiler core dump.
  1445. *
  1446. * Revision 1.39  2002/07/22 22:53:24  kimelman
  1447. * exception handling fixed: 2level mutexing moved to Guard class + added
  1448. * handling of confidential data.
  1449. *
  1450. * Revision 1.38  2002/06/04 17:18:33  kimelman
  1451. * memory cleanup :  new/delete/Cref rearrangements
  1452. *
  1453. * Revision 1.37  2002/05/14 20:06:26  grichenk
  1454. * Improved CTSE_Info locking by CDataSource and CDataLoader
  1455. *
  1456. * Revision 1.36  2002/05/10 16:44:32  kimelman
  1457. * tuning to allow pubseq enable build
  1458. *
  1459. * Revision 1.35  2002/05/08 22:23:48  kimelman
  1460. * MT fixes
  1461. *
  1462. * Revision 1.34  2002/05/06 03:28:47  vakatov
  1463. * OM/OM1 renaming
  1464. *
  1465. * Revision 1.33  2002/05/03 21:28:10  ucko
  1466. * Introduce T(Signed)SeqPos.
  1467. *
  1468. * Revision 1.32  2002/04/30 18:56:54  gouriano
  1469. * added multithreading-related initialization
  1470. *
  1471. * Revision 1.31  2002/04/28 03:36:47  vakatov
  1472. * Temporarily turn off R1.30(b) unconditionally -- until it is buildable
  1473. *
  1474. * Revision 1.30  2002/04/26 16:32:23  kimelman
  1475. * a) turn on GC b) turn on PubSeq where sybase is available
  1476. *
  1477. * Revision 1.29  2002/04/12 22:54:28  kimelman
  1478. * pubseq_reader auto call commented per Denis request
  1479. *
  1480. * Revision 1.28  2002/04/12 21:10:33  kimelman
  1481. * traps for coredumps
  1482. *
  1483. * Revision 1.27  2002/04/11 18:45:35  ucko
  1484. * Pull in extra headers to make KCC happy.
  1485. *
  1486. * Revision 1.26  2002/04/10 22:47:56  kimelman
  1487. * added pubseq_reader as default one
  1488. *
  1489. * Revision 1.25  2002/04/09 19:04:23  kimelman
  1490. * make gcc happy
  1491. *
  1492. * Revision 1.24  2002/04/09 18:48:15  kimelman
  1493. * portability bugfixes: to compile on IRIX, sparc gcc
  1494. *
  1495. * Revision 1.23  2002/04/05 23:47:18  kimelman
  1496. * playing around tests
  1497. *
  1498. * Revision 1.22  2002/04/04 01:35:35  kimelman
  1499. * more MT tests
  1500. *
  1501. * Revision 1.21  2002/04/02 17:27:00  gouriano
  1502. * bugfix: skip test for yet unregistered data
  1503. *
  1504. * Revision 1.20  2002/04/02 16:27:20  gouriano
  1505. * memory leak
  1506. *
  1507. * Revision 1.19  2002/04/02 16:02:31  kimelman
  1508. * MT testing
  1509. *
  1510. * Revision 1.18  2002/03/30 19:37:06  kimelman
  1511. * gbloader MT test
  1512. *
  1513. * Revision 1.17  2002/03/29 02:47:04  kimelman
  1514. * gbloader: MT scalability fixes
  1515. *
  1516. * Revision 1.16  2002/03/27 20:23:50  butanaev
  1517. * Added connection pool.
  1518. *
  1519. * Revision 1.15  2002/03/26 23:31:08  gouriano
  1520. * memory leaks and garbage collector fix
  1521. *
  1522. * Revision 1.14  2002/03/26 15:39:24  kimelman
  1523. * GC fixes
  1524. *
  1525. * Revision 1.13  2002/03/25 17:49:12  kimelman
  1526. * ID1 failure handling
  1527. *
  1528. * Revision 1.12  2002/03/25 15:44:46  kimelman
  1529. * proper logging and exception handling
  1530. *
  1531. * Revision 1.11  2002/03/22 18:56:05  kimelman
  1532. * GC list fix
  1533. *
  1534. * Revision 1.10  2002/03/22 18:51:18  kimelman
  1535. * stream WS skipping fix
  1536. *
  1537. * Revision 1.9  2002/03/22 18:15:47  grichenk
  1538. * Unset "skipws" flag in binary stream
  1539. *
  1540. * Revision 1.8  2002/03/21 23:16:32  kimelman
  1541. * GC bugfixes
  1542. *
  1543. * Revision 1.7  2002/03/21 21:39:48  grichenk
  1544. * garbage collector bugfix
  1545. *
  1546. * Revision 1.6  2002/03/21 19:14:53  kimelman
  1547. * GB related bugfixes
  1548. *
  1549. * Revision 1.5  2002/03/21 01:34:53  kimelman
  1550. * gbloader related bugfixes
  1551. *
  1552. * Revision 1.4  2002/03/20 21:24:59  gouriano
  1553. * *** empty log message ***
  1554. *
  1555. * Revision 1.3  2002/03/20 19:06:30  kimelman
  1556. * bugfixes
  1557. *
  1558. * Revision 1.2  2002/03/20 17:03:24  gouriano
  1559. * minor changes to make it compilable on MS Windows
  1560. *
  1561. * Revision 1.1  2002/03/20 04:50:13  kimelman
  1562. * GB loader added
  1563. *
  1564. * ===========================================================================
  1565. */