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

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

生物技术

开发平台：

C/C++

reader_id1_cache.cpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: reader_id1_cache.cpp,v $
  4.  * PRODUCTION Revision 1000.2  2004/06/01 19:41:59  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.25
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. /*  $Id: reader_id1_cache.cpp,v 1000.2 2004/06/01 19:41:59 gouriano Exp $
  11.  * ===========================================================================
  12.  *                            PUBLIC DOMAIN NOTICE
  13.  *               National Center for Biotechnology Information
  14.  *
  15.  *  This software/database is a "United States Government Work" under the
  16.  *  terms of the United States Copyright Act.  It was written as part of
  17.  *  the author's official duties as a United States Government employee and
  18.  *  thus cannot be copyrighted.  This software/database is freely available
  19.  *  to the public for use. The National Library of Medicine and the U.S.
  20.  *  Government have not placed any restriction on its use or reproduction.
  21.  *
  22.  *  Although all reasonable efforts have been taken to ensure the accuracy
  23.  *  and reliability of the software and data, the NLM and the U.S.
  24.  *  Government do not and cannot warrant the performance or results that
  25.  *  may be obtained by using this software or data. The NLM and the U.S.
  26.  *  Government disclaim all warranties, express or implied, including
  27.  *  warranties of performance, merchantability or fitness for any particular
  28.  *  purpose.
  29.  *
  30.  *  Please cite the author in any work or product based on this material.
  31.  *
  32.  * ===========================================================================
  33.  *
  34.  *  Author:  Eugene Vasilchenko, Anatoliy Kuznetsov
  35.  *
  36.  *  File Description: Cached extension of data reader from ID1
  37.  *
  38.  */
  39. #include <ncbi_pch.hpp>
  40. #include <objtools/data_loaders/genbank/readers/id1/reader_id1_cache.hpp>
  41. #include <objtools/data_loaders/genbank/reader_snp.hpp>
  42. #include <objtools/data_loaders/genbank/split_parser.hpp>
  44. #include <corelib/ncbitime.hpp>
  46. #include <util/cache/blob_cache.hpp>
  47. #include <util/cache/int_cache.hpp>
  48. #include <util/cache/icache.hpp>
  50. #include <util/rwstream.hpp>
  51. #include <util/bytesrc.hpp>
  53. #include <serial/objistr.hpp>
  54. #include <serial/objistrasnb.hpp>
  55. #include <serial/objostrasnb.hpp>
  57. #include <objmgr/objmgr_exception.hpp>
  58. #include <objmgr/impl/snp_annot_info.hpp>
  59. #include <objmgr/impl/tse_chunk_info.hpp>
  60. #include <util/compress/reader_zlib.hpp>
  62. #include <connect/ncbi_conn_stream.hpp>
  64. #include <objects/seqset/Seq_entry.hpp>
  65. #include <objects/seqsplit/ID2S_Split_Info.hpp>
  66. #include <objects/seqsplit/ID2S_Chunk_Info.hpp>
  67. #include <objects/seqsplit/ID2S_Chunk.hpp>
  68. #include <objects/seqsplit/ID2S_Chunk_Id.hpp>
  70. #include <objects/id1/id1__.hpp>
  71. #include <objects/id2/ID2_Reply_Data.hpp>
  73. #include <serial/serial.hpp>
  75. #include <stdio.h>
  77. BEGIN_NCBI_SCOPE
  78. BEGIN_SCOPE(objects)
  80. /// Utility function to skip part of the input byte source
  81. void Id1ReaderSkipBytes(CByteSourceReader& reader, size_t to_skip);
  84. static size_t resolve_id_count = 0;
  85. static double resolve_id_time = 0;
  87. static size_t resolve_gi_count = 0;
  88. static double resolve_gi_time = 0;
  90. static size_t resolve_ver_count = 0;
  91. static double resolve_ver_time = 0;
  93. static size_t main_blob_count = 0;
  94. static double main_bytes = 0;
  95. static double main_time = 0;
  97. static size_t chunk_blob_count = 0;
  98. static double chunk_bytes = 0;
  99. static double chunk_time = 0;
  101. static size_t snp_load_count = 0;
  102. static double snp_load_bytes = 0;
  103. static double snp_load_time = 0;
  105. static size_t snp_store_count = 0;
  106. static double snp_store_bytes = 0;
  107. static double snp_store_time = 0;
  109. CCachedId1Reader::CCachedId1Reader(TConn noConn, 
  110.                                    IBLOB_Cache* blob_cache,
  111.                                    IIntCache* id_cache)
  112.     : CId1Reader(noConn),
  113.       m_BlobCache(0), m_IdCache(0),
  114.       m_OldBlobCache(0), m_OldIdCache(0)
  115. {
  116.     SetBlobCache(blob_cache);
  117.     SetIdCache(id_cache);
  118. }
  121. CCachedId1Reader::CCachedId1Reader(TConn noConn, 
  122.                                    ICache* blob_cache,
  123.                                    ICache* id_cache)
  124.     : CId1Reader(noConn),
  125.       m_BlobCache(0), m_IdCache(0),
  126.       m_OldBlobCache(0), m_OldIdCache(0)
  127. {
  128.     SetBlobCache(blob_cache);
  129.     SetIdCache(id_cache);
  130. }
  133. CCachedId1Reader::~CCachedId1Reader()
  134. {
  135.     if ( CollectStatistics() ) {
  136.         PrintStatistics();
  137.     }
  138. }
  141. void CCachedId1Reader::PrintStatistics(void) const
  142. {
  143.     PrintStat("Cache resolution: resolved",
  144.                 resolve_id_count, "ids", resolve_id_time);
  145.     PrintStat("Cache resolution: resolved",
  146.                 resolve_gi_count, "gis", resolve_gi_time);
  147.     PrintStat("Cache resolution: resolved",
  148.               resolve_ver_count, "blob vers", resolve_ver_time);
  149.     PrintBlobStat("Cache main: loaded",
  150.                   main_blob_count, main_bytes, main_time);
  151.     PrintBlobStat("Cache chunk: loaded",
  152.                   chunk_blob_count, chunk_bytes, chunk_time);
  153.     PrintBlobStat("Cache SNP: loaded",
  154.                   snp_load_count, snp_load_bytes, snp_load_time);
  155.     PrintBlobStat("Cache SNP: stored",
  156.                   snp_store_count, snp_store_bytes, snp_store_time);
  157. }
  160. void CCachedId1Reader::SetBlobCache(ICache* blob_cache)
  161. {
  162.     m_OldBlobCache = 0;
  163.     m_BlobCache = blob_cache;
  164. }
  167. void CCachedId1Reader::SetIdCache(ICache* id_cache)
  168. {
  169.     m_OldIdCache = 0;
  170.     m_IdCache = id_cache;
  171. }
  174. void CCachedId1Reader::SetBlobCache(IBLOB_Cache* blob_cache)
  175. {
  176.     m_BlobCache = 0;
  177.     if ( blob_cache && blob_cache != m_OldBlobCache ) {
  178.         ERR_POST(Warning << "CCachedId1Reader: "
  179.                  "IBLOB_Cache is deprecated, use ICache instead");
  180.     }
  181.     m_OldBlobCache = blob_cache;
  182. }
  185. void CCachedId1Reader::SetIdCache(IIntCache* id_cache)
  186. {
  187.     m_IdCache = 0;
  188.     if ( id_cache && id_cache != m_OldIdCache ) {
  189.         ERR_POST(Warning << "CCachedId1Reader: "
  190.                  "IIntCache is deprecated, use ICache instead");
  191.     }
  192.     m_OldIdCache = id_cache;
  193. }
  196. string CCachedId1Reader::GetBlobKey(const CSeqref& seqref) const
  197. {
  198.     int sat = seqref.GetSat();
  199.     int sat_key = seqref.GetSatKey();
  201.     char szBlobKeyBuf[256];
  202.     sprintf(szBlobKeyBuf, "%i-%i", sat, sat_key);
  203.     return szBlobKeyBuf;
  204. }
  207. string CCachedId1Reader::GetIdKey(int gi) const
  208. {
  209.     return NStr::IntToString(gi);
  210. }
  213. string CCachedId1Reader::GetIdKey(const CSeq_id& id) const
  214. {
  215.     return id.IsGi()? GetIdKey(id.GetGi()): id.AsFastaString();
  216. }
  219. const char* CCachedId1Reader::GetSeqrefsSubkey(void) const
  220. {
  221.     return "srs";
  222. }
  225. const char* CCachedId1Reader::GetGiSubkey(void) const
  226. {
  227.     return "gi";
  228. }
  231. const char* CCachedId1Reader::GetBlobVersionSubkey(void) const
  232. {
  233.     return "ver";
  234. }
  237. const char* CCachedId1Reader::GetSeqEntrySubkey(void) const
  238. {
  239.     return "Seq-entry";
  240. }
  243. const char* CCachedId1Reader::GetSNPTableSubkey(void) const
  244. {
  245.     return "SNP table";
  246. }
  249. const char* CCachedId1Reader::GetSkeletonSubkey(void) const
  250. {
  251.     return "Skeleton";
  252. }
  255. const char* CCachedId1Reader::GetSplitInfoSubkey(void) const
  256. {
  257.     return "ID2S-Split-Info";
  258. }
  261. string CCachedId1Reader::GetChunkSubkey(int chunk_id) const
  262. {
  263.     return "ID2S-Chunk "+NStr::IntToString(chunk_id);
  264. }
  267. void CCachedId1Reader::PurgeSeqrefs(const TSeqrefs& srs, const CSeq_id& id)
  268. {
  269.     if ( m_IdCache ) {
  270.         m_IdCache->Remove(GetIdKey(id));
  271.         ITERATE ( TSeqrefs, it, srs ) {
  272.             const CSeqref& sr = **it;
  273.             m_IdCache->Remove(GetBlobKey(sr));
  274.         }
  275.     }
  276.     else if ( m_OldIdCache ) {
  277.         ITERATE ( TSeqrefs, it, srs ) {
  278.             const CSeqref& sr = **it;
  279.             m_OldIdCache->Remove(sr.GetGi(), 0);
  280.             m_OldIdCache->Remove(sr.GetSatKey(), sr.GetSat());
  281.         }
  282.     }
  283. }
  286. bool CCachedId1Reader::x_GetIdCache(const string& key,
  287.                                     const string& subkey,
  288.                                     vector<int>& ints)
  289. {
  290.     CStopWatch sw;
  291.     if ( CollectStatistics() ) {
  292.         sw.Start();
  293.     }
  295.     size_t size = m_IdCache->GetSize(key, 0, subkey);
  296.     ints.resize(size / sizeof(int));
  297.     if ( size == 0 || size % sizeof(int) != 0 ||
  298.          !m_IdCache->Read(key, 0, subkey, &ints[0], size) ) {
  299.         if ( CollectStatistics() ) {
  300.             double time = sw.Elapsed();
  301.             LogStat("CId1Cache: failed to read id cache record for id",
  302.                     key, subkey, time);
  303.             resolve_id_count++;
  304.             resolve_id_time += time;
  305.         }
  306.         return false;
  307.     }
  308.     if ( CollectStatistics() ) {
  309.         double time = sw.Elapsed();
  310.         LogStat("CId1Cache: resolved id", key, subkey, time);
  311.         resolve_id_count++;
  312.         resolve_id_time += time;
  313.     }
  314.     return true;
  315. }
  318. bool CCachedId1Reader::x_GetIdCache(const string& key,
  319.                                     const string& subkey,
  320.                                     int& value)
  321. {
  322.     CStopWatch sw;
  323.     if ( CollectStatistics() ) {
  324.         sw.Start();
  325.     }
  327.     size_t size = m_IdCache->GetSize(key, 0, subkey);
  328.     if ( size != sizeof(int) ||
  329.          !m_IdCache->Read(key, 0, subkey, &value, size) ) {
  330.         if ( CollectStatistics() ) {
  331.             double time = sw.Elapsed();
  332.             LogStat("CId1Cache: failed to read id cache record for id",
  333.                     key, subkey, time);
  334.             resolve_id_count++;
  335.             resolve_id_time += time;
  336.         }
  337.         return false;
  338.     }
  339.     if ( CollectStatistics() ) {
  340.         double time = sw.Elapsed();
  341.         LogStat("CId1Cache: resolved id", key, subkey, time);
  342.         resolve_id_count++;
  343.         resolve_id_time += time;
  344.     }
  345.     return true;
  346. }
  349. void CCachedId1Reader::x_StoreIdCache(const string& key,
  350.                                       const string& subkey,
  351.                                       const vector<int>& ints)
  352. {
  353.     CStopWatch sw;
  354.     if ( CollectStatistics() ) {
  355.         sw.Start();
  356.     }
  357.     
  358.     m_IdCache->Store(key, 0, subkey, &ints[0], ints.size()*sizeof(int));
  359.     
  360.     if ( CollectStatistics() ) {
  361.         double time = sw.Elapsed();
  362.         LogStat("CId1Cache: stored id", key, subkey, time);
  363.         resolve_id_count++;
  364.         resolve_id_time += time;
  365.     }
  366. }
  369. void CCachedId1Reader::x_StoreIdCache(const string& key,
  370.                                       const string& subkey,
  371.                                       const int& value)
  372. {
  373.     CStopWatch sw;
  374.     if ( CollectStatistics() ) {
  375.         sw.Start();
  376.     }
  377.     
  378.     m_IdCache->Store(key, 0, subkey, &value, sizeof(value));
  379.     
  380.     if ( CollectStatistics() ) {
  381.         double time = sw.Elapsed();
  382.         LogStat("CId1Cache: stored id", key, subkey, time);
  383.         resolve_id_count++;
  384.         resolve_id_time += time;
  385.     }
  386. }
  389. bool CCachedId1Reader::GetSeqrefs(const string& key, TSeqrefs& srs)
  390. {
  391.     vector<int> data;
  392.     if ( !x_GetIdCache(key, GetSeqrefsSubkey(), data) ) {
  393.         return false;
  394.     }
  395.     if ( data.size() % 5 != 0 || data.size() > 50 ) {
  396.         return false;
  397.     }
  398.     ITERATE ( vector<int>, it, data ) {
  399.         int gi      = *it++;
  400.         int sat     = *it++;
  401.         int satkey  = *it++;
  402.         int version = *it++;
  403.         int flags   = *it;
  404.         CRef<CSeqref> sr(new CSeqref(gi, sat, satkey));
  405.         sr->SetVersion(version);
  406.         sr->SetFlags(flags);
  407.         srs.push_back(sr);
  408.     }
  409.     return true;
  410. }
  413. void CCachedId1Reader::StoreSeqrefs(const string& key, const TSeqrefs& srs)
  414. {
  415.     vector<int> data;
  416.     ITERATE ( TSeqrefs, it, srs ) {
  417.         const CSeqref& sr = **it;
  418.         data.push_back(sr.GetGi());
  419.         data.push_back(sr.GetSat());
  420.         data.push_back(sr.GetSatKey());
  421.         data.push_back(sr.GetVersion());
  422.         data.push_back(sr.GetFlags());
  423.     }
  424.     x_StoreIdCache(key, GetSeqrefsSubkey(), data);
  425. }
  428. bool CCachedId1Reader::GetSeqrefs(int gi, TSeqrefs& srs)
  429. {
  430.     if ( m_IdCache ) {
  431.         return GetSeqrefs(GetIdKey(gi), srs);
  432.     }
  433.     else if ( m_OldIdCache) {
  434.         CStopWatch sw;
  435.         if ( CollectStatistics() ) {
  436.             sw.Start();
  437.         }
  439.         vector<int> data;
  440.         if ( !m_OldIdCache->Read(gi, 0, data) ) {
  441.             if ( CollectStatistics() ) {
  442.                 double time = sw.Elapsed();
  443.                 LogStat("CId1Cache: failed to resolve gi", gi, time);
  444.                 resolve_gi_count++;
  445.                 resolve_gi_time += time;
  446.             }
  447.             return false;
  448.         }
  449.     
  450.         _ASSERT(data.size() == 4 || data.size() == 8);
  452.         for ( size_t pos = 0; pos + 4 <= data.size(); pos += 4 ) {
  453.             int sat = data[pos];
  454.             int satkey = data[pos+1];
  455.             int version = data[pos+2];
  456.             int flags = data[pos+3];
  457.             CRef<CSeqref> sr(new CSeqref(gi, sat, satkey));
  458.             sr->SetVersion(version);
  459.             sr->SetFlags(flags);
  460.             srs.push_back(sr);
  461.         }
  463.         if ( CollectStatistics() ) {
  464.             double time = sw.Elapsed();
  465.             LogStat("CId1Cache: resolved gi", gi, time);
  466.             resolve_gi_count++;
  467.             resolve_gi_time += time;
  468.         }
  469.         return true;
  470.     }
  471.     else {
  472.         return false;
  473.     }
  474. }
  477. void CCachedId1Reader::StoreSeqrefs(int gi, const TSeqrefs& srs)
  478. {
  479.     if ( m_IdCache ) {
  480.         StoreSeqrefs(GetIdKey(gi), srs);
  481.     }
  482.     else if ( m_OldIdCache ) {
  483.         CStopWatch sw;
  484.         if ( CollectStatistics() ) {
  485.             sw.Start();
  486.         }
  488.         vector<int> data;
  490.         ITERATE ( TSeqrefs, it, srs ) {
  491.             const CSeqref& sr = **it;
  492.             data.push_back(sr.GetSat());
  493.             data.push_back(sr.GetSatKey());
  494.             data.push_back(sr.GetVersion());
  495.             data.push_back(sr.GetFlags());
  496.         }
  498.         _ASSERT(data.size() == 4 || data.size() == 8);
  500.         m_OldIdCache->Store(gi, 0, data);
  502.         if ( CollectStatistics() ) {
  503.             double time = sw.Elapsed();
  504.             LogStat("CId1Cache: saved gi", gi, time);
  505.             resolve_gi_count++;
  506.             resolve_gi_time += time;
  507.         }
  508.     }
  509. }
  512. bool CCachedId1Reader::GetSeqrefs(const CSeq_id& id, TSeqrefs& srs)
  513. {
  514.     if ( m_IdCache ) {
  515.         return GetSeqrefs(GetIdKey(id), srs);
  516.     }
  517.     else {
  518.         return false;
  519.     }
  520. }
  523. void CCachedId1Reader::StoreSeqrefs(const CSeq_id& id, const TSeqrefs& srs)
  524. {
  525.     if ( m_IdCache ) {
  526.         StoreSeqrefs(GetIdKey(id), srs);
  527.     }
  528. }
  531. int CCachedId1Reader::GetBlobVersion(const CSeqref& seqref)
  532. {
  533.     if ( m_IdCache ) {
  534.         int version = 0;
  535.         if ( x_GetIdCache(GetBlobKey(seqref),
  536.                           GetBlobVersionSubkey(),
  537.                           version) ) {
  538.             return version;
  539.         }
  540.     }
  541.     else if ( m_OldIdCache ) {
  542.         CStopWatch sw;
  543.         if ( CollectStatistics() ) {
  544.             sw.Start();
  545.         }
  547.         vector<int> data;
  548.         if ( !m_OldIdCache->Read(seqref.GetSatKey(), seqref.GetSat(), data) ) {
  549.             if ( CollectStatistics() ) {
  550.                 double time = sw.Elapsed();
  551.                 LogStat("CId1Cache: failed to get blob version",
  552.                         seqref.printTSE(), time);
  553.                 resolve_ver_count++;
  554.                 resolve_ver_time += time;
  555.             }
  556.             return 0;
  557.         }
  558.     
  559.         _ASSERT(data.size() == 1);
  561.         if ( CollectStatistics() ) {
  562.             double time = sw.Elapsed();
  563.             LogStat("CId1Cache: got blob version", seqref.printTSE(), time);
  564.             resolve_ver_count++;
  565.             resolve_ver_time += time;
  566.         }
  568.         return data[0];
  569.     }
  570.     return 0;
  571. }
  574. void CCachedId1Reader::StoreBlobVersion(const CSeqref& seqref, int version)
  575. {
  576.     if ( m_IdCache ) {
  577.         x_StoreIdCache(GetBlobKey(seqref),
  578.                        GetBlobVersionSubkey(),
  579.                        version);
  580.     }
  581.     else if ( m_OldIdCache ) {
  582.         CStopWatch sw;
  583.         if ( CollectStatistics() ) {
  584.             sw.Start();
  585.         }
  587.         vector<int> data;
  588.         data.push_back(version);
  590.         _ASSERT(data.size() == 1);
  592.         m_OldIdCache->Store(seqref.GetSatKey(), seqref.GetSat(), data);
  594.         if ( CollectStatistics() ) {
  595.             double time = sw.Elapsed();
  596.             LogStat("CId1Cache: saved blob version", seqref.printTSE(), time);
  597.             resolve_ver_count++;
  598.             resolve_ver_time += time;
  599.         }
  600.     }
  601. }
  604. int CCachedId1Reader::ResolveSeq_id_to_gi(const CSeq_id& id, TConn conn)
  605. {
  606.     if ( m_IdCache ) {
  607.         int gi = 0;
  608.         string key = GetIdKey(id);
  609.         string subkey = GetGiSubkey();
  610.         if ( !x_GetIdCache(key, subkey, gi) ) {
  611.             gi = CId1Reader::ResolveSeq_id_to_gi(id, conn);
  612.             x_StoreIdCache(key, subkey, gi);
  613.         }
  614.         return gi;
  615.     }
  616.     else {
  617.         return CId1Reader::ResolveSeq_id_to_gi(id, conn);
  618.     }
  619. }
  622. void CCachedId1Reader::RetrieveSeqrefs(TSeqrefs& srs, int gi, TConn conn)
  623. {
  624.     if ( !GetSeqrefs(gi, srs) ) {
  625.         CId1Reader::RetrieveSeqrefs(srs, gi, conn);
  626.         StoreSeqrefs(gi, srs);
  627.     }
  628. }
  631. void CCachedId1Reader::GetTSEChunk(const CSeqref& seqref,
  632.                                    CTSE_Chunk_Info& chunk_info,
  633.                                    TConn /*conn*/)
  634. {
  635.     if ( m_BlobCache ) {
  636.         CID2_Reply_Data chunk_data;
  637.         string key = GetBlobKey(seqref);
  638.         string subkey = GetChunkSubkey(chunk_info.GetChunkId());
  639.         if ( !LoadData(key, seqref.GetVersion(), subkey.c_str(),
  640.                        chunk_data) ) {
  641.             NCBI_THROW(CLoaderException, eLoaderFailed,
  642.                        "CCachedId1Reader::GetTSEChunk: chunk is missing");
  643.         }
  644.         CRef<CID2S_Chunk> chunk(new CID2S_Chunk);
  645.         size_t size = 0;
  646.         {{
  647.             CRef<CByteSourceReader> reader = GetReader(chunk_data,
  648.                                                        eDataType_Chunk);
  649.             AutoPtr<CObjectIStream> in(OpenData(chunk_data, *reader));
  650.             CReader::SetSeqEntryReadHooks(*in);
  651.             *in >> *chunk;
  652.             size = in->GetStreamOffset();
  653.         }}
  654.         CSplitParser::Load(chunk_info, *chunk);
  655.     
  656.         // everything is fine
  657.     }
  658.     else if ( m_OldBlobCache ) {
  659.         CStopWatch sw;
  660.         if ( CollectStatistics() ) {
  661.             sw.Start();
  662.         }
  664.         CID2_Reply_Data chunk_data;
  665.         string key = GetBlobKey(seqref);
  666.         string suffix = "-chunk-"+NStr::IntToString(chunk_info.GetChunkId());
  667.         if ( !LoadData(key, suffix.c_str(), seqref.GetVersion(),
  668.                        chunk_data) ) {
  669.             NCBI_THROW(CLoaderException, eLoaderFailed,
  670.                        "CCachedId1Reader::GetTSEChunk: chunk is missing");
  671.         }
  672.         CRef<CID2S_Chunk> chunk(new CID2S_Chunk);
  673.         size_t size = 0;
  674.         {{
  675.             CRef<CByteSourceReader> reader = GetReader(chunk_data,
  676.                                                        eDataType_Chunk);
  677.             AutoPtr<CObjectIStream> in(OpenData(chunk_data, *reader));
  678.             CReader::SetSeqEntryReadHooks(*in);
  679.             *in >> *chunk;
  680.             size = in->GetStreamOffset();
  681.         }}
  682.         CSplitParser::Load(chunk_info, *chunk);
  683.     
  684.         // everything is fine
  685.         if ( CollectStatistics() ) {
  686.             double time = sw.Elapsed();
  687.             LogBlobStat("CId1Cache: read chunk", seqref, size, time);
  688.             chunk_blob_count++;
  689.             chunk_bytes += size;
  690.             chunk_time += time;
  691.         }
  692.     }
  693.     else {
  694.     }
  695. }
  698. int CCachedId1Reader::x_GetVersion(const CSeqref& seqref, TConn conn)
  699. {
  700.     int version = GetBlobVersion(seqref);
  701.     if ( version == 0 ) {
  702.         version = CId1Reader::x_GetVersion(seqref, conn);
  703.         _ASSERT(version != 0);
  704.         StoreBlobVersion(seqref, version);
  705.     }
  706.     return version;
  707. }
  710. void CCachedId1Reader::x_GetTSEBlob(CID1server_back& id1_reply,
  711.                                     CRef<CID2S_Split_Info>& split_info,
  712.                                     const CSeqref& seqref,
  713.                                     TConn conn)
  714. {
  715.     // update seqref's version
  716.     GetVersion(seqref, conn);
  717.     if ( !LoadBlob(id1_reply, split_info, seqref) ) {
  718.         // we'll intercept loading deeper and write loaded data on the fly
  719.         CId1Reader::x_GetTSEBlob(id1_reply, split_info, seqref, conn);
  720.     }
  721. }
  724. void CCachedId1Reader::x_ReadTSEBlob(CID1server_back& id1_reply,
  725.                                      const CSeqref& seqref,
  726.                                      CNcbiIstream& stream)
  727. {
  728.     if ( m_BlobCache ) {
  729.         string key = GetBlobKey(seqref);
  730.         int ver = seqref.GetVersion();
  731.         string subkey = GetSeqEntrySubkey();
  733.         try {
  734.             auto_ptr<IWriter> writer(
  735.                 m_BlobCache->GetWriteStream(key, ver, subkey));
  736.             
  737.             if ( writer.get() ) {
  738.                 {{
  739.                     CWriterByteSourceReader proxy(&stream, writer.get());
  740.                     
  741.                     CObjectIStreamAsnBinary obj_stream(proxy);
  742.                     
  743.                     CStreamDelayBufferGuard guard(obj_stream);
  744.                     
  745.                     CId1Reader::x_ReadTSEBlob(id1_reply, obj_stream);
  746.                 }}
  748.                 writer->Flush();
  750.                 // everything is fine
  751.                 return;
  752.             }
  753.         }
  754.         catch ( ... ) {
  755.             // In case of an error we need to remove incomplete BLOB
  756.             // from the cache.
  757.             try {
  758.                 m_BlobCache->Remove(key);
  759.             }
  760.             catch ( exception& /*exc*/ ) {
  761.                 // ignored
  762.             }
  764.             // continue with exception
  765.             throw;
  766.         }
  767.     }
  768.     else if ( m_OldBlobCache ) {
  769.         string key = GetBlobKey(seqref);
  770.         int version = seqref.GetVersion();
  772.         try {
  773.             auto_ptr<IWriter> writer(m_OldBlobCache->GetWriteStream(key,
  774.                                                                     version));
  775.             
  776.             if ( writer.get() ) {
  777.                 {{
  778.                     CWriterByteSourceReader proxy(&stream, writer.get());
  779.                     
  780.                     CObjectIStreamAsnBinary obj_stream(proxy);
  781.                     
  782.                     CStreamDelayBufferGuard guard(obj_stream);
  783.                     
  784.                     CId1Reader::x_ReadTSEBlob(id1_reply, obj_stream);
  785.                 }}
  787.                 writer->Flush();
  788.                 writer.reset();
  789.                 // everything is fine
  790.                 return;
  791.             }
  792.         }
  793.         catch ( ... ) {
  794.             // In case of an error we need to remove incomplete BLOB
  795.             // from the cache.
  796.             try {
  797.                 m_OldBlobCache->Remove(key);
  798.             }
  799.             catch ( exception& /*exc*/ ) {
  800.                 // ignored
  801.             }
  803.             // continue with exception
  804.             throw;
  805.         }
  806.     }
  807.     // by deault read from ID1
  808.     CId1Reader::x_ReadTSEBlob(id1_reply, seqref, stream);
  809. }
  812. void CCachedId1Reader::x_GetSNPAnnot(CSeq_annot_SNP_Info& snp_info,
  813.                                      const CSeqref& seqref,
  814.                                      TConn conn)
  815. {
  816.     // update seqref's version
  817.     GetVersion(seqref, conn);
  818.     if ( !LoadSNPTable(snp_info, seqref) ) {
  819.         snp_info.Reset();
  820.         // load SNP table from GenBank
  821.         CId1Reader::x_GetSNPAnnot(snp_info, seqref, conn);
  823.         // and store SNP table in cache
  824.         StoreSNPTable(snp_info, seqref);
  825.     }
  826. }
  829. bool CCachedId1Reader::LoadBlob(CID1server_back& id1_reply,
  830.                                 CRef<CID2S_Split_Info>& split_info,
  831.                                 const CSeqref& seqref)
  832. {
  833.     return LoadSplitBlob(id1_reply, split_info, seqref) ||
  834.         LoadWholeBlob(id1_reply, seqref);
  835. }
  838. bool CCachedId1Reader::LoadWholeBlob(CID1server_back& id1_reply,
  839.                                      const CSeqref& seqref)
  840. {
  841.     if ( m_BlobCache ) {
  842.         string key = GetBlobKey(seqref);
  843.         int ver = seqref.GetVersion();
  844.         string subkey = GetSeqEntrySubkey();
  846.         CStopWatch sw;
  847.         if ( CollectStatistics() ) {
  848.             sw.Start();
  849.         }
  850.         try {
  851.             auto_ptr<IReader> reader(
  852.                 m_BlobCache->GetReadStream(key, ver, subkey));
  853.             if ( !reader.get() ) {
  854.                 return false;
  855.             }
  857.             CIRByteSourceReader rd(reader.get());
  858.         
  859.             CObjectIStreamAsnBinary in(rd);
  860.         
  861.             CReader::SetSeqEntryReadHooks(in);
  862.             in >> id1_reply;
  863.         
  864.             // everything is fine
  865.             if ( CollectStatistics() ) {
  866.                 double time = sw.Elapsed();
  867.                 size_t size = in.GetStreamOffset();
  868.                 LogBlobStat("CId1Cache: read blob", seqref, size, time);
  869.                 main_blob_count++;
  870.                 main_bytes += size;
  871.                 main_time += time;
  872.             }
  874.             return true;
  875.         }
  876.         catch ( exception& exc ) {
  877.             ERR_POST("CId1Cache: Exception while loading cached blob: " <<
  878.                      seqref.printTSE() << ": " << exc.what());
  880.             if ( CollectStatistics() ) {
  881.                 double time = sw.Elapsed();
  882.                 LogBlobStat("CId1Cache: read fail blob",
  883.                             seqref, 0, time);
  884.                 main_blob_count++;
  885.                 main_time += time;
  886.             }
  888.             return false;
  889.         }
  890.     }
  891.     else if ( m_OldBlobCache ) {
  892.         string key = GetBlobKey(seqref);
  893.         int ver = seqref.GetVersion();
  895.         CStopWatch sw;
  896.         if ( CollectStatistics() ) {
  897.             sw.Start();
  898.         }
  899.         try {
  900.             auto_ptr<IReader> reader(m_OldBlobCache->GetReadStream(key, ver));
  901.             if ( !reader.get() ) {
  902.                 return false;
  903.             }
  905.             CIRByteSourceReader rd(reader.get());
  906.         
  907.             CObjectIStreamAsnBinary in(rd);
  908.         
  909.             CReader::SetSeqEntryReadHooks(in);
  910.             in >> id1_reply;
  911.         
  912.             // everything is fine
  913.             if ( CollectStatistics() ) {
  914.                 double time = sw.Elapsed();
  915.                 size_t size = in.GetStreamOffset();
  916.                 LogBlobStat("CId1Cache: read blob", seqref, size, time);
  917.                 main_blob_count++;
  918.                 main_bytes += size;
  919.                 main_time += time;
  920.             }
  922.             return true;
  923.         }
  924.         catch ( exception& exc ) {
  925.             ERR_POST("CId1Cache: Exception while loading cached blob: " <<
  926.                      seqref.printTSE() << ": " << exc.what());
  928.             if ( CollectStatistics() ) {
  929.                 double time = sw.Elapsed();
  930.                 LogBlobStat("CId1Cache: read fail blob",
  931.                             seqref, 0, time);
  932.                 main_blob_count++;
  933.                 main_time += time;
  934.             }
  936.             return false;
  937.         }
  938.     }
  939.     else {
  940.         return false;
  941.     }
  942. }
  945. bool CCachedId1Reader::LoadSplitBlob(CID1server_back& id1_reply,
  946.                                      CRef<CID2S_Split_Info>& split_info,
  947.                                      const CSeqref& seqref)
  948. {
  949.     if ( m_BlobCache ) {
  950.         string key = GetBlobKey(seqref);
  951.         int ver = seqref.GetVersion();
  953.         try {
  954.             CID2_Reply_Data main_data, split_data;
  955.             if ( !LoadData(key, ver, GetSkeletonSubkey(), main_data) ||
  956.                  !LoadData(key, ver, GetSplitInfoSubkey(), split_data) ) {
  957.                 return false;
  958.             }
  959.             size_t size = 0;
  960.             CRef<CSeq_entry> main(new CSeq_entry);
  961.             {{
  962.                 CRef<CByteSourceReader> reader(GetReader(main_data,
  963.                                                          eDataType_MainBlob));
  964.                 AutoPtr<CObjectIStream> in(OpenData(main_data, *reader));
  965.                 CReader::SetSeqEntryReadHooks(*in);
  966.                 *in >> *main;
  967.                 size += in->GetStreamOffset();
  968.             }}
  969.             CRef<CID2S_Split_Info> split(new CID2S_Split_Info);
  970.             {{
  971.                 CRef<CByteSourceReader> reader(GetReader(split_data,
  972.                                                          eDataType_SplitInfo));
  973.                 AutoPtr<CObjectIStream> in(OpenData(split_data, *reader));
  974.                 CReader::SetSeqEntryReadHooks(*in);
  975.                 *in >> *split;
  976.                 size += in->GetStreamOffset();
  977.             }}
  978.         
  979.             id1_reply.SetGotseqentry(*main);
  980.             split_info = split;
  982.             // everything is fine
  983.             return true;
  984.         }
  985.         catch ( exception& exc ) {
  986.             ERR_POST("CId1Cache: Exception while loading cached blob: " <<
  987.                      seqref.printTSE() << ": " << exc.what());
  988.             return false;
  989.         }
  990.         return false;
  991.     }
  992.     else if ( m_OldBlobCache ) {
  993.         string key = GetBlobKey(seqref);
  994.         int ver = seqref.GetVersion();
  996.         CStopWatch sw;
  997.         if ( CollectStatistics() ) {
  998.             sw.Start();
  999.         }
  1000.         try {
  1001.             CID2_Reply_Data main_data, split_data;
  1002.             if ( !LoadData(key, "-main", ver, main_data) ||
  1003.                  !LoadData(key, "-split", ver, split_data) ) {
  1004.                 return false;
  1005.             }
  1006.             size_t size = 0;
  1007.             CRef<CSeq_entry> main(new CSeq_entry);
  1008.             {{
  1009.                 CRef<CByteSourceReader> reader(GetReader(main_data,
  1010.                                                          eDataType_MainBlob));
  1011.                 AutoPtr<CObjectIStream> in(OpenData(main_data, *reader));
  1012.                 CReader::SetSeqEntryReadHooks(*in);
  1013.                 *in >> *main;
  1014.                 size += in->GetStreamOffset();
  1015.             }}
  1016.             CRef<CID2S_Split_Info> split(new CID2S_Split_Info);
  1017.             {{
  1018.                 CRef<CByteSourceReader> reader(GetReader(split_data,
  1019.                                                          eDataType_SplitInfo));
  1020.                 AutoPtr<CObjectIStream> in(OpenData(split_data, *reader));
  1021.                 CReader::SetSeqEntryReadHooks(*in);
  1022.                 *in >> *split;
  1023.                 size += in->GetStreamOffset();
  1024.             }}
  1025.         
  1026.             id1_reply.SetGotseqentry(*main);
  1027.             split_info = split;
  1029.             // everything is fine
  1030.             if ( CollectStatistics() ) {
  1031.                 double time = sw.Elapsed();
  1032.                 LogBlobStat("CId1Cache: read blob", seqref, size, time);
  1033.                 main_blob_count++;
  1034.                 main_bytes += size;
  1035.                 main_time += time;
  1036.             }
  1037.         
  1038.             return true;
  1039.         }
  1040.         catch ( exception& exc ) {
  1041.             ERR_POST("CId1Cache: Exception while loading cached blob: " <<
  1042.                      seqref.printTSE() << ": " << exc.what());
  1044.             if ( CollectStatistics() ) {
  1045.                 double time = sw.Elapsed();
  1046.                 LogBlobStat("CId1Cache: read fail blob",
  1047.                             seqref, 0, time);
  1048.                 main_blob_count++;
  1049.                 main_time += time;
  1050.             }
  1052.             return false;
  1053.         }
  1054.     }
  1055.     else {
  1056.         return false;
  1057.     }
  1058. }
  1061. bool CCachedId1Reader::LoadSNPTable(CSeq_annot_SNP_Info& snp_info,
  1062.                                     const CSeqref& seqref)
  1063. {
  1064.     if ( m_BlobCache ) {
  1065.         string key = GetBlobKey(seqref);
  1066.         int ver = seqref.GetVersion();
  1067.         string subkey = GetSNPTableSubkey();
  1069.         CStopWatch sw;
  1070.         if ( CollectStatistics() ) {
  1071.             sw.Start();
  1072.         }
  1073.         try {
  1074.             auto_ptr<IReader> reader(
  1075.                 m_BlobCache->GetReadStream(key, ver, subkey));
  1076.             if ( !reader.get() ) {
  1077.                 return false;
  1078.             }
  1079.             CRStream stream(reader.get());
  1081.             // table
  1082.             CSeq_annot_SNP_Info_Reader::Read(stream, snp_info);
  1084.             if ( CollectStatistics() ) {
  1085.                 double time = sw.Elapsed();
  1086.                 size_t size = m_BlobCache->GetSize(key, ver, subkey);
  1087.                 LogBlobStat("CId1Cache: read SNP blob",
  1088.                             seqref, size, time);
  1089.                 snp_load_count++;
  1090.                 snp_load_bytes += size;
  1091.                 snp_load_time += time;
  1092.             }
  1094.             return true;
  1095.         }
  1096.         catch ( exception& exc ) {
  1097.             ERR_POST("CId1Cache: "
  1098.                      "Exception while loading cached SNP table: "<<
  1099.                      seqref.printTSE() << ": " << exc.what());
  1100.             snp_info.Reset();
  1102.             if ( CollectStatistics() ) {
  1103.                 double time = sw.Elapsed();
  1104.                 LogBlobStat("CId1Cache: read fail SNP blob",
  1105.                             seqref, 0, time);
  1106.                 snp_load_count++;
  1107.                 snp_load_time += time;
  1108.             }
  1110.             return false;
  1111.         }
  1112.     }
  1113.     else if ( m_OldBlobCache ) {
  1114.         string key = GetBlobKey(seqref);
  1115.         int ver = seqref.GetVersion();
  1117.         CStopWatch sw;
  1118.         if ( CollectStatistics() ) {
  1119.             sw.Start();
  1120.         }
  1121.         try {
  1122.             auto_ptr<IReader> reader(m_OldBlobCache->GetReadStream(key, ver));
  1123.             if ( !reader.get() ) {
  1124.                 return false;
  1125.             }
  1126.             CRStream stream(reader.get());
  1128.             // blob type
  1129.             char type[4];
  1130.             if ( !stream.read(type, 4) || memcmp(type, "STBL", 4) != 0 ) {
  1131.                 if ( CollectStatistics() ) {
  1132.                     double time = sw.Elapsed();
  1133.                     LogBlobStat("CId1Cache: read fail SNP blob",
  1134.                                 seqref, 0, time);
  1135.                     snp_load_count++;
  1136.                     snp_load_time += time;
  1137.                 }
  1139.                 return false;
  1140.             }
  1142.             // table
  1143.             CSeq_annot_SNP_Info_Reader::Read(stream, snp_info);
  1145.             if ( CollectStatistics() ) {
  1146.                 double time = sw.Elapsed();
  1147.                 size_t size = m_OldBlobCache->GetSize(key, ver);
  1148.                 LogBlobStat("CId1Cache: read SNP blob",
  1149.                             seqref, size, time);
  1150.                 snp_load_count++;
  1151.                 snp_load_bytes += size;
  1152.                 snp_load_time += time;
  1153.             }
  1155.             return true;
  1156.         }
  1157.         catch ( exception& exc ) {
  1158.             ERR_POST("CId1Cache: "
  1159.                      "Exception while loading cached SNP table: "<<
  1160.                      seqref.printTSE() << ": " << exc.what());
  1161.             snp_info.Reset();
  1163.             if ( CollectStatistics() ) {
  1164.                 double time = sw.Elapsed();
  1165.                 LogBlobStat("CId1Cache: read fail SNP blob",
  1166.                             seqref, 0, time);
  1167.                 snp_load_count++;
  1168.                 snp_load_time += time;
  1169.             }
  1171.             return false;
  1172.         }
  1173.     }
  1174.     else {
  1175.         return false;
  1176.     }
  1177. }
  1180. void CCachedId1Reader::StoreSNPTable(const CSeq_annot_SNP_Info& snp_info,
  1181.                                      const CSeqref& seqref)
  1182. {
  1183.     if ( m_BlobCache ) {
  1184.         string key = GetBlobKey(seqref);
  1185.         int ver = seqref.GetVersion();
  1186.         string subkey = GetSNPTableSubkey();
  1188.         CStopWatch sw;
  1189.         if ( CollectStatistics() ) {
  1190.             sw.Start();
  1191.         }
  1192.         try {
  1193.             {{
  1194.                 auto_ptr<IWriter> writer;
  1195.                 writer.reset(m_BlobCache->GetWriteStream(key, ver, subkey));
  1196.                 if ( !writer.get() ) {
  1197.                     return;
  1198.                 }
  1200.                 {{
  1201.                     CWStream stream(writer.get());
  1202.                     CSeq_annot_SNP_Info_Reader::Write(stream, snp_info);
  1203.                 }}
  1204.                 writer->Flush();
  1205.                 writer.reset();
  1206.             }}
  1208.             if ( CollectStatistics() ) {
  1209.                 double time = sw.Elapsed();
  1210.                 size_t size = m_BlobCache->GetSize(key, ver, subkey);
  1211.                 LogBlobStat("CId1Cache: saved SNP blob",
  1212.                             seqref, size, time);
  1213.                 snp_store_count++;
  1214.                 snp_store_bytes += size;
  1215.                 snp_store_time += time;
  1216.             }
  1217.         }
  1218.         catch ( exception& exc ) {
  1219.             ERR_POST("CId1Cache: "
  1220.                      "Exception while storing SNP table: "<<
  1221.                      seqref.printTSE() << ": " << exc.what());
  1222.             try {
  1223.                 m_BlobCache->Remove(key);
  1224.             }
  1225.             catch ( exception& /*exc*/ ) {
  1226.                 // ignored
  1227.             }
  1229.             if ( CollectStatistics() ) {
  1230.                 double time = sw.Elapsed();
  1231.                 LogBlobStat("CId1Cache: save fail SNP blob",
  1232.                             seqref, 0, time);
  1233.                 snp_store_count++;
  1234.                 snp_store_time += time;
  1235.             }
  1236.         }
  1237.     }
  1238.     else if ( m_OldBlobCache ) {
  1239.         string key = GetBlobKey(seqref);
  1240.         int ver = seqref.GetVersion();
  1242.         CStopWatch sw;
  1243.         if ( CollectStatistics() ) {
  1244.             sw.Start();
  1245.         }
  1246.         try {
  1247.             {{
  1248.                 auto_ptr<IWriter> writer;
  1249.                 writer.reset(m_OldBlobCache->GetWriteStream(key, ver));
  1250.                 if ( !writer.get() ) {
  1251.                     return;
  1252.                 }
  1254.                 {{
  1255.                     CWStream stream(writer.get());
  1256.                     stream.write("STBL", 4);
  1257.                     CSeq_annot_SNP_Info_Reader::Write(stream, snp_info);
  1258.                 }}
  1259.                 writer->Flush();
  1260.                 writer.reset();
  1261.             }}
  1263.             if ( CollectStatistics() ) {
  1264.                 double time = sw.Elapsed();
  1265.                 size_t size = m_OldBlobCache->GetSize(key, ver);
  1266.                 LogBlobStat("CId1Cache: saved SNP blob",
  1267.                             seqref, size, time);
  1268.                 snp_store_count++;
  1269.                 snp_store_bytes += size;
  1270.                 snp_store_time += time;
  1271.             }
  1272.         }        
  1273.         catch ( exception& exc ) {
  1274.             ERR_POST("CId1Cache: "
  1275.                      "Exception while storing SNP table: "<<
  1276.                      seqref.printTSE() << ": " << exc.what());
  1277.             try {
  1278.                 m_OldBlobCache->Remove(key);
  1279.             }
  1280.             catch ( exception& /*exc*/ ) {
  1281.                 // ignored
  1282.             }
  1284.             if ( CollectStatistics() ) {
  1285.                 double time = sw.Elapsed();
  1286.                 LogBlobStat("CId1Cache: save fail SNP blob",
  1287.                             seqref, 0, time);
  1288.                 snp_store_count++;
  1289.                 snp_store_time += time;
  1290.             }
  1291.         }
  1292.     }
  1293. }
  1296. bool CCachedId1Reader::LoadData(const string& key, int version,
  1297.                                 const char* suffix,
  1298.                                 CID2_Reply_Data& data)
  1299. {
  1300.     AutoPtr<IReader> reader(m_BlobCache->GetReadStream(key, version, suffix));
  1301.     if ( !reader.get() ) {
  1302.         return false;
  1303.     }
  1304.     
  1305.     CIRByteSourceReader rd(reader.get());
  1306.     
  1307.     CObjectIStreamAsnBinary in(rd);
  1308.     
  1309.     in >> data;
  1311.     return true;
  1312. }
  1315. bool CCachedId1Reader::LoadData(const string& key, const char* suffix,
  1316.                                 int version, CID2_Reply_Data& data)
  1317. {
  1318.     AutoPtr<IReader> reader(m_OldBlobCache->GetReadStream(key + suffix,
  1319.                                                           version));
  1320.     if ( !reader.get() ) {
  1321.         return false;
  1322.     }
  1323.     
  1324.     CIRByteSourceReader rd(reader.get());
  1325.     
  1326.     CObjectIStreamAsnBinary in(rd);
  1327.     
  1328.     in >> data;
  1330.     return true;
  1331. }
  1334. class CVectorListReader : public CByteSourceReader
  1335. {
  1336. public:
  1337.     typedef list< vector< char >* > TData;
  1339.     CVectorListReader(const TData& data)
  1340.         : m_Data(data),
  1341.           m_CurrentIter(data.begin()),
  1342.           m_CurrentOffset(0)
  1343.         {
  1344.         }
  1346.     size_t Read(char* buffer, size_t bufferLength)
  1347.         {
  1348.             while ( m_CurrentIter != m_Data.end() ) {
  1349.                 const vector<char> curr = **m_CurrentIter;
  1350.                 if ( m_CurrentOffset < curr.size() ) {
  1351.                     size_t remaining = curr.size() - m_CurrentOffset;
  1352.                     size_t count = min(bufferLength, remaining);
  1353.                     memcpy(buffer, &curr[m_CurrentOffset], count);
  1354.                     m_CurrentOffset += count;
  1355.                     return count;
  1356.                 }
  1357.                 ++m_CurrentIter;
  1358.                 m_CurrentOffset = 0;
  1359.             }
  1360.             return 0;
  1361.         }
  1362.     
  1363. private:
  1364.     const TData& m_Data;
  1365.     TData::const_iterator m_CurrentIter;
  1366.     size_t m_CurrentOffset;
  1367. };
  1370. CRef<CByteSourceReader> CCachedId1Reader::GetReader(CID2_Reply_Data& data,
  1371.                                                     EDataType data_type)
  1372. {
  1373.     CRef<CByteSourceReader> ret;
  1374.     if ( data.GetData_type() != data_type ) {
  1375.         return ret;
  1376.     }
  1377.     ret.Reset(new CVectorListReader(data.GetData()));
  1378.     switch ( data.GetData_compression() ) {
  1379.     case eCompression_none:
  1380.         break;
  1381.     case eCompression_nlm_zip:
  1382.         ret.Reset(new CNlmZipBtRdr(ret.GetPointer()));
  1383.         break;
  1384.     default:
  1385.         NCBI_THROW(CLoaderException, eLoaderFailed,
  1386.                    "unknown compression");
  1387.     }
  1388.     return ret;
  1389. }
  1392. AutoPtr<CObjectIStream> CCachedId1Reader::OpenData(CID2_Reply_Data& data,
  1393.                                                    CByteSourceReader& reader)
  1394. {
  1395.     if ( data.GetData_format() != eSerial_AsnBinary ) {
  1396.         NCBI_THROW(CLoaderException, eLoaderFailed,
  1397.                    "unknown serial format");
  1398.     }
  1399.     return new CObjectIStreamAsnBinary(reader);
  1400. }
  1403. END_SCOPE(objects)
  1404. END_NCBI_SCOPE
  1407. /*
  1408.  * $Log: reader_id1_cache.cpp,v $
  1409.  * Revision 1000.2  2004/06/01 19:41:59  gouriano
  1410.  * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.25
  1411.  *
  1412.  * Revision 1.25  2004/05/21 21:42:52  gorelenk
  1413.  * Added PCH ncbi_pch.hpp
  1414.  *
  1415.  * Revision 1.24  2004/04/28 17:06:25  vasilche
  1416.  * Load split blobs from new ICache.
  1417.  *
  1418.  * Revision 1.23  2004/02/17 21:20:11  vasilche
  1419.  * Fixed 'unused argument' warning.
  1420.  *
  1421.  * Revision 1.22  2004/01/22 20:53:31  vasilche
  1422.  * Fixed include path.
  1423.  *
  1424.  * Revision 1.21  2004/01/22 20:10:37  vasilche
  1425.  * 1. Splitted ID2 specs to two parts.
  1426.  * ID2 now specifies only protocol.
  1427.  * Specification of ID2 split data is moved to seqsplit ASN module.
  1428.  * For now they are still reside in one resulting library as before - libid2.
  1429.  * As the result split specific headers are now in objects/seqsplit.
  1430.  * 2. Moved ID2 and ID1 specific code out of object manager.
  1431.  * Protocol is processed by corresponding readers.
  1432.  * ID2 split parsing is processed by ncbi_xreader library - used by all readers.
  1433.  * 3. Updated OBJMGR_LIBS correspondingly.
  1434.  *
  1435.  * Revision 1.20  2004/01/20 16:56:04  vasilche
  1436.  * Allow storing version of any blob (not only SNP).
  1437.  *
  1438.  * Revision 1.19  2004/01/13 21:54:50  vasilche
  1439.  * Requrrected new version
  1440.  *
  1441.  * Revision 1.5  2004/01/13 16:55:56  vasilche
  1442.  * CReader, CSeqref and some more classes moved from xobjmgr to separate lib.
  1443.  * Headers moved from include/objmgr to include/objtools/data_loaders/genbank.
  1444.  *
  1445.  * Revision 1.4  2003/12/30 22:14:42  vasilche
  1446.  * Updated genbank loader and readers plugins.
  1447.  *
  1448.  * Revision 1.17  2003/12/30 16:00:25  vasilche
  1449.  * Added support for new ICache (CBDB_Cache) interface.
  1450.  *
  1451.  * Revision 1.16  2003/12/09 17:30:32  ucko
  1452.  * +<stdio.h> for sprintf
  1453.  *
  1454.  * Revision 1.15  2003/11/26 17:55:59  vasilche
  1455.  * Implemented ID2 split in ID1 cache.
  1456.  * Fixed loading of splitted annotations.
  1457.  *
  1458.  * Revision 1.14  2003/10/27 15:05:41  vasilche
  1459.  * Added correct recovery of cached ID1 loader if gi->sat/satkey cache is invalid.
  1460.  * Added recognition of ID1 error codes: private, etc.
  1461.  * Some formatting of old code.
  1462.  *
  1463.  * Revision 1.13  2003/10/24 15:36:46  vasilche
  1464.  * Fixed incorrect order of objects' destruction - IWriter before object stream.
  1465.  *
  1466.  * Revision 1.12  2003/10/24 13:27:40  vasilche
  1467.  * Cached ID1 reader made more safe. Process errors and exceptions correctly.
  1468.  * Cleaned statistics printing methods.
  1469.  *
  1470.  * Revision 1.11  2003/10/23 13:48:38  vasilche
  1471.  * Use CRStream and CWStream instead of strstreams.
  1472.  *
  1473.  * Revision 1.10  2003/10/21 16:32:50  vasilche
  1474.  * Cleaned ID1 statistics messages.
  1475.  * Now by setting GENBANK_ID1_STATS=1 CId1Reader collects and displays stats.
  1476.  * And by setting GENBANK_ID1_STATS=2 CId1Reader logs all activities.
  1477.  *
  1478.  * Revision 1.9  2003/10/21 14:27:35  vasilche
  1479.  * Added caching of gi -> sat,satkey,version resolution.
  1480.  * SNP blobs are stored in cache in preprocessed format (platform dependent).
  1481.  * Limit number of connections to GenBank servers.
  1482.  * Added collection of ID1 loader statistics.
  1483.  *
  1484.  * Revision 1.8  2003/10/14 21:06:25  vasilche
  1485.  * Fixed compression statistics.
  1486.  * Disabled caching of SNP blobs.
  1487.  *
  1488.  * Revision 1.7  2003/10/14 19:31:18  kuznets
  1489.  * Removed unnecessary hook in SNP deserialization.
  1490.  *
  1491.  * Revision 1.6  2003/10/14 18:31:55  vasilche
  1492.  * Added caching support for SNP blobs.
  1493.  * Added statistics collection of ID1 connection.
  1494.  *
  1495.  * Revision 1.5  2003/10/08 18:58:23  kuznets
  1496.  * Implemented correct ID1 BLOB versions
  1497.  *
  1498.  * Revision 1.4  2003/10/03 17:41:44  kuznets
  1499.  * Added an option, that cache is owned by the ID1 reader.
  1500.  *
  1501.  * Revision 1.3  2003/10/02 19:29:14  kuznets
  1502.  * First working revision
  1503.  *
  1504.  * Revision 1.2  2003/10/01 19:32:22  kuznets
  1505.  * Work in progress
  1506.  *
  1507.  * Revision 1.1  2003/09/30 19:38:26  vasilche
  1508.  * Added support for cached id1 reader.
  1509.  *
  1510.  */