readfeat.cpp

来自「ncbi源码」· C++ 代码 · 共 1,648 行 · 第 1/5 页

        string str = string (site_key_to_subtype [i].key);
        m_SiteKeys [string (site_key_to_subtype [i].key)] = site_key_to_subtype [i].subtype;
    }

    for (int i = 0; i < sizeof (trna_key_to_subtype) / sizeof (TrnaInit); i++) {
        string str = string (trna_key_to_subtype [i].key);
        m_TrnaKeys [string (trna_key_to_subtype [i].key)] = trna_key_to_subtype [i].subtype;
    }

    for (int i = 0; i < sizeof (single_key_list) / sizeof (SingleInit); i++) {
        string str = string (single_key_list [i].key);
        m_SingleKeys.push_back (str);
    }
}

// destructor
CFeature_table_reader_imp::~CFeature_table_reader_imp(void)
{
}


bool CFeature_table_reader_imp::x_ParseFeatureTableLine (const string& line, Int4* startP, Int4* stopP,
                                                         bool* partial5P, bool* partial3P, bool* ispointP,
                                                         string& featP, string& qualP, string& valP, Int4 offset)

{
    SIZE_TYPE      numtkns;
    bool           badNumber = false;
    bool           ispoint = false;
    size_t         len;
    bool           partial5 = false;
    bool           partial3 = false;
    Int4           startv = -1;
    Int4           stopv = -1;
    Int4           swp;
    string         start, stop, feat, qual, val, stnd;
    vector<string> tkns;

    if (line.empty ()) return false;

    tkns.clear ();
    NStr::Tokenize (line, "\t", tkns);
    numtkns = tkns.size ();

    if (numtkns > 0) {
        start = tkns [0];
    }
    if (numtkns > 1) {
        stop = tkns [1];
    }
    if (numtkns > 2) {
        feat = tkns [2];
    }
    if (numtkns > 3) {
        qual = tkns [3];
    }
    if (numtkns > 4) {
        val = tkns [4];
    }
    if (numtkns > 5) {
        stnd = tkns [5];
    }

    if (! start.empty ()) {
        if (start [0] == '<') {
            partial5 = true;
            start.erase (0, 1);
        }
        len = start.length ();
        if (len > 1 && start [len - 1] == '^') {
          ispoint = true;
          start [len - 1] = '\0';
        }
        try {
            startv = NStr::StringToLong (start);
        } catch (...) {
            badNumber = true;
        }
    }

    if (! stop.empty ()) {
        if (stop [0] == '>') {
            partial3 = true;
            stop.erase (0, 1);
        }
        try {
            stopv = NStr::StringToLong (stop);
        } catch (CStringException) {
            badNumber = true;
        }
    }

    if (badNumber) {
        startv = -1;
        stopv = -1;
    } else {
        startv--;
        stopv--;
        if (! stnd.empty ()) {
            if (stnd == "minus" || stnd == "-" || stnd == "complement") {
                if (start < stop) {
                    swp = startv;
                    startv = stopv;
                    stopv = swp;
                }
            }
        }
    }

    *startP = startv + offset;
    *stopP = stopv + offset;
    *partial5P = partial5;
    *partial3P = partial3;
    *ispointP = ispoint;
    featP = feat;
    qualP = qual;
    valP = val;

    return true;
}


bool CFeature_table_reader_imp::x_AddQualifierToGene (CSeqFeatData& sfdata,
                                                      EQual qtype, const string& val)

{
    CGene_ref& grp = sfdata.SetGene ();
    switch (qtype) {
        case eQual_gene:
            grp.SetLocus (val);
            return true;
        case eQual_allele:
            grp.SetAllele (val);
            return true;
        case eQual_gene_desc:
            grp.SetDesc (val);
            return true;
        case eQual_gene_syn:
            {
                CGene_ref::TSyn& syn = grp.SetSyn ();
                syn.push_back (val);
                return true;
            }
        case eQual_map:
            grp.SetMaploc (val);
            return true;
        case eQual_locus_tag:
            grp.SetLocus_tag (val);
            return true;
        default:
            break;
    }
    return false;
}


bool CFeature_table_reader_imp::x_AddQualifierToCdregion (CRef<CSeq_feat> sfp, CSeqFeatData& sfdata,
                                                          EQual qtype, const string& val)

{
    CCdregion& crp = sfdata.SetCdregion ();
    switch (qtype) {
        case eQual_codon_start:
            {
                int frame = NStr::StringToInt (val);
                switch (frame) {
                    case 0:
                        crp.SetFrame (CCdregion::eFrame_not_set);
                        break;
                    case 1:
                        crp.SetFrame (CCdregion::eFrame_one);
                        break;
                    case 2:
                        crp.SetFrame (CCdregion::eFrame_two);
                        break;
                    case 3:
                        crp.SetFrame (CCdregion::eFrame_three);
                        break;
                    default:
                        break;
                }
                return true;
            }
        case eQual_EC_number:
            {
                CProt_ref& prp = sfp->SetProtXref ();
                CProt_ref::TEc& ec = prp.SetEc ();
                ec.push_back (val);
                return true;
            }
        case eQual_function:
            {
                CProt_ref& prp = sfp->SetProtXref ();
                CProt_ref::TActivity& fun = prp.SetActivity ();
                fun.push_back (val);
                return true;
            }
        case eQual_product:
            {
                CProt_ref& prp = sfp->SetProtXref ();
                CProt_ref::TName& prod = prp.SetName ();
                prod.push_back (val);
                return true;
            }
        case eQual_prot_desc:
            {
                CProt_ref& prp = sfp->SetProtXref ();
                prp.SetDesc (val);
                return true;
            }
        case eQual_prot_note:
            return true;
        case eQual_transl_except:
            return true;
        default:
            break;
    }
    return false;
}


int CFeature_table_reader_imp::x_ParseTrnaString (const string& val)

{
    string fst, scd;

    scd = val;
    if (NStr::StartsWith (val, "tRNA-")) {
        NStr::SplitInTwo (val, "-", fst, scd);
    }

    if (m_TrnaKeys.find (scd) != m_TrnaKeys.end ()) {
        return m_TrnaKeys [scd];
    }

    return 0;
}


bool CFeature_table_reader_imp::x_AddQualifierToRna (CSeqFeatData& sfdata,
                                                     EQual qtype, const string& val)

{
    CRNA_ref& rrp = sfdata.SetRna ();
    CRNA_ref::EType rnatyp = rrp.GetType ();
    switch (rnatyp) {
        case CRNA_ref::eType_premsg:
        case CRNA_ref::eType_mRNA:
        case CRNA_ref::eType_rRNA:
        case CRNA_ref::eType_snRNA:
        case CRNA_ref::eType_scRNA:
        case CRNA_ref::eType_snoRNA:
        case CRNA_ref::eType_other:
            switch (qtype) {
                case eQual_product:
                    {
                        CRNA_ref::TExt& tex = rrp.SetExt ();
                        CRNA_ref::C_Ext::E_Choice exttype = tex.Which ();
                        if (exttype == CRNA_ref::C_Ext::e_TRNA) return false;
                        tex.SetName (val);
                        return true;
                    }
                default:
                    break;
            }
            break;
        case CRNA_ref::eType_tRNA:
            switch (qtype) {
                case eQual_product: {
                        CRNA_ref::TExt& tex = rrp.SetExt ();
                        CRNA_ref::C_Ext::E_Choice exttype = tex.Which ();
                        if (exttype == CRNA_ref::C_Ext::e_Name) return false;
                        CTrna_ext& trx = tex.SetTRNA ();
                        int aaval = x_ParseTrnaString (val);
                        if (aaval > 0) {
                            CTrna_ext::TAa& taa = trx.SetAa ();
                            taa.SetNcbieaa (aaval);
                            trx.SetAa (taa);
                            tex.SetTRNA (trx);
                            return true;
                        }
                    }
                    break;
                default:
                    break;
            }
            break;
        default:
            break;
    }
    return false;
}


bool CFeature_table_reader_imp::x_AddQualifierToImp (CRef<CSeq_feat> sfp, CSeqFeatData& sfdata,
                                                     EQual qtype, const string& qual, const string& val)

{
    switch (qtype) {
        case eQual_allele:
        case eQual_bound_moiety:
        case eQual_clone:
        case eQual_cons_splice:
        case eQual_direction:
        case eQual_EC_number:
        case eQual_frequency:
        case eQual_function:
        case eQual_insertion_seq:
        case eQual_label:
        case eQual_map:
        case eQual_number:
        case eQual_operon:
        case eQual_organism:
        case eQual_PCR_conditions:
        case eQual_phenotype:
        case eQual_product:
        case eQual_replace:
        case eQual_rpt_family:
        case eQual_rpt_type:
        case eQual_rpt_unit:
        case eQual_standard_name:
        case eQual_transposon:
        case eQual_usedin:
            {
                CSeq_feat::TQual& qlist = sfp->SetQual ();
                CRef<CGb_qual> gbq (new CGb_qual);
                gbq->SetQual (qual);
                gbq->SetVal (val);
                qlist.push_back (gbq);
                return true;