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

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

生物技术

开发平台：

C/C++

test_seqport.cpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: test_seqport.cpp,v $
  4.  * PRODUCTION Revision 1000.3  2004/06/01 19:33:33  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.13
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. /*  $Id: test_seqport.cpp,v 1000.3 2004/06/01 19:33:33 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:  Clifford Clausen
  36.  *          (also reviewed/fixed/groomed by Denis Vakatov)
  37.  * File Description:
  38.  *   
  39.  */
  41. #include <ncbi_pch.hpp>
  42. #include <corelib/ncbiapp.hpp>
  43. #include <corelib/ncbiargs.hpp>
  44. #include <corelib/ncbienv.hpp>
  45. #include <corelib/ncbireg.hpp>
  47. #include <serial/serial.hpp>
  48. #include <serial/objistr.hpp>
  50. #include <objects/seqset/Seq_entry.hpp>
  51. #include <objects/seqset/Bioseq_set.hpp>
  52. #include <objects/seqfeat/Genetic_code.hpp>
  53. #include <objects/seq/Bioseq.hpp>
  54. #include <objects/seq/NCBI2na.hpp>
  55. #include <objects/seq/NCBI4na.hpp>
  56. #include <objects/seq/IUPACna.hpp>
  57. #include <objects/seq/IUPACaa.hpp>
  58. #include <objects/seq/NCBIeaa.hpp>
  59. #include <objects/seq/NCBIstdaa.hpp>
  60. #include <objects/seq/Seq_inst.hpp>
  62. #include <objects/seq/seqport_util.hpp>
  66. USING_NCBI_SCOPE;
  67. USING_SCOPE(objects);
  69. #define MAX_DISPLAY 48
  72. /////////////////////////////////////////////////////////////////////////////
  73. //
  75. class CSeqportTestApp : public CNcbiApplication
  76. {
  77. public:
  78.     virtual void Init();
  79.     virtual int  Run(void);
  80.     virtual void Exit();
  82.     void DisplaySeq(const CSeq_data& seq, unsigned int uSize=48);
  84.     // Testing methods that require CSeq_data
  85.     void SeqDataTest();
  86.     void GetAmbigsTest(const CSeq_data&     in_seq,
  87.               CSeq_data*           out_seq,
  88.               CSeq_data::E_Choice  to_code,
  89.               TSeqPos              uBeginIdx,
  90.               TSeqPos              uLength);
  91.     void ConvertTest(const CSeq_data&     in_seq,
  92.               CSeq_data*           out_seq,
  93.               CSeq_data::E_Choice  to_code,
  94.               TSeqPos              uBeginIdx,
  95.               TSeqPos              uLength,
  96.               bool                 bAmbig);
  97.     void AppendTest(const CSeq_data&     in_seq,
  98.               CSeq_data*           out_seq,
  99.               TSeqPos              uBeginIdx,
  100.               TSeqPos              uLength);
  101.     void InPlaceReverseComplementTest(const CSeq_data&     in_seq,
  102.               CSeq_data*           out_seq,
  103.               TSeqPos              uBeginIdx,
  104.               TSeqPos              uLength);
  105.     void InCopyReverseComplementTest(const CSeq_data&     in_seq,
  106.               CSeq_data*           out_seq,
  107.               TSeqPos              uBeginIdx,
  108.               TSeqPos              uLength);
  109.     void InPlaceReverseTest(const CSeq_data&     in_seq,
  110.               CSeq_data*           out_seq,
  111.               TSeqPos              uBeginIdx,
  112.               TSeqPos              uLength);
  113.     void InCopyReverseTest(const CSeq_data&     in_seq,
  114.               CSeq_data*           out_seq,
  115.               TSeqPos              uBeginIdx,
  116.               TSeqPos              uLength);
  117.     void InPlaceComplementTest(const CSeq_data&     in_seq,
  118.               CSeq_data*           out_seq,
  119.               TSeqPos              uBeginIdx,
  120.               TSeqPos              uLength);
  121.     void InCopyComplementTest(const CSeq_data&     in_seq,
  122.               CSeq_data*           out_seq,
  123.               TSeqPos              uBeginIdx,
  124.               TSeqPos              uLength);
  125.     void FastValidateTest(const CSeq_data&     in_seq,
  126.               TSeqPos              uBeginIdx,
  127.               TSeqPos              uLength);
  128.     void ValidateTest(const CSeq_data&     in_seq,
  129.               TSeqPos              uBeginIdx,
  130.               TSeqPos              uLength);
  131.     void GetCopyTest(const CSeq_data&     in_seq,
  132.               CSeq_data*           out_seq,
  133.               TSeqPos              uBeginIdx,
  134.               TSeqPos              uLength);
  135.     void KeepTest(const CSeq_data&     in_seq,
  136.               CSeq_data*           out_seq,
  137.               TSeqPos         uBeginIdx,
  138.               TSeqPos         uLength);
  139.     void PackTest(const CSeq_data&     in_seq,
  140.               CSeq_data*           out_seq,
  141.               TSeqPos              uBeginIdx,
  142.               TSeqPos              uLength);
  143.     
  144.     
  145.     // Testing methods that do not require CSeq_data
  146.     void NonSeqDataTest();
  147.     void GetIupacaa3();
  148.     void GetCodeEChoice();
  149.     void GetCodeESeq();
  150.     void GetNameEChoice();    
  151.     void GetNameESeq();
  152.     void GetIndexEChoice();
  153.     void GetIndexESeq();
  154.     void IsCodeAvailableEChoice();
  155.     void IsCodeAvailableESeq();
  156.     void GetCodeIndexFromToEChoice();
  157.     void GetCodeIndexFromToESeq();
  158.     void GetIndexComplementEChoice();
  159.     void GetIndexComplementESeq();
  160.     void GetMapToIndexEChoice();
  161.     void GetMapToIndexESeq();       
  162. };
  167. /////////////////////////////////////////////////////////////////////////////
  168. //
  171. void CSeqportTestApp::Init()
  172. {
  173.     return;
  174. }
  176. int CSeqportTestApp::Run()
  177. {
  178.     while ( true ) {
  179.     
  180.         cout << "Enter type tests to run: " << endl
  181.              << "0) Done" << endl
  182.              << "1) Tests requiring CSeq_dat" << endl
  183.              << "2) Tests not requiring CSeq_dat" << endl; 
  185.         int resp;
  186.         cin >> resp;
  187.         
  188.         switch (resp) {
  189.         case 0:
  190.             return 0;
  191.         case 1:
  192.             SeqDataTest();
  193.             break;
  194.         case 2:
  195.             NonSeqDataTest();
  196.             break;
  197.         }
  198.     }
  199. }
  202. static int GetChoice()
  203. {
  204.     int choice = -1;
  205.     while ( (choice < 0 || choice > 11) && (choice != 99) ) {
  206.         cout << "Enter code type choice:" << endl
  207.              << "0:  Not set" << endl
  208.              << "1:  Iupacna" << endl
  209.              << "2:  Iupacaa" << endl
  210.              << "3:  Ncbi2na" << endl
  211.              << "4:  Ncbi4na" << endl
  212.              << "5:  Ncbi8na" << endl
  213.              << "6:  Ncbipna" << endl
  214.              << "7:  Ncbi8aa" << endl
  215.              << "8:  Ncbieaa" << endl
  216.              << "9:  Ncbipaa" << endl
  217.              << "10: Ncbistdaa" << endl
  218.              << "11: Iupacaa3" << endl
  219.              << "99: Done" << endl;
  220.         cin >> choice;
  221.     }    
  222.     return choice;  
  223. }
  225. static CSeq_data::E_Choice GetEChoice()
  226. {
  227.     int choice = GetChoice();
  228.     
  229.     switch (choice) {
  230.     case 0:
  231.         return CSeq_data::e_not_set;
  232.     case 1:
  233.         return CSeq_data::e_Iupacna;
  234.     case 2:
  235.         return CSeq_data::e_Iupacaa;
  236.     case 3:
  237.         return CSeq_data::e_Ncbi2na;
  238.     case 4:
  239.         return CSeq_data::e_Ncbi4na;
  240.     case 5:
  241.         return CSeq_data::e_Ncbi8na;
  242.     case 6:
  243.         return CSeq_data::e_Ncbipna;
  244.     case 7:
  245.         return CSeq_data::e_Ncbi8aa;
  246.     case 8:
  247.         return CSeq_data::e_Ncbieaa;
  248.     case 9:
  249.         return CSeq_data::e_Ncbipaa;
  250.     case 10:
  251.         return CSeq_data::e_Ncbistdaa;
  252.     case 99:
  253.         throw runtime_error("Done");
  254.     }
  255.     cout << "Requested code not CSeq_data:E_Choice" << endl;
  256.     cout << "Using CSeq_data::e_not_set" << endl;
  257.     return CSeq_data::e_not_set;
  258. }
  260. static ESeq_code_type GetESeqCodeType()
  261. {
  262.     int choice = GetChoice();
  263.     
  264.     switch (choice) {
  265.     case 1:
  266.         return eSeq_code_type_iupacna;
  267.     case 2:
  268.         return eSeq_code_type_iupacaa;
  269.     case 3:
  270.         return eSeq_code_type_ncbi2na;
  271.     case 4:
  272.         return eSeq_code_type_ncbi4na;
  273.     case 5:
  274.         return eSeq_code_type_ncbi8na;
  275.     case 6:
  276.         return eSeq_code_type_ncbipna;
  277.     case 7:
  278.         return eSeq_code_type_ncbi8aa;
  279.     case 8:
  280.         return eSeq_code_type_ncbieaa;
  281.     case 9:
  282.         return eSeq_code_type_ncbipaa;
  283.     case 10:
  284.         return eSeq_code_type_ncbistdaa;
  285.     case 11:
  286.         return eSeq_code_type_iupacaa3;
  287.     case 99:
  288.         throw runtime_error("Done");
  289.     }
  290.     cout << "Requested code no an ESeq_code_type. Using iupacna." << endl;
  291.     return eSeq_code_type_iupacna;
  292. }
  295. void CSeqportTestApp::GetIupacaa3()
  296. {
  297.     unsigned int ncbistdaa;
  298.     cout << "Enter Ncbistdaa index: ";
  299.     cin >> ncbistdaa;
  300.     string iupacaa3;
  301.     iupacaa3 = CSeqportUtil::GetIupacaa3(ncbistdaa);
  302.     cout << "Iupacaa3 is : " << iupacaa3 << endl;
  303.     throw runtime_error("Done");
  304. }
  306. void CSeqportTestApp::GetCodeEChoice()
  307. {   
  308.     CSeq_data::E_Choice code_type = GetEChoice();  
  309.     CSeqportUtil::TIndex idx;
  310.     cout << "Enter index: ";
  311.     cin >> idx;
  312.     string code;
  313.     code = CSeqportUtil::GetCode(code_type, idx);
  314.     cout << "Code is : " << code << endl;
  315. }
  317. void CSeqportTestApp::GetCodeESeq()
  318. {
  319.     ESeq_code_type code_type = GetESeqCodeType();
  320.     int idx;
  321.     cout << "Enter index: ";
  322.     cin >> idx;
  323.     string code;
  324.     code = CSeqportUtil::GetCode(code_type, idx);
  325.     cout << "Code is : " << code << endl;
  326. }
  328. void CSeqportTestApp::GetNameEChoice()
  329. {
  330.     CSeq_data::E_Choice code_type = GetEChoice();
  331.     int idx;
  332.     cout << "Enter index: ";
  333.     cin >> idx;
  334.     string code;
  335.     code = CSeqportUtil::GetName(code_type, idx);
  336.     cout << "Name is : " << code << endl;
  337. }
  339. void CSeqportTestApp::GetNameESeq()
  340. {
  341.     ESeq_code_type code_type = GetESeqCodeType();
  342.     int idx;
  343.     cout << "Enter index: ";
  344.     cin >> idx;
  345.     string code;
  346.     code = CSeqportUtil::GetName(code_type, idx);
  347.     cout << "Name is : " << code << endl;
  348. }
  350. void CSeqportTestApp::GetIndexEChoice()
  351. {
  352.     CSeq_data::E_Choice code_type = GetEChoice();
  353.     string code;
  354.     cout << "Enter code: ";
  355.     cin >> code;
  356.     int idx = CSeqportUtil::GetIndex(code_type, code);
  357.     cout << "Index is : " << idx << endl;
  358. }
  360. void CSeqportTestApp::GetIndexESeq()
  361. {
  362.     ESeq_code_type code_type = GetESeqCodeType();
  363.     string code;
  364.     cout << "Enter code: ";
  365.     cin >> code;
  366.     int idx = CSeqportUtil::GetIndex(code_type, code);
  367.     cout << "Index is : " << idx << endl;
  368. }
  370. void CSeqportTestApp::IsCodeAvailableEChoice()
  371. {
  372.     CSeq_data::E_Choice code_type = GetEChoice();
  373.     bool avail = CSeqportUtil::IsCodeAvailable(code_type);
  374.     cout << "Code availabe is " << avail << endl;
  375. }
  377. void CSeqportTestApp::IsCodeAvailableESeq()
  378. {
  379.     ESeq_code_type code_type = GetESeqCodeType();
  380.     bool avail= CSeqportUtil::IsCodeAvailable(code_type);
  381.     cout << "Code availabe is " << avail << endl;
  382. }
  384. void CSeqportTestApp::GetCodeIndexFromToEChoice()
  385. {
  386.     CSeq_data::E_Choice code_type = GetEChoice();
  387.     CSeqportUtil::TPair from_to = 
  388.         CSeqportUtil::GetCodeIndexFromTo(code_type);
  389.     cout << "From is " << from_to.first
  390.          << ": To is " << from_to.second << endl;
  391. }
  393. void CSeqportTestApp::GetCodeIndexFromToESeq()
  394. {
  395.     ESeq_code_type code_type = GetESeqCodeType();
  396.     CSeqportUtil::TPair from_to = 
  397.         CSeqportUtil::GetCodeIndexFromTo(code_type);
  398.     cout << "From is " << from_to.first
  399.          << ": To is " << from_to.second << endl;
  400. }
  402. void CSeqportTestApp::GetIndexComplementEChoice()
  403. {
  404.     CSeq_data::E_Choice code_type = GetEChoice();
  405.     cout << "Enter index: ";
  406.     int idx;
  407.     cin >> idx;
  408.     int c_idx = CSeqportUtil::GetIndexComplement(code_type, idx);
  409.     cout << "Complement for index " << idx << " is " << c_idx << endl;
  410. }
  412. void CSeqportTestApp::GetIndexComplementESeq()
  413. {
  414.     ESeq_code_type code_type = GetESeqCodeType();
  415.     cout << "Enter index: ";
  416.     int idx;
  417.     cin >> idx;
  418.     int c_idx = CSeqportUtil::GetIndexComplement(code_type, idx);
  419.     cout << "Complement for index " << idx << " is " << c_idx << endl;
  420. }
  422. void CSeqportTestApp::GetMapToIndexEChoice()
  423. {
  424.     cout << "From type: " << endl;
  425.     CSeq_data::E_Choice from_type = GetEChoice();
  426.     cout << "To type: " << endl;
  427.     CSeq_data::E_Choice to_type = GetEChoice();
  428.     cout << "Enter from index: ";
  429.     int from_idx;
  430.     cin >> from_idx;
  431.     int to_idx = CSeqportUtil::GetMapToIndex(from_type, to_type, from_idx);
  432.     cout << "From index maps to " << to_idx << endl;
  433. }
  435. void CSeqportTestApp::GetMapToIndexESeq()
  436. {
  437.     cout << "From type: " << endl;
  438.     ESeq_code_type from_type = GetESeqCodeType();
  439.     cout << "To type: " << endl;
  440.     ESeq_code_type to_type = GetESeqCodeType();
  441.     cout << "Enter from index: ";
  442.     int from_idx;
  443.     cin >> from_idx;
  444.     int to_idx = CSeqportUtil::GetMapToIndex(from_type, to_type, from_idx);
  445.     cout << "From index maps to " << to_idx << endl;
  446. }
  448. void CSeqportTestApp::NonSeqDataTest()
  449. {
  450.     while (true) {
  451.         cout << "Enter test to run: " << endl
  452.              << "0)  Done " << endl
  453.              << "1)  GetIupacaa3() " << endl
  454.              << "2)  GetCode(E_Choice) " << endl
  455.              << "3)  GetCode(ESeq_code_type) " << endl
  456.              << "4)  GetName(E_Choice) " << endl
  457.              << "5)  GetName(ESeq_code_type) " << endl
  458.              << "6)  GetIndex(E_Choice) " << endl
  459.              << "7)  GetIndex(ESeq_code_type) " << endl
  460.              << "8)  IsCodeAvailable(E_Choice) " << endl
  461.              << "9)  IsCodeAvailable(ESeq_code_type) " << endl
  462.              << "10) GetCodeIndexFromTo(E_Choice) " << endl
  463.              << "11) GetCodeIndexFromTo(ESeq_code_type) " << endl
  464.              << "12) GetIndexComplement(E_Choice) " << endl
  465.              << "13) GetIndexComplement(ESeq_code_type) " << endl
  466.              << "14) GetMapToIndex(E_Choice) " << endl
  467.              << "15) GetMapToIndex(ESeq) " << endl
  468.              << endl;
  469.         int resp;
  470.         cin >> resp;
  471.         while (true) {
  472.             try {
  473.                 switch (resp) {
  474.                 case 0:
  475.                     return;
  476.                 case 1:   
  477.                     GetIupacaa3();
  478.                     break;
  479.                 case 2:
  480.                     GetCodeEChoice();
  481.                     break;
  482.                 case 3:
  483.                     GetCodeESeq();
  484.                     break;
  485.                 case 4:
  486.                     GetNameEChoice();
  487.                     break;
  488.                 case 5:
  489.                     GetNameESeq();
  490.                     break;
  491.                 case 6:
  492.                     GetIndexEChoice();
  493.                     break;
  494.                 case 7:
  495.                     GetIndexESeq();
  496.                     break;
  497.                 case 8:
  498.                     IsCodeAvailableEChoice();
  499.                     break;
  500.                 case 9:
  501.                     IsCodeAvailableESeq();
  502.                     break;
  503.                 case 10:
  504.                     GetCodeIndexFromToEChoice();
  505.                     break;
  506.                 case 11:
  507.                     GetCodeIndexFromToESeq();
  508.                     break;
  509.                 case 12:
  510.                     GetIndexComplementEChoice();
  511.                     break;
  512.                 case 13:
  513.                     GetIndexComplementESeq();
  514.                     break;
  515.                 case 14:
  516.                     GetMapToIndexEChoice();
  517.                     break;
  518.                 case 15:
  519.                     GetMapToIndexESeq();
  520.                     break;
  521.                 }
  522.             } catch (runtime_error e) {
  523.                 string msg(e.what());
  524.                 if (msg == "Done") {
  525.                     break;
  526.                 }
  527.                 cout << msg << endl;
  528.             } 
  529.         }
  530.     }    
  531. }
  534. void CSeqportTestApp::SeqDataTest()
  535. {
  536.     //Declare local variables
  537.     unsigned int nTimes=0, uOverhang=0;
  538.     TSeqPos uSeqLen = 0, uCnt = 0;
  539.     int nInSeqType, nOutSeqType;
  540.     CSeq_data::E_Choice to_code = CSeq_data::e_not_set;
  541.     bool bAmbig;
  543.     //Create in CSeq_data 
  544.     CRef<CSeq_data> in_seq(new CSeq_data); 
  545.     
  546.     //Enter in sequence type
  547.     nInSeqType = -1;
  548.     while(nInSeqType<0) {
  549.         cout << "Enter input sequence type " << endl;
  550.         cout <<
  551.             "(0=ncbi2na, 1=ncbi4na, 2=iupacna, 3=ncbieaa,"
  552.             " 4=ncbistdaa, 5=iupacaa): ";
  553.         cin >> nInSeqType;
  554.         if(nInSeqType > 5)
  555.             nInSeqType = -1;
  556.     }  
  557.   
  558.     //Enter out sequence type
  559.     nOutSeqType = -1;
  560.     while(nOutSeqType<0) {
  561.         cout << "Enter output sequence type " << endl;
  562.         cout <<
  563.             "(0=ncbi2na, 1=ncbi4na, 2=iupacna, 3=ncbieaa,"
  564.             " 4=ncbistdaa, 5=iupacaa): ";
  565.         cin >> nOutSeqType;
  566.         if(nOutSeqType > 5)
  567.             nOutSeqType = -1;
  568.     } 
  569.     bAmbig = false;
  570.     if(((nInSeqType==1) || (nInSeqType==2)) && (nOutSeqType==0))
  571.         {
  572.             cout << "Randomly disambiguate (1 = Yes, 0 = No)? ";
  573.             unsigned int nAmbig = 0;
  574.             cin >> nAmbig;
  575.             if(nAmbig!=0)
  576.                 bAmbig = true;
  577.         }
  579.     switch(nOutSeqType){
  580.     case 0:
  581.         to_code = CSeq_data::e_Ncbi2na;
  582.         break;
  583.     case 1:
  584.         to_code = CSeq_data::e_Ncbi4na;
  585.         break;
  586.     case 2:
  587.         to_code = CSeq_data::e_Iupacna;
  588.         break;
  589.     case 3:
  590.         to_code = CSeq_data::e_Ncbieaa;
  591.         break;
  592.     case 4:
  593.         to_code = CSeq_data::e_Ncbistdaa;
  594.         break;
  595.     case 5:
  596.         to_code = CSeq_data::e_Iupacaa;
  597.         break;
  598.     }
  599.   
  600.     //Enter desired sequence length
  601.     uSeqLen = 0;
  602.     cout << "Enter desired sequence length: ";
  603.     cin >> uSeqLen;
  604.       
  605.     //Get input depending on type of input sequence
  606.     if(nInSeqType == 2 || nInSeqType == 3 || nInSeqType == 5) {
  607.         //Enter an in sequence string
  608.         string str = "";
  609.         cout << "Enter an input sequence string: " << endl;
  610.         cin >> str;
  611.         if(str.size() > 0) {
  612.             nTimes = uSeqLen/str.size();
  613.             uOverhang = uSeqLen % str.size();
  614.         }
  615.         in_seq->Reset();
  616.         int nSize = str.size();
  617.         const char* s = str.c_str();
  618.         switch(nInSeqType) {
  619.         case 2:
  620.             in_seq->SetIupacna().Set().resize(uSeqLen);
  621.             for(unsigned int i=0; i<nTimes; i++){               
  622.                 in_seq->SetIupacna().Set().replace
  623.                     (i*nSize,nSize,s);
  624.                 string tst = in_seq->SetIupacna().Set();
  625.             } 
  626.             if (uOverhang > 0) {         
  627.                 in_seq->SetIupacna().Set().replace
  628.                     (nTimes*str.size(),uOverhang,str.substr(0,uOverhang)); 
  629.             } 
  630.             break;
  631.         case 3:
  632.             in_seq->SetNcbieaa().Set().resize(uSeqLen);
  633.             for(unsigned int i=0; i<nTimes; i++) {
  634.                 in_seq->SetNcbieaa().Set().replace
  635.                     (i*nSize,nSize,s);
  636.             }
  637.             if (uOverhang > 0) {         
  638.                 in_seq->SetNcbieaa().Set().replace
  639.                     (nTimes*str.size(),uOverhang,str.substr(0,uOverhang)); 
  640.             }    
  641.             break;
  642.         case 5:
  643.             in_seq->SetIupacaa().Set().resize(uSeqLen);
  644.             for(unsigned int i=0; i<nTimes; i++) {
  645.                 in_seq->SetIupacaa().Set().replace
  646.                     (i*nSize,nSize,s);
  647.             }            
  648.             if (uOverhang > 0) {         
  649.                 in_seq->SetIupacaa().Set().replace
  650.                     (nTimes*str.size(),uOverhang,str.substr(0,uOverhang));
  651.             }
  652.             break;
  653.         }
  654.     }
  655.     else {
  656.         //Enter an in sequence vector
  657.         cout << "Enter an input sequence vector in hex (end with -1): "
  658.              << endl;
  659.         int nIn = 0;
  660.         vector<char> v;
  661.         uCnt = 0;
  662.         while(uCnt < uSeqLen)
  663.             {
  664.                 cin >> std::hex >> nIn;
  665.                 if(nIn < 0 || nIn > 255) {
  666.                     break;
  667.                 }
  668.                 v.push_back(nIn);
  669.                 switch(nInSeqType){
  670.                 case 0:
  671.                     uCnt+=4;
  672.                     break;
  673.                 case 1:
  674.                     uCnt+=2;
  675.                     break;
  676.                 default:
  677.                     uCnt++;
  678.                 }
  679.             }
  680.         if(v.size() == 0) {
  681.             cout << "No input sequence given. Setting to 0." << endl;
  682.             v.push_back(0);
  683.         }
  684.         TSeqPos uInSize;
  685.         switch(nInSeqType) {
  686.         case 0:
  687.             if((uSeqLen % 4) != 0) {
  688.                 uSeqLen += (4-(uSeqLen % 4));
  689.             }
  690.             uInSize = 4*v.size();
  691.             if(uSeqLen % uInSize == 0) {
  692.                 nTimes = uSeqLen/uInSize;
  693.             }
  694.             else {
  695.                 nTimes = uSeqLen/uInSize + 1;
  696.             }
  697.             break;
  698.         case 1:
  699.             if((uSeqLen % 2) != 0) {
  700.                 uSeqLen += (2-(uSeqLen % 2));
  701.             }
  702.             uInSize = 2*v.size();
  703.             if(uSeqLen % uInSize == 0) {
  704.                 nTimes = uSeqLen/uInSize;
  705.             }
  706.             else {
  707.                 nTimes = uSeqLen/uInSize + 1;
  708.             }
  709.             break;
  710.         case 4:
  711.             if(uSeqLen % v.size() == 0) {
  712.                 nTimes = uSeqLen/v.size();
  713.             }
  714.             else {
  715.                 nTimes = uSeqLen/v.size() + 1;
  716.             }
  717.             break;
  718.         }
  719.         
  720.         switch(nInSeqType){
  721.         case 0:
  722.             for(unsigned int i=0; i<nTimes; i++) {
  723.                 ITERATE (vector<char>, j, v) {
  724.                     in_seq->SetNcbi2na().Set().push_back(*j);
  725.                 }
  726.             }
  727.             break;
  728.         case 1:
  729.             for(unsigned int i=0; i<nTimes; i++) {
  730.                 ITERATE (vector<char>, j, v) {
  731.                     in_seq->SetNcbi4na().Set().push_back(*j);
  732.                 }
  733.             }
  734.             break;
  735.         case 4:
  736.             for(unsigned int i=0; i<nTimes; i++) {
  737.                 ITERATE (vector<char>, j, v) {
  738.                     in_seq->SetNcbistdaa().Set().push_back(*j);
  739.                 }
  740.             }
  741.             break;
  742.         }
  743.     }
  744.   
  745.     //Enter Begin Index (relative to biological sequence)
  746.     TSeqPos uBeginIdx = 0, uLength = 0;
  747.     cout << "Enter begin index to Convert: ";
  748.     cin >> std::dec >> uBeginIdx;
  749.     
  750.     //Enter Length of sequence to Convert
  751.     cout << "Enter length of sequence to Convert: ";
  752.     cin >> uLength;
  753.     
  754.     //Create out_seq
  755.     CRef<CSeq_data> out_seq(new CSeq_data);
  756.     
  757.     int nResponse;
  758.     
  759.     while (true) {
  760.         cout << "Enter test to run:" << endl
  761.              << "0)  Quit" << endl
  762.              << "1)  GetAmbigsTest" << endl
  763.              << "2)  ConvertTest" << endl
  764.              << "3)  AppendTest" << endl
  765.              << "4)  InPlaceReverseComplementTest" << endl
  766.              << "5)  InCopyReverseComplementTest" << endl
  767.              << "6)  InPlaceReverseTest" << endl
  768.              << "7)  InCopyReverseTest" << endl
  769.              << "8)  InPlaceComplementTest" << endl
  770.              << "9) InCopyComplementTest" << endl
  771.              << "10) FastValidateTest" << endl
  772.              << "11) ValidateTest" << endl
  773.              << "12) GetCopyTest" << endl
  774.              << "13) KeepTest" << endl
  775.              << "14) PackTest" << endl; 
  776.         cin >> nResponse;   
  777.          
  778.         switch (nResponse) {
  779.         case 0:
  780.             return;
  781.         case 1:
  782.             GetAmbigsTest
  783.                 (*in_seq, out_seq, to_code, uBeginIdx, uLength);
  784.             break;
  785.         case 2:
  786.             ConvertTest(*in_seq, out_seq, to_code, uBeginIdx, uLength, bAmbig);
  787.             break;
  788.         case 3:
  789.             AppendTest(*in_seq, out_seq, uBeginIdx, uLength);
  790.             break;
  791.         case 4:
  792.             InPlaceReverseComplementTest
  793.                 (*in_seq, out_seq, uBeginIdx, uLength);
  794.             break;
  795.         case 5:
  796.             InCopyReverseComplementTest
  797.                 (*in_seq, out_seq, uBeginIdx, uLength);
  798.             break;
  799.         case 6:
  800.             InPlaceReverseTest
  801.                 (*in_seq, out_seq, uBeginIdx, uLength);
  802.             break;
  803.         case 7:
  804.             InCopyReverseTest
  805.                 (*in_seq, out_seq, uBeginIdx, uLength);
  806.             break;
  807.         case 8:
  808.             InPlaceComplementTest
  809.                 (*in_seq, out_seq, uBeginIdx, uLength);
  810.             break;
  811.         case 9:
  812.             InCopyComplementTest
  813.                 (*in_seq, out_seq, uBeginIdx, uLength);
  814.             break;
  815.         case 10:
  816.             FastValidateTest
  817.                 (*in_seq, uBeginIdx, uLength);
  818.             break;
  819.         case 11:
  820.             ValidateTest
  821.                 (*in_seq, uBeginIdx, uLength);
  822.             break;
  823.         case 12:
  824.             GetCopyTest(*in_seq, out_seq, uBeginIdx, uLength);
  825.             break;
  826.         case 13:
  827.             KeepTest(*in_seq, out_seq, uBeginIdx, uLength);
  828.             break;
  829.         case 14:
  830.             PackTest(*in_seq, out_seq, uBeginIdx, uLength);
  831.             break;
  832.         default:
  833.             break;
  834.         }
  835.     }        
  836. }
  838.  
  839. void CSeqportTestApp::GetAmbigsTest(const CSeq_data&     in_seq,
  840.               CSeq_data*           out_seq,
  841.               CSeq_data::E_Choice  to_code,
  842.               TSeqPos              uBeginIdx,
  843.               TSeqPos              uLength)
  844. {
  845.     TSeqPos uSeqLen=0;
  846.     
  847.     try {
  848.         vector<TSeqPos> out_indices;
  849.     
  850.         TSeqPos uLen = CSeqportUtil::GetAmbigs
  851.             (in_seq,
  852.              out_seq,
  853.              &out_indices,
  854.              to_code,
  855.              uBeginIdx,
  856.              uLength);
  857.     
  858.     
  859.         cout << endl << "Results for GetAmbigs()" << endl;
  860.         cout << "uSeqLen = " << uSeqLen << endl;
  861.         cout << "(uBeginIdx, uLength) = (" << uBeginIdx
  862.              << ", " << uLength << ")" << endl;
  863.         cout << "Num ambigs = " << out_indices.size() << endl;
  864.         cout << "Return length = " << uLen << endl;
  865.   
  866.         if(out_seq->Which() == CSeq_data::e_Ncbi4na) {
  867.             if (out_indices.size() <= 24) {
  868.                 ITERATE (vector<TSeqPos>, i_idx, out_indices) {
  869.                     cout << (*i_idx) << " ";
  870.                 }
  871.                 cout << endl;
  872.                 const vector<char>& out_seq_data
  873.                     = out_seq->GetNcbi4na().Get();
  874.                 ITERATE (vector<char>, i_out, out_seq_data) {
  875.                     cout << std::hex
  876.                          << (unsigned short)(unsigned char) *i_out << " ";
  877.                 }
  878.                 cout << endl;
  879.             }
  880.         }
  881.         else if(out_seq->Which() == CSeq_data::e_Iupacna) {
  882.             if(out_indices.size() <= 24) {
  883.                 ITERATE (vector<TSeqPos>, i_idx, out_indices) {
  884.                     cout << (*i_idx) << " ";
  885.                 }
  886.                 cout << endl;
  887.                 string out_seq_data = out_seq->GetIupacna().Get();
  888.                 cout << out_seq_data << endl;
  889.             }
  890.         
  891.         }
  892.         out_indices.clear();
  893.         out_seq->Reset();   
  894.     }
  895.     STD_CATCH("");
  896. }
  899. void CSeqportTestApp::ConvertTest(const CSeq_data&     in_seq,
  900.               CSeq_data*           out_seq,
  901.               CSeq_data::E_Choice  to_code,
  902.               TSeqPos              uBeginIdx,
  903.               TSeqPos              uLength,
  904.               bool                 bAmbig)
  905. {
  906.     TSeqPos uSeqLen=0;
  907.     
  908.     try{ 
  909.         TSeqPos uLen = CSeqportUtil::Convert
  910.             (in_seq, out_seq, to_code, uBeginIdx, uLength, bAmbig);
  912.         cout << endl << "Conversion Results" << endl;
  913.         cout << "uSeqLen = " << uSeqLen  << endl;
  914.         cout << "Return length = " << uLen << endl;
  915.         
  916.         //Write input and ouput sequences if uSeqLen <= 50
  917.         //Print uBeginIdx and uLength
  918.         cout << "(uBeginIdx, uLength) = (" << uBeginIdx
  919.              << ", " << uLength << ")" << endl;
  920.         
  921.         //Print the in sequence
  922.         cout << "Input sequence is: " << endl;
  923.         DisplaySeq(in_seq, MAX_DISPLAY);
  924.       
  925.         //Print the out sequence
  926.         cout << "Output sequence is: " << endl;
  927.         DisplaySeq(*out_seq, MAX_DISPLAY);
  928.              
  929.         //Reset output sequence
  930.         out_seq->Reset();
  931.       
  932.     } 
  933.     STD_CATCH("");
  934. }
  936. void CSeqportTestApp::AppendTest(const CSeq_data&     in_seq,
  937.               CSeq_data*           out_seq,
  938.               TSeqPos              uBeginIdx,
  939.               TSeqPos              uLength)
  940. {
  941.     TSeqPos uSeqLen=0;
  942.     
  943.     try{
  944.         TSeqPos uBeginIdx2, uLength2;
  945.         cout << "(uBeginIdx1, uLength1) = (" 
  946.              << uBeginIdx << "," << uLength << ")" << endl;
  947.         cout << "Enter uBeginIdx2: ";
  948.         cin >> uBeginIdx2;
  949.         cout << "Enter uLength2: ";
  950.         cin >> uLength2;
  951.         CRef<CSeq_data> in_seq1(new CSeq_data);
  952.         CRef<CSeq_data> in_seq2(new CSeq_data);
  953.         CSeqportUtil::GetCopy(in_seq, in_seq1, uBeginIdx, uLength);
  954.         CSeqportUtil::GetCopy(in_seq, in_seq2, 0, 0);
  955.         TSeqPos uLen = CSeqportUtil::Append(out_seq,
  956.                                       *in_seq1.GetPointer(),
  957.                                       uBeginIdx, uLength,
  958.                                       *in_seq2.GetPointer(), 
  959.                                       uBeginIdx2, uLength2);
  960.     
  961.         cout << endl << "Append Results" << endl;
  962.         cout << "uSeqLen = " << uSeqLen << endl;
  963.         cout << "(uBeginIdx1, uLength1) = (" << uBeginIdx
  964.              << ", " << uLength << ")" << endl;
  965.         cout << "(uBeginIdx2, uLength2) = (" << uBeginIdx2
  966.              << ", " << uLength2 << ")" << endl;
  967.         cout << "Return length = " << uLen << endl;
  968.   
  969.         //Print the Append out_seq
  970.         cout << "Append output sequence is: " << endl;
  971.         DisplaySeq(*out_seq, MAX_DISPLAY);
  972.         
  973.         //Reset out_seq to free memory
  974.         out_seq->Reset();
  975.     }
  976.     STD_CATCH("");
  977. }
  979. void CSeqportTestApp::InPlaceReverseComplementTest(const CSeq_data&     in_seq,
  980.               CSeq_data*           out_seq,
  981.               TSeqPos              uBeginIdx,
  982.               TSeqPos              uLength)
  983. {
  984.     TSeqPos uSeqLen=0;
  986.     try{
  987.         CSeqportUtil::GetCopy(in_seq, out_seq, 0, 0);
  988.         TSeqPos uLen
  989.             = CSeqportUtil::ReverseComplement(out_seq, uBeginIdx, uLength);
  990.         cout << endl << "In-place reverse complement results" << endl;
  991.         cout << "uSeqLen = " << uSeqLen << endl;
  992.         cout << "(uBeginIdx, uLength) = (" << uBeginIdx
  993.              << ", " << uLength << ")" << endl;
  994.         cout << "Return length = " << uLen << endl;
  995.   
  996.         //Print the In-place reverse-complement sequence
  997.         cout << "In-place reverse-complement sequence is: " << endl;
  998.         DisplaySeq(*out_seq, MAX_DISPLAY);
  999.         
  1000.         //Reset out_seq to free memory
  1001.         out_seq->Reset();
  1002.     }
  1003.     STD_CATCH("");
  1004. }
  1006. void CSeqportTestApp::InCopyReverseComplementTest(const CSeq_data&     in_seq,
  1007.               CSeq_data*           out_seq,
  1008.               TSeqPos              uBeginIdx,
  1009.               TSeqPos              uLength)
  1010. {
  1011.     TSeqPos uSeqLen=0;
  1013.     try{
  1014.         TSeqPos uLen = CSeqportUtil::ReverseComplement
  1015.             (in_seq, out_seq, uBeginIdx, uLength);
  1016.     
  1017.         cout << endl << "Reverse-complement Results" << endl;
  1018.         cout << "uSeqLen = " << uSeqLen << endl;
  1019.         cout << "(uBeginIdx, uLength) = (" << uBeginIdx
  1020.              << ", " << uLength << ")" << endl;
  1021.         cout << "Return length = " << uLen << endl;
  1022.   
  1023.         //Print the reverse-complement sequence
  1024.         cout << "Reverse-complement sequence is: " << endl;
  1025.         DisplaySeq(*out_seq, MAX_DISPLAY);
  1026.         
  1027.         //Reset out_seq to free memory
  1028.         out_seq->Reset();
  1029.     }
  1030.     STD_CATCH("");
  1031. }
  1033. void CSeqportTestApp::InPlaceReverseTest(const CSeq_data&     in_seq,
  1034.               CSeq_data*           out_seq,
  1035.               TSeqPos              uBeginIdx,
  1036.               TSeqPos              uLength)
  1037. {
  1038.     TSeqPos uSeqLen=0;
  1040.     try{
  1041.         CSeqportUtil::GetCopy(in_seq, out_seq, 0, 0);
  1042.         TSeqPos uLen = 
  1043.             CSeqportUtil::Reverse(out_seq, uBeginIdx, uLength);
  1044.     
  1045.         cout << endl << "In-place Reverse Results" << endl;
  1046.         cout << "uSeqLen = " << uSeqLen << endl;
  1047.         cout << "(uBeginIdx, uLength) = (" << uBeginIdx
  1048.              << ", " << uLength << ")" << endl;
  1049.         cout << "Return length = " << uLen << endl;
  1050.   
  1051.         //Print the In-place reverse sequence
  1052.         cout << "In-place reverse sequence is: " << endl;
  1053.         DisplaySeq(*out_seq, MAX_DISPLAY);
  1054.         
  1055.         //Reset out_seq to free memory
  1056.         out_seq->Reset();
  1057.     }
  1058.     STD_CATCH("");
  1059. }
  1061. void CSeqportTestApp::InCopyReverseTest(const CSeq_data&     in_seq,
  1062.               CSeq_data*           out_seq,
  1063.               TSeqPos              uBeginIdx,
  1064.               TSeqPos              uLength)
  1065. {
  1066.     TSeqPos uSeqLen=0;
  1068.     try{
  1069.         TSeqPos uLen = CSeqportUtil::Reverse
  1070.             (in_seq, out_seq, uBeginIdx, uLength);
  1071.     
  1072.         cout << endl << "Reverse Results" << endl;
  1073.         cout << "uSeqLen = " << uSeqLen << endl;
  1074.         cout << "(uBeginIdx, uLength) = (" << uBeginIdx <<
  1075.             ", " << uLength << ")" << endl;
  1076.         cout << "Return length = " << uLen << endl;
  1077.   
  1078.         //Print the reverse sequence
  1079.         cout << "Reverse sequence is: " << endl;
  1080.         DisplaySeq(*out_seq, MAX_DISPLAY);
  1081.         
  1082.         //Reset out_seq to free memory
  1083.         out_seq->Reset();
  1084.     }
  1085.     STD_CATCH("");
  1086. }
  1088. void CSeqportTestApp::InPlaceComplementTest(const CSeq_data&     in_seq,
  1089.               CSeq_data*           out_seq,
  1090.               TSeqPos              uBeginIdx,
  1091.               TSeqPos              uLength)
  1092. {
  1093.     TSeqPos uSeqLen=0;
  1095.     try{
  1096.         CSeqportUtil::GetCopy(in_seq, out_seq, 0, 0);
  1097.         TSeqPos uLen = CSeqportUtil::Complement
  1098.             (out_seq, uBeginIdx, uLength);
  1099.     
  1100.         cout << endl << "In-place Complement Results" << endl;
  1101.         cout << "uSeqLen = " << uSeqLen << endl;
  1102.         cout << "(uBeginIdx, uLength) = (" << uBeginIdx <<
  1103.             ", " << uLength << ")" << endl;
  1104.         cout << "Return length = " << uLen << endl;
  1105.   
  1106.         //Print the In-place complement sequence
  1107.         cout << "In-place complement sequence is: " << endl;
  1108.         DisplaySeq(*out_seq, MAX_DISPLAY);
  1109.         
  1110.         //Reset out_seq to free memory
  1111.         out_seq->Reset();
  1112.     }
  1113.     STD_CATCH("");
  1114. }
  1115.  
  1116. void CSeqportTestApp::InCopyComplementTest(const CSeq_data&     in_seq,
  1117.               CSeq_data*           out_seq,
  1118.               TSeqPos              uBeginIdx,
  1119.               TSeqPos              uLength)
  1120. {
  1121.     TSeqPos uSeqLen=0;
  1123.     try{
  1124.         TSeqPos uLen = CSeqportUtil::Complement
  1125.             (in_seq, out_seq, uBeginIdx, uLength);
  1126.     
  1127.         cout << endl << "Complement Results" << endl;
  1128.         cout << "uSeqLen = " << uSeqLen << endl;
  1129.         cout << "(uBeginIdx, uLength) = (" << uBeginIdx <<
  1130.             ", " << uLength << ")" << endl;
  1131.         cout << "Return length = " << uLen << endl;
  1132.   
  1133.         //Print the complement sequence
  1134.         cout << "Complement sequence is: " << endl;
  1135.         DisplaySeq(*out_seq, MAX_DISPLAY);
  1136.         
  1137.         //Reset out_seq to free memory
  1138.         out_seq->Reset();
  1139.     }
  1140.     STD_CATCH("");      
  1141. }
  1143. void CSeqportTestApp::FastValidateTest(const CSeq_data&     in_seq,
  1144.               TSeqPos              uBeginIdx,
  1145.               TSeqPos              uLength)
  1146. {
  1147.     TSeqPos uSeqLen=0;
  1149.     try{
  1150.         bool isValid;
  1151.     
  1152.         isValid = 
  1153.             CSeqportUtil::FastValidate(in_seq, uBeginIdx, uLength);
  1154.     
  1155.         cout << endl << "Fast Validation Results" << endl;
  1156.         cout << "uSeqLen = " << uSeqLen << endl;
  1157.         cout << "(uBeginIdx, uLength) = (" << uBeginIdx
  1158.              << ", " << uLength << ")" <<
  1159.             endl;
  1160.         if(isValid)
  1161.             cout << "in_seq is VALID" << endl;
  1162.         else
  1163.             cout << "in_seq is NOT VALID" << endl;
  1164.     }
  1165.     STD_CATCH("");    
  1166. }
  1168. void CSeqportTestApp::ValidateTest(const CSeq_data&     in_seq,
  1169.               TSeqPos              uBeginIdx,
  1170.               TSeqPos              uLength)
  1171. {
  1172.     TSeqPos uSeqLen=0;
  1174.     try{
  1175.         vector<TSeqPos> badIdx;
  1176.         
  1177.         CSeqportUtil::Validate(in_seq, &badIdx, uBeginIdx, uLength);
  1178.     
  1179.     
  1180.         cout << endl << "Validation Results" << endl;
  1181.         cout << "uSeqLen = " << uSeqLen << endl;
  1182.         cout << "(uBeginIdx, uLength) = (" << uBeginIdx <<
  1183.             ", " << uLength << ")" << endl;
  1184.         if(badIdx.size() <= 50 && badIdx.size() > 0)
  1185.             {
  1186.                 cout << "Bad indices are:" << endl;
  1187.                 vector<TSeqPos>::iterator itor;
  1188.                 for(itor = badIdx.begin(); itor != badIdx.end(); ++itor)
  1189.                     cout << *itor << " ";
  1190.                 cout << endl;
  1191.             }
  1192.         else
  1193.             {
  1194.                 cout << "The number of bad indices are: " << badIdx.size()
  1195.                      << endl;
  1196.             }
  1197.         badIdx.clear();
  1198.     }
  1199.     STD_CATCH("");
  1200. }
  1202. void CSeqportTestApp::GetCopyTest(const CSeq_data&     in_seq,
  1203.               CSeq_data*           out_seq,
  1204.               TSeqPos              uBeginIdx,
  1205.               TSeqPos              uLength)
  1206. {
  1207.     TSeqPos uSeqLen=0;
  1209.     try{      
  1210.         TSeqPos uLen = CSeqportUtil::GetCopy
  1211.             (in_seq, out_seq, uBeginIdx, uLength);
  1212.   
  1213.         cout << endl << "Copy Results" << endl;
  1214.         cout << "uSeqLen = " << uSeqLen  << endl;
  1215.         cout << "Return length = " << uLen << endl;
  1216.   
  1217.         //Print the out sequence
  1218.         cout << "(uBeginIdx, uLength) = (" << uBeginIdx <<
  1219.             ", " << uLength << ")" << endl;
  1220.         cout << "out_seq is: " << endl;
  1221.         DisplaySeq(*out_seq, MAX_DISPLAY);
  1222.         
  1223.         out_seq->Reset();
  1224.     }
  1225.     STD_CATCH("");
  1226. }
  1228. void CSeqportTestApp::KeepTest(const CSeq_data&     in_seq,
  1229.               CSeq_data*           out_seq,
  1230.               TSeqPos              uBeginIdx,
  1231.               TSeqPos              uLength)
  1232. {
  1234.     try{
  1235.         CSeqportUtil::GetCopy(in_seq, out_seq, 0, 0);
  1236.   
  1237.         TSeqPos uLen
  1238.             = CSeqportUtil::Keep(out_seq, uBeginIdx, uLength);
  1239.   
  1240.         cout << endl << "Keep Results" << endl;
  1241.         cout << "uLength = " << uLength  << endl;
  1242.         cout << "Return length = " << uLen << endl;
  1243.   
  1244.         //Print the out sequence
  1245.         cout << "(uBeginIdx, uLength) = (" << uBeginIdx <<
  1246.             ", " << uLength << ")" << endl;
  1247.         cout << "out_seq is: " << endl;
  1248.         DisplaySeq(*out_seq, MAX_DISPLAY);
  1249.         out_seq->Reset();
  1250.     }
  1251.     STD_CATCH("");
  1252. }
  1254. void CSeqportTestApp::PackTest(const CSeq_data&     in_seq,
  1255.               CSeq_data*           out_seq,
  1256.               TSeqPos              uBeginIdx,
  1257.               TSeqPos              uLength)
  1258. {
  1260.     try{
  1261.         CSeqportUtil::GetCopy(in_seq, out_seq, 0, 0);
  1262.   
  1263.         TSeqPos uLen = CSeqportUtil::Pack(out_seq, uLength);
  1264.   
  1265.         cout << endl << "Pack Results" << endl;
  1266.         cout << "uLength = " << uLength  << endl;
  1267.         cout << "Return length = " << uLen << endl;
  1268.   
  1269.         //Print the out sequence
  1270.         cout << "(uBeginIdx, uLength) = (" << uBeginIdx <<
  1271.             ", " << uLength << ")" << endl;
  1272.         switch(out_seq->Which()){
  1273.         case CSeq_data::e_Iupacna:
  1274.             cout << "out_seq is Iupacna" << endl;
  1275.             break;
  1276.         case CSeq_data::e_Ncbi4na:
  1277.             cout << "out_seq is Ncbi4na" << endl;
  1278.             break;
  1279.         case CSeq_data::e_Ncbi2na:
  1280.             cout << "out_seq is Ncbi2na" << endl;
  1281.             break;
  1282.         case CSeq_data::e_Ncbieaa:
  1283.             cout << "out_seq is Ncbieaa" << endl;
  1284.             break;
  1285.         case CSeq_data::e_Ncbistdaa:
  1286.             cout << "out_seq is Ncbistdaa" << endl;
  1287.             break;
  1288.         case CSeq_data::e_Iupacaa:
  1289.             cout << "out_seq is Iupacaa" << endl;
  1290.             break;
  1291.         default:
  1292.             cout << "out_seq type is not supported." << endl;
  1293.             break;
  1294.         }
  1295.         cout << "out_seq is: " << endl;
  1296.         DisplaySeq(*out_seq, MAX_DISPLAY);
  1297.         
  1298.         out_seq->Reset();
  1299.     }
  1300.     STD_CATCH("");
  1301. }
  1303. void CSeqportTestApp::Exit() {
  1304.     return;
  1305. }
  1308. void CSeqportTestApp::DisplaySeq(const CSeq_data& seq, TSeqPos uSize)
  1309. {
  1310.     //Print the sequence
  1311.     switch (seq.Which()) {
  1312.     case CSeq_data::e_Ncbi2na:
  1313.         {
  1314.             const vector<char>& v = seq.GetNcbi2na().Get();
  1315.             if (v.size() <= 12) {
  1316.                 ITERATE (vector<char>, i, v) {
  1317.                     cout << std::hex << (unsigned short)(unsigned char) *i
  1318.                          << " " << endl;
  1319.                 }
  1320.             }
  1321.             cout << "seq size = " << v.size() << endl;
  1322.             break;
  1323.         }
  1324.     case CSeq_data::e_Ncbi4na:
  1325.         {
  1326.             const vector<char>& v = seq.GetNcbi4na().Get();
  1327.             if (v.size() <= 24) {
  1328.                 ITERATE (vector<char>, i, v) {
  1329.                     cout << std::hex << (unsigned short)(unsigned char) *i
  1330.                          << " " << endl;
  1331.                 }
  1332.             }
  1333.             cout << "seq size = " << v.size() << endl;
  1334.             break;
  1335.         }
  1336.     case CSeq_data::e_Iupacna:
  1337.         if(seq.GetIupacna().Get().size() <= uSize)
  1338.             cout << seq.GetIupacna().Get() << endl;
  1339.         cout << "seq size = " << seq.GetIupacna().Get().size() << endl;
  1340.         break;
  1341.     case CSeq_data::e_Ncbieaa:
  1342.         if(seq.GetNcbieaa().Get().size() <= uSize)
  1343.             cout << seq.GetNcbieaa().Get() << endl;;
  1344.         cout << "seq size = " << seq.GetNcbieaa().Get().size() << endl;
  1345.         break;
  1346.     case CSeq_data::e_Ncbistdaa:
  1347.         {
  1348.             const vector<char>& v = seq.GetNcbistdaa().Get();
  1349.             if (v.size() <= uSize) {
  1350.                 ITERATE (vector<char>, i, v) {
  1351.                     cout << std::hex << (unsigned short)(unsigned char) *i
  1352.                          << " " << endl;
  1353.                 }
  1354.             }
  1355.             cout << "seq size = " << v.size() << endl;
  1356.             break;
  1357.         }
  1358.     case CSeq_data::e_Iupacaa:
  1359.         if(seq.GetIupacaa().Get().size() <= uSize)
  1360.             cout << seq.GetIupacaa().Get() << endl;
  1361.         cout << "seq size = " << seq.GetIupacaa().Get().size() << endl;
  1362.         break;
  1363.     default: 
  1364.         cout << "Display of requested sequence type not supported" << endl;
  1365.     }
  1367. }
  1370. int main(int argc, const char* argv[])
  1371. {
  1372.     CSeqportTestApp theApp;
  1373.     return theApp.AppMain(argc, argv, 0, eDS_Default, 0, "seqport_test");
  1374. }
  1376.  /*
  1377.  * ---------------------------------------------------------------------------
  1378.  * $Log: test_seqport.cpp,v $
  1379.  * Revision 1000.3  2004/06/01 19:33:33  gouriano
  1380.  * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.13
  1381.  *
  1382.  * Revision 1.13  2004/05/19 17:25:27  gorelenk
  1383.  * Added include of PCH - ncbi_pch.hpp
  1384.  *
  1385.  * Revision 1.12  2004/01/30 17:21:24  shomrat
  1386.  * Removed TranslateTest due to deprecated translation code
  1387.  *
  1388.  * Revision 1.11  2003/11/06 16:13:59  shomrat
  1389.  * changed call to Pack due to change in its signature
  1390.  *
  1391.  * Revision 1.10  2003/04/15 19:48:06  vasilche
  1392.  * Fixed uninitialized variable.
  1393.  *
  1394.  * Revision 1.9  2003/03/11 15:53:25  kuznets
  1395.  * iterate -> ITERATE
  1396.  *
  1397.  * Revision 1.8  2002/07/01 16:15:08  clausen
  1398.  * Fixed defined but not used warnings
  1399.  *
  1400.  * Revision 1.7  2002/05/14 17:42:32  ucko
  1401.  * Fix type of from_to.
  1402.  *
  1403.  * Revision 1.6  2002/05/14 15:17:15  clausen
  1404.  * Reorganized code and added tests for new CSeqportUtil methods
  1405.  *
  1406.  * Revision 1.5  2002/05/03 21:28:15  ucko
  1407.  * Introduce T(Signed)SeqPos.
  1408.  *
  1409.  * Revision 1.4  2002/01/10 20:34:15  clausen
  1410.  * Added tests for GetIupacaa3, GetCode, and GetIndex
  1411.  *
  1412.  * Revision 1.3  2001/12/07 18:52:05  grichenk
  1413.  * Updated "#include"-s and forward declarations to work with the
  1414.  * new datatool version.
  1415.  *
  1416.  * Revision 1.2  2001/11/13 12:14:29  clausen
  1417.  * Changed call to CGencode::Translate to reflect new type for code breaks
  1418.  *
  1419.  * Revision 1.1  2001/08/24 00:44:05  vakatov
  1420.  * Initial revision
  1421.  *
  1422.  * ===========================================================================
  1423.  */