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

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

生物技术

开发平台：

C/C++

sequtil_convert_imp.cpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: sequtil_convert_imp.cpp,v $
  4.  * PRODUCTION Revision 1000.1  2004/06/01 19:42:17  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.2
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. /*  $Id: sequtil_convert_imp.cpp,v 1000.1 2004/06/01 19:42:17 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:  Mati Shomrat
  36.  *
  37.  * File Description:
  38.  *   
  39.  */   
  40. #include <ncbi_pch.hpp>
  41. #include <corelib/ncbistd.hpp>
  43. #include <util/sequtil/sequtil_expt.hpp>
  45. #include "sequtil_convert_imp.hpp"
  46. #include "sequtil_shared.hpp"
  47. #include "sequtil_tables.hpp"
  50. BEGIN_NCBI_SCOPE
  53. /////////////////////////////////////////////////////////////////////////////
  54. //
  55. // Conversions
  57. // NB: We try to use conversion tables wherever possible, minimizing bit 
  58. // shifting or any other operation within the main conversion loop.
  60. // All conversion functions takes the following parameters:
  61. // src - input sequence
  62. // pos - starting position in sequence coordinates
  63. // length - number of residues to convert
  64. // dst - an output container
  67. SIZE_TYPE CSeqConvert_imp::Convert
  68. (const char* src,
  69.  TCoding src_coding,
  70.  TSeqPos pos,
  71.  TSeqPos length,
  72.  char* dst,
  73.  TCoding dst_coding)
  74. {
  75.     _ASSERT((dst != 0)  &&  (src != 0));
  76.     _ASSERT(CSeqUtil::GetCodingType(src_coding) == 
  77.             CSeqUtil::GetCodingType(dst_coding));
  79.     if ( length == 0 ) {
  80.         return 0;
  81.     }
  83.     // conversion from a coding to itself.
  84.     if ( src_coding == dst_coding ) {
  85.         return Subseq(src, src_coding, pos, length, dst);
  86.     }
  87.     
  88.     // all other conversions
  89.     switch ( src_coding ) {
  90.         
  91.     // --- NA conversions 
  92.         
  93.     // iupacna -> ...
  94.     case CSeqUtil::e_Iupacna:
  95.         switch ( dst_coding ) {
  96.         case CSeqUtil::e_Ncbi2na:
  97.             return x_ConvertIupacnaTo2na(src, pos, length, dst);
  98.         case CSeqUtil::e_Ncbi2na_expand:
  99.             return x_ConvertIupacnaTo2naExpand(src, pos, length, dst);
  100.         case CSeqUtil::e_Ncbi4na:
  101.             return x_ConvertIupacnaTo4na(src, pos, length, dst);
  102.         case CSeqUtil::e_Ncbi4na_expand:
  103.         case CSeqUtil::e_Ncbi8na:
  104.             return x_ConvertIupacnaTo8na(src, pos, length, dst);
  105.         }
  106.         break;
  107.     
  108.     // ncbi2na -> ...
  109.     case CSeqUtil::e_Ncbi2na:
  110.         switch ( dst_coding ) {
  111.         case CSeqUtil::e_Iupacna:
  112.             return x_Convert2naToIupacna(src, pos, length, dst);
  113.         case CSeqUtil::e_Ncbi2na_expand:
  114.             return x_Convert2naTo2naExpand(src, pos, length, dst);
  115.         case CSeqUtil::e_Ncbi4na:
  116.             return x_Convert2naTo4na(src, pos, length, dst);
  117.         case CSeqUtil::e_Ncbi4na_expand:
  118.         case CSeqUtil::e_Ncbi8na:
  119.             return x_Convert2naTo8na(src, pos, length, dst);
  120.         }
  121.         break;
  123.     // ncbi2na_expand -> ...
  124.     case CSeqUtil::e_Ncbi2na_expand:
  125.         switch ( dst_coding ) {
  126.         case CSeqUtil::e_Iupacna:
  127.             return x_Convert2naExpandToIupacna(src, pos, length, dst);
  128.         case CSeqUtil::e_Ncbi2na:
  129.             return x_Convert2naExpandTo2na(src, pos, length, dst);
  130.         case CSeqUtil::e_Ncbi4na:
  131.             return x_Convert2naExpandTo4na(src, pos, length, dst);
  132.         case CSeqUtil::e_Ncbi4na_expand:
  133.         case CSeqUtil::e_Ncbi8na:
  134.             return x_Convert2naExpandTo8na(src, pos, length, dst);
  135.         }
  136.         break;
  137.         
  138.     // ncbi4na -> ...
  139.     case CSeqUtil::e_Ncbi4na:
  140.         switch ( dst_coding ) {
  141.         case CSeqUtil::e_Iupacna:
  142.             return x_Convert4naToIupacna(src, pos, length, dst);
  143.         case CSeqUtil::e_Ncbi2na:
  144.             return x_Convert4naTo2na(src, pos, length, dst);
  145.         case CSeqUtil::e_Ncbi2na_expand:
  146.             return x_Convert4naTo2naExpand(src, pos, length, dst);
  147.         case CSeqUtil::e_Ncbi4na_expand:
  148.         case CSeqUtil::e_Ncbi8na:
  149.             return x_Convert4naTo8na(src, pos, length, dst);
  150.         }
  151.         break;
  152.         
  153.     // ncbi8na / ncbi4na_expand -> ...
  154.     case CSeqUtil::e_Ncbi8na:
  155.     case CSeqUtil::e_Ncbi4na_expand:
  156.         switch ( dst_coding ) {
  157.         case CSeqUtil::e_Iupacna:
  158.             return x_Convert8naToIupacna(src, pos, length, dst);
  159.         case CSeqUtil::e_Ncbi2na:
  160.             return x_Convert8naTo2na(src, pos, length, dst);
  161.         case CSeqUtil::e_Ncbi2na_expand:
  162.             return x_Convert8naTo2naExpand(src, pos, length, dst);
  163.         case CSeqUtil::e_Ncbi4na:
  164.             return x_Convert8naTo4na(src, pos, length, dst);
  165.         case CSeqUtil::e_Ncbi8na:
  166.         case CSeqUtil::e_Ncbi4na_expand:
  167.             return Subseq(src, src_coding, pos, length, dst);
  168.         }
  169.         break;
  170.         
  171.     // --- AA conversions 
  172.                         
  173.     // NB: currently ncbi8aa is the same as ncbistdaa.
  174.               
  175.     // iupacaa -> ...
  176.     case CSeqUtil::e_Iupacaa:
  177.         switch ( dst_coding ) {
  178.         case CSeqUtil::e_Ncbieaa:
  179.             return x_ConvertIupacaaToEaa(src, pos, length, dst);
  180.         case CSeqUtil::e_Ncbistdaa:
  181.         case CSeqUtil::e_Ncbi8aa:
  182.             return x_ConvertIupacaaToStdaa(src, pos, length, dst);
  183.         }
  184.         break;
  185.         
  186.     // ncbieaa -> ...
  187.     case CSeqUtil::e_Ncbieaa:
  188.         switch ( dst_coding ) {
  189.         case CSeqUtil::e_Iupacaa:
  190.             return x_ConvertEaaToIupacaa(src, pos, length, dst);
  191.         case CSeqUtil::e_Ncbistdaa:
  192.         case CSeqUtil::e_Ncbi8aa:
  193.             return x_ConvertEaaToStdaa(src, pos, length, dst);            
  194.         }
  195.         break;
  196.         
  197.     // ncbistdaa / ncbi8aa -> ...
  198.     case CSeqUtil::e_Ncbi8aa:
  199.     case CSeqUtil::e_Ncbistdaa:
  200.         switch ( dst_coding ) {
  201.         case CSeqUtil::e_Ncbieaa:
  202.             return x_ConvertStdaaToEaa(src, pos, length, dst);
  203.         case CSeqUtil::e_Iupacaa:
  204.             return x_ConvertStdaaToIupacaa(src, pos, length, dst);
  205.         case CSeqUtil::e_Ncbi8aa:
  206.         case CSeqUtil::e_Ncbistdaa:
  207.             return Subseq(src, src_coding, pos, length, dst);
  208.         }
  209.         break;
  210.     }
  212.     // We should never reach here
  213.     NCBI_THROW(CSeqUtilException, eInvalidCoding, "Unknown conversion.");
  214. }
  217. // --- NA conversions:
  220. // from IUPACna to ...
  221. //===========================================================================
  223. // IUPACna -> IUPACna
  224. // This is not a simple copy since we handle conversion of lower to upper 
  225. // case and conversion of 'U'('u') to 'T'
  227. SIZE_TYPE CSeqConvert_imp::x_ConvertIupacnaToIupacna
  228. (const char* src,
  229.  TSeqPos pos,
  230.  TSeqPos length,
  231.  char* dst)
  232. {
  233.     // call the shared implementation for converting 1 byte to another byte
  234.     // given a specific conversion table.
  235.     // the iupacna to iupacna table converts upper and lower case to upper case
  236.     // and U (u) to T
  237.     return convert_1_to_1(src, pos, length, dst, 
  238.                           CIupacnaToIupacna::GetTable());
  239. }
  242. // IUPACna -> NCBI2na
  243. // convert 4 IUPACna characters into a single NCBI2na byte
  245. SIZE_TYPE CSeqConvert_imp::x_ConvertIupacnaTo2na
  246. (const char* src,
  247.  TSeqPos pos,
  248.  TSeqPos length,
  249.  char* dst)
  250. {
  251.     // The iupacna to ncbi2na table is constructed such that each row
  252.     // correspond to an iupacna letter and each column corresponds to
  253.     // that letter being in one of the 4 possible offsets within the 
  254.     // ncbi2na byte
  255.     const Uint1* table = CIupacnaTo2na::GetTable();
  256.     
  257.     const char* src_i = src + pos;
  258.     for ( size_t count = length / 4; count; --count ) {
  259.         *dst = 
  260.             table[*src_i * 4          ] | 
  261.             table[*(src_i + 1) * 4 + 1] |
  262.             table[*(src_i + 2) * 4 + 2] |
  263.             table[*(src_i + 3) * 4 + 3];
  264.         src_i += 4;
  265.         ++dst;
  266.     }
  267.     
  268.     // Handle overhang
  269.     if ( length % 4 != 0 ) {
  270.         *dst = 0x0;
  271.         for( size_t i = 0; i < (length % 4); ++i, ++src_i ) {
  272.             *dst |= table[static_cast<Uint1>(*src_i) * 4 + i];
  273.         }
  274.     }
  275.     
  276.     return length;
  277. }
  280. // IUPACna -> NCBI2na_expand
  281. // convert a single IUPACna character into a single NCBI2na_expand byte.
  283. SIZE_TYPE CSeqConvert_imp::x_ConvertIupacnaTo2naExpand
  284. (const char* src,
  285.  TSeqPos pos,
  286.  TSeqPos length,
  287.  char* dst)
  288. {
  289.     // call the shared implementation for converting 1 byte to another byte
  290.     // given a specific conversion table.
  291.     // the iupacna to ncbi2na_expand table converts upper and lower case IUPACna
  292.     // into a single ncbi2na_expand byte.
  293.     return convert_1_to_1(src, pos, length, dst, 
  294.                           CIupacnaTo2naExpand::GetTable());
  295. }
  298. // IUPACna -> NCBI4na
  299. // convert 2 IUPACna characters into a single NCBI4na byte
  301. SIZE_TYPE CSeqConvert_imp::x_ConvertIupacnaTo4na
  302. (const char* src,
  303.  TSeqPos pos,
  304.  TSeqPos length,
  305.  char* dst)
  306. {
  308.     // The iupacna to ncbi4na table is constructed such that each row
  309.     // correspond to an iupacna letter and each column corresponds to
  310.     // that letter being in one of the 2 possible offsets within the 
  311.     // ncbi4na byte
  312.     const Uint1* table = CIupacnaTo4na::GetTable();
  313.     
  314.     const char* src_i = src + pos;
  315.     
  316.     for ( size_t count = length / 2; count; --count ) {
  317.         *dst = table[*src_i * 2] | table[*(src_i + 1) * 2 + 1];
  318.         src_i += 2;
  319.         ++dst;
  320.     }
  321.     
  322.     // handle overhang
  323.     if ( length % 2 != 0 ) {
  324.         *dst = table[static_cast<Uint1>(*src_i) * 2];
  325.     }
  326.     
  327.     return length;
  328. }
  331. // IUPACna -> NCBI8na (NCBI4na_expand)
  332. // convert a single IUPACna character into a single NCBI8na byte.
  334. SIZE_TYPE CSeqConvert_imp::x_ConvertIupacnaTo8na
  335. (const char* src,
  336.  TSeqPos pos,
  337.  TSeqPos length,
  338.  char* dst)
  339. {
  340.     // call the shared implementation for converting 1 byte to another byte
  341.     // given a specific conversion table.
  342.     // the iupacna to ncbi8na table converts upper and lower case IUPACna
  343.     // into a single ncbi8na byte (which is the same as ncbi4na_expand)
  344.     return convert_1_to_1(src, pos, length, dst, 
  345.                           CIupacnaTo8na::GetTable());
  346. }
  349. // from NCBI2na to ...
  350. //===========================================================================
  352. // NCBI2na -> IUPACna
  353. // convert a NCBI2na byte into 4 IUPACna characters.
  355. SIZE_TYPE CSeqConvert_imp::x_Convert2naToIupacna
  356. (const char* src,
  357.  TSeqPos pos,
  358.  TSeqPos length,
  359.  char* dst)
  360. {
  361.     return convert_1_to_4(src, pos, length, dst, C2naToIupacna::GetTable());
  362. }
  365. // NCBI2na -> NCBI2na_expand
  366. // convert a NCBI2na byte into 4 NCBI2na_expand characters.
  368. SIZE_TYPE CSeqConvert_imp::x_Convert2naTo2naExpand
  369. (const char* src,
  370.  TSeqPos pos,
  371.  TSeqPos length,
  372.  char* dst)
  373. {
  374.     return convert_1_to_4(src, pos, length, dst, C2naTo2naExpand::GetTable());
  375. }
  378. // NCBI2na -> NCBI4na
  379. // convert a NCBI2na byte into 2 NCBI4na bytes.
  381. SIZE_TYPE CSeqConvert_imp::x_Convert2naTo4na
  382. (const char* src,
  383.  TSeqPos pos,
  384.  TSeqPos length,
  385.  char* dst)
  386. {
  387.     const Uint1* table = C2naTo4na::GetTable(pos % 2 == 0);
  388.     const Uint2* table2 = reinterpret_cast<const Uint2*>(table);
  390.     const char* iter = src + (pos / 4);
  391.     
  392.     size_t size = length;
  393.     // NB: branch within the inner loop as devastating consequences
  394.     // on performance.
  395.     
  396.     // we handle two different cases, the first being offsets 0 and 2.
  397.     // the second are offsets 1 and 3.
  398.     // for offsets 0,2 we use a 2 column table, where the first column
  399.     // corresponds to the lower 4 bits of the ncbi2na coding (entry 0)
  400.     // and the second column corresponds to the upper 4 bits (entry 1).
  401.     // in this case once we set the initial entry progress is the same.
  402.     // the overhang for this case is either 0 or 1.
  403.     // the 13 offset is a more complex one. for it we use a 3 column table.
  404.     // the first column corresponds to the lower 2 bits of the ncbi2na 
  405.     // coding, the second corresponds to the middle 4 bits and the third
  406.     // correspond to the upper 2 bits.
  407.     // we handle all cases as offset 3. for offset one we simply handle 
  408.     // the first 4 bits, which will being us to offset 3.
  409.     // as handling the middle 4 bits or the combination of the 2 lower
  410.     // ones and 2 upper ones are done differently, we handle 4 letters (8 bits)
  411.     // at a time, in oredr to prevent branching withing the inner loop.
  412.     // overhang for this case is 1, 2 or 3.
  413.     
  414.     switch ( pos % 4 ) {
  415.         // --- table entry size for offsets 0,2 is 2
  416.     case 2:
  417.         {{
  418.             *dst = table[static_cast<Uint1>(*iter) * 2 + 1];
  419.             if ( length == 1 ) {
  420.                 *dst &= 0xf0;
  421.                 return length;
  422.             }
  423.             size -= 2;
  424.             ++iter;
  425.             ++dst;
  426.         }}
  428.         // intentional fall through
  429.     case 0:
  430.         {{
  431.             // "trick" the compiler so that each assignment will
  432.             // be of 2 bytes.
  433.             Uint2* dst2 = reinterpret_cast<Uint2*>(dst);
  434.             for ( size_t i = size / 4; i; --i , ++dst2, ++iter ) {
  435.                 *dst2 = table2[static_cast<Uint1>(*iter)];
  436.             }
  437.             dst = reinterpret_cast<char*>(dst2);
  438.         }}
  440.         // handle overhang
  441.         if ( (size % 4) != 0 ) {
  442.             switch ( size % 4 ) {
  443.             case 1:
  444.                 *dst = table[static_cast<Uint1>(*iter) * 2] & 0xf0;
  445.                 break;
  446.             case 2:
  447.                 *dst = table[static_cast<Uint1>(*iter) * 2];
  448.                 break;
  449.             case 3:
  450.                 *dst = table[static_cast<Uint1>(*iter) * 2];
  451.                 ++dst;
  452.                 *dst = table[static_cast<Uint1>(*iter) * 2 + 1] & 0xf0;
  453.                 break;
  454.             }
  455.         }
  456.         break;
  457.         
  458.         // --- table entry size for offsets 1,3 is 3
  459.     case 3:
  460.         {{
  461.             if ( length == 1 ) {
  462.                 *dst = table[static_cast<Uint1>(*iter) * 3 + 2];
  463.                 return length;
  464.             } else {
  465.                 *dst = table[static_cast<Uint1>(*iter) * 3 + 2] |
  466.                        table[static_cast<Uint1>(*(iter + 1)) * 3];
  467.                 ++dst;
  468.                 ++iter;
  469.                 size -= 2;
  470.             }
  471.         }}
  472.         // intentional fall through
  473.     case 1:
  474.         {{
  475.             for ( size_t i = size / 4; i; --i, ++iter ) {
  476.                 *dst = table[static_cast<Uint1>(*iter) * 3 + 1];
  477.                 ++dst;
  478.                 *dst = table[static_cast<Uint1>(*iter) * 3 + 2] |
  479.                        table[static_cast<Uint1>(*(iter + 1)) * 3];
  480.                 ++dst;
  481.             }
  482.         }}
  484.         // handle overhang
  485.         if ( size % 4 != 0 ) {
  486.             switch ( size % 4 ) {
  487.             case 1:
  488.                 *dst = table[static_cast<Uint1>(*iter) * 3 + 1] & 0xF0;
  489.                 break;
  491.             case 2:
  492.                 *dst = table[static_cast<Uint1>(*iter) * 3 + 1];
  493.                 break;
  495.             case 3:
  496.                 *dst = table[static_cast<Uint1>(*iter) * 3 + 1];
  497.                 ++dst;
  498.                 *dst = table[static_cast<Uint1>(*iter) * 3 + 2];
  499.                 break;
  500.             }
  501.         }
  502.         break;
  503.     } // end of switch ( offset )
  504.     
  505.     return length;
  506. }
  507.     
  509. // NCBI2na -> NCBI8na (NCBI4na_expand)
  510. // convert a ncbi2na byte into 4 ncbi4na bytes.
  512. SIZE_TYPE CSeqConvert_imp::x_Convert2naTo8na
  513. (const char* src,
  514.  TSeqPos pos,
  515.  TSeqPos length,
  516.  char* dst)
  517. {
  518.     return convert_1_to_4(src, pos, length, dst, C2naTo8na::GetTable());
  519. }
  522. // from NCBI2na_expand to ...
  523. //===========================================================================
  525. // NCBI2na_expand -> IUPACna
  526. // convert a single NCBI2na_expand byte into a single IUPACna byte.
  528. SIZE_TYPE CSeqConvert_imp::x_Convert2naExpandToIupacna
  529. (const char* src,
  530.  TSeqPos pos,
  531.  TSeqPos length,
  532.  char* dst)
  533. {
  534.     return convert_1_to_1(src, pos, length, dst, 
  535.                           C2naExpandToIupacna::GetTable());
  536. }
  539. // NCBI2na_expand -> NCBI2na
  540. // convert 4 NCBI2na_expand bytes to a single NCBI2na one.
  542. SIZE_TYPE CSeqConvert_imp::x_Convert2naExpandTo2na
  543. (const char* src,
  544.  TSeqPos pos,
  545.  TSeqPos length,
  546.  char* dst)
  547. {
  548.     const char* iter = src + pos;
  549.     
  550.     // main loop. pack 4 ncbi2na_expand bytes into a single bye and add it
  551.     // to the output container
  552.     for ( size_t i = length / 4; i; --i, ++dst ) {
  553.         *dst = (*iter << 6) | (*(iter + 1) << 4) | 
  554.                (*(iter + 2) << 2) | (*(iter + 3));
  555.         iter += 4;
  556.     }
  558.     switch ( length % 4 ) {
  559.     case 1:
  560.         *dst = (*iter << 6);
  561.         break;
  562.     case 2:
  563.         *dst = (*iter << 6) | (*(iter + 1) << 4);
  564.         break;
  565.     case 3:
  566.         *dst = (*iter << 6) | (*(iter + 1) << 4) | (*(iter + 2) << 2);
  567.         break;
  568.     }
  569.     
  570.     return length;
  571. }
  574. // NCBI2na_expand -> NCBI4na
  575. // convert 2 NCBI2na_expand bytes into a single NCBI4na byte.
  577. SIZE_TYPE CSeqConvert_imp::x_Convert2naExpandTo4na
  578. (const char* src,
  579.  TSeqPos pos,
  580.  TSeqPos length,
  581.  char* dst)
  582. {
  583.     // A simple conversion table that converts a ncbi2na_expand byte
  584.     // into a "half" ncbi4na byte, based on the position of the 
  585.     // ncbi2na_expand byte within the ncbi4na byte
  586.     // positions 0 and 1 corresponds to the lower and upper 4 bits in 
  587.     // a ncbi4na byte respectively.
  588.     static Uint1 table[8] = {
  589.       //  0     1
  590.         0x10, 0x01,  // A 
  591.         0x20, 0x02,  // C
  592.         0x40, 0x04,  // G
  593.         0x80, 0x08   // T
  594.     };
  596.     const char* iter = src + pos;
  598.     for ( size_t i = length / 2; i; --i, ++dst ) {
  599.         *dst = table[*iter * 2] | table[*(iter + 1) * 2 + 1];
  600.         iter += 2;
  601.     }
  602.     
  603.     if ( length % 2 != 0 ) { // == 1
  604.         *dst = table[*iter * 2];
  605.     }
  607.     return length;
  608. }
  611. // NCBI2na_expand -> NCBI8na (NCBI4na_expand)
  612. // convert a single NCBI2na_expand byte into a single NCBI8na one.
  614. SIZE_TYPE CSeqConvert_imp::x_Convert2naExpandTo8na
  615. (const char* src,
  616.  TSeqPos pos,
  617.  TSeqPos length,
  618.  char* dst)
  619. {
  620.     // simple
  621.     static Uint1 table[4] = {
  622.         0x01,  // A  0 -> 1
  623.         0x02,  // C  1 -> 2
  624.         0x04,  // G  2 -> 4
  625.         0x08   // T  3 -> 8
  626.     };
  627.     
  628.     return convert_1_to_1(src, pos, length, dst, table);
  629. }
  632. // from NCBI4na to ...
  633. //===========================================================================
  636. // NCBI4na -> IUPACna
  637. // convert a NCBI4na byte into 2 IUPACna characters.
  639. SIZE_TYPE CSeqConvert_imp::x_Convert4naToIupacna
  640. (const char* src,
  641.  TSeqPos pos,
  642.  TSeqPos length,
  643.  char* dst)
  644. {
  645.     return convert_1_to_2(src, pos, length, dst, C4naToIupacna::GetTable());
  646. }
  648. // NCBI4na -> NCBI2na
  649. // convert 2 NCBI4na bytes into a NCBI2na byte.
  651. SIZE_TYPE CSeqConvert_imp::x_Convert4naTo2na
  652. (const char* src,
  653.  TSeqPos pos,
  654.  TSeqPos length,
  655.  char* dst)
  656. {
  657.     Uint1 offset = pos % 2;
  658.     const Uint1* table = C4naTo2na::GetTable(offset);
  659.     
  660.     size_t overhang = length % 4;
  662.     
  663.     const char* iter = src + (pos / 2);
  664.     
  665.     switch ( offset ) {
  666.     case 0:
  667.         // aligned copy
  668.         {{
  669.             for ( size_t i = length / 4; i; --i, ++dst ) {
  670.                 *dst = 
  671.                     table[static_cast<Uint1>(*iter) * 2] |
  672.                     table[static_cast<Uint1>(*(iter + 1)) * 2 + 1];
  673.                 iter += 2;
  674.             }
  675.             
  676.             // handle overhang
  677.             if ( overhang != 0 ) {
  678.                 switch ( overhang ) {
  679.                 case 1:
  680.                     // leave just the 2 lower bits
  681.                     *dst = (table[static_cast<Uint1>(*iter) * 2]) & 0xC0;
  682.                     break;
  683.                 case 2:
  684.                     // leave just the 4 lower bits
  685.                     *dst = (table[static_cast<Uint1>(*iter) * 2]) & 0xF0;
  686.                     break;
  687.                 case 3:
  688.                     *dst = 
  689.                         table[static_cast<Uint1>(*iter) * 2]           |
  690.                         table[static_cast<Uint1>(*(iter + 1)) * 2 + 1] &
  691.                         0xFC;
  692.                     break;
  693.                 }
  694.             }
  695.         }}
  696.         break;
  697.         
  698.     case 1:
  699.         // unaligned copy
  700.         {{
  701.             for ( size_t i = length / 4; i; --i, ++dst ) {
  702.                 *dst  = 
  703.                     table[static_cast<Uint1>(*iter) * 3]             |
  704.                     table[static_cast<Uint1>(*(iter + 1)) * 3 + 1]   |
  705.                     table[static_cast<Uint1>(*(iter + 2)) * 3 + 2];
  706.                 iter += 2;
  707.             }
  708.             
  709.             // handle overhang
  710.             if ( overhang != 0 ) {
  711.                 switch ( overhang ) {
  712.                 case 1:
  713.                     *dst = table[static_cast<Uint1>(*iter) * 3] & 0xC0;
  714.                     break;
  715.                 case 2:
  716.                     *dst = 
  717.                         table[static_cast<Uint1>(*iter) * 3]           |
  718.                         table[static_cast<Uint1>(*(iter + 1)) * 3 + 1] &
  719.                         0xF0;
  720.                     break;
  721.                 case 3:
  722.                     *dst = 
  723.                         table[static_cast<Uint1>(*iter) * 3]           |
  724.                         table[static_cast<Uint1>(*(iter + 1)) * 3 + 1] &
  725.                         0xFC;
  726.                     break;
  727.                 }
  728.             }
  729.         }}
  730.         break;
  731.     }
  732.     
  733.     return length;
  734. }
  736. // NCBI4na -> NCBI2na_expand
  737. // convert a NCBI4na byte into 2 NCBI2na_expand bytes.
  739. SIZE_TYPE CSeqConvert_imp::x_Convert4naTo2naExpand
  740. (const char* src,
  741.  TSeqPos pos,
  742.  TSeqPos length,
  743.  char* dst)
  744. {
  745.     return convert_1_to_2(src, pos, length, dst, 
  746.                           C4naTo2naExpand::GetTable());
  747. }
  750. // NCBI4na -> NCBI8na (NCBI4na_expand)
  751. // convert a NCBI2na byte into 4 IUPACna characters.
  753. SIZE_TYPE CSeqConvert_imp::x_Convert4naTo8na
  754. (const char* src,
  755.  TSeqPos pos,
  756.  TSeqPos length,
  757.  char* dst)
  758. {
  759.     return convert_1_to_2(src, pos, length, dst, C4naTo8na::GetTable());
  760. }
  763. // from NCBI8na (NCBI4na_expand) to ...
  764. //===========================================================================
  766. // NCBI8na -> IUPACna
  767. // convert a single NCBI8na byte into a single IUPACna byte.
  769. SIZE_TYPE CSeqConvert_imp::x_Convert8naToIupacna
  770. (const char* src,
  771.  TSeqPos pos,
  772.  TSeqPos length,
  773.  char *dst)
  774. {
  775.     return convert_1_to_1(src, pos, length, dst, C8naToIupacna::GetTable());
  776. }
  779. // NCBI8na -> NCBI2na
  780. // convert 4 NCBI8na bytes into a single NCBI2na byte.
  782. SIZE_TYPE CSeqConvert_imp::x_Convert8naTo2na
  783. (const char* src,
  784.  TSeqPos pos,
  785.  TSeqPos length,
  786.  char *dst)
  787. {
  788.     const Uint1* table = C8naTo2na::GetTable();
  789.     
  790.     const char* iter = src + pos;
  791.     
  792.     for ( size_t i = length / 4; i; --i, ++dst ) {
  793.         *dst = table[static_cast<Uint1>(*iter) * 4] |
  794.             table[static_cast<Uint1>(*(iter + 1)) * 4 + 1] |
  795.             table[static_cast<Uint1>(*(iter + 2)) * 4 + 2] |
  796.             table[static_cast<Uint1>(*(iter + 3)) * 4 + 3];
  797.         iter += 4;
  798.     }
  799.     
  800.     // Handle overhang
  801.     if ( (length % 4) != 0 ) {
  802.         *dst = 0;
  803.         for( size_t i = 0; i < (length % 4); ++i, ++iter ) {
  804.             *dst |= table[static_cast<Uint1>(*iter) * 4 + i];
  805.         }
  806.     }
  807.     
  808.     return length;
  809. }
  812. // NCBI8na -> NCBI2na_expand
  813. // convert a single NCBI8na byte into a single NCBI2na_expand byte.
  815. SIZE_TYPE CSeqConvert_imp::x_Convert8naTo2naExpand
  816. (const char* src,
  817.  TSeqPos pos,
  818.  TSeqPos length,
  819.  char *dst)
  820. {
  821.     // simple conversion table
  822.     static const Uint1 table[16] = {
  823.         0x03,    // gap -> T
  824.         0x00,    // A -> A
  825.         0x01,    // C -> C
  826.         0x01,    // M -> C
  827.         0x02,    // G -> G
  828.         0x02,    // R -> G
  829.         0x01,    // S -> C
  830.         0x00,    // V -> A
  831.         0x03,    // T -> T
  832.         0x03,    // W -> T
  833.         0x03,    // Y -> T
  834.         0x00,    // H -> A
  835.         0x02,    // K -> G
  836.         0x02,    // D -> G
  837.         0x01,    // B -> C
  838.         0x00     // N -> A
  839.     };
  840.     
  841.     return convert_1_to_1(src, pos, length, dst, table);
  842. }
  845. // NCBI8na -> NCBI4na
  846. // convert 2 NCBI8na bytes into  a single NCBI4na byte.
  848. SIZE_TYPE CSeqConvert_imp::x_Convert8naTo4na
  849. (const char* src,
  850.  TSeqPos pos,
  851.  TSeqPos length,
  852.  char *dst)
  853. {
  854.     const char* iter = src + pos;
  856.     for ( size_t i = length / 2; i; --i, ++dst ) {
  857.         *dst = (*iter << 4) | (*(iter + 1));
  858.         iter += 2;
  859.     }
  861.     if ( (length % 2) != 0 ) {
  862.         *dst = (*iter << 4) & 0xf0;
  863.     }
  864.     
  865.     return length;
  866. }
  869. // AA conversions:
  871. // All AA conversions ara a 1 to 1 conversion
  873. // from IUPACaa to ...
  874. //===========================================================================
  876. // IUPACaa -> NCBIeaa
  878. SIZE_TYPE CSeqConvert_imp::x_ConvertIupacaaToEaa
  879. (const char* src,
  880.  TSeqPos pos,
  881.  TSeqPos length,
  882.  char *dst)
  883. {
  884.     // they map directly
  885.     return Subseq(src, CSeqUtil::e_Iupacaa, pos, length, dst);
  886. }
  889. // IUPACaa -> NCBIstdaa (NCBI8aa)
  891. SIZE_TYPE CSeqConvert_imp::x_ConvertIupacaaToStdaa
  892. (const char* src,
  893.  TSeqPos pos,
  894.  TSeqPos length,
  895.  char *dst)
  896. {
  897.     return convert_1_to_1(src, pos, length, dst, CIupacaaToStdaa::GetTable());
  898. }
  901. // from NCBIeaa to ...
  902. //===========================================================================
  904. // NCBIeaa -> IUPACaa
  906. SIZE_TYPE CSeqConvert_imp::x_ConvertEaaToIupacaa
  907. (const char* src,
  908.  TSeqPos pos,
  909.  TSeqPos length,
  910.  char *dst)
  911. {
  912.     return convert_1_to_1(src, pos, length, dst, CEaaToIupacaa::GetTable());
  913. }
  916. // NCBIeaa -> NCBIstdaa (NCBI8aa)
  918. SIZE_TYPE CSeqConvert_imp::x_ConvertEaaToStdaa
  919. (const char* src,
  920.  TSeqPos pos,
  921.  TSeqPos length,
  922.  char *dst)
  923. {
  924.     return convert_1_to_1(src, pos, length, dst, CEaaToStdaa::GetTable());
  925. }
  928. // from NCBIstdaa (NCBI8aa) to ...
  929. //===========================================================================
  931. // NCBIstdaa (NCBI8aa) -> IUPACaa
  933. SIZE_TYPE CSeqConvert_imp::x_ConvertStdaaToIupacaa
  934. (const char* src,
  935.  TSeqPos pos,
  936.  TSeqPos length,
  937.  char *dst)
  938. {
  939.     return convert_1_to_1(src, pos, length, dst, CStdaaToIupacaa::GetTable());
  940. }
  942. // NCBIstdaa (NCBI8aa) -> NCBIeaa
  944. SIZE_TYPE CSeqConvert_imp::x_ConvertStdaaToEaa
  945. (const char* src,
  946.  TSeqPos pos,
  947.  TSeqPos length,
  948.  char *dst)
  949. {
  950.     return convert_1_to_1(src, pos, length, dst, CStdaaToEaa::GetTable());
  951. }
  954. /////////////////////////////////////////////////////////////////////////////
  955. //
  956. // Subseq - partial sequence
  958. SIZE_TYPE CSeqConvert_imp::Subseq
  959. (const char* src,
  960.  TCoding coding,
  961.  TSeqPos pos,
  962.  TSeqPos length,
  963.  char* dst)
  964. {
  965.     SIZE_TYPE converted = 0;
  966.     char *buf = 0;
  967.     try {
  968.         switch ( coding ) {
  969.             
  970.         // for packed coding (2na and 4na) first expand, then re-pack
  971.         case CSeqUtil::e_Ncbi2na:
  972.             {{
  973.                 buf = new char[length];
  974.                 x_Convert2naTo2naExpand(src, pos, length, buf);
  975.                 converted = x_Convert2naExpandTo2na(buf, 0, length, dst);
  976.                 delete[] buf;
  977.                 buf = 0;
  978.             }}
  979.             break;
  980.             
  981.         case CSeqUtil::e_Ncbi4na:
  982.             {{
  983.                 buf = new char[length];
  984.                 x_Convert4naTo8na(src, pos, length, buf);
  985.                 converted = x_Convert8naTo4na(buf, 0, length, dst);
  986.                 delete[] buf;
  987.                 buf = 0;
  988.             }}
  989.             break;
  990.             
  991.         // iupacna may contain 'U' that needs to be converted to 'T'
  992.         case CSeqUtil::e_Iupacna:
  993.             {{
  994.                 converted = convert_1_to_1(src, pos, length, dst, 
  995.                     CIupacnaToIupacna::GetTable());
  996.             }}
  997.             break;
  998.             
  999.         // for other ascii codings make sure the output is upper case
  1000.         case CSeqUtil::e_Iupacaa:
  1001.         case CSeqUtil::e_Ncbieaa:
  1002.             {{
  1003.                 const char* iter = src + pos;
  1004.                 const char* end  = iter + length;
  1005.                 
  1006.                 for ( ; iter != end; ++iter, ++dst ) {
  1007.                     *dst++ = toupper(*iter);
  1008.                 }
  1009.                 converted = length;
  1010.             }}
  1011.             break;
  1012.             
  1013.         // for the rest of the codings (e.g. 8na, stdaa) copy
  1014.         // the desired range.
  1015.         default:
  1016.             {{
  1017.                 copy(src + pos, src + pos + length, dst);
  1018.                 converted = length;
  1019.             }}
  1020.             break;
  1021.         } // end of switch statement
  1022.     } catch ( ... ) {
  1023.         if ( buf != 0 ) {
  1024.             delete[] buf;
  1025.         }
  1026.         throw;
  1027.     }
  1029.     return converted;
  1030. }
  1033. /////////////////////////////////////////////////////////////////////////////
  1034. //
  1035. // Packing
  1037. SIZE_TYPE CSeqConvert_imp::Pack
  1038. (const char* src,
  1039.  TSeqPos length,
  1040.  TCoding src_coding,
  1041.  char* dst,
  1042.  TCoding& dst_coding)
  1043. {
  1044.     dst_coding = x_HasAmbig(src, src_coding, length) ?
  1045.         CSeqUtil::e_Ncbi4na : CSeqUtil::e_Ncbi2na;
  1046.     
  1047.     return Convert(src, src_coding, 0, length, dst, dst_coding);
  1048. }
  1051. bool CSeqConvert_imp::x_HasAmbig
  1052. (const char* src,
  1053.  TCoding src_coding,
  1054.  size_t length)
  1055. {
  1056.     if ( length == 0 ) {
  1057.         return false;
  1058.     }
  1059.     
  1060.     switch ( src_coding ) {
  1061.     case CSeqUtil::e_Iupacna:
  1062.         return x_HasAmbigIupacna(src, length);
  1063.         
  1064.     case CSeqUtil::e_Ncbi4na:
  1065.         return x_HasAmbigNcbi4na(src, length);
  1066.         
  1067.     case CSeqUtil::e_Ncbi4na_expand:
  1068.     case CSeqUtil::e_Ncbi8na:
  1069.         return x_HasAmbigNcbi8na(src, length);
  1070.         
  1071.     case CSeqUtil::e_Ncbi2na:
  1072.     case CSeqUtil::e_Ncbi2na_expand:
  1073.         return false;
  1074.     }
  1075.     
  1076.     return false;
  1077. }
  1080. bool CSeqConvert_imp::x_HasAmbigIupacna(const char* src, size_t length)
  1081. {
  1082.     const bool *not_ambig = CIupacnaAmbig::GetTable();
  1083.     
  1084.     const char* end = src + length;
  1085.     
  1086.     const char* iter = src;
  1087.     while ( (iter != end)  &&  (not_ambig[static_cast<Uint1>(*iter)]) ) { 
  1088.           ++iter;
  1089.     }
  1091.     return iter != end;
  1092. }
  1095. bool CSeqConvert_imp::x_HasAmbigNcbi4na(const char* src, size_t length)
  1096. {
  1097.     const bool* not_ambig = CNcbi4naAmbig::GetTable();
  1098.     
  1099.     const char* end = src + (length / 2);
  1100.     
  1101.     const char* iter = src;
  1102.     while ( (iter != end)  &&  (not_ambig[static_cast<Uint1>(*iter)]) ) {
  1103.           ++iter;
  1104.     }
  1105.     
  1106.     if ( (iter == end)  &&  (length % 2) != 0 ) {
  1107.         return not_ambig[static_cast<Uint1>(*iter) & 0xF1];
  1108.     }
  1109.     return iter != end;
  1110. }
  1113. bool CSeqConvert_imp::x_HasAmbigNcbi8na(const char* src, size_t length)
  1114. {
  1115.     const bool *not_ambig = CNcbi8naAmbig::GetTable();
  1116.     
  1117.     const char* end = src + length;
  1118.     
  1119.     const char* iter = src;
  1120.     while ( (iter != end)  &&  (not_ambig[static_cast<Uint1>(*iter)]) ) {
  1121.           ++iter;
  1122.     }
  1123.     
  1124.     return iter != end;
  1125. }
  1128. END_NCBI_SCOPE
  1131. /*
  1132. * ===========================================================================
  1133. *
  1134. * $Log: sequtil_convert_imp.cpp,v $
  1135. * Revision 1000.1  2004/06/01 19:42:17  gouriano
  1136. * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.2
  1137. *
  1138. * Revision 1.2  2004/05/17 21:08:53  gorelenk
  1139. * Added include of PCH ncbi_pch.hpp
  1140. *
  1141. * Revision 1.1  2003/10/08 13:34:59  shomrat
  1142. * Initial version
  1143. *
  1144. *
  1145. * ===========================================================================
  1146. */