readfeat.cpp

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

            }
        default:
            break;
    }
    return false;
}


bool CFeature_table_reader_imp::x_AddQualifierToBioSrc (CSeqFeatData& sfdata,
                                                        EOrgRef rtype, const string& val)

{
    CBioSource& bsp = sfdata.SetBiosrc ();

    switch (rtype) {
        case eOrgRef_organism:
            {
                CBioSource::TOrg& orp = bsp.SetOrg ();
                orp.SetTaxname (val);
                return true;
            }
        case eOrgRef_organelle:
            {
                if (m_GenomeKeys.find (val) != m_GenomeKeys.end ()) {
                    CBioSource::EGenome gtype = m_GenomeKeys [val];
                    bsp.SetGenome (gtype);
                    return true;
                }
            }
        case eOrgRef_div:
            {
                CBioSource::TOrg& orp = bsp.SetOrg ();
                COrg_ref::TOrgname& onp = orp.SetOrgname ();
                onp.SetDiv (val);
                return true;
            }
        case eOrgRef_lineage:
            {
                CBioSource::TOrg& orp = bsp.SetOrg ();
                COrg_ref::TOrgname& onp = orp.SetOrgname ();
                onp.SetLineage (val);
                return true;
            }
        case eOrgRef_gcode:
            {
                CBioSource::TOrg& orp = bsp.SetOrg ();
                COrg_ref::TOrgname& onp = orp.SetOrgname ();
                int code = NStr::StringToInt (val);
                onp.SetGcode (code);
                return true;
            }
        case eOrgRef_mgcode:
            {
                CBioSource::TOrg& orp = bsp.SetOrg ();
                COrg_ref::TOrgname& onp = orp.SetOrgname ();
                int code = NStr::StringToInt (val);
                onp.SetMgcode (code);
                return true;
            }
        default:
            break;
    }
    return false;
}


bool CFeature_table_reader_imp::x_AddQualifierToBioSrc (CSeqFeatData& sfdata,
                                                        CSubSource::ESubtype stype, const string& val)

{
    CBioSource& bsp = sfdata.SetBiosrc ();
    CBioSource::TSubtype& slist = bsp.SetSubtype ();
    CRef<CSubSource> ssp (new CSubSource);
    ssp->SetSubtype (stype);
    ssp->SetName (val);
    slist.push_back (ssp);
    return true;
}


bool CFeature_table_reader_imp::x_AddQualifierToBioSrc (CSeqFeatData& sfdata,
                                                        COrgMod::ESubtype  mtype, const string& val)

{
    CBioSource& bsp = sfdata.SetBiosrc ();
    CBioSource::TOrg& orp = bsp.SetOrg ();
    COrg_ref::TOrgname& onp = orp.SetOrgname ();
    COrgName::TMod& mlist = onp.SetMod ();
    CRef<COrgMod> omp (new COrgMod);
    omp->SetSubtype (mtype);
    omp->SetSubname (val);
    mlist.push_back (omp);
    return true;
}


bool CFeature_table_reader_imp::x_AddQualifierToFeature (CRef<CSeq_feat> sfp,
                                                         const string& qual, const string& val)

{
    CSeqFeatData&          sfdata = sfp->SetData ();
    CSeqFeatData::E_Choice typ = sfdata.Which ();

    if (typ == CSeqFeatData::e_Biosrc) {

        if (m_OrgRefKeys.find (qual) != m_OrgRefKeys.end ()) {

            EOrgRef rtype = m_OrgRefKeys [qual];
            if (x_AddQualifierToBioSrc (sfdata, rtype, val)) return true;

        } else if (m_SubSrcKeys.find (qual) != m_SubSrcKeys.end ()) {

            CSubSource::ESubtype stype = m_SubSrcKeys [qual];
            if (x_AddQualifierToBioSrc (sfdata, stype, val)) return true;

        } else if (m_OrgModKeys.find (qual) != m_OrgModKeys.end ()) {

            COrgMod::ESubtype  mtype = m_OrgModKeys [qual];
            if (x_AddQualifierToBioSrc (sfdata, mtype, val)) return true;
        }

    } else if (m_QualKeys.find (qual) != m_QualKeys.end ()) {

        EQual qtype = m_QualKeys [qual];
        switch (typ) {
            case CSeqFeatData::e_Gene:
                if (x_AddQualifierToGene (sfdata, qtype, val)) return true;
                break;
            case CSeqFeatData::e_Cdregion:
                if (x_AddQualifierToCdregion (sfp, sfdata, qtype, val)) return true;
                break;
            case CSeqFeatData::e_Rna:
                if (x_AddQualifierToRna (sfdata, qtype, val)) return true;
                break;
           case CSeqFeatData::e_Imp:
                if (x_AddQualifierToImp (sfp, sfdata, qtype, qual, val)) return true;
                break;
            case CSeqFeatData::e_Region:
                if (qtype == eQual_region_name) {
                    sfdata.SetRegion (val);
                    return true;
                }
                break;
            case CSeqFeatData::e_Bond:
                if (qtype == eQual_bond_type) {
                    if (m_BondKeys.find (val) != m_BondKeys.end ()) {
                        CSeqFeatData::EBond btyp = m_BondKeys [val];
                        sfdata.SetBond (btyp);
                        return true;
                    }
                }
                break;
            case CSeqFeatData::e_Site:
                if (qtype == eQual_site_type) {
                    if (m_SiteKeys.find (val) != m_SiteKeys.end ()) {
                        CSeqFeatData::ESite styp = m_SiteKeys [val];
                        sfdata.SetSite (styp);
                        return true;
                    }
                }
                break;
            default:
                break;
        }
        switch (qtype) {
            case eQual_pseudo:
                sfp->SetPseudo (true);
                return true;
            case eQual_partial:
                sfp->SetPartial (true);
                return true;
            case eQual_exception:
                sfp->SetExcept (true);
                sfp->SetExcept_text (val);
                return true;
            case eQual_evidence:
                if (val == "experimental") {
                    sfp->SetExp_ev (CSeq_feat::eExp_ev_experimental);
                } else if (val == "not_experimental" || val == "non_experimental" ||
                           val == "not-experimental" || val == "non-experimental") {
                    sfp->SetExp_ev (CSeq_feat::eExp_ev_not_experimental);
                }
                return true;
            case eQual_note:
                {
                    if (sfp->CanGetComment ()) {
                        const CSeq_feat::TComment& comment = sfp->GetComment ();
                        CSeq_feat::TComment revised = comment + "; " + val;
                        sfp->SetComment (revised);
                    } else {
                        sfp->SetComment (val);
                    }
                    return true;
                }
            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_protein_id:
            case eQual_replace:
            case eQual_rpt_family:
            case eQual_rpt_type:
            case eQual_rpt_unit:
            case eQual_standard_name:
            case eQual_transcript_id:
            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;
                }
            case eQual_gene:
                {
                    CGene_ref& grp = sfp->SetGeneXref ();
                    if (val == "-") {
                        grp.SetLocus ("");
                    } else {
                        grp.SetLocus (val);
                    }
                    return true;
                }
            case eQual_gene_desc:
                {
                    CGene_ref& grp = sfp->SetGeneXref ();
                    grp.SetDesc (val);
                    return true;
                }
            case eQual_gene_syn:
                {
                    CGene_ref& grp = sfp->SetGeneXref ();
                    CGene_ref::TSyn& syn = grp.SetSyn ();
                    syn.push_back (val);
                    return true;
                }
            case eQual_locus_tag:
                {
                    CGene_ref& grp = sfp->SetGeneXref ();
                    grp.SetLocus_tag (val);
                    return true;
                }
            case eQual_db_xref:
                {
                    string db, tag;
                    if (NStr::SplitInTwo (val, ":", db, tag)) {
                        CSeq_feat::TDbxref& dblist = sfp->SetDbxref ();
                        CRef<CDbtag> dbt (new CDbtag);
                        dbt->SetDb (db);
                        CRef<CObject_id> oid (new CObject_id);
                        oid->SetStr (tag);
                        dbt->SetTag (*oid);
                        dblist.push_back (dbt);
                        return true;
                    }
                    return true;
                }
            default:
                break;
        }
    }
    return false;
}


bool CFeature_table_reader_imp::x_AddIntervalToFeature (CRef<CSeq_feat> sfp, CSeq_loc_mix *mix,
                                                        const string& seqid, Int4 start, Int4 stop,
                                                        bool partial5, bool partial3)

{
    CSeq_interval::TStrand strand = eNa_strand_plus;

    if (start > stop) {
        Int4 flip = start;
        start = stop;
        stop = flip;
        strand = eNa_strand_minus;
    }

    if (start == stop) {
        // just a point
        CRef<CSeq_loc> loc(new CSeq_loc);
        CSeq_point& point = loc->SetPnt();
        point.SetPoint(start);
        point.SetStrand(strand);
        CSeq_id seq_id(seqid);
        point.SetId().Assign (seq_id);
        mix->Set().push_back(loc);
    } else {
        // interval
        CRef<CSeq_loc> loc(new CSeq_loc);
        CSeq_interval& ival = loc->SetInt();
        ival.SetFrom(start);
        ival.SetTo(stop);
        ival.SetStrand(strand);
        CSeq_id seq_id(seqid);
        ival.SetId().Assign (seq_id);
        mix->Set().push_back(loc);
    }

    if (partial5 || partial3) {
        sfp->SetPartial (true);
    }

    return true;
}


CRef<CSeq_annot> CFeature_table_reader_imp::ReadSequinFeatureTable (
    CNcbiIstream& ifs,
    const string& seqid,
    const string& annotname,
    const CFeature_table_reader::TFlags flags
)