test_seqport.cpp

ncbi源码

/*
 * ===========================================================================
 * PRODUCTION $Log: test_seqport.cpp,v $
 * PRODUCTION Revision 1000.3  2004/06/01 19:33:33  gouriano
 * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.13
 * PRODUCTION
 * ===========================================================================
 */

/*  $Id: test_seqport.cpp,v 1000.3 2004/06/01 19:33:33 gouriano Exp $
 * ===========================================================================
 *
 *                            PUBLIC DOMAIN NOTICE
 *               National Center for Biotechnology Information
 *
 *  This software/database is a "United States Government Work" under the
 *  terms of the United States Copyright Act.  It was written as part of
 *  the author's official duties as a United States Government employee and
 *  thus cannot be copyrighted.  This software/database is freely available
 *  to the public for use. The National Library of Medicine and the U.S.
 *  Government have not placed any restriction on its use or reproduction.
 *
 *  Although all reasonable efforts have been taken to ensure the accuracy
 *  and reliability of the software and data, the NLM and the U.S.
 *  Government do not and cannot warrant the performance or results that
 *  may be obtained by using this software or data. The NLM and the U.S.
 *  Government disclaim all warranties, express or implied, including
 *  warranties of performance, merchantability or fitness for any particular
 *  purpose.
 *
 *  Please cite the author in any work or product based on this material.
 *
 * ===========================================================================
 *
 * Author:  Clifford Clausen
 *          (also reviewed/fixed/groomed by Denis Vakatov)
 * File Description:
 *   
 */

#include <ncbi_pch.hpp>
#include <corelib/ncbiapp.hpp>
#include <corelib/ncbiargs.hpp>
#include <corelib/ncbienv.hpp>
#include <corelib/ncbireg.hpp>

#include <serial/serial.hpp>
#include <serial/objistr.hpp>

#include <objects/seqset/Seq_entry.hpp>
#include <objects/seqset/Bioseq_set.hpp>
#include <objects/seqfeat/Genetic_code.hpp>
#include <objects/seq/Bioseq.hpp>
#include <objects/seq/NCBI2na.hpp>
#include <objects/seq/NCBI4na.hpp>
#include <objects/seq/IUPACna.hpp>
#include <objects/seq/IUPACaa.hpp>
#include <objects/seq/NCBIeaa.hpp>
#include <objects/seq/NCBIstdaa.hpp>
#include <objects/seq/Seq_inst.hpp>

#include <objects/seq/seqport_util.hpp>



USING_NCBI_SCOPE;
USING_SCOPE(objects);

#define MAX_DISPLAY 48


/////////////////////////////////////////////////////////////////////////////
//

class CSeqportTestApp : public CNcbiApplication
{
public:
    virtual void Init();
    virtual int  Run(void);
    virtual void Exit();

    void DisplaySeq(const CSeq_data& seq, unsigned int uSize=48);

    // Testing methods that require CSeq_data
    void SeqDataTest();
    void GetAmbigsTest(const CSeq_data&     in_seq,
              CSeq_data*           out_seq,
              CSeq_data::E_Choice  to_code,
              TSeqPos              uBeginIdx,
              TSeqPos              uLength);
    void ConvertTest(const CSeq_data&     in_seq,
              CSeq_data*           out_seq,
              CSeq_data::E_Choice  to_code,
              TSeqPos              uBeginIdx,
              TSeqPos              uLength,
              bool                 bAmbig);
    void AppendTest(const CSeq_data&     in_seq,
              CSeq_data*           out_seq,
              TSeqPos              uBeginIdx,
              TSeqPos              uLength);
    void InPlaceReverseComplementTest(const CSeq_data&     in_seq,
              CSeq_data*           out_seq,
              TSeqPos              uBeginIdx,
              TSeqPos              uLength);
    void InCopyReverseComplementTest(const CSeq_data&     in_seq,
              CSeq_data*           out_seq,
              TSeqPos              uBeginIdx,
              TSeqPos              uLength);
    void InPlaceReverseTest(const CSeq_data&     in_seq,
              CSeq_data*           out_seq,
              TSeqPos              uBeginIdx,
              TSeqPos              uLength);
    void InCopyReverseTest(const CSeq_data&     in_seq,
              CSeq_data*           out_seq,
              TSeqPos              uBeginIdx,
              TSeqPos              uLength);
    void InPlaceComplementTest(const CSeq_data&     in_seq,
              CSeq_data*           out_seq,
              TSeqPos              uBeginIdx,
              TSeqPos              uLength);
    void InCopyComplementTest(const CSeq_data&     in_seq,
              CSeq_data*           out_seq,
              TSeqPos              uBeginIdx,
              TSeqPos              uLength);
    void FastValidateTest(const CSeq_data&     in_seq,
              TSeqPos              uBeginIdx,
              TSeqPos              uLength);
    void ValidateTest(const CSeq_data&     in_seq,
              TSeqPos              uBeginIdx,
              TSeqPos              uLength);
    void GetCopyTest(const CSeq_data&     in_seq,
              CSeq_data*           out_seq,
              TSeqPos              uBeginIdx,
              TSeqPos              uLength);
    void KeepTest(const CSeq_data&     in_seq,
              CSeq_data*           out_seq,
              TSeqPos         uBeginIdx,
              TSeqPos         uLength);
    void PackTest(const CSeq_data&     in_seq,
              CSeq_data*           out_seq,
              TSeqPos              uBeginIdx,
              TSeqPos              uLength);
    
    
    // Testing methods that do not require CSeq_data
    void NonSeqDataTest();
    void GetIupacaa3();
    void GetCodeEChoice();
    void GetCodeESeq();
    void GetNameEChoice();    
    void GetNameESeq();
    void GetIndexEChoice();
    void GetIndexESeq();
    void IsCodeAvailableEChoice();
    void IsCodeAvailableESeq();
    void GetCodeIndexFromToEChoice();
    void GetCodeIndexFromToESeq();
    void GetIndexComplementEChoice();
    void GetIndexComplementESeq();
    void GetMapToIndexEChoice();
    void GetMapToIndexESeq();       
};




/////////////////////////////////////////////////////////////////////////////
//


void CSeqportTestApp::Init()
{
    return;
}

int CSeqportTestApp::Run()
{
    while ( true ) {
    
        cout << "Enter type tests to run: " << endl
             << "0) Done" << endl
             << "1) Tests requiring CSeq_dat" << endl
             << "2) Tests not requiring CSeq_dat" << endl; 

        int resp;
        cin >> resp;
        
        switch (resp) {
        case 0:
            return 0;
        case 1:
            SeqDataTest();
            break;
        case 2:
            NonSeqDataTest();
            break;
        }
    }
}


static int GetChoice()
{
    int choice = -1;
    while ( (choice < 0 || choice > 11) && (choice != 99) ) {
        cout << "Enter code type choice:" << endl
             << "0:  Not set" << endl
             << "1:  Iupacna" << endl
             << "2:  Iupacaa" << endl
             << "3:  Ncbi2na" << endl
             << "4:  Ncbi4na" << endl
             << "5:  Ncbi8na" << endl
             << "6:  Ncbipna" << endl
             << "7:  Ncbi8aa" << endl
             << "8:  Ncbieaa" << endl
             << "9:  Ncbipaa" << endl
             << "10: Ncbistdaa" << endl
             << "11: Iupacaa3" << endl
             << "99: Done" << endl;
        cin >> choice;
    }    
    return choice;  
}

static CSeq_data::E_Choice GetEChoice()
{
    int choice = GetChoice();
    
    switch (choice) {
    case 0:
        return CSeq_data::e_not_set;
    case 1:
        return CSeq_data::e_Iupacna;
    case 2:
        return CSeq_data::e_Iupacaa;
    case 3:
        return CSeq_data::e_Ncbi2na;
    case 4:
        return CSeq_data::e_Ncbi4na;
    case 5:
        return CSeq_data::e_Ncbi8na;
    case 6:
        return CSeq_data::e_Ncbipna;
    case 7:
        return CSeq_data::e_Ncbi8aa;
    case 8:
        return CSeq_data::e_Ncbieaa;
    case 9:
        return CSeq_data::e_Ncbipaa;
    case 10:
        return CSeq_data::e_Ncbistdaa;
    case 99:
        throw runtime_error("Done");
    }
    cout << "Requested code not CSeq_data:E_Choice" << endl;
    cout << "Using CSeq_data::e_not_set" << endl;
    return CSeq_data::e_not_set;
}

static ESeq_code_type GetESeqCodeType()
{
    int choice = GetChoice();
    
    switch (choice) {
    case 1:
        return eSeq_code_type_iupacna;
    case 2:
        return eSeq_code_type_iupacaa;
    case 3:
        return eSeq_code_type_ncbi2na;
    case 4:
        return eSeq_code_type_ncbi4na;
    case 5:
        return eSeq_code_type_ncbi8na;
    case 6:
        return eSeq_code_type_ncbipna;
    case 7:
        return eSeq_code_type_ncbi8aa;
    case 8:
        return eSeq_code_type_ncbieaa;
    case 9:
        return eSeq_code_type_ncbipaa;
    case 10:
        return eSeq_code_type_ncbistdaa;
    case 11:
        return eSeq_code_type_iupacaa3;
    case 99:
        throw runtime_error("Done");
    }
    cout << "Requested code no an ESeq_code_type. Using iupacna." << endl;
    return eSeq_code_type_iupacna;
}


void CSeqportTestApp::GetIupacaa3()
{
    unsigned int ncbistdaa;
    cout << "Enter Ncbistdaa index: ";
    cin >> ncbistdaa;
    string iupacaa3;
    iupacaa3 = CSeqportUtil::GetIupacaa3(ncbistdaa);
    cout << "Iupacaa3 is : " << iupacaa3 << endl;
    throw runtime_error("Done");
}

void CSeqportTestApp::GetCodeEChoice()
{   
    CSeq_data::E_Choice code_type = GetEChoice();  
    CSeqportUtil::TIndex idx;
    cout << "Enter index: ";
    cin >> idx;
    string code;
    code = CSeqportUtil::GetCode(code_type, idx);
    cout << "Code is : " << code << endl;
}

void CSeqportTestApp::GetCodeESeq()
{
    ESeq_code_type code_type = GetESeqCodeType();
    int idx;
    cout << "Enter index: ";
    cin >> idx;
    string code;
    code = CSeqportUtil::GetCode(code_type, idx);
    cout << "Code is : " << code << endl;
}

void CSeqportTestApp::GetNameEChoice()
{
    CSeq_data::E_Choice code_type = GetEChoice();
    int idx;
    cout << "Enter index: ";
    cin >> idx;
    string code;
    code = CSeqportUtil::GetName(code_type, idx);
    cout << "Name is : " << code << endl;
}

void CSeqportTestApp::GetNameESeq()
{
    ESeq_code_type code_type = GetESeqCodeType();
    int idx;
    cout << "Enter index: ";
    cin >> idx;
    string code;
    code = CSeqportUtil::GetName(code_type, idx);
    cout << "Name is : " << code << endl;
}

void CSeqportTestApp::GetIndexEChoice()
{
    CSeq_data::E_Choice code_type = GetEChoice();
    string code;
    cout << "Enter code: ";
    cin >> code;
    int idx = CSeqportUtil::GetIndex(code_type, code);
    cout << "Index is : " << idx << endl;
}

void CSeqportTestApp::GetIndexESeq()
{
    ESeq_code_type code_type = GetESeqCodeType();
    string code;
    cout << "Enter code: ";
    cin >> code;
    int idx = CSeqportUtil::GetIndex(code_type, code);
    cout << "Index is : " << idx << endl;
}

void CSeqportTestApp::IsCodeAvailableEChoice()
{
    CSeq_data::E_Choice code_type = GetEChoice();
    bool avail = CSeqportUtil::IsCodeAvailable(code_type);
    cout << "Code availabe is " << avail << endl;
}

void CSeqportTestApp::IsCodeAvailableESeq()
{
    ESeq_code_type code_type = GetESeqCodeType();
    bool avail= CSeqportUtil::IsCodeAvailable(code_type);
    cout << "Code availabe is " << avail << endl;
}

void CSeqportTestApp::GetCodeIndexFromToEChoice()
{
    CSeq_data::E_Choice code_type = GetEChoice();
    CSeqportUtil::TPair from_to = 
        CSeqportUtil::GetCodeIndexFromTo(code_type);
    cout << "From is " << from_to.first
         << ": To is " << from_to.second << endl;
}

void CSeqportTestApp::GetCodeIndexFromToESeq()
{
    ESeq_code_type code_type = GetESeqCodeType();
    CSeqportUtil::TPair from_to = 
        CSeqportUtil::GetCodeIndexFromTo(code_type);
    cout << "From is " << from_to.first
         << ": To is " << from_to.second << endl;
}

void CSeqportTestApp::GetIndexComplementEChoice()
{
    CSeq_data::E_Choice code_type = GetEChoice();
    cout << "Enter index: ";
    int idx;
    cin >> idx;
    int c_idx = CSeqportUtil::GetIndexComplement(code_type, idx);
    cout << "Complement for index " << idx << " is " << c_idx << endl;
}

void CSeqportTestApp::GetIndexComplementESeq()
{
    ESeq_code_type code_type = GetESeqCodeType();
    cout << "Enter index: ";
    int idx;
    cin >> idx;
    int c_idx = CSeqportUtil::GetIndexComplement(code_type, idx);
    cout << "Complement for index " << idx << " is " << c_idx << endl;
}

void CSeqportTestApp::GetMapToIndexEChoice()
{
    cout << "From type: " << endl;
    CSeq_data::E_Choice from_type = GetEChoice();
    cout << "To type: " << endl;
    CSeq_data::E_Choice to_type = GetEChoice();
    cout << "Enter from index: ";
    int from_idx;
    cin >> from_idx;
    int to_idx = CSeqportUtil::GetMapToIndex(from_type, to_type, from_idx);
    cout << "From index maps to " << to_idx << endl;
}

void CSeqportTestApp::GetMapToIndexESeq()
{
    cout << "From type: " << endl;
    ESeq_code_type from_type = GetESeqCodeType();
    cout << "To type: " << endl;
    ESeq_code_type to_type = GetESeqCodeType();
    cout << "Enter from index: ";
    int from_idx;
    cin >> from_idx;
    int to_idx = CSeqportUtil::GetMapToIndex(from_type, to_type, from_idx);
    cout << "From index maps to " << to_idx << endl;
}

void CSeqportTestApp::NonSeqDataTest()
{
    while (true) {
        cout << "Enter test to run: " << endl
             << "0)  Done " << endl
             << "1)  GetIupacaa3() " << endl
             << "2)  GetCode(E_Choice) " << endl
             << "3)  GetCode(ESeq_code_type) " << endl
             << "4)  GetName(E_Choice) " << endl
             << "5)  GetName(ESeq_code_type) " << endl
             << "6)  GetIndex(E_Choice) " << endl
             << "7)  GetIndex(ESeq_code_type) " << endl
             << "8)  IsCodeAvailable(E_Choice) " << endl
             << "9)  IsCodeAvailable(ESeq_code_type) " << endl
             << "10) GetCodeIndexFromTo(E_Choice) " << endl
             << "11) GetCodeIndexFromTo(ESeq_code_type) " << endl
             << "12) GetIndexComplement(E_Choice) " << endl
             << "13) GetIndexComplement(ESeq_code_type) " << endl
             << "14) GetMapToIndex(E_Choice) " << endl
             << "15) GetMapToIndex(ESeq) " << endl
             << endl;
        int resp;
        cin >> resp;
        while (true) {
            try {
                switch (resp) {
                case 0:
                    return;