validatorp.cpp

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

        case CPub::e_Pmid:
            if ( uid == 0 ) {
                uid = pub.GetPmid();
            }
            break;
            
        case CPub::e_Article:
            ValidatePubArticle(pub.GetArticle(), uid, obj);
            break;

        case CPub::e_Equiv:
            PostErr(eDiag_Warning, eErr_GENERIC_UnnecessaryPubEquiv,
                "Publication has unexpected internal Pub-equiv", obj);
            break;

        default:
            break;
        }
    }
    ValidateEtAl(pubdesc, obj);
}


void CValidError_imp::ValidatePubGen
(const CCit_gen& gen,
 const CSerialObject& obj)
{
    if ( gen.IsSetCit()  &&  !gen.GetCit().empty() ) {
        const string& cit = gen.GetCit();
        if ( (NStr::CompareNocase(cit, 0, 8,  "submitted") != 0)          &&
             (NStr::CompareNocase(cit, 0, 11, "unpublished") != 0)        &&
             (NStr::CompareNocase(cit, 0, 18, "Online Publication") != 0) &&
             (NStr::CompareNocase(cit, 0, 26, "Published Only in DataBase") != 0) ) {
            PostErr(eDiag_Error, eErr_GENERIC_MissingPubInfo,
                "Unpublished citation text invalid", obj);
        }
    }
}


void CValidError_imp::ValidatePubArticle
(const CCit_art& art,
 int uid,
 const CSerialObject& obj)
{
    if ( !art.IsSetTitle()  ||  !HasTitle(art.GetTitle()) ) { 
        PostErr(eDiag_Error, eErr_GENERIC_MissingPubInfo,
            "Publication has no title", obj);
    }
    
    if ( art.IsSetAuthors() ) {
        const CAuth_list::C_Names& names = art.GetAuthors().GetNames();

        bool has_name = false;
        if ( names.IsStd() ) {
            has_name = HasName(names.GetStd());
        } 
        if ( names.IsMl() ) {
            has_name = !IsBlankStringList(names.GetMl());
        }
        if ( names.IsStr() ) {
            has_name = !IsBlankStringList(names.GetStr());
        }

        if ( !has_name ) {
            PostErr(eDiag_Error, eErr_GENERIC_MissingPubInfo,
                "Publication has no author names", obj);
        }
    }
    
    
    if ( art.GetFrom().IsJournal() ) {
        const CCit_jour& jour = art.GetFrom().GetJournal();
        
        bool has_iso_jta = HasIsoJTA(jour.GetTitle());
        bool in_press = false;

        if ( !HasTitle(jour.GetTitle()) ) {
            PostErr(eDiag_Error, eErr_GENERIC_MissingPubInfo,
            "Journal title missing", obj);
        }

        if ( jour.CanGetImp() ) {
            const CImprint& imp = jour.GetImp();

            if ( imp.CanGetPrepub() ) {
                in_press =  imp.GetPrepub() == CImprint::ePrepub_in_press;
            }

            if ( !imp.IsSetPrepub()        &&  
                 (!imp.CanGetPubstatus()   ||  
                  imp.GetPubstatus() != ePubStatus_aheadofprint) ) {
                bool no_vol = !imp.IsSetVolume()  || 
                              IsBlankString(imp.GetVolume());
                bool no_pages = !imp.IsSetPages()  ||
                                IsBlankString(imp.GetPages());

                EDiagSev sev = IsRefSeq() ? eDiag_Warning : eDiag_Error;

                if ( no_vol  &&  no_pages ) {
                    PostErr(sev, eErr_GENERIC_MissingPubInfo, 
                        "Journal volume and pages missing", obj);
                } else if ( no_vol ) {
                    PostErr(sev, eErr_GENERIC_MissingPubInfo,
                        "Journal volume missing", obj);
                } else if ( no_pages ) {
                    PostErr(sev, eErr_GENERIC_MissingPubInfo,
                        "Journal pages missing", obj);
                }
                
                if ( !no_pages ) {
                    sev = eDiag_Warning;
                    string pages = imp.GetPages();
                    size_t pos = pages.find('-');
                    if ( pos != string::npos ) {
                        try {
                            int start = 
                                NStr::StringToInt(pages.substr(0, pos), 
                                                  10, NStr::eCheck_Skip);
                            
                            try {
                                int stop = NStr::StringToInt(
                                        pages.substr(pos + 1, pages.length()),
                                        10, NStr::eCheck_Skip);
                                
                                if ( start == 0  ||  stop == 0 ) {
                                    PostErr(sev, eErr_GENERIC_BadPageNumbering,
                                        "Page numbering has zero value", obj);
                                } else if ( start < 0  ||  stop < 0 ) {
                                    PostErr(sev, eErr_GENERIC_BadPageNumbering,
                                        "Page numbering has negative value", obj);
                                } else if ( start > stop ) {
                                    PostErr(sev, eErr_GENERIC_BadPageNumbering,
                                        "Page numbering out of order", obj);
                                } else if ( stop - start > 50 ) {
                                    PostErr(sev, eErr_GENERIC_BadPageNumbering,
                                        "Page numbering greater than 50", obj);
                                }
                            } catch ( CStringException& ) {
                                PostErr(sev, eErr_GENERIC_BadPageNumbering,
                                    "Page numbering stop looks strange", obj);
                            }
                        } catch ( CStringException& ) {
                            if ( !isalpha(pages[0]) ) {
                                PostErr(sev, eErr_GENERIC_BadPageNumbering,
                                    "Page numbering start looks strange", obj);
                            }
                        }
                    }
                }
            }
        }
        if ( !has_iso_jta  &&  (uid > 0  ||  in_press  ||  IsRequireISOJTA()) ) {
            PostErr(eDiag_Warning, eErr_GENERIC_MissingPubInfo,
                "ISO journal title abbreviation missing", obj);
        }
    }
}


bool CValidError_imp::HasTitle(const CTitle& title)
{
    ITERATE (CTitle::Tdata, item, title.Get() ) {
        const string *str = 0;
        switch ( (*item)->Which() ) {
        case CTitle::C_E::e_Name:
            str = &(*item)->GetName();
            break;

        case CTitle::C_E::e_Tsub:
            str = &(*item)->GetTsub();
            break;

        case CTitle::C_E::e_Trans:
            str = &(*item)->GetTrans();
            break;

        case CTitle::C_E::e_Jta:
            str = &(*item)->GetJta();
            break;

        case CTitle::C_E::e_Iso_jta:
            str = &(*item)->GetIso_jta();
            break;

        case CTitle::C_E::e_Ml_jta:
            str = &(*item)->GetMl_jta();
            break;

        case CTitle::C_E::e_Coden:
            str = &(*item)->GetCoden();
            break;

        case CTitle::C_E::e_Issn:
            str = &(*item)->GetIssn();
            break;

        case CTitle::C_E::e_Abr:
            str = &(*item)->GetAbr();
            break;

        case CTitle::C_E::e_Isbn:
            str = &(*item)->GetIsbn();
            break;

        default:
            break;
        };
        if ( IsBlankString(*str) ) {
            return false;
        }
    }
    return true;
}


bool CValidError_imp::HasIsoJTA(const CTitle& title)
{
    ITERATE (CTitle::Tdata, item, title.Get() ) {
        if ( (*item)->IsIso_jta() ) {
            return true;
        }
    }
    return false;
}


bool CValidError_imp::HasName(const list< CRef< CAuthor > >& authors)
{
    ITERATE ( list< CRef< CAuthor > >, auth, authors ) {
        const CPerson_id& pid = (*auth)->GetName();
        if ( pid.IsName() ) {
            if ( !IsBlankString(pid.GetName().GetLast()) ) {
                return true;
            }
        }
    }
    return false;
}


void CValidError_imp::ValidateEtAl
(const CPubdesc& pubdesc,
 const CSerialObject& obj)
{
    ITERATE( CPub_equiv::Tdata, pub, pubdesc.GetPub().Get() ) {
        const CAuth_list* authors = 0;
        switch ( (*pub)->Which() ) {
        case CPub::e_Gen:
            if ( (*pub)->GetGen().IsSetAuthors() ) {
                authors = &((*pub)->GetGen().GetAuthors());
            }
            break;
        case CPub::e_Sub:
            authors = &((*pub)->GetSub().GetAuthors());
            break;
        case CPub::e_Article:
            if ( (*pub)->GetArticle().IsSetAuthors() ) {
                authors = &((*pub)->GetArticle().GetAuthors());
            }
            break;
        case CPub::e_Book:
            authors = &((*pub)->GetBook().GetAuthors());
            break;
        case CPub::e_Proc:
            authors = &((*pub)->GetProc().GetBook().GetAuthors());
            break;
        case CPub::e_Man:
            authors = &((*pub)->GetMan().GetCit().GetAuthors());
            break;
        default:
            break;
        }

        if ( !authors ) {
            continue;
        }

        const CAuth_list::C_Names& names = authors->GetNames();
        if ( !names.IsStd() ) {
            continue;
        }

        ITERATE ( CAuth_list::C_Names::TStd, name, names.GetStd() ) {
            if ( (*name)->GetName().IsName() ) {
                const CName_std& nstd = (*name)->GetName().GetName();
                if ( (NStr::CompareNocase(nstd.GetLast(), "et al.") == 0)  ||
                     (nstd.GetLast() == "et."  &&  nstd.GetInitials() == "al"  &&
                      nstd.GetFirst().empty()) ) {
                    CAuth_list::C_Names::TStd::const_iterator temp = name;
                    if ( ++temp == names.GetStd().end() ) {
                        PostErr(eDiag_Warning, eErr_GENERIC_AuthorListHasEtAl,
                            "Author list ends in et al.", obj);
                    } else {
                        PostErr(eDiag_Warning, eErr_GENERIC_AuthorListHasEtAl,
                            "Author list contains et al.", obj);
                    }
                }
            }
        }
    }
}


void CValidError_imp::ValidateDbxref
(const CDbtag& xref,
 const CSerialObject& obj,
 bool biosource)
{
    if ( !xref.CanGetDb() ) {
        return;
    }
    const string& db = xref.GetDb();
    CDbtag::EDbtagType db_type = xref.GetType();
    bool is_pid = db_type == CDbtag::eDbtagType_PID   ||
                  db_type == CDbtag::eDbtagType_PIDd  ||
                  db_type == CDbtag::eDbtagType_PIDe  ||
                  db_type == CDbtag::eDbtagType_PIDg;

    if ( biosource ) {
        if ( !xref.IsApproved() || is_pid ) {
            PostErr(eDiag_Warning, eErr_SEQ_FEAT_IllegalDbXref,
                "Illegal db_xref type " + db, obj);
        }
    } else {  // Seq_feat
        const CSeq_feat* feat = dynamic_cast<const CSeq_feat*>(&obj);
        if ( feat != 0 ) {
            bool is_cdregion = 
                feat->CanGetData()  &&  feat->GetData().IsCdregion();
            bool refseq = IsRefSeq();
            if ( !xref.IsApproved(refseq)  ||  (!is_cdregion  &&  is_pid) ) {
                const char* legal = xref.IsApprovedNoCase(refseq);
                if ( legal != 0 ) {
                    PostErr(eDiag_Warning, eErr_SEQ_FEAT_IllegalDbXref,
                        "Illegal db_xref type " + db +
                        ", legal capitalization is " + legal, obj);
                } else {
                    PostErr(eDiag_Warning, eErr_SEQ_FEAT_IllegalDbXref,
                        "Illegal db_xref type " + db, obj);
                }
            }
        }
    }
}


void CValidError_imp::ValidateDbxref
(TDbtags& xref_list,
 const CSerialObject& obj,
 bool biosource)
{
    ITERATE( TDbtags, xref, xref_list) {
        ValidateDbxref(**xref, obj, biosource);
    }
}


void CValidError_imp::ValidateBioSource
(const CBioSource&    bsrc,
 const CSerialObject& obj)
{
    if ( !bsrc.CanGetOrg() ) {
        PostErr(eDiag_Error, eErr_SEQ_DESCR_NoOrgFound,
            "No organism has been applied to this Bioseq.", obj);
        return;
    }

	const COrg_ref& orgref = bsrc.GetOrg();
  
	// Organism must have a name.
	if ( (!orgref.IsSetTaxname()  ||  orgref.GetTaxname().empty())  &&
         (!orgref.IsSetCommon()   ||  orgref.GetCommon().empty()) ) {
		PostErr(eDiag_Error, eErr_SEQ_DESCR_NoOrgFound,
            "No organism name has been applied to this Bioseq.", obj);
	}

	// validate legal locations.
	if ( bsrc.GetGenome() == CBioSource::eGenome_transposon  ||
		 bsrc.GetGenome() == CBioSource::eGenome_insertion_seq ) {
		PostErr(eDiag_Warning, eErr_SEQ_DESCR_ObsoleteSourceLocation,
            "Transposon and insertion sequence are no longer legal locations.",
            obj);
	}

	int chrom_count = 0;
	bool chrom_conflict = false;
    const CSubSource *chromosome = 0;
	string countryname;
    bool germline = false;
    bool rearranged = false;

    if ( bsrc.IsSetSubtype() ) {
        ITERATE( CBioSource::TSubtype, ssit, bsrc.GetSubtype() ) {
            switch ( (**ssit).GetSubtype() ) {
                
            case CSubSource::eSubtype_country:
                countryname = (**ssit).GetName();
                if ( !CCountries::IsValid(countryname) ) {
                    if ( countryname.empty() ) {
                        countryname = "?";
                    }
                    PostErr(eDiag_Warning, eErr_SEQ_DESCR_BadCountryCode,
                        "Bad country name " + countryname, obj);
                }
                break;
                
            case CSubSource::eSubtype_chromosome:
                ++chrom_count;
                if ( chromosome != 0 ) {
                    if ( NStr::CompareNocase((**ssit).GetName(), chromosome->GetName()) != 0) {
                        chrom_conflict = true;
                    }          
                } else {