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

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

生物技术

开发平台：

C/C++

seq_vector_ci.cpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: seq_vector_ci.cpp,v $
  4.  * PRODUCTION Revision 1000.3  2004/06/01 19:24:26  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.34
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. /*  $Id: seq_vector_ci.cpp,v 1000.3 2004/06/01 19:24:26 gouriano Exp $
  11. * ===========================================================================
  12. *
  13. *                            PUBLIC DOMAIN NOTICE
  14. *               National Center for Biotechnology Information
  15. *
  16. *  This software/database is a "United States Government Work" under the
  17. *  terms of the United States Copyright Act.  It was written as part of
  18. *  the author's official duties as a United States Government employee and
  19. *  thus cannot be copyrighted.  This software/database is freely available
  20. *  to the public for use. The National Library of Medicine and the U.S.
  21. *  Government have not placed any restriction on its use or reproduction.
  22. *
  23. *  Although all reasonable efforts have been taken to ensure the accuracy
  24. *  and reliability of the software and data, the NLM and the U.S.
  25. *  Government do not and cannot warrant the performance or results that
  26. *  may be obtained by using this software or data. The NLM and the U.S.
  27. *  Government disclaim all warranties, express or implied, including
  28. *  warranties of performance, merchantability or fitness for any particular
  29. *  purpose.
  30. *
  31. *  Please cite the author in any work or product based on this material.
  32. *
  33. * ===========================================================================
  34. *
  35. * Author: Aleksey Grichenko, Eugene Vasilchenko
  36. *
  37. * File Description:
  38. *   Seq-vector iterator
  39. *
  40. */
  43. #include <ncbi_pch.hpp>
  44. #include <objmgr/seq_vector.hpp>
  45. #include <objmgr/seq_vector_ci.hpp>
  46. #include <objects/seq/NCBI8aa.hpp>
  47. #include <objects/seq/NCBIpaa.hpp>
  48. #include <objects/seq/NCBIstdaa.hpp>
  49. #include <objects/seq/NCBIeaa.hpp>
  50. #include <objects/seq/NCBIpna.hpp>
  51. #include <objects/seq/NCBI8na.hpp>
  52. #include <objects/seq/NCBI4na.hpp>
  53. #include <objects/seq/NCBI2na.hpp>
  54. #include <objects/seq/IUPACaa.hpp>
  55. #include <objects/seq/IUPACna.hpp>
  56. #include <algorithm>
  57. #include <objmgr/impl/seq_vector_cvt.hpp>
  58. #include <objmgr/objmgr_exception.hpp>
  59. #include <util/random_gen.hpp>
  61. BEGIN_NCBI_SCOPE
  62. BEGIN_SCOPE(objects)
  65. // Internal class to put random bases in place of ambiguities
  67. const size_t kRandomizerPosMask = 0x3f;
  68. const size_t kRandomDataSize    = kRandomizerPosMask + 1;
  70. class CNcbi2naRandomizer : public CObject
  71. {
  72. public:
  73.     // If seed == 0 then use random number for seed
  74.     CNcbi2naRandomizer(CRandom& gen);
  75.     ~CNcbi2naRandomizer(void);
  77.     typedef char* TData;
  79.     void RandomizeData(TData data,    // cache to be randomized
  80.                        size_t count,  // number of bases in the cache
  81.                        TSeqPos pos);  // sequence pos of the cache
  83. private:
  84.     CNcbi2naRandomizer(const CNcbi2naRandomizer&);
  85.     CNcbi2naRandomizer& operator=(const CNcbi2naRandomizer&);
  87.     // First value in each row indicates ambiguity (1) or
  88.     // normal base (0)
  89.     typedef char        TRandomData[kRandomDataSize + 1];
  90.     typedef TRandomData TRandomTable[16];
  92.     TRandomTable m_RandomTable;
  93. };
  96. CNcbi2naRandomizer::CNcbi2naRandomizer(CRandom& gen)
  97. {
  98.     unsigned int bases[4]; // Count of each base in the random distribution
  99.     for (int na4 = 0; na4 < 16; na4++) {
  100.         int bit_count = 0;
  101.         char set_bit = 0;
  102.         for (int bit = 0; bit < 4; bit++) {
  103.             // na4 == 0 is special case (gap) should be treated as 0xf
  104.             if ( !na4  ||  (na4 & (1 << bit)) ) {
  105.                 bit_count++;
  106.                 bases[bit] = 1;
  107.                 set_bit = bit;
  108.             }
  109.             else {
  110.                 bases[bit] = 0;
  111.             }
  112.         }
  113.         if (bit_count == 1) {
  114.             // Single base
  115.             m_RandomTable[na4][0] = 0;
  116.             m_RandomTable[na4][1] = set_bit;
  117.             continue;
  118.         }
  119.         // Ambiguity: create random distribution with possible bases
  120.         m_RandomTable[na4][0] = bit_count; // need any non-zero value
  121.         for (int bit = 0; bit < 4; bit++) {
  122.             bases[bit] *= kRandomDataSize/bit_count +
  123.                 kRandomDataSize % bit_count;
  124.         }
  125.         for (int i = kRandomDataSize - 1; i >= 0; i--) {
  126.             CRandom::TValue rnd = gen.GetRand(0, i);
  127.             for (int base = 0; base < 4; base++) {
  128.                 if (!bases[base]  ||  rnd > bases[base]) {
  129.                     rnd -= bases[base];
  130.                     continue;
  131.                 }
  132.                 m_RandomTable[na4][i + 1] = base;
  133.                 bases[base]--;
  134.                 break;
  135.             }
  136.         }
  137.     }
  138. }
  141. CNcbi2naRandomizer::~CNcbi2naRandomizer(void)
  142. {
  143.     return;
  144. }
  147. void CNcbi2naRandomizer::RandomizeData(TData data,
  148.                                        size_t count,
  149.                                        TSeqPos pos)
  150. {
  151.     for (TData stop = data + count; data < stop; ++data, ++pos) {
  152.         if ( m_RandomTable[(unsigned char)(*data)][0] ) {
  153.             // Ambiguity, use random value
  154.             *data = m_RandomTable[(unsigned char)(*data)]
  155.                 [(pos & kRandomizerPosMask) + 1];
  156.         }
  157.         else {
  158.             // Normal base
  159.             *data = m_RandomTable[(unsigned char)(*data)][1];
  160.         }
  161.     }
  162. }
  165. static const TSeqPos kCacheSize = 1024;
  167. template<class DstIter, class SrcCont>
  168. inline
  169. void copy_8bit_any(DstIter dst, size_t count,
  170.                    const SrcCont& srcCont, size_t srcPos,
  171.                    const char* table, bool reverse)
  172. {
  173.     size_t endPos = srcPos + count;
  174.     if ( endPos < srcPos || endPos > srcCont.size() ) {
  175.         NCBI_THROW(CSeqVectorException, eOutOfRange,
  176.                    "reference out of range of Seq-inst data");
  177.     }
  178.     if ( table ) {
  179.         if ( reverse ) {
  180.             copy_8bit_table_reverse(dst, count, srcCont, srcPos, table);
  181.         }
  182.         else {
  183.             copy_8bit_table(dst, count, srcCont, srcPos, table);
  184.         }
  185.     }
  186.     else {
  187.         if ( reverse ) {
  188.             copy_8bit_reverse(dst, count, srcCont, srcPos);
  189.         }
  190.         else {
  191.             copy_8bit(dst, count, srcCont, srcPos);
  192.         }
  193.     }
  194. }
  197. template<class DstIter, class SrcCont>
  198. inline
  199. void copy_4bit_any(DstIter dst, size_t count,
  200.                    const SrcCont& srcCont, size_t srcPos,
  201.                    const char* table, bool reverse)
  202. {
  203.     size_t endPos = srcPos + count;
  204.     if ( endPos < srcPos || endPos / 2 > srcCont.size() ) {
  205.         NCBI_THROW(CSeqVectorException, eOutOfRange,
  206.                    "reference out of range of Seq-inst data");
  207.     }
  208.     if ( table ) {
  209.         if ( reverse ) {
  210.             copy_4bit_table_reverse(dst, count, srcCont, srcPos, table);
  211.         }
  212.         else {
  213.             copy_4bit_table(dst, count, srcCont, srcPos, table);
  214.         }
  215.     }
  216.     else {
  217.         if ( reverse ) {
  218.             copy_4bit_reverse(dst, count, srcCont, srcPos);
  219.         }
  220.         else {
  221.             copy_4bit(dst, count, srcCont, srcPos);
  222.         }
  223.     }
  224. }
  227. template<class DstIter, class SrcCont>
  228. inline
  229. void copy_2bit_any(DstIter dst, size_t count,
  230.                    const SrcCont& srcCont, size_t srcPos,
  231.                    const char* table, bool reverse)
  232. {
  233.     size_t endPos = srcPos + count;
  234.     if ( endPos < srcPos || endPos / 4 > srcCont.size() ) {
  235.         NCBI_THROW(CSeqVectorException, eOutOfRange,
  236.                    "reference out of range of Seq-inst data");
  237.     }
  238.     if ( table ) {
  239.         if ( reverse ) {
  240.             copy_2bit_table_reverse(dst, count, srcCont, srcPos, table);
  241.         }
  242.         else {
  243.             copy_2bit_table(dst, count, srcCont, srcPos, table);
  244.         }
  245.     }
  246.     else {
  247.         if ( reverse ) {
  248.             copy_2bit_reverse(dst, count, srcCont, srcPos);
  249.         }
  250.         else {
  251.             copy_2bit(dst, count, srcCont, srcPos);
  252.         }
  253.     }
  254. }
  257. // CSeqVector_CI::
  260. CSeqVector_CI::CSeqVector_CI(void)
  261.     : m_Strand(eNa_strand_unknown),
  262.       m_Coding(CSeq_data::e_not_set),
  263.       m_Cache(0),
  264.       m_CachePos(0),
  265.       m_CacheData(0),
  266.       m_CacheEnd(0),
  267.       m_BackupPos(0),
  268.       m_BackupData(0),
  269.       m_BackupEnd(0)
  270. {
  271. }
  274. CSeqVector_CI::~CSeqVector_CI(void)
  275. {
  276.     x_DestroyCache();
  277. }
  280. CSeqVector_CI::CSeqVector_CI(const CSeqVector_CI& sv_it)
  281.     : m_Strand(eNa_strand_unknown),
  282.       m_Coding(CSeq_data::e_not_set),
  283.       m_Cache(0),
  284.       m_CachePos(0),
  285.       m_CacheData(0),
  286.       m_CacheEnd(0),
  287.       m_BackupPos(0),
  288.       m_BackupData(0),
  289.       m_BackupEnd(0),
  290.       m_Randomizer(sv_it.m_Randomizer)
  291. {
  292.     try {
  293.         *this = sv_it;
  294.     }
  295.     catch (...) {
  296.         x_DestroyCache();
  297.         throw;
  298.     }
  299. }
  302. CSeqVector_CI::CSeqVector_CI(const CSeqVector& seq_vector, TSeqPos pos)
  303.     : m_SeqMap(seq_vector.m_SeqMap),
  304.       m_Scope(seq_vector.m_Scope),
  305.       m_Strand(seq_vector.m_Strand),
  306.       m_Coding(seq_vector.m_Coding),
  307.       m_Cache(0),
  308.       m_CachePos(0),
  309.       m_CacheData(0),
  310.       m_CacheEnd(0),
  311.       m_BackupPos(0),
  312.       m_BackupData(0),
  313.       m_BackupEnd(0)
  314. {
  315.     try {
  316.         x_SetPos(pos);
  317.     }
  318.     catch (...) {
  319.         x_DestroyCache();
  320.         throw;
  321.     }
  322. }
  325. void CSeqVector_CI::x_SetVector(CSeqVector& seq_vector)
  326. {
  327.     if ( m_SeqMap ) {
  328.         // reset old values
  329.         m_Seg = CSeqMap_CI();
  330.         x_ResetCache();
  331.         x_ResetBackup();
  332.     }
  334.     m_SeqMap = seq_vector.m_SeqMap;
  335.     m_Scope  = seq_vector.m_Scope;
  336.     m_Strand = seq_vector.m_Strand;
  337.     m_Coding = seq_vector.m_Coding;
  338.     m_CachePos = seq_vector.size();
  339. }
  342. inline
  343. TSeqPos CSeqVector_CI::x_GetSize(void) const
  344. {
  345.     return m_SeqMap->GetLength(m_Scope.GetScopeOrNull());
  346. }
  349. inline
  350. void CSeqVector_CI::x_InitSeg(TSeqPos pos)
  351. {
  352.     m_Seg = m_SeqMap->FindResolved(pos, m_Scope.GetScopeOrNull(), m_Strand);
  353. }
  356. void CSeqVector_CI::SetCoding(TCoding coding)
  357. {
  358.     if ( m_Coding != coding ) {
  359.         TSeqPos pos = GetPos();
  360.         x_ResetCache();
  361.         x_ResetBackup();
  362.         m_Coding = coding;
  363.         x_SetPos(pos);
  364.     }
  365. }
  367. CSeqVector_CI& CSeqVector_CI::operator=(const CSeqVector_CI& sv_it)
  368. {
  369.     if ( this == &sv_it ) {
  370.         return *this;
  371.     }
  373.     m_Scope = sv_it.m_Scope;
  374.     m_SeqMap = sv_it.m_SeqMap;
  375.     m_Strand = sv_it.m_Strand;
  376.     m_Coding = sv_it.GetCoding();
  377.     m_Seg = sv_it.m_Seg;
  378.     m_CachePos = sv_it.x_CachePos();
  379.     m_Randomizer = sv_it.m_Randomizer;
  380.     // copy cache if any
  381.     size_t cache_size = sv_it.x_CacheSize();
  382.     if ( cache_size ) {
  383.         x_InitializeCache();
  384.         m_CacheEnd = m_CacheData + cache_size;
  385.         m_Cache = m_CacheData + sv_it.x_CacheOffset();
  386.         memcpy(m_CacheData, sv_it.m_CacheData, cache_size);
  388.         // copy backup cache if any
  389.         size_t backup_size = sv_it.x_BackupSize();
  390.         if ( backup_size ) {
  391.             m_BackupPos = sv_it.x_BackupPos();
  392.             m_BackupEnd = m_BackupData + backup_size;
  393.             memcpy(m_BackupData, sv_it.m_BackupData, backup_size);
  394.         }
  395.         else {
  396.             x_ResetBackup();
  397.         }
  398.     }
  399.     else {
  400.         x_ResetCache();
  401.         x_ResetBackup();
  402.     }
  403.     return *this;
  404. }
  407. void CSeqVector_CI::x_DestroyCache(void)
  408. {
  409.     m_CachePos = GetPos();
  411.     delete[] m_CacheData;
  412.     m_Cache = m_CacheData = m_CacheEnd = 0;
  414.     delete[] m_BackupData;
  415.     m_BackupData = m_BackupEnd = 0;
  416. }
  419. void CSeqVector_CI::x_InitializeCache(void)
  420. {
  421.     if ( !m_Cache ) {
  422.         m_Cache = m_CacheEnd = m_CacheData = new char[kCacheSize];
  423.         try {
  424.             m_BackupEnd = m_BackupData = new char[kCacheSize];
  425.         }
  426.         catch (...) {
  427.             x_DestroyCache();
  428.             throw;
  429.         }
  430.     }
  431.     else {
  432.         x_ResetCache();
  433.     }
  434. }
  437. inline
  438. void CSeqVector_CI::x_ResizeCache(size_t size)
  439. {
  440.     _ASSERT(size <= kCacheSize);
  441.     if ( !m_CacheData ) {
  442.         x_InitializeCache();
  443.     }
  444.     m_CacheEnd = m_CacheData + size;
  445.     m_Cache = m_CacheData;
  446. }
  449. void CSeqVector_CI::x_UpdateCacheUp(TSeqPos pos)
  450. {
  451.     _ASSERT(pos < x_GetSize());
  453.     TSeqPos segEnd = m_Seg.GetEndPosition();
  454.     _ASSERT(pos >= m_Seg.GetPosition() && pos < segEnd);
  456.     TSeqPos cache_size = min(kCacheSize, segEnd - pos);
  457.     x_FillCache(pos, cache_size);
  458.     m_Cache = m_CacheData;
  459.     _ASSERT(GetPos() == pos);
  460. }
  463. void CSeqVector_CI::x_UpdateCacheDown(TSeqPos pos)
  464. {
  465.     _ASSERT(pos < x_GetSize());
  467.     TSeqPos segStart = m_Seg.GetPosition();
  468.     _ASSERT(pos >= segStart && pos < m_Seg.GetEndPosition());
  470.     TSeqPos cache_offset = min(kCacheSize - 1, pos - segStart);
  471.     x_FillCache(pos - cache_offset, cache_offset + 1);
  472.     m_Cache = m_CacheData + cache_offset;
  473.     _ASSERT(GetPos() == pos);
  474. }
  477. void CSeqVector_CI::x_FillCache(TSeqPos start, TSeqPos count)
  478. {
  479.     _ASSERT(m_Seg.GetType() != CSeqMap::eSeqEnd);
  480.     _ASSERT(start >= m_Seg.GetPosition());
  481.     _ASSERT(start < m_Seg.GetEndPosition());
  483.     x_ResizeCache(count);
  485.     switch ( m_Seg.GetType() ) {
  486.     case CSeqMap::eSeqData:
  487.     {
  488.         const CSeq_data& data = m_Seg.GetRefData();
  490.         CSeqVector::TCoding dataCoding = data.Which();
  491.         CSeqVector::TCoding cacheCoding = x_GetCoding(m_Coding, dataCoding);
  492.         bool reverse = m_Seg.GetRefMinusStrand();
  494.         bool randomize = false;
  495.         if (cacheCoding == CSeq_data::e_Ncbi2na  &&  bool(m_Randomizer)) {
  496.             cacheCoding = CSeq_data::e_Ncbi4na;
  497.             randomize = true;
  498.         }
  500.         const char* table = 0;
  501.         if ( cacheCoding != dataCoding || reverse ) {
  502.             table = CSeqVector::sx_GetConvertTable(dataCoding,
  503.                                                    cacheCoding,
  504.                                                    reverse);
  505.             if ( !table && cacheCoding != dataCoding ) {
  506.                 NCBI_THROW(CSeqVectorException, eCodingError,
  507.                            "Incompatible sequence codings");
  508.             }
  509.         }
  511.         TSeqPos dataPos;
  512.         if ( reverse ) {
  513.             // Revert segment offset
  514.             dataPos = m_Seg.GetRefEndPosition() -
  515.                 (start - m_Seg.GetPosition()) - count;
  516.         }
  517.         else {
  518.             dataPos = m_Seg.GetRefPosition() +
  519.                 (start - m_Seg.GetPosition());
  520.         }
  522.         switch ( dataCoding ) {
  523.         case CSeq_data::e_Iupacna:
  524.             copy_8bit_any(m_Cache, count, data.GetIupacna().Get(), dataPos,
  525.                           table, reverse);
  526.             break;
  527.         case CSeq_data::e_Iupacaa:
  528.             copy_8bit_any(m_Cache, count, data.GetIupacaa().Get(), dataPos,
  529.                           table, reverse);
  530.             break;
  531.         case CSeq_data::e_Ncbi2na:
  532.             copy_2bit_any(m_Cache, count, data.GetNcbi2na().Get(), dataPos,
  533.                             table, reverse);
  534.             break;
  535.         case CSeq_data::e_Ncbi4na:
  536.             copy_4bit_any(m_Cache, count, data.GetNcbi4na().Get(), dataPos,
  537.                           table, reverse);
  538.             break;
  539.         case CSeq_data::e_Ncbi8na:
  540.             copy_8bit_any(m_Cache, count, data.GetNcbi8na().Get(), dataPos,
  541.                           table, reverse);
  542.             break;
  543.         case CSeq_data::e_Ncbipna:
  544.             NCBI_THROW(CSeqVectorException, eCodingError,
  545.                        "Ncbipna conversion not implemented");
  546.         case CSeq_data::e_Ncbi8aa:
  547.             copy_8bit_any(m_Cache, count, data.GetNcbi8aa().Get(), dataPos,
  548.                           table, reverse);
  549.             break;
  550.         case CSeq_data::e_Ncbieaa:
  551.             copy_8bit_any(m_Cache, count, data.GetNcbieaa().Get(), dataPos,
  552.                           table, reverse);
  553.             break;
  554.         case CSeq_data::e_Ncbipaa:
  555.             NCBI_THROW(CSeqVectorException, eCodingError,
  556.                        "Ncbipaa conversion not implemented");
  557.         case CSeq_data::e_Ncbistdaa:
  558.             copy_8bit_any(m_Cache, count, data.GetNcbistdaa().Get(), dataPos,
  559.                           table, reverse);
  560.             break;
  561.         default:
  562.             NCBI_THROW(CSeqVectorException, eCodingError,
  563.                        "Invalid data coding");
  564.         }
  565.         if ( randomize ) {
  566.             m_Randomizer->RandomizeData(m_Cache, count, start);
  567.         }
  568.         break;
  569.     }
  570.     case CSeqMap::eSeqGap:
  571.         // x_GetCoding(m_Coding, CSeq_data::e_not_set);
  572.         fill(m_Cache, m_Cache + count, CSeqVector::x_GetGapChar(m_Coding));
  573.         if (m_Coding == CSeq_data::e_Ncbi2na  &&  bool(m_Randomizer)) {
  574.             m_Randomizer->RandomizeData(m_Cache, count, start);
  575.         }
  576.         break;
  577.     default:
  578.         NCBI_THROW(CSeqVectorException, eDataError,
  579.                    "Invalid segment type");
  580.     }
  581.     m_CachePos = start;
  582. }
  585. void CSeqVector_CI::x_SetPos(TSeqPos pos)
  586. {
  587.     TSeqPos size = x_GetSize();
  588.     if ( pos >= size ) {
  589.         if ( x_CacheSize() ) {
  590.             // save current cache as backup
  591.             x_SwapCache();
  592.             x_ResetCache();
  593.         }
  594.         _ASSERT(x_CacheSize() == 0 && x_CacheOffset() == 0);
  595.         m_CachePos = size;
  596.         _ASSERT(GetPos() == size);
  597.         return;
  598.     }
  600.     _ASSERT(pos - x_CachePos() >= x_CacheSize());
  602.     // update current segment
  603.     x_UpdateSeg(pos);
  605.     // save current cache as backup and restore old backup
  606.     x_SwapCache();
  608.     // check if old backup is suitable
  609.     TSeqPos cache_offset = pos - x_CachePos();
  610.     TSeqPos cache_size = x_CacheSize();
  611.     if ( cache_offset < cache_size ) {
  612.         // can use backup
  613.         _ASSERT(x_CacheSize() &&
  614.                 x_CachePos() >= m_Seg.GetPosition() &&
  615.                 x_CacheEndPos() <= m_Seg.GetEndPosition());
  616.         m_Cache = m_CacheData + cache_offset;
  617.     }
  618.     else {
  619.         // cannot use backup
  620.         x_InitializeCache();
  621.         TSeqPos old_pos = x_BackupPos();
  622.         if ( pos < old_pos && pos >= old_pos - kCacheSize &&
  623.              m_Seg.GetEndPosition() >= old_pos ) {
  624.             x_UpdateCacheDown(old_pos - 1);
  625.             cache_offset = pos - x_CachePos();
  626.             m_Cache = m_CacheData + cache_offset;
  627.         }
  628.         else {
  629.             x_UpdateCacheUp(pos);
  630.         }
  631.     }
  632.     _ASSERT(x_CacheOffset() < x_CacheSize());
  633.     _ASSERT(GetPos() == pos);
  634. }
  637. void CSeqVector_CI::x_UpdateSeg(TSeqPos pos)
  638. {
  639.     if ( m_Seg.IsInvalid() ) {
  640.         x_InitSeg(pos);
  641.     }
  642.     else if ( m_Seg.GetPosition() > pos ) {
  643.         // segment is ahead
  644.         do {
  645.             _ASSERT(m_Seg || m_Seg.GetPosition() == x_GetSize());
  646.             --m_Seg;
  647.         } while ( m_Seg.GetLength() == 0 ); // skip zero length segments
  648.         _ASSERT(m_Seg);
  649.         if ( m_Seg.GetPosition() > pos ) {
  650.             // too far
  651.             x_InitSeg(pos);
  652.         }
  653.     }
  654.     else if ( m_Seg.GetEndPosition() <= pos ) {
  655.         // segment is behind
  656.         do {
  657.             _ASSERT(m_Seg);
  658.             ++m_Seg;
  659.         } while ( m_Seg.GetLength() == 0 ); // skip zero length segments
  660.         _ASSERT(m_Seg);
  661.         if ( m_Seg.GetEndPosition() <= pos ) {
  662.             // too far
  663.             x_InitSeg(pos);
  664.         }
  665.     }
  666.     _ASSERT(pos >= m_Seg.GetPosition() && pos < m_Seg.GetEndPosition());
  667. }
  670. void CSeqVector_CI::GetSeqData(string& buffer, TSeqPos count)
  671. {
  672.     buffer.erase();
  673.     count = min(count, x_GetSize() - GetPos());
  674.     if ( count ) {
  675.         buffer.reserve(count);
  676.         do {
  677.             TCache_I cache = m_Cache;
  678.             TCache_I cache_end = m_CacheEnd;
  679.             TSeqPos chunk_count = min(count, TSeqPos(cache_end - cache));
  680.             _ASSERT(chunk_count > 0);
  681.             TCache_I chunk_end = cache + chunk_count;
  682.             buffer.append(cache, chunk_end);
  683.             if ( chunk_end == cache_end ) {
  684.                 x_NextCacheSeg();
  685.             }
  686.             else {
  687.                 m_Cache = chunk_end;
  688.             }
  689.             count -= chunk_count;
  690.         } while ( count );
  691.     }
  692. }
  695. void CSeqVector_CI::x_NextCacheSeg()
  696. {
  697.     _ASSERT(m_SeqMap);
  698.     TSeqPos pos = x_CacheEndPos();
  699.     // save current cache in backup
  700.     _ASSERT(x_CacheSize());
  701.     x_SwapCache();
  702.     // update segment if needed
  703.     while ( m_Seg.GetEndPosition() <= pos ) {
  704.         if ( !m_Seg ) {
  705.             // end of sequence
  706.             _ASSERT(pos == x_GetSize());
  707.             x_ResetCache();
  708.             m_CachePos = pos;
  709.             return;
  710.         }
  711.         ++m_Seg;
  712.     }
  713.     _ASSERT(m_Seg);
  714.     // Try to re-use backup cache
  715.     if ( pos < x_CacheEndPos() && pos >= x_CachePos() ) {
  716.         m_Cache = m_CacheData + pos - x_CachePos();
  717.     }
  718.     else {
  719.         // can not use backup cache
  720.         x_ResetCache();
  721.         x_UpdateCacheUp(pos);
  722.         _ASSERT(GetPos() == pos);
  723.         _ASSERT(x_CacheSize());
  724.         _ASSERT(x_CachePos() == pos);
  725.     }
  726. }
  729. void CSeqVector_CI::x_PrevCacheSeg()
  730. {
  731.     _ASSERT(m_SeqMap);
  732.     TSeqPos pos = x_CachePos();
  733.     if ( pos-- == 0 ) {
  734.         // Can not go further
  735.         NCBI_THROW(CSeqVectorException, eOutOfRange,
  736.                    "Can not update cache: iterator out of range");
  737.     }
  738.     // save current cache in backup
  739.     x_SwapCache();
  740.     // update segment if needed
  741.     if ( m_Seg.IsInvalid() ) {
  742.         x_InitSeg(pos);
  743.     }
  744.     else {
  745.         while ( m_Seg.GetPosition() > pos ) {
  746.             _ASSERT(m_Seg || m_Seg.GetPosition() == x_GetSize());
  747.             --m_Seg;
  748.         }
  749.     }
  750.     _ASSERT(m_Seg);
  751.     // Try to re-use backup cache
  752.     if ( pos >= x_CachePos()  &&  pos < x_CacheEndPos() ) {
  753.         m_Cache = m_CacheData + pos - x_CachePos();
  754.     }
  755.     else {
  756.         // can not use backup cache
  757.         x_ResetCache();
  758.         x_UpdateCacheDown(pos);
  759.         _ASSERT(GetPos() == pos);
  760.         _ASSERT(x_CacheSize());
  761.         _ASSERT(x_CacheEndPos() == pos+1);
  762.     }
  763. }
  766. void CSeqVector_CI::x_InitRandomizer(CRandom& random_gen)
  767. {
  768.     TSeqPos pos = GetPos();
  769.     x_ResetCache();
  770.     x_ResetBackup();
  771.     m_Randomizer.Reset(new CNcbi2naRandomizer(random_gen));
  772.     x_SetPos(pos);
  773. }
  776. void CSeqVector_CI::SetRandomizeAmbiguities(void)
  777. {
  778.     CRandom random_gen;
  779.     x_InitRandomizer(random_gen);
  780. }
  783. void CSeqVector_CI::SetRandomizeAmbiguities(Uint4 seed)
  784. {
  785.     CRandom random_gen(seed);
  786.     x_InitRandomizer(random_gen);
  787. }
  790. void CSeqVector_CI::SetRandomizeAmbiguities(CRandom& random_gen)
  791. {
  792.     x_InitRandomizer(random_gen);
  793. }
  796. void CSeqVector_CI::SetNoAmbiguities(void)
  797. {
  798.     TSeqPos pos = GetPos();
  799.     x_ResetCache();
  800.     x_ResetBackup();
  801.     m_Randomizer.Reset();
  802.     x_SetPos(pos);
  803. }
  806. END_SCOPE(objects)
  807. END_NCBI_SCOPE
  809. /*
  810. * ---------------------------------------------------------------------------
  811. * $Log: seq_vector_ci.cpp,v $
  812. * Revision 1000.3  2004/06/01 19:24:26  gouriano
  813. * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.34
  814. *
  815. * Revision 1.34  2004/05/21 21:42:13  gorelenk
  816. * Added PCH ncbi_pch.hpp
  817. *
  818. * Revision 1.33  2004/05/10 18:27:37  grichenk
  819. * Check cache in x_ResizeCache()
  820. *
  821. * Revision 1.32  2004/04/27 14:45:01  grichenk
  822. * Fixed warnings.
  823. *
  824. * Revision 1.31  2004/04/22 18:34:18  grichenk
  825. * Added optional ambiguity randomizer for ncbi2na coding
  826. *
  827. * Revision 1.30  2004/04/12 16:49:16  vasilche
  828. * Allow null scope in CSeqMap_CI and CSeqVector.
  829. *
  830. * Revision 1.29  2004/04/09 20:34:50  vasilche
  831. * Fixed wrong assertion.
  832. *
  833. * Revision 1.28  2003/11/07 17:00:13  vasilche
  834. * Added check for out of bounds withing CSeq_inst to avoid coredump.
  835. *
  836. * Revision 1.27  2003/10/08 14:16:55  vasilche
  837. * Removed circular reference CSeqVector <-> CSeqVector_CI.
  838. *
  839. * Revision 1.26  2003/09/05 17:29:40  grichenk
  840. * Structurized Object Manager exceptions
  841. *
  842. * Revision 1.25  2003/08/29 13:34:47  vasilche
  843. * Rewrote CSeqVector/CSeqVector_CI code to allow better inlining.
  844. * CSeqVector::operator[] made significantly faster.
  845. * Added possibility to have platform dependent byte unpacking functions.
  846. *
  847. * Revision 1.24  2003/08/21 18:51:34  vasilche
  848. * Fixed compilation errors on translation with reverse.
  849. *
  850. * Revision 1.23  2003/08/21 17:04:10  vasilche
  851. * Fixed bug in making conversion tables.
  852. *
  853. * Revision 1.22  2003/08/21 13:32:04  vasilche
  854. * Optimized CSeqVector iteration.
  855. * Set some CSeqVector values (mol type, coding) in constructor instead of detecting them while iteration.
  856. * Remove unsafe bit manipulations with coding.
  857. *
  858. * Revision 1.21  2003/08/19 18:34:11  vasilche
  859. * Buffer length constant moved to *.cpp file for easier modification.
  860. *
  861. * Revision 1.20  2003/07/21 14:30:48  vasilche
  862. * Fixed buffer destruction and exception processing.
  863. *
  864. * Revision 1.19  2003/07/18 20:41:48  grichenk
  865. * Fixed memory leaks in CSeqVector_CI
  866. *
  867. * Revision 1.18  2003/07/18 19:42:42  vasilche
  868. * Added x_DestroyCache() method.
  869. *
  870. * Revision 1.17  2003/07/01 18:00:41  vasilche
  871. * Fixed unsigned/signed comparison.
  872. *
  873. * Revision 1.16  2003/06/24 19:46:43  grichenk
  874. * Changed cache from vector<char> to char*. Made
  875. * CSeqVector::operator[] inline.
  876. *
  877. * Revision 1.15  2003/06/18 15:01:19  vasilche
  878. * Fixed positioning of CSeqVector_CI in GetSeqData().
  879. *
  880. * Revision 1.14  2003/06/17 20:37:06  grichenk
  881. * Removed _TRACE-s, fixed bug in x_GetNextSeg()
  882. *
  883. * Revision 1.13  2003/06/13 17:22:28  grichenk
  884. * Check if seq-map is not null before using it
  885. *
  886. * Revision 1.12  2003/06/10 15:27:14  vasilche
  887. * Fixed warning
  888. *
  889. * Revision 1.11  2003/06/06 15:09:43  grichenk
  890. * One more fix for coordinates
  891. *
  892. * Revision 1.10  2003/06/05 20:20:22  grichenk
  893. * Fixed bugs in assignment functions,
  894. * fixed minor problems with coordinates.
  895. *
  896. * Revision 1.9  2003/06/04 13:48:56  grichenk
  897. * Improved double-caching, fixed problem with strands.
  898. *
  899. * Revision 1.8  2003/06/02 21:03:59  vasilche
  900. * Grichenko's fix of wrong data in CSeqVector.
  901. *
  902. * Revision 1.7  2003/06/02 16:53:35  dicuccio
  903. * Restore file damaged by last check-in
  904. *
  905. * Revision 1.5  2003/05/31 01:42:51  ucko
  906. * Avoid min(size_t, TSeqPos), as they may be different types.
  907. *
  908. * Revision 1.4  2003/05/30 19:30:08  vasilche
  909. * Fixed compilation on GCC 3.
  910. *
  911. * Revision 1.3  2003/05/30 18:00:29  grichenk
  912. * Fixed caching bugs in CSeqVector_CI
  913. *
  914. * Revision 1.2  2003/05/29 13:35:36  grichenk
  915. * Fixed bugs in buffer fill/copy procedures.
  916. *
  917. * Revision 1.1  2003/05/27 19:42:24  grichenk
  918. * Initial revision
  919. *
  920. *
  921. * ===========================================================================
  922. */