validatorp.cpp

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

 const string& message,
 TBioseq sq,
 TGraph graph)
{
    // Append Graph label
    string msg(message + " GRAPH: ");
    if ( graph.IsSetTitle() ) {
        msg += graph.GetTitle();
    } else {
        msg += "Not Named";
    }
    msg += " ";
    graph.GetLoc().GetLabel(&msg);

    PostErr(sv, et, msg, sq);
}


void CValidError_imp::PostErr
(EDiagSev sv,
 EErrType et,
 const string& message,
 TAlign align)
{
    // Append Alignment label
    string msg(message + " ALIGNMENT: ");
    msg += align.ENUM_METHOD_NAME(EType)()->FindName(align.GetType(), true);
    msg += ", dim=" + NStr::IntToString(align.GetDim());

    msg+= " SEGS: ";
    msg += align.GetSegs().SelectionName(align.GetSegs().Which());

    m_ErrRepository->AddValidErrItem(new CValidErrItem(sv, et, msg, align));
}


void CValidError_imp::PostErr
(EDiagSev sv,
 EErrType et,
 const string& message,
 TEntry entry)
{
    m_ErrRepository->AddValidErrItem(new CValidErrItem(sv, et, message, entry));
}


bool CValidError_imp::Validate
(const CSeq_entry& se,
 const CCit_sub* cs,
 CScope* scope)
{
    if ( m_PrgCallback ) {
        m_PrgInfo.m_State = CValidator::CProgressInfo::eState_Initializing;
        if ( m_PrgCallback(&m_PrgInfo) ) {
            return false;
        }
    }

    // Check that CSeq_entry has data
    if (se.Which() == CSeq_entry::e_not_set) {
        ERR_POST(Warning << "Seq_entry not set");
        return false;
    }

    // Get first CBioseq object pointer for PostErr below.
    CTypeConstIterator<CBioseq> seq(ConstBegin(se));
    if (!seq) {
        ERR_POST("No Bioseq anywhere on this Seq-entry");
        return false;
    }

    Setup(se, scope);
 
    // If m_NonASCII is true, then this flag was set by the caller
    // of validate to indicate that a non ascii character had been
    // read from a file being used to create a CSeq_entry, that the
    // error had been corrected, but that the error needs to be reported
    // by Validate. Note, Validate is not doing anything other than
    // reporting an error if m_NonASCII is true;
    if (m_NonASCII) {
        PostErr(eDiag_Critical, eErr_GENERIC_NonAsciiAsn,
                  "Non-ascii chars in input ASN.1 strings", *seq);
        // Only report the error once
        m_NonASCII = false;
    }

    // Iterate thru components of record and validate each

    // Features:

    if ( m_PrgCallback ) {
        m_PrgInfo.m_State = CValidator::CProgressInfo::eState_Feat;
        m_PrgInfo.m_Current = m_NumFeat;
        m_PrgInfo.m_CurrentDone = 0;
        if ( m_PrgCallback(&m_PrgInfo) ) {
            return false;
        }
    }
    CValidError_feat feat_validator(*this);
    for (CTypeConstIterator<CSeq_feat> fi(se); fi; ++fi) {
        try {
            feat_validator.ValidateSeqFeat(*fi);
            if ( m_PrgCallback ) {
                m_PrgInfo.m_CurrentDone++;
                m_PrgInfo.m_TotalDone++;
                if ( m_PrgCallback(&m_PrgInfo) ) {
                    return false;
                }
            }
        } catch ( const exception& e ) {
        PostErr(eDiag_Fatal, eErr_Internal_Exception,
            string("Exeption while validating feature. EXCEPTION: ") +
                e.what(), *fi);
            return true;
        }
    }
    if ( feat_validator.GetNumGenes() == 0  &&  
         feat_validator.GetNumGeneXrefs() > 0 ) {
        PostErr(eDiag_Warning, eErr_SEQ_FEAT_OnlyGeneXrefs,
            "There are " + NStr::IntToString(feat_validator.GetNumGeneXrefs()) +
            " gene xrefs and no gene features in this record.", se);
    }

    // Descriptors:

    if ( m_PrgCallback ) {
        m_PrgInfo.m_State = CValidator::CProgressInfo::eState_Desc;
        m_PrgInfo.m_Current = m_NumDesc;
        m_PrgInfo.m_CurrentDone = 0;
        m_PrgCallback(&m_PrgInfo);
    }
    CValidError_desc desc_validator(*this);
    for (CTypeConstIterator<CSeqdesc> di(se); di; ++di) {
        try {
            desc_validator.ValidateSeqDesc(*di);
            if ( m_PrgCallback ) {
                m_PrgInfo.m_CurrentDone++;
                m_PrgInfo.m_TotalDone++;
                if ( m_PrgCallback(&m_PrgInfo) ) {
                    return false;
                }
            }
        } catch ( const exception& e ) {
        PostErr(eDiag_Fatal, eErr_Internal_Exception,
            string("Exeption while validating descriptor. EXCEPTION: ") +
                e.what(), *di);
            return true;
        }
    }
    
    // Bioseqs:

    if ( m_PrgCallback ) {
        m_PrgInfo.m_State = CValidator::CProgressInfo::eState_Bioseq;
        m_PrgInfo.m_Current = m_NumBioseq;
        m_PrgInfo.m_CurrentDone = 0;
        m_PrgCallback(&m_PrgInfo);
    }
    CValidError_bioseq bioseq_validator(*this);
    for (CTypeConstIterator<CBioseq> bi(se); bi; ++bi) {
        try {
            bioseq_validator.ValidateSeqIds(*bi);
            bioseq_validator.ValidateInst(*bi);
            bioseq_validator.ValidateBioseqContext(*bi);
            bioseq_validator.ValidateHistory(*bi);
            if ( m_PrgCallback ) {
                m_PrgInfo.m_CurrentDone++;
                m_PrgInfo.m_TotalDone++;
                if ( m_PrgCallback(&m_PrgInfo) ) {
                    return false;
                }
            }
        } catch ( const exception& e ) {
        PostErr(eDiag_Fatal, eErr_Internal_Exception,
            string("Exeption while validating bioseq. EXCEPTION: ") +
                e.what(), *bi);
            return true;
        }
    }
    if ( bioseq_validator.GetTpaWithHistory() > 0  &&
         bioseq_validator.GetTpaWithoutHistory() > 0 ) {
        PostErr(eDiag_Error, eErr_SEQ_INST_TpaAssmeblyProblem,
            "There are " +
            NStr::IntToString(bioseq_validator.GetTpaWithHistory()) +
            " TPAs with history and " + 
            NStr::IntToString(bioseq_validator.GetTpaWithoutHistory()) +
            " without history in this record.", se);
    }

    // Bioseq sets:

    if ( m_PrgCallback ) {
        m_PrgInfo.m_State = CValidator::CProgressInfo::eState_Bioseq_set;
        m_PrgInfo.m_Current = m_NumBioseq_set;
        m_PrgInfo.m_CurrentDone = 0;
        m_PrgCallback(&m_PrgInfo);
    }
    CValidError_bioseqset bioseqset_validator(*this);
    for (CTypeConstIterator<CBioseq_set> si(se); si; ++si) {
        try {
            bioseqset_validator.ValidateBioseqSet(*si);
            if ( m_PrgCallback ) {
                m_PrgInfo.m_CurrentDone++;
                m_PrgInfo.m_TotalDone++;
                if ( m_PrgCallback(&m_PrgInfo) ) {
                    return false;
                }
            }
        } catch ( const exception& e ) {
        PostErr(eDiag_Fatal, eErr_Internal_Exception,
            string("Exeption while validating bioseq set. EXCEPTION: ") +
                e.what(), *si);
            return true;
        }
    }

    // Alignments:

    if ( m_PrgCallback ) {
        m_PrgInfo.m_State = CValidator::CProgressInfo::eState_Align;
        m_PrgInfo.m_Current = m_NumAlign;
        m_PrgInfo.m_CurrentDone = 0;
        m_PrgCallback(&m_PrgInfo);
    }
    CValidError_align align_validator(*this);
    for (CTypeConstIterator<CSeq_align> ai(se); ai; ++ai) {
        try {
            align_validator.ValidateSeqAlign(*ai);
            if ( m_PrgCallback ) {
                m_PrgInfo.m_CurrentDone++;
                m_PrgInfo.m_TotalDone++;
                if ( m_PrgCallback(&m_PrgInfo) ) {
                    return false;
                }
            }
        } catch ( const exception& e ) {
        PostErr(eDiag_Fatal, eErr_Internal_Exception,
            string("Exeption while validating alignment. EXCEPTION: ") +
                e.what(), *ai);
            return true;
        }
    }

    // Graphs:
    if ( m_PrgCallback ) {
        m_PrgInfo.m_State = CValidator::CProgressInfo::eState_Graph;
        m_PrgInfo.m_Current = m_NumGraph;
        m_PrgInfo.m_CurrentDone = 0;
        m_PrgCallback(&m_PrgInfo);
    }
    CValidError_graph graph_validator(*this);
    for (CTypeConstIterator<CSeq_graph> gi(se); gi; ++gi) {
        try {
            graph_validator.ValidateSeqGraph(*gi);
            if ( m_PrgCallback ) {
                m_PrgInfo.m_CurrentDone++;
                m_PrgInfo.m_TotalDone++;
                if ( m_PrgCallback(&m_PrgInfo) ) {
                    return false;
                }
            }
        } catch ( const exception& e ) {
        PostErr(eDiag_Fatal, eErr_Internal_Exception,
            string("Exeption while validating graph. EXCEPTION: ") +
                e.what(), *gi);
            return true;
        }
    }
    SIZE_TYPE misplaced = graph_validator.GetNumMisplacedGraphs();
    if ( misplaced > 0 ) {
        string num = NStr::IntToString(misplaced);
        PostErr(eDiag_Critical, eErr_SEQ_PKG_GraphPackagingProblem,
            string("There ") + ((misplaced > 1) ? "are" : "is") + num + 
            " mispackaged graph" + ((misplaced > 1) ? "s" : "") + " in this record.",
            se);
    }

    // Annotation:
    if ( m_PrgCallback ) {
        m_PrgInfo.m_State = CValidator::CProgressInfo::eState_Annot;
        m_PrgInfo.m_Current = m_NumAnnot;
        m_PrgInfo.m_CurrentDone = 0;
        m_PrgCallback(&m_PrgInfo);
    }
    CValidError_annot annot_validator(*this);
    for (CTypeConstIterator<CSeq_annot> ni(se); ni; ++ni) {
        try {
            annot_validator.ValidateSeqAnnot(*ni);
            if ( m_PrgCallback ) {
                m_PrgInfo.m_CurrentDone++;
                m_PrgInfo.m_TotalDone++;
                if ( m_PrgCallback(&m_PrgInfo) ) {
                    return false;
                }
            }
        } catch ( const exception& e ) {
        PostErr(eDiag_Fatal, eErr_Internal_Exception,
            string("Exeption while validating annotation. EXCEPTION: ") +
                e.what(), *ni);
            return true;
        }
    }

    // Descriptor lists:

    if ( m_PrgCallback ) {
        m_PrgInfo.m_State = CValidator::CProgressInfo::eState_Descr;
        m_PrgInfo.m_Current = m_NumDescr;
        m_PrgInfo.m_CurrentDone = 0;
        m_PrgCallback(&m_PrgInfo);
    }
    CValidError_descr descr_validator(*this);
    for (CTypeConstIterator<CSeq_descr> ei(se); ei; ++ei) {
        try {
            descr_validator.ValidateSeqDescr(*ei);
            if ( m_PrgCallback ) {
                m_PrgInfo.m_CurrentDone++;
                m_PrgInfo.m_TotalDone++;
                if ( m_PrgCallback(&m_PrgInfo) ) {
                    return false;
                }
            }
        } catch ( const exception& e ) {
        PostErr(eDiag_Fatal, eErr_Internal_Exception,
            string("Exeption while validating annotation. EXCEPTION: ") +
                e.what(), *ei);
            return true;
        }
    }

    ReportMissingPubs(se, cs);
    ReportMissingBiosource(se);
    ReportProtWithoutFullRef();
    ReportBioseqsWithNoMolinfo();
    return true;
}


void CValidError_imp::Validate(const CSeq_submit& ss, CScope* scope)
{
    // Check that ss is type e_Entrys
    if ( ss.GetData().Which() != CSeq_submit::C_Data::e_Entrys ) {
        return;
    }

    // Get CCit_sub pointer
    const CCit_sub* cs = &ss.GetSub().GetCit();

    // Just loop thru CSeq_entrys
    ITERATE( list< CRef< CSeq_entry > >, se, ss.GetData().GetEntrys() ) {
        Validate(**se, cs, scope);
    }
}


// Validate standalone Seq-annot objects
void CValidError_imp::Validate(const CSeq_annot& sa, CScope* scope)
{
    Setup(sa, scope);

    // Iterate thru components of record and validate each

    CValidError_annot annot_validator(*this);
    annot_validator.ValidateSeqAnnot(sa);

    CValidError_feat feat_validator(*this);
    for (CTypeConstIterator <CSeq_feat> fi (sa); fi; ++fi) {
        feat_validator.ValidateSeqFeat(*fi);
    }

    CValidError_align align_validator(*this);
    for (CTypeConstIterator <CSeq_align> ai (sa); ai; ++ai) {
        align_validator.ValidateSeqAlign(*ai);
    }

    CValidError_graph graph_validator(*this);
    for (CTypeConstIterator <CSeq_graph> gi (sa); gi; ++gi) {
        graph_validator.ValidateSeqGraph(*gi);
    }
}


void CValidError_imp::SetProgressCallback
(CValidator::TProgressCallback callback,
 void* user_data)
{
    m_PrgCallback = callback;
    m_PrgInfo.m_UserData = user_data;
}


void CValidError_imp::ValidatePubdesc
(const CPubdesc& pubdesc,
 const CSerialObject& obj)
{
    int uid = 0;

    ITERATE( CPub_equiv::Tdata, pub_iter, pubdesc.GetPub().Get() ) {
        const CPub& pub = **pub_iter;

        switch( pub.Which() ) {
        case CPub::e_Gen:
            ValidatePubGen(pub.GetGen(), obj);
            break;

        case CPub::e_Sub:
            ValidateCitSub(pub.GetSub(), obj);
            break;

        case CPub::e_Muid:
            if ( uid == 0 ) {
                uid = pub.GetMuid();
            }
            break;