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

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

生物技术

开发平台：

C/C++

validerror_feat.cpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: validerror_feat.cpp,v $
  4.  * PRODUCTION Revision 1000.2  2004/06/01 19:48:04  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.56
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. /*  $Id: validerror_feat.cpp,v 1000.2 2004/06/01 19:48:04 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......
  36.  *
  37.  * File Description:
  38.  *   validation of Seq_feat
  39.  *   .......
  40.  *
  41.  */
  42. #include <ncbi_pch.hpp>
  43. #include <corelib/ncbistd.hpp>
  44. #include <corelib/ncbistr.hpp>
  45. #include "validatorp.hpp"
  46. #include "utilities.hpp"
  48. #include <serial/serialbase.hpp>
  50. #include <objmgr/bioseq_handle.hpp>
  51. #include <objmgr/seq_entry_handle.hpp>
  52. #include <objmgr/feat_ci.hpp>
  53. #include <objmgr/seqdesc_ci.hpp>
  54. #include <objmgr/seq_vector.hpp>
  55. #include <objmgr/scope.hpp>
  56. #include <objmgr/util/sequence.hpp>
  57. #include <objmgr/util/feature.hpp>
  59. #include <objects/seqfeat/Seq_feat.hpp>
  60. #include <objects/seqfeat/BioSource.hpp>
  61. #include <objects/seqfeat/Cdregion.hpp>
  62. #include <objects/seqfeat/Code_break.hpp>
  63. #include <objects/seqfeat/Gb_qual.hpp>
  64. #include <objects/seqfeat/Genetic_code.hpp>
  65. #include <objects/seqfeat/Genetic_code_table.hpp>
  66. #include <objects/seqfeat/Imp_feat.hpp>
  67. #include <objects/seqfeat/Org_ref.hpp>
  68. #include <objects/seqfeat/Prot_ref.hpp>
  69. #include <objects/seqfeat/RNA_ref.hpp>
  70. #include <objects/seqfeat/SubSource.hpp>
  71. #include <objects/seqfeat/Trna_ext.hpp>
  73. #include <objects/seqloc/Seq_loc.hpp>
  74. #include <objects/seqloc/Seq_interval.hpp>
  75. #include <objects/seqloc/Seq_point.hpp>
  76. #include <objects/seqloc/Textseq_id.hpp>
  78. #include <objects/seqset/Seq_entry.hpp>
  79. #include <objects/seqset/Bioseq_set.hpp>
  81. #include <objects/seq/MolInfo.hpp>
  82. #include <objects/seq/Bioseq.hpp>
  84. #include <objects/pub/Pub.hpp>
  85. #include <objects/pub/Pub_set.hpp>
  87. #include <objects/general/Dbtag.hpp>
  89. #include <algorithm>
  90. #include <string>
  93. BEGIN_NCBI_SCOPE
  94. BEGIN_SCOPE(objects)
  95. BEGIN_SCOPE(validator)
  96. using namespace sequence;
  99. // =============================================================================
  100. //                                     Public
  101. // =============================================================================
  104. CValidError_feat::CValidError_feat(CValidError_imp& imp) :
  105.     CValidError_base(imp),
  106.     m_NumGenes(0),
  107.     m_NumGeneXrefs(0)
  108. {
  109. }
  112. CValidError_feat::~CValidError_feat(void)
  113. {
  114. }
  117. void CValidError_feat::ValidateSeqFeat(const CSeq_feat& feat)
  118. {
  119.     if ( !feat.CanGetLocation() ) {
  120.         PostErr(eDiag_Critical, eErr_SEQ_FEAT_MissingLocation,
  121.             "The feature is missing a location", feat);
  122.     }
  124.     CBioseq_Handle bsh = m_Scope->GetBioseqHandle(feat.GetLocation());
  125.     m_Imp.ValidateSeqLoc(feat.GetLocation(), bsh, "Location", feat);
  126.     
  127.     if ( feat.CanGetProduct() ) {
  128.         ValidateSeqFeatProduct(feat.GetProduct(), feat);
  129.     }
  130.     
  131.     ValidateFeatPartialness(feat);
  132.     
  133.     ValidateExcept(feat);
  134.     
  135.     ValidateSeqFeatData(feat.GetData(), feat);
  136.     
  137.     if (feat.CanGetDbxref ()) {
  138.         m_Imp.ValidateDbxref (feat.GetDbxref (), feat);
  139.     }
  140.     
  141.     if ( feat.CanGetComment() ) {
  142.         ValidateFeatComment(feat.GetComment(), feat);
  143.     }
  145.     if ( feat.CanGetCit() ) {
  146.         ValidateFeatCit(feat.GetCit(), feat);
  147.     }
  149.     const CGene_ref* gene_xref = feat.GetGeneXref();
  150.     if ( gene_xref != 0  &&  !gene_xref->IsSuppressed() ) {
  151.         ++m_NumGeneXrefs;
  152.     }
  153. }
  156. // =============================================================================
  157. //                                     Private
  158. // =============================================================================
  161. // static member initializations
  162. const string s_PlastidTxt[] = {
  163.   "",
  164.   "",
  165.   "chloroplast",
  166.   "chromoplast",
  167.   "",
  168.   "",
  169.   "plastid",
  170.   "",
  171.   "",
  172.   "",
  173.   "",
  174.   "",
  175.   "cyanelle",
  176.   "",
  177.   "",
  178.   "",
  179.   "apicoplast",
  180.   "leucoplast",
  181.   "proplastid",
  182.   ""
  183. };
  186. static string s_LegalRepeatTypes[] = {
  187.   "tandem", "inverted", "flanking", "terminal",
  188.   "direct", "dispersed", "other"
  189. };
  192. static string s_LegalConsSpliceStrings[] = {
  193.   "(5'site:YES, 3'site:YES)",
  194.   "(5'site:YES, 3'site:NO)",
  195.   "(5'site:YES, 3'site:ABSENT)",
  196.   "(5'site:NO, 3'site:YES)",
  197.   "(5'site:NO, 3'site:NO)",
  198.   "(5'site:NO, 3'site:ABSENT)",
  199.   "(5'site:ABSENT, 3'site:YES)",
  200.   "(5'site:ABSENT, 3'site:NO)",
  201.   "(5'site:ABSENT, 3'site:ABSENT)"
  202. };
  205. static bool s_IsLocRefSeqMrna(const CSeq_loc& loc, CScope& scope)
  206. {
  207.     CBioseq_Handle bsh = scope.GetBioseqHandle(loc);
  208.     if ( bsh ) {
  209.         ITERATE (CBioseq::TId, it, bsh.GetBioseqCore()->GetId()) {
  210.             if ( (*it)->IdentifyAccession() == CSeq_id::eAcc_refseq_mrna ) {
  211.                 return true;
  212.             }
  213.         }
  214.     }
  216.     return false;
  217. }
  220. static bool s_IsLocGEDL(const CSeq_loc& loc, CScope& scope)
  221. {
  222.     CBioseq_Handle bsh = scope.GetBioseqHandle(loc);
  223.     if ( bsh ) {
  224.         ITERATE (CBioseq::TId, it, bsh.GetBioseqCore()->GetId()) {
  225.             CSeq_id::EAccessionInfo acc_info = (*it)->IdentifyAccession();
  226.             if ( acc_info == CSeq_id::eAcc_gb_embl_ddbj  ||
  227.                  acc_info == CSeq_id::eAcc_local ) {
  228.                 return true;
  229.             }
  230.         }
  231.     }
  233.     return false;
  234. }
  237. // private member functions:
  239. void CValidError_feat::ValidateSeqFeatData
  240. (const CSeqFeatData& data,
  241.  const CSeq_feat& feat)
  242. {
  243.     switch ( data.Which () ) {
  244.     case CSeqFeatData::e_Gene:
  245.         // Validate CGene_ref
  246.         ValidateGene(data.GetGene (), feat);
  247.         break;
  248.     case CSeqFeatData::e_Cdregion:
  249.         // Validate CCdregion
  250.         ValidateCdregion(data.GetCdregion (), feat);
  251.         break;
  252.     case CSeqFeatData::e_Prot:
  253.         // Validate CProt_ref
  254.         ValidateProt(data.GetProt (), feat);
  255.         break;
  256.     case CSeqFeatData::e_Rna:
  257.         // Validate CRNA_ref
  258.         ValidateRna(data.GetRna (), feat);
  259.         break;
  260.     case CSeqFeatData::e_Pub:
  261.         // Validate CPubdesc
  262.         m_Imp.ValidatePubdesc(data.GetPub (), feat);
  263.         break;
  264.     case CSeqFeatData::e_Imp:
  265.         // Validate CPubdesc
  266.         ValidateImp(data.GetImp (), feat);
  267.         break;
  268.     case CSeqFeatData::e_Biosrc:
  269.         // Validate CBioSource
  270.         ValidateFeatBioSource(data.GetBiosrc(), feat);
  271.         break;
  273.     case CSeqFeatData::e_Org:
  274.     case CSeqFeatData::e_Region:
  275.     case CSeqFeatData::e_Seq:
  276.     case CSeqFeatData::e_Comment:
  277.     case CSeqFeatData::e_Bond:
  278.     case CSeqFeatData::e_Site:
  279.     case CSeqFeatData::e_Rsite:
  280.     case CSeqFeatData::e_User:
  281.     case CSeqFeatData::e_Txinit:
  282.     case CSeqFeatData::e_Num:
  283.     case CSeqFeatData::e_Psec_str:
  284.     case CSeqFeatData::e_Non_std_residue:
  285.     case CSeqFeatData::e_Het:
  286.         break;
  288.     default:
  289.         PostErr(eDiag_Error, eErr_SEQ_FEAT_InvalidType,
  290.             "Invalid SeqFeat type [" + 
  291.             NStr::IntToString(data.Which ()) +
  292.             "]", feat);
  293.         break;
  294.     }
  296.     if ( !data.IsGene() ) {
  297.         ValidateGeneXRef(feat);
  298.     } else {
  299.         ValidateOperon(feat);
  300.     }
  301. }
  304. void CValidError_feat::ValidateSeqFeatProduct
  305. (const CSeq_loc& prod, const CSeq_feat& feat)
  306. {
  307.     CBioseq_Handle bsh = m_Scope->GetBioseqHandle(feat.GetProduct());
  308.     m_Imp.ValidateSeqLoc(feat.GetProduct(), bsh, "Product", feat);
  309.     
  310.     if ( IsOneBioseq(prod, m_Scope) ) {
  311.         const CSeq_id& sid = GetId(prod, m_Scope);
  312.     
  313.         switch ( sid.Which() ) {
  314.         case CSeq_id::e_Genbank:
  315.         case CSeq_id::e_Embl:
  316.         case CSeq_id::e_Ddbj:
  317.         case CSeq_id::e_Tpg:
  318.         case CSeq_id::e_Tpe:
  319.         case CSeq_id::e_Tpd:
  320.             {
  321.                 const CTextseq_id* tsid = sid.GetTextseq_Id();
  322.                 if ( tsid != NULL ) {
  323.                     if ( !tsid->CanGetAccession()  &&  tsid->CanGetName() ) {
  324.                         if ( m_Imp.IsNucAcc(tsid->GetName()) ) {
  325.                             PostErr(eDiag_Warning, eErr_SEQ_FEAT_BadProductSeqId,
  326.                                 "Feature product should not use "
  327.                                 "Textseq-id 'name' slot", feat);
  328.                         }
  329.                     }
  330.                 }
  331.             }
  332.             break;
  333.             
  334.         default:
  335.             break;
  336.         }
  337.     }
  338. }
  341. bool CValidError_feat::IsPlastid(int genome)
  342. {
  343.     if ( genome == CBioSource::eGenome_chloroplast  ||
  344.          genome == CBioSource::eGenome_chromoplast  ||
  345.          genome == CBioSource::eGenome_plastid      ||
  346.          genome == CBioSource::eGenome_cyanelle     ||
  347.          genome == CBioSource::eGenome_apicoplast   ||
  348.          genome == CBioSource::eGenome_leucoplast   ||
  349.          genome == CBioSource::eGenome_proplastid  ) { 
  350.         return true;
  351.     }
  353.     return false;
  354. }
  357. bool CValidError_feat::IsOverlappingGenePseudo(const CSeq_feat& feat)
  358. {
  359.     const CGene_ref* grp = feat.GetGeneXref();
  360.     if ( grp  ) {
  361.         return (grp->CanGetPseudo()  &&  grp->GetPseudo());
  362.     }
  364.     // !!! DEBUG {
  365.     // For testing purposes. Remove when test is done.
  366.     if ( m_Imp.AvoidPerfBottlenecks() ) {
  367.         return false;
  368.     }
  369.     // }
  371.     // check overlapping gene
  372.     CConstRef<CSeq_feat> overlap = 
  373.         GetOverlappingGene(feat.GetLocation(), *m_Scope);
  374.     if ( overlap ) {
  375.         if ( (overlap->CanGetPseudo()  &&  overlap->GetPseudo())  ||
  376.              (overlap->GetData().GetGene().CanGetPseudo()  &&
  377.               overlap->GetData().GetGene().GetPseudo()) ) {
  378.             return true;
  379.         }
  380.     }
  382.     return false;
  383. }
  386. bool CValidError_feat::SuppressCheck(const string& except_text)
  387. {
  388.     static string exceptions[] = {
  389.         "ribosomal slippage",
  390.         "artificial frameshift",
  391.         "nonconsensus splice site"
  392.     };
  394.     for ( size_t i = 0; i < sizeof(exceptions) / sizeof(string); ++i ) {
  395.     if ( NStr::FindNoCase(except_text, exceptions[i] ) != string::npos )
  396.          return true;
  397.     }
  398.     return false;
  399. }
  405. unsigned char CValidError_feat::Residue(unsigned char res)
  406. {
  407.     return res == 255 ? '?' : res;
  408. }
  411. int CValidError_feat::CheckForRaggedEnd
  412. (const CSeq_loc& loc, 
  413.  const CCdregion& cdregion)
  414. {
  415.     size_t len = GetLength(loc, m_Scope);
  416.     if ( cdregion.GetFrame() > CCdregion::eFrame_one ) {
  417.         len -= cdregion.GetFrame() - 1;
  418.     }
  420.     int ragged = len % 3;
  421.     if ( ragged > 0 ) {
  422.         len = GetLength(loc, m_Scope);
  424.         CSeq_loc::TRange range = CSeq_loc::TRange::GetEmpty();
  425.         ITERATE( CCdregion::TCode_break, cbr, cdregion.GetCode_break() ) {
  426.             SRelLoc rl(loc, (*cbr)->GetLoc(), m_Scope);
  427.             CRef<CSeq_loc> rel_loc = rl.Resolve(m_Scope);
  428.             range += rel_loc->GetTotalRange();
  429.         }
  431.         // allowing a partial codon at the end
  432.         TSeqPos codon_length = range.GetLength();
  433.         if ( (codon_length == 0 || codon_length == 1)  && 
  434.             range.GetTo() == len - 1 ) {
  435.             ragged = 0;
  436.         }
  437.     }
  438.     return ragged;
  439. }
  442. string CValidError_feat::MapToNTCoords
  443. (const CSeq_feat& feat,
  444.  const CSeq_loc& product,
  445.  TSeqPos pos)
  446. {
  447.     string result;
  449.     CSeq_point pnt;
  450.     pnt.SetPoint(pos);
  451.     pnt.SetStrand( GetStrand(product, m_Scope) );
  453.     try {
  454.         pnt.SetId().Assign(GetId(product, m_Scope));
  455.     } catch (CNotUnique) {}
  457.     CSeq_loc tmp;
  458.     tmp.SetPnt(pnt);
  459.     CRef<CSeq_loc> loc = ProductToSource(feat, tmp, 0, m_Scope);
  460.     
  461.     loc->GetLabel(&result);
  463.     return result;
  464. }
  467. void CValidError_feat::ValidateFeatPartialness(const CSeq_feat& feat)
  468. {
  469.     unsigned int  partial_prod = eSeqlocPartial_Complete, 
  470.         partial_loc = eSeqlocPartial_Complete;
  471.     static string parterr[2] = { "PartialProduct", "PartialLocation" };
  472.     static string parterrs[4] = {
  473.         "Start does not include first/last residue of sequence",
  474.         "Stop does not include first/last residue of sequence",
  475.         "Internal partial intervals do not include first/last residue of sequence",
  476.         "Improper use of partial (greater than or less than)"
  477.     };
  479.     partial_loc  = SeqLocPartialCheck(feat.GetLocation(), m_Scope );
  480.     if (feat.CanGetProduct ()) {
  481.         partial_prod = SeqLocPartialCheck(feat.GetProduct (), m_Scope );
  482.     }
  483.     
  484.     if ( (partial_loc  != eSeqlocPartial_Complete)  ||
  485.          (partial_prod != eSeqlocPartial_Complete)  ||   
  486.          (feat.CanGetPartial()  &&  feat.GetPartial() == true) ) {
  488.         // a feature on a partial sequence should be partial -- it often isn't
  489.         if ( (!feat.CanGetPartial()  ||  !feat.GetPartial()) &&
  490.             partial_loc != eSeqlocPartial_Complete  &&
  491.             feat.GetLocation ().Which () == CSeq_loc::e_Whole ) {
  492.             PostErr(eDiag_Info, eErr_SEQ_FEAT_PartialProblem,
  493.                 "On partial Bioseq, SeqFeat.partial should be TRUE", feat);
  494.         }
  495.         // a partial feature, with complete location, but partial product
  496.         else if ( (feat.CanGetPartial()  &&  feat.GetPartial())  &&
  497.             partial_loc == eSeqlocPartial_Complete  &&
  498.             feat.CanGetProduct () &&
  499.             feat.GetProduct ().Which () == CSeq_loc::e_Whole  &&
  500.             partial_prod != eSeqlocPartial_Complete ) {
  501.             PostErr(eDiag_Warning, eErr_SEQ_FEAT_PartialProblem,
  502.                 "When SeqFeat.product is a partial Bioseq, SeqFeat.location "
  503.                 "should also be partial", feat);
  504.         }
  505.         // gene on segmented set is now 'order', should also be partial
  506.         else if ( feat.GetData ().IsGene ()  &&
  507.             !feat.CanGetProduct ()  &&
  508.             partial_loc == eSeqlocPartial_Internal ) {
  509.             PostErr(eDiag_Warning, eErr_SEQ_FEAT_PartialProblem,
  510.                 "Gene of 'order' with otherwise complete location should "
  511.                 "have partial flag set", feat);
  512.         }
  513.         // inconsistent combination of partial/complete product,location,partial flag - part 1
  514.         else if ( partial_prod == eSeqlocPartial_Complete  &&
  515.                   feat.CanGetProduct() ) {
  516.             // if not local bioseq product, lower severity
  517.             EDiagSev sev = eDiag_Warning;
  518.             if ( IsOneBioseq(feat.GetProduct(), m_Scope) ) {
  519.                 const CSeq_id& prod_id = GetId(feat.GetProduct());
  520.                 CBioseq_Handle prod =
  521.                     m_Scope->GetBioseqHandleFromTSE(prod_id, m_Imp.GetTSE());
  522.                 if ( !prod ) {
  523.                     sev = eDiag_Info;
  524.                 }
  525.             }
  526.                         
  527.             string str("Inconsistent: Product= complete, Location= ");
  528.             if ( partial_loc != eSeqlocPartial_Complete ) {
  529.                 str += "partial, ";
  530.             } else {
  531.                 str += "complete, ";
  532.             }
  533.             str += "Feature.partial= ";
  534.             if ( feat.CanGetPartial()  &&  feat.GetPartial() ) {
  535.                 str += "TRUE";
  536.             } else {
  537.                 str += "FALSE";
  538.             }
  539.             PostErr(sev, eErr_SEQ_FEAT_PartialsInconsistent, str, feat);
  540.         }
  541.         // inconsistent combination of partial/complete product,location,partial flag - part 2
  542.         else if ( partial_loc == eSeqlocPartial_Complete  ||
  543.                   (feat.CanGetPartial()  &&  !feat.GetPartial()) ) {
  544.             string str("Inconsistent: ");
  545.             if ( feat.CanGetProduct() ) {
  546.                 str += "Product= ";
  547.                 if ( partial_prod != eSeqlocPartial_Complete ) {
  548.                     str += "partial, ";
  549.                 } else {
  550.                     str += "complete, ";
  551.                 }
  552.                 str += "Location= ";
  553.                 if ( partial_loc != eSeqlocPartial_Complete ) {
  554.                     str += "partial, ";
  555.                 } else {
  556.                     str += "complete, ";
  557.                 }
  558.                 str += "Feature.partial= ";
  559.                 if ( feat.CanGetPartial()  &&  feat.GetPartial() ) {
  560.                     str += "TRUE";
  561.                 } else {
  562.                     str += "FALSE";
  563.                 }
  564.             }
  565.             PostErr(eDiag_Warning, eErr_SEQ_FEAT_PartialsInconsistent, str, feat);
  566.         }
  567.         // 5' or 3' partial location giving unclassified partial product
  568.         else if ( (partial_loc & eSeqlocPartial_Start  ||
  569.                    partial_loc & eSeqlocPartial_Stop)  &&
  570.                    partial_prod & eSeqlocPartial_Other &&
  571.                    feat.CanGetPartial()  &&  feat.GetPartial() ) {
  572.             PostErr(eDiag_Warning, eErr_SEQ_FEAT_PartialProblem,
  573.                 "5' or 3' partial location should not have unclassified "
  574.                 "partial location", feat);
  575.         }
  576.         
  577.         // may have other error bits set as well 
  578.         unsigned int partials[2] = { partial_prod, partial_loc };
  579.         for ( int i = 0; i < 2; ++i ) {
  580.             unsigned int errtype = eSeqlocPartial_Nostart;
  582.             for ( int j = 0; j < 4; ++j ) {
  583.                 if (partials[i] & errtype) {
  584.                     if ( i == 1  &&  j < 2  &&  IsCDDFeat(feat) ) {
  585.                         // supress warning
  586.                     } else if ( i == 1  &&  j < 2  &&
  587.                         IsPartialAtSpliceSite(feat.GetLocation(), errtype) ) {
  588.                         PostErr(eDiag_Info, eErr_SEQ_FEAT_PartialProblem,
  589.                             parterr[i] + ": " + parterrs[j] + 
  590.                             " (but is at consensus splice site)", feat);
  591.                     } else if ( i == 1  &&  j < 2  &&
  592.                         (feat.GetData().Which() == CSeqFeatData::e_Gene  ||
  593.                         feat.GetData().GetSubtype() == CSeqFeatData::eSubtype_mRNA) &&
  594.                          IsSameAsCDS(feat) ) {
  595.                         PostErr(eDiag_Info, eErr_SEQ_FEAT_PartialProblem,
  596.                             parterr[i] + ": " + parterrs[j], feat);
  597.                     } else if (feat.GetData().Which() == CSeqFeatData::e_Cdregion && j == 0) {
  598.                         PostErr (eDiag_Warning, eErr_SEQ_FEAT_PartialProblem,
  599.                             parterr[i] + 
  600.                             ": 5' partial is not at start AND is not at consensus splice site",
  601.                             feat); 
  602.                     } else if (feat.GetData().Which() == CSeqFeatData::e_Cdregion && j == 1) {
  603.                         PostErr (eDiag_Warning, eErr_SEQ_FEAT_PartialProblem,
  604.                             parterr[i] + 
  605.                             ": 3' partial is not at stop AND is not at consensus splice site",
  606.                             feat);
  607.                     } else {
  608.                         PostErr (eDiag_Warning, eErr_SEQ_FEAT_PartialProblem,
  609.                             parterr[i] + ": " + parterrs[j], feat);
  610.                     }
  611.                 }
  612.                 errtype <<= 1;
  613.             }
  614.         }
  615.     }
  616. }
  619. void CValidError_feat::ValidateGene(const CGene_ref& gene, const CSeq_feat& feat)
  620. {
  621.     ++m_NumGenes;
  623.     if ( (gene.CanGetLocus()      &&  gene.GetLocus().empty())   &&
  624.          (gene.CanGetAllele()     &&  gene.GetAllele().empty())  &&
  625.          (gene.CanGetDesc()       &&  gene.GetDesc().empty())    &&
  626.          (gene.CanGetMaploc()     &&  gene.GetMaploc().empty())  &&
  627.          (gene.CanGetDb()         &&  gene.GetDb().empty())      &&
  628.          (gene.CanGetSyn()        &&  gene.GetSyn().empty())     &&
  629.          (gene.CanGetLocus_tag()  &&  gene.GetLocus_tag().empty()) ) {
  630.         PostErr(eDiag_Warning, eErr_SEQ_FEAT_GeneRefHasNoData,
  631.             "There is a gene feature where all fields are empty", feat);
  632.     }
  633.     if ( gene.CanGetLocus()  &&  !gene.GetLocus().empty() ) {
  634.         ITERATE (string, it, gene.GetLocus() ) {
  635.             if ( isspace(*it) != 0 ) {
  636.                 PostErr(eDiag_Warning, eErr_SEQ_FEAT_LocusTagProblem,
  637.                     "Gene locus_tag '" + gene.GetLocus() + 
  638.                     "' should be a single word without any spaces", feat);
  639.                 break;
  640.             }
  641.         }         
  643.     }
  644.     if ( gene.CanGetDb () ) {
  645.         m_Imp.ValidateDbxref(gene.GetDb(), feat);
  646.     }
  647. }
  650. void CValidError_feat::ValidateCdregion (
  651.     const CCdregion& cdregion, 
  652.     const CSeq_feat& feat
  653. ) 
  654. {
  655.     ITERATE( CSeq_feat::TQual, qual, feat.GetQual () ) {
  656.         if ( (**qual).GetQual() == "codon" ) {
  657.             PostErr(eDiag_Warning, eErr_SEQ_FEAT_WrongQualOnImpFeat,
  658.                 "Use the proper genetic code, if available, "
  659.                 "or set transl_excepts on specific codons", feat);
  660.             break;
  661.         }
  662.     }
  664.     bool pseudo = (feat.CanGetPseudo()  &&  feat.GetPseudo())  ||
  665.         IsOverlappingGenePseudo(feat);
  666.     bool conflict = cdregion.CanGetConflict()  &&  cdregion.GetConflict();
  667.     if ( !pseudo  &&  !conflict ) {
  668.         ValidateCdTrans(feat);
  669.         ValidateSplice(feat, false);
  670.         ValidateCdsProductId(feat);
  671.     } else if ( conflict ) {
  672.         ValidateCdConflict(cdregion, feat);
  673.     }
  675.     ITERATE( CCdregion::TCode_break, codebreak, cdregion.GetCode_break() ) {
  676.         ECompare comp = sequence::Compare((**codebreak).GetLoc (),
  677.             feat.GetLocation (), m_Scope );
  678.         if ( (comp != eContained) && (comp != eSame))
  679.             PostErr (eDiag_Error, eErr_SEQ_FEAT_Range, 
  680.                 "Code-break location not in coding region", feat);
  681.     }
  683.     if ( cdregion.CanGetOrf()  &&  cdregion.GetOrf ()  &&
  684.          feat.CanGetProduct () ) {
  685.         PostErr (eDiag_Warning, eErr_SEQ_FEAT_OrfCdsHasProduct,
  686.             "An ORF coding region should not have a product", feat);
  687.     }
  689.     if ( pseudo && feat.CanGetProduct () ) {
  690.         PostErr (eDiag_Warning, eErr_SEQ_FEAT_PsuedoCdsHasProduct,
  691.             "A pseudo coding region should not have a product", feat);
  692.     }
  693.     
  694.     CBioseq_Handle bsh = m_Scope->GetBioseqHandle(feat.GetLocation ());
  695.     if ( bsh ) {
  696.         CSeqdesc_CI diter (bsh, CSeqdesc::e_Source);
  697.         if ( diter ) {
  698.             const CBioSource& src = diter->GetSource();
  699.             
  700.             int biopgencode = src.GetGenCode();
  701.             
  702.             if (cdregion.CanGetCode ()) {
  703.                 int cdsgencode = cdregion.GetCode().GetId();
  704.                 
  705.                 if ( biopgencode != cdsgencode ) {
  706.                     int genome = 0;
  707.                     
  708.                     if ( src.CanGetGenome() ) {
  709.                         genome = src.GetGenome();
  710.                     }
  711.                     
  712.                     if ( IsPlastid(genome) ) {
  713.                         PostErr (eDiag_Warning, eErr_SEQ_FEAT_GenCodeMismatch,
  714.                             "Genetic code conflict between CDS (code " +
  715.                             NStr::IntToString (cdsgencode) +
  716.                             ") and BioSource.genome biological context (" +
  717.                             s_PlastidTxt [genome] + ") (uses code 11)", feat);
  718.                     } else {
  719.                         PostErr (eDiag_Warning, eErr_SEQ_FEAT_GenCodeMismatch,
  720.                             "Genetic code conflict between CDS (code " +
  721.                             NStr::IntToString (cdsgencode) +
  722.                             ") and BioSource (code " +
  723.                             NStr::IntToString (biopgencode) + ")", feat);
  724.                     }
  725.                 }
  726.             }
  727.         }
  728.     }
  730.     ValidateBothStrands(feat);
  731.     ValidateBadGeneOverlap(feat);
  732.     ValidateBadMRNAOverlap(feat);
  733.     ValidateCommonCDSProduct(feat);
  734.     ValidateCDSPartial(feat);
  735. }
  738. // non-pseudo CDS must have product
  739. void CValidError_feat::ValidateCdsProductId(const CSeq_feat& feat)
  740. {
  741.     // bail if product exists
  742.     if ( feat.CanGetProduct() ) {
  743.         return;
  744.     }
  745.     
  746.     // bail if location has just stop
  747.     if ( feat.CanGetLocation() ) {
  748.         const CSeq_loc& loc = feat.GetLocation();
  749.         if ( loc.IsPartialLeft()  &&  !loc.IsPartialRight() ) {
  750.             if ( GetLength(loc, m_Scope) <= 5 ) {
  751.                 return;
  752.             }
  753.         }
  754.     }
  755.     
  756.     // supress in case of the appropriate exception
  757.     if ( feat.CanGetExcept()  &&  feat.CanGetExcept_text()  &&
  758.         !IsBlankString(feat.GetExcept_text()) ) {
  759.         if ( NStr::Find(feat.GetExcept_text(),
  760.                         "rearrangement required for product") != NPOS ) {
  761.             return;
  762.         }
  763.     }
  764.     
  765.     PostErr(eDiag_Warning, eErr_SEQ_FEAT_MissingCDSproduct,
  766.         "Expected CDS product absent", feat);
  767. }
  770. void CValidError_feat::ValidateCdConflict
  771. (const CCdregion& cdregion,
  772.  const CSeq_feat& feat)
  773. {
  774.     CBioseq_Handle nuc  = m_Scope->GetBioseqHandle(feat.GetLocation());
  775.     CBioseq_Handle prot = m_Scope->GetBioseqHandle(feat.GetProduct());
  776.     
  777.     // translate the coding region
  778.     string transl_prot;
  779.     try {
  780.         CCdregion_translate::TranslateCdregion(
  781.             transl_prot, 
  782.             nuc, 
  783.             feat.GetLocation(), 
  784.             cdregion,
  785.             false,   // do not include stop codons
  786.             false);  // do not remove trailing X/B/Z
  787.     } catch ( const runtime_error& ) {
  788.     }
  790.     CSeqVector prot_vec = prot.GetSeqVector(CBioseq_Handle::eCoding_Iupac);
  791.     string prot_seq;
  792.     prot_vec.GetSeqData(0, prot_vec.size(), prot_seq);
  794.     if ( transl_prot.empty()  ||  prot_seq.empty()  ||  transl_prot == prot_seq ) {
  795.         PostErr(eDiag_Error, eErr_SEQ_FEAT_BadConflictFlag,
  796.             "Coding region conflict flag should not be set", feat);
  797.     } else {
  798.         PostErr(eDiag_Warning, eErr_SEQ_FEAT_ConflictFlagSet,
  799.             "Coding region conflict flag is set", feat);
  800.     }
  801. }
  804. void CValidError_feat::ValidateSplice(const CSeq_feat& feat, bool check_all)
  805. {
  806.     // !!! suppress if NCBISubValidate
  807.     //if (GetAppProperty ("NcbiSubutilValidation") != NULL)
  808.     //    return;
  810.     // specific biological exceptions suppress check
  811.     if ( feat.CanGetExcept()  &&  feat.GetExcept()  &&
  812.          feat.CanGetExcept_text() ) {
  813.         if ( SuppressCheck(feat.GetExcept_text()) ) {
  814.             return;
  815.         }
  816.     }
  817.         
  818.     size_t num_of_parts = 0;
  819.     ENa_strand  strand = eNa_strand_unknown;
  821.     // !!! The C version treated seq_loc equiv as one whereas the iterator
  822.     // treats it as many. 
  823.     const CSeq_loc& location = feat.GetLocation ();
  825.     for (CSeq_loc_CI citer(location); citer; ++citer) {
  826.         ++num_of_parts;
  827.         if ( num_of_parts == 1 ) {  // first part
  828.             strand = citer.GetStrand();
  829.         } else {
  830.             if ( strand != citer.GetStrand() ) {
  831.                 return;         //bail on mixed strand
  832.             }
  833.         }
  834.     }
  836.     if ( num_of_parts == 0 ) {
  837.         return;
  838.     }
  839.     if ( !check_all  &&  num_of_parts == 1 ) {
  840.         return;
  841.     }
  842.     
  843.     bool partial_first = location.IsPartialLeft();
  844.     bool partial_last = location.IsPartialRight();
  847.     size_t counter = 0;
  848.     const CSeq_id* last_id = 0;
  849.     CBioseq_Handle bsh;
  850.     size_t seq_len = 0;
  851.     CSeqVector seq_vec;
  852.     string label;
  854.     for (CSeq_loc_CI citer(location); citer; ++citer) {
  855.         ++counter;
  857.         const CSeq_id& seq_id = citer.GetSeq_id();
  858.         if ( last_id == 0  ||  !last_id->Match(seq_id) ) {
  859.             bsh = m_Scope->GetBioseqHandle(seq_id);
  860.             if ( !bsh ) {
  861.                 break;
  862.             }
  863.             seq_vec = 
  864.                 bsh.GetSeqVector(CBioseq_Handle::eCoding_Iupac,
  865.                                  citer.GetStrand());
  866.             seq_len = seq_vec.size();
  868.             // get the label. if m_SuppressContext flag in true, 
  869.             // get the worst label.
  870.             const CBioseq& bsq = *bsh.GetCompleteBioseq();
  871.             bsq.GetLabel(&label, CBioseq::eContent, m_Imp.IsSuppressContext());
  873.             last_id = &seq_id;
  874.         }
  876.         TSeqPos acceptor = citer.GetRange().GetFrom();
  877.         TSeqPos donor = citer.GetRange().GetTo();
  879.         TSeqPos start = acceptor;
  880.         TSeqPos stop = donor;
  882.         if ( citer.GetStrand() == eNa_strand_minus ) {
  883.             swap(acceptor, donor);
  884.             stop = seq_len - donor - 1;
  885.             start = seq_len - acceptor - 1;
  886.         }
  888.         // set severity level
  889.         // genomic product set or NT_ contig always relaxes to SEV_WARNING
  890.         EDiagSev sev = eDiag_Warning;
  891.         if ( m_Imp.IsSpliceErr()                   &&
  892.              !(m_Imp.IsGPS() || m_Imp.IsRefSeq())  &&
  893.              !check_all ) {
  894.             sev = eDiag_Error;
  895.         }
  897.         // check donor on all but last exon and on sequence
  898.         if ( ((check_all && !partial_last)  ||  counter < num_of_parts)  &&
  899.              (stop < seq_len - 2) ) {
  900.             try {
  901.                 CSeqVector::TResidue res1 = seq_vec[stop + 1];    
  902.                 CSeqVector::TResidue res2 = seq_vec[stop + 2];
  904.                 if ( IsResidue(res1)  &&  IsResidue(res2) ) {
  905.                     if ( (res1 != 'G')  || (res2 != 'T' ) ) {
  906.                         string msg;
  907.                         if ( (res1 == 'G')  && (res2 == 'C' ) ) { // GC minor splice site
  908.                             sev = eDiag_Info;
  909.                             msg = "Rare splice donor consensus (GC) found instead of "
  910.                                 "(GT) after exon ending at position " +
  911.                                 NStr::IntToString(donor + 1) + " of " + label;
  912.                         } else {
  913.                             msg = "Splice donor consensus (GT) not found after exon"
  914.                                 " ending at position " + 
  915.                                 NStr::IntToString(donor + 1) + " of " + label;
  916.                         }
  917.                         PostErr(sev, eErr_SEQ_FEAT_NotSpliceConsensus, msg, feat);
  918.                     }
  919.                 }
  920.             } catch ( exception& ) {
  921.                 break;
  922.             }
  923.         }
  925.         if ( ((check_all && !partial_first)  ||  counter != 1)  &&
  926.              (start > 1) ) {
  927.             try {
  928.                 CSeqVector::TResidue res1 = seq_vec[start - 2];
  929.                 CSeqVector::TResidue res2 = seq_vec[start - 1];
  930.                 
  931.                 if ( IsResidue(res1)  &&  IsResidue(res2) ) {
  932.                     if ( (res1 != 'A')  ||  (res2 != 'G') ) {
  933.                         PostErr(sev, eErr_SEQ_FEAT_NotSpliceConsensus,
  934.                             "Splice acceptor consensus (AG) not found before "
  935.                             "exon starting at position " + 
  936.                             NStr::IntToString(acceptor + 1) + " of " + label, feat);
  937.                     }
  938.                 }
  939.             } catch ( exception& ) {
  940.             }
  941.         }
  942.     } // end of for loop
  943. }
  946. void CValidError_feat::ValidateProt(const CProt_ref& prot, const CSerialObject& obj) 
  947. {
  948.     CProt_ref::EProcessed processed = CProt_ref::eProcessed_not_set;
  950.     if ( prot.CanGetProcessed() ) {
  951.         processed = prot.GetProcessed();
  952.     }
  954.     bool empty = true;
  955.     if ( processed != CProt_ref::eProcessed_signal_peptide  &&
  956.          processed != CProt_ref::eProcessed_transit_peptide ) {
  957.         if ( prot.CanGetName()  &&
  958.             (!prot.GetName().empty()  ||  !prot.GetName().front().empty()) ) {
  959.             empty = false;
  960.         }
  961.         if ( prot.CanGetDesc()  &&  !prot.GetDesc().empty() ) {
  962.             empty = false;
  963.         }
  964.         if ( prot.CanGetEc()  &&  !prot.GetEc().empty() ) {
  965.             empty = false;
  966.         }
  967.         if ( prot.CanGetActivity()  &&  !prot.GetActivity().empty() ) {
  968.             empty = false;
  969.         }
  970.         if ( prot.CanGetDb()  &&  !prot.GetDb().empty() ) {
  971.             empty = false;
  972.         }
  974.         if ( empty ) {
  975.             PostErr(eDiag_Warning, eErr_SEQ_FEAT_ProtRefHasNoData,
  976.                 "There is a protein feature where all fields are empty", obj);
  977.         }
  978.     }
  979.     if ( prot.CanGetDb () ) {
  980.         m_Imp.ValidateDbxref(prot.GetDb(), obj);
  981.     }
  982. }
  985. void CValidError_feat::ValidateRna(const CRNA_ref& rna, const CSeq_feat& feat) 
  986. {
  987.     const CRNA_ref::EType& rna_type = rna.GetType ();
  989.     if ( rna_type == CRNA_ref::eType_mRNA ) {
  990.         bool pseudo = (feat.CanGetPseudo()  &&  feat.GetPseudo())  ||  IsOverlappingGenePseudo(feat);
  991.         
  992.         if ( !pseudo ) {
  993.             ValidateMrnaTrans(feat);      /* transcription check */
  994.             ValidateSplice(feat, false);
  995.         }
  996.         ValidateBothStrands(feat);
  997.         ValidateBadGeneOverlap(feat);
  998.         ValidateCommonMRNAProduct(feat);
  999.     }
  1001.     if ( rna.CanGetExt()  &&
  1002.          rna.GetExt().Which() == CRNA_ref::C_Ext::e_TRNA ) {
  1003.         const CTrna_ext& trna = rna.GetExt ().GetTRNA ();
  1004.         if ( trna.CanGetAnticodon () ) {
  1005.             ECompare comp = sequence::Compare(trna.GetAnticodon(), 
  1006.                                               feat.GetLocation());
  1007.             if ( comp != eContained  &&  comp != eSame ) {
  1008.                 PostErr (eDiag_Error, eErr_SEQ_FEAT_Range,
  1009.                     "Anticodon location not in tRNA", feat);
  1010.             }
  1011.             if ( GetLength( trna.GetAnticodon (), m_Scope ) != 3 ) {
  1012.                 PostErr (eDiag_Warning, eErr_SEQ_FEAT_Range,
  1013.                     "Anticodon is not 3 bases in length", feat);
  1014.             }
  1015.         }
  1016.         ValidateTrnaCodons(trna, feat);
  1017.     }
  1019.     if ( rna_type == CRNA_ref::eType_tRNA ) {
  1020.         ITERATE ( CSeq_feat::TQual, gbqual, feat.GetQual () ) {
  1021.             if ( NStr::CompareNocase((**gbqual).GetVal (), "anticodon") == 0 ) {
  1022.                 PostErr (eDiag_Error, eErr_SEQ_FEAT_InvalidQualifierValue,
  1023.                     "Unparsed anticodon qualifier in tRNA", feat);
  1024.                 break;
  1025.             }
  1026.         }
  1027.         /* tRNA with string extension */
  1028.         if ( rna.CanGetExt()  &&  
  1029.              rna.GetExt().Which () == CRNA_ref::C_Ext::e_Name ) {
  1030.             PostErr (eDiag_Error, eErr_SEQ_FEAT_InvalidQualifierValue,
  1031.                 "Unparsed product qualifier in tRNA", feat);
  1032.         }
  1033.     }
  1035.     if ( rna_type == CRNA_ref::eType_unknown ) {
  1036.         PostErr(eDiag_Warning, eErr_SEQ_FEAT_RNAtype0,
  1037.             "RNA type 0 (unknown) not supported", feat);
  1038.     }
  1040.     if ( feat.CanGetProduct() ) {
  1041.         ValidateRnaProductType(rna, feat);
  1042.     }
  1043. }
  1046. void CValidError_feat::ValidateRnaProductType
  1047. (const CRNA_ref& rna,
  1048.  const CSeq_feat& feat)
  1049. {
  1050.     CBioseq_Handle bsh = m_Scope->GetBioseqHandle(feat.GetProduct());
  1051.     if ( !bsh ) {
  1052.         return;
  1053.     }
  1054.     CSeqdesc_CI di(bsh, CSeqdesc::e_Molinfo);
  1055.     if ( !di ) {
  1056.         return;
  1057.     }
  1058.     const CMolInfo& mol_info = di->GetMolinfo();
  1059.     if ( !mol_info.CanGetBiomol() ) {
  1060.         return;
  1061.     }
  1062.     int biomol = mol_info.GetBiomol();
  1063.     
  1064.     switch ( rna.GetType() ) {
  1066.     case CRNA_ref::eType_mRNA:
  1067.         if ( biomol == CMolInfo::eBiomol_mRNA ) {
  1068.             return;
  1069.         }        
  1070.         break;
  1072.     case CRNA_ref::eType_tRNA:
  1073.         if ( biomol == CMolInfo::eBiomol_tRNA ) {
  1074.             return;
  1075.         }
  1076.         break;
  1078.     case CRNA_ref::eType_rRNA:
  1079.         if ( biomol == CMolInfo::eBiomol_rRNA ) {
  1080.             return;
  1081.         }
  1082.         break;
  1084.     default:
  1085.         return;
  1086.     }
  1088.     PostErr(eDiag_Error, eErr_SEQ_FEAT_RnaProductMismatch,
  1089.         "Type of RNA does not match MolInfo of product Bioseq", feat);
  1090. }
  1093. int s_LegalNcbieaaValues[] = { 42, 65, 66, 67, 68, 69, 70, 71, 72, 73,
  1094.                                75, 76, 77, 78, 80, 81, 82, 83, 84, 85,
  1095.                                86, 87, 88, 89, 90 };
  1097. void CValidError_feat::ValidateTrnaCodons(const CTrna_ext& trna, const CSeq_feat& feat)
  1098. {
  1099.     // Make sure AA coding is ncbieaa.
  1100.     if ( trna.GetAa().Which() != CTrna_ext::C_Aa::e_Ncbieaa ) {
  1101.         PostErr (eDiag_Error, eErr_SEQ_FEAT_TrnaCodonWrong,
  1102.             "tRNA AA coding does not match ncbieaa", feat);
  1103.         return;
  1104.     }
  1106.     unsigned char aa = trna.GetAa().GetNcbieaa();
  1108.     // make sure the amino acid is valid
  1109.     bool found = false;
  1110.     for ( int i = 0; i < 25; ++i ) {
  1111.         if ( aa == s_LegalNcbieaaValues[i] ) {
  1112.             found = true;
  1113.             break;
  1114.         }
  1115.     }
  1116.     if ( !found ) {
  1117.         PostErr(eDiag_Error, eErr_SEQ_FEAT_BadTrnaAA, 
  1118.             "Invalid tRNA amino acid (" + NStr::IntToString(aa) + ")", feat);
  1119.         return;
  1120.     }
  1122.     // Retrive the Genetic code id for the tRNA
  1123.     int gcode = 0;
  1124.     CBioseq_Handle bsh = m_Scope->GetBioseqHandle(feat.GetLocation());
  1125.     if ( !bsh ) {
  1126.         gcode = 1;
  1127.     } else {
  1128.         // need only the closest biosoure.
  1129.         CSeqdesc_CI diter(bsh, CSeqdesc::e_Source);
  1130.         if ( diter ) {
  1131.             gcode = diter->GetSource().GetGenCode();
  1132.         }
  1133.     }
  1134.     
  1135.     const string& ncbieaa = CGen_code_table::GetNcbieaa(gcode);
  1136.     if ( ncbieaa.length() != 64 ) {
  1137.         return;
  1138.     }
  1139.     
  1140.     EDiagSev sev = (aa == 'U') ? eDiag_Warning : eDiag_Error;
  1142.     ITERATE( CTrna_ext::TCodon, iter, trna.GetCodon() ) {
  1143.         // test that codon value is in range 0 - 63
  1144.         if ( *iter < 0  ||  *iter > 63 ) {
  1145.             PostErr(sev, eErr_SEQ_FEAT_TrnaCodonWrong,
  1146.                 "tRNA codon value (" + NStr::IntToString(*iter) + 
  1147.                 ") out of range", feat);
  1148.             continue;
  1149.         }
  1151.         unsigned char taa = ncbieaa[*iter];
  1152.         if ( taa != aa ) {
  1153.             PostErr(sev, eErr_SEQ_FEAT_TrnaCodonWrong,
  1154.                 "tRNA codon does not match genetic code", feat);
  1155.         }
  1156.     }
  1157. }
  1160. void CValidError_feat::ValidateImp(const CImp_feat& imp, const CSeq_feat& feat)
  1161. {
  1162.     CSeqFeatData::ESubtype subtype = feat.GetData().GetSubtype();
  1163.     string key = imp.GetKey();
  1165.     switch ( subtype ) {
  1166.     case CSeqFeatData::eSubtype_exon:
  1167.         if ( m_Imp.IsValidateExons() ) {
  1168.             ValidateSplice(feat, true);
  1169.         }
  1170.         break;
  1172.     case CSeqFeatData::eSubtype_bad:
  1173.         PostErr(eDiag_Warning, eErr_SEQ_FEAT_UnknownImpFeatKey, 
  1174.             "Unknown feature key " + key, feat);
  1175.         break;
  1177.     case CSeqFeatData::eSubtype_virion:
  1178.     case CSeqFeatData::eSubtype_mutation:
  1179.     case CSeqFeatData::eSubtype_allele:
  1180.         PostErr(eDiag_Error, eErr_SEQ_FEAT_UnknownImpFeatKey,
  1181.             "Feature key " + key + " is no longer legal", feat);
  1182.         break;
  1184.     case CSeqFeatData::eSubtype_polyA_site:
  1185.         {
  1186.             CSeq_loc::TRange range = feat.GetLocation().GetTotalRange();
  1187.             if ( range.GetFrom() != range.GetTo() ) {
  1188.                 PostErr(eDiag_Warning, eErr_SEQ_FEAT_PolyAsiteNotPoint,
  1189.                     "PolyA_site should be a single point", feat);
  1190.             }
  1191.         }
  1192.         break;
  1194.     case CSeqFeatData::eSubtype_mat_peptide:
  1195.     case CSeqFeatData::eSubtype_sig_peptide:
  1196.     case CSeqFeatData::eSubtype_transit_peptide:
  1197.         PostErr(eDiag_Warning, eErr_SEQ_FEAT_InvalidForType,
  1198.             "Peptide processing feature should be converted to the "
  1199.             "appropriate protein feature subtype", feat);
  1200.         ValidatePeptideOnCodonBoundry(feat, key);
  1201.         break;
  1202.         
  1203.     case CSeqFeatData::eSubtype_mRNA:
  1204.     case CSeqFeatData::eSubtype_tRNA:
  1205.     case CSeqFeatData::eSubtype_rRNA:
  1206.     case CSeqFeatData::eSubtype_snRNA:
  1207.     case CSeqFeatData::eSubtype_scRNA:
  1208.     case CSeqFeatData::eSubtype_snoRNA:
  1209.     case CSeqFeatData::eSubtype_misc_RNA:
  1210.     case CSeqFeatData::eSubtype_precursor_RNA:
  1211.     // !!! what about other RNA types (preRNA, otherRNA)?
  1212.         PostErr(eDiag_Error, eErr_SEQ_FEAT_InvalidForType,
  1213.               "RNA feature should be converted to the appropriate RNA feature "
  1214.               "subtype, location should be converted manually", feat);
  1215.         break;
  1217.     case CSeqFeatData::eSubtype_Imp_CDS:
  1218.         {
  1219.             // impfeat CDS must be pseudo; fail if not
  1220.             bool pseudo = (feat.CanGetPseudo()  &&  feat.GetPseudo())  ||
  1221.                           IsOverlappingGenePseudo(feat);
  1222.             if ( !pseudo ) {
  1223.                 PostErr(eDiag_Info, eErr_SEQ_FEAT_ImpCDSnotPseudo,
  1224.                     "ImpFeat CDS should be pseudo", feat);
  1225.             }
  1227.             ITERATE( CSeq_feat::TQual, gbqual, feat.GetQual() ) {
  1228.                 if ( NStr::CompareNocase( (*gbqual)->GetQual(), "translation") == 0 ) {
  1229.                     PostErr(eDiag_Error, eErr_SEQ_FEAT_ImpCDShasTranslation,
  1230.                         "ImpFeat CDS with /translation found", feat);
  1231.                 }
  1232.             }
  1233.         }
  1234.         break;
  1236.     default:
  1237.         break;
  1238.     }// end of switch statement  
  1239.     
  1240.     // validate the feature's location
  1241.     if ( imp.CanGetLoc() ) {
  1242.         const string& imp_loc = imp.GetLoc();
  1243.         if ( imp_loc.find("one-of") != string::npos ) {
  1244.             PostErr(eDiag_Error, eErr_SEQ_FEAT_ImpFeatBadLoc,
  1245.                 "ImpFeat loc " + imp_loc + 
  1246.                 " has obsolete 'one-of' text for feature " + key, feat);
  1247.         } else if ( feat.GetLocation().IsInt() ) {
  1248.             const CSeq_interval& seq_int = feat.GetLocation().GetInt();
  1249.             string temp_loc = NStr::IntToString(seq_int.GetFrom() + 1) +
  1250.                 ".." + NStr::IntToString(seq_int.GetTo() + 1);
  1251.             if ( imp_loc != temp_loc ) {
  1252.                 PostErr(eDiag_Error, eErr_SEQ_FEAT_ImpFeatBadLoc,
  1253.                     "ImpFeat loc " + imp_loc + " does not equal feature location " +
  1254.                     temp_loc + "for feature " + key, feat);
  1255.             }
  1256.         }
  1257.     }
  1259.     if ( feat.CanGetQual() ) {
  1260.         ValidateImpGbquals(imp, feat);
  1262.         // Make sure a feature has its mandatory qualifiers
  1263.         ITERATE( CFeatQualAssoc::TGBQualTypeVec,
  1264.                  required,
  1265.                  CFeatQualAssoc::GetMandatoryGbquals(subtype) ) {
  1266.             bool found = false;
  1267.             ITERATE( CSeq_feat::TQual, qual, feat.GetQual() ) {
  1268.                 if ( CGbqualType::GetType(**qual) == *required ) {
  1269.                     found = true;
  1270.                     break;
  1271.                 }
  1272.             }
  1273.             if ( !found ) {
  1274.                 PostErr(eDiag_Warning, eErr_SEQ_FEAT_MissingQualOnImpFeat,
  1275.                     "Missing qualifier " + CGbqualType::GetString(*required) +
  1276.                     " for feature " + key, feat);
  1277.             }
  1278.         }
  1279.     }
  1280. }
  1283. void CValidError_feat::ValidateImpGbquals
  1284. (const CImp_feat& imp,
  1285.  const CSeq_feat& feat)
  1286. {
  1287.     CSeqFeatData::ESubtype ftype = feat.GetData().GetSubtype();
  1288.     const string& key = imp.GetKey();
  1290.     ITERATE( CSeq_feat::TQual, qual, feat.GetQual() ) {
  1291.         const string& qual_str = (*qual)->GetQual();
  1293.         if ( qual_str == "gsdb_id" ) {
  1294.             continue;
  1295.         }
  1297.         CGbqualType::EType gbqual = CGbqualType::GetType(qual_str);
  1298.         
  1299.         if ( gbqual == CGbqualType::e_Bad ) {
  1300.             if ( !qual_str.empty() ) {
  1301.                 PostErr(eDiag_Warning, eErr_SEQ_FEAT_UnknownImpFeatQual,
  1302.                     "Unknown qualifier " + qual_str, feat);
  1303.             } else {
  1304.                 PostErr(eDiag_Warning, eErr_SEQ_FEAT_UnknownImpFeatQual,
  1305.                     "Empty qualifier", feat);
  1306.             }
  1307.         } else {
  1308.             if ( !CFeatQualAssoc::IsLegalGbqual(ftype, gbqual) ) {
  1309.                 PostErr(eDiag_Warning, eErr_SEQ_FEAT_WrongQualOnImpFeat,
  1310.                     "Wrong qualifier " + qual_str + " for feature " + 
  1311.                     key, feat);
  1312.             }
  1313.             
  1314.             string val = (*qual)->GetVal();
  1315.             
  1316.             bool error = false;
  1317.             switch ( gbqual ) {
  1318.             case CGbqualType::e_Rpt_type:
  1319.                 {{
  1320.                     for ( size_t i = 0; 
  1321.                     i < sizeof(s_LegalRepeatTypes) / sizeof(string); 
  1322.                     ++i ) {
  1323.                         if ( val.find(s_LegalRepeatTypes[i]) != string::npos ) {
  1324.                             bool left = false, right = false;
  1325.                             if ( i > 0 ) {
  1326.                                 left = val[i-1] == ','  ||  val[i-1] == '(';
  1327.                             }
  1328.                             if ( i < val.length() - 1 ) {
  1329.                                 right = val[i+1] == ','  ||  val[i+1] == ')';
  1330.                             }
  1331.                             if ( left  &&  right ) {
  1332.                                 error = true;
  1333.                             }
  1334.                             break;
  1335.                         }
  1336.                     }
  1337.                 }}
  1338.                 break;
  1339.                 
  1340.             case CGbqualType::e_Rpt_unit:
  1341.                 {{
  1342.                     bool found = false, multiple_rpt_unit = true;
  1343.                     ITERATE(string, it, val) {
  1344.                         if ( *it <= ' ' ) {
  1345.                             found = true;
  1346.                         } else if ( *it == '('  ||  *it == ')'  ||
  1347.                             *it == ','  ||  *it == '.'  ||
  1348.                             isdigit(*it) ) {
  1349.                         } else {
  1350.                             multiple_rpt_unit = false;
  1351.                         }
  1352.                     }
  1353.                     /*
  1354.                     if ( found || 
  1355.                     (!multiple_rpt_unit && val.length() > 48) ) {
  1356.                     error = true;
  1357.                     }
  1358.                     */
  1359.                     if ( NStr::CompareNocase(key, "repeat_region") == 0  &&
  1360.                         !multiple_rpt_unit  &&
  1361.                         val.length() == GetLength(feat.GetLocation(), m_Scope) ) {
  1362.                         bool just_nuc_letters = true;
  1363.                         static const string nuc_letters = "ACGTNacgtn";
  1364.                         
  1365.                         ITERATE(string, it, val) {
  1366.                             if ( nuc_letters.find(*it) == NPOS ) {
  1367.                                 just_nuc_letters = false;
  1368.                                 break;
  1369.                             }
  1370.                         }
  1371.                         
  1372.                         if ( just_nuc_letters ) {
  1373.                             CSeqVector vec = GetSequenceFromFeature(feat, *m_Scope);
  1374.                             if ( !vec.empty() ) {
  1375.                                 string vec_data;
  1376.                                 vec.GetSeqData(0, vec.size(), vec_data);
  1377.                                 if ( NStr::CompareNocase(val, vec_data) != 0 ) {
  1378.                                     PostErr(eDiag_Warning, eErr_SEQ_FEAT_InvalidQualifierValue,
  1379.                                         "repeat_region /rpt_unit and underlying"
  1380.                                         "sequence do not match", feat);
  1381.                                 }
  1382.                             }
  1383.                             
  1384.                             
  1385.                         }
  1386.                     }
  1387.                 }}
  1388.                 break;
  1389.                 
  1390.             case CGbqualType::e_Label:
  1391.                 {{
  1392.                     bool only_digits = true,
  1393.                         has_spaces = false;
  1394.                     
  1395.                     ITERATE(string, it, val) {
  1396.                         if ( isspace(*it) ) {
  1397.                             has_spaces = true;
  1398.                         }
  1399.                         if ( !isdigit(*it) ) {
  1400.                             only_digits = false;
  1401.                         }
  1402.                     }
  1403.                     error = only_digits  ||  has_spaces;
  1404.                 }}
  1405.                 break;
  1406.                 
  1407.             case CGbqualType::e_Cons_splice:
  1408.                 {{
  1409.                     error = true;
  1410.                     for (size_t i = 0; 
  1411.                          i < sizeof(s_LegalConsSpliceStrings) / sizeof(string);
  1412.                          ++i) {
  1413.                         if ( NStr::CompareNocase(val, s_LegalConsSpliceStrings[i]) == 0 ) {
  1414.                             error = false;
  1415.                             break;
  1416.                         }
  1417.                     }
  1418.                 }}
  1419.                 break;
  1421.         default:
  1422.             break;
  1423.             } // end of switch statement
  1424.             if ( error ) {
  1425.                 PostErr(eDiag_Error, eErr_SEQ_FEAT_InvalidQualifierValue,
  1426.                     val + " is not a legal value for qualifier " + qual_str, feat);
  1427.             }
  1428.         }
  1429.     }  // end of ITERATE 
  1430. }
  1433. void CValidError_feat::ValidatePeptideOnCodonBoundry
  1434. (const CSeq_feat& feat, 
  1435.  const string& key)
  1436. {
  1437.     const CSeq_loc& loc = feat.GetLocation();
  1439.     // !!! DEBUG {
  1440.     if( m_Imp.AvoidPerfBottlenecks() ) {
  1441.         return;
  1442.     } 
  1443.     // } DEBUG
  1445.     CConstRef<CSeq_feat> cds = GetOverlappingCDS(loc, *m_Scope);
  1446.     if ( !cds ) {
  1447.         return;
  1448.     }
  1449.     const CCdregion& cdr = cds->GetData().GetCdregion();
  1451.     CSeq_loc_CI first, last;
  1452.     for ( CSeq_loc_CI sl_iter(loc); sl_iter; ++sl_iter ) {
  1453.         if ( !first ) {
  1454.             first = sl_iter;
  1455.         }
  1456.         last = sl_iter;
  1457.     }
  1458.         
  1459.     if ( !first  ||  !last ) {
  1460.         return;
  1461.     }
  1463.     TSeqPos pos1 = LocationOffset(loc, first.GetSeq_loc(), eOffset_FromStart);
  1464.     TSeqPos pos2 = LocationOffset(loc, last.GetSeq_loc(), eOffset_FromEnd);
  1465.     TSeqPos mod1 = (pos1 - cdr.GetFrame()) %3;
  1466.     TSeqPos mod2 = (pos2 - cdr.GetFrame()) %3;
  1468.     if ( loc.IsPartialLeft() ) {
  1469.         mod1 = 0;
  1470.     }
  1471.     if ( loc.IsPartialRight() ) {
  1472.         mod2 = 2;
  1473.     }
  1475.     if ( (mod1 != 0)  &&  (mod2 != 2) ) {
  1476.         PostErr(eDiag_Warning, eErr_SEQ_FEAT_PeptideFeatOutOfFrame,
  1477.             "Start and stop of " + key + " are out of frame with CDS codons",
  1478.             feat);
  1479.     } else if (mod1 != 0) {
  1480.         PostErr(eDiag_Warning, eErr_SEQ_FEAT_PeptideFeatOutOfFrame, 
  1481.             "Start of " + key + " is out of frame with CDS codons", feat);
  1482.     } else if (mod2 != 2) {
  1483.         PostErr(eDiag_Warning, eErr_SEQ_FEAT_PeptideFeatOutOfFrame,
  1484.             "Stop of " + key + " is out of frame with CDS codons", feat);
  1485.     }
  1486. }
  1489. void CValidError_feat::ValidateMrnaTrans(const CSeq_feat& feat)
  1490. {
  1491.     static string s_BypassMrnaTransCheck[] = {
  1492.         "RNA editing",
  1493.         "reasons given in citation",
  1494.         "artificial frameshift",
  1495.         "unclassified transcription discrepancy",
  1496.         "rearrangement required for product"
  1497.     };
  1499.     if ( feat.CanGetPseudo()  &&  feat.GetPseudo() ) {
  1500.         return;
  1501.     }
  1502.     if ( !feat.CanGetProduct() ) {
  1503.         return;
  1504.     }
  1506.     // biological exception
  1507.     
  1508.     if ( feat.CanGetExcept()  &&  feat.GetExcept()  &&
  1509.          feat.CanGetExcept_text() ) {
  1510.         size_t except_num = sizeof(s_BypassMrnaTransCheck) / sizeof(string);
  1511.         for ( size_t i = 0; i < except_num; ++i ) {
  1512.             if ( NStr::FindNoCase(feat.GetExcept_text(), 
  1513.                 s_BypassMrnaTransCheck[i]) != string::npos ) {
  1514.                 return; 
  1515.             }
  1516.         }
  1517.     }
  1519.     CBioseq_Handle nuc = m_Scope->GetBioseqHandle(feat.GetLocation());
  1520.     CBioseq_Handle rna = m_Scope->GetBioseqHandle(feat.GetProduct());
  1521.     if ( !nuc  ||  !rna ) {
  1522.         return;
  1523.     }
  1525.     CSeqVector nuc_vec = nuc.GetSequenceView(feat.GetLocation(),
  1526.         CBioseq_Handle::eViewConstructed,
  1527.         CBioseq_Handle::eCoding_Iupac);
  1528.     CSeqVector rna_vec = rna.GetSequenceView(feat.GetProduct(),
  1529.         CBioseq_Handle::eViewConstructed,
  1530.         CBioseq_Handle::eCoding_Iupac);
  1532.     size_t nuc_len = nuc_vec.size();
  1533.     size_t rna_len = rna_vec.size();
  1535.     if ( nuc_len != rna_len ) {
  1536.         if ( nuc_len < rna_len ) {
  1537.             size_t count_a = 0, count_no_a = 0;
  1538.             // count 'A's in the tail
  1539.             for ( CSeqVector_CI iter(rna_vec, nuc_len); iter; ++iter ) {
  1540.                 if ( (*iter == 'A')  ||  (*iter == 'a') ) {
  1541.                     ++count_a;
  1542.                 } else {
  1543.                     ++count_no_a;
  1544.                 }
  1545.             }
  1546.             if ( count_a < (19 * count_no_a) ) { // less then 5%
  1547.                 PostErr(eDiag_Error, eErr_SEQ_FEAT_TranscriptLen,
  1548.                     "Transcript length [" + NStr::IntToString(nuc_len) + 
  1549.                     "] less than product length [" + NStr::IntToString(rna_len) + 
  1550.                     "], and tail < 95% polyA", feat);
  1551.             } else {
  1552.                 PostErr(eDiag_Info, eErr_SEQ_FEAT_TranscriptLen,
  1553.                     "Transcript length [" + NStr::IntToString(nuc_len) + 
  1554.                     "] less than product length [" + NStr::IntToString(rna_len) +
  1555.                     "], but tail >= 95% polyA", feat);
  1556.             }
  1557.             // allow base-by-base comparison on common length
  1558.             rna_len = nuc_len; 
  1559.         } else {
  1560.             PostErr(eDiag_Error, eErr_SEQ_FEAT_TranscriptLen,
  1561.                 "Transcript length [" + NStr::IntToString(nuc_vec.size()) + "] " +
  1562.                 "does not match product length [" + 
  1563.                 NStr::IntToString(rna_vec.size()) + "]", feat);
  1564.         }
  1565.     } 
  1566.     if ( (nuc_len == rna_len)  &&  (nuc_len > 0) ) {
  1567.         // compare content of common length
  1568.         CSeqVector_CI nuc_ci(nuc_vec);
  1569.         CSeqVector_CI rna_ci(rna_vec);
  1570.         size_t mismatches = 0;
  1572.         while ( nuc_ci  &&  rna_ci ) {
  1573.             if ( *nuc_ci != *rna_ci ) {
  1574.                 ++mismatches;
  1575.             }
  1576.             ++nuc_ci;
  1577.             ++rna_ci;
  1578.         }
  1579.         if ( mismatches > 0 ) {
  1580.             PostErr(eDiag_Error, eErr_SEQ_FEAT_TranscriptMismatches,
  1581.                 "There are " + NStr::IntToString(mismatches) + 
  1582.                 " mismatches out of " + NStr::IntToString(nuc_len) +
  1583.                 " bases between the transcript and product sequence", feat);
  1584.         }
  1585.     }
  1586. }
  1589. void CValidError_feat::ValidateCommonMRNAProduct(const CSeq_feat& feat)
  1590. {
  1591.     if ( (feat.CanGetPseudo()  &&  feat.GetPseudo())  ||
  1592.          IsOverlappingGenePseudo(feat) ) {
  1593.         return;
  1594.     }
  1596.     if ( !feat.CanGetProduct() ) {
  1597.         return;
  1598.     }
  1600.     CBioseq_Handle bsh = m_Scope->GetBioseqHandle(feat.GetProduct());
  1601.     if ( !bsh ) {
  1602.         const CSeq_id& sid = GetId(feat.GetProduct(), m_Scope);
  1603.         if ( sid.IsLocal() ) {
  1604.             if ( m_Imp.IsGPS()  ||  m_Imp.IsRefSeq() ) {
  1605.                 PostErr(eDiag_Error, eErr_SEQ_FEAT_MissingMRNAproduct,
  1606.                     "Product Bioseq of mRNA feature is not "
  1607.                     "packaged in the record", feat);
  1608.             }
  1609.         }
  1610.     } else {
  1612.         // !!! DEBUG {
  1613.         if( m_Imp.AvoidPerfBottlenecks() ) {
  1614.             return;
  1615.         } 
  1616.         // } DEBUG
  1618.         CFeat_CI mrna(
  1619.             bsh, 
  1620.             0, 0,
  1621.             CSeqFeatData::e_Rna,
  1622.             SAnnotSelector::eOverlap_TotalRange,
  1623.             SAnnotSelector::eResolve_None,
  1624.             CFeat_CI::e_Product);
  1625.         while ( mrna ) {
  1626.             if ( &(mrna->GetOriginalFeature()) != &feat ) {
  1627.                     PostErr(eDiag_Critical, eErr_SEQ_FEAT_MultipleMRNAproducts,
  1628.                         "Same product Bioseq from multiple mRNA features", feat);
  1629.                     break;
  1630.             }
  1631.             ++mrna;
  1632.         }
  1633.     }
  1634. }
  1637. void CValidError_feat::ValidateBothStrands(const CSeq_feat& feat)
  1638. {
  1639.     const CSeq_loc& location = feat.GetLocation ();
  1640.     for ( CSeq_loc_CI citer (location); citer; ++citer ) {
  1641.         if ( citer.GetStrand () == eNa_strand_both ) {
  1642.             PostErr (eDiag_Error, eErr_SEQ_FEAT_BothStrands, 
  1643.                 "mRNA or CDS may not be on both strands", feat);  
  1644.             break;
  1645.         }
  1646.     }
  1647. }
  1650. // Precondition: feat is a coding region
  1651. void CValidError_feat::ValidateCommonCDSProduct
  1652. (const CSeq_feat& feat)
  1653. {
  1654.     if ( (feat.CanGetPseudo()  &&  feat.GetPseudo())  ||
  1655.           IsOverlappingGenePseudo(feat) ) {
  1656.         return;
  1657.     }
  1658.     
  1659.     if ( !feat.CanGetProduct() ) {
  1660.         return;
  1661.     }
  1662.     
  1663.     const CCdregion& cdr = feat.GetData().GetCdregion();
  1664.     if ( cdr.CanGetOrf() ) {
  1665.         return;
  1666.     }
  1668.     CBioseq_Handle prod = m_Scope->GetBioseqHandle(feat.GetProduct());
  1669.     if ( !prod ) {
  1670.         const CSeq_id* sid = 0;
  1671.         try {
  1672.             sid = &(GetId(feat.GetProduct(), m_Scope));
  1673.         } catch (const CNotUnique&) {}
  1675.         // okay to have far RefSeq product, but only if genomic product set
  1676.         if ( sid == 0  ||  !sid->IsOther() ) {
  1677.             if ( m_Imp.IsGPS() ) {
  1678.                 return;
  1679.             }
  1680.         }
  1681.         // or just a bioseq
  1682.         if ( m_Imp.GetTSE().IsSeq() ) {
  1683.             return;
  1684.         }
  1686.         // or in a standalone Seq-annot
  1687.         if ( m_Imp.IsStandaloneAnnot() ) {
  1688.             return;
  1689.         }
  1691.         PostErr(eDiag_Warning, eErr_SEQ_FEAT_MultipleCDSproducts,
  1692.             "Unable to find product Bioseq from CDS feature", feat);
  1693.         return;
  1694.     }
  1695.     CBioseq_Handle nuc  = m_Scope->GetBioseqHandle(feat.GetLocation());
  1696.     if ( nuc ) {
  1697.         CSeq_entry_Handle prod_nps = 
  1698.             prod.GetExactComplexityLevel(CBioseq_set::eClass_nuc_prot);
  1699.         CSeq_entry_Handle nuc_nps = 
  1700.             nuc.GetExactComplexityLevel(CBioseq_set::eClass_nuc_prot);
  1702.         if ( (prod_nps != nuc_nps)  &&  (!m_Imp.IsNT())  &&  (!m_Imp.IsGPS()) ) {
  1703.             PostErr(eDiag_Error, eErr_SEQ_FEAT_CDSproductPackagingProblem,
  1704.                 "Protein product not packaged in nuc-prot set with nucleotide", 
  1705.                 feat);
  1706.         }
  1707.     }
  1708.     const CSeq_feat* sfp = GetCDSForProduct(prod);
  1709.     if ( sfp == 0 ) {
  1710.         return;
  1711.     }
  1712.     
  1713.     if ( &feat != sfp ) {
  1714.         // if genomic product set, with one cds on contig and one on cdna,
  1715.         // do not report.
  1716.         if ( m_Imp.IsGPS() ) {
  1717.             // feature packaging test will do final contig vs. cdna check
  1718.             CBioseq_Handle sfh = m_Scope->GetBioseqHandle(sfp->GetLocation());
  1719.             if ( nuc != sfh ) {
  1720.                 return;
  1721.             }
  1722.         }
  1723.         PostErr(eDiag_Critical, eErr_SEQ_FEAT_MultipleCDSproducts, 
  1724.             "Same product Bioseq from multiple CDS features", feat);
  1725.     }
  1726. }
  1729. void CValidError_feat::ValidateCDSPartial(const CSeq_feat& feat)
  1730. {
  1731.     if ( !feat.CanGetProduct()  ||  !feat.CanGetLocation() ) {
  1732.         return;
  1733.     }
  1735.     CBioseq_Handle bsh = m_Scope->GetBioseqHandle(feat.GetProduct());
  1736.     if ( !bsh ) {
  1737.         return;
  1738.     }
  1740.     CSeqdesc_CI sd(bsh, CSeqdesc::e_Molinfo);
  1741.     if ( !sd ) {
  1742.         return;
  1743.     }
  1744.     const CMolInfo& molinfo = sd->GetMolinfo();
  1746.     const CSeq_loc& loc = feat.GetLocation();
  1747.     bool partial5 = loc.IsPartialLeft();
  1748.     bool partial3 = loc.IsPartialRight();
  1750.     if ( molinfo.CanGetCompleteness() ) {
  1751.         switch ( molinfo.GetCompleteness() ) {
  1752.         case CMolInfo::eCompleteness_unknown:
  1753.             break;
  1755.         case CMolInfo::eCompleteness_complete:
  1756.             if ( partial5 || partial3 ) {
  1757.                 PostErr(eDiag_Error, eErr_SEQ_FEAT_PartialProblem,
  1758.                     "CDS is partial but protein is complete", feat);
  1759.             }
  1760.             break;
  1762.         case CMolInfo::eCompleteness_partial:
  1763.             break;
  1765.         case CMolInfo::eCompleteness_no_left:
  1766.             if ( !partial5 ) {
  1767.                 PostErr(eDiag_Error, eErr_SEQ_FEAT_PartialProblem,
  1768.                     "CDS is 5' complete but protein is NH2 partial", feat);
  1769.             }
  1770.             if ( partial3 ) {
  1771.                 PostErr(eDiag_Error, eErr_SEQ_FEAT_PartialProblem,
  1772.                     "CDS is 3' partial but protein is NH2 partial", feat);
  1773.             }
  1774.             break;
  1776.         case CMolInfo::eCompleteness_no_right:
  1777.             if (! partial3) {
  1778.                 PostErr(eDiag_Error, eErr_SEQ_FEAT_PartialProblem,
  1779.                     "CDS is 3' complete but protein is CO2 partial", feat);
  1780.             }
  1781.             if (partial5) {
  1782.                 PostErr(eDiag_Error, eErr_SEQ_FEAT_PartialProblem,
  1783.                     "CDS is 5' partial but protein is CO2 partial", feat);
  1784.             }
  1785.             break;
  1787.         case CMolInfo::eCompleteness_no_ends:
  1788.             if ( partial5 && partial3 ) {
  1789.             } else if ( partial5 ) {
  1790.                 PostErr(eDiag_Error, eErr_SEQ_FEAT_PartialProblem,
  1791.                     "CDS is 5' partial but protein has neither end", feat);
  1792.             } else if ( partial3 ) {
  1793.                 PostErr(eDiag_Error, eErr_SEQ_FEAT_PartialProblem,
  1794.                     "CDS is 3' partial but protein has neither end", feat);
  1795.             } else {
  1796.                 PostErr(eDiag_Error, eErr_SEQ_FEAT_PartialProblem,
  1797.                     "CDS is complete but protein has neither end", feat);
  1798.             }
  1799.             break;
  1801.         case CMolInfo::eCompleteness_has_left:
  1802.             break;
  1804.         case CMolInfo::eCompleteness_has_right:
  1805.             break;
  1807.         case CMolInfo::eCompleteness_other:
  1808.             break;
  1810.         default:
  1811.             break;
  1812.         }
  1813.     }
  1814. }
  1817. void CValidError_feat::ValidateBadMRNAOverlap(const CSeq_feat& feat)
  1818. {
  1819.     const CSeq_loc& loc = feat.GetLocation();
  1821.     // !!! DEBUG {
  1822.     if( m_Imp.AvoidPerfBottlenecks() ) {
  1823.         return;
  1824.     } 
  1825.     // } DEBUG
  1827.     CConstRef<CSeq_feat> mrna = GetBestOverlappingFeat(
  1828.         loc,
  1829.         CSeqFeatData::eSubtype_mRNA,
  1830.         eOverlap_Simple,
  1831.         *m_Scope);
  1832.     if ( !mrna ) {
  1833.         return;
  1834.     }
  1836.     mrna = GetBestOverlappingFeat(
  1837.         loc,
  1838.         CSeqFeatData::eSubtype_mRNA,
  1839.         eOverlap_CheckIntervals,
  1840.         *m_Scope);
  1841.     if ( mrna ) {
  1842.         return;
  1843.     }
  1845.     mrna = GetBestOverlappingFeat(
  1846.         loc,
  1847.         CSeqFeatData::eSubtype_mRNA,
  1848.         eOverlap_Interval,
  1849.         *m_Scope);
  1850.     if ( !mrna ) {
  1851.         return;
  1852.     }
  1854.     mrna = GetBestOverlappingFeat(
  1855.         loc,
  1856.         CSeqFeatData::eSubtype_mRNA,
  1857.         eOverlap_Subset,
  1858.         *m_Scope);
  1860.     EDiagSev sev = eDiag_Error;
  1861.     if ( m_Imp.IsNC()  ||  m_Imp.IsNT()  ||  
  1862.          (feat.CanGetExcept()  &&  feat.GetExcept()) ) {
  1863.         sev = eDiag_Warning;
  1864.     }
  1865.     if ( mrna ) {
  1866.         // ribosomal slippage exception suppresses CDSmRNArange warning
  1867.         bool supress = false;
  1869.         if ( feat.CanGetExcept_text() ) {
  1870.             const CSeq_feat::TExcept_text& text = feat.GetExcept_text();
  1871.             if ( NStr::FindNoCase(text, "ribosomal slippage") != NPOS ) {
  1872.                 supress = true;
  1873.             }
  1874.         }
  1875.         if ( !supress ) {
  1876.             PostErr(sev, eErr_SEQ_FEAT_CDSmRNArange,
  1877.                 "mRNA contains CDS but internal intron-exon boundaries "
  1878.                 "do not match", feat);
  1879.         }
  1880.     } else {
  1881.         PostErr(sev, eErr_SEQ_FEAT_CDSmRNArange,
  1882.             "mRNA overlaps or contains CDS but does not completely "
  1883.             "contain intervals", feat);
  1884.     }
  1885. }
  1888. void CValidError_feat::ValidateBadGeneOverlap(const CSeq_feat& feat)
  1889. {
  1890.     const CGene_ref* grp = feat.GetGeneXref();
  1891.     if ( grp != 0 ) {
  1892.         return;
  1893.     }
  1895.     // !!! DEBUG {
  1896.     if( m_Imp.AvoidPerfBottlenecks() ) {
  1897.         return;
  1898.     } 
  1899.     // } DEBUG
  1900.     
  1901.     // !!! can't look for contating feature using GetBestOverlap.
  1902.     // This implementation should be changed once the above is supported
  1904.     // look for overlapping genes
  1905.     CConstRef<CSeq_feat> gene = 
  1906.         GetOverlappingGene(feat.GetLocation(), *m_Scope);
  1907.     if ( gene ) {
  1908.         return;
  1909.     }
  1912.     // look for intersecting genes
  1913.     gene = GetBestOverlappingFeat(
  1914.         feat.GetLocation(),
  1915.         CSeqFeatData::e_Gene,
  1916.         eOverlap_Simple,
  1917.         *m_Scope);
  1918.     if ( !gene ) {
  1919.         return;
  1920.     }
  1922.     // found an intersecting (but not overlapping) gene
  1923.     EDiagSev sev = eDiag_Error;
  1924.     if ( m_Imp.IsNC()  ||  m_Imp.IsNT() ) {
  1925.         sev = eDiag_Warning;
  1926.     }
  1928.     if ( feat.GetData().IsCdregion() ) {
  1929.         PostErr(sev, eErr_SEQ_FEAT_CDSgeneRange, 
  1930.             "gene overlaps CDS but does not completely contain it", feat);
  1931.     } else if ( feat.GetData().IsRna() ) {
  1932.         PostErr(sev, eErr_SEQ_FEAT_mRNAgeneRange,
  1933.             "gene overlaps mRNA but does not completely contain it", feat);
  1934.     }
  1935. }
  1938. static const string s_LegalExceptionStrings[] = {
  1939.   "RNA editing",
  1940.   "reasons given in citation",
  1941.   "ribosomal slippage",
  1942.   "trans-splicing",
  1943.   "alternative processing",
  1944.   "artificial frameshift",
  1945.   "nonconsensus splice site",
  1946.   "rearrangement required for product",
  1947.   "modified codon recognition",
  1948.   "alternative start codon"
  1949. };
  1952. static const string s_RefseqExceptionStrings [] = {
  1953.   "unclassified transcription discrepancy",
  1954.   "unclassified translation discrepancy",
  1955. };
  1958. void CValidError_feat::ValidateExcept(const CSeq_feat& feat)
  1959. {
  1960.     if ( feat.CanGetExcept() &&  !feat.GetExcept()  &&
  1961.          feat.CanGetExcept_text()  &&  !feat.GetExcept_text().empty() ) {
  1962.         PostErr(eDiag_Warning, eErr_SEQ_FEAT_ExceptInconsistent,
  1963.             "Exception text is set, but exception flag is not set", feat);
  1964.     }
  1965.     if ( feat.CanGetExcept_text()  &&  !feat.GetExcept_text ().empty() ) {
  1966.         ValidateExceptText(feat.GetExcept_text(), feat);
  1967.     }
  1968. }
  1971. void CValidError_feat::ValidateExceptText(const string& text, const CSeq_feat& feat)
  1972. {
  1973.     if ( text.empty() ) return;
  1975.     EDiagSev sev = eDiag_Error;
  1976.     bool found = false;
  1978.     string str;
  1979.     string::size_type   begin = 0, end, textlen = text.length();
  1981.     const string* except_begin = s_LegalExceptionStrings;
  1982.     const string* except_end = 
  1983.         &(s_LegalExceptionStrings[sizeof(s_LegalExceptionStrings) / sizeof(string)]);
  1984.     const string* refseq_begin = s_RefseqExceptionStrings;
  1985.     const string* refseq_end = 
  1986.         &(s_RefseqExceptionStrings[sizeof(s_RefseqExceptionStrings) / sizeof(string)]);
  1987.     
  1988.     while ( begin < textlen ) {
  1989.         found = false;
  1990.         end = min( text.find_first_of(',', begin), textlen );
  1991.         str = NStr::TruncateSpaces( text.substr(begin, end) );
  1992.         if ( find(except_begin, except_end, str) != except_end ) {
  1993.             found = true;
  1994.         }
  1995.         if ( !found  &&  (m_Imp.IsGPS() || m_Imp.IsRefSeq()) ) {
  1996.             if ( find(refseq_begin, refseq_end, str) != refseq_end ) {
  1997.                found = true;
  1998.             }
  1999.         }
  2000.         if ( !found ) {
  2001.             if ( m_Imp.IsNC()  ||  m_Imp.IsNT() ) {
  2002.                 sev = eDiag_Warning;
  2003.             }
  2004.             PostErr(sev, eErr_SEQ_FEAT_InvalidQualifierValue,
  2005.                 str + " is not legal exception explanation", feat);
  2006.         }
  2007.         begin = end + 1;
  2008.     }
  2009. }
  2012. static const string s_BypassCdsTransCheck[] = {
  2013.   "RNA editing",
  2014.   "reasons given in citation",
  2015.   "artificial frameshift",
  2016.   "unclassified translation discrepancy",
  2017.   "rearrangement required for product"
  2018. };
  2021. void CValidError_feat::ReportCdTransErrors
  2022. (const CSeq_feat& feat,
  2023.  bool show_stop,
  2024.  bool got_stop, 
  2025.  bool no_end,
  2026.  int ragged)
  2027. {
  2028.     if ( show_stop ) {
  2029.         if ( !got_stop  && !no_end ) {
  2030.             PostErr(eDiag_Error, eErr_SEQ_FEAT_NoStop, 
  2031.                 "Missing stop codon", feat);
  2032.         } else if ( got_stop  &&  no_end ) {
  2033.             PostErr (eDiag_Error, eErr_SEQ_FEAT_PartialProblem,
  2034.                 "Got stop codon, but 3'end is labeled partial", feat);
  2035.         } else if ( got_stop  &&  !no_end  &&  ragged ) {
  2036.             PostErr (eDiag_Error, eErr_SEQ_FEAT_TransLen, 
  2037.                 "Coding region extends " + NStr::IntToString(ragged) +
  2038.                 " base(s) past stop codon", feat);
  2039.         }
  2040.     }
  2041. }
  2044. void CValidError_feat::ValidateCdTrans(const CSeq_feat& feat)
  2045. {
  2046.     bool prot_ok = true;
  2047.     int  ragged = 0;
  2049.     // biological exception
  2050.     size_t except_num = sizeof(s_BypassCdsTransCheck) / sizeof(string);
  2051.     if ( feat.CanGetExcept()  &&  feat.GetExcept()  &&
  2052.          feat.CanGetExcept_text() ) {
  2053.         for ( size_t i = 0; i < except_num; ++i ) {
  2054.             if ( NStr::FindNoCase(feat.GetExcept_text(), 
  2055.                 s_BypassCdsTransCheck[i]) != NPOS ) {
  2056.                 return; 
  2057.             }
  2058.         }
  2059.     }
  2060.     
  2062.     // pseuogene
  2063.     if ( (feat.CanGetPseudo()  &&  feat.GetPseudo())  ||
  2064.          IsOverlappingGenePseudo(feat) ) {
  2065.         return;
  2066.     }
  2068.     if ( !feat.CanGetProduct() ) {
  2069.         // bail if no product exists. shuold be checked elsewhere.
  2070.         return;
  2071.     }
  2073.     const CCdregion& cdregion = feat.GetData().GetCdregion();
  2074.     const CSeq_loc& location = feat.GetLocation();
  2075.     const CSeq_loc& product = feat.GetProduct();
  2076.     
  2077.     int gc = 0;
  2078.     if ( cdregion.CanGetCode() ) {
  2079.         // We assume that the id is set for all Genetic_code
  2080.         gc = cdregion.GetCode().GetId();
  2081.     }
  2082.     string gccode = NStr::IntToString(gc);
  2084.     string transl_prot;   // translated protein
  2085.     CBioseq_Handle nuc_handle = m_Scope->GetBioseqHandle(location);
  2086.     if ( !nuc_handle ) {
  2087.         return;
  2088.     }
  2089.     bool alt_start = false;
  2090.     try {
  2091.         CCdregion_translate::TranslateCdregion(
  2092.             transl_prot, 
  2093.             nuc_handle, 
  2094.             location, 
  2095.             cdregion,
  2096.             true,   // include stop codons
  2097.             false,  // do not remove trailing X/B/Z
  2098.             &alt_start);
  2099.     } catch (CException&) {
  2100.     }
  2101.     if ( transl_prot.empty() ) {
  2102.         PostErr (eDiag_Error, eErr_SEQ_FEAT_CdTransFail, 
  2103.             "Unable to translate", feat);
  2104.         return;
  2105.     }
  2106.     // check alternative start codon
  2107.     if ( alt_start  &&  gc == 1 ) {
  2108.         EDiagSev sev = eDiag_Warning;
  2109.         if ( s_IsLocRefSeqMrna(feat.GetLocation(), *m_Scope) ) {
  2110.             sev = eDiag_Error;
  2111.         } else if ( s_IsLocGEDL(feat.GetLocation(), *m_Scope) ) {
  2112.             sev = eDiag_Info;
  2113.         }
  2114.         if ( sev != eDiag_Info  &&  
  2115.              feat.CanGetExcept()  &&  feat.GetExcept()  &&
  2116.              feat.CanGetExcept_text()  &&  !feat.GetExcept_text().empty() ) {
  2117.             if ( feat.GetExcept_text().find("alternative start codon") != NPOS ) {
  2118.                 sev = eDiag_Info;
  2119.             }
  2120.         }
  2121.         if ( sev != eDiag_Info ) {
  2122.             PostErr(sev, eErr_SEQ_FEAT_AltStartCodon,
  2123.                 "Alternative start codon used", feat);
  2124.         }
  2125.     }
  2127.     bool no_end = false;
  2128.     unsigned int part_loc = SeqLocPartialCheck(location, m_Scope);
  2129.     unsigned int part_prod = SeqLocPartialCheck(product, m_Scope);
  2130.     if ( (part_loc & eSeqlocPartial_Stop)  ||
  2131.         (part_prod & eSeqlocPartial_Stop) ) {
  2132.         no_end = true;
  2133.     } else {    
  2134.         // complete stop, so check for ragged end
  2135.         ragged = CheckForRaggedEnd(location, cdregion);
  2136.     }
  2137.     
  2138.     // check for code break not on a codon
  2139.     ValidateCodeBreakNotOnCodon(feat, location, cdregion);
  2140.     
  2141.     if ( cdregion.GetFrame() > CCdregion::eFrame_one ) {
  2142.         EDiagSev sev = s_IsLocRefSeqMrna(feat.GetLocation(), *m_Scope) ?
  2143.             eDiag_Error : eDiag_Warning;
  2144.         if ( !(part_loc & eSeqlocPartial_Start) ) {
  2145.             PostErr(sev, eErr_SEQ_FEAT_PartialProblem, 
  2146.                 "Suspicious CDS location - frame > 1 but not 5' partial", feat);
  2147.         } else if ( (part_loc & eSeqlocPartial_Nostart)  && 
  2148.             !IsPartialAtSpliceSite(location, eSeqlocPartial_Nostart) ) {
  2149.             PostErr(sev, eErr_SEQ_FEAT_PartialProblem, 
  2150.                 "Suspicious CDS location - frame > 1 and not at consensus splice site",
  2151.                 feat);
  2152.         }
  2153.     }
  2154.     
  2155.     bool no_beg = false;
  2156.     
  2157.     size_t stop_count = 0;
  2158.     if ( (part_loc & eSeqlocPartial_Start)  ||
  2159.          (part_prod & eSeqlocPartial_Start) ) {
  2160.         no_beg = true;
  2161.     }
  2162.     
  2163.     bool got_dash = (transl_prot[0] == '-');
  2164.     bool got_stop = (transl_prot[transl_prot.length() - 1] == '*');
  2165.     
  2166.     // count internal stops
  2167.     ITERATE( string, it, transl_prot ) {
  2168.         if ( *it == '*' ) {
  2169.             ++stop_count;
  2170.         }
  2171.     }
  2172.     if ( got_stop ) {
  2173.         --stop_count;
  2174.     }
  2175.     
  2176.     if ( stop_count > 0 ) {
  2177.         if ( got_dash ) {
  2178.             PostErr(eDiag_Error, eErr_SEQ_FEAT_StartCodon,
  2179.                 "Illegal start codon and " + 
  2180.                 NStr::IntToString(stop_count) +
  2181.                 " internal stops. Probably wrong genetic code [" + gccode + "]",
  2182.                 feat);
  2183.         } else {
  2184.             PostErr(eDiag_Error, eErr_SEQ_FEAT_InternalStop, 
  2185.                 NStr::IntToString(stop_count) + 
  2186.                 " internal stops. Genetic code [" + gccode + "]", feat);
  2187.             prot_ok = false;
  2188.             if ( stop_count > 5 ) {
  2189.                 return;
  2190.             }
  2191.         }
  2192.     } else if ( got_dash ) {
  2193.         PostErr(eDiag_Error, eErr_SEQ_FEAT_StartCodon, 
  2194.             "Illegal start codon used. Wrong genetic code [" +
  2195.             gccode + "] or protein should be partial", feat);
  2196.     }
  2197.     
  2198.     bool show_stop = true;
  2200.     CBioseq_Handle prot_handle = m_Scope->GetBioseqHandle(product);
  2201.     if ( !prot_handle ) {
  2202.         if ( transl_prot.length() > 6 ) {
  2203.             if ( !(m_Imp.IsNG() || m_Imp.IsNT()) ) {
  2204.                 EDiagSev sev = eDiag_Error;
  2205.                 if ( IsDeltaOrFarSeg(location, m_Scope) ) {
  2206.                     sev = eDiag_Warning;
  2207.                 }
  2208.                 if ( m_Imp.IsNC() ) {
  2209.                     sev = eDiag_Warning;
  2211.                     if ( nuc_handle.GetTopLevelSeqEntry().IsSeq() ) {
  2212.                         sev = eDiag_Info;
  2213.                     }
  2214.                 }
  2215.                 if ( sev != eDiag_Info ) {
  2216.                     PostErr(sev, eErr_SEQ_FEAT_NoProtein, 
  2217.                         "No protein Bioseq given", feat);
  2218.                 }
  2219.             }
  2220.         }
  2221.         ReportCdTransErrors(feat, show_stop, got_stop, no_end, ragged);
  2222.         return;
  2223.     }
  2225.     CSeqVector prot_vec = prot_handle.GetSeqVector();
  2226.     prot_vec.SetCoding(CSeq_data::e_Ncbieaa);
  2227.     size_t prot_len = prot_vec.size(); 
  2228.     size_t len = transl_prot.length();
  2230.     if ( got_stop  &&  (len == prot_len + 1) ) { // ok, got stop
  2231.         --len;
  2232.     }
  2234.     // ignore terminal 'X' from partial last codon if present
  2235.     
  2236.     while ( prot_len > 0 ) {
  2237.         if ( prot_vec[prot_len - 1] == 'X' ) {  //remove terminal X
  2238.             --prot_len;
  2239.         } else {
  2240.             break;
  2241.         }
  2242.     }
  2243.     
  2244.     while ( len > 0 ) {
  2245.         if ( transl_prot[len - 1] == 'X' ) {  //remove terminal X
  2246.             --len;
  2247.         } else {
  2248.             break;
  2249.         }
  2250.     }
  2252.     vector<TSeqPos> mismatches;
  2253.     if ( len == prot_len )  {                // could be identical
  2254.         for ( TSeqPos i = 0; i < len; ++i ) {
  2255.             if ( transl_prot[i] != prot_vec[i] ) {
  2256.                 mismatches.push_back(i);
  2257.                 prot_ok = false;
  2258.             }
  2259.         }
  2260.     } else {
  2261.         PostErr(eDiag_Error, eErr_SEQ_FEAT_TransLen,
  2262.             "Given protein length [" + NStr::IntToString(prot_len) + 
  2263.             "] does not match translation length [" + 
  2264.             NStr::IntToString(len) + "]", feat);
  2265.     }
  2266.     
  2267.     // Mismatch on first residue
  2268.     string msg;
  2269.     if ( !mismatches.empty() && mismatches.front() == 0 ) {
  2270.         if ( feat.GetPartial() && (!no_beg) && (!no_end)) {
  2271.             PostErr(eDiag_Error, eErr_SEQ_FEAT_PartialProblem, 
  2272.                 "Start of location should probably be partial",
  2273.                 feat);
  2274.         } else if ( transl_prot[mismatches.front()] == '-' ) {
  2275.             PostErr(eDiag_Error, eErr_SEQ_FEAT_StartCodon,
  2276.                 "Illegal start codon used. Wrong genetic code [" +
  2277.                 gccode + "] or protein should be partial", feat);
  2278.         }
  2279.     }
  2281.     char prot_res, transl_res;
  2282.     string nuclocstr;
  2283.     if ( mismatches.size() > 10 ) {
  2284.         // report total number of mismatches and the details of the 
  2285.         // first and last.
  2286.         nuclocstr = MapToNTCoords(feat, product, mismatches.front());
  2287.         prot_res = prot_vec[mismatches.front()];
  2288.         transl_res = Residue(transl_prot[mismatches.front()]);
  2289.         msg = 
  2290.             NStr::IntToString(mismatches.size()) + " mismatches found. " +
  2291.             "First mismatch at " + NStr::IntToString(mismatches.front() + 1) +
  2292.             ", residue in protein [" + prot_res + "]" +
  2293.             " != translation [" + transl_res + "]";
  2294.         if ( !nuclocstr.empty() ) {
  2295.             msg += " at " + nuclocstr;
  2296.         }
  2297.         nuclocstr = MapToNTCoords(feat, product, mismatches.back());
  2298.         prot_res = prot_vec[mismatches.back()];
  2299.         transl_res = Residue(transl_prot[mismatches.back()]);
  2300.         msg += 
  2301.             ". Last mismatch at " + NStr::IntToString(mismatches.back() + 1) +
  2302.             ", residue in protein [" + prot_res + "]" +
  2303.             " != translation [" + transl_res + "]";
  2304.         if ( !nuclocstr.empty() ) {
  2305.             msg += " at " + nuclocstr;
  2306.         }
  2307.         msg += ". Genetic code [" + gccode + "]";
  2308.         PostErr(eDiag_Error, eErr_SEQ_FEAT_MisMatchAA, msg, feat);
  2309.     } else {
  2310.         // report individual mismatches
  2311.         for ( size_t i = 0; i < mismatches.size(); ++i ) {
  2312.             nuclocstr = MapToNTCoords(feat, product, mismatches[i]);
  2313.             prot_res = prot_vec[mismatches[i]];
  2314.             transl_res = Residue(transl_prot[mismatches[i]]);
  2315.             msg += 
  2316.                 "Residue " + NStr::IntToString(mismatches[i] + 1) + 
  2317.                 " in protein [" + prot_res + "]" +
  2318.                 " != translation [" + transl_res + "]";
  2319.             if ( !nuclocstr.empty() ) {
  2320.                 msg += " at " + nuclocstr;
  2321.             }
  2322.             PostErr(eDiag_Error, eErr_SEQ_FEAT_MisMatchAA, msg, feat);
  2323.         }
  2324.     }
  2326.     if ( feat.CanGetPartial()  &&  feat.GetPartial()  &&
  2327.          mismatches.empty() ) {
  2328.         if ( !no_beg  && !no_end ) {
  2329.             if ( !got_stop ) {
  2330.                 PostErr(eDiag_Error, eErr_SEQ_FEAT_PartialProblem, 
  2331.                     "End of location should probably be partial", feat);
  2332.             } else {
  2333.                 PostErr(eDiag_Error, eErr_SEQ_FEAT_PartialProblem,
  2334.                     "This SeqFeat should not be partial", feat);
  2335.             }
  2336.             show_stop = false;
  2337.         }
  2338.     }
  2340.     ReportCdTransErrors(feat, show_stop, got_stop, no_end, ragged);
  2341. }
  2344. void CValidError_feat::ValidateCodeBreakNotOnCodon
  2345. (const CSeq_feat& feat,
  2346.  const CSeq_loc& loc, 
  2347.  const CCdregion& cdregion)
  2348. {
  2349.     TSeqPos len = GetLength(loc, m_Scope);
  2351.     ITERATE( CCdregion::TCode_break, cbr, cdregion.GetCode_break() ) {
  2352.         size_t codon_length = GetLength((*cbr)->GetLoc(), m_Scope);
  2353.         TSeqPos from = LocationOffset(loc, (*cbr)->GetLoc(), 
  2354.             eOffset_FromStart, m_Scope);
  2355.         TSeqPos to = from + codon_length - 1;
  2356.         
  2357.         // check for code break not on a codon
  2358.         if ( codon_length == 3  ||
  2359.             ((codon_length == 1 || codon_length == 2)  && 
  2360.             to == len - 1) ) {
  2361.             size_t start_pos;
  2362.             switch ( cdregion.GetFrame() ) {
  2363.             case CCdregion::eFrame_two:
  2364.                 start_pos = 1;
  2365.                 break;
  2366.             case CCdregion::eFrame_three:
  2367.                 start_pos = 2;
  2368.                 break;
  2369.             default:
  2370.                 start_pos = 0;
  2371.                 break;
  2372.             }
  2373.             if ( (from % 3) != start_pos ) {
  2374.                 PostErr(eDiag_Warning, eErr_SEQ_FEAT_TranslExceptPhase,
  2375.                     "transl_except qual out of frame.", feat);
  2376.             }
  2377.         }
  2378.     }
  2379. }
  2382. // Check for redundant gene Xref
  2383. void CValidError_feat::ValidateGeneXRef(const CSeq_feat& feat)
  2384. {
  2385.     const CGene_ref* grp = feat.GetGeneXref();
  2386.     if ( !grp  ||  grp->IsSuppressed() ) {
  2387.         return;
  2388.     }
  2390.     // !!! DEBUG {
  2391.     if( m_Imp.AvoidPerfBottlenecks() ) {
  2392.         return;
  2393.     } 
  2394.     // } DEBUG
  2395.     
  2396.     CConstRef<CSeq_feat> overlap = 
  2397.         GetOverlappingGene(feat.GetLocation(), *m_Scope);
  2398.     if ( !overlap ) {
  2399.         return;
  2400.     }
  2401.     
  2402.     const CGene_ref& gene = overlap->GetData().GetGene();
  2403.     if ( !gene.IsSuppressed() ) {
  2404.         if ( gene.CanGetAllele()  && !gene.GetAllele().empty() ) {
  2405.             const string& allele = gene.GetAllele();
  2407.             ITERATE(CSeq_feat::TQual, qual_iter, feat.GetQual()) {
  2408.                 const CGb_qual& qual = **qual_iter;
  2409.                 if ( qual.CanGetQual()  &&
  2410.                      NStr::Compare(qual.GetQual(), "allele") == 0 ) {
  2411.                     if ( qual.CanGetVal()  &&
  2412.                          NStr::CompareNocase(qual.GetVal(), allele) == 0 ) {
  2413.                         PostErr(eDiag_Warning, eErr_SEQ_FEAT_InvalidQualifierValue,
  2414.                             "Redundant allele qualifier (" + allele + 
  2415.                             ") on gene and feature", feat);
  2416.                     } else {
  2417.                         PostErr(eDiag_Warning, eErr_SEQ_FEAT_InvalidQualifierValue,
  2418.                             "Mismatched allele qualifier on gene (" + allele + 
  2419.                             ") and feature (" + qual.GetVal() +")", feat);
  2420.                     }
  2421.                 }
  2422.             }
  2423.         }
  2424.     }
  2426.     string label, gene_label;
  2427.     grp->GetLabel(&label);
  2428.     gene.GetLabel(&gene_label);
  2429.     
  2430.     if ( NStr::CompareNocase(label, gene_label) == 0 ) {
  2431.         PostErr(eDiag_Warning, eErr_SEQ_FEAT_UnnecessaryGeneXref,
  2432.             "Unnecessary gene cross-reference " + label, feat);
  2433.     }
  2434. }
  2437. void CValidError_feat::ValidateOperon(const CSeq_feat& gene)
  2438. {
  2439.     CConstRef<CSeq_feat> operon = 
  2440.         GetOverlappingOperon(gene.GetLocation(), *m_Scope);
  2441.     if ( !operon  ||  !operon->CanGetQual() ) {
  2442.         return;
  2443.     }
  2445.     string label;
  2446.     feature::GetLabel(gene, &label, feature::eContent, m_Scope);
  2447.     if ( label.empty() ) {
  2448.         return;
  2449.     }
  2451.     ITERATE(CSeq_feat::TQual, qual_iter, gene.GetQual()) {
  2452.         const CGb_qual& qual = **qual_iter;
  2453.         if( qual.CanGetQual()  &&  qual.CanGetVal() ) {
  2454.             if ( NStr::Compare(qual.GetQual(), "operon") == 0  &&
  2455.                  NStr::CompareNocase(qual.GetVal(), label) ) {
  2456.                 PostErr(eDiag_Warning, eErr_SEQ_FEAT_InvalidQualifierValue,
  2457.                     "Operon is same as gene - " + label, gene);
  2458.             }
  2459.         }
  2460.     }
  2461. }
  2464. bool CValidError_feat::IsPartialAtSpliceSite
  2465. (const CSeq_loc& loc,
  2466.  unsigned int tag)
  2467. {
  2468.     if ( tag != eSeqlocPartial_Nostart && tag != eSeqlocPartial_Nostop ) {
  2469.         return false;
  2470.     }
  2472.     CSeq_loc_CI first, last;
  2473.     for ( CSeq_loc_CI sl_iter(loc); sl_iter; ++sl_iter ) { // EQUIV_IS_ONE not supported
  2474.         if ( !first ) {
  2475.             first = sl_iter;
  2476.         }
  2477.         last = sl_iter;
  2478.     }
  2480.     if ( first.GetStrand() != last.GetStrand() ) {
  2481.         return false;
  2482.     }
  2483.     CSeq_loc_CI temp = (tag == eSeqlocPartial_Nostart) ? first : last;
  2485.     CBioseq_Handle bsh = m_Scope->GetBioseqHandle(temp.GetSeq_id());
  2486.     if ( !bsh ) {
  2487.         return false;
  2488.     }
  2489.     
  2490.     TSeqPos acceptor = temp.GetRange().GetFrom();
  2491.     TSeqPos donor = temp.GetRange().GetTo();
  2492.     TSeqPos start = acceptor;
  2493.     TSeqPos stop = donor;
  2495.     CSeqVector vec = bsh.GetSeqVector(CBioseq_Handle::eCoding_Iupac,
  2496.         temp.GetStrand());
  2497.     TSeqPos len = vec.size();
  2499.     if ( temp.GetStrand() == eNa_strand_minus ) {
  2500.         swap(acceptor, donor);
  2501.         stop = len - donor - 1;
  2502.         start = len - acceptor - 1;
  2503.     }
  2505.     bool result = false;
  2507.     
  2508.     if ( (tag == eSeqlocPartial_Nostop)  &&  (stop < len - 2) ) {
  2509.         try {
  2510.             CSeqVector::TResidue res1 = vec[stop + 1];
  2511.             CSeqVector::TResidue res2 = vec[stop + 2];
  2513.             if ( IsResidue(res1)  &&  IsResidue(res2) ) {
  2514.                 if ( (res1 == 'G'  &&  res2 == 'T')  || 
  2515.                     (res1 == 'G'  &&  res2 == 'C') ) {
  2516.                     result = true;
  2517.                 }
  2518.             }
  2519.         } catch ( exception& ) {
  2520.             return false;
  2521.         }
  2522.     } else if ( (tag == eSeqlocPartial_Nostart)  &&  (start > 1) ) {
  2523.         try {
  2524.             CSeqVector::TResidue res1 = vec[start - 2];    
  2525.             CSeqVector::TResidue res2 = vec[start - 1];
  2526.         
  2527.             if ( IsResidue(res1)  &&  IsResidue(res2) ) {
  2528.                 if ( (res1 == 'A')  &&  (res2 == 'G') ) { 
  2529.                     result = true;
  2530.                 }
  2531.             }
  2532.         } catch ( exception& ) {
  2533.             return false;
  2534.         }
  2535.     }
  2537.     return result;    
  2538. }
  2541. void CValidError_feat::ValidateFeatCit
  2542. (const CPub_set& cit,
  2543.  const CSeq_feat& feat)
  2544. {
  2545.     if ( !feat.CanGetCit() ) {
  2546.         return;
  2547.     }
  2549.     if ( cit.IsPub() ) {
  2550.         ITERATE( CPub_set::TPub, pi, cit.GetPub() ) {
  2551.             if ( (*pi)->IsEquiv() ) {
  2552.                 PostErr(eDiag_Warning, eErr_SEQ_FEAT_UnnecessaryCitPubEquiv,
  2553.                     "Citation on feature has unexpected internal Pub-equiv",
  2554.                     feat);
  2555.                 return;
  2556.             }
  2557.         }
  2558.     }
  2559. }
  2561. void CValidError_feat::ValidateFeatComment
  2562. (const string& comment,
  2563.  const CSeq_feat& feat)
  2564. {
  2565.     if ( m_Imp.IsSerialNumberInComment(comment) ) {
  2566.         PostErr(eDiag_Info, eErr_SEQ_FEAT_SerialInComment,
  2567.             "Feature comment may refer to reference by serial number - "
  2568.             "attach reference specific comments to the reference "
  2569.             "REMARK instead.", feat);
  2570.     }
  2571. }
  2574. void CValidError_feat::ValidateFeatBioSource
  2575. (const CBioSource& bsrc,
  2576.  const CSeq_feat& feat)
  2577. {
  2578.     if ( bsrc.CanGetIs_focus() ) {
  2579.         PostErr(eDiag_Error, eErr_SEQ_FEAT_FocusOnBioSourceFeature,
  2580.             "Focus must be on BioSource descriptor, not BioSource feature.",
  2581.             feat);
  2582.     }
  2584.     CBioseq_Handle bsh = m_Scope->GetBioseqHandle(feat.GetLocation());
  2585.     if ( !bsh ) {
  2586.         return;
  2587.     }
  2588.     CSeqdesc_CI dbsrc_i(bsh, CSeqdesc::e_Source);
  2589.     if ( !dbsrc_i ) {
  2590.         return;
  2591.     }
  2592.     
  2593.     const COrg_ref& org = bsrc.GetOrg();           
  2594.     const CBioSource& dbsrc = dbsrc_i->GetSource();
  2595.     const COrg_ref& dorg = dbsrc.GetOrg(); 
  2597.     if ( org.CanGetTaxname()  &&  !org.GetTaxname().empty()  &&
  2598.             dorg.CanGetTaxname() ) {
  2599.         string taxname = org.GetTaxname();
  2600.         string dtaxname = dorg.GetTaxname();
  2601.         if ( NStr::CompareNocase(taxname, dtaxname) != 0 ) {
  2602.             if ( !dbsrc.CanGetIs_focus()  &&  !IsTransgenic(dbsrc) ) {
  2603.                 PostErr(eDiag_Error, eErr_SEQ_DESCR_BioSourceNeedsFocus,
  2604.                     "BioSource descriptor must have focus or transgenic "
  2605.                     "when BioSource feature with different taxname is "
  2606.                     "present.", feat);
  2607.             }
  2608.         }
  2609.     }
  2610.     m_Imp.ValidateBioSource(bsrc, feat);
  2611. }
  2614. bool CValidError_feat::IsTransgenic(const CBioSource& bsrc)
  2615. {
  2616.     if ( bsrc.CanGetSubtype() ) {
  2617.         ITERATE( CBioSource::TSubtype, sub, bsrc.GetSubtype() ) {
  2618.             if ( (*sub)->GetSubtype() == CSubSource::eSubtype_transgenic ) {
  2619.                 return true;
  2620.             }
  2621.         }
  2622.     }
  2623.     return false;
  2624. }
  2627. // REQUIRES: feature is either Gene or mRNA
  2628. bool CValidError_feat::IsSameAsCDS(const CSeq_feat& feat)
  2629. {
  2630.     EOverlapType overlap_type;
  2631.     if ( feat.GetData().IsGene() ) {
  2632.         overlap_type = eOverlap_Simple;
  2633.     } else if ( feat.GetData().GetSubtype() == CSeqFeatData::eSubtype_mRNA ) {
  2634.         overlap_type = eOverlap_CheckIntervals;
  2635.     } else {
  2636.         return false;
  2637.     }
  2639.     CConstRef<CSeq_feat> cds = GetBestOverlappingFeat(
  2640.             feat.GetLocation(),
  2641.             CSeqFeatData::e_Cdregion,
  2642.             overlap_type,
  2643.             *m_Scope);
  2644.         if ( cds ) {
  2645.             if ( TestForOverlap(
  2646.                     cds->GetLocation(),
  2647.                     feat.GetLocation(),
  2648.                     eOverlap_Simple) == 0 ) {
  2649.                 return true;
  2650.             }
  2651.         }
  2652.     return false;
  2653. }
  2656. bool CValidError_feat::IsCDDFeat(const CSeq_feat& feat) const
  2657. {
  2658.     if ( feat.GetData().IsRegion() ) {
  2659.         if ( feat.CanGetDbxref() ) {
  2660.             ITERATE(CSeq_feat::TDbxref, db, feat.GetDbxref()) {
  2661.                 if ( (*db)->CanGetDb()  &&
  2662.                     NStr::Compare((*db)->GetDb(), "CDD") == 0 ) {
  2663.                     return true;
  2664.                 }
  2665.             }
  2666.         }
  2667.     }
  2668.     return false;
  2669. }
  2671. END_SCOPE(validator)
  2672. END_SCOPE(objects)
  2673. END_NCBI_SCOPE
  2676. /*
  2677. * ===========================================================================
  2678. *
  2679. * $Log: validerror_feat.cpp,v $
  2680. * Revision 1000.2  2004/06/01 19:48:04  gouriano
  2681. * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.56
  2682. *
  2683. * Revision 1.56  2004/05/26 14:53:30  shomrat
  2684. * removed non-preferred variants ribosome slippage, trans splicing, alternate processing, and non-consensus splice site
  2685. *
  2686. * Revision 1.55  2004/05/21 21:42:56  gorelenk
  2687. * Added PCH ncbi_pch.hpp
  2688. *
  2689. * Revision 1.54  2004/04/23 16:27:09  shomrat
  2690. * Stop using CBioseq_Handle deprecated interface
  2691. *
  2692. * Revision 1.53  2004/04/05 15:56:15  grichenk
  2693. * Redesigned CAnnotTypes_CI: moved all data and data collecting
  2694. * functions to CAnnotDataCollector. CAnnotTypes_CI is no more
  2695. * inherited from SAnnotSelector.
  2696. *
  2697. * Revision 1.52  2004/03/25 20:10:13  shomrat
  2698. * Fix statement with no effect
  2699. *
  2700. * Revision 1.51  2004/03/25 18:33:47  shomrat
  2701. * Bug fix
  2702. *
  2703. * Revision 1.50  2004/03/19 14:48:53  shomrat
  2704. * use ERR_SEQ_FEAT_PartialsInconsistent in two places
  2705. *
  2706. * Revision 1.49  2004/03/10 21:24:44  shomrat
  2707. * suppress eErr_SEQ_FEAT_AltStartCodon for GenBank/EMBL/DDBJ and Local
  2708. *
  2709. * Revision 1.48  2004/03/01 18:44:28  shomrat
  2710. * Check alternative start codon
  2711. *
  2712. * Revision 1.47  2004/02/05 20:08:32  shomrat
  2713. * Using convenience functions for overlapping features
  2714. *
  2715. * Revision 1.46  2004/01/16 20:09:15  shomrat
  2716. * Implemented check for locus tag problem
  2717. *
  2718. * Revision 1.45  2003/12/16 17:35:39  shomrat
  2719. * catch all exceptions, not just runtime
  2720. *
  2721. * Revision 1.44  2003/12/16 16:21:34  shomrat
  2722. * Implemented ValidateCdConflict
  2723. *
  2724. * Revision 1.43  2003/10/27 14:18:03  shomrat
  2725. * ValidateImp warns if repeat_region /rpt_unit has same length as feature location but does not have matching sequence
  2726. *
  2727. * Revision 1.42  2003/10/24 17:57:25  shomrat
  2728. * warn about allele gbqual when inheriting allele from gene; warn about operon when same as gene
  2729. *
  2730. * Revision 1.41  2003/10/21 13:21:52  shomrat
  2731. * added * Terminator codon
  2732. *
  2733. * Revision 1.40  2003/10/20 16:13:28  shomrat
  2734. * count gene and gene xrefs
  2735. *
  2736. * Revision 1.39  2003/10/13 18:48:52  shomrat
  2737. * added tests for TrnaCodonWrong and BadTrnaAA
  2738. *
  2739. * Revision 1.38  2003/10/13 12:49:37  shomrat
  2740. *                     // now any text will be allowed
  2741. *
  2742. * Revision 1.37  2003/10/01 21:00:24  shomrat
  2743. * suppress partial not at end warning for CDD region
  2744. *
  2745. * Revision 1.36  2003/09/22 20:25:10  shomrat
  2746. * lower severity for far product partial inconsistency and mrnatranscheck, also check for 95% polyA
  2747. *
  2748. * Revision 1.35  2003/07/24 20:16:18  vasilche
  2749. * Fixed typedefs for dbxref: list<CRef<CDbtag>> -> vector<CRef<CDbtag>>
  2750. *
  2751. * Revision 1.34  2003/07/21 21:19:43  shomrat
  2752. * Make sure we can get before trying to call GetXXX methods
  2753. *
  2754. * Revision 1.33  2003/07/02 21:04:48  shomrat
  2755. * added CheckCDSPartial to check cds->location partials against product molinfo
  2756. *
  2757. * Revision 1.32  2003/06/17 13:40:48  shomrat
  2758. * Use SeqVector_CI to improve performance
  2759. *
  2760. * Revision 1.31  2003/06/02 16:06:43  dicuccio
  2761. * Rearranged src/objects/ subtree.  This includes the following shifts:
  2762. *     - src/objects/asn2asn --> arc/app/asn2asn
  2763. *     - src/objects/testmedline --> src/objects/ncbimime/test
  2764. *     - src/objects/objmgr --> src/objmgr
  2765. *     - src/objects/util --> src/objmgr/util
  2766. *     - src/objects/alnmgr --> src/objtools/alnmgr
  2767. *     - src/objects/flat --> src/objtools/flat
  2768. *     - src/objects/validator --> src/objtools/validator
  2769. *     - src/objects/cddalignview --> src/objtools/cddalignview
  2770. * In addition, libseq now includes six of the objects/seq... libs, and libmmdb
  2771. * replaces the three libmmdb? libs.
  2772. *
  2773. * Revision 1.30  2003/05/28 16:25:42  shomrat
  2774. * Minor corrections.
  2775. *
  2776. * Revision 1.29  2003/05/15 20:00:44  shomrat
  2777. * Bug fix in ValidateImpGbquals
  2778. *
  2779. * Revision 1.28  2003/05/14 21:20:50  shomrat
  2780. * Changes to ValidateGeneXRef
  2781. *
  2782. * Revision 1.27  2003/05/05 15:36:15  shomrat
  2783. * Implemented ValidateCdsProductId
  2784. *
  2785. * Revision 1.26  2003/04/24 16:16:00  vasilche
  2786. * Added missing includes and forward class declarations.
  2787. *
  2788. * Revision 1.25  2003/04/07 14:58:36  shomrat
  2789. * Added information to error postings
  2790. *
  2791. * Revision 1.24  2003/04/04 18:42:22  shomrat
  2792. * Increased robustness in face of exceptions and minor bug fixes
  2793. *
  2794. * Revision 1.23  2003/03/31 14:40:13  shomrat
  2795. * $id: -> $id$
  2796. *
  2797. * Revision 1.22  2003/03/28 16:26:47  shomrat
  2798. * Removed IsResidue (moved to utilities)
  2799. *
  2800. * Revision 1.21  2003/03/21 21:15:27  shomrat
  2801. * Implemented ValidateSeqFeatProduct
  2802. *
  2803. * Revision 1.20  2003/03/20 18:56:44  shomrat
  2804. * Supress error in case of Seq-annot validation
  2805. *
  2806. * Revision 1.19  2003/03/18 21:48:37  grichenk
  2807. * Removed obsolete class CAnnot_CI
  2808. *
  2809. * Revision 1.18  2003/03/11 16:04:09  kuznets
  2810. * iterate -> ITERATE
  2811. *
  2812. * Revision 1.17  2003/02/14 21:54:21  shomrat
  2813. * Change use of GetBestOverlappingFeat due to addition of contains option
  2814. *
  2815. * Revision 1.16  2003/02/12 18:05:52  shomrat
  2816. * SerialNumberInComment was moved to validerror_imp; and a few bug fixes
  2817. *
  2818. * Revision 1.15  2003/02/10 15:54:02  grichenk
  2819. * Use CFeat_CI->GetMappedFeature() and GetOriginalFeature()
  2820. *
  2821. * Revision 1.14  2003/02/07 21:25:04  shomrat
  2822. * SameAsCDS checks partial gene or mRNA for CDS with proper intervals, drops severity to INFO; Bug fixes
  2823. *
  2824. * Revision 1.13  2003/02/03 20:21:41  shomrat
  2825. * Skip use of feature indexing if performance flag is set (testing)
  2826. *
  2827. * Revision 1.12  2003/02/03 18:03:22  shomrat
  2828. * Change in use of GetSequenceView and style improvments
  2829. *
  2830. * Revision 1.11  2003/01/31 18:28:03  shomrat
  2831. * Re-implementation of ValidateBadGeneOverlap
  2832. *
  2833. * Revision 1.10  2003/01/30 20:26:17  shomrat
  2834. * Explicitly call sequence::Compare
  2835. *
  2836. * Revision 1.9  2003/01/29 21:58:26  shomrat
  2837. * Commented check for multiple CDS due to feature indexing implementation issues
  2838. *
  2839. * Revision 1.8  2003/01/29 17:50:06  shomrat
  2840. * Bug fix in ValidateExceptText
  2841. *
  2842. * Revision 1.7  2003/01/24 21:21:00  shomrat
  2843. * Bug fixes in ValidateMrnaTrans & ValidateBadGeneOverlap
  2844. *
  2845. * Revision 1.6  2003/01/21 20:11:11  shomrat
  2846. * Added check for RNA product mismatch
  2847. *
  2848. * Revision 1.5  2003/01/10 16:29:51  shomrat
  2849. * Added Checks for eErr_SEQ_FEAT_UnnecessaryCitPubEquiv and eErr_SEQ_DESCR_BioSourceNeedsFocus
  2850. *
  2851. * Revision 1.4  2003/01/06 16:43:01  shomrat
  2852. * naming convention
  2853. *
  2854. * Revision 1.3  2003/01/02 22:13:04  shomrat
  2855. * Implemented checks relying on overlapping features (IsOverlappingGenePseudo, PeptideOnCodonBoundry, CommonCDSProduct, BadMRNAOverlap, BadGeneOverlap, GeneXRef); Check for bad product seq id in ValidateSeqFeat
  2856. *
  2857. * Revision 1.2  2002/12/24 16:54:02  shomrat
  2858. * Changes to include directives
  2859. *
  2860. * Revision 1.1  2002/12/23 20:16:34  shomrat
  2861. * Initial submission after splitting former implementation
  2862. *
  2863. *
  2864. * ===========================================================================
  2865. */