开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数值算法/人工智能 > 生物技术 > 查看源码
validatorp.cpp
资源名称：ncbi_cxx_win--Jul_08_2004.zip　[点击查看]
上传用户：yhdzpy8989
上传日期：2007-06-13
资源大小：13604k
文件大小：77k
源码类别：

生物技术

开发平台：

C/C++

validatorp.cpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: validatorp.cpp,v $
  4.  * PRODUCTION Revision 1000.3  2004/06/01 19:47:39  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.52
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. /*  $Id: validatorp.cpp,v 1000.3 2004/06/01 19:47:39 gouriano Exp $
  11.  * ===========================================================================
  12.  *
  13.  *                            PUBLIC DOMAIN NOTICE
  14.  *               National Center for Biotechnology Information
  15.  *
  16.  *  This software/database is a "United States Government Work" under the
  17.  *  terms of the United States Copyright Act.  It was written as part of
  18.  *  the author's official duties as a United States Government employee and
  19.  *  thus cannot be copyrighted.  This software/database is freely available
  20.  *  to the public for use. The National Library of Medicine and the U.S.
  21.  *  Government have not placed any restriction on its use or reproduction.
  22.  *
  23.  *  Although all reasonable efforts have been taken to ensure the accuracy
  24.  *  and reliability of the software and data, the NLM and the U.S.
  25.  *  Government do not and cannot warrant the performance or results that
  26.  *  may be obtained by using this software or data. The NLM and the U.S.
  27.  *  Government disclaim all warranties, express or implied, including
  28.  *  warranties of performance, merchantability or fitness for any particular
  29.  *  purpose.
  30.  *
  31.  *  Please cite the author in any work or product based on this material.
  32.  *
  33.  * ===========================================================================
  34.  *
  35.  * Author:  Jonathan Kans, Clifford Clausen, Aaron Ucko, Mati Shomrat, ....
  36.  *
  37.  * File Description:
  38.  *   Implementation of private parts of the validator
  39.  *   .......
  40.  *
  41.  */
  42. #include <ncbi_pch.hpp>
  43. #include <corelib/ncbistd.hpp>
  44. #include <corelib/ncbistr.hpp>
  45. #include <objmgr/object_manager.hpp>
  47. #include "validatorp.hpp"
  48. #include "utilities.hpp"
  50. #include <serial/iterator.hpp>
  51. #include <serial/enumvalues.hpp>
  53. #include <objects/general/Dbtag.hpp>
  54. #include <objects/general/Person_id.hpp>
  55. #include <objects/general/Name_std.hpp>
  57. #include <objects/seqalign/Seq_align.hpp>
  59. #include <objects/seqset/Bioseq_set.hpp>
  60. #include <objects/seqset/Seq_entry.hpp>
  62. #include <objects/seq/Bioseq.hpp>
  63. #include <objects/seq/Seq_annot.hpp>
  64. #include <objects/seq/Seqdesc.hpp>
  65. #include <objects/seq/Seq_descr.hpp>
  66. #include <objects/seq/Pubdesc.hpp>
  68. #include <objects/seqfeat/BioSource.hpp>
  69. #include <objects/seqfeat/OrgMod.hpp>
  70. #include <objects/seqfeat/OrgName.hpp>
  71. #include <objects/seqfeat/Org_ref.hpp>
  72. #include <objects/seqfeat/Seq_feat.hpp>
  73. #include <objects/seqfeat/SubSource.hpp>
  75. #include <objects/seqloc/Seq_loc.hpp>
  76. #include <objects/seqloc/Seq_interval.hpp>
  77. #include <objects/seqloc/Seq_point.hpp>
  78. #include <objects/seqloc/Textseq_id.hpp>
  80. #include <objects/seqres/Seq_graph.hpp>
  82. #include <objects/submit/Seq_submit.hpp>
  83. #include <objects/submit/Submit_block.hpp>
  85. #include <objmgr/util/feature.hpp>
  86. #include <objmgr/util/sequence.hpp>
  88. #include <objmgr/feat_ci.hpp>
  89. #include <objmgr/seq_vector.hpp>
  90. #include <objmgr/scope.hpp>
  92. #include <objects/pub/Pub.hpp>
  93. #include <objects/pub/Pub_equiv.hpp>
  95. #include <objects/biblio/Author.hpp>
  96. #include <objects/biblio/Auth_list.hpp>
  97. #include <objects/biblio/Cit_art.hpp>
  98. #include <objects/biblio/Cit_book.hpp>
  99. #include <objects/biblio/Cit_gen.hpp>
  100. #include <objects/biblio/Cit_jour.hpp>
  101. #include <objects/biblio/Cit_let.hpp>
  102. #include <objects/biblio/Cit_proc.hpp>
  103. #include <objects/biblio/Cit_sub.hpp>
  104. #include <objects/biblio/PubMedId.hpp>
  105. #include <objects/biblio/PubStatus.hpp>
  106. #include <objects/biblio/Title.hpp>
  107. #include <objects/biblio/Imprint.hpp>
  108. #include <objects/biblio/Affil.hpp>
  110. #include <algorithm>
  112. BEGIN_NCBI_SCOPE
  113. BEGIN_SCOPE(objects)
  114. BEGIN_SCOPE(validator)
  115. using namespace sequence;
  118. auto_ptr<CTextFsa> CValidError_imp::m_SourceQualTags;
  121. // =============================================================================
  122. //                            CValidError_imp Public
  123. // =============================================================================
  125. // Constructor
  126. CValidError_imp::CValidError_imp
  127. (CObjectManager& objmgr, 
  128.  CValidError*       errs,
  129.  Uint4              options) :
  130.       m_ObjMgr(&objmgr),
  131.       m_Scope(0),
  132.       m_TSE(0),
  133.       m_ErrRepository(errs),
  134.       m_NonASCII((options & CValidator::eVal_non_ascii) != 0),
  135.       m_SuppressContext((options & CValidator::eVal_no_context) != 0),
  136.       m_ValidateAlignments((options & CValidator::eVal_val_align) != 0),
  137.       m_ValidateExons((options & CValidator::eVal_val_exons) != 0),
  138.       m_SpliceErr((options & CValidator::eVal_splice_err) != 0),
  139.       m_OvlPepErr((options & CValidator::eVal_ovl_pep_err) != 0),
  140.       m_RequireTaxonID((options & CValidator::eVal_need_taxid) != 0),
  141.       m_RequireISOJTA((options & CValidator::eVal_need_isojta) != 0),
  142.       m_ValidateIdSet((options & CValidator::eVal_validate_id_set) != 0),
  143.       m_RemoteFetch((options & CValidator::eVal_remote_fetch) != 0),
  144.       m_PerfBottlenecks((options & CValidator::eVal_perf_bottlenecks) != 0),
  145.       m_IsStandaloneAnnot(false),
  146.       m_NoPubs(false),
  147.       m_NoBioSource(false),
  148.       m_IsGPS(false),
  149.       m_IsGED(false),
  150.       m_IsPDB(false),
  151.       m_IsTPA(false),
  152.       m_IsPatent(false),
  153.       m_IsRefSeq(false),
  154.       m_IsNC(false),
  155.       m_IsNG(false),
  156.       m_IsNM(false),
  157.       m_IsNP(false),
  158.       m_IsNR(false),
  159.       m_IsNS(false),
  160.       m_IsNT(false),
  161.       m_IsNW(false),
  162.       m_IsXR(false),
  163.       m_IsGI(false),
  164.       m_PrgCallback(0),
  165.       m_NumAlign(0),
  166.       m_NumAnnot(0),
  167.       m_NumBioseq(0),
  168.       m_NumBioseq_set(0),
  169.       m_NumDesc(0),
  170.       m_NumDescr(0),
  171.       m_NumFeat(0),
  172.       m_NumGraph(0)
  173. {
  174.     if ( m_SourceQualTags.get() == 0 ) {
  175.         InitializeSourceQualTags();
  176.     }
  177. }
  180. // Destructor
  181. CValidError_imp::~CValidError_imp()
  182. {
  183. }
  186. // Error post methods
  187. void CValidError_imp::PostErr
  188. (EDiagSev sv,
  189.  EErrType et,
  190.  const string&  msg,
  191.  const CSerialObject& obj)
  192. {
  193.     const CSeqdesc* desc = dynamic_cast < const CSeqdesc* > (&obj);
  194.     if (desc != 0) {
  195.         PostErr (sv, et, msg, *desc);
  196.         return;
  197.     }
  198.     const CSeq_feat* feat = dynamic_cast < const CSeq_feat* > (&obj);
  199.     if (feat != 0) {
  200.         PostErr (sv, et, msg, *feat);
  201.         return;
  202.     }
  203.     const CBioseq* seq = dynamic_cast < const CBioseq* > (&obj);
  204.     if (seq != 0) {
  205.         PostErr (sv, et, msg, *seq);
  206.         return;
  207.     }
  208.     const CBioseq_set* set = dynamic_cast < const CBioseq_set* > (&obj);
  209.     if (set != 0) {
  210.         PostErr (sv, et, msg, *set);
  211.         return;
  212.     }
  213.     const CSeq_annot* annot = dynamic_cast < const CSeq_annot* > (&obj);
  214.     if (annot != 0) {
  215.         PostErr (sv, et, msg, *annot);
  216.         return;
  217.     }
  218.     const CSeq_graph* graph = dynamic_cast < const CSeq_graph* > (&obj);
  219.     if (graph != 0) {
  220.         PostErr (sv, et, msg, *graph);
  221.         return;
  222.     }
  223.     const CSeq_align* align = dynamic_cast < const CSeq_align* > (&obj);
  224.     if (align != 0) {
  225.         PostErr (sv, et, msg, *align);
  226.         return;
  227.     }
  228.     const CSeq_entry* entry = dynamic_cast < const CSeq_entry* > (&obj);
  229.     if (entry != 0) {
  230.         PostErr (sv, et, msg, *entry);
  231.         return;
  232.     }
  233. }
  236. void CValidError_imp::PostErr
  237. (EDiagSev sv,
  238.  EErrType et,
  239.  const string&   message,
  240.  TDesc    ds)
  241. {
  242.     // Append Descriptor label
  243.     string msg(message + " DESCRIPTOR: ");
  244.     ds.GetLabel (&msg, CSeqdesc::eBoth);
  246.     m_ErrRepository->AddValidErrItem(new CValidErrItem(sv, et, msg, ds));
  247. }
  250. void CValidError_imp::PostErr
  251. (EDiagSev sv,
  252.  EErrType et,
  253.  const string&   message,
  254.  TFeat    ft)
  255. {
  256.     // Add feature part of label
  257.     string msg(message + " FEATURE: ");
  258.     feature::GetLabel(ft, &msg, feature::eBoth, m_Scope);
  260.     // Add feature location part of label
  261.     string loc_label;
  262.     if (m_SuppressContext) {
  263.         CSeq_loc loc;
  264.         loc.Assign(ft.GetLocation());
  265.         ChangeSeqLocId(&loc, false, m_Scope.GetPointer());
  266.         loc.GetLabel(&loc_label);
  267.     } else {
  268.         ft.GetLocation().GetLabel(&loc_label);
  269.     }
  270.     if (loc_label.size() > 800) {
  271.         loc_label = loc_label.substr(0, 797) + "...";
  272.     }
  273.     if (!loc_label.empty()) {
  274.         loc_label = string("[") + loc_label + "]";
  275.         msg += loc_label;
  276.     }
  278.     // Append label for bioseq of feature location
  279.     if (!m_SuppressContext) {
  280.         try {
  281.             CBioseq_Handle hnd = m_Scope->GetBioseqHandle(ft.GetLocation());
  282.             if( hnd ) {
  283.                 CBioseq_Handle::TBioseqCore bc = hnd.GetBioseqCore();
  284.                 msg += "[";
  285.                 bc->GetLabel(&msg, CBioseq::eBoth);
  286.                 msg += "]";
  287.             }
  288.         } catch (...){
  289.         };
  290.     }
  292.     // Append label for product of feature
  293.     loc_label.erase();
  294.     if (ft.IsSetProduct()) {
  295.         if (m_SuppressContext) {
  296.             CSeq_loc loc;
  297.             loc.Assign(ft.GetProduct());
  298.             ChangeSeqLocId(&loc, false, m_Scope.GetPointer());
  299.             loc.GetLabel(&loc_label);
  300.         } else {
  301.             ft.GetProduct().GetLabel(&loc_label);
  302.         }
  303.         if (loc_label.size() > 800) {
  304.             loc_label = loc_label.substr(0, 797) + "...";
  305.         }
  306.         if (!loc_label.empty()) {
  307.             loc_label = string("[") + loc_label + "]";
  308.             msg += loc_label;
  309.         }
  310.     }
  311.     m_ErrRepository->AddValidErrItem(new CValidErrItem(sv, et, msg, ft));
  312. }
  315. void CValidError_imp::PostErr
  316. (EDiagSev sv,
  317.  EErrType et,
  318.  const string&   message,
  319.  TBioseq  sq)
  320. {
  321.     // Append bioseq label
  322.     string msg(message + " BIOSEQ: ");
  323.     if (m_SuppressContext) {
  324.         sq.GetLabel(&msg, CBioseq::eContent, true);
  325.     } else {
  326.         sq.GetLabel(&msg, CBioseq::eBoth, false);
  327.     }
  328.     m_ErrRepository->AddValidErrItem(new CValidErrItem(sv, et, msg, sq));
  329. }
  332. void CValidError_imp::PostErr
  333. (EDiagSev sv,
  334.  EErrType et,
  335.  const string&   message,
  336.  TBioseq  sq,
  337.  TDesc    ds)
  338. {
  339.     // Append Descriptor label
  340.     string msg(message + " DESCRIPTOR: ");
  341.     ds.GetLabel(&msg, CSeqdesc::eBoth);
  342.     PostErr(sv, et, msg, sq);
  343. }
  346. void CValidError_imp::PostErr
  347. (EDiagSev      sv,
  348.  EErrType      et,
  349.  const string& message,
  350.  TSet          set)
  351. {
  352.     // Append Bioseq_set label
  353.     string msg(message + " BIOSEQ-SET: ");
  354.     if (m_SuppressContext) {
  355.         set.GetLabel(&msg, CBioseq_set::eContent);
  356.     } else {
  357.         set.GetLabel(&msg, CBioseq_set::eBoth);
  358.     }
  359.     m_ErrRepository->AddValidErrItem(new CValidErrItem(sv, et, msg, set));
  360. }
  363. void CValidError_imp::PostErr
  364. (EDiagSev        sv,
  365.  EErrType        et,
  366.  const string&   message,
  367.  TSet            set,
  368.  TDesc           ds)
  369. {
  370.     // Append Descriptor label
  371.     string msg(message + " DESCRIPTOR: ");
  372.     ds.GetLabel(&msg, CSeqdesc::eBoth);
  373.     PostErr(sv, et, msg, set);
  374. }
  377. void CValidError_imp::PostErr
  378. (EDiagSev sv,
  379.  EErrType et,
  380.  const string&   message,
  381.  TAnnot    an)
  382. {
  383.     // Append Annotation label
  384.     string msg(message + " ANNOTATION: ");
  386.     // !!! need to decide on the message
  388.     m_ErrRepository->AddValidErrItem(new CValidErrItem(sv, et, msg, an));
  389. }
  392. void CValidError_imp::PostErr
  393. (EDiagSev sv,
  394.  EErrType et,
  395.  const string& message,
  396.  TGraph graph)
  397. {
  398.     // Append Graph label
  399.     string msg(message + " GRAPH: ");
  400.     if ( graph.IsSetTitle() ) {
  401.         msg += graph.GetTitle();
  402.     } else {
  403.         msg += "Not Named";
  404.     }
  405.     msg += " ";
  406.     graph.GetLoc().GetLabel(&msg);
  408.     m_ErrRepository->AddValidErrItem(new CValidErrItem(sv, et, msg, graph));
  409. }
  412. void CValidError_imp::PostErr
  413. (EDiagSev sv,
  414.  EErrType et,
  415.  const string& message,
  416.  TBioseq sq,
  417.  TGraph graph)
  418. {
  419.     // Append Graph label
  420.     string msg(message + " GRAPH: ");
  421.     if ( graph.IsSetTitle() ) {
  422.         msg += graph.GetTitle();
  423.     } else {
  424.         msg += "Not Named";
  425.     }
  426.     msg += " ";
  427.     graph.GetLoc().GetLabel(&msg);
  429.     PostErr(sv, et, msg, sq);
  430. }
  433. void CValidError_imp::PostErr
  434. (EDiagSev sv,
  435.  EErrType et,
  436.  const string& message,
  437.  TAlign align)
  438. {
  439.     // Append Alignment label
  440.     string msg(message + " ALIGNMENT: ");
  441.     msg += align.ENUM_METHOD_NAME(EType)()->FindName(align.GetType(), true);
  442.     msg += ", dim=" + NStr::IntToString(align.GetDim());
  444.     msg+= " SEGS: ";
  445.     msg += align.GetSegs().SelectionName(align.GetSegs().Which());
  447.     m_ErrRepository->AddValidErrItem(new CValidErrItem(sv, et, msg, align));
  448. }
  451. void CValidError_imp::PostErr
  452. (EDiagSev sv,
  453.  EErrType et,
  454.  const string& message,
  455.  TEntry entry)
  456. {
  457.     m_ErrRepository->AddValidErrItem(new CValidErrItem(sv, et, message, entry));
  458. }
  461. bool CValidError_imp::Validate
  462. (const CSeq_entry& se,
  463.  const CCit_sub* cs,
  464.  CScope* scope)
  465. {
  466.     if ( m_PrgCallback ) {
  467.         m_PrgInfo.m_State = CValidator::CProgressInfo::eState_Initializing;
  468.         if ( m_PrgCallback(&m_PrgInfo) ) {
  469.             return false;
  470.         }
  471.     }
  473.     // Check that CSeq_entry has data
  474.     if (se.Which() == CSeq_entry::e_not_set) {
  475.         ERR_POST(Warning << "Seq_entry not set");
  476.         return false;
  477.     }
  479.     // Get first CBioseq object pointer for PostErr below.
  480.     CTypeConstIterator<CBioseq> seq(ConstBegin(se));
  481.     if (!seq) {
  482.         ERR_POST("No Bioseq anywhere on this Seq-entry");
  483.         return false;
  484.     }
  486.     Setup(se, scope);
  487.  
  488.     // If m_NonASCII is true, then this flag was set by the caller
  489.     // of validate to indicate that a non ascii character had been
  490.     // read from a file being used to create a CSeq_entry, that the
  491.     // error had been corrected, but that the error needs to be reported
  492.     // by Validate. Note, Validate is not doing anything other than
  493.     // reporting an error if m_NonASCII is true;
  494.     if (m_NonASCII) {
  495.         PostErr(eDiag_Critical, eErr_GENERIC_NonAsciiAsn,
  496.                   "Non-ascii chars in input ASN.1 strings", *seq);
  497.         // Only report the error once
  498.         m_NonASCII = false;
  499.     }
  501.     // Iterate thru components of record and validate each
  503.     // Features:
  505.     if ( m_PrgCallback ) {
  506.         m_PrgInfo.m_State = CValidator::CProgressInfo::eState_Feat;
  507.         m_PrgInfo.m_Current = m_NumFeat;
  508.         m_PrgInfo.m_CurrentDone = 0;
  509.         if ( m_PrgCallback(&m_PrgInfo) ) {
  510.             return false;
  511.         }
  512.     }
  513.     CValidError_feat feat_validator(*this);
  514.     for (CTypeConstIterator<CSeq_feat> fi(se); fi; ++fi) {
  515.         try {
  516.             feat_validator.ValidateSeqFeat(*fi);
  517.             if ( m_PrgCallback ) {
  518.                 m_PrgInfo.m_CurrentDone++;
  519.                 m_PrgInfo.m_TotalDone++;
  520.                 if ( m_PrgCallback(&m_PrgInfo) ) {
  521.                     return false;
  522.                 }
  523.             }
  524.         } catch ( const exception& e ) {
  525.         PostErr(eDiag_Fatal, eErr_Internal_Exception,
  526.             string("Exeption while validating feature. EXCEPTION: ") +
  527.                 e.what(), *fi);
  528.             return true;
  529.         }
  530.     }
  531.     if ( feat_validator.GetNumGenes() == 0  &&  
  532.          feat_validator.GetNumGeneXrefs() > 0 ) {
  533.         PostErr(eDiag_Warning, eErr_SEQ_FEAT_OnlyGeneXrefs,
  534.             "There are " + NStr::IntToString(feat_validator.GetNumGeneXrefs()) +
  535.             " gene xrefs and no gene features in this record.", se);
  536.     }
  538.     // Descriptors:
  540.     if ( m_PrgCallback ) {
  541.         m_PrgInfo.m_State = CValidator::CProgressInfo::eState_Desc;
  542.         m_PrgInfo.m_Current = m_NumDesc;
  543.         m_PrgInfo.m_CurrentDone = 0;
  544.         m_PrgCallback(&m_PrgInfo);
  545.     }
  546.     CValidError_desc desc_validator(*this);
  547.     for (CTypeConstIterator<CSeqdesc> di(se); di; ++di) {
  548.         try {
  549.             desc_validator.ValidateSeqDesc(*di);
  550.             if ( m_PrgCallback ) {
  551.                 m_PrgInfo.m_CurrentDone++;
  552.                 m_PrgInfo.m_TotalDone++;
  553.                 if ( m_PrgCallback(&m_PrgInfo) ) {
  554.                     return false;
  555.                 }
  556.             }
  557.         } catch ( const exception& e ) {
  558.         PostErr(eDiag_Fatal, eErr_Internal_Exception,
  559.             string("Exeption while validating descriptor. EXCEPTION: ") +
  560.                 e.what(), *di);
  561.             return true;
  562.         }
  563.     }
  564.     
  565.     // Bioseqs:
  567.     if ( m_PrgCallback ) {
  568.         m_PrgInfo.m_State = CValidator::CProgressInfo::eState_Bioseq;
  569.         m_PrgInfo.m_Current = m_NumBioseq;
  570.         m_PrgInfo.m_CurrentDone = 0;
  571.         m_PrgCallback(&m_PrgInfo);
  572.     }
  573.     CValidError_bioseq bioseq_validator(*this);
  574.     for (CTypeConstIterator<CBioseq> bi(se); bi; ++bi) {
  575.         try {
  576.             bioseq_validator.ValidateSeqIds(*bi);
  577.             bioseq_validator.ValidateInst(*bi);
  578.             bioseq_validator.ValidateBioseqContext(*bi);
  579.             bioseq_validator.ValidateHistory(*bi);
  580.             if ( m_PrgCallback ) {
  581.                 m_PrgInfo.m_CurrentDone++;
  582.                 m_PrgInfo.m_TotalDone++;
  583.                 if ( m_PrgCallback(&m_PrgInfo) ) {
  584.                     return false;
  585.                 }
  586.             }
  587.         } catch ( const exception& e ) {
  588.         PostErr(eDiag_Fatal, eErr_Internal_Exception,
  589.             string("Exeption while validating bioseq. EXCEPTION: ") +
  590.                 e.what(), *bi);
  591.             return true;
  592.         }
  593.     }
  594.     if ( bioseq_validator.GetTpaWithHistory() > 0  &&
  595.          bioseq_validator.GetTpaWithoutHistory() > 0 ) {
  596.         PostErr(eDiag_Error, eErr_SEQ_INST_TpaAssmeblyProblem,
  597.             "There are " +
  598.             NStr::IntToString(bioseq_validator.GetTpaWithHistory()) +
  599.             " TPAs with history and " + 
  600.             NStr::IntToString(bioseq_validator.GetTpaWithoutHistory()) +
  601.             " without history in this record.", se);
  602.     }
  604.     // Bioseq sets:
  606.     if ( m_PrgCallback ) {
  607.         m_PrgInfo.m_State = CValidator::CProgressInfo::eState_Bioseq_set;
  608.         m_PrgInfo.m_Current = m_NumBioseq_set;
  609.         m_PrgInfo.m_CurrentDone = 0;
  610.         m_PrgCallback(&m_PrgInfo);
  611.     }
  612.     CValidError_bioseqset bioseqset_validator(*this);
  613.     for (CTypeConstIterator<CBioseq_set> si(se); si; ++si) {
  614.         try {
  615.             bioseqset_validator.ValidateBioseqSet(*si);
  616.             if ( m_PrgCallback ) {
  617.                 m_PrgInfo.m_CurrentDone++;
  618.                 m_PrgInfo.m_TotalDone++;
  619.                 if ( m_PrgCallback(&m_PrgInfo) ) {
  620.                     return false;
  621.                 }
  622.             }
  623.         } catch ( const exception& e ) {
  624.         PostErr(eDiag_Fatal, eErr_Internal_Exception,
  625.             string("Exeption while validating bioseq set. EXCEPTION: ") +
  626.                 e.what(), *si);
  627.             return true;
  628.         }
  629.     }
  631.     // Alignments:
  633.     if ( m_PrgCallback ) {
  634.         m_PrgInfo.m_State = CValidator::CProgressInfo::eState_Align;
  635.         m_PrgInfo.m_Current = m_NumAlign;
  636.         m_PrgInfo.m_CurrentDone = 0;
  637.         m_PrgCallback(&m_PrgInfo);
  638.     }
  639.     CValidError_align align_validator(*this);
  640.     for (CTypeConstIterator<CSeq_align> ai(se); ai; ++ai) {
  641.         try {
  642.             align_validator.ValidateSeqAlign(*ai);
  643.             if ( m_PrgCallback ) {
  644.                 m_PrgInfo.m_CurrentDone++;
  645.                 m_PrgInfo.m_TotalDone++;
  646.                 if ( m_PrgCallback(&m_PrgInfo) ) {
  647.                     return false;
  648.                 }
  649.             }
  650.         } catch ( const exception& e ) {
  651.         PostErr(eDiag_Fatal, eErr_Internal_Exception,
  652.             string("Exeption while validating alignment. EXCEPTION: ") +
  653.                 e.what(), *ai);
  654.             return true;
  655.         }
  656.     }
  658.     // Graphs:
  659.     if ( m_PrgCallback ) {
  660.         m_PrgInfo.m_State = CValidator::CProgressInfo::eState_Graph;
  661.         m_PrgInfo.m_Current = m_NumGraph;
  662.         m_PrgInfo.m_CurrentDone = 0;
  663.         m_PrgCallback(&m_PrgInfo);
  664.     }
  665.     CValidError_graph graph_validator(*this);
  666.     for (CTypeConstIterator<CSeq_graph> gi(se); gi; ++gi) {
  667.         try {
  668.             graph_validator.ValidateSeqGraph(*gi);
  669.             if ( m_PrgCallback ) {
  670.                 m_PrgInfo.m_CurrentDone++;
  671.                 m_PrgInfo.m_TotalDone++;
  672.                 if ( m_PrgCallback(&m_PrgInfo) ) {
  673.                     return false;
  674.                 }
  675.             }
  676.         } catch ( const exception& e ) {
  677.         PostErr(eDiag_Fatal, eErr_Internal_Exception,
  678.             string("Exeption while validating graph. EXCEPTION: ") +
  679.                 e.what(), *gi);
  680.             return true;
  681.         }
  682.     }
  683.     SIZE_TYPE misplaced = graph_validator.GetNumMisplacedGraphs();
  684.     if ( misplaced > 0 ) {
  685.         string num = NStr::IntToString(misplaced);
  686.         PostErr(eDiag_Critical, eErr_SEQ_PKG_GraphPackagingProblem,
  687.             string("There ") + ((misplaced > 1) ? "are" : "is") + num + 
  688.             " mispackaged graph" + ((misplaced > 1) ? "s" : "") + " in this record.",
  689.             se);
  690.     }
  692.     // Annotation:
  693.     if ( m_PrgCallback ) {
  694.         m_PrgInfo.m_State = CValidator::CProgressInfo::eState_Annot;
  695.         m_PrgInfo.m_Current = m_NumAnnot;
  696.         m_PrgInfo.m_CurrentDone = 0;
  697.         m_PrgCallback(&m_PrgInfo);
  698.     }
  699.     CValidError_annot annot_validator(*this);
  700.     for (CTypeConstIterator<CSeq_annot> ni(se); ni; ++ni) {
  701.         try {
  702.             annot_validator.ValidateSeqAnnot(*ni);
  703.             if ( m_PrgCallback ) {
  704.                 m_PrgInfo.m_CurrentDone++;
  705.                 m_PrgInfo.m_TotalDone++;
  706.                 if ( m_PrgCallback(&m_PrgInfo) ) {
  707.                     return false;
  708.                 }
  709.             }
  710.         } catch ( const exception& e ) {
  711.         PostErr(eDiag_Fatal, eErr_Internal_Exception,
  712.             string("Exeption while validating annotation. EXCEPTION: ") +
  713.                 e.what(), *ni);
  714.             return true;
  715.         }
  716.     }
  718.     // Descriptor lists:
  720.     if ( m_PrgCallback ) {
  721.         m_PrgInfo.m_State = CValidator::CProgressInfo::eState_Descr;
  722.         m_PrgInfo.m_Current = m_NumDescr;
  723.         m_PrgInfo.m_CurrentDone = 0;
  724.         m_PrgCallback(&m_PrgInfo);
  725.     }
  726.     CValidError_descr descr_validator(*this);
  727.     for (CTypeConstIterator<CSeq_descr> ei(se); ei; ++ei) {
  728.         try {
  729.             descr_validator.ValidateSeqDescr(*ei);
  730.             if ( m_PrgCallback ) {
  731.                 m_PrgInfo.m_CurrentDone++;
  732.                 m_PrgInfo.m_TotalDone++;
  733.                 if ( m_PrgCallback(&m_PrgInfo) ) {
  734.                     return false;
  735.                 }
  736.             }
  737.         } catch ( const exception& e ) {
  738.         PostErr(eDiag_Fatal, eErr_Internal_Exception,
  739.             string("Exeption while validating annotation. EXCEPTION: ") +
  740.                 e.what(), *ei);
  741.             return true;
  742.         }
  743.     }
  745.     ReportMissingPubs(se, cs);
  746.     ReportMissingBiosource(se);
  747.     ReportProtWithoutFullRef();
  748.     ReportBioseqsWithNoMolinfo();
  749.     return true;
  750. }
  753. void CValidError_imp::Validate(const CSeq_submit& ss, CScope* scope)
  754. {
  755.     // Check that ss is type e_Entrys
  756.     if ( ss.GetData().Which() != CSeq_submit::C_Data::e_Entrys ) {
  757.         return;
  758.     }
  760.     // Get CCit_sub pointer
  761.     const CCit_sub* cs = &ss.GetSub().GetCit();
  763.     // Just loop thru CSeq_entrys
  764.     ITERATE( list< CRef< CSeq_entry > >, se, ss.GetData().GetEntrys() ) {
  765.         Validate(**se, cs, scope);
  766.     }
  767. }
  770. // Validate standalone Seq-annot objects
  771. void CValidError_imp::Validate(const CSeq_annot& sa, CScope* scope)
  772. {
  773.     Setup(sa, scope);
  775.     // Iterate thru components of record and validate each
  777.     CValidError_annot annot_validator(*this);
  778.     annot_validator.ValidateSeqAnnot(sa);
  780.     CValidError_feat feat_validator(*this);
  781.     for (CTypeConstIterator <CSeq_feat> fi (sa); fi; ++fi) {
  782.         feat_validator.ValidateSeqFeat(*fi);
  783.     }
  785.     CValidError_align align_validator(*this);
  786.     for (CTypeConstIterator <CSeq_align> ai (sa); ai; ++ai) {
  787.         align_validator.ValidateSeqAlign(*ai);
  788.     }
  790.     CValidError_graph graph_validator(*this);
  791.     for (CTypeConstIterator <CSeq_graph> gi (sa); gi; ++gi) {
  792.         graph_validator.ValidateSeqGraph(*gi);
  793.     }
  794. }
  797. void CValidError_imp::SetProgressCallback
  798. (CValidator::TProgressCallback callback,
  799.  void* user_data)
  800. {
  801.     m_PrgCallback = callback;
  802.     m_PrgInfo.m_UserData = user_data;
  803. }
  806. void CValidError_imp::ValidatePubdesc
  807. (const CPubdesc& pubdesc,
  808.  const CSerialObject& obj)
  809. {
  810.     int uid = 0;
  812.     ITERATE( CPub_equiv::Tdata, pub_iter, pubdesc.GetPub().Get() ) {
  813.         const CPub& pub = **pub_iter;
  815.         switch( pub.Which() ) {
  816.         case CPub::e_Gen:
  817.             ValidatePubGen(pub.GetGen(), obj);
  818.             break;
  820.         case CPub::e_Sub:
  821.             ValidateCitSub(pub.GetSub(), obj);
  822.             break;
  824.         case CPub::e_Muid:
  825.             if ( uid == 0 ) {
  826.                 uid = pub.GetMuid();
  827.             }
  828.             break;
  830.         case CPub::e_Pmid:
  831.             if ( uid == 0 ) {
  832.                 uid = pub.GetPmid();
  833.             }
  834.             break;
  835.             
  836.         case CPub::e_Article:
  837.             ValidatePubArticle(pub.GetArticle(), uid, obj);
  838.             break;
  840.         case CPub::e_Equiv:
  841.             PostErr(eDiag_Warning, eErr_GENERIC_UnnecessaryPubEquiv,
  842.                 "Publication has unexpected internal Pub-equiv", obj);
  843.             break;
  845.         default:
  846.             break;
  847.         }
  848.     }
  849.     ValidateEtAl(pubdesc, obj);
  850. }
  853. void CValidError_imp::ValidatePubGen
  854. (const CCit_gen& gen,
  855.  const CSerialObject& obj)
  856. {
  857.     if ( gen.IsSetCit()  &&  !gen.GetCit().empty() ) {
  858.         const string& cit = gen.GetCit();
  859.         if ( (NStr::CompareNocase(cit, 0, 8,  "submitted") != 0)          &&
  860.              (NStr::CompareNocase(cit, 0, 11, "unpublished") != 0)        &&
  861.              (NStr::CompareNocase(cit, 0, 18, "Online Publication") != 0) &&
  862.              (NStr::CompareNocase(cit, 0, 26, "Published Only in DataBase") != 0) ) {
  863.             PostErr(eDiag_Error, eErr_GENERIC_MissingPubInfo,
  864.                 "Unpublished citation text invalid", obj);
  865.         }
  866.     }
  867. }
  870. void CValidError_imp::ValidatePubArticle
  871. (const CCit_art& art,
  872.  int uid,
  873.  const CSerialObject& obj)
  874. {
  875.     if ( !art.IsSetTitle()  ||  !HasTitle(art.GetTitle()) ) { 
  876.         PostErr(eDiag_Error, eErr_GENERIC_MissingPubInfo,
  877.             "Publication has no title", obj);
  878.     }
  879.     
  880.     if ( art.IsSetAuthors() ) {
  881.         const CAuth_list::C_Names& names = art.GetAuthors().GetNames();
  883.         bool has_name = false;
  884.         if ( names.IsStd() ) {
  885.             has_name = HasName(names.GetStd());
  886.         } 
  887.         if ( names.IsMl() ) {
  888.             has_name = !IsBlankStringList(names.GetMl());
  889.         }
  890.         if ( names.IsStr() ) {
  891.             has_name = !IsBlankStringList(names.GetStr());
  892.         }
  894.         if ( !has_name ) {
  895.             PostErr(eDiag_Error, eErr_GENERIC_MissingPubInfo,
  896.                 "Publication has no author names", obj);
  897.         }
  898.     }
  899.     
  900.     
  901.     if ( art.GetFrom().IsJournal() ) {
  902.         const CCit_jour& jour = art.GetFrom().GetJournal();
  903.         
  904.         bool has_iso_jta = HasIsoJTA(jour.GetTitle());
  905.         bool in_press = false;
  907.         if ( !HasTitle(jour.GetTitle()) ) {
  908.             PostErr(eDiag_Error, eErr_GENERIC_MissingPubInfo,
  909.             "Journal title missing", obj);
  910.         }
  912.         if ( jour.CanGetImp() ) {
  913.             const CImprint& imp = jour.GetImp();
  915.             if ( imp.CanGetPrepub() ) {
  916.                 in_press =  imp.GetPrepub() == CImprint::ePrepub_in_press;
  917.             }
  919.             if ( !imp.IsSetPrepub()        &&  
  920.                  (!imp.CanGetPubstatus()   ||  
  921.                   imp.GetPubstatus() != ePubStatus_aheadofprint) ) {
  922.                 bool no_vol = !imp.IsSetVolume()  || 
  923.                               IsBlankString(imp.GetVolume());
  924.                 bool no_pages = !imp.IsSetPages()  ||
  925.                                 IsBlankString(imp.GetPages());
  927.                 EDiagSev sev = IsRefSeq() ? eDiag_Warning : eDiag_Error;
  929.                 if ( no_vol  &&  no_pages ) {
  930.                     PostErr(sev, eErr_GENERIC_MissingPubInfo, 
  931.                         "Journal volume and pages missing", obj);
  932.                 } else if ( no_vol ) {
  933.                     PostErr(sev, eErr_GENERIC_MissingPubInfo,
  934.                         "Journal volume missing", obj);
  935.                 } else if ( no_pages ) {
  936.                     PostErr(sev, eErr_GENERIC_MissingPubInfo,
  937.                         "Journal pages missing", obj);
  938.                 }
  939.                 
  940.                 if ( !no_pages ) {
  941.                     sev = eDiag_Warning;
  942.                     string pages = imp.GetPages();
  943.                     size_t pos = pages.find('-');
  944.                     if ( pos != string::npos ) {
  945.                         try {
  946.                             int start = 
  947.                                 NStr::StringToInt(pages.substr(0, pos), 
  948.                                                   10, NStr::eCheck_Skip);
  949.                             
  950.                             try {
  951.                                 int stop = NStr::StringToInt(
  952.                                         pages.substr(pos + 1, pages.length()),
  953.                                         10, NStr::eCheck_Skip);
  954.                                 
  955.                                 if ( start == 0  ||  stop == 0 ) {
  956.                                     PostErr(sev, eErr_GENERIC_BadPageNumbering,
  957.                                         "Page numbering has zero value", obj);
  958.                                 } else if ( start < 0  ||  stop < 0 ) {
  959.                                     PostErr(sev, eErr_GENERIC_BadPageNumbering,
  960.                                         "Page numbering has negative value", obj);
  961.                                 } else if ( start > stop ) {
  962.                                     PostErr(sev, eErr_GENERIC_BadPageNumbering,
  963.                                         "Page numbering out of order", obj);
  964.                                 } else if ( stop - start > 50 ) {
  965.                                     PostErr(sev, eErr_GENERIC_BadPageNumbering,
  966.                                         "Page numbering greater than 50", obj);
  967.                                 }
  968.                             } catch ( CStringException& ) {
  969.                                 PostErr(sev, eErr_GENERIC_BadPageNumbering,
  970.                                     "Page numbering stop looks strange", obj);
  971.                             }
  972.                         } catch ( CStringException& ) {
  973.                             if ( !isalpha(pages[0]) ) {
  974.                                 PostErr(sev, eErr_GENERIC_BadPageNumbering,
  975.                                     "Page numbering start looks strange", obj);
  976.                             }
  977.                         }
  978.                     }
  979.                 }
  980.             }
  981.         }
  982.         if ( !has_iso_jta  &&  (uid > 0  ||  in_press  ||  IsRequireISOJTA()) ) {
  983.             PostErr(eDiag_Warning, eErr_GENERIC_MissingPubInfo,
  984.                 "ISO journal title abbreviation missing", obj);
  985.         }
  986.     }
  987. }
  990. bool CValidError_imp::HasTitle(const CTitle& title)
  991. {
  992.     ITERATE (CTitle::Tdata, item, title.Get() ) {
  993.         const string *str = 0;
  994.         switch ( (*item)->Which() ) {
  995.         case CTitle::C_E::e_Name:
  996.             str = &(*item)->GetName();
  997.             break;
  999.         case CTitle::C_E::e_Tsub:
  1000.             str = &(*item)->GetTsub();
  1001.             break;
  1003.         case CTitle::C_E::e_Trans:
  1004.             str = &(*item)->GetTrans();
  1005.             break;
  1007.         case CTitle::C_E::e_Jta:
  1008.             str = &(*item)->GetJta();
  1009.             break;
  1011.         case CTitle::C_E::e_Iso_jta:
  1012.             str = &(*item)->GetIso_jta();
  1013.             break;
  1015.         case CTitle::C_E::e_Ml_jta:
  1016.             str = &(*item)->GetMl_jta();
  1017.             break;
  1019.         case CTitle::C_E::e_Coden:
  1020.             str = &(*item)->GetCoden();
  1021.             break;
  1023.         case CTitle::C_E::e_Issn:
  1024.             str = &(*item)->GetIssn();
  1025.             break;
  1027.         case CTitle::C_E::e_Abr:
  1028.             str = &(*item)->GetAbr();
  1029.             break;
  1031.         case CTitle::C_E::e_Isbn:
  1032.             str = &(*item)->GetIsbn();
  1033.             break;
  1035.         default:
  1036.             break;
  1037.         };
  1038.         if ( IsBlankString(*str) ) {
  1039.             return false;
  1040.         }
  1041.     }
  1042.     return true;
  1043. }
  1046. bool CValidError_imp::HasIsoJTA(const CTitle& title)
  1047. {
  1048.     ITERATE (CTitle::Tdata, item, title.Get() ) {
  1049.         if ( (*item)->IsIso_jta() ) {
  1050.             return true;
  1051.         }
  1052.     }
  1053.     return false;
  1054. }
  1057. bool CValidError_imp::HasName(const list< CRef< CAuthor > >& authors)
  1058. {
  1059.     ITERATE ( list< CRef< CAuthor > >, auth, authors ) {
  1060.         const CPerson_id& pid = (*auth)->GetName();
  1061.         if ( pid.IsName() ) {
  1062.             if ( !IsBlankString(pid.GetName().GetLast()) ) {
  1063.                 return true;
  1064.             }
  1065.         }
  1066.     }
  1067.     return false;
  1068. }
  1071. void CValidError_imp::ValidateEtAl
  1072. (const CPubdesc& pubdesc,
  1073.  const CSerialObject& obj)
  1074. {
  1075.     ITERATE( CPub_equiv::Tdata, pub, pubdesc.GetPub().Get() ) {
  1076.         const CAuth_list* authors = 0;
  1077.         switch ( (*pub)->Which() ) {
  1078.         case CPub::e_Gen:
  1079.             if ( (*pub)->GetGen().IsSetAuthors() ) {
  1080.                 authors = &((*pub)->GetGen().GetAuthors());
  1081.             }
  1082.             break;
  1083.         case CPub::e_Sub:
  1084.             authors = &((*pub)->GetSub().GetAuthors());
  1085.             break;
  1086.         case CPub::e_Article:
  1087.             if ( (*pub)->GetArticle().IsSetAuthors() ) {
  1088.                 authors = &((*pub)->GetArticle().GetAuthors());
  1089.             }
  1090.             break;
  1091.         case CPub::e_Book:
  1092.             authors = &((*pub)->GetBook().GetAuthors());
  1093.             break;
  1094.         case CPub::e_Proc:
  1095.             authors = &((*pub)->GetProc().GetBook().GetAuthors());
  1096.             break;
  1097.         case CPub::e_Man:
  1098.             authors = &((*pub)->GetMan().GetCit().GetAuthors());
  1099.             break;
  1100.         default:
  1101.             break;
  1102.         }
  1104.         if ( !authors ) {
  1105.             continue;
  1106.         }
  1108.         const CAuth_list::C_Names& names = authors->GetNames();
  1109.         if ( !names.IsStd() ) {
  1110.             continue;
  1111.         }
  1113.         ITERATE ( CAuth_list::C_Names::TStd, name, names.GetStd() ) {
  1114.             if ( (*name)->GetName().IsName() ) {
  1115.                 const CName_std& nstd = (*name)->GetName().GetName();
  1116.                 if ( (NStr::CompareNocase(nstd.GetLast(), "et al.") == 0)  ||
  1117.                      (nstd.GetLast() == "et."  &&  nstd.GetInitials() == "al"  &&
  1118.                       nstd.GetFirst().empty()) ) {
  1119.                     CAuth_list::C_Names::TStd::const_iterator temp = name;
  1120.                     if ( ++temp == names.GetStd().end() ) {
  1121.                         PostErr(eDiag_Warning, eErr_GENERIC_AuthorListHasEtAl,
  1122.                             "Author list ends in et al.", obj);
  1123.                     } else {
  1124.                         PostErr(eDiag_Warning, eErr_GENERIC_AuthorListHasEtAl,
  1125.                             "Author list contains et al.", obj);
  1126.                     }
  1127.                 }
  1128.             }
  1129.         }
  1130.     }
  1131. }
  1134. void CValidError_imp::ValidateDbxref
  1135. (const CDbtag& xref,
  1136.  const CSerialObject& obj,
  1137.  bool biosource)
  1138. {
  1139.     if ( !xref.CanGetDb() ) {
  1140.         return;
  1141.     }
  1142.     const string& db = xref.GetDb();
  1143.     CDbtag::EDbtagType db_type = xref.GetType();
  1144.     bool is_pid = db_type == CDbtag::eDbtagType_PID   ||
  1145.                   db_type == CDbtag::eDbtagType_PIDd  ||
  1146.                   db_type == CDbtag::eDbtagType_PIDe  ||
  1147.                   db_type == CDbtag::eDbtagType_PIDg;
  1149.     if ( biosource ) {
  1150.         if ( !xref.IsApproved() || is_pid ) {
  1151.             PostErr(eDiag_Warning, eErr_SEQ_FEAT_IllegalDbXref,
  1152.                 "Illegal db_xref type " + db, obj);
  1153.         }
  1154.     } else {  // Seq_feat
  1155.         const CSeq_feat* feat = dynamic_cast<const CSeq_feat*>(&obj);
  1156.         if ( feat != 0 ) {
  1157.             bool is_cdregion = 
  1158.                 feat->CanGetData()  &&  feat->GetData().IsCdregion();
  1159.             bool refseq = IsRefSeq();
  1160.             if ( !xref.IsApproved(refseq)  ||  (!is_cdregion  &&  is_pid) ) {
  1161.                 const char* legal = xref.IsApprovedNoCase(refseq);
  1162.                 if ( legal != 0 ) {
  1163.                     PostErr(eDiag_Warning, eErr_SEQ_FEAT_IllegalDbXref,
  1164.                         "Illegal db_xref type " + db +
  1165.                         ", legal capitalization is " + legal, obj);
  1166.                 } else {
  1167.                     PostErr(eDiag_Warning, eErr_SEQ_FEAT_IllegalDbXref,
  1168.                         "Illegal db_xref type " + db, obj);
  1169.                 }
  1170.             }
  1171.         }
  1172.     }
  1173. }
  1176. void CValidError_imp::ValidateDbxref
  1177. (TDbtags& xref_list,
  1178.  const CSerialObject& obj,
  1179.  bool biosource)
  1180. {
  1181.     ITERATE( TDbtags, xref, xref_list) {
  1182.         ValidateDbxref(**xref, obj, biosource);
  1183.     }
  1184. }
  1187. void CValidError_imp::ValidateBioSource
  1188. (const CBioSource&    bsrc,
  1189.  const CSerialObject& obj)
  1190. {
  1191.     if ( !bsrc.CanGetOrg() ) {
  1192.         PostErr(eDiag_Error, eErr_SEQ_DESCR_NoOrgFound,
  1193.             "No organism has been applied to this Bioseq.", obj);
  1194.         return;
  1195.     }
  1197. const COrg_ref& orgref = bsrc.GetOrg();
  1198.   
  1199. // Organism must have a name.
  1200. if ( (!orgref.IsSetTaxname()  ||  orgref.GetTaxname().empty())  &&
  1201.          (!orgref.IsSetCommon()   ||  orgref.GetCommon().empty()) ) {
  1202. PostErr(eDiag_Error, eErr_SEQ_DESCR_NoOrgFound,
  1203.             "No organism name has been applied to this Bioseq.", obj);
  1204. }
  1206. // validate legal locations.
  1207. if ( bsrc.GetGenome() == CBioSource::eGenome_transposon  ||
  1208.  bsrc.GetGenome() == CBioSource::eGenome_insertion_seq ) {
  1209. PostErr(eDiag_Warning, eErr_SEQ_DESCR_ObsoleteSourceLocation,
  1210.             "Transposon and insertion sequence are no longer legal locations.",
  1211.             obj);
  1212. }
  1214. int chrom_count = 0;
  1215. bool chrom_conflict = false;
  1216.     const CSubSource *chromosome = 0;
  1217. string countryname;
  1218.     bool germline = false;
  1219.     bool rearranged = false;
  1221.     if ( bsrc.IsSetSubtype() ) {
  1222.         ITERATE( CBioSource::TSubtype, ssit, bsrc.GetSubtype() ) {
  1223.             switch ( (**ssit).GetSubtype() ) {
  1224.                 
  1225.             case CSubSource::eSubtype_country:
  1226.                 countryname = (**ssit).GetName();
  1227.                 if ( !CCountries::IsValid(countryname) ) {
  1228.                     if ( countryname.empty() ) {
  1229.                         countryname = "?";
  1230.                     }
  1231.                     PostErr(eDiag_Warning, eErr_SEQ_DESCR_BadCountryCode,
  1232.                         "Bad country name " + countryname, obj);
  1233.                 }
  1234.                 break;
  1235.                 
  1236.             case CSubSource::eSubtype_chromosome:
  1237.                 ++chrom_count;
  1238.                 if ( chromosome != 0 ) {
  1239.                     if ( NStr::CompareNocase((**ssit).GetName(), chromosome->GetName()) != 0) {
  1240.                         chrom_conflict = true;
  1241.                     }          
  1242.                 } else {
  1243.                     chromosome = ssit->GetPointer();
  1244.                 }
  1245.                 break;
  1246.                 
  1247.             case CSubSource::eSubtype_transposon_name:
  1248.             case CSubSource::eSubtype_insertion_seq_name:
  1249.                 PostErr(eDiag_Warning, eErr_SEQ_DESCR_ObsoleteSourceQual,
  1250.                     "Transposon name and insertion sequence name are no "
  1251.                     "longer legal qualifiers.", obj);
  1252.                 break;
  1253.                 
  1254.             case 0:
  1255.                 PostErr(eDiag_Warning, eErr_SEQ_DESCR_BadSubSource,
  1256.                     "Unknown subsource subtype 0.", obj);
  1257.                 break;
  1258.                 
  1259.             case CSubSource::eSubtype_other:
  1260.                 ValidateSourceQualTags((**ssit).GetName(), obj);
  1261.                 break;
  1263.             case CSubSource::eSubtype_germline:
  1264.                 germline = true;
  1265.                 break;
  1267.             case CSubSource::eSubtype_rearranged:
  1268.                 rearranged = true;
  1269.                 break;
  1271.             default:
  1272.                 break;
  1273.             }
  1274.         }
  1275.     }
  1276.     if ( germline  &&  rearranged ) {
  1277.         PostErr(eDiag_Warning, eErr_SEQ_DESCR_BadSubSource,
  1278.             "Germline and rearranged should not both be present", obj);
  1279.     }
  1280. if ( chrom_count > 1 ) {
  1281. string msg = 
  1282.             chrom_conflict ? "Multiple conflicting chromosome qualifiers" :
  1283.                              "Multiple identical chromosome qualifiers";
  1284. PostErr(eDiag_Warning, eErr_SEQ_DESCR_MultipleChromosomes, msg, obj);
  1285. }
  1287.     if ( !orgref.IsSetOrgname()  ||
  1288.          !orgref.GetOrgname().IsSetLineage()  ||
  1289.          orgref.GetOrgname().GetLineage().empty() ) {
  1290. PostErr(eDiag_Error, eErr_SEQ_DESCR_MissingLineage, 
  1291.      "No lineage for this BioSource.", obj);
  1292. } else {
  1293.         const string& lineage = orgref.GetOrgname().GetLineage();
  1294. if ( bsrc.GetGenome() == CBioSource::eGenome_kinetoplast ) {
  1295. if ( lineage.find("Kinetoplastida") == string::npos ) {
  1296. PostErr(eDiag_Warning, eErr_SEQ_DESCR_BadOrganelle, 
  1297.  "Only Kinetoplastida have kinetoplasts", obj);
  1298. }
  1299. } 
  1300. if ( bsrc.GetGenome() == CBioSource::eGenome_nucleomorph ) {
  1301. if ( lineage.find("Chlorarchniophyta") == string::npos  &&
  1302. lineage.find("Cryptophyta") == string::npos ) {
  1303. PostErr(eDiag_Warning, eErr_SEQ_DESCR_BadOrganelle, 
  1304.                     "Only Chlorarchniophyta and Cryptophyta have nucleomorphs", obj);
  1305. }
  1306. }
  1307. }
  1308.     if ( !orgref.IsSetOrgname() ) {
  1309.         return;
  1310.     }
  1311.     const COrgName& orgname = orgref.GetOrgname();
  1313.     if ( orgname.IsSetMod() ) {
  1314.         ITERATE ( COrgName::TMod, omit, orgname.GetMod() ) {
  1315.             int subtype = (**omit).GetSubtype();
  1316.             
  1317.             if ( (subtype == 0) || (subtype == 1) ) {
  1318.                 PostErr(eDiag_Warning, eErr_SEQ_DESCR_BadOrgMod, 
  1319.                     "Unknown orgmod subtype " + subtype, obj);
  1320.             }
  1321.             if ( subtype == COrgMod::eSubtype_variety ) {
  1322.                 if ( NStr::CompareNocase( orgname.GetDiv(), "PLN" ) != 0 ) {
  1323.                     PostErr(eDiag_Warning, eErr_SEQ_DESCR_BadOrgMod, 
  1324.                         "Orgmod variety should only be in plants or fungi", 
  1325.                         obj);
  1326.                 }
  1327.             }
  1328.             if ( subtype == COrgMod::eSubtype_other ) {
  1329.                 ValidateSourceQualTags( (**omit).GetSubname(), obj);
  1330.             }
  1331.         }
  1332.     }
  1334.     if ( orgref.IsSetDb() ) {
  1335.         ValidateDbxref(orgref.GetDb(), obj, true);
  1336.     }
  1338.     if ( IsRequireTaxonID() ) {
  1339.         bool found = false;
  1340.         if ( orgref.IsSetDb() ) {
  1341.             ITERATE( COrg_ref::TDb, dbt, orgref.GetDb() ) {
  1342.                 if ( NStr::CompareNocase((*dbt)->GetDb(), "taxon") == 0 ) {
  1343.                     found = true;
  1344.                     break;
  1345.                 }
  1346.             }
  1347.         }
  1348.         if ( !found ) {
  1349.             PostErr(eDiag_Warning, eErr_SEQ_DESCR_NoTaxonID,
  1350.                 "BioSource is missing taxon ID", obj);
  1351.         }
  1352.     }
  1353. }
  1356. void CValidError_imp::ValidateCitSub
  1357. (const CCit_sub& cs,
  1358.  const CSerialObject& obj)
  1359. {
  1360.     bool has_name  = false,
  1361.          has_affil = false;
  1363.     if ( cs.CanGetAuthors() ) {
  1364.         const CAuth_list& authors = cs.GetAuthors();
  1366.         if ( authors.CanGetNames() ) {
  1367.             const CAuth_list::TNames& names = cs.GetAuthors().GetNames();
  1368.             switch ( names.Which() ) {
  1369.             case CAuth_list::TNames::e_Std:
  1370.                 has_name = HasName(names.GetStd());
  1371.                 break;
  1372.                 
  1373.             case CAuth_list::TNames::e_Ml:
  1374.                 ITERATE( CAuth_list::TNames::TMl, it, names.GetMl() ) {
  1375.                     if ( !IsBlankString(*it) ) {
  1376.                         has_name = true;
  1377.                         break;
  1378.                     }
  1379.                 }
  1380.                 break;
  1381.                 
  1382.             case CAuth_list::TNames::e_Str:
  1383.                 ITERATE( CAuth_list::TNames::TStr, it, names.GetStr() ) {
  1384.                     if ( !IsBlankString(*it) ) {
  1385.                         has_name = true;
  1386.                         break;
  1387.                     }
  1388.                 }
  1389.                 break;
  1390.                 
  1391.             default:
  1392.                 break;
  1393.             }
  1394.         }
  1396.         if ( authors.CanGetAffil() ) {
  1397.             const CAffil& affil = authors.GetAffil();
  1399.             switch ( affil.Which() ) {
  1400.             case CAffil::e_Str:
  1401.                 {{
  1402.                     if ( !IsBlankString(affil.GetStr()) ) {
  1403.                         has_affil = true;
  1404.                     }
  1405.                 }}
  1406.                 break;
  1408.             case CAffil::e_Std:
  1409. #define HAS_VALUE(o, x) (o.CanGet##x()  &&  !IsBlankString(o.Get##x()))
  1410.                 {{
  1411.                     const CAffil::TStd& std = affil.GetStd();
  1412.                     if ( HAS_VALUE(std, Affil)    ||
  1413.                          HAS_VALUE(std, Div)      ||
  1414.                          HAS_VALUE(std, City)     ||
  1415.                          HAS_VALUE(std, Sub)      ||
  1416.                          HAS_VALUE(std, Country)  ||
  1417.                          HAS_VALUE(std, Street)   ||
  1418.                          HAS_VALUE(std, Email)    ||
  1419.                          HAS_VALUE(std, Fax)      ||
  1420.                          HAS_VALUE(std, Phone)    ||
  1421.                          HAS_VALUE(std, Postal_code) ) {
  1422.                         has_affil = true;
  1423.                     }
  1424.                 }}
  1425. #undef HAS_VALUE
  1426.                 break;
  1427.             }
  1428.         }
  1429.     }
  1431.     if ( !has_name ) {
  1432.         PostErr(eDiag_Error, eErr_GENERIC_MissingPubInfo,
  1433.             "Submission citation has no author names", obj);
  1434.     }
  1435.     if ( !has_affil ) {
  1436.         PostErr(eDiag_Error, eErr_GENERIC_MissingPubInfo,
  1437.             "Submission citation has no affiliation", obj);
  1438.     }
  1439. }
  1442. void CValidError_imp::ValidateSeqLoc
  1443. (const CSeq_loc& loc,
  1444.  const CBioseq_Handle&  seq,
  1445.  const string&   prefix,
  1446.  const CSerialObject& obj)
  1447. {
  1448.     bool circular = false;
  1449.     circular = seq  &&  seq.GetInst_Topology() == CSeq_inst::eTopology_circular;
  1450.     
  1451.     bool ordered = true, adjacent = false, chk = true,
  1452.         unmarked_strand = false, mixed_strand = false;
  1453.     const CSeq_id* id_cur = 0, *id_prv = 0;
  1454.     const CSeq_interval *int_cur = 0, *int_prv = 0;
  1455.     ENa_strand strand_cur = eNa_strand_unknown,
  1456.         strand_prv = eNa_strand_unknown;
  1458.     CTypeConstIterator<CSeq_loc> lit = ConstBegin(loc);
  1459.     for (; lit; ++lit) {
  1460.         try {
  1461.             switch (lit->Which()) {
  1462.             case CSeq_loc::e_Int:
  1463.                 int_cur = &lit->GetInt();
  1464.                 strand_cur = int_cur->IsSetStrand() ?
  1465.                     int_cur->GetStrand() : eNa_strand_unknown;
  1466.                 id_cur = &int_cur->GetId();
  1467.                 chk = IsValid(*int_cur, m_Scope);
  1468.                 if (chk  &&  int_prv  && ordered  &&
  1469.                     !circular  && id_prv) {
  1470.                     if (IsSameBioseq(*id_prv, *id_cur, m_Scope)) {
  1471.                         if (strand_cur == eNa_strand_minus) {
  1472.                             if (int_prv->GetTo() < int_cur->GetTo()) {
  1473.                                 ordered = false;
  1474.                             }
  1475.                             if (int_cur->GetTo() + 1 == int_prv->GetFrom()) {
  1476.                                 adjacent = true;
  1477.                             }
  1478.                         } else {
  1479.                             if (int_prv->GetTo() > int_cur->GetTo()) {
  1480.                                 ordered = false;
  1481.                             }
  1482.                             if (int_prv->GetTo() + 1 == int_cur->GetFrom()) {
  1483.                                 adjacent = true;
  1484.                             }
  1485.                         }
  1486.                     }
  1487.                 }
  1488.                 if (int_prv) {
  1489.                     if (IsSameBioseq(int_prv->GetId(), int_cur->GetId(), m_Scope)){
  1490.                         if (strand_prv == strand_cur  &&
  1491.                             int_prv->GetFrom() == int_cur->GetFrom()  &&
  1492.                             int_prv->GetTo() == int_cur->GetTo()) {
  1493.                             PostErr(eDiag_Error,
  1494.                                 eErr_SEQ_FEAT_DuplicateInterval,
  1495.                                 "Duplicate exons in location", obj);
  1496.                         }
  1497.                     }
  1498.                 }
  1499.                 int_prv = int_cur;
  1500.                 break;
  1501.             case CSeq_loc::e_Pnt:
  1502.                 strand_cur = lit->GetPnt().IsSetStrand() ?
  1503.                     lit->GetPnt().GetStrand() : eNa_strand_unknown;
  1504.                 id_cur = &lit->GetPnt().GetId();
  1505.                 chk = IsValid(lit->GetPnt(), m_Scope);
  1506.                 int_prv = 0;
  1507.                 break;
  1508.             case CSeq_loc::e_Packed_pnt:
  1509.                 strand_cur = lit->GetPacked_pnt().IsSetStrand() ?
  1510.                     lit->GetPacked_pnt().GetStrand() : eNa_strand_unknown;
  1511.                 id_cur = &lit->GetPacked_pnt().GetId();
  1512.                 chk = IsValid(lit->GetPacked_pnt(), m_Scope);
  1513.                 int_prv = 0;
  1514.                 break;
  1515.             case CSeq_loc::e_Null:
  1516.                 break;
  1517.             default:
  1518.                 strand_cur = eNa_strand_other;
  1519.                 id_cur = 0;
  1520.                 int_prv = 0;
  1521.                 break;
  1522.             }
  1523.             if (!chk) {
  1524.                 string lbl;
  1525.                 lit->GetLabel(&lbl);
  1526.                 PostErr(eDiag_Critical, eErr_SEQ_FEAT_Range,
  1527.                     prefix + ": Seq-loc " + lbl + " out of range", obj);
  1528.             }
  1529.             
  1530.             if (lit->Which() != CSeq_loc::e_Null) {
  1531.                 if (strand_prv != eNa_strand_other  &&
  1532.                     strand_cur != eNa_strand_other) {
  1533.                     if (id_cur  &&  id_prv  &&
  1534.                         IsSameBioseq(*id_cur, *id_prv, m_Scope)) {
  1535.                         if (strand_prv != strand_cur) {
  1536.                             if ((strand_prv == eNa_strand_plus  &&
  1537.                                 strand_cur == eNa_strand_unknown)  ||
  1538.                                 (strand_prv == eNa_strand_unknown  &&
  1539.                                 strand_cur == eNa_strand_plus)) {
  1540.                                 unmarked_strand = true;
  1541.                             } else {
  1542.                                 mixed_strand = true;
  1543.                             }
  1544.                         }
  1545.                     }
  1546.                 }                
  1547.                 strand_prv = strand_cur;
  1548.                 id_prv = id_cur;
  1549.             }
  1550.         } catch( const exception& e ) {
  1551.             string label;
  1552.             lit->GetLabel(&label);
  1553.             PostErr(eDiag_Error, eErr_Internal_Exception,  
  1554.                 "Exception caught while validating location " +
  1555.                 label + ". Exception: " + e.what(), obj);
  1556.                 
  1557.             strand_cur = eNa_strand_other;
  1558.             id_cur = 0;
  1559.             int_prv = 0;
  1560.         }
  1561.         
  1562.     }
  1564.     // Warn if different parts of a seq-loc refer to the same bioseq using 
  1565.     // differnt id types (i.e. gi and accession)
  1566.     ValidateSeqLocIds(loc, obj);
  1567.     
  1568.     bool exception = false;
  1569.     const CSeq_feat* sfp = dynamic_cast<const CSeq_feat*>(&obj);
  1570.     if (sfp != 0) {
  1571.         
  1572.         // Publication intervals ordering does not matter
  1573.         
  1574.         if ( sfp->GetData().GetSubtype() == CSeqFeatData::eSubtype_pub ) {
  1575.             ordered = true;
  1576.             adjacent = false;
  1577.         }
  1578.         
  1579.         // ignore ordering of heterogen bonds
  1580.         
  1581.         if ( sfp->GetData().GetSubtype() == CSeqFeatData::eSubtype_het ) {
  1582.             ordered = true;
  1583.             adjacent = false;
  1584.         }
  1585.         
  1586.         // misc_recomb intervals SHOULD be in reverse order
  1587.         if ( sfp->GetData().GetSubtype() == CSeqFeatData::eSubtype_misc_recomb ) {
  1588.             ordered = true;
  1589.         }
  1590.         
  1591.         // primer_bind intervals MAY be in on opposite strands
  1592.         
  1593.         if ( sfp->GetData().GetSubtype() == CSeqFeatData::eSubtype_primer_bind ) {
  1594.             mixed_strand = false;
  1595.             unmarked_strand = false;
  1596.             ordered = true;
  1597.         }
  1598.         
  1599.         exception = sfp->IsSetExcept() ?  sfp->GetExcept() : false;
  1600.     }
  1602.     string loc_lbl;
  1603.     if (adjacent) {
  1604.         loc.GetLabel(&loc_lbl);
  1605.         EDiagSev sev = exception ? eDiag_Warning : eDiag_Error;
  1606.         PostErr(sev, eErr_SEQ_FEAT_AbuttingIntervals,
  1607.             prefix + ": Adjacent intervals in SeqLoc [" +
  1608.             loc_lbl + "]", obj);
  1609.     }
  1610.     if (exception  &&  sfp->CanGetExcept_text()) {
  1611.         // trans splicing exception turns off both mixed_strand and
  1612.         // out_of_order messages
  1613.         if (NStr::FindNoCase(sfp->GetExcept_text(), "trans-splicing") != NPOS) {
  1614.             return;
  1615.         }
  1616.     }
  1617.     if (mixed_strand  ||  unmarked_strand  ||  !ordered) {
  1618.         if (loc_lbl.empty()) {
  1619.             loc.GetLabel(&loc_lbl);
  1620.         }
  1621.         if (mixed_strand) {
  1622.             PostErr(eDiag_Error, eErr_SEQ_FEAT_MixedStrand,
  1623.                 prefix + ": Mixed strands in SeqLoc [" +
  1624.                 loc_lbl + "]", obj);
  1625.         } else if (unmarked_strand) {
  1626.             PostErr(eDiag_Warning, eErr_SEQ_FEAT_MixedStrand,
  1627.                 prefix + ": Mixed plus and unknown strands in SeqLoc "
  1628.                 " [" + loc_lbl + "]", obj);
  1629.         }
  1630.         if (!ordered) {
  1631.             PostErr(eDiag_Error, eErr_SEQ_FEAT_SeqLocOrder,
  1632.                 prefix + ": Intervals out of order in SeqLoc [" +
  1633.                 loc_lbl + "]", obj);
  1634.         }
  1635.         return;
  1636.     }
  1638.     if ( seq  &&
  1639.          seq.IsSetInst_Repr()  &&
  1640.          seq.GetInst_Repr() != CSeq_inst::eRepr_seg ) {
  1641.         return;
  1642.     }
  1644.     // Check for intervals out of order on segmented Bioseq
  1645.     if ( seq  &&  BadSeqLocSortOrder(*seq.GetCompleteBioseq(), loc, m_Scope) ) {
  1646.         if (loc_lbl.empty()) {
  1647.             loc.GetLabel(&loc_lbl);
  1648.         }
  1649.         PostErr(eDiag_Error, eErr_SEQ_FEAT_SeqLocOrder,
  1650.             prefix + "Intervals out of order in SeqLoc [" +
  1651.             loc_lbl + "]", obj);
  1652.     }
  1654.     // Check for mixed strand on segmented Bioseq
  1655.     if ( IsMixedStrands(loc) ) {
  1656.         if (loc_lbl.empty()) {
  1657.             loc.GetLabel(&loc_lbl);
  1658.         }
  1659.         PostErr(eDiag_Error, eErr_SEQ_FEAT_MixedStrand,
  1660.             prefix + ": Mixed strands in SeqLoc [" +
  1661.             loc_lbl + "]", obj);
  1662.     }
  1663. }
  1666. void CValidError_imp::AddBioseqWithNoPub(const CBioseq& seq)
  1667. {
  1668.     m_BioseqWithNoPubs.push_back(CConstRef<CBioseq>(&seq));
  1669. }
  1672. void CValidError_imp::AddBioseqWithNoBiosource(const CBioseq& seq)
  1673. {
  1674.     m_BioseqWithNoSource.push_back(CConstRef<CBioseq>(&seq));
  1675. }
  1678. void CValidError_imp::AddBioseqWithNoMolinfo(const CBioseq& seq)
  1679. {
  1680.     m_BioseqWithNoMolinfo.push_back(CConstRef<CBioseq>(&seq));
  1681. }
  1684. void CValidError_imp::AddProtWithoutFullRef(const CBioseq_Handle& seq)
  1685. {
  1686.     const CSeq_feat* cds = GetCDSForProduct(seq);
  1687.     if ( cds != 0 ) {
  1688.         m_ProtWithNoFullRef.push_back(CConstRef<CSeq_feat>(cds));
  1689.     }
  1690. }
  1693. void CValidError_imp::ReportMissingPubs(const CSeq_entry& se, const CCit_sub* cs)
  1694. {
  1695.     if ( m_NoPubs ) {
  1696.         if ( !m_IsGPS  &&  !m_IsRefSeq  &&  !cs) {
  1697.             PostErr(eDiag_Error, eErr_SEQ_DESCR_NoPubFound, 
  1698.                 "No publications anywhere on this entire record", se);
  1699.         } 
  1700.         return;
  1701.     }
  1703.     size_t num_no_pubs = m_BioseqWithNoPubs.size();
  1705.     EDiagSev sev = IsCuratedRefSeq() ? eDiag_Error : eDiag_Warning;
  1707.     if ( num_no_pubs == 1 ) {
  1708.         PostErr(sev, eErr_SEQ_DESCR_NoPubFound, 
  1709.             "No publications refer to this Bioseq.",
  1710.             *(m_BioseqWithNoPubs[0]));
  1711.     } else if ( num_no_pubs > 10 ) {
  1712.         PostErr(sev, eErr_SEQ_DESCR_NoPubFound, 
  1713.             NStr::IntToString(num_no_pubs) + 
  1714.             " Bioseqs without publication in this record  (first reported)",
  1715.             *(m_BioseqWithNoPubs[0]));
  1716.     } else {
  1717.         string msg;
  1718.         for ( size_t i = 0; i < num_no_pubs; ++i ) {
  1719.             msg = NStr::IntToString(i + 1) + " of " + 
  1720.                 NStr::IntToString(num_no_pubs) + 
  1721.                 " Bioseqs without publication";
  1722.             PostErr(sev, eErr_SEQ_DESCR_NoPubFound, msg, 
  1723.                 *(m_BioseqWithNoPubs[i]));
  1724.         }
  1725.     }
  1726. }
  1729. void CValidError_imp::ReportMissingBiosource(const CSeq_entry& se)
  1730. {
  1731.     if(m_NoBioSource  &&  !m_IsPatent  &&  !m_IsPDB) {
  1732.         PostErr(eDiag_Error, eErr_SEQ_DESCR_NoOrgFound,
  1733.             "No organism name anywhere on this entire record", se);
  1734.         return;
  1735.     }
  1736.     
  1737.     size_t num_no_source = m_BioseqWithNoSource.size();
  1738.     
  1739.     if ( num_no_source == 1 ) {
  1740.         PostErr(eDiag_Error, eErr_SEQ_DESCR_NoOrgFound, 
  1741.             "No organism name has been applied to this Bioseq.",
  1742.             *(m_BioseqWithNoSource[0]));
  1743.     } else if ( num_no_source > 10 ) {
  1744.         PostErr(eDiag_Error, eErr_SEQ_DESCR_NoOrgFound, 
  1745.             NStr::IntToString(num_no_source) + 
  1746.             " Bioseqs without organism name in this record (first reported)",
  1747.             *(m_BioseqWithNoSource[0]));
  1748.     } else {
  1749.         string msg;
  1750.         for ( size_t i = 0; i < num_no_source; ++i ) {
  1751.             msg = NStr::IntToString(i + 1) + " of " + 
  1752.                 NStr::IntToString(num_no_source) + 
  1753.                 " Bioseqs without organism name";
  1754.             PostErr(eDiag_Error, eErr_SEQ_DESCR_NoOrgFound, msg, 
  1755.                 *(m_BioseqWithNoSource[i]));
  1756.         }
  1757.     }
  1758. }
  1761. void CValidError_imp::ReportProtWithoutFullRef(void)
  1762. {
  1763.     size_t num = m_ProtWithNoFullRef.size();
  1764.     
  1765.     if ( num == 1 ) {
  1766.         PostErr(eDiag_Error, eErr_SEQ_FEAT_NoProtRefFound, 
  1767.             "No full length Prot-ref feature applied to this Bioseq",
  1768.             *(m_ProtWithNoFullRef[0]));
  1769.     } else if ( num > 10 ) {
  1770.         PostErr(eDiag_Error, eErr_SEQ_FEAT_NoProtRefFound, 
  1771.             NStr::IntToString(num) + " Bioseqs with no full length " 
  1772.             "Prot-ref feature applied to them (first reported)",
  1773.             *(m_ProtWithNoFullRef[0]));
  1774.     } else {
  1775.         string msg;
  1776.         for ( size_t i = 0; i < num; ++i ) {
  1777.             msg = NStr::IntToString(i + 1) + " of " + 
  1778.                 NStr::IntToString(num) + 
  1779.                 " Bioseqs without full length Prot-ref feature applied to";
  1780.             PostErr(eDiag_Error, eErr_SEQ_FEAT_NoProtRefFound, msg, 
  1781.                 *(m_ProtWithNoFullRef[i]));
  1782.         }
  1783.     }
  1784. }   
  1787. void CValidError_imp::ReportBioseqsWithNoMolinfo(void)
  1788. {
  1789.     if ( m_BioseqWithNoMolinfo.empty() ) {
  1790.         return;
  1791.     }
  1793.     size_t num = m_BioseqWithNoMolinfo.size();
  1794.     
  1795.     if ( num == 1 ) {
  1796.         PostErr(eDiag_Error, eErr_SEQ_DESCR_NoMolInfoFound, 
  1797.             "No Mol-info applies to this Bioseq",
  1798.             *(m_BioseqWithNoMolinfo[0]));
  1799.     } else if ( num > 10 ) {
  1800.         PostErr(eDiag_Error, eErr_SEQ_DESCR_NoMolInfoFound, 
  1801.             NStr::IntToString(num) + " Bioseqs with no Mol-info " 
  1802.             "applied to them (first reported)",
  1803.             *(m_BioseqWithNoMolinfo[0]));
  1804.     } else {
  1805.         string msg;
  1806.         for ( size_t i = 0; i < num; ++i ) {
  1807.             msg = NStr::IntToString(i + 1) + " of " + 
  1808.                 NStr::IntToString(num) + 
  1809.                 " Bioseqs with no Mol-info applied to";
  1810.             PostErr(eDiag_Error, eErr_SEQ_DESCR_NoMolInfoFound, msg, 
  1811.                 *(m_BioseqWithNoMolinfo[i]));
  1812.         }
  1813.     }
  1814. }   
  1817. bool CValidError_imp::IsNucAcc(const string& acc)
  1818. {
  1819.     if ( isupper(acc[0])  &&  acc.find('_') != NPOS ) {
  1820.         return true;
  1821.     }
  1823.     return false;
  1824. }
  1827. bool CValidError_imp::IsFarLocation(const CSeq_loc& loc)
  1828. {
  1829.     for ( CSeq_loc_CI citer(loc); citer; ++citer ) {
  1830.         CConstRef<CSeq_id> id(&citer.GetSeq_id());
  1831.         if ( id ) {
  1832.             CBioseq_Handle near_seq = 
  1833.                 m_Scope->GetBioseqHandleFromTSE(*id, *m_TSE);
  1834.             if ( !near_seq ) {
  1835.                 return true;
  1836.             }
  1837.         }
  1838.     }
  1840.     return false;
  1841. }
  1844. CConstRef<CSeq_feat> CValidError_imp::GetCDSGivenProduct(const CBioseq& seq)
  1845. {
  1846.     CConstRef<CSeq_feat> feat;
  1848.     CBioseq_Handle bsh = m_Scope->GetBioseqHandle(seq);
  1851.     // In case of a NT bioseq limit the search to features packaged on the 
  1852.     // NT (we assume features have been pulled from the segments to the NT).
  1853.     const CSeq_entry* limit = 0;
  1854.     if ( IsNT() ) {
  1855.         limit = m_TSE.GetPointerOrNull();
  1856.     }
  1858.     if ( bsh ) {
  1859.         CFeat_CI fi(bsh, 
  1860.                     0, 0,
  1861.                     CSeqFeatData::e_Cdregion,
  1862.                     SAnnotSelector::eOverlap_Intervals,
  1863.                     SAnnotSelector::eResolve_TSE,
  1864.                     CFeat_CI::e_Product,
  1865.                     limit);
  1866.         if ( fi ) {
  1867.             // return the first one (should be the one packaged on the
  1868.             // nuc-prot set).
  1869.             feat.Reset(&(fi->GetOriginalFeature()));
  1870.         }
  1871.     }
  1873.     return feat;
  1874. }
  1877. const CSeq_entry* CValidError_imp::GetAncestor
  1878. (const CBioseq& seq,
  1879.  CBioseq_set::EClass clss)
  1880. {
  1881.     const CSeq_entry* parent = 0;
  1882.     for ( parent = seq.GetParentEntry(); 
  1883.           parent != 0;
  1884.           parent = parent->GetParentEntry() ) {
  1885.         if ( parent->IsSet() ) {
  1886.             const CBioseq_set& set = parent->GetSet();
  1887.             if ( set.IsSetClass()  &&  set.GetClass() == clss ) {
  1888.                 break;
  1889.             }
  1890.         }
  1891.     }
  1892.     return parent;
  1893. }
  1896. bool CValidError_imp::IsSerialNumberInComment(const string& comment)
  1897. {
  1898.     size_t pos = comment.find('[', 0);
  1899.     while ( pos != string::npos ) {
  1900.         ++pos;
  1901.         if ( isdigit(comment[pos]) ) {
  1902.             while ( isdigit(comment[pos]) ) {
  1903.                 ++pos;
  1904.             }
  1905.             if ( comment[pos] == ']' ) {
  1906.                 return true;
  1907.             }
  1908.         }
  1910.         pos = comment.find('[', pos);
  1911.     }
  1912.     return false;
  1913. }
  1916. bool CValidError_imp::CheckSeqVector(const CSeqVector& vec)
  1917. {
  1918.     if ( IsSequenceAvaliable(vec) ) {
  1919.         return true;
  1920.     }
  1922.     if ( IsRemoteFetch() ) {
  1923.         // issue some sort of error
  1924.     }
  1925.     return false;
  1926. }
  1929. bool CValidError_imp::IsSequenceAvaliable(const CSeqVector& vec)
  1930. {
  1931.     // IMPORTANT: This is a temporary implementation, due to (yet) restricted
  1932.     // implementation of the Scope / object manager classes.
  1933.     // if the first and last elements are accesible the sequence is available.
  1934.     try {
  1935.         vec[0]; 
  1936.         vec[vec.size() - 1];
  1937.     } catch ( const exception& ) {
  1938.         // do something
  1939.         return false;
  1940.     }
  1942.     return true;
  1943. }
  1946. // =============================================================================
  1947. //                                  Private
  1948. // =============================================================================
  1951. bool CValidError_imp::IsMixedStrands(const CSeq_loc& loc)
  1952. {
  1953.     if ( SeqLocCheck(loc, m_Scope) == eSeqLocCheck_warning ) {
  1954.         return false;
  1955.     }
  1957.     CSeq_loc_CI curr(loc);
  1958.     if ( !curr ) {
  1959.         return false;
  1960.     }
  1961.     CSeq_loc_CI prev = curr;
  1962.     ++curr;
  1963.     
  1964.     while ( curr ) {
  1965.         ENa_strand curr_strand = curr.GetStrand();
  1966.         ENa_strand prev_strand = prev.GetStrand();
  1968.         if ( (prev_strand == eNa_strand_minus  &&  
  1969.               curr_strand != eNa_strand_minus)   ||
  1970.              (prev_strand != eNa_strand_minus  &&  
  1971.               curr_strand == eNa_strand_minus) ) {
  1972.             return true;
  1973.         }
  1975.         prev = curr;
  1976.         ++curr;
  1977.     }
  1979.     return false;
  1980. }
  1983. void CValidError_imp::Setup(const CSeq_entry& se, CScope* scope) 
  1984. {
  1985.     // "Save" the Seq-entry
  1986.     m_TSE = &se;
  1988.     if ( scope ) {
  1989.         m_Scope.Reset(scope);
  1990.     } else {
  1991.         SetScope(se);
  1992.     }
  1994.     // If no Pubs/BioSource in CSeq_entry, post only one error
  1995.     CTypeConstIterator<CPub> pub(ConstBegin(se));
  1996.     m_NoPubs = !pub;
  1997.     CTypeConstIterator<CBioSource> src(ConstBegin(se));
  1998.     m_NoBioSource = !src;
  1999.     
  2000.     // Look for genomic product set
  2001.     for (CTypeConstIterator <CBioseq_set> si (se); si; ++si) {
  2002.         if (si->IsSetClass ()) {
  2003.             if (si->GetClass () == CBioseq_set::eClass_gen_prod_set) {
  2004.                 m_IsGPS = true;
  2005.             }
  2006.         }
  2007.     }
  2009.     // Examine all Seq-ids on Bioseqs
  2010.     for (CTypeConstIterator <CBioseq> bi (se); bi; ++bi) {
  2011.         ITERATE (CBioseq::TId, id, bi->GetId()) {
  2012.             CSeq_id::E_Choice typ = (**id).Which();
  2013.             switch (typ) {
  2014.                 case CSeq_id::e_not_set:
  2015.                     break;
  2016.                 case CSeq_id::e_Local:
  2017.                     break;
  2018.                 case CSeq_id::e_Gibbsq:
  2019.                     break;
  2020.                 case CSeq_id::e_Gibbmt:
  2021.                     break;
  2022.                 case CSeq_id::e_Giim:
  2023.                     break;
  2024.                 case CSeq_id::e_Genbank:
  2025.                     m_IsGED = true;
  2026.                     break;
  2027.                 case CSeq_id::e_Embl:
  2028.                     m_IsGED = true;
  2029.                     break;
  2030.                 case CSeq_id::e_Pir:
  2031.                     break;
  2032.                 case CSeq_id::e_Swissprot:
  2033.                     break;
  2034.                 case CSeq_id::e_Patent:
  2035.                     m_IsPatent = true;
  2036.                     break;
  2037.                 case CSeq_id::e_Other:
  2038.                     m_IsRefSeq = true;
  2039.                     // and do RefSeq subclasses up front as well
  2040.                     if ((**id).GetOther().IsSetAccession()) {
  2041.                         string acc = (**id).GetOther().GetAccession().substr(0, 3);
  2042.                         if (acc == "NC_") {
  2043.                             m_IsNC = true;
  2044.                         } else if (acc == "NG_") {
  2045.                             m_IsNG = true;
  2046.                         } else if (acc == "NM_") {
  2047.                             m_IsNM = true;
  2048.                         } else if (acc == "NP_") {
  2049.                             m_IsNP = true;
  2050.                         } else if (acc == "NR_") {
  2051.                             m_IsNR = true;
  2052.                         } else if (acc == "NS_") {
  2053.                             m_IsNS = true;
  2054.                         } else if (acc == "NT_") {
  2055.                             m_IsNT = true;
  2056.                         } else if (acc == "NW_") {
  2057.                             m_IsNW = true;
  2058.                         } else if (acc == "XR_") {
  2059.                             m_IsXR = true;
  2060.                         }
  2061.                     }
  2062.                     break;
  2063.                 case CSeq_id::e_General:
  2064.                     if (!NStr::CompareCase((**id).GetGeneral().GetDb(), "BankIt")) {
  2065.                         m_IsTPA = true;
  2066.                     }
  2067.                     break;
  2068.                 case CSeq_id::e_Gi:
  2069.                     m_IsGI = true;
  2070.                     break;
  2071.                 case CSeq_id::e_Ddbj:
  2072.                     m_IsGED = true;
  2073.                     break;
  2074.                 case CSeq_id::e_Prf:
  2075.                     break;
  2076.                 case CSeq_id::e_Pdb:
  2077.                     m_IsPDB = true;
  2078.                     break;
  2079.                 case CSeq_id::e_Tpg:
  2080.                     m_IsTPA = true;
  2081.                     break;
  2082.                 case CSeq_id::e_Tpe:
  2083.                     m_IsTPA = true;
  2084.                     break;
  2085.                 case CSeq_id::e_Tpd:
  2086.                     m_IsTPA = true;
  2087.                     break;
  2088.                 default:
  2089.                     break;
  2090.             }
  2091.         }
  2092.     }
  2093.     
  2094.     if ( m_PrgCallback ) {
  2095.         m_NumAlign = 0;
  2096.         for (CTypeConstIterator<CSeq_align> i(se); i; ++i) {
  2097.             m_NumAlign++;
  2098.         }
  2099.         m_NumAnnot = 0;
  2100.         for (CTypeConstIterator<CSeq_annot> i(se); i; ++i) {
  2101.             m_NumAnnot++;
  2102.         }
  2103.         m_NumBioseq = 0;
  2104.         for (CTypeConstIterator<CBioseq> i(se); i; ++i) {
  2105.             m_NumBioseq++;
  2106.         }
  2107.         m_NumBioseq_set = 0;
  2108.         for (CTypeConstIterator<CBioseq_set> i(se); i; ++i) {
  2109.             m_NumBioseq_set++;
  2110.         }
  2111.         m_NumDesc = 0;
  2112.         for (CTypeConstIterator<CSeqdesc> i(se); i; ++i) {
  2113.             m_NumDesc++;
  2114.         }
  2115.         m_NumDescr = 0;
  2116.         for (CTypeConstIterator<CSeq_descr> i(se); i; ++i) {
  2117.             m_NumDescr++;
  2118.         }
  2119.         m_NumFeat = 0;
  2120.         for (CTypeConstIterator<CSeq_feat> i(se); i; ++i) {
  2121.             m_NumFeat++;
  2122.         }
  2123.         m_NumGraph = 0;
  2124.         for (CTypeConstIterator<CSeq_graph> i(se); i; ++i) {
  2125.             m_NumGraph++;
  2126.         }
  2127.         m_PrgInfo.m_Total = m_NumAlign + m_NumAnnot + m_NumBioseq + 
  2128.             m_NumBioseq_set + m_NumDesc + m_NumDescr + m_NumFeat + 
  2129.             m_NumGraph;
  2130.     } 
  2131. }
  2135. void CValidError_imp::SetScope(const CSeq_entry& se)
  2136. {
  2137.     m_Scope.Reset(new CScope(*m_ObjMgr));
  2138.     m_Scope->AddTopLevelSeqEntry(*const_cast<CSeq_entry*>(&se));
  2139.     m_Scope->AddDefaults();
  2140. }
  2143. void CValidError_imp::Setup(const CSeq_annot& sa, CScope* scope) 
  2144. {
  2145.     m_IsStandaloneAnnot = true;
  2146.     m_TSE.Reset(new CSeq_entry); // set a dummy Seq-entry
  2148.     if ( scope ) {
  2149.         m_Scope.Reset(scope);
  2150.     } else {
  2151.         SetScope(sa);
  2152.     }
  2153. }
  2156. void CValidError_imp::SetScope(const CSeq_annot& sa)
  2157. {
  2158.     CRef<CSeq_entry> se(new CSeq_entry);  // dummy Seq-entry
  2160.     m_Scope.Reset(new CScope(*m_ObjMgr));
  2161.     m_Scope->AttachAnnot(*se, const_cast<CSeq_annot&>(sa));
  2162.     m_Scope->AddDefaults();
  2163. }
  2166. const string CValidError_imp::sm_SourceQualPrefixes[] = {
  2167.   "acronym:",
  2168.   "anamorph:",
  2169.   "authority:",
  2170.   "biotype:",
  2171.   "biovar:",
  2172.   "breed:",
  2173.   "cell_line:",
  2174.   "cell_type:",
  2175.   "chemovar:",
  2176.   "chromosome:",
  2177.   "clone:",
  2178.   "clone_lib:",
  2179.   "common:",
  2180.   "country:",
  2181.   "cultivar:",
  2182.   "dev_stage:",
  2183.   "dosage:",
  2184.   "ecotype:",
  2185.   "endogenous_virus_name:",
  2186.   "environmental_sample:",
  2187.   "forma:",
  2188.   "forma_specialis:",
  2189.   "frequency:",
  2190.   "genotype:",
  2191.   "germline:",
  2192.   "group:",
  2193.   "haplotype:",
  2194.   "insertion_seq_name:",
  2195.   "isolate:",
  2196.   "isolation_source:",
  2197.   "lab_host:",
  2198.   "map:",
  2199.   "nat_host:",
  2200.   "pathovar:",
  2201.   "plasmid_name:",
  2202.   "plastid_name:",
  2203.   "pop_variant:",
  2204.   "rearranged:",
  2205.   "segment:",
  2206.   "serogroup:",
  2207.   "serotype:",
  2208.   "serovar:",
  2209.   "sex:",
  2210.   "specimen_voucher:",
  2211.   "strain:",
  2212.   "subclone:",
  2213.   "subgroup:",
  2214.   "substrain:",
  2215.   "subtype:",
  2216.   "sub_species:",
  2217.   "synonym:",
  2218.   "taxon:",
  2219.   "teleomorph:",
  2220.   "tissue_lib:",
  2221.   "tissue_type:",
  2222.   "transgenic:",
  2223.   "transposon_name:",
  2224.   "type:",
  2225.   "variety:",
  2226. };
  2229. void CValidError_imp::InitializeSourceQualTags() 
  2230. {
  2231.     m_SourceQualTags.reset(new CTextFsa);
  2232.     size_t size = sizeof(sm_SourceQualPrefixes) / sizeof(string);
  2234.     for (size_t i = 0; i < size; ++i ) {
  2235.         m_SourceQualTags->AddWord(sm_SourceQualPrefixes[i]);
  2236.     }
  2238.     m_SourceQualTags->Prime();
  2239. }
  2242. void CValidError_imp::ValidateSourceQualTags
  2243. (const string& str,
  2244.  const CSerialObject& obj)
  2245. {
  2246.     if ( str.empty() ) return;
  2248.     size_t str_len = str.length();
  2250.     int state = m_SourceQualTags->GetInitialState();
  2251.     for ( size_t i = 0; i < str_len; ++i ) {
  2252.         state = m_SourceQualTags->GetNextState(state, str[i]);
  2253.         if ( m_SourceQualTags->IsMatchFound(state) ) {
  2254.             string match = m_SourceQualTags->GetMatches(state)[0];
  2255.             if ( match.empty() ) {
  2256.                 match = "?";
  2257.             }
  2259.             bool okay = true;
  2260.             if ( (int)(i - str_len) >= 0 ) {
  2261.                 char ch = str[i - str_len];
  2262.                 if ( !isspace(ch) || ch != ';' ) {
  2263.                     okay = false;
  2264.                 }
  2265.             }
  2266.             if ( okay ) {
  2267.                 PostErr(eDiag_Warning, eErr_SEQ_DESCR_StructuredSourceNote,
  2268.                     "Source note has structured tag " + match, obj);
  2269.             }
  2270.         }
  2271.     }
  2272. }
  2275. bool CValidError_imp::IsCuratedRefSeq(void) const {
  2276.     return !(IsNM()  ||  IsNP()  || IsNG()  ||  IsNR());
  2277. }
  2280. void CValidError_imp::ValidateSeqLocIds
  2281. (const CSeq_loc& loc,
  2282.  const CSerialObject& obj)
  2283. {
  2284.     for ( CSeq_loc_CI lit(loc); lit; ++lit ) {
  2285.         const CSeq_id& id1 = lit.GetSeq_id();
  2286.         CSeq_loc_CI  lit2 = lit;
  2287.         for ( ++lit2; lit2; ++lit2 ) {
  2288.             const CSeq_id& id2 = lit2.GetSeq_id();
  2289.             if ( IsSameBioseq(id1, id2, m_Scope)  &&  !id1.Match(id2) ) {
  2290.                 PostErr(eDiag_Warning,
  2291.                     eErr_SEQ_FEAT_DifferntIdTypesInSeqLoc,
  2292.                     "Two ids refer to the same bioseq but are of "
  2293.                     "differnt type", obj);
  2294.             }
  2295.         }
  2296.     } 
  2297. }
  2301. // =============================================================================
  2302. //                         CValidError_base Implementation
  2303. // =============================================================================
  2306. CValidError_base::CValidError_base(CValidError_imp& imp) :
  2307.     m_Imp(imp), m_Scope(imp.GetScope())
  2308. {
  2309. }
  2312. CValidError_base::~CValidError_base()
  2313. {
  2314. }
  2317. void CValidError_base::PostErr
  2318. (EDiagSev sv,
  2319.  EErrType et,
  2320.  const string& msg,
  2321.  const CSerialObject& obj) 
  2322. {
  2323.     m_Imp.PostErr(sv, et, msg, obj);
  2324. }
  2327. void CValidError_base::PostErr
  2328. (EDiagSev sv,
  2329.  EErrType et,
  2330.  const string& msg,
  2331.  TDesc ds)
  2332. {
  2333.     m_Imp.PostErr(sv, et, msg, ds);
  2334. }
  2337. void CValidError_base::PostErr
  2338. (EDiagSev sv,
  2339.  EErrType et,
  2340.  const string& msg,
  2341.  TFeat ft)
  2342. {
  2343.     m_Imp.PostErr(sv, et, msg, ft);
  2344. }
  2347. void CValidError_base::PostErr
  2348. (EDiagSev sv,
  2349.  EErrType et,
  2350.  const string& msg,
  2351.  TBioseq sq)
  2352. {
  2353.     m_Imp.PostErr(sv, et, msg, sq);
  2354. }
  2357. void CValidError_base::PostErr
  2358. (EDiagSev sv,
  2359.  EErrType et,
  2360.  const string& msg,
  2361.  TBioseq sq,
  2362.  TDesc ds)
  2363. {
  2364.     m_Imp.PostErr(sv, et, msg, sq, ds);
  2365. }
  2368. void CValidError_base::PostErr
  2369. (EDiagSev sv,
  2370.  EErrType et,
  2371.  const string& msg, 
  2372.  TSet set)
  2373. {
  2374.     m_Imp.PostErr(sv, et, msg, set);
  2375. }
  2378. void CValidError_base::PostErr
  2379. (EDiagSev sv, 
  2380.  EErrType et, 
  2381.  const string& msg, 
  2382.  TSet set,
  2383.  TDesc ds)
  2384. {
  2385.     m_Imp.PostErr(sv, et, msg, set, ds);
  2386. }
  2389. void CValidError_base::PostErr
  2390. (EDiagSev sv,
  2391.  EErrType et,
  2392.  const string& msg,
  2393.  TAnnot annot)
  2394. {
  2395.     m_Imp.PostErr(sv, et, msg, annot);
  2396. }
  2398. void CValidError_base::PostErr
  2399. (EDiagSev sv,
  2400.  EErrType et,
  2401.  const string& msg,
  2402.  TGraph graph)
  2403. {
  2404.     m_Imp.PostErr(sv, et, msg, graph);
  2405. }
  2408. void CValidError_base::PostErr
  2409. (EDiagSev sv,
  2410.  EErrType et,
  2411.  const string& msg,
  2412.  TBioseq sq,
  2413.  TGraph graph)
  2414. {
  2415.     m_Imp.PostErr(sv, et, msg, sq, graph);
  2416. }
  2419. void CValidError_base::PostErr
  2420. (EDiagSev sv,
  2421.  EErrType et,
  2422.  const string& msg,
  2423.  TAlign align)
  2424. {
  2425.     m_Imp.PostErr(sv, et, msg, align);
  2426. }
  2429. void CValidError_base::PostErr
  2430. (EDiagSev sv,
  2431.  EErrType et,
  2432.  const string& msg,
  2433.  TEntry entry)
  2434. {
  2435.     m_Imp.PostErr(sv, et, msg, entry);
  2436. }
  2439. END_SCOPE(validator)
  2440. END_SCOPE(objects)
  2441. END_NCBI_SCOPE
  2444. /*
  2445. * ===========================================================================
  2446. *
  2447. * $Log: validatorp.cpp,v $
  2448. * Revision 1000.3  2004/06/01 19:47:39  gouriano
  2449. * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.52
  2450. *
  2451. * Revision 1.52  2004/05/26 14:52:59  shomrat
  2452. * trans-splice exception supress subsequent error messages
  2453. *
  2454. * Revision 1.51  2004/05/21 21:42:56  gorelenk
  2455. * Added PCH ncbi_pch.hpp
  2456. *
  2457. * Revision 1.50  2004/05/10 13:56:47  shomrat
  2458. * Use CSeq_feat_Handle instead of FeatAnnotMap
  2459. *
  2460. * Revision 1.49  2004/04/27 18:41:05  shomrat
  2461. * ProtWithoutFullRef report CDS feature instead of protein bioseq
  2462. *
  2463. * Revision 1.48  2004/04/23 16:25:30  shomrat
  2464. * Stop using CBioseq_Handle deprecated interface
  2465. *
  2466. * Revision 1.47  2004/04/05 15:56:15  grichenk
  2467. * Redesigned CAnnotTypes_CI: moved all data and data collecting
  2468. * functions to CAnnotDataCollector. CAnnotTypes_CI is no more
  2469. * inherited from SAnnotSelector.
  2470. *
  2471. * Revision 1.46  2004/03/01 18:40:28  shomrat
  2472. * Changed far location check
  2473. *
  2474. * Revision 1.45  2004/01/12 20:25:23  shomrat
  2475. * ValidateCitSub called from ValidatePubdesc, gives error if no affiliation fields set
  2476. *
  2477. * Revision 1.44  2003/12/17 19:16:15  shomrat
  2478. * Notify graph packaging problem
  2479. *
  2480. * Revision 1.43  2003/12/15 19:09:34  shomrat
  2481. * seq-id ordering not adequate for binary_search algorithm
  2482. *
  2483. * Revision 1.42  2003/11/14 15:56:47  shomrat
  2484. * report TPA assembly problem
  2485. *
  2486. * Revision 1.41  2003/10/27 17:02:01  shomrat
  2487. * fixes to ValidatePubdesc and ValidatePubArticle
  2488. *
  2489. * Revision 1.40  2003/10/20 16:12:32  shomrat
  2490. * Added SEQ_FEAT_OnlyGeneXrefs test
  2491. *
  2492. * Revision 1.39  2003/07/24 20:16:18  vasilche
  2493. * Fixed typedefs for dbxref: list<CRef<CDbtag>> -> vector<CRef<CDbtag>>
  2494. *
  2495. * Revision 1.38  2003/06/27 18:54:22  shomrat
  2496. * Modified ValidateDbxref to use CDbtag.IsApproved
  2497. *
  2498. * Revision 1.37  2003/06/18 20:58:44  shomrat
  2499. * germline and rearranged are mutually exclusive - proviral and virion are because there is only one biop->genome
  2500. *
  2501. * Revision 1.36  2003/06/02 16:06:43  dicuccio
  2502. * Rearranged src/objects/ subtree.  This includes the following shifts:
  2503. *     - src/objects/asn2asn --> arc/app/asn2asn
  2504. *     - src/objects/testmedline --> src/objects/ncbimime/test
  2505. *     - src/objects/objmgr --> src/objmgr
  2506. *     - src/objects/util --> src/objmgr/util
  2507. *     - src/objects/alnmgr --> src/objtools/alnmgr
  2508. *     - src/objects/flat --> src/objtools/flat
  2509. *     - src/objects/validator --> src/objtools/validator
  2510. *     - src/objects/cddalignview --> src/objtools/cddalignview
  2511. * In addition, libseq now includes six of the objects/seq... libs, and libmmdb
  2512. * replaces the three libmmdb? libs.
  2513. *
  2514. * Revision 1.35  2003/05/28 16:23:23  shomrat
  2515. * SourceQualTags mad static, to improve performance in batch mode; other minor corrections.
  2516. *
  2517. * Revision 1.34  2003/05/15 18:12:10  shomrat
  2518. * Bug fix in ValidatePubArticle
  2519. *
  2520. * Revision 1.33  2003/05/14 22:10:43  shomrat
  2521. * == -> !=
  2522. *
  2523. * Revision 1.32  2003/05/05 15:35:02  shomrat
  2524. * eErr_GENERIC_BadPageNumbering dropped to eDiag_warning
  2525. *
  2526. * Revision 1.31  2003/04/29 14:57:09  shomrat
  2527. * Added SeqAlign and SeqEntry error posting methods
  2528. *
  2529. * Revision 1.30  2003/04/15 14:53:57  shomrat
  2530. * Implemented a progress callback mechanism
  2531. *
  2532. * Revision 1.29  2003/04/07 14:56:33  shomrat
  2533. * Added Seq-loc ids validation
  2534. *
  2535. * Revision 1.28  2003/04/04 18:40:50  shomrat
  2536. * Increased robustness in face of exceptions.
  2537. *
  2538. * Revision 1.27  2003/03/28 16:30:33  shomrat
  2539. * Implemented PostErr method for graph errors.
  2540. *
  2541. * Revision 1.26  2003/03/21 21:11:09  shomrat
  2542. * Initialization of m_ValidateIdSet
  2543. *
  2544. * Revision 1.25  2003/03/21 20:36:34  shomrat
  2545. * Added SEQ_DESCR_UnnecessaryBioSourceFocus
  2546. *
  2547. * Revision 1.23  2003/03/20 18:55:55  shomrat
  2548. * Added validation of standalone Seq-annot objects
  2549. *
  2550. * Revision 1.22  2003/03/18 21:48:37  grichenk
  2551. * Removed obsolete class CAnnot_CI
  2552. *
  2553. * Revision 1.21  2003/03/11 16:04:09  kuznets
  2554. * iterate -> ITERATE
  2555. *
  2556. * Revision 1.20  2003/03/07 19:15:01  shomrat
  2557. * Using binary search in IsFarLocation
  2558. *
  2559. * Revision 1.19  2003/02/24 20:18:09  shomrat
  2560. * Pass the CValidError object to the implementation class instead of the internal TErrs vector
  2561. *
  2562. * Revision 1.18  2003/02/24 18:58:13  vasilche
  2563. * Use faster version of CSeq_id::Assign().
  2564. *
  2565. * Revision 1.17  2003/02/14 21:47:13  shomrat
  2566. * Added methods to report Bioseqs with no MolInfo
  2567. *
  2568. * Revision 1.16  2003/02/12 17:49:24  shomrat
  2569. * Added implementation of IsSerialNumberInComment; Changed implementation of IsFarLocation
  2570. *
  2571. * Revision 1.15  2003/02/10 15:54:02  grichenk
  2572. * Use CFeat_CI->GetMappedFeature() and GetOriginalFeature()
  2573. *
  2574. * Revision 1.14  2003/02/07 21:14:01  shomrat
  2575. * IsMixedStrands signature changed
  2576. *
  2577. * Revision 1.13  2003/02/04 01:41:24  ucko
  2578. * Fix compilation errors caused by trying to return a pointer as a CRef
  2579. * without explicit conversion (required these days).
  2580. *
  2581. * Revision 1.12  2003/02/03 20:20:19  shomrat
  2582. * If performance flag set skip check for far location (testing)
  2583. *
  2584. * Revision 1.11  2003/02/03 17:09:05  shomrat
  2585. * Changed return value for GetCDSGivenProduct
  2586. *
  2587. * Revision 1.10  2003/01/31 19:46:46  lavr
  2588. * Remove unused variable "e" from catch() clause
  2589. *
  2590. * Revision 1.9  2003/01/29 21:55:14  shomrat
  2591. * Added check for et al
  2592. *
  2593. * Revision 1.8  2003/01/24 20:38:51  shomrat
  2594. * Added call to ValidateHistory for each bioseq
  2595. *
  2596. * Revision 1.7  2003/01/24 19:14:47  ucko
  2597. * Catch exceptions by reference rather than value; fixes a build error
  2598. * with WorkShop in release mode.
  2599. *
  2600. * Revision 1.6  2003/01/21 20:19:07  shomrat
  2601. * Implemented ValidatePubDesc
  2602. *
  2603. * Revision 1.5  2003/01/08 18:35:39  shomrat
  2604. * Added mapping features to their enclosing annotation
  2605. *
  2606. * Revision 1.4  2003/01/02 22:01:20  shomrat
  2607. * Added GetCDSGivenProduct and GetAncestor
  2608. *
  2609. * Revision 1.3  2002/12/26 16:35:11  shomrat
  2610. * Typo
  2611. *
  2612. * Revision 1.2  2002/12/24 16:51:54  shomrat
  2613. * Changes to include directives
  2614. *
  2615. * Revision 1.1  2002/12/23 20:14:37  shomrat
  2616. * Initial submission after splitting former implementation
  2617. *
  2618. *
  2619. * ===========================================================================
  2620. */