test_seqport.cpp

ncbi源码

                case 1:   
                    GetIupacaa3();
                    break;
                case 2:
                    GetCodeEChoice();
                    break;
                case 3:
                    GetCodeESeq();
                    break;
                case 4:
                    GetNameEChoice();
                    break;
                case 5:
                    GetNameESeq();
                    break;
                case 6:
                    GetIndexEChoice();
                    break;
                case 7:
                    GetIndexESeq();
                    break;
                case 8:
                    IsCodeAvailableEChoice();
                    break;
                case 9:
                    IsCodeAvailableESeq();
                    break;
                case 10:
                    GetCodeIndexFromToEChoice();
                    break;
                case 11:
                    GetCodeIndexFromToESeq();
                    break;
                case 12:
                    GetIndexComplementEChoice();
                    break;
                case 13:
                    GetIndexComplementESeq();
                    break;
                case 14:
                    GetMapToIndexEChoice();
                    break;
                case 15:
                    GetMapToIndexESeq();
                    break;
                }
            } catch (runtime_error e) {
                string msg(e.what());
                if (msg == "Done") {
                    break;
                }
                cout << msg << endl;
            } 
        }
    }    
}


void CSeqportTestApp::SeqDataTest()
{
    //Declare local variables
    unsigned int nTimes=0, uOverhang=0;
    TSeqPos uSeqLen = 0, uCnt = 0;
    int nInSeqType, nOutSeqType;
    CSeq_data::E_Choice to_code = CSeq_data::e_not_set;
    bool bAmbig;

    //Create in CSeq_data 
    CRef<CSeq_data> in_seq(new CSeq_data); 
    
    //Enter in sequence type
    nInSeqType = -1;
    while(nInSeqType<0) {
        cout << "Enter input sequence type " << endl;
        cout <<
            "(0=ncbi2na, 1=ncbi4na, 2=iupacna, 3=ncbieaa,"
            " 4=ncbistdaa, 5=iupacaa): ";
        cin >> nInSeqType;
        if(nInSeqType > 5)
            nInSeqType = -1;
    }  
  
    //Enter out sequence type
    nOutSeqType = -1;
    while(nOutSeqType<0) {
        cout << "Enter output sequence type " << endl;
        cout <<
            "(0=ncbi2na, 1=ncbi4na, 2=iupacna, 3=ncbieaa,"
            " 4=ncbistdaa, 5=iupacaa): ";
        cin >> nOutSeqType;
        if(nOutSeqType > 5)
            nOutSeqType = -1;
    } 
    bAmbig = false;
    if(((nInSeqType==1) || (nInSeqType==2)) && (nOutSeqType==0))
        {
            cout << "Randomly disambiguate (1 = Yes, 0 = No)? ";
            unsigned int nAmbig = 0;
            cin >> nAmbig;
            if(nAmbig!=0)
                bAmbig = true;
        }

    switch(nOutSeqType){
    case 0:
        to_code = CSeq_data::e_Ncbi2na;
        break;
    case 1:
        to_code = CSeq_data::e_Ncbi4na;
        break;
    case 2:
        to_code = CSeq_data::e_Iupacna;
        break;
    case 3:
        to_code = CSeq_data::e_Ncbieaa;
        break;
    case 4:
        to_code = CSeq_data::e_Ncbistdaa;
        break;
    case 5:
        to_code = CSeq_data::e_Iupacaa;
        break;
    }
  
    //Enter desired sequence length
    uSeqLen = 0;
    cout << "Enter desired sequence length: ";
    cin >> uSeqLen;
      
    //Get input depending on type of input sequence
    if(nInSeqType == 2 || nInSeqType == 3 || nInSeqType == 5) {
        //Enter an in sequence string
        string str = "";
        cout << "Enter an input sequence string: " << endl;
        cin >> str;
        if(str.size() > 0) {
            nTimes = uSeqLen/str.size();
            uOverhang = uSeqLen % str.size();
        }
        in_seq->Reset();
        int nSize = str.size();
        const char* s = str.c_str();
        switch(nInSeqType) {
        case 2:
            in_seq->SetIupacna().Set().resize(uSeqLen);
            for(unsigned int i=0; i<nTimes; i++){               
                in_seq->SetIupacna().Set().replace
                    (i*nSize,nSize,s);
                string tst = in_seq->SetIupacna().Set();
            } 
            if (uOverhang > 0) {         
                in_seq->SetIupacna().Set().replace
                    (nTimes*str.size(),uOverhang,str.substr(0,uOverhang)); 
            } 
            break;
        case 3:
            in_seq->SetNcbieaa().Set().resize(uSeqLen);
            for(unsigned int i=0; i<nTimes; i++) {
                in_seq->SetNcbieaa().Set().replace
                    (i*nSize,nSize,s);
            }
            if (uOverhang > 0) {         
                in_seq->SetNcbieaa().Set().replace
                    (nTimes*str.size(),uOverhang,str.substr(0,uOverhang)); 
            }    
            break;
        case 5:
            in_seq->SetIupacaa().Set().resize(uSeqLen);
            for(unsigned int i=0; i<nTimes; i++) {
                in_seq->SetIupacaa().Set().replace
                    (i*nSize,nSize,s);
            }            
            if (uOverhang > 0) {         
                in_seq->SetIupacaa().Set().replace
                    (nTimes*str.size(),uOverhang,str.substr(0,uOverhang));
            }
            break;
        }
    }
    else {
        //Enter an in sequence vector
        cout << "Enter an input sequence vector in hex (end with -1): "
             << endl;
        int nIn = 0;
        vector<char> v;
        uCnt = 0;
        while(uCnt < uSeqLen)
            {
                cin >> std::hex >> nIn;
                if(nIn < 0 || nIn > 255) {
                    break;
                }
                v.push_back(nIn);
                switch(nInSeqType){
                case 0:
                    uCnt+=4;
                    break;
                case 1:
                    uCnt+=2;
                    break;
                default:
                    uCnt++;
                }
            }
        if(v.size() == 0) {
            cout << "No input sequence given. Setting to 0." << endl;
            v.push_back(0);
        }
        TSeqPos uInSize;
        switch(nInSeqType) {
        case 0:
            if((uSeqLen % 4) != 0) {
                uSeqLen += (4-(uSeqLen % 4));
            }
            uInSize = 4*v.size();
            if(uSeqLen % uInSize == 0) {
                nTimes = uSeqLen/uInSize;
            }
            else {
                nTimes = uSeqLen/uInSize + 1;
            }
            break;
        case 1:
            if((uSeqLen % 2) != 0) {
                uSeqLen += (2-(uSeqLen % 2));
            }
            uInSize = 2*v.size();
            if(uSeqLen % uInSize == 0) {
                nTimes = uSeqLen/uInSize;
            }
            else {
                nTimes = uSeqLen/uInSize + 1;
            }
            break;
        case 4:
            if(uSeqLen % v.size() == 0) {
                nTimes = uSeqLen/v.size();
            }
            else {
                nTimes = uSeqLen/v.size() + 1;
            }
            break;
        }
        
        switch(nInSeqType){
        case 0:
            for(unsigned int i=0; i<nTimes; i++) {
                ITERATE (vector<char>, j, v) {
                    in_seq->SetNcbi2na().Set().push_back(*j);
                }
            }
            break;
        case 1:
            for(unsigned int i=0; i<nTimes; i++) {
                ITERATE (vector<char>, j, v) {
                    in_seq->SetNcbi4na().Set().push_back(*j);
                }
            }
            break;
        case 4:
            for(unsigned int i=0; i<nTimes; i++) {
                ITERATE (vector<char>, j, v) {
                    in_seq->SetNcbistdaa().Set().push_back(*j);
                }
            }
            break;
        }
    }
  
    //Enter Begin Index (relative to biological sequence)
    TSeqPos uBeginIdx = 0, uLength = 0;
    cout << "Enter begin index to Convert: ";
    cin >> std::dec >> uBeginIdx;
    
    //Enter Length of sequence to Convert
    cout << "Enter length of sequence to Convert: ";
    cin >> uLength;
    
    //Create out_seq
    CRef<CSeq_data> out_seq(new CSeq_data);
    
    int nResponse;
    
    while (true) {
        cout << "Enter test to run:" << endl
             << "0)  Quit" << endl
             << "1)  GetAmbigsTest" << endl
             << "2)  ConvertTest" << endl
             << "3)  AppendTest" << endl
             << "4)  InPlaceReverseComplementTest" << endl
             << "5)  InCopyReverseComplementTest" << endl
             << "6)  InPlaceReverseTest" << endl
             << "7)  InCopyReverseTest" << endl
             << "8)  InPlaceComplementTest" << endl
             << "9) InCopyComplementTest" << endl
             << "10) FastValidateTest" << endl
             << "11) ValidateTest" << endl
             << "12) GetCopyTest" << endl
             << "13) KeepTest" << endl
             << "14) PackTest" << endl; 
        cin >> nResponse;   
         
        switch (nResponse) {
        case 0:
            return;
        case 1:
            GetAmbigsTest
                (*in_seq, out_seq, to_code, uBeginIdx, uLength);
            break;
        case 2:
            ConvertTest(*in_seq, out_seq, to_code, uBeginIdx, uLength, bAmbig);
            break;
        case 3:
            AppendTest(*in_seq, out_seq, uBeginIdx, uLength);
            break;
        case 4:
            InPlaceReverseComplementTest
                (*in_seq, out_seq, uBeginIdx, uLength);
            break;
        case 5:
            InCopyReverseComplementTest
                (*in_seq, out_seq, uBeginIdx, uLength);
            break;
        case 6:
            InPlaceReverseTest
                (*in_seq, out_seq, uBeginIdx, uLength);
            break;
        case 7:
            InCopyReverseTest
                (*in_seq, out_seq, uBeginIdx, uLength);
            break;
        case 8:
            InPlaceComplementTest
                (*in_seq, out_seq, uBeginIdx, uLength);
            break;
        case 9:
            InCopyComplementTest
                (*in_seq, out_seq, uBeginIdx, uLength);
            break;
        case 10:
            FastValidateTest
                (*in_seq, uBeginIdx, uLength);
            break;
        case 11:
            ValidateTest
                (*in_seq, uBeginIdx, uLength);
            break;
        case 12:
            GetCopyTest(*in_seq, out_seq, uBeginIdx, uLength);
            break;
        case 13:
            KeepTest(*in_seq, out_seq, uBeginIdx, uLength);
            break;
        case 14:
            PackTest(*in_seq, out_seq, uBeginIdx, uLength);
            break;
        default:
            break;
        }
    }        
}

 
void CSeqportTestApp::GetAmbigsTest(const CSeq_data&     in_seq,
              CSeq_data*           out_seq,
              CSeq_data::E_Choice  to_code,
              TSeqPos              uBeginIdx,
              TSeqPos              uLength)
{
    TSeqPos uSeqLen=0;
    
    try {
        vector<TSeqPos> out_indices;
    
        TSeqPos uLen = CSeqportUtil::GetAmbigs
            (in_seq,
             out_seq,
             &out_indices,
             to_code,
             uBeginIdx,
             uLength);
    
    
        cout << endl << "Results for GetAmbigs()" << endl;
        cout << "uSeqLen = " << uSeqLen << endl;
        cout << "(uBeginIdx, uLength) = (" << uBeginIdx
             << ", " << uLength << ")" << endl;
        cout << "Num ambigs = " << out_indices.size() << endl;
        cout << "Return length = " << uLen << endl;
  
        if(out_seq->Which() == CSeq_data::e_Ncbi4na) {
            if (out_indices.size() <= 24) {
                ITERATE (vector<TSeqPos>, i_idx, out_indices) {
                    cout << (*i_idx) << " ";
                }
                cout << endl;
                const vector<char>& out_seq_data
                    = out_seq->GetNcbi4na().Get();
                ITERATE (vector<char>, i_out, out_seq_data) {
                    cout << std::hex
                         << (unsigned short)(unsigned char) *i_out << " ";
                }
                cout << endl;
            }
        }
        else if(out_seq->Which() == CSeq_data::e_Iupacna) {
            if(out_indices.size() <= 24) {
                ITERATE (vector<TSeqPos>, i_idx, out_indices) {
                    cout << (*i_idx) << " ";
                }
                cout << endl;
                string out_seq_data = out_seq->GetIupacna().Get();
                cout << out_seq_data << endl;
            }
        
        }
        out_indices.clear();
        out_seq->Reset();	  
    }
    STD_CATCH("");
}


void CSeqportTestApp::ConvertTest(const CSeq_data&     in_seq,
              CSeq_data*           out_seq,
              CSeq_data::E_Choice  to_code,
              TSeqPos              uBeginIdx,
              TSeqPos              uLength,
              bool                 bAmbig)
{
    TSeqPos uSeqLen=0;
    
    try{ 
        TSeqPos uLen = CSeqportUtil::Convert
            (in_seq, out_seq, to_code, uBeginIdx, uLength, bAmbig);

        cout << endl << "Conversion Results" << endl;
        cout << "uSeqLen = " << uSeqLen  << endl;
        cout << "Return length = " << uLen << endl;
        
        //Write input and ouput sequences if uSeqLen <= 50
        //Print uBeginIdx and uLength
        cout << "(uBeginIdx, uLength) = (" << uBeginIdx
             << ", " << uLength << ")" << endl;
        
        //Print the in sequence
        cout << "Input sequence is: " << endl;
        DisplaySeq(in_seq, MAX_DISPLAY);
      
        //Print the out sequence
        cout << "Output sequence is: " << endl;
        DisplaySeq(*out_seq, MAX_DISPLAY);
             
        //Reset output sequence
        out_seq->Reset();
      
    } 
    STD_CATCH("");
}

void CSeqportTestApp::AppendTest(const CSeq_data&     in_seq,
              CSeq_data*           out_seq,
              TSeqPos              uBeginIdx,
              TSeqPos              uLength)
{
    TSeqPos uSeqLen=0;
    
    try{
        TSeqPos uBeginIdx2, uLength2;
        cout << "(uBeginIdx1, uLength1) = (" 
             << uBeginIdx << "," << uLength << ")" << endl;
        cout << "Enter uBeginIdx2: ";
        cin >> uBeginIdx2;
        cout << "Enter uLength2: ";
        cin >> uLength2;