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

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

生物技术

开发平台：

C/C++

feature_item.cpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: feature_item.cpp,v $
  4.  * PRODUCTION Revision 1000.2  2004/06/01 19:44:14  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.26
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. /*  $Id: feature_item.cpp,v 1000.2 2004/06/01 19:44:14 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:  Aaron Ucko, NCBI
  36. *          Mati Shomrat
  37. *
  38. * File Description:
  39. *   new (early 2003) flat-file generator -- representation of features
  40. *   (mainly of interest to implementors)
  41. *
  42. * ===========================================================================
  43. */
  44. #include <ncbi_pch.hpp>
  45. #include <corelib/ncbistd.hpp>
  46. #include <serial/iterator.hpp>
  48. #include <objects/seq/Bioseq.hpp>
  49. #include <objects/seq/Heterogen.hpp>
  50. #include <objects/seqfeat/Org_ref.hpp>
  51. #include <objects/seqfeat/OrgName.hpp>
  52. #include <objects/seqfeat/OrgMod.hpp>
  53. #include <objects/seqfeat/Code_break.hpp>
  54. #include <objects/seqfeat/Genetic_code.hpp>
  55. #include <objects/seqfeat/Genetic_code_table.hpp>
  56. #include <objects/seqfeat/Imp_feat.hpp>
  57. #include <objects/seqfeat/RNA_ref.hpp>
  58. #include <objects/seqfeat/Trna_ext.hpp>
  59. #include <objects/seqloc/Seq_loc.hpp>
  60. #include <objects/seqloc/Seq_point.hpp>
  61. #include <objects/seqloc/Seq_interval.hpp>
  62. #include <objects/seqloc/Packed_seqpnt.hpp>
  63. #include <objects/seqloc/Textseq_id.hpp>
  64. #include <objects/general/Object_id.hpp>
  66. #include <objmgr/scope.hpp>
  67. #include <objmgr/seqdesc_ci.hpp>
  68. #include <objmgr/seq_vector.hpp>
  69. #include <objmgr/seq_loc_mapper.hpp>
  70. #include <objmgr/util/sequence.hpp>
  71. #include <objmgr/util/feature.hpp>
  73. #include <util/static_set.hpp>
  74. #include <util/static_map.hpp>
  75. #include <util/sequtil/sequtil.hpp>
  76. #include <util/sequtil/sequtil_convert.hpp>
  78. #include <algorithm>
  79. #include <objtools/format/formatter.hpp>
  80. #include <objtools/format/items/feature_item.hpp>
  81. #include <objtools/format/context.hpp>
  82. #include <objtools/format/items/qualifiers.hpp>
  83. #include "utils.hpp"
  85. // On Mac OS X 10.3, FixMath.h defines ff as a one-argument macro(!)
  86. #ifdef ff
  87. #  undef ff
  88. #endif
  90. BEGIN_NCBI_SCOPE
  91. BEGIN_SCOPE(objects)
  92. USING_SCOPE(sequence);
  95. // -- static functions
  97. const CGb_qual* s_GetQual(const CSeq_feat& feat, const string& qual)
  98. {
  99.     ITERATE(CSeq_feat::TQual, it, feat.GetQual()) {
  100.         if ( (*it)->CanGetQual()  &&
  101.              NStr::CompareNocase((*it)->GetQual(), qual) == 0  &&
  102.              (*it)->CanGetVal()  &&  !(*it)->GetVal().empty() ) {
  103.             return *it;
  104.         }
  105.     }
  106.     return 0;
  107. }
  110. static bool s_ValidId(const CSeq_id& id)
  111. {
  112.     return id.IsGenbank()  ||  id.IsEmbl()    ||  id.IsDdbj()  ||
  113.            id.IsOther()    ||  id.IsPatent()  ||  
  114.            id.IsTpg()      ||  id.IsTpe()     ||  id.IsTpd();
  115. }
  118. static bool s_CheckQuals_cdregion(const CSeq_feat& feat, CBioseqContext& ctx)
  119. {
  120.     if ( !ctx.Config().CheckCDSProductId() ) {
  121.         return true;
  122.     }
  123.     
  124.     CScope& scope = ctx.GetScope();
  126.     // non-pseudo CDS must have /product
  127.     bool pseudo = feat.CanGetPseudo()  &&  feat.GetPseudo();
  128.     if ( !pseudo ) {
  129.         const CGene_ref* grp = feat.GetGeneXref();
  130.         if ( grp == 0 ) {
  131.             CConstRef<CSeq_feat> gene = 
  132.                 GetOverlappingGene(feat.GetLocation(), scope);
  133.             if ( gene ) {
  134.                 pseudo = gene->CanGetPseudo()  &&  gene->GetPseudo();
  135.                 if ( !pseudo ) {
  136.                     grp = &(gene->GetData().GetGene());
  137.                 }
  138.             }
  139.         }
  140.         if ( !pseudo  &&  grp != 0 ) {
  141.             pseudo = grp->GetPseudo();
  142.         }
  143.     }
  145.     bool just_stop = false;
  146.     if ( feat.CanGetLocation() ) {
  147.         const CSeq_loc& loc = feat.GetLocation();
  148.         if ( loc.IsPartialLeft()  &&  !loc.IsPartialRight() ) {
  149.             if ( GetLength(loc, &scope) <= 5 ) {
  150.                 just_stop = true;
  151.             }
  152.         }
  153.     }
  155.     if ( pseudo ||  just_stop ) {
  156.         return true;
  157.     } 
  159.     // make sure the product has a valid accession
  160.     if ( feat.CanGetProduct() ) {
  161.         const CSeq_id* id = 0;
  162.         try {
  163.             id = &(GetId(feat.GetProduct(), &ctx.GetScope()));
  164.         } catch ( CException& ) {}
  165.         if ( id != 0 ) {
  166.             if ( (id->IsGi()  &&  id->GetGi() > 0) ||  id->IsLocal() ) {
  167.                 CBioseq_Handle prod = scope.GetBioseqHandle(*id);
  168.                 if ( prod ) {
  169.                     ITERATE (CBioseq_Handle::TId, it, prod.GetId()) {
  170.                         if ( s_ValidId(*it->GetSeqId()) ) {
  171.                             const CTextseq_id* tsip = it->GetSeqId()->GetTextseq_Id();
  172.                             if ( tsip != 0  &&  tsip->IsSetAccession()  &&
  173.                                  ValidateAccession(tsip->GetAccession()) ) {
  174.                                 return true;
  175.                             }
  176.                         }
  177.                     }
  178.                 } else if ( id->IsGi()  &&  id->GetGi() > 0 ) {
  179.                     // RELEASE_MODE requires that /protein_id is an accession
  180.                     // !!! need to be able to retrieve accession from server withou
  181.                     // retrieving the entire bioseq
  182.                     return true;
  183.                 }
  184.             } else if ( s_ValidId(*id) ) {
  185.                 const CTextseq_id* tsip = id->GetTextseq_Id();
  186.                 if ( tsip != 0  &&  tsip->CanGetAccession()  &&
  187.                      ValidateAccession(tsip->GetAccession()) ) {
  188.                     return true;
  189.                 }
  190.             }
  191.         }
  192.     } else {  // no product
  193.         if ( feat.CanGetExcept()  &&  feat.GetExcept()  &&
  194.              feat.CanGetExcept_text() ) {
  195.             if ( NStr::Find(feat.GetExcept_text(),
  196.                     "rearrangement required for product") != NPOS ) {
  197.                 return true;
  198.             }
  199.         }
  200.     }
  202.     return false;
  203. }
  206. // conflict and old_sequence require a publication printable on the segment
  207. static bool s_HasPub(const CSeq_feat& feat, CBioseqContext& ctx)
  208. {
  209.     if ( !feat.CanGetCit() ) {
  210.         return false;
  211.     }
  213.     ITERATE(CBioseqContext::TReferences, it, ctx.GetReferences()) {
  214.         if ( (*it)->Matches(feat.GetCit()) ) {
  215.             return true;
  216.         }
  217.     }
  219.     return false;
  220. }
  223. static bool s_CheckQuals_conflict(const CSeq_feat& feat, CBioseqContext& ctx)
  224. {
  225.     if ( !feat.CanGetCit() ) {
  226.         // RefSeq allows conflict with accession in comment instead of sfp->cit
  227.         if ( ctx.IsRefSeq()  &&
  228.              feat.CanGetComment()  &&  !feat.GetComment().empty() ) {
  229.             return true;
  230.         }
  231.     } else {
  232.         return s_HasPub(feat, ctx);
  233.     }
  235.     return false;
  236. }
  239. static bool s_CheckQuals_old_seq(const CSeq_feat& feat, CBioseqContext& ctx)
  240. {    
  241.     return s_HasPub(feat, ctx);
  242. }
  245. static bool s_CheckQuals_gene(const CSeq_feat& feat)
  246. {
  247.     // gene requires /gene or /locus_tag, but desc or syn can be mapped to /gene
  248.     const CSeqFeatData::TGene& gene = feat.GetData().GetGene();
  249.     if ( (gene.CanGetLocus()      &&  !gene.GetLocus().empty())      ||
  250.          (gene.CanGetLocus_tag()  &&  !gene.GetLocus_tag().empty())  ||
  251.          (gene.CanGetDesc()       &&  !gene.GetDesc().empty())       ||
  252.          (!gene.GetSyn().empty()  &&  !gene.GetSyn().front().empty()) ) {
  253.         return true;
  254.     }
  256.     return false;
  257. }
  260. static bool s_CheckQuals_bind(const CSeq_feat& feat)
  261. {
  262.     // protein_bind or misc_binding require eFQ_bound_moiety
  263.     return s_GetQual(feat, "bound_moiety") != 0;
  264. }
  267. static bool s_CheckQuals_mod_base(const CSeq_feat& feat)
  268. {
  269.     // modified_base requires eFQ_mod_base
  270.     return s_GetQual(feat, "mod_base") != 0;
  271. }
  274. static bool s_CheckMandatoryQuals(const CSeq_feat& feat, CBioseqContext& ctx)
  275. {
  276.     switch ( feat.GetData().GetSubtype() ) {
  277.     case CSeqFeatData::eSubtype_cdregion:
  278.         {
  279.             return s_CheckQuals_cdregion(feat, ctx);
  280.         }
  281.     case CSeqFeatData::eSubtype_conflict:
  282.         {
  283.             return s_CheckQuals_conflict(feat, ctx);
  284.         }
  285.     case CSeqFeatData::eSubtype_old_sequence:
  286.         {
  287.             return s_CheckQuals_old_seq(feat, ctx);
  288.         }
  289.     case CSeqFeatData::eSubtype_gene:
  290.         {
  291.             return s_CheckQuals_gene(feat);
  292.         }
  293.     case CSeqFeatData::eSubtype_protein_bind:
  294.     case CSeqFeatData::eSubtype_misc_binding:
  295.         {
  296.             return s_CheckQuals_bind(feat);
  297.         }
  298.     case CSeqFeatData::eSubtype_modified_base:
  299.         {
  300.             return s_CheckQuals_mod_base(feat);
  301.         }
  302.     default:
  303.         break;
  304.     }
  306.     return true;
  307. }
  310. static bool s_SkipFeature(const CSeq_feat& feat, CBioseqContext& ctx)
  311. {
  312.     CSeqFeatData::E_Choice type    = feat.GetData().Which();
  313.     CSeqFeatData::ESubtype subtype = feat.GetData().GetSubtype();        
  314.    
  315.     if ( subtype == CSeqFeatData::eSubtype_pub              ||
  316.          subtype == CSeqFeatData::eSubtype_non_std_residue  ||
  317.          subtype == CSeqFeatData::eSubtype_biosrc           ||
  318.          subtype == CSeqFeatData::eSubtype_rsite            ||
  319.          subtype == CSeqFeatData::eSubtype_seq ) {
  320.         return true;
  321.     }
  322.     
  323.     const CFlatFileConfig& cfg = ctx.Config();
  325.     // check feature customization flags
  326.     if ( cfg.ValidateFeats()  &&
  327.         (subtype == CSeqFeatData::eSubtype_bad  ||
  328.          subtype == CSeqFeatData::eSubtype_virion) ) {
  329.         return true;
  330.     }
  331.     
  332.     if ( ctx.IsNuc()  &&  subtype == CSeqFeatData::eSubtype_het ) {
  333.         return true;
  334.     }
  335.     
  336.     if ( cfg.HideImpFeats()  &&  type == CSeqFeatData::e_Imp ) {
  337.         return true;
  338.     }
  339.     
  340.     if ( cfg.HideSNPFeatures()  &&  subtype == CSeqFeatData::eSubtype_variation ) {
  341.         return true;
  342.     }
  344.     if ( cfg.HideExonFeatures()  &&  subtype == CSeqFeatData::eSubtype_exon ) {
  345.         return true;
  346.     }
  348.     if ( cfg.HideIntronFeatures()  &&  subtype == CSeqFeatData::eSubtype_intron ) {
  349.         return true;
  350.     }
  352.     if ( cfg.HideRemoteImpFeats()  &&  type == CSeqFeatData::e_Imp ) {
  353.         if ( subtype == CSeqFeatData::eSubtype_variation  ||
  354.              subtype == CSeqFeatData::eSubtype_exon       ||
  355.              subtype == CSeqFeatData::eSubtype_intron     ||
  356.              subtype == CSeqFeatData::eSubtype_misc_feature ) {
  357.             return true;
  358.         }
  359.     }
  361.     // skip genes in DDBJ format
  362.     if ( cfg.IsFormatDDBJ()  &&  type == CSeqFeatData::e_Gene ) {
  363.         return true;
  364.     }
  366.     // To Do:
  367.     // !!! supress full length comment features
  369.     // if RELEASE mode, make sure we have all info to create mandatory quals.
  370.     if ( cfg.NeedRequiredQuals() ) {
  371.         return !s_CheckMandatoryQuals(feat, ctx);
  372.     }
  374.     return false;
  375. }
  378. static const string s_BondList[] = {
  379.     "",
  380.     "disulfide",
  381.     "thiolester",
  382.     "xlink",
  383.     "thioether",
  384.     "unclassified"
  385. };
  388. static const string s_SiteList[] = {
  389.     "",
  390.     "active",
  391.     "binding",
  392.     "cleavage",
  393.     "inhibit",
  394.     "modified",
  395.     "glycosylation",
  396.     "myristoylation",
  397.     "mutagenized",
  398.     "metal-binding",
  399.     "phosphorylation",
  400.     "acetylation",
  401.     "amidation",
  402.     "methylation",
  403.     "hydroxylation",
  404.     "sulfatation",
  405.     "oxidative-deamination",
  406.     "pyrrolidone-carboxylic-acid",
  407.     "gamma-carboxyglutamic-acid",
  408.     "blocked",
  409.     "lipid-binding",
  410.     "np-binding",
  411.     "DNA binding",
  412.     "signal-peptide",
  413.     "transit-peptide",
  414.     "transmembrane-region",
  415.     "unclassified"
  416. };
  419. static const string s_PsecStrText[] = {
  420.     "",
  421.     "helix",
  422.     "sheet",
  423.     "turn"
  424. };
  427. // -- FeatureHeader
  429. CFeatHeaderItem::CFeatHeaderItem(CBioseqContext& ctx) : CFlatItem(&ctx)
  430. {
  431.     x_GatherInfo(ctx);
  432. }
  435. void CFeatHeaderItem::x_GatherInfo(CBioseqContext& ctx)
  436. {
  437.     if ( ctx.Config().IsFormatFTable() ) {
  438.         m_Id.Reset(ctx.GetPrimaryId());
  439.     }
  440. }
  443. // -- FeatureItem
  447. // constructor
  448. CFeatureItemBase::CFeatureItemBase
  449. (const CSeq_feat& feat,
  450.  CBioseqContext& ctx,
  451.  const CSeq_loc* loc) :
  452.     CFlatItem(&ctx), m_Feat(&feat), m_Loc(loc != 0 ? loc : &feat.GetLocation())
  453. {
  454. }
  457. CConstRef<CFlatFeature> CFeatureItemBase::Format(void) const
  458. {
  459.     CRef<CFlatFeature> ff(new CFlatFeature(GetKey(),
  460.                           *new CFlatSeqLoc(GetLoc(), *GetContext()),
  461.                           *m_Feat));
  462.     if ( ff ) {
  463.         x_FormatQuals(*ff);
  464.     }
  465.     return ff;
  466. }
  469. static bool s_CheckFuzz(const CInt_fuzz& fuzz)
  470. {
  471.     return !(fuzz.IsLim()  &&  fuzz.GetLim() == CInt_fuzz::eLim_unk);
  472. }
  475. static bool s_LocIsFuzz(const CSeq_feat& feat, const CSeq_loc& loc)
  476. {
  477.     if ( feat.GetData().GetSubtype() == CSeqFeatData::eSubtype_imp  &&
  478.          feat.GetData().IsImp() ) {  // unmappable impfeats
  479.         const CSeqFeatData::TImp& imp = feat.GetData().GetImp();
  480.         if ( imp.CanGetLoc() ) {
  481.             const string& imploc = imp.GetLoc();
  482.             if ( imploc.find('<') != NPOS  ||  imploc.find('>') != NPOS ) {
  483.                 return true;
  484.             }
  485.         }
  486.     } else {    // any regular feature test location for fuzz
  487.         for ( CSeq_loc_CI it(loc); it; ++it ) {
  488.             const CSeq_loc& l = it.GetSeq_loc();
  489.             switch ( l.Which() ) {
  490.             case CSeq_loc::e_Pnt:
  491.             {{
  492.                 if ( l.GetPnt().CanGetFuzz() ) {
  493.                     if ( s_CheckFuzz(l.GetPnt().GetFuzz()) ) {
  494.                         return true;
  495.                     }
  496.                 }
  497.                 break;
  498.             }}
  499.             case CSeq_loc::e_Packed_pnt:
  500.             {{
  501.                 if ( l.GetPacked_pnt().CanGetFuzz() ) {
  502.                     if ( s_CheckFuzz(l.GetPacked_pnt().GetFuzz()) ) {
  503.                         return true;
  504.                     }
  505.                 }
  506.                 break;
  507.             }}
  508.             case CSeq_loc::e_Int:
  509.             {{
  510.                 bool fuzz = false;
  511.                 if ( l.GetInt().CanGetFuzz_from() ) {
  512.                     fuzz = s_CheckFuzz(l.GetInt().GetFuzz_from());
  513.                 }
  514.                 if ( !fuzz  &&  l.GetInt().CanGetFuzz_to() ) {
  515.                     fuzz = s_CheckFuzz(l.GetInt().GetFuzz_to());
  516.                 }
  517.                 if ( fuzz ) {
  518.                     return true;
  519.                 }
  520.                 break;
  521.             }}
  522.             default:
  523.                 break;
  524.             }
  525.         }
  526.     }
  528.     return false;
  529. }
  532. /////////////////////////////////////////////////////////////////////////////
  533. //  CFeatureItem
  535. string CFeatureItem::GetKey(void) const
  536. {
  537.     CBioseqContext& ctx = *GetContext();
  539.     CSeqFeatData::E_Choice type = m_Feat->GetData().Which();
  540.     CSeqFeatData::ESubtype subtype = m_Feat->GetData().GetSubtype();
  542.     if ( GetContext()->IsProt() ) {
  543.         if ( IsMappedFromProt()  &&  type == CSeqFeatData::e_Prot ) {
  544.             if ( subtype == CSeqFeatData::eSubtype_preprotein         ||
  545.                  subtype == CSeqFeatData::eSubtype_mat_peptide_aa     ||
  546.                 subtype == CSeqFeatData::eSubtype_sig_peptide_aa     ||
  547.                 subtype == CSeqFeatData::eSubtype_transit_peptide_aa ) {
  548.                 return "Precursor";
  549.             } 
  550.         }
  551.         switch ( subtype ) {
  552.         case CSeqFeatData::eSubtype_region:
  553.             return "Region";
  554.         case CSeqFeatData::eSubtype_bond:
  555.             return "Bond";
  556.         case CSeqFeatData::eSubtype_site:
  557.             return "Site";
  558.         default:
  559.             break;
  560.         }
  561.     } else if ( subtype == CSeqFeatData::eSubtype_preprotein  &&  !ctx.IsRefSeq() ) {
  562.         return "misc_feature";
  563.     }
  565.     // deal with unmappable impfeats
  566.     if ( subtype == CSeqFeatData::eSubtype_imp  &&  type == CSeqFeatData::e_Imp ) {
  567.         const CSeqFeatData::TImp& imp = m_Feat->GetData().GetImp();
  568.         if ( imp.CanGetKey() ) {
  569.             return imp.GetKey();
  570.         }
  571.     }
  573.     return CFeatureItemBase::GetKey();
  574. }
  577. // constructor from CSeq_feat
  578. CFeatureItem::CFeatureItem
  579. (const CSeq_feat& feat,
  580.  CBioseqContext& ctx,
  581.  const CSeq_loc* loc,
  582.  EMapped mapped) :
  583.     CFeatureItemBase(feat, ctx, loc), m_Mapped(mapped)
  584. {
  585.     x_GatherInfo(ctx);
  586. }
  589. void CFeatureItem::x_GatherInfo(CBioseqContext& ctx)
  590. {
  591.     if ( s_SkipFeature(GetFeat(), ctx) ) {
  592.         x_SetSkip();
  593.         return;
  594.     }
  595.     m_Type = m_Feat->GetData().GetSubtype();
  596.     //x_FixLocation(ctx);
  597.     x_AddQuals(ctx);
  598. }
  601. void CFeatureItem::x_AddQuals(CBioseqContext& ctx)
  602. {
  603.     if ( ctx.Config().IsFormatFTable() ) {
  604.         x_AddFTableQuals(ctx);
  605.         return;
  606.     }
  608.     CScope&             scope = ctx.GetScope();
  609.     const CSeqFeatData& data  = m_Feat->GetData();
  610.     const CSeq_loc&     loc   = GetLoc();
  611.     CSeqFeatData::E_Choice type = data.Which();
  612.     CSeqFeatData::ESubtype subtype = data.GetSubtype();
  614.     bool pseudo = m_Feat->CanGetPseudo() ? m_Feat->GetPseudo() : false;
  615.     bool had_prot_desc = false;
  616.     string precursor_comment;
  618.     // add various common qualifiers...
  620.     // partial
  621.     if ( !(IsMappedFromCDNA()  &&  ctx.IsProt())  &&
  622.          !ctx.Config().HideUnclassPartial() ) {
  623.         if ( m_Feat->CanGetPartial()  &&  m_Feat->GetPartial() ) {
  624.             if ( !s_LocIsFuzz(*m_Feat, loc) ) {
  625.                 int partial = SeqLocPartialCheck(m_Feat->GetLocation(), &scope);
  626.                 if ( partial == eSeqlocPartial_Complete ) {
  627.                     x_AddQual(eFQ_partial, new CFlatBoolQVal(true));
  628.                 }
  629.             }
  630.         }
  631.     }
  632.     
  633.     // dbxref
  634.     if (m_Feat->IsSetDbxref()) {
  635.         x_AddQual(eFQ_db_xref, new CFlatXrefQVal(m_Feat->GetDbxref(), &m_Quals));
  636.     }
  637.     // model_evidance and go quals
  638.     if ( m_Feat->IsSetExt() ) {
  639.         x_AddExtQuals(m_Feat->GetExt());
  640.     }
  641.     // evidence
  642.     if ( !ctx.IsProt()  &&  m_Feat->IsSetExp_ev() ) {
  643.         x_AddQual(eFQ_evidence, new CFlatExpEvQVal(m_Feat->GetExp_ev()));
  644.     }
  645.     // citation
  646.     if (m_Feat->IsSetCit()) {
  647.         x_AddQual(eFQ_citation, new CFlatPubSetQVal(m_Feat->GetCit()));
  648.     }
  649.     // exception
  650.     x_AddExceptionQuals(ctx);
  652.     if ( !data.IsGene()  &&  (subtype != CSeqFeatData::eSubtype_operon) ) {
  653.         const CGene_ref* grp = m_Feat->GetGeneXref();
  654.         CConstRef<CSeq_feat> overlap_gene;
  655.         if ( grp != 0  &&  grp->CanGetDb() ) {
  656.             x_AddQual(eFQ_gene_xref, new CFlatXrefQVal(grp->GetDb()));
  657.         }
  658.         if ( grp == 0 ) {
  659.             const CSeq_loc& gene_loc = (ctx.IsProt()  ||  !IsMapped()) ? 
  660.                 m_Feat->GetLocation() : GetLoc();
  661.             overlap_gene = GetOverlappingGene(gene_loc, scope);
  662.             if ( overlap_gene ) {
  663.                 if ( overlap_gene->CanGetComment() ) {
  664.                     x_AddQual(eFQ_gene_note,
  665.                         new CFlatStringQVal(overlap_gene->GetComment()));
  666.                 }
  667.                 if ( overlap_gene->CanGetPseudo()  &&  overlap_gene->GetPseudo() ) {
  668.                     pseudo = true;
  669.                 }
  670.                 grp = &overlap_gene->GetData().GetGene();
  671.                 if ( grp != 0  &&  grp->IsSetDb() ) {
  672.                     x_AddQual(eFQ_gene_xref, new CFlatXrefQVal(grp->GetDb()));
  673.                 } else if ( overlap_gene->IsSetDbxref() ) {
  674.                     x_AddQual(eFQ_gene_xref, new CFlatXrefQVal(overlap_gene->GetDbxref()));
  675.                 }
  676.             }
  677.         }
  678.         if ( grp != 0 ) {
  679.             if (grp->CanGetPseudo()  &&  grp->GetPseudo() ) {
  680.                 pseudo = true;
  681.             }
  682.             if ( !grp->IsSuppressed()  &&
  683.                 (!overlap_gene  ||
  684.                  subtype != CSeqFeatData::eSubtype_repeat_region) ) {
  685.                 x_AddQuals(*grp);
  686.             }
  687.             if ( subtype != CSeqFeatData::eSubtype_variation ) {
  688.                 if ( grp->IsSetAllele()  &&  !grp->GetAllele().empty() ) {
  689.                     // now propagating /allele
  690.                     x_AddQual(eFQ_gene_allele, new CFlatStringQVal(grp->GetAllele()));
  691.                 }
  692.             }
  693.         }
  694.         if ( type != CSeqFeatData::e_Cdregion  &&  type !=  CSeqFeatData::e_Rna ) {
  695.             x_RemoveQuals(eFQ_gene_xref);
  696.         }
  697.     }
  699.     // specific fields set here...
  700.     switch ( type ) {
  701.     case CSeqFeatData::e_Gene:
  702.         x_AddGeneQuals(*m_Feat, scope);
  703.         break;
  704.     case CSeqFeatData::e_Cdregion:
  705.         x_AddCdregionQuals(*m_Feat, ctx, pseudo, had_prot_desc);
  706.         break;
  707.     case CSeqFeatData::e_Rna:
  708.         x_AddRnaQuals(*m_Feat, ctx, pseudo);
  709.         break;
  710.     case CSeqFeatData::e_Prot:
  711.         x_AddProtQuals(*m_Feat, ctx, pseudo, had_prot_desc, precursor_comment);
  712.         break;
  713.     case CSeqFeatData::e_Region:
  714.         x_AddRegionQuals(*m_Feat, ctx);
  715.         break;
  716.     // !!! case CSeqFeatData::e_XXX:
  717.     default:
  718.         break;
  719.     }
  720.     
  721.     if ( pseudo ) {
  722.         bool add_pseudo = true;
  724.         // if RELEASE_MODE, check list of features that can have /pseudo
  725.         if ( ctx.Config().DropIllegalQuals()  &&
  726.              (data.IsRna()  ||  data.IsImp()) ) {
  727.             switch ( subtype ) {
  728.             case  CSeqFeatData::eSubtype_allele:
  729.             case  CSeqFeatData::eSubtype_attenuator:
  730.             case  CSeqFeatData::eSubtype_CAAT_signal:
  731.             case  CSeqFeatData::eSubtype_conflict:
  732.             case  CSeqFeatData::eSubtype_D_loop:
  733.             case  CSeqFeatData::eSubtype_enhancer:
  734.             case  CSeqFeatData::eSubtype_GC_signal:
  735.             case  CSeqFeatData::eSubtype_iDNA:
  736.             case  CSeqFeatData::eSubtype_intron:
  737.             case  CSeqFeatData::eSubtype_LTR:
  738.             case  CSeqFeatData::eSubtype_misc_binding:
  739.             case  CSeqFeatData::eSubtype_misc_difference:
  740.             case  CSeqFeatData::eSubtype_misc_recomb:
  741.             case  CSeqFeatData::eSubtype_misc_RNA:
  742.             case  CSeqFeatData::eSubtype_misc_signal:
  743.             case  CSeqFeatData::eSubtype_misc_structure:
  744.             case  CSeqFeatData::eSubtype_modified_base:
  745.             case  CSeqFeatData::eSubtype_mutation:
  746.             case  CSeqFeatData::eSubtype_old_sequence:
  747.             case  CSeqFeatData::eSubtype_polyA_signal:
  748.             case  CSeqFeatData::eSubtype_polyA_site:
  749.             case  CSeqFeatData::eSubtype_precursor_RNA:
  750.             case  CSeqFeatData::eSubtype_prim_transcript:
  751.             case  CSeqFeatData::eSubtype_primer_bind:
  752.             case  CSeqFeatData::eSubtype_protein_bind:
  753.             case  CSeqFeatData::eSubtype_RBS:
  754.             case  CSeqFeatData::eSubtype_repeat_region:
  755.             case  CSeqFeatData::eSubtype_repeat_unit:
  756.             case  CSeqFeatData::eSubtype_rep_origin:
  757.             case  CSeqFeatData::eSubtype_satellite:
  758.             case  CSeqFeatData::eSubtype_stem_loop:
  759.             case  CSeqFeatData::eSubtype_STS:
  760.             case  CSeqFeatData::eSubtype_TATA_signal:
  761.             case  CSeqFeatData::eSubtype_terminator:
  762.             case  CSeqFeatData::eSubtype_unsure:
  763.             case  CSeqFeatData::eSubtype_variation:
  764.             case  CSeqFeatData::eSubtype_3clip:
  765.             case  CSeqFeatData::eSubtype_3UTR:
  766.             case  CSeqFeatData::eSubtype_5clip:
  767.             case  CSeqFeatData::eSubtype_5UTR:
  768.             case  CSeqFeatData::eSubtype_10_signal:
  769.             case  CSeqFeatData::eSubtype_35_signal:
  770.                 add_pseudo = false;
  771.                 break;
  772.             default:
  773.                 break;
  774.             }
  775.         }
  776.         if ( add_pseudo ) {
  777.             x_AddQual(eFQ_pseudo, new CFlatBoolQVal(true));
  778.         }
  779.     }
  780.     // comment
  781.     if (m_Feat->IsSetComment()) {
  782.         string comment = m_Feat->GetComment();
  783.         if ( had_prot_desc  &&  NStr::EndsWith(m_Feat->GetComment(), ".") ) {
  784.             comment.erase(comment.length() - 1);
  785.         }
  786.         if ( precursor_comment != comment ) {
  787.             x_AddQual(eFQ_seqfeat_note, new CFlatStringQVal(comment));
  788.         }
  789.     }
  791.     // now go through gbqual list
  792.     if (m_Feat->IsSetQual()) {
  793.         x_ImportQuals(m_Feat->GetQual());
  794.     }
  796.     // cleanup (drop illegal quals, duplicate information etc.)
  797.     x_CleanQuals();
  798. }
  801. static const string s_TrnaList[] = {
  802.   "tRNA-Gap",
  803.   "tRNA-Ala",
  804.   "tRNA-Asx",
  805.   "tRNA-Cys",
  806.   "tRNA-Asp",
  807.   "tRNA-Glu",
  808.   "tRNA-Phe",
  809.   "tRNA-Gly",
  810.   "tRNA-His",
  811.   "tRNA-Ile",
  812.   "tRNA-Lys",
  813.   "tRNA-Leu",
  814.   "tRNA-Met",
  815.   "tRNA-Asn",
  816.   "tRNA-Pro",
  817.   "tRNA-Gln",
  818.   "tRNA-Arg",
  819.   "tRNA-Ser",
  820.   "tRNA-Thr",
  821.   "tRNA-Sec",
  822.   "tRNA-Val",
  823.   "tRNA-Trp",
  824.   "tRNA-OTHER",
  825.   "tRNA-Tyr",
  826.   "tRNA-Glx",
  827.   "tRNA-TERM"
  828. };
  831. static const string& s_AaName(int aa)
  832. {
  833.     int shift = 0, idx = 255;
  835.     if ( aa <= 74 ) {
  836.         shift = 0;
  837.     } else if (aa > 79) {
  838.         shift = 2;
  839.     } else {
  840.         shift = 1;
  841.     }
  842.     if (aa != '*') {
  843.         idx = aa - (64 + shift);
  844.     } else {
  845.         idx = 25;
  846.     }
  847.     if ( idx > 0 && idx < 26 ) {
  848.         return s_TrnaList [idx];
  849.     }
  850.     return kEmptyStr;
  851. }
  854. static int s_ToIupacaa(int aa)
  855. {
  856.     vector<char> n(1, static_cast<char>(aa));
  857.     vector<char> i;
  858.     CSeqConvert::Convert(n, CSeqUtil::e_Ncbieaa, 0, 1, i, CSeqUtil::e_Iupacaa);
  859.     return i.front();
  860. }
  863. void CFeatureItem::x_AddRnaQuals
  864. (const CSeq_feat& feat,
  865.  CBioseqContext& ctx,
  866.  bool& pseudo) const
  867. {
  868.     const CRNA_ref& rna = feat.GetData().GetRna();
  869.     const CFlatFileConfig& cfg = ctx.Config();
  871.     if ( rna.CanGetPseudo()  &&  rna.GetPseudo() ) {
  872.         pseudo = true;
  873.     }
  875.     CRNA_ref::TType rna_type = rna.CanGetType() ?
  876.         rna.GetType() : CRNA_ref::eType_unknown;
  877.     switch ( rna_type ) {
  878.     case CRNA_ref::eType_tRNA:
  879.     {
  880.         if ( rna.CanGetExt() ) {
  881.             const CRNA_ref::C_Ext& ext = rna.GetExt();
  882.             switch ( ext.Which() ) {
  883.             case CRNA_ref::C_Ext::e_Name:
  884.             {
  885.                 // amino acid could not be parsed into structured form
  886.                 if ( !cfg.DropIllegalQuals() ) {
  887.                     x_AddQual(eFQ_product,
  888.                               new CFlatStringQVal(ext.GetName()));
  889.                 } else {
  890.                     x_AddQual(eFQ_product,
  891.                               new CFlatStringQVal("tRNA-OTHER"));
  892.                 }
  893.                 break;
  894.             }
  895.             case CRNA_ref::C_Ext::e_TRNA:
  896.             {
  897.                 const CTrna_ext& trna = ext.GetTRNA();
  898.                 int aa = 0;
  899.                 if ( trna.CanGetAa()  &&  trna.GetAa().IsNcbieaa() ) {
  900.                     aa = trna.GetAa().GetNcbieaa();
  901.                 } else {
  902.                     // !!!
  903.                     return;
  904.                 }
  905.                 if ( cfg.IupacaaOnly() ) {
  906.                     aa = s_ToIupacaa(aa);
  907.                 }
  908.                 const string& aa_str = s_AaName(aa);
  909.                 if ( !aa_str.empty() ) {
  910.                     x_AddQual(eFQ_product, new CFlatStringQVal(aa_str));
  911.                     if ( trna.CanGetAnticodon()  &&  !aa_str.empty() ) {
  912.                         x_AddQual(eFQ_anticodon,
  913.                             new CFlatAnticodonQVal(trna.GetAnticodon(),
  914.                                                    aa_str.substr(5, NPOS)));
  915.                     }
  916.                 }
  917.                 if ( trna.IsSetCodon() ) {
  918.                     x_AddQual(eFQ_trna_codons, new CFlatTrnaCodonsQVal(trna));
  919.                 }
  920.                 break;
  921.             }
  922.             default:
  923.                 break;
  924.             } // end of internal switch
  925.         }
  926.         break;
  927.     }
  928.     case CRNA_ref::eType_mRNA:
  929.     {
  930.         try {
  931.             if ( feat.CanGetProduct() ) {
  932.                 const CSeq_id& id = GetId(feat.GetProduct(), &ctx.GetScope());
  933.                 CBioseq_Handle prod = 
  934.                     ctx.GetScope().GetBioseqHandleFromTSE(id, ctx.GetHandle());
  935.                 EFeatureQualifier slot = 
  936.                     (ctx.IsRefSeq()  ||  cfg.IsModeDump()  ||  cfg.IsModeGBench()) ?
  937.                     eFQ_transcript_id : eFQ_transcript_id_note;
  938.                 if ( prod ) {
  939.                     x_AddProductIdQuals(prod, slot);
  940.                 } else {
  941.                     x_AddQual(slot, new CFlatSeqIdQVal(id));
  942.                     if ( id.IsGi() ) {
  943.                         x_AddQual(eFQ_db_xref, new CFlatSeqIdQVal(id, true));
  944.                     }
  945.                 }
  946.             }
  947.         } catch (CNotUnique&) {}
  948.         if ( !pseudo  &&  cfg.ShowTranscript() ) {
  949.             CSeqVector vec(feat.GetLocation(), ctx.GetScope());
  950.             vec.SetCoding(CBioseq_Handle::eCoding_Iupac);
  951.             string transcription;
  952.             vec.GetSeqData(0, vec.size(), transcription);
  953.             x_AddQual(eFQ_transcription, new CFlatStringQVal(transcription));
  954.         }
  955.         // intentional fall through
  956.     }
  957.     default:
  958.         if ( rna.CanGetExt()  &&  rna.GetExt().IsName() ) {
  959.             x_AddQual(eFQ_product, new CFlatStringQVal(rna.GetExt().GetName()));
  960.         }
  961.         break;
  962.     } // end of switch
  963. }
  966. void CFeatureItem::x_AddGeneQuals(const CSeq_feat& gene, CScope& scope) const
  967. {
  968.     _ASSERT(gene.GetData().Which() == CSeqFeatData::e_Gene);
  970.     x_AddQuals(gene.GetData().GetGene());
  971.     CConstRef<CSeq_feat> operon =
  972.         GetOverlappingOperon(gene.GetLocation(), scope);
  973.     if ( operon ) {
  974.         ITERATE (CSeq_feat::TQual, it, operon->GetQual()) {
  975.             if ( (*it)->CanGetQual()  &&  (*it)->GetQual() == "operon"  &&
  976.                  (*it)->CanGetVal() ) {
  977.                 x_AddQual(eFQ_operon, new CFlatStringQVal((*it)->GetVal()));
  978.             }
  979.         }
  980.     }
  981. }
  984. void CFeatureItem::x_AddCdregionQuals
  985. (const CSeq_feat& cds,
  986.  CBioseqContext& ctx,
  987.  bool& pseudo, bool& had_prot_desc) const
  988. {
  989.     CScope& scope = ctx.GetScope();
  990.     const CFlatFileConfig& cfg = ctx.Config();
  991.     
  992.     x_AddQuals(cds.GetData().GetCdregion());
  993.     if ( ctx.IsProt()  &&  IsMappedFromCDNA() ) {
  994.         x_AddQual(eFQ_coded_by, new CFlatSeqLocQVal(m_Feat->GetLocation()));
  995.     } else {
  996.         // protein qualifiers
  997.         if ( m_Feat->CanGetProduct() ) {
  998.             const CSeq_id* prot_id = 0;
  999.             // protein id
  1000.             try {
  1001.                 prot_id = &GetId(m_Feat->GetProduct(), &scope);
  1002.                 CBioseq_Handle h = scope.GetBioseqHandle(*prot_id);
  1003.                 if (h) {
  1004.                     prot_id = &GetId(h, eGetId_Best);
  1005.                 }
  1006.             } catch (CException&) {
  1007.                 prot_id = 0;
  1008.             }
  1009.             
  1010.             if ( prot_id != 0 ) {
  1011.                 CBioseq_Handle prot;
  1012.                 if ( !cfg.AlwaysTranslateCDS() ) {
  1013.                     // by default only show /translation if product bioseq is within
  1014.                     // entity, but flag can override and force far /translation
  1015.                     prot = cfg.ShowFarTranslations() ? 
  1016.                         scope.GetBioseqHandle(*prot_id) : 
  1017.                         scope.GetBioseqHandleFromTSE(*prot_id, ctx.GetHandle());
  1018.                 }
  1019.                 const CProt_ref* pref = 0;
  1020.                 if ( prot ) {
  1021.                     // Add protein quals (comment, note, names ...) 
  1022.                     pref = x_AddProteinQuals(prot);
  1023.                 } else {
  1024.                     x_AddQual(eFQ_protein_id, new CFlatSeqIdQVal(*prot_id));
  1025.                     if ( prot_id->IsGi() ) {
  1026.                         x_AddQual(eFQ_db_xref, new CFlatSeqIdQVal(*prot_id, true));
  1027.                     }
  1028.                 }
  1029.                 
  1030.                 // protein xref overrides names, but should not prevent /protein_id, etc.
  1031.                 const CProt_ref* p = m_Feat->GetProtXref();
  1032.                 if ( p != 0 ) {
  1033.                     pref = p;
  1034.                 }
  1035.                 if ( pref != 0 ) {
  1036.                     if ( !pref->GetName().empty() ) {
  1037.                         CProt_ref::TName names = pref->GetName();
  1038.                         x_AddQual(eFQ_cds_product, new CFlatStringQVal(names.front()));
  1039.                         names.pop_front();
  1040.                         if ( !names.empty() ) {
  1041.                             x_AddQual(eFQ_prot_names, new CFlatStringListQVal(names));
  1042.                         }
  1043.                     }
  1044.                     if ( pref->CanGetDesc() ) {
  1045.                         x_AddQual(eFQ_prot_desc, new CFlatStringQVal(pref->GetDesc()));
  1046.                         had_prot_desc = true;
  1047.                     }
  1048.                     if ( !pref->GetActivity().empty() ) {
  1049.                         x_AddQual(eFQ_prot_activity,
  1050.                             new CFlatStringListQVal(pref->GetActivity()));
  1051.                     }
  1052.                     if ( !pref->GetEc().empty() ) {
  1053.                         x_AddQual(eFQ_prot_EC_number,
  1054.                             new CFlatStringListQVal(pref->GetEc()));
  1055.                     }
  1056.                 }
  1058.                 // translation
  1059.                 if ( !pseudo ) {
  1060.                     string translation;
  1061.                     if ( (!prot  &&  cfg.TranslateIfNoProduct())  ||
  1062.                         cfg.AlwaysTranslateCDS() ) {
  1063.                         CCdregion_translate::TranslateCdregion(translation, *m_Feat,
  1064.                             scope);
  1065.                     } else if ( prot ) {
  1066.                         TSeqPos len = GetLength(cds.GetProduct(), &scope);
  1067.                         if ( len > 0 ){
  1068.                             CSeqVector seqv = 
  1069.                                 prot.GetSeqVector(CBioseq_Handle::eCoding_Ncbi);
  1070.                             if ( cfg.IupacaaOnly() ) {
  1071.                                 seqv.SetCoding(CSeq_data::e_Iupacaa);
  1072.                             } else {
  1073.                                 seqv.SetCoding(CSeq_data::e_Ncbieaa);
  1074.                             }
  1075.                             seqv.GetSeqData(0, seqv.size(), translation);
  1076.                         }
  1077.                     }
  1078.                     if ( !translation.empty() ) {
  1079.                         x_AddQual(eFQ_translation, new CFlatStringQVal(translation));
  1080.                     } else {
  1081.                         // !!! release mode error
  1082.                     }
  1083.                 }
  1084.             }
  1085.         }
  1086.     }
  1087. }
  1090. const CProt_ref* CFeatureItem::x_AddProteinQuals(CBioseq_Handle& prot) const
  1091. {
  1092.     _ASSERT(prot);
  1094.     x_AddProductIdQuals(prot, eFQ_protein_id);
  1096.     CSeqdesc_CI comm(prot, CSeqdesc::e_Comment, 1);
  1097.     if ( comm  &&  !comm->GetComment().empty() ) {
  1098.         x_AddQual(eFQ_prot_comment, new CFlatStringQVal(comm->GetComment()));
  1099.     }
  1101.     CSeqdesc_CI mi(prot, CSeqdesc::e_Molinfo);
  1102.     if ( mi ) {
  1103.         CMolInfo::TTech prot_tech = mi->GetMolinfo().GetTech();
  1104.         if ( prot_tech >  CMolInfo::eTech_standard       &&
  1105.              prot_tech != CMolInfo::eTech_concept_trans  &&
  1106.              prot_tech != CMolInfo::eTech_concept_trans_a ) {
  1107.             if ( !GetTechString(prot_tech).empty() ) {
  1108.                 x_AddQual(eFQ_prot_method, 
  1109.                     new CFlatStringQVal("Method: " + GetTechString(prot_tech)));
  1110.             }
  1111.         }
  1112.     }
  1114.     const CProt_ref* pref = 0;
  1115.     CFeat_CI prot_feat(prot, 0, 0, CSeqFeatData::e_Prot);
  1116.     if ( prot_feat ) {
  1117.         pref = &(prot_feat->GetData().GetProt());
  1118.         if ( prot_feat->IsSetComment() ) {
  1119.             if ( pref->GetProcessed() == CProt_ref::eProcessed_not_set  ||
  1120.                  pref->GetProcessed() == CProt_ref::eProcessed_preprotein ) {
  1121.                 x_AddQual(eFQ_prot_note, 
  1122.                     new CFlatStringQVal(prot_feat->GetComment()));
  1123.             }
  1124.         }
  1125.     }
  1127.     bool maploc = false, fig = false;
  1128.     for ( CSeqdesc_CI it(prot, CSeqdesc::e_Pub); it; ++it ) {
  1129.         const CPubdesc& pub = it->GetPub();
  1130.         if ( !maploc  &&  pub.CanGetMaploc() ) {
  1131.             string mapstr = "Map location " + pub.GetMaploc();
  1132.             RemovePeriodFromEnd(mapstr);
  1133.             x_AddQual(eFQ_maploc, new CFlatStringQVal(mapstr));
  1134.             maploc = true;
  1135.         }
  1136.         if ( !fig  &&  pub.CanGetFig() ) {
  1137.             string figstr = "This sequence comes from " + pub.GetFig();
  1138.             RemovePeriodFromEnd(figstr);
  1139.             x_AddQual(eFQ_figure, new CFlatStringQVal(figstr));
  1140.             fig = true;
  1141.         }
  1142.     }
  1143.     return pref;
  1144. }
  1147. static const string s_ValidExceptionText[] = {
  1148.   "RNA editing",
  1149.   "reasons given in citation"
  1150. };
  1153. static const string s_ValidRefSeqExceptionText[] = {
  1154.     "RNA editing",
  1155.     "alternative processing",
  1156.     "alternative start codon",
  1157.     "artificial frameshift",
  1158.     "modified codon recognition",
  1159.     "nonconsensus splice site",
  1160.     "rearrangement required for product",
  1161.     "reasons given in citation",
  1162.     "ribosomal slippage",
  1163.     "trans-splicing",
  1164.     "unclassified transcription discrepancy",
  1165.     "unclassified translation discrepancy"
  1166. };
  1169. static bool s_IsValidExceptionText(const string& text)
  1170. {
  1171.     CStaticArraySet<string> legal_text(s_ValidExceptionText,
  1172.         sizeof(s_ValidExceptionText));
  1173.     return legal_text.find(text) != legal_text.end();
  1174. }
  1177. static bool s_IsValidRefSeqExceptionText(const string& text)
  1178. {
  1179.     CStaticArraySet<string> legal_refseq_text(s_ValidRefSeqExceptionText,
  1180.         sizeof(s_ValidRefSeqExceptionText));
  1181.     return legal_refseq_text.find(text) != legal_refseq_text.end();
  1182. }
  1185. static void s_ParseException
  1186. (const string& original,
  1187.  string& except,
  1188.  string& note,
  1189.  CBioseqContext& ctx)
  1190. {
  1191.     if ( original.empty() ) {
  1192.         return;
  1193.     }
  1195.     except.erase();
  1196.     note.erase();
  1198.     if ( !ctx.Config().DropIllegalQuals() ) {
  1199.         except = original;
  1200.         return;
  1201.     }
  1203.     list<string> l;
  1204.     NStr::Split(original, ",", l);
  1205.     NON_CONST_ITERATE (list<string>, it, l) {
  1206.         NStr::TruncateSpaces(*it);
  1207.     }
  1209.     list<string> except_list, note_list;
  1211.     ITERATE (list<string>, it, l) {
  1212.         if ( s_IsValidExceptionText(*it)  ||
  1213.              s_IsValidRefSeqExceptionText(*it) ) {
  1214.             except_list.push_back(*it);
  1215.         } else {
  1216.             note_list.push_back(*it);
  1217.         }
  1218.     }
  1220.     except = NStr::Join(except_list, ", ");
  1221.     note = NStr::Join(note_list, ", ");
  1222. }
  1225. void CFeatureItem::x_AddExceptionQuals(CBioseqContext& ctx) const
  1226. {
  1227.     string except_text, note_text;
  1228.     const CFlatFileConfig& cfg = ctx.Config();
  1230.     if ( m_Feat->CanGetExcept_text()  &&  !m_Feat->GetExcept_text().empty() ) {
  1231.         except_text = m_Feat->GetExcept_text();
  1232.     }
  1233.     
  1234.     // /exception currently legal only on cdregion
  1235.     if ( m_Feat->GetData().IsCdregion()  ||  !cfg.DropIllegalQuals() ) {
  1236.         // exception flag is set, but no exception text supplied
  1237.         if ( except_text.empty()  &&
  1238.              m_Feat->CanGetExcept()  &&  m_Feat->GetExcept() ) {
  1239.             // if no /exception text, use text in comment, remove from /note
  1240.             if ( x_HasQual(eFQ_seqfeat_note) ) {
  1241.                 const CFlatStringQVal* qval = 
  1242.                     dynamic_cast<const CFlatStringQVal*>(x_GetQual(eFQ_seqfeat_note).first->second.GetPointerOrNull());
  1243.                 if ( qval != 0 ) {
  1244.                     const string& seqfeat_note = qval->GetValue();
  1245.                     if ( !cfg.DropIllegalQuals()  ||
  1246.                         s_IsValidExceptionText(seqfeat_note) ) {
  1247.                         except_text = seqfeat_note;
  1248.                         x_RemoveQuals(eFQ_seqfeat_note);
  1249.                     }
  1250.                 }
  1251.             } else {
  1252.                 except_text = "No explanation supplied";
  1253.             }
  1255.             // if DropIllegalQuals is set, check CDS list here as well
  1256.             if ( cfg.DropIllegalQuals()  &&
  1257.                  !s_IsValidExceptionText(except_text) ) {
  1258.                 except_text.erase();
  1259.             }
  1260.         }
  1261.         
  1262.         if ( cfg.DropIllegalQuals() ) {
  1263.             string except = except_text;
  1264.             s_ParseException(except, except_text, note_text, ctx);
  1265.         }
  1266.     } else if ( !except_text.empty() ) {
  1267.         note_text = except_text;
  1268.         except_text.erase();
  1269.     }
  1271.     if ( !except_text.empty() ) {
  1272.         x_AddQual(eFQ_exception, new CFlatStringQVal(except_text));
  1273.     }
  1274.     if ( !note_text.empty() ) {
  1275.         x_AddQual(eFQ_exception_note, new CFlatStringQVal(note_text));
  1276.     }
  1277. }
  1280. void CFeatureItem::x_AddProductIdQuals(CBioseq_Handle& prod, EFeatureQualifier slot) const
  1281. {
  1282.     if ( !prod ) {
  1283.         return;
  1284.     }
  1286.     const CBioseq::TId& ids = prod.GetBioseqCore()->GetId();
  1287.     if ( ids.empty() ) {
  1288.         return;
  1289.     }
  1291.     // the product id (transcript or protein) is set to the best id
  1292.     const CSeq_id* best = FindBestChoice(ids, CSeq_id::Score);
  1293.     if ( best != 0 ) {
  1294.         switch ( best->Which() ) {
  1295.         case CSeq_id::e_Genbank:
  1296.         case CSeq_id::e_Embl:
  1297.         case CSeq_id::e_Ddbj:
  1298.         case CSeq_id::e_Gi:
  1299.         case CSeq_id::e_Other:
  1300.         case CSeq_id::e_General:
  1301.         case CSeq_id::e_Tpg:
  1302.         case CSeq_id::e_Tpe:
  1303.         case CSeq_id::e_Tpd:
  1304.             // these are the only types we allow as product ids
  1305.             break;
  1306.         default:
  1307.             best = 0;
  1308.         }
  1309.     }
  1310.     if ( best == 0 ) {
  1311.         return;
  1312.     }
  1313.     x_AddQual(slot, new CFlatSeqIdQVal(*best));
  1315.     ITERATE (CBioseq::TId, it, ids) {
  1316.         const CSeq_id& id = **it;
  1317.         CSeq_id::E_Choice choice = id.Which();
  1318.         if ( choice != CSeq_id::e_Genbank  &&
  1319.              choice != CSeq_id::e_Embl  &&
  1320.              choice != CSeq_id::e_Ddbj  &&
  1321.              choice != CSeq_id::e_Gi  &&
  1322.              choice != CSeq_id::e_Other  &&
  1323.              choice != CSeq_id::e_General  &&
  1324.              choice != CSeq_id::e_Tpg  &&
  1325.              choice != CSeq_id::e_Tpe  &&
  1326.              choice != CSeq_id::e_Tpd ) {
  1327.             continue;
  1328.         }
  1330.         if ( &id == best  &&  !id.IsGi() ) {
  1331.             // we've already done 'best'. 
  1332.             continue;
  1333.         }
  1334.         if ( id.IsGeneral() ) {
  1335.             const CDbtag& dbt = id.GetGeneral();
  1336.             if ( dbt.GetType() != CDbtag::eDbtagType_PID ) {
  1337.                 if ( ids.size() == 1 ) {
  1338.                     x_AddQual(eFQ_db_xref, new CFlatSeqIdQVal(id, id.IsGi()));
  1339.                 }
  1340.             }
  1341.         } else {
  1342.             x_AddQual(eFQ_db_xref, new CFlatSeqIdQVal(id, id.IsGi()));
  1343.         }
  1344.     }
  1345. }
  1348. void CFeatureItem::x_AddRegionQuals(const CSeq_feat& feat, CBioseqContext& ctx) const
  1349. {
  1350.     const string& region = feat.GetData().GetRegion();
  1351.     if ( region.empty() ) {
  1352.         return;
  1353.     }
  1355.     if ( ctx.IsProt()  &&
  1356.          feat.GetData().GetSubtype() == CSeqFeatData::eSubtype_region ) {
  1357.         x_AddQual(eFQ_region_name, new CFlatStringQVal(region));
  1358.     } else {
  1359.         x_AddQual(eFQ_region, new CFlatStringQVal("Region: " + region));
  1360.     }
  1361. }
  1364. void CFeatureItem::x_AddExtQuals(const CSeq_feat::TExt& ext) const
  1365. {
  1366.     ITERATE (CUser_object::TData, it, ext.GetData()) {
  1367.         const CUser_field& field = **it;
  1368.         if ( !field.CanGetData() ) {
  1369.             continue;
  1370.         }
  1371.         if ( field.GetData().IsObject() ) {
  1372.             const CUser_object& obj = field.GetData().GetObject();
  1373.             x_AddExtQuals(obj);
  1374.             return;
  1375.         } else if ( field.GetData().IsObjects() ) {
  1376.             ITERATE (CUser_field::C_Data::TObjects, o, field.GetData().GetObjects()) {
  1377.                 x_AddExtQuals(**o);
  1378.             }
  1379.             return;
  1380.         }
  1381.     }
  1382.     if ( ext.CanGetType()  &&  ext.GetType().IsStr() ) {
  1383.         const string& oid = ext.GetType().GetStr();
  1384.         if ( oid == "ModelEvidence" ) {
  1385.             x_AddQual(eFQ_modelev, new CFlatModelEvQVal(ext));
  1386.         } else if ( oid == "GeneOntology" ) {
  1387.             x_AddGoQuals(ext);
  1388.         }
  1389.     }
  1390. }
  1393. void CFeatureItem::x_AddGoQuals(const CUser_object& uo) const
  1394. {
  1395.     ITERATE (CUser_object::TData, uf_it, uo.GetData()) {
  1396.         const CUser_field& field = **uf_it;
  1397.         if ( field.IsSetLabel()  &&  field.GetLabel().IsStr() ) {
  1398.             const string& label = field.GetLabel().GetStr();
  1399.             EFeatureQualifier slot = eFQ_none;
  1400.             if ( label == "Process" ) {
  1401.                 slot = eFQ_go_process;
  1402.             } else if ( label == "Component" ) {               
  1403.                 slot = eFQ_go_component;
  1404.             } else if ( label == "Function" ) {
  1405.                 slot = eFQ_go_function;
  1406.             }
  1407.             if ( slot == eFQ_none ) {
  1408.                 continue;
  1409.             }
  1411.             ITERATE (CUser_field::TData::TFields, it, field.GetData().GetFields()) {
  1412.                 if ( (*it)->GetData().IsFields() ) {
  1413.                     x_AddQual(slot, new CFlatGoQVal(**it));
  1414.                 }
  1415.             }
  1416.         }
  1417.     }
  1418. }
  1421. void CFeatureItem::x_AddQuals(const CGene_ref& gene) const
  1422. {
  1423.     const string* locus = (gene.IsSetLocus()  &&  !gene.GetLocus().empty()) ?
  1424.         &gene.GetLocus() : 0;
  1425.     
  1426.     const string* desc = (gene.IsSetDesc() &&  !gene.GetDesc().empty()) ?
  1427.         &gene.GetDesc() : 0;
  1428.     const CGene_ref::TSyn* syn = (gene.IsSetSyn()  &&  !gene.GetSyn().empty()) ?
  1429.         &gene.GetSyn() : 0;
  1430.     const string* locus_tag = 
  1431.         (gene.IsSetLocus_tag()  &&  !gene.GetLocus_tag().empty()) ?
  1432.         &gene.GetLocus_tag() : 0;
  1434.     if ( locus ) {
  1435.         x_AddQual(eFQ_gene, new CFlatStringQVal(*locus));
  1436.         if ( locus_tag ) {
  1437.             x_AddQual(eFQ_locus_tag, new CFlatStringQVal(*locus_tag));
  1438.         }
  1439.         if ( desc ) {
  1440.             x_AddQual(eFQ_gene_desc, new CFlatStringQVal(*desc));
  1441.         }
  1442.         if ( syn ) {
  1443.             x_AddQual(eFQ_gene_syn, new CFlatStringListQVal(*syn));
  1444.         }
  1445.     } else if ( locus_tag ) {
  1446.         x_AddQual(eFQ_locus_tag, new CFlatStringQVal(*locus_tag));
  1447.         if ( desc ) {
  1448.             x_AddQual(eFQ_gene_desc, new CFlatStringQVal(*desc));
  1449.         }
  1450.         if ( syn ) {
  1451.             x_AddQual(eFQ_gene_syn, new CFlatStringListQVal(*syn));
  1452.         }
  1453.     } else if ( desc ) {
  1454.         x_AddQual(eFQ_gene, new CFlatStringQVal(*desc));
  1455.         if ( syn ) {
  1456.             x_AddQual(eFQ_gene_syn, new CFlatStringListQVal(*syn));
  1457.         }
  1458.     } else if ( syn ) {
  1459.         CGene_ref::TSyn syns = *syn;
  1460.         x_AddQual(eFQ_gene, new CFlatStringQVal(syns.front()));
  1461.         syns.pop_front();
  1462.         if ( !syns.empty() ) {
  1463.             x_AddQual(eFQ_gene_syn, new CFlatStringListQVal(syns));
  1464.         }
  1465.     }
  1467.     if ( gene.IsSetAllele()  &&  !gene.GetAllele().empty() ) {
  1468.         x_AddQual(eFQ_gene_allele, new CFlatStringQVal(gene.GetAllele()));
  1469.     }
  1470.     if ( gene.IsSetMaploc()  &&  !gene.GetMaploc().empty() ) {
  1471.         x_AddQual(eFQ_gene_map, new CFlatStringQVal(gene.GetMaploc()));
  1472.     }
  1473.     if ( gene.IsSetDb() ) {
  1474.         x_AddQual(eFQ_gene_xref, new CFlatXrefQVal(gene.GetDb()));
  1475.     }
  1476.     if ( gene.GetPseudo() ) {
  1477.         x_AddQual(eFQ_pseudo, new CFlatBoolQVal(true));
  1478.     }
  1479. }
  1482. void CFeatureItem::x_AddQuals(const CCdregion& cds) const
  1483. {
  1484.     CBioseqContext& ctx = *GetContext();
  1485.     CScope& scope = ctx.GetScope();
  1487.     CCdregion::TFrame frame = cds.GetFrame();
  1489.     // code break
  1490.     if ( cds.IsSetCode_break() ) {
  1491.         // set selenocysteine quals
  1492.         ITERATE (CCdregion::TCode_break, it, cds.GetCode_break()) {
  1493.             if ( !(*it)->IsSetAa() ) {
  1494.                 continue;
  1495.             }
  1496.             const CCode_break::C_Aa& cbaa = (*it)->GetAa();
  1497.             bool is_U = false;
  1498.             switch ( cbaa.Which() ) {
  1499.             case CCode_break::C_Aa::e_Ncbieaa:
  1500.                 is_U = (cbaa.GetNcbieaa() == 'U');
  1501.                 break;
  1502.             case CCode_break::C_Aa::e_Ncbi8aa:
  1503.                 is_U = (cbaa.GetNcbieaa() == 'U');
  1504.             case CCode_break::C_Aa::e_Ncbistdaa:
  1505.                 is_U = (cbaa.GetNcbieaa() == 24);
  1506.                 break;
  1507.             default:
  1508.                 break;
  1509.             }
  1510.             
  1511.             if ( is_U ) {
  1512.                 if ( ctx.Config().SelenocysteineToNote() ) {
  1513.                     x_AddQual(eFQ_selenocysteine_note,
  1514.                         new CFlatStringQVal("selenocysteine"));
  1515.                 } else {
  1516.                     x_AddQual(eFQ_selenocysteine, new CFlatBoolQVal(true));
  1517.                 }
  1518.                 break;
  1519.             }
  1520.         }
  1521.     }
  1523.     // translation table
  1524.     if ( cds.CanGetCode() ) {
  1525.         int gcode = cds.GetCode().GetId();
  1526.         if ( gcode > 0  &&  gcode != 255 ) {
  1527.             // show code 1 only in GBSeq format.
  1528.             if ( ctx.Config().IsFormatGBSeq()  ||  gcode > 1 ) {
  1529.                 x_AddQual(eFQ_transl_table, new CFlatIntQVal(gcode));
  1530.             }
  1531.         }
  1532.     }
  1534.     if ( !(ctx.IsProt()  && IsMappedFromCDNA()) ) {
  1535.         // frame
  1536.         if ( frame == CCdregion::eFrame_not_set ) {
  1537.             frame = CCdregion::eFrame_one;
  1538.         }
  1539.         x_AddQual(eFQ_codon_start, new CFlatIntQVal(frame));
  1541.         // translation exception
  1542.         if ( cds.IsSetCode_break() ) {
  1543.             x_AddQual(eFQ_transl_except, 
  1544.                 new CFlatCodeBreakQVal(cds.GetCode_break()));
  1545.         }
  1546.         
  1547.         // protein conflict
  1548.         static const string conflic_msg = 
  1549.             "Protein sequence is in conflict with the conceptual translation";
  1550.         bool has_prot = m_Feat->IsSetProduct()  &&
  1551.                         (GetLength(m_Feat->GetProduct(), &scope) > 0);
  1552.         if ( cds.CanGetConflict()  &&  cds.GetConflict()  &&  has_prot ) {
  1553.             x_AddQual(eFQ_prot_conflict, new CFlatStringQVal(conflic_msg));
  1554.         }
  1555.     } else {
  1556.         // frame
  1557.         if ( frame > 1 ) {
  1558.             x_AddQual(eFQ_codon_start, new CFlatIntQVal(frame));
  1559.         }
  1560.     }
  1561. }
  1563. void CFeatureItem::x_AddProtQuals
  1564. (const CSeq_feat& feat,
  1565.  CBioseqContext& ctx, 
  1566.  bool& pseudo,
  1567.  bool& had_prot_desc,
  1568.  string& precursor_comment) const
  1569. {
  1570.     const CProt_ref& pref = feat.GetData().GetProt();
  1571.     CProt_ref::TProcessed processed = pref.GetProcessed();
  1573.     if ( ctx.IsNuc()  ||  (ctx.IsProt()  &&  !IsMappedFromProt()) ) {
  1574.         if ( pref.IsSetName()  &&  !pref.GetName().empty() ) {
  1575.             CProt_ref::TName names = pref.GetName();
  1576.             x_AddQual(eFQ_product, new CFlatStringQVal(names.front()));
  1577.             names.pop_front();
  1578.             if ( !names.empty() ) {
  1579.                 x_AddQual(eFQ_prot_names, new CFlatStringListQVal(names));
  1580.             }
  1581.         }
  1582.         if ( pref.CanGetDesc()  &&  !pref.GetDesc().empty() ) {
  1583.             if ( !ctx.IsProt() ) {
  1584.                 x_AddQual(eFQ_prot_desc, new CFlatStringQVal(pref.GetDesc()));
  1585.                 had_prot_desc = true;
  1586.             } else {
  1587.                 x_AddQual(eFQ_prot_name, new CFlatStringQVal(pref.GetDesc()));
  1588.             }
  1589.         }
  1590.         if ( pref.IsSetActivity()  &&  !pref.GetActivity().empty() ) {
  1591.             if ( ctx.IsNuc()  ||  processed != CProt_ref::eProcessed_mature ) {
  1592.                 x_AddQual(eFQ_prot_activity, 
  1593.                     new CFlatStringListQVal(pref.GetActivity()));
  1594.             }
  1595.         }
  1596.         if ( feat.CanGetProduct() ) {
  1597.             CBioseq_Handle prot = 
  1598.                 ctx.GetScope().GetBioseqHandle(feat.GetProduct());
  1599.             if ( prot ) {
  1600.                 x_AddProductIdQuals(prot, eFQ_protein_id);
  1601.             } else {
  1602.                 try {
  1603.                     const CSeq_id& prod_id = 
  1604.                         GetId(feat.GetProduct(), &ctx.GetScope());
  1605.                     if ( ctx.IsRefSeq()  ||  !ctx.Config().ForGBRelease() ) {
  1606.                         x_AddQual(eFQ_protein_id, new CFlatSeqIdQVal(prod_id));
  1607.                     }
  1608.                 } catch (CNotUnique&) {}
  1609.             }
  1610.         }
  1611.     } else { // protein feature on subpeptide bioseq
  1612.         x_AddQual(eFQ_derived_from, new CFlatSeqLocQVal(m_Feat->GetLocation()));
  1613.         // check precursor_comment
  1614.         CConstRef<CSeq_feat> prot = 
  1615.             GetBestOverlappingFeat(m_Feat->GetProduct(),
  1616.                                    CSeqFeatData::e_Prot,
  1617.                                    eOverlap_Simple,
  1618.                                    ctx.GetScope());
  1619.         if ( (bool)prot  &&  prot->CanGetComment() ) {
  1620.             precursor_comment = prot->GetComment();
  1621.         }
  1622.     }
  1623.     if ( !pseudo  &&  ctx.Config().ShowPeptides() ) {
  1624.         if ( processed == CProt_ref::eProcessed_mature          ||
  1625.              processed == CProt_ref::eProcessed_signal_peptide  ||
  1626.              processed == CProt_ref::eProcessed_transit_peptide ) {
  1627.             CSeqVector pep(m_Feat->GetLocation(), ctx.GetScope());
  1628.             string peptide;
  1629.             pep.GetSeqData(pep.begin(), pep.end(), peptide);
  1630.             if ( !peptide.empty() ) {
  1631.                 x_AddQual(eFQ_peptide, new CFlatStringQVal(peptide));
  1632.             }
  1633.         }
  1634.     }
  1636.     // cleanup
  1637.     if ( processed == CProt_ref::eProcessed_signal_peptide  ||
  1638.          processed == CProt_ref::eProcessed_transit_peptide ) {
  1639.         if ( !ctx.IsRefSeq() ) {
  1640.            // Only RefSeq allows product on signal or transit peptide
  1641.            x_RemoveQuals(eFQ_product);
  1642.         }
  1643.     }
  1644.     if ( processed == CProt_ref::eProcessed_preprotein  &&
  1645.          !ctx.IsRefSeq()  &&  !ctx.IsProt()  &&  
  1646.          feat.GetData().GetSubtype() == CSeqFeatData::eSubtype_preprotein ) {
  1647.         TQI product = m_Quals.Find(eFQ_product);
  1648.         if (  product != m_Quals.end() ) {
  1649.             x_AddQual(eFQ_encodes, product->second);
  1650.             x_RemoveQuals(eFQ_product);
  1651.         }
  1652.     }
  1653. }
  1656. struct SLegalImport {
  1657.     const char*       m_Name;
  1658.     EFeatureQualifier m_Value;
  1660.     operator string(void) const { return m_Name; }
  1661. };
  1664. void CFeatureItem::x_ImportQuals(const CSeq_feat::TQual& quals) const
  1665. {
  1666.     typedef pair<const char*, EFeatureQualifier> TLegalImport;
  1667.     static const TLegalImport kLegalImports[] = {
  1668.         // Must be in case-insensitive alphabetical order!
  1669. #define DO_IMPORT(x) TLegalImport(#x, eFQ_##x)
  1670.         DO_IMPORT(allele),
  1671.         DO_IMPORT(bound_moiety),
  1672.         DO_IMPORT(clone),
  1673.         DO_IMPORT(codon),
  1674.         DO_IMPORT(cons_splice),
  1675.         DO_IMPORT(direction),
  1676.         DO_IMPORT(EC_number),
  1677.         DO_IMPORT(evidence),
  1678.         DO_IMPORT(frequency),
  1679.         DO_IMPORT(function),
  1680.         DO_IMPORT(insertion_seq),
  1681.         DO_IMPORT(label),
  1682.         DO_IMPORT(map),
  1683.         DO_IMPORT(mod_base),
  1684.         DO_IMPORT(number),
  1685.         DO_IMPORT(organism),
  1686.         DO_IMPORT(PCR_conditions),
  1687.         DO_IMPORT(phenotype),
  1688.         TLegalImport("product", eFQ_product_quals),
  1689.         DO_IMPORT(replace),
  1690.         DO_IMPORT(rpt_family),
  1691.         DO_IMPORT(rpt_type),
  1692.         DO_IMPORT(rpt_unit),
  1693.         DO_IMPORT(standard_name),
  1694.         DO_IMPORT(transposon),
  1695.         DO_IMPORT(usedin)
  1696. #undef DO_IMPORT
  1697.     };
  1698.     typedef const CStaticArrayMap<const char*, EFeatureQualifier, PNocase> TLegalImportMap;
  1699.     static TLegalImportMap kLegalImportMap(kLegalImports, sizeof(kLegalImports));
  1701.     ITERATE (CSeq_feat::TQual, it, quals) {
  1702.         const char* name = (*it)->GetQual().c_str();
  1703.         const TLegalImportMap::const_iterator li = kLegalImportMap.find(name);
  1704.         EFeatureQualifier   slot = eFQ_illegal_qual;
  1705.         if ( li != kLegalImportMap.end() ) {
  1706.             slot = li->second;
  1707.         }
  1708.         switch (slot) {
  1709.         case eFQ_codon:
  1710.         case eFQ_cons_splice:
  1711.         case eFQ_direction:
  1712.         case eFQ_evidence:
  1713.         case eFQ_mod_base:
  1714.         case eFQ_number:
  1715.         case eFQ_rpt_type:
  1716.         case eFQ_rpt_unit:
  1717.         case eFQ_usedin:
  1718.             // XXX -- each of these should really get its own class
  1719.             // (to verify correct syntax)
  1720.             x_AddQual(slot, new CFlatStringQVal((*it)->GetVal(),
  1721.                 CFormatQual::eUnquoted));
  1722.             break;
  1723.         case eFQ_label:
  1724.             x_AddQual(slot, new CFlatLabelQVal((*it)->GetVal()));
  1725.             break;
  1726.         case eFQ_illegal_qual:
  1727.             x_AddQual(slot, new CFlatIllegalQVal(**it));
  1728.             break;
  1729.         default:
  1730.             // XXX - should split off EC_number and replace
  1731.             // (to verify correct syntax)
  1732.             x_AddQual(slot, new CFlatStringQVal((*it)->GetVal()));
  1733.             break;
  1734.         }
  1735.     }
  1736. }
  1739. void CFeatureItem::x_FormatQuals(CFlatFeature& ff) const
  1740. {
  1741.     const CFlatFileConfig& cfg = GetContext()->Config();
  1743.     if ( cfg.IsFormatFTable() ) {
  1744.         ff.SetQuals() = m_FTableQuals;
  1745.         return;
  1746.     }
  1748.     ff.SetQuals().reserve(m_Quals.Size());
  1749.     CFlatFeature::TQuals& qvec = ff.SetQuals();
  1751. #define DO_QUAL(x) x_FormatQual(eFQ_##x, #x, qvec)
  1752.     DO_QUAL(partial);
  1753.     DO_QUAL(gene);
  1755.     DO_QUAL(locus_tag);
  1756.     DO_QUAL(gene_syn_refseq);
  1758.     x_FormatQual(eFQ_gene_allele, "allele", qvec);
  1760.     DO_QUAL(operon);
  1762.     DO_QUAL(product);
  1764.     x_FormatQual(eFQ_prot_EC_number, "EC_number", qvec);
  1765.     x_FormatQual(eFQ_prot_activity,  "function", qvec);
  1767.     DO_QUAL(standard_name);
  1768.     DO_QUAL(coded_by);
  1769.     DO_QUAL(derived_from);
  1771.     x_FormatQual(eFQ_prot_name, "name", qvec);
  1772.     DO_QUAL(region_name);
  1773.     DO_QUAL(bond_type);
  1774.     DO_QUAL(site_type);
  1775.     DO_QUAL(sec_str_type);
  1776.     DO_QUAL(heterogen);
  1778.     if ( !cfg.GoQualsToNote() ) {
  1779.         DO_QUAL(go_component);
  1780.         DO_QUAL(go_function);
  1781.         DO_QUAL(go_process);
  1782.     }
  1784.     x_FormatNoteQuals(ff);
  1785.         
  1786.     DO_QUAL(citation);
  1788.     DO_QUAL(number);
  1790.     DO_QUAL(pseudo);
  1791.     DO_QUAL(selenocysteine);
  1793.     DO_QUAL(codon_start);
  1795.     DO_QUAL(anticodon);
  1796.     DO_QUAL(bound_moiety);
  1797.     DO_QUAL(clone);
  1798.     DO_QUAL(cons_splice);
  1799.     DO_QUAL(direction);
  1800.     DO_QUAL(function);
  1801.     DO_QUAL(evidence);
  1802.     DO_QUAL(exception);
  1803.     DO_QUAL(frequency);
  1804.     DO_QUAL(EC_number);
  1805.     x_FormatQual(eFQ_gene_map, "map", qvec);
  1806.     DO_QUAL(allele);
  1807.     DO_QUAL(map);
  1808.     DO_QUAL(mod_base);
  1809.     DO_QUAL(PCR_conditions);
  1810.     DO_QUAL(phenotype);
  1811.     DO_QUAL(rpt_family);
  1812.     DO_QUAL(rpt_type);
  1813.     DO_QUAL(rpt_unit);
  1814.     DO_QUAL(insertion_seq);
  1815.     DO_QUAL(transposon);
  1816.     DO_QUAL(usedin);
  1818.     // extra imports, actually...
  1819.     x_FormatQual(eFQ_illegal_qual, "illegal", qvec);
  1821.     DO_QUAL(replace);
  1823.     DO_QUAL(transl_except);
  1824.     DO_QUAL(transl_table);
  1825.     DO_QUAL(codon);
  1826.     DO_QUAL(organism);
  1827.     DO_QUAL(label);
  1828.     x_FormatQual(eFQ_cds_product, "product", qvec);
  1829.     DO_QUAL(protein_id);
  1830.     DO_QUAL(transcript_id);
  1831.     DO_QUAL(db_xref);
  1832.     x_FormatQual(eFQ_gene_xref, "db_xref", qvec);
  1833.     DO_QUAL(translation);
  1834.     DO_QUAL(transcription);
  1835.     DO_QUAL(peptide);
  1836. #undef DO_QUAL
  1837. }
  1840. void CFeatureItem::x_FormatNoteQuals(CFlatFeature& ff) const
  1841. {
  1842.     CFlatFeature::TQuals qvec;
  1844. #define DO_NOTE(x) x_FormatNoteQual(eFQ_##x, #x, qvec)
  1845.     x_FormatNoteQual(eFQ_transcript_id_note, "tscpt_id_note", qvec);
  1846.     DO_NOTE(gene_desc);
  1847.     DO_NOTE(gene_syn);
  1848.     DO_NOTE(trna_codons);
  1849.     DO_NOTE(prot_desc);
  1850.     DO_NOTE(prot_note);
  1851.     DO_NOTE(prot_comment);
  1852.     DO_NOTE(prot_method);
  1853.     DO_NOTE(figure);
  1854.     DO_NOTE(maploc);
  1855.     DO_NOTE(prot_conflict);
  1856.     DO_NOTE(prot_missing);
  1857.     DO_NOTE(seqfeat_note);
  1858.     DO_NOTE(exception_note);
  1859.     DO_NOTE(region);
  1860.     DO_NOTE(selenocysteine_note);
  1861.     DO_NOTE(prot_names);
  1862.     DO_NOTE(bond);
  1863.     DO_NOTE(site);
  1864.     DO_NOTE(rrna_its);
  1865.     DO_NOTE(xtra_prod_quals);
  1866.     DO_NOTE(modelev);
  1867.     if ( GetContext()->Config().GoQualsToNote() ) {
  1868.         DO_NOTE(go_component);
  1869.         DO_NOTE(go_function);
  1870.         DO_NOTE(go_process);
  1871.     }
  1872. #undef DO_NOTE
  1874.     string notestr;
  1875.     const string* suffix = &kEmptyStr;
  1877.     CFlatFeature::TQuals::const_iterator last = qvec.end();
  1878.     CFlatFeature::TQuals::const_iterator end = last--;
  1879.     CFlatFeature::TQuals::const_iterator it = qvec.begin();
  1880.     bool add_period = false;
  1881.     for ( ; it != end; ++it ) {
  1882.         add_period = false;
  1883.         string note = (*it)->GetValue();
  1884.         if ( NStr::EndsWith(note, ".")  &&  !NStr::EndsWith(note, "...") ) {
  1885.             note.erase(note.length() - 1);
  1886.             add_period = true;
  1887.         }
  1888.         const string& prefix = *suffix + (*it)->GetPrefix();
  1889.         JoinNoRedund(notestr, prefix, note);
  1890.         suffix = &(*it)->GetSuffix();
  1891.     }
  1893.     if ( !notestr.empty() ) {
  1894.         NStr::TruncateSpaces(notestr);
  1895.         if ( add_period  &&  !NStr::EndsWith(notestr, ".") ) {
  1896.             notestr += ".";
  1897.         }
  1898.         CRef<CFormatQual> note(new CFormatQual("note", 
  1899.             ExpandTildes(notestr, eTilde_newline)));
  1900.         ff.SetQuals().push_back(note);
  1901.     }
  1902. }
  1905. void CFeatureItem::x_FormatQual
  1906. (EFeatureQualifier slot,
  1907.  const string& name,
  1908.  CFlatFeature::TQuals& qvec,
  1909.  IFlatQVal::TFlags flags) const
  1910. {
  1911.     pair<TQCI, TQCI> range = const_cast<const TQuals&>(m_Quals).GetQuals(slot);
  1912.     for (TQCI it = range.first;  it != range.second;  ++it) {
  1913.         it->second->Format(qvec, name, *GetContext(), flags);
  1914.     }
  1915. }
  1918. const CFlatStringQVal* CFeatureItem::x_GetStringQual(EFeatureQualifier slot) const
  1919. {
  1920.     const IFlatQVal* qual = 0;
  1921.     if ( x_HasQual(slot) ) {
  1922.         qual = m_Quals.Find(slot)->second;
  1923.     }
  1924.     return dynamic_cast<const CFlatStringQVal*>(qual);
  1925. }
  1928. void CFeatureItem::x_CleanQuals(void) const
  1929. {
  1930.     if ( GetContext()->Config().DropIllegalQuals() ) {
  1931.         x_DropIllegalQuals();
  1932.     }
  1934.     const CFlatStringQVal* gene = x_GetStringQual(eFQ_gene);
  1935.     if ( gene != 0 ) {
  1936.         // /gene same as feature.comment will suppress /note
  1937.         if ( m_Feat->CanGetComment() ) {
  1938.             if ( NStr::Equal(gene->GetValue(), m_Feat->GetComment()) ) {
  1939.                 x_RemoveQuals(eFQ_seqfeat_note);
  1940.             }
  1941.         }
  1943.         // remove protein description that equals the gene name, case sensitive
  1944.         const CFlatStringQVal* prod_desc = x_GetStringQual(eFQ_prot_desc);
  1945.         if ( prod_desc != 0 ) {
  1946.             if ( NStr::Equal(gene->GetValue(), prod_desc->GetValue()) ) {
  1947.                 x_RemoveQuals(eFQ_prot_desc);
  1948.             }
  1949.         }
  1950.     }
  1951. }
  1954. typedef pair<EFeatureQualifier, CSeqFeatData::EQualifier> TQualPair;
  1955. static const TQualPair sc_GbToFeatQualMap[] = {
  1956.     TQualPair(eFQ_none, CSeqFeatData::eQual_bad),
  1957.     TQualPair(eFQ_allele, CSeqFeatData::eQual_allele),
  1958.     TQualPair(eFQ_anticodon, CSeqFeatData::eQual_anticodon),
  1959.     TQualPair(eFQ_bond, CSeqFeatData::eQual_note),
  1960.     TQualPair(eFQ_bond_type, CSeqFeatData::eQual_bad),
  1961.     TQualPair(eFQ_bound_moiety, CSeqFeatData::eQual_bound_moiety),
  1962.     TQualPair(eFQ_cds_product, CSeqFeatData::eQual_product),
  1963.     TQualPair(eFQ_citation, CSeqFeatData::eQual_citation),
  1964.     TQualPair(eFQ_clone, CSeqFeatData::eQual_clone),
  1965.     TQualPair(eFQ_coded_by, CSeqFeatData::eQual_bad),
  1966.     TQualPair(eFQ_codon, CSeqFeatData::eQual_codon),
  1967.     TQualPair(eFQ_codon_start, CSeqFeatData::eQual_codon_start),
  1968.     TQualPair(eFQ_cons_splice, CSeqFeatData::eQual_cons_splice),
  1969.     TQualPair(eFQ_db_xref, CSeqFeatData::eQual_db_xref),
  1970.     TQualPair(eFQ_derived_from, CSeqFeatData::eQual_bad),
  1971.     TQualPair(eFQ_direction, CSeqFeatData::eQual_direction),
  1972.     TQualPair(eFQ_EC_number, CSeqFeatData::eQual_EC_number),
  1973.     TQualPair(eFQ_encodes, CSeqFeatData::eQual_note),
  1974.     TQualPair(eFQ_evidence, CSeqFeatData::eQual_evidence),
  1975.     TQualPair(eFQ_exception, CSeqFeatData::eQual_exception),
  1976.     TQualPair(eFQ_exception_note, CSeqFeatData::eQual_note),
  1977.     TQualPair(eFQ_figure, CSeqFeatData::eQual_note),
  1978.     TQualPair(eFQ_frequency, CSeqFeatData::eQual_frequency),
  1979.     TQualPair(eFQ_function, CSeqFeatData::eQual_function),
  1980.     TQualPair(eFQ_gene, CSeqFeatData::eQual_gene),
  1981.     TQualPair(eFQ_gene_desc, CSeqFeatData::eQual_note),
  1982.     TQualPair(eFQ_gene_allele, CSeqFeatData::eQual_allele),
  1983.     TQualPair(eFQ_gene_map, CSeqFeatData::eQual_bad),
  1984.     TQualPair(eFQ_gene_syn, CSeqFeatData::eQual_note),
  1985.     TQualPair(eFQ_gene_syn_refseq, CSeqFeatData::eQual_bad),
  1986.     TQualPair(eFQ_gene_note, CSeqFeatData::eQual_note),
  1987.     TQualPair(eFQ_gene_xref, CSeqFeatData::eQual_db_xref),
  1988.     TQualPair(eFQ_go_component, CSeqFeatData::eQual_note),
  1989.     TQualPair(eFQ_go_function, CSeqFeatData::eQual_note),
  1990.     TQualPair(eFQ_go_process, CSeqFeatData::eQual_note),
  1991.     TQualPair(eFQ_heterogen, CSeqFeatData::eQual_bad),
  1992.     TQualPair(eFQ_illegal_qual, CSeqFeatData::eQual_bad),
  1993.     TQualPair(eFQ_insertion_seq, CSeqFeatData::eQual_insertion_seq),
  1994.     TQualPair(eFQ_label, CSeqFeatData::eQual_label),
  1995.     TQualPair(eFQ_locus_tag, CSeqFeatData::eQual_locus_tag),
  1996.     TQualPair(eFQ_map, CSeqFeatData::eQual_map),
  1997.     TQualPair(eFQ_maploc, CSeqFeatData::eQual_note),
  1998.     TQualPair(eFQ_mod_base, CSeqFeatData::eQual_mod_base),
  1999.     TQualPair(eFQ_modelev, CSeqFeatData::eQual_note),
  2000.     TQualPair(eFQ_number, CSeqFeatData::eQual_number),
  2001.     TQualPair(eFQ_operon, CSeqFeatData::eQual_operon),
  2002.     TQualPair(eFQ_organism, CSeqFeatData::eQual_organism),
  2003.     TQualPair(eFQ_partial, CSeqFeatData::eQual_partial),
  2004.     TQualPair(eFQ_PCR_conditions, CSeqFeatData::eQual_PCR_conditions),
  2005.     TQualPair(eFQ_peptide, CSeqFeatData::eQual_bad),
  2006.     TQualPair(eFQ_phenotype, CSeqFeatData::eQual_phenotype),
  2007.     TQualPair(eFQ_product, CSeqFeatData::eQual_product),
  2008.     TQualPair(eFQ_product_quals, CSeqFeatData::eQual_product),
  2009.     TQualPair(eFQ_prot_activity, CSeqFeatData::eQual_bad),
  2010.     TQualPair(eFQ_prot_comment, CSeqFeatData::eQual_note),
  2011.     TQualPair(eFQ_prot_EC_number, CSeqFeatData::eQual_bad),
  2012.     TQualPair(eFQ_prot_note, CSeqFeatData::eQual_note),
  2013.     TQualPair(eFQ_prot_method, CSeqFeatData::eQual_note),
  2014.     TQualPair(eFQ_prot_conflict, CSeqFeatData::eQual_note),
  2015.     TQualPair(eFQ_prot_desc, CSeqFeatData::eQual_note),
  2016.     TQualPair(eFQ_prot_missing, CSeqFeatData::eQual_note),
  2017.     TQualPair(eFQ_prot_name, CSeqFeatData::eQual_bad),
  2018.     TQualPair(eFQ_prot_names, CSeqFeatData::eQual_note),
  2019.     TQualPair(eFQ_protein_id, CSeqFeatData::eQual_protein_id),
  2020.     TQualPair(eFQ_pseudo, CSeqFeatData::eQual_pseudo),
  2021.     TQualPair(eFQ_region, CSeqFeatData::eQual_note),
  2022.     TQualPair(eFQ_region_name, CSeqFeatData::eQual_bad),
  2023.     TQualPair(eFQ_replace, CSeqFeatData::eQual_replace),
  2024.     TQualPair(eFQ_rpt_family, CSeqFeatData::eQual_rpt_family),
  2025.     TQualPair(eFQ_rpt_type, CSeqFeatData::eQual_rpt_type),
  2026.     TQualPair(eFQ_rpt_unit, CSeqFeatData::eQual_rpt_unit),
  2027.     TQualPair(eFQ_rrna_its, CSeqFeatData::eQual_note),
  2028.     TQualPair(eFQ_sec_str_type, CSeqFeatData::eQual_bad),
  2029.     TQualPair(eFQ_selenocysteine, CSeqFeatData::eQual_bad),
  2030.     TQualPair(eFQ_selenocysteine_note, CSeqFeatData::eQual_note),
  2031.     TQualPair(eFQ_seqfeat_note, CSeqFeatData::eQual_note),
  2032.     TQualPair(eFQ_site, CSeqFeatData::eQual_note),
  2033.     TQualPair(eFQ_site_type, CSeqFeatData::eQual_bad),
  2034.     TQualPair(eFQ_standard_name, CSeqFeatData::eQual_bad),
  2035.     TQualPair(eFQ_transcription, CSeqFeatData::eQual_bad),
  2036.     TQualPair(eFQ_transcript_id, CSeqFeatData::eQual_bad),
  2037.     TQualPair(eFQ_transcript_id_note, CSeqFeatData::eQual_note),
  2038.     TQualPair(eFQ_transl_except, CSeqFeatData::eQual_transl_except),
  2039.     TQualPair(eFQ_transl_table, CSeqFeatData::eQual_transl_table),
  2040.     TQualPair(eFQ_translation, CSeqFeatData::eQual_translation),
  2041.     TQualPair(eFQ_transposon, CSeqFeatData::eQual_transposon),
  2042.     TQualPair(eFQ_trna_aa, CSeqFeatData::eQual_bad),
  2043.     TQualPair(eFQ_trna_codons, CSeqFeatData::eQual_note),
  2044.     TQualPair(eFQ_usedin, CSeqFeatData::eQual_usedin),
  2045.     TQualPair(eFQ_xtra_prod_quals, CSeqFeatData::eQual_note)
  2046. };
  2047. typedef CStaticArrayMap<EFeatureQualifier, CSeqFeatData::EQualifier> TQualMap;
  2048. static const TQualMap sc_QualMap(sc_GbToFeatQualMap, sizeof(sc_GbToFeatQualMap));
  2050. static CSeqFeatData::EQualifier s_GbToSeqFeatQual(EFeatureQualifier qual)
  2051. {
  2052.     TQualMap::const_iterator it = sc_QualMap.find(qual);
  2053.     if ( it != sc_QualMap.end() ) {
  2054.         return it->second;
  2055.     }
  2056.     return CSeqFeatData::eQual_bad;
  2057. }
  2060. void CFeatureItem::x_DropIllegalQuals(void) const
  2061. {
  2062.     const CSeqFeatData& data = m_Feat->GetData();
  2064.     TQI it = m_Quals.begin();
  2065.     while ( it != m_Quals.end() ) {
  2066.         CSeqFeatData::EQualifier qual = s_GbToSeqFeatQual(it->first);
  2067.         if ( !data.IsLegalQualifier(qual) ) {
  2068.             it = m_Quals.Erase(it);
  2069.         } else {
  2070.             ++it;
  2071.         }
  2072.     }
  2073. }
  2076. void CFeatureItem::x_AddFTableQuals(CBioseqContext& ctx) const
  2077. {
  2078.     bool pseudo = m_Feat->CanGetPseudo()  &&  m_Feat->GetPseudo();
  2080.     const CSeqFeatData& data = m_Feat->GetData();
  2082.     switch ( m_Feat->GetData().Which() ) {
  2083.     case CSeqFeatData::e_Gene:
  2084.         pseudo |= x_AddFTableGeneQuals(data.GetGene());
  2085.         break;
  2086.     case CSeqFeatData::e_Rna:
  2087.         x_AddFTableRnaQuals(*m_Feat, ctx);
  2088.         break;
  2089.     case CSeqFeatData::e_Cdregion:
  2090.         x_AddFTableCdregionQuals(*m_Feat, ctx);
  2091.         break;
  2092.     case CSeqFeatData::e_Prot:
  2093.         x_AddFTableProtQuals(*m_Feat);
  2094.         break;
  2095.     case CSeqFeatData::e_Region:
  2096.         x_AddFTableRegionQuals(data.GetRegion());
  2097.         break;
  2098.     case CSeqFeatData::e_Bond:
  2099.         x_AddFTableBondQuals(data.GetBond());
  2100.         break;
  2101.     case CSeqFeatData::e_Site:
  2102.         x_AddFTableSiteQuals(data.GetSite());
  2103.         break;
  2104.     case CSeqFeatData::e_Psec_str:
  2105.         x_AddFTablePsecStrQuals(data.GetPsec_str());
  2106.         break;
  2107.     case CSeqFeatData::e_Het:
  2108.         x_AddFTablePsecStrQuals(data.GetHet());
  2109.         break;
  2110.     case CSeqFeatData::e_Biosrc:
  2111.         x_AddFTableBiosrcQuals(data.GetBiosrc());
  2112.         break;
  2113.     default:
  2114.         break;
  2115.     }
  2116.     if ( pseudo ) {
  2117.         x_AddFTableQual("pseudo");
  2118.     }
  2119.     const CGene_ref* grp = m_Feat->GetGeneXref();
  2120.     if ( grp != 0  &&  grp->IsSuppressed() ) {
  2121.         x_AddFTableQual("gene", "-");
  2122.     }
  2123.     if ( m_Feat->CanGetComment()  &&  !m_Feat->GetComment().empty() ) {
  2124.         x_AddFTableQual("note", m_Feat->GetComment());
  2125.     }
  2126.     if ( m_Feat->CanGetExp_ev() ) {
  2127.         string ev;
  2128.         switch ( m_Feat->GetExp_ev() ) {
  2129.         case CSeq_feat::eExp_ev_experimental:
  2130.             ev = "experimental";
  2131.             break;
  2132.         case CSeq_feat::eExp_ev_not_experimental:
  2133.             ev = "not_experimental";
  2134.             break;
  2135.         }
  2136.         x_AddFTableQual("evidence", ev);
  2137.     }
  2138.     if ( m_Feat->CanGetExcept_text()  &&  !m_Feat->GetExcept_text().empty() ) {
  2139.         x_AddFTableQual("exception", m_Feat->GetExcept_text());
  2140.     } else if ( m_Feat->CanGetExcept()  &&  m_Feat->GetExcept() ) {
  2141.         x_AddFTableQual("exception");
  2142.     }
  2143.     ITERATE (CSeq_feat::TQual, it, m_Feat->GetQual()) {
  2144.         const CGb_qual& qual = **it;
  2145.         const string& key = qual.CanGetQual() ? qual.GetQual() : kEmptyStr;
  2146.         const string& val = qual.CanGetVal() ? qual.GetVal() : kEmptyStr;
  2147.         if ( !key.empty()  &&  !val.empty() ) {
  2148.             x_AddFTableQual(key, val);
  2149.         }
  2150.     }
  2151.     if ( m_Feat->IsSetExt() ) {
  2152.         x_AddFTableExtQuals(m_Feat->GetExt());
  2153.     }
  2154.     if ( data.IsGene() ) {
  2155.         x_AddFTableDbxref(data.GetGene().GetDb());
  2156.     } else if ( data.IsProt() ) {
  2157.         x_AddFTableDbxref(data.GetProt().GetDb());
  2158.     }
  2159.     x_AddFTableDbxref(m_Feat->GetDbxref());
  2160. }
  2163. void CFeatureItem::x_AddFTableExtQuals(const CSeq_feat::TExt& ext) const
  2164. {
  2165.     ITERATE (CUser_object::TData, it, ext.GetData()) {
  2166.         const CUser_field& field = **it;
  2167.         if ( !field.CanGetData() ) {
  2168.             continue;
  2169.         }
  2170.         if ( field.GetData().IsObject() ) {
  2171.             const CUser_object& obj = field.GetData().GetObject();
  2172.             x_AddExtQuals(obj);
  2173.             return;
  2174.         } else if ( field.GetData().IsObjects() ) {
  2175.             ITERATE (CUser_field::C_Data::TObjects, o, field.GetData().GetObjects()) {
  2176.                 x_AddExtQuals(**o);
  2177.             }
  2178.             return;
  2179.         }
  2180.     }
  2181.     if ( ext.CanGetType()  &&  ext.GetType().IsStr() ) {
  2182.         const string& oid = ext.GetType().GetStr();
  2183.         if ( oid == "GeneOntology" ) {
  2184.             ITERATE (CUser_object::TData, uf_it, ext.GetData()) {
  2185.                 const CUser_field& field = **uf_it;
  2186.                 if ( field.IsSetLabel()  &&  field.GetLabel().IsStr() ) {
  2187.                     const string& label = field.GetLabel().GetStr();
  2188.                     string name;
  2189.                     if ( label == "Process" ) {
  2190.                         name = "go_process";
  2191.                     } else if ( label == "Component" ) {               
  2192.                         name = "go_component";
  2193.                     } else if ( label == "Function" ) {
  2194.                         name = "go_function";
  2195.                     }
  2196.                     if ( name.empty() ) {
  2197.                         continue;
  2198.                     }
  2199.                     
  2200.                     ITERATE (CUser_field::TData::TFields, it, field.GetData().GetFields()) {
  2201.                         if ( (*it)->GetData().IsFields() ) {
  2202.                             CFlatGoQVal(**it).Format(m_FTableQuals, name, *GetContext(), 0);;
  2203.                         }
  2204.                     }
  2205.                 }
  2206.             }
  2207.         }
  2208.     }
  2209. }
  2212. void CFeatureItem::x_AddFTableDbxref(const CSeq_feat::TDbxref& dbxref) const
  2213. {
  2214.     ITERATE (CSeq_feat::TDbxref, it, dbxref) {
  2215.         const CDbtag& dbt = **it;
  2216.         if ( dbt.CanGetDb()  &&  !dbt.GetDb().empty()  &&
  2217.              dbt.CanGetTag() ) {
  2218.             const CObject_id& oid = dbt.GetTag();
  2219.             switch ( oid.Which() ) {
  2220.             case CObject_id::e_Str:
  2221.                 if ( !oid.GetStr().empty() ) {
  2222.                     x_AddFTableQual("db_xref", dbt.GetDb() + ":" + oid.GetStr());
  2223.                 }
  2224.                 break;
  2225.             case CObject_id::e_Id:
  2226.                 x_AddFTableQual("db_xref", dbt.GetDb() + ":" + NStr::IntToString(oid.GetId()));
  2227.                 break;
  2228.             default:
  2229.                 break;
  2230.             }
  2231.         }
  2232.     }
  2233. }
  2236. bool CFeatureItem::x_AddFTableGeneQuals(const CGene_ref& gene) const
  2237. {
  2238.     if ( gene.CanGetLocus()  &&  !gene.GetLocus().empty() ) {
  2239.         x_AddFTableQual("gene", gene.GetLocus());
  2240.     }
  2241.     ITERATE (CGene_ref::TSyn, it, gene.GetSyn()) {
  2242.         x_AddFTableQual("gene_syn", *it);
  2243.     }
  2244.     if ( gene.CanGetDesc()  &&  !gene.GetDesc().empty() ) {
  2245.         x_AddFTableQual("gene_desc", gene.GetDesc());
  2246.     }
  2247.     if ( gene.CanGetMaploc()  &&  !gene.GetMaploc().empty() ) {
  2248.         x_AddFTableQual("map", gene.GetMaploc());
  2249.     }
  2250.     if ( gene.CanGetLocus_tag()  &&  !gene.GetLocus_tag().empty() ) {
  2251.         x_AddFTableQual("locus_tag", gene.GetLocus_tag());
  2252.     }
  2254.     return (gene.CanGetPseudo()  &&  gene.GetPseudo());
  2255. }
  2258. void CFeatureItem::x_AddFTableRnaQuals(const CSeq_feat& feat, CBioseqContext& ctx) const
  2259. {
  2260.     string label;
  2262.     if ( !feat.GetData().IsRna() ) {
  2263.         return;
  2264.     }
  2265.     const CSeqFeatData::TRna& rna = feat.GetData().GetRna();
  2266.     if ( rna.CanGetExt() ) {
  2267.         const CRNA_ref::TExt& ext = rna.GetExt();
  2268.         switch ( ext.Which() ) {
  2269.         case CRNA_ref::TExt::e_Name:
  2270.             if ( !ext.GetName().empty() ) {
  2271.                 x_AddFTableQual("product", ext.GetName());
  2272.             }
  2273.             break;
  2274.         case CRNA_ref::TExt::e_TRNA:
  2275.             feature::GetLabel(feat, &label, feature::eContent, &ctx.GetScope());
  2276.             x_AddFTableQual("product", label);
  2277.             break;
  2278.         }
  2279.     }
  2281.     if ( feat.CanGetProduct() ) {
  2282.         CBioseq_Handle prod = 
  2283.             ctx.GetScope().GetBioseqHandle(m_Feat->GetProduct());
  2284.         if ( prod ) {
  2285.             const CSeq_id& id = GetId(prod, eGetId_Best);
  2286.             string id_str;
  2287.             if ( id.IsGenbank()  ||  id.IsEmbl()  ||  id.IsDdbj()  ||
  2288.                  id.IsTpg()  ||  id.IsTpd()  ||  id.IsTpe()  ||
  2289.                  id.IsOther() ||
  2290.                  (id.IsLocal()  &&  !ctx.Config().SuppressLocalId()) ) {
  2291.                 id_str = id.GetSeqIdString(true);
  2292.             } else if ( id.IsGeneral() ) {
  2293.                 id_str = id.AsFastaString();
  2294.             }
  2295.             x_AddFTableQual("transcript_id", id_str);
  2296.         }
  2297.     }
  2298. }
  2301. void CFeatureItem::x_AddFTableCdregionQuals(const CSeq_feat& feat, CBioseqContext& ctx) const
  2302. {
  2303.     CBioseq_Handle prod;
  2304.     if ( feat.CanGetProduct() ) {
  2305.         prod = ctx.GetScope().GetBioseqHandle(feat.GetProduct());
  2306.     }
  2307.     if ( prod ) {
  2308.         CConstRef<CSeq_feat> prot = GetBestOverlappingFeat(
  2309.             feat.GetProduct(),
  2310.             CSeqFeatData::e_Prot,
  2311.             eOverlap_Simple,
  2312.             ctx.GetScope());
  2313.         if ( prot ) {
  2314.             x_AddFTableProtQuals(*prot);
  2315.         }
  2316.     }
  2317.     const CCdregion& cdr = feat.GetData().GetCdregion();
  2318.     if ( cdr.CanGetFrame()  &&  cdr.GetFrame() > CCdregion::eFrame_one ) {
  2319.         x_AddFTableQual("codon_start", NStr::IntToString(cdr.GetFrame()));
  2320.     }
  2321.     ITERATE (CCdregion::TCode_break, it, cdr.GetCode_break()) {
  2322.         string pos = CFlatSeqLoc((*it)->GetLoc(), ctx).GetString();
  2323.         string aa  = "OTHER";
  2324.         switch ((*it)->GetAa().Which()) {
  2325.         case CCode_break::C_Aa::e_Ncbieaa:
  2326.             aa = GetAAName((*it)->GetAa().GetNcbieaa(), true);
  2327.             break;
  2328.         case CCode_break::C_Aa::e_Ncbi8aa:
  2329.             aa = GetAAName((*it)->GetAa().GetNcbi8aa(), false);
  2330.             break;
  2331.         case CCode_break::C_Aa::e_Ncbistdaa:
  2332.             aa = GetAAName((*it)->GetAa().GetNcbistdaa(), false);
  2333.             break;
  2334.         default:
  2335.             break;
  2336.         }
  2337.         x_AddFTableQual("transl_except", "(pos:" + pos + ",aa:" + aa + ")");
  2338.     }
  2339.     const CSeq_id* id = 0;
  2340.     string id_str;
  2341.     if ( prod ) {
  2342.         id = &GetId(prod, eGetId_Best);
  2343.     } else if ( feat.CanGetProduct() ) {
  2344.         try { 
  2345.             id = &GetId(feat.GetProduct(), &ctx.GetScope());
  2346.             if ( id->IsGi() ) {
  2347.                 // get "normal" id 
  2348.             }
  2349.         } catch (CNotUnique&) {
  2350.             id = 0;
  2351.         }
  2352.     }
  2353.     if ( id != 0 ) {
  2354.         if ( id->IsGenbank()  ||  id->IsEmbl()  ||  id->IsDdbj()  ||
  2355.              id->IsTpg()  ||  id->IsTpd()  ||  id->IsTpe()  ||
  2356.              id->IsOther() ||
  2357.              (id->IsLocal()  &&  !ctx.Config().SuppressLocalId()) ) {
  2358.             id_str = id->GetSeqIdString(true);
  2359.         } else if ( id->IsGi() ) {
  2360.             id_str = id->AsFastaString();
  2361.         }
  2362.         x_AddFTableQual("protein_id", id_str);
  2363.     }
  2364. }
  2367. void CFeatureItem::x_AddFTableProtQuals(const CSeq_feat& prot) const
  2368. {
  2369.     if ( !prot.GetData().IsProt() ) {
  2370.         return;
  2371.     }
  2372.     const CProt_ref& pref = prot.GetData().GetProt();
  2373.     ITERATE (CProt_ref::TName, it, pref.GetName()) {
  2374.         if ( !it->empty() ) {
  2375.             x_AddFTableQual("product", *it);
  2376.         }
  2377.     }
  2378.     if ( pref.CanGetDesc()  &&  !pref.GetDesc().empty() ) {
  2379.         x_AddFTableQual("prot_desc", pref.GetDesc());
  2380.     }
  2381.     ITERATE (CProt_ref::TActivity, it, pref.GetActivity()) {
  2382.         if ( !it->empty() ) {
  2383.             x_AddFTableQual("function", *it);
  2384.         }
  2385.     }
  2386.     ITERATE (CProt_ref::TEc, it, pref.GetEc()) {
  2387.         if ( !it->empty() ) {
  2388.             x_AddFTableQual("EC_number", *it);
  2389.         }
  2390.     }
  2391.     if ( prot.CanGetComment()  &&  !prot.GetComment().empty() ) {
  2392.         x_AddFTableQual("prot_note", prot.GetComment());
  2393.     }
  2394. }
  2397. void CFeatureItem::x_AddFTableRegionQuals(const CSeqFeatData::TRegion& region) const
  2398. {
  2399.     if ( !region.empty() ) {
  2400.         x_AddFTableQual("region", region);
  2401.     }
  2402. }
  2405. void CFeatureItem::x_AddFTableBondQuals(const CSeqFeatData::TBond& bond) const
  2406. {
  2407.     size_t bondidx = static_cast<size_t>(bond);
  2408.     if ( bondidx == static_cast<size_t>(CSeqFeatData::eBond_other) ) {
  2409.         bondidx = 5;
  2410.     }
  2411.     if ( bondidx > 0  &&  bondidx < 6 ) {
  2412.         x_AddFTableQual("bond_type", s_BondList[bondidx]);
  2413.     }
  2414. }
  2417. void CFeatureItem::x_AddFTableSiteQuals(const CSeqFeatData::TSite& site) const
  2418. {
  2419.     size_t siteidx = static_cast<size_t>(site);
  2420.     if ( siteidx == static_cast<size_t>(CSeqFeatData::eSite_other) ) {
  2421.         siteidx = 26;
  2422.     }
  2423.     if ( siteidx > 0  &&  siteidx < 27 ) {
  2424.         x_AddFTableQual("site_type", s_SiteList[siteidx]);
  2425.     }
  2426. }
  2429. void CFeatureItem::x_AddFTablePsecStrQuals(const CSeqFeatData::TPsec_str& psec_str) const
  2430. {
  2431.     size_t idx = static_cast<size_t>(psec_str);
  2432.     if ( idx > 0  &&  idx < 3 ) {
  2433.         x_AddFTableQual("sec_str_type", s_PsecStrText[idx]);
  2434.     }
  2435. }
  2438. void CFeatureItem::x_AddFTablePsecStrQuals(const CSeqFeatData::THet& het) const
  2439. {
  2440.     if ( !het.Get().empty() ) {
  2441.         x_AddFTableQual("heterogen", het.Get());
  2442.     }
  2443. }
  2446. static const string s_GetSubtypeString(const COrgMod::TSubtype& subtype)
  2447. {
  2448.     switch ( subtype ) {
  2449.         case COrgMod::eSubtype_strain:           return "strain";
  2450.         case COrgMod::eSubtype_substrain:        return "substrain";
  2451.         case COrgMod::eSubtype_type:             return "type";
  2452.         case COrgMod::eSubtype_subtype:          return "subtype";
  2453.         case COrgMod::eSubtype_variety:          return "variety";
  2454.         case COrgMod::eSubtype_serotype:         return "serotype";
  2455.         case COrgMod::eSubtype_serogroup:        return "serogroup";
  2456.         case COrgMod::eSubtype_serovar:          return "serovar";
  2457.         case COrgMod::eSubtype_cultivar:         return "cultivar";
  2458.         case COrgMod::eSubtype_pathovar:         return "pathovar";
  2459.         case COrgMod::eSubtype_chemovar:         return "chemovar";
  2460.         case COrgMod::eSubtype_biovar:           return "biovar";
  2461.         case COrgMod::eSubtype_biotype:          return "biotype";
  2462.         case COrgMod::eSubtype_group:            return "group";
  2463.         case COrgMod::eSubtype_subgroup:         return "subgroup";
  2464.         case COrgMod::eSubtype_isolate:          return "isolate";
  2465.         case COrgMod::eSubtype_common:           return "common";
  2466.         case COrgMod::eSubtype_acronym:          return "acronym";
  2467.         case COrgMod::eSubtype_dosage:           return "dosage";
  2468.         case COrgMod::eSubtype_nat_host:         return "nat_host";
  2469.         case COrgMod::eSubtype_sub_species:      return "sub_species";
  2470.         case COrgMod::eSubtype_specimen_voucher: return "specimen_voucher";
  2471.         case COrgMod::eSubtype_authority:        return "authority";
  2472.         case COrgMod::eSubtype_forma:            return "forma";
  2473.         case COrgMod::eSubtype_forma_specialis:  return "dosage";
  2474.         case COrgMod::eSubtype_ecotype:          return "ecotype";
  2475.         case COrgMod::eSubtype_synonym:          return "synonym";
  2476.         case COrgMod::eSubtype_anamorph:         return "anamorph";
  2477.         case COrgMod::eSubtype_teleomorph:       return "teleomorph";
  2478.         case COrgMod::eSubtype_breed:            return "breed";
  2479.         case COrgMod::eSubtype_gb_acronym:       return "gb_acronym";
  2480.         case COrgMod::eSubtype_gb_anamorph:      return "gb_anamorph";
  2481.         case COrgMod::eSubtype_gb_synonym:       return "gb_synonym";
  2482.         case COrgMod::eSubtype_old_lineage:      return "old_lineage";
  2483.         case COrgMod::eSubtype_old_name:         return "old_name";
  2484.         case COrgMod::eSubtype_other:            return "note";
  2485.         default:                                 return kEmptyStr;
  2486.     }
  2487.     return kEmptyStr;
  2488. }
  2491. static const string s_GetSubsourceString(const CSubSource::TSubtype& subtype)
  2492. {
  2493.     switch ( subtype ) {
  2494.         case CSubSource::eSubtype_chromosome: return "chromosome";
  2495.         case CSubSource::eSubtype_map: return "map";
  2496.         case CSubSource::eSubtype_clone: return "clone";
  2497.         case CSubSource::eSubtype_subclone: return "subclone";
  2498.         case CSubSource::eSubtype_haplotype: return "haplotype";
  2499.         case CSubSource::eSubtype_genotype: return "genotype";
  2500.         case CSubSource::eSubtype_sex: return "sex";
  2501.         case CSubSource::eSubtype_cell_line: return "cell_line";
  2502.         case CSubSource::eSubtype_cell_type: return "cell_type";
  2503.         case CSubSource::eSubtype_tissue_type: return "tissue_type";
  2504.         case CSubSource::eSubtype_clone_lib: return "clone_lib";
  2505.         case CSubSource::eSubtype_dev_stage: return "dev_stage";
  2506.         case CSubSource::eSubtype_frequency: return "frequency";
  2507.         case CSubSource::eSubtype_germline: return "germline";
  2508.         case CSubSource::eSubtype_rearranged: return "rearranged";
  2509.         case CSubSource::eSubtype_lab_host: return "lab_host";
  2510.         case CSubSource::eSubtype_pop_variant: return "pop_variant";
  2511.         case CSubSource::eSubtype_tissue_lib: return "tissue_lib";
  2512.         case CSubSource::eSubtype_plasmid_name: return "plasmid_name";
  2513.         case CSubSource::eSubtype_transposon_name: return "transposon_name";
  2514.         case CSubSource::eSubtype_insertion_seq_name: return "insertion_seq_name";
  2515.         case CSubSource::eSubtype_plastid_name: return "plastid_name";
  2516.         case CSubSource::eSubtype_country: return "country";
  2517.         case CSubSource::eSubtype_segment: return "segment";
  2518.         case CSubSource::eSubtype_endogenous_virus_name: return "endogenous_virus_name";
  2519.         case CSubSource::eSubtype_transgenic: return "transgenic";
  2520.         case CSubSource::eSubtype_environmental_sample: return "environmental_sample";
  2521.         case CSubSource::eSubtype_isolation_source: return "isolation_source";
  2522.         case CSubSource::eSubtype_other: return "note";
  2523.         default: return kEmptyStr;
  2524.     }
  2525.     return kEmptyStr;
  2526. }
  2528. void CFeatureItem::x_AddFTableBiosrcQuals(const CBioSource& src) const
  2529. {
  2530.     if ( src.CanGetOrg() ) {
  2531.         const CBioSource::TOrg& org = src.GetOrg();
  2533.         if ( org.CanGetTaxname()  &&  !org.GetTaxname().empty() ) {
  2534.             x_AddFTableQual("organism", org.GetTaxname());
  2535.         }
  2537.         if ( org.CanGetOrgname() ) {
  2538.             ITERATE (COrgName::TMod, it, org.GetOrgname().GetMod()) {
  2539.                 if ( (*it)->CanGetSubtype() ) {
  2540.                     string str = s_GetSubtypeString((*it)->GetSubtype());
  2541.                     if ( str.empty() ) {
  2542.                         continue;
  2543.                     }
  2544.                     if ( (*it)->CanGetSubname()  &&  !(*it)->GetSubname().empty() ) {
  2545.                         str += (*it)->GetSubname();
  2546.                     }
  2547.                     x_AddFTableQual(str);
  2548.                 }
  2549.             }
  2550.         }
  2551.     }
  2553.     ITERATE (CBioSource::TSubtype, it, src.GetSubtype()) {
  2554.         if ( (*it)->CanGetSubtype() ) {
  2555.             string str = s_GetSubsourceString((*it)->GetSubtype());
  2556.             if ( str.empty() ) {
  2557.                 continue;
  2558.             }
  2559.             if ( (*it)->CanGetName() ) {
  2560.                 str += (*it)->GetName();
  2561.             }
  2562.             x_AddFTableQual(str);
  2563.         }
  2564.     }
  2565. }
  2568. /////////////////////////////////////////////////////////////////////////////
  2569. //   Source Feature
  2570. /////////////////////////////////////////////////////////////////////////////
  2572. void CSourceFeatureItem::x_AddQuals(CBioseqContext& ctx)
  2573. {
  2574.     const CSeqFeatData& data = m_Feat->GetData();
  2575.     _ASSERT(data.IsOrg()  ||  data.IsBiosrc());
  2576.     // add various generic qualifiers...
  2577.     x_AddQual(eSQ_mol_type,
  2578.               new CFlatMolTypeQVal(ctx.GetBiomol(), ctx.GetMol()));
  2579.     if (m_Feat->IsSetComment()) {
  2580.         x_AddQual(eSQ_seqfeat_note, new CFlatStringQVal(m_Feat->GetComment()));
  2581.     }
  2582.     if (m_Feat->IsSetTitle()) {
  2583.         x_AddQual(eSQ_label, new CFlatLabelQVal(m_Feat->GetTitle()));
  2584.     }
  2585.     if (m_Feat->IsSetCit()) {
  2586.         x_AddQual(eSQ_citation, new CFlatPubSetQVal(m_Feat->GetCit()));
  2587.     }
  2588.     if (m_Feat->IsSetDbxref()) {
  2589.         x_AddQual(eSQ_org_xref, new CFlatXrefQVal(m_Feat->GetDbxref()));
  2590.     }
  2591.     // add qualifiers from biosource fields
  2592.     x_AddQuals(data.GetBiosrc(), ctx);
  2593. }
  2596. static ESourceQualifier s_OrgModToSlot(const COrgMod& om)
  2597. {
  2598.     switch ( om.GetSubtype() ) {
  2599. #define CASE_ORGMOD(x) case COrgMod::eSubtype_##x:  return eSQ_##x;
  2600.         CASE_ORGMOD(strain);
  2601.         CASE_ORGMOD(substrain);
  2602.         CASE_ORGMOD(type);
  2603.         CASE_ORGMOD(subtype);
  2604.         CASE_ORGMOD(variety);
  2605.         CASE_ORGMOD(serotype);
  2606.         CASE_ORGMOD(serogroup);
  2607.         CASE_ORGMOD(serovar);
  2608.         CASE_ORGMOD(cultivar);
  2609.         CASE_ORGMOD(pathovar);
  2610.         CASE_ORGMOD(chemovar);
  2611.         CASE_ORGMOD(biovar);
  2612.         CASE_ORGMOD(biotype);
  2613.         CASE_ORGMOD(group);
  2614.         CASE_ORGMOD(subgroup);
  2615.         CASE_ORGMOD(isolate);
  2616.         CASE_ORGMOD(common);
  2617.         CASE_ORGMOD(acronym);
  2618.         CASE_ORGMOD(dosage);
  2619.     case COrgMod::eSubtype_nat_host:  return eSQ_spec_or_nat_host;
  2620.         CASE_ORGMOD(sub_species);
  2621.         CASE_ORGMOD(specimen_voucher);
  2622.         CASE_ORGMOD(authority);
  2623.         CASE_ORGMOD(forma);
  2624.         CASE_ORGMOD(forma_specialis);
  2625.         CASE_ORGMOD(ecotype);
  2626.         CASE_ORGMOD(synonym);
  2627.         CASE_ORGMOD(anamorph);
  2628.         CASE_ORGMOD(teleomorph);
  2629.         CASE_ORGMOD(breed);
  2630.         CASE_ORGMOD(gb_acronym);
  2631.         CASE_ORGMOD(gb_anamorph);
  2632.         CASE_ORGMOD(gb_synonym);
  2633.         CASE_ORGMOD(old_lineage);
  2634.         CASE_ORGMOD(old_name);
  2635. #undef CASE_ORGMOD
  2636.     case COrgMod::eSubtype_other:  return eSQ_orgmod_note;
  2637.     default:                       return eSQ_none;
  2638.     }
  2639. }
  2642. void CSourceFeatureItem::x_AddQuals(const COrg_ref& org, CBioseqContext& ctx) const
  2643. {
  2644.     string taxname, common;
  2645.     if ( org.IsSetTaxname() ) {
  2646.         taxname = org.GetTaxname();
  2647.     }
  2648.     if ( taxname.empty()  &&  ctx.Config().NeedOrganismQual() ) {
  2649.         taxname = "unknown";
  2650.         if ( org.IsSetCommon() ) {
  2651.             common = org.GetCommon();
  2652.         }
  2653.     }
  2654.     if ( !taxname.empty() ) {
  2655.         x_AddQual(eSQ_organism, new CFlatStringQVal(taxname));
  2656.     }
  2657.     if ( !common.empty() ) {
  2658.         x_AddQual(eSQ_common_name, new CFlatStringQVal(common));
  2659.     }
  2660.     if ( org.CanGetOrgname() ) {
  2661.         ITERATE (COrgName::TMod, it, org.GetOrgname().GetMod()) {
  2662.             ESourceQualifier slot = s_OrgModToSlot(**it);
  2663.             if (slot != eSQ_none) {
  2664.                 x_AddQual(slot, new CFlatOrgModQVal(**it));
  2665.             }
  2666.         }
  2667.     }
  2668.     if ( !WasDesc() ) {
  2669.         x_AddQual(eSQ_unstructured, new CFlatStringListQVal(org.GetMod()));
  2670.     }
  2671.     if ( org.IsSetDb() ) {
  2672.         x_AddQual(eSQ_db_xref, new CFlatXrefQVal(org.GetDb()));
  2673.     }
  2674. }
  2677. static ESourceQualifier s_SubSourceToSlot(const CSubSource& ss)
  2678. {
  2679.     switch (ss.GetSubtype()) {
  2680. #define DO_SS(x) case CSubSource::eSubtype_##x:  return eSQ_##x;
  2681.         DO_SS(chromosome);
  2682.         DO_SS(map);
  2683.         DO_SS(clone);
  2684.         DO_SS(subclone);
  2685.         DO_SS(haplotype);
  2686.         DO_SS(genotype);
  2687.         DO_SS(sex);
  2688.         DO_SS(cell_line);
  2689.         DO_SS(cell_type);
  2690.         DO_SS(tissue_type);
  2691.         DO_SS(clone_lib);
  2692.         DO_SS(dev_stage);
  2693.         DO_SS(frequency);
  2694.         DO_SS(germline);
  2695.         DO_SS(rearranged);
  2696.         DO_SS(lab_host);
  2697.         DO_SS(pop_variant);
  2698.         DO_SS(tissue_lib);
  2699.         DO_SS(plasmid_name);
  2700.         DO_SS(transposon_name);
  2701.         DO_SS(insertion_seq_name);
  2702.         DO_SS(plastid_name);
  2703.         DO_SS(country);
  2704.         DO_SS(segment);
  2705.         DO_SS(endogenous_virus_name);
  2706.         DO_SS(transgenic);
  2707.         DO_SS(environmental_sample);
  2708.         DO_SS(isolation_source);
  2709. #undef DO_SS
  2710.     case CSubSource::eSubtype_other:  return eSQ_subsource_note;
  2711.     default:                          return eSQ_none;
  2712.     }
  2713. }
  2716. void CSourceFeatureItem::x_AddQuals(const CBioSource& src, CBioseqContext& ctx) const
  2717. {
  2718.     // add qualifiers from Org_ref field
  2719.     if ( src.CanGetOrg() ) {
  2720.         x_AddQuals(src.GetOrg(), ctx);
  2721.     }
  2722.     x_AddQual(eSQ_focus, new CFlatBoolQVal(src.IsSetIs_focus()));
  2724.     
  2725.     bool insertion_seq_name = false,
  2726.          plasmid_name = false,
  2727.          transposon_name = false;
  2728.     ITERATE (CBioSource::TSubtype, it, src.GetSubtype()) {
  2729.         ESourceQualifier slot = s_SubSourceToSlot(**it);
  2730.         if ( slot == eSQ_insertion_seq_name ) {
  2731.             insertion_seq_name = true;
  2732.         } else if ( slot == eSQ_plasmid_name ) {
  2733.             plasmid_name = true;
  2734.         } else if ( slot == eSQ_transposon_name ) {
  2735.             transposon_name = true;
  2736.         }
  2737.         if (slot != eSQ_none) {
  2738.             x_AddQual(slot, new CFlatSubSourceQVal(**it));
  2739.         }
  2740.     }
  2742.     // some qualifiers are flags in genome and names in subsource,
  2743.     // print once with name
  2744.     CBioSource::TGenome genome = src.GetGenome();
  2745.     CRef<CFlatOrganelleQVal> organelle(new CFlatOrganelleQVal(genome));
  2746.     if ( (insertion_seq_name  &&  genome == CBioSource::eGenome_insertion_seq)  ||
  2747.          (plasmid_name  &&  genome == CBioSource::eGenome_plasmid)  ||
  2748.          (transposon_name  &&  genome == CBioSource::eGenome_transposon) ) {
  2749.         organelle.Reset();
  2750.     }
  2751.     if ( organelle ) {
  2752.         x_AddQual(eSQ_organelle, organelle);
  2753.     }
  2755.     if ( !WasDesc()  &&  m_Feat->CanGetComment() ) {
  2756.         x_AddQual(eSQ_seqfeat_note, new CFlatStringQVal(m_Feat->GetComment()));
  2757.     }
  2758. }
  2761. void CSourceFeatureItem::x_FormatQuals(CFlatFeature& ff) const
  2762. {
  2763.     ff.SetQuals().reserve(m_Quals.Size());
  2764.     CFlatFeature::TQuals& qvec = ff.SetQuals();
  2766. #define DO_QUAL(x) x_FormatQual(eSQ_##x, #x, qvec)
  2767.     DO_QUAL(organism);
  2769.     DO_QUAL(organelle);
  2771.     DO_QUAL(mol_type);
  2773.     DO_QUAL(strain);
  2774.     x_FormatQual(eSQ_substrain, "sub_strain", qvec);
  2775.     DO_QUAL(variety);
  2776.     DO_QUAL(serotype);
  2777.     DO_QUAL(serovar);
  2778.     DO_QUAL(cultivar);
  2779.     DO_QUAL(isolate);
  2780.     DO_QUAL(isolation_source);
  2781.     x_FormatQual(eSQ_spec_or_nat_host, "specific_host", qvec);
  2782.     DO_QUAL(sub_species);
  2783.     DO_QUAL(specimen_voucher);
  2785.     DO_QUAL(db_xref);
  2786.     x_FormatQual(eSQ_org_xref, "db_xref", qvec);
  2788.     DO_QUAL(chromosome);
  2790.     DO_QUAL(segment);
  2792.     DO_QUAL(map);
  2793.     DO_QUAL(clone);
  2794.     x_FormatQual(eSQ_subclone, "sub_clone", qvec);
  2795.     DO_QUAL(haplotype);
  2796.     DO_QUAL(sex);
  2797.     DO_QUAL(cell_line);
  2798.     DO_QUAL(cell_type);
  2799.     DO_QUAL(tissue_type);
  2800.     DO_QUAL(clone_lib);
  2801.     DO_QUAL(dev_stage);
  2802.     DO_QUAL(frequency);
  2804.     DO_QUAL(germline);
  2805.     DO_QUAL(rearranged);
  2806.     DO_QUAL(transgenic);
  2807.     DO_QUAL(environmental_sample);
  2809.     DO_QUAL(lab_host);
  2810.     DO_QUAL(pop_variant);
  2811.     DO_QUAL(tissue_lib);
  2813.     x_FormatQual(eSQ_plasmid_name,       "plasmid", qvec);
  2814.     x_FormatQual(eSQ_transposon_name,    "transposon", qvec);
  2815.     x_FormatQual(eSQ_insertion_seq_name, "insertion_seq", qvec);
  2817.     DO_QUAL(country);
  2819.     DO_QUAL(focus);
  2821.     if ( !GetContext()->Config().SrcQualsToNote() ) {
  2822.         // some note qualifiers appear as regular quals in GBench or Dump mode
  2823.         x_FormatGBNoteQuals(ff);
  2824.     }
  2826.     DO_QUAL(sequenced_mol);
  2827.     DO_QUAL(label);
  2828.     DO_QUAL(usedin);
  2829.     DO_QUAL(citation);
  2830. #undef DO_QUAL
  2832.     // Format the rest of the note quals (ones that weren't formatted above)
  2833.     // as a single note qualifier
  2834.     x_FormatNoteQuals(ff);
  2835. }
  2838. void CSourceFeatureItem::x_FormatGBNoteQuals(CFlatFeature& ff) const
  2839. {
  2840.     _ASSERT(!GetContext()->Config().SrcQualsToNote());
  2841.     CFlatFeature::TQuals& qvec = ff.SetQuals();
  2843. #define DO_QUAL(x) x_FormatQual(eSQ_##x, #x, qvec)
  2844.     DO_QUAL(type);
  2845.     DO_QUAL(subtype);
  2846.     DO_QUAL(serogroup);
  2847.     DO_QUAL(pathovar);
  2848.     DO_QUAL(chemovar);
  2849.     DO_QUAL(biovar);
  2850.     DO_QUAL(biotype);
  2851.     DO_QUAL(group);
  2852.     DO_QUAL(subgroup);
  2853.     DO_QUAL(common);
  2854.     DO_QUAL(acronym);
  2855.     DO_QUAL(dosage);
  2856.     
  2857.     DO_QUAL(authority);
  2858.     DO_QUAL(forma);
  2859.     DO_QUAL(forma_specialis);
  2860.     DO_QUAL(ecotype);
  2861.     DO_QUAL(synonym);
  2862.     DO_QUAL(anamorph);
  2863.     DO_QUAL(teleomorph);
  2864.     DO_QUAL(breed);
  2865.     
  2866.     DO_QUAL(genotype);
  2867.     x_FormatQual(eSQ_plastid_name, "plastid", qvec);
  2868.     
  2869.     x_FormatQual(eSQ_endogenous_virus_name, "endogenous_virus", qvec);
  2871.     x_FormatQual(eSQ_zero_orgmod, "?", qvec);
  2872.     x_FormatQual(eSQ_one_orgmod,  "?", qvec);
  2873.     x_FormatQual(eSQ_zero_subsrc, "?", qvec);
  2874. #undef DO_QUAL
  2875. }
  2878. void CSourceFeatureItem::x_FormatNoteQuals(CFlatFeature& ff) const
  2879. {
  2880.     CFlatFeature::TQuals qvec;
  2881.     bool add_period = false;
  2883. #define DO_NOTE(x) x_FormatNoteQual(eSQ_##x, #x, qvec, add_period)
  2884.     if (m_WasDesc) {
  2885.         x_FormatNoteQual(eSQ_seqfeat_note, "note", qvec, add_period);
  2886.         DO_NOTE(orgmod_note);
  2887.         DO_NOTE(subsource_note);
  2888.     } else {
  2889.         DO_NOTE(unstructured);
  2890.     }
  2892.     if ( GetContext()->Config().SrcQualsToNote() ) {
  2893.         DO_NOTE(type);
  2894.         DO_NOTE(subtype);
  2895.         DO_NOTE(serogroup);
  2896.         DO_NOTE(pathovar);
  2897.         DO_NOTE(chemovar);
  2898.         DO_NOTE(biovar);
  2899.         DO_NOTE(biotype);
  2900.         DO_NOTE(group);
  2901.         DO_NOTE(subgroup);
  2902.         DO_NOTE(common);
  2903.         DO_NOTE(acronym);
  2904.         DO_NOTE(dosage);
  2905.         
  2906.         DO_NOTE(authority);
  2907.         DO_NOTE(forma);
  2908.         DO_NOTE(forma_specialis);
  2909.         DO_NOTE(ecotype);
  2910.         DO_NOTE(synonym);
  2911.         DO_NOTE(anamorph);
  2912.         DO_NOTE(teleomorph);
  2913.         DO_NOTE(breed);
  2914.         
  2915.         DO_NOTE(genotype);
  2916.         x_FormatNoteQual(eSQ_plastid_name, "plastid", qvec, add_period);
  2917.         
  2918.         x_FormatNoteQual(eSQ_endogenous_virus_name, "endogenous_virus", qvec, add_period);
  2919.     }
  2921.     x_FormatNoteQual(eSQ_common_name, "common", qvec, add_period);
  2923.     if ( GetContext()->Config().SrcQualsToNote() ) {
  2924.         x_FormatNoteQual(eSQ_zero_orgmod, "?", qvec, add_period);
  2925.         x_FormatNoteQual(eSQ_one_orgmod,  "?", qvec, add_period);
  2926.         x_FormatNoteQual(eSQ_zero_subsrc, "?", qvec, add_period);
  2927.     }
  2928. #undef DO_NOTE
  2930.     string notestr;
  2931.     const string* suffix = &kEmptyStr;
  2933.     if ( GetSource().CanGetGenome()  &&  
  2934.         GetSource().GetGenome() == CBioSource::eGenome_extrachrom ) {
  2935.         static const string kEOL = "n";
  2936.         notestr += "extrachromosomal";
  2937.         suffix = &kEOL;
  2938.     }
  2940.     CFlatFeature::TQuals::const_iterator last = qvec.end();
  2941.     CFlatFeature::TQuals::const_iterator end = last--;
  2942.     CFlatFeature::TQuals::const_iterator it = qvec.begin();
  2943.     for ( ; it != end; ++it ) {
  2944.         string note = (*it)->GetValue();
  2945.         if ( NStr::EndsWith(note, ".")  &&  !NStr::EndsWith(note, "...") ) {
  2946.             if ( !add_period ) {
  2947.                 note.erase(note.length() - 1);
  2948.             }
  2949.         }
  2950.         const string& prefix = *suffix + (*it)->GetPrefix();
  2951.         JoinNoRedund(notestr, prefix, note);
  2952.         suffix = &(*it)->GetSuffix();
  2953.     }
  2954.     if ( !notestr.empty() ) {
  2955.         CRef<CFormatQual> note(new CFormatQual("note", notestr));
  2956.         ff.SetQuals().push_back(note);
  2957.     }
  2958. }
  2961. CSourceFeatureItem::CSourceFeatureItem
  2962. (const CBioSource& src,
  2963.  TRange range,
  2964.  CBioseqContext& ctx)
  2965.     : CFeatureItemBase(*new CSeq_feat, ctx),
  2966.       m_WasDesc(true)
  2967. {
  2968.     CSeq_feat& feat = const_cast<CSeq_feat&>(*m_Feat);
  2969.     feat.SetData().SetBiosrc(const_cast<CBioSource&>(src));
  2970.     if ( range.IsWhole() ) {
  2971.         feat.SetLocation().SetWhole(*ctx.GetPrimaryId());
  2972.     } else {
  2973.         CSeq_interval& ival = feat.SetLocation().SetInt();
  2974.         ival.SetFrom(range.GetFrom());
  2975.         ival.SetTo(range.GetTo());
  2976.         ival.SetId(*ctx.GetPrimaryId());
  2977.     }
  2979.     x_GatherInfo(ctx);
  2980. }
  2983. void CSourceFeatureItem::x_FormatQual
  2984. (ESourceQualifier slot,
  2985.  const string& name,
  2986.  CFlatFeature::TQuals& qvec,
  2987.  bool& add_period,
  2988.  IFlatQVal::TFlags flags) const
  2989. {
  2990.     pair<TQCI, TQCI> range = const_cast<const TQuals&>(m_Quals).GetQuals(slot);
  2991.     for (TQCI it = range.first;  it != range.second;  ++it) {
  2992.         const IFlatQVal* qual = it->second;
  2993.         qual->Format(qvec, name, *GetContext(),
  2994.                      flags | IFlatQVal::fIsSource);
  2995.         const CFlatOrgModQVal* orgmod = dynamic_cast<const CFlatOrgModQVal*>(qual);
  2996.         const CFlatSubSourceQVal* subsource = dynamic_cast<const CFlatSubSourceQVal*>(qual);
  2998.         add_period = add_period  ||  (orgmod != 0)  ||  (subsource != 0);
  2999.     }
  3000. }
  3003. END_SCOPE(objects)
  3004. END_NCBI_SCOPE
  3006. /*
  3007. * ===========================================================================
  3008. *
  3009. * $Log: feature_item.cpp,v $
  3010. * Revision 1000.2  2004/06/01 19:44:14  gouriano
  3011. * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.26
  3012. *
  3013. * Revision 1.26  2004/05/26 14:57:54  shomrat
  3014. * removed non-preferred variants ribosome slippage, trans splicing, alternate processing, and non-consensus splice site
  3015. *
  3016. * Revision 1.25  2004/05/21 21:42:54  gorelenk
  3017. * Added PCH ncbi_pch.hpp
  3018. *
  3019. * Revision 1.24  2004/05/19 14:47:19  shomrat
  3020. * Check for illegal qualifiers in RELEASE mode
  3021. *
  3022. * Revision 1.23  2004/05/08 12:12:00  dicuccio
  3023. * Use best ID representation for protein products
  3024. *
  3025. * Revision 1.22  2004/05/07 15:22:39  shomrat
  3026. * Added qualifiers add Seq-id filters
  3027. *
  3028. * Revision 1.21  2004/05/06 19:41:00  ucko
  3029. * Kill unwanted definition of ff as a macro, if present (as on Mac OS 10.3)
  3030. *
  3031. * Revision 1.20  2004/05/06 17:49:59  shomrat
  3032. * Fixed feature formatting
  3033. *
  3034. * Revision 1.19  2004/04/22 15:56:47  shomrat
  3035. * Changes in context
  3036. *
  3037. * Revision 1.18  2004/04/13 16:46:39  shomrat
  3038. * Changes due to GBSeq format
  3039. *
  3040. * Revision 1.17  2004/04/12 16:17:27  vasilche
  3041. * Fixed '=' <-> '==' typo.
  3042. *
  3043. * Revision 1.16  2004/04/07 14:27:15  shomrat
  3044. * Added methods forFTable format
  3045. *
  3046. * Revision 1.15  2004/03/31 16:00:12  ucko
  3047. * C(Source)FeatureItem::x_FormatQual: make sure to call the const
  3048. * version of GetQuals to fix WorkShop build errors.
  3049. *
  3050. * Revision 1.14  2004/03/30 20:27:09  shomrat
  3051. * Separated quals container from feature class
  3052. *
  3053. * Revision 1.13  2004/03/25 20:37:41  shomrat
  3054. * Use handles
  3055. *
  3056. * Revision 1.12  2004/03/18 15:37:57  shomrat
  3057. * Fixes to note qual formatting
  3058. *
  3059. * Revision 1.11  2004/03/10 21:30:18  shomrat
  3060. * + product tRNA qual; limit Seq-is types for product ids
  3061. *
  3062. * Revision 1.10  2004/03/10 16:22:18  shomrat
  3063. * Fixed product-id qualifiers
  3064. *
  3065. * Revision 1.9  2004/03/08 21:02:18  shomrat
  3066. * + Exception quals gathering; fixed product id gathering
  3067. *
  3068. * Revision 1.8  2004/03/08 15:45:46  shomrat
  3069. * Added pseudo qualifier
  3070. *
  3071. * Revision 1.7  2004/03/05 18:44:48  shomrat
  3072. * fixes to qualifiers collection and formatting
  3073. *
  3074. * Revision 1.6  2004/02/19 18:07:26  shomrat
  3075. * HideXXXFeat() => HideXXXFeats()
  3076. *
  3077. * Revision 1.5  2004/02/11 22:50:35  shomrat
  3078. * override GetKey
  3079. *
  3080. * Revision 1.4  2004/02/11 16:56:42  shomrat
  3081. * changes in qualifiers gathering and formatting
  3082. *
  3083. * Revision 1.3  2004/01/14 16:12:20  shomrat
  3084. * uncommenetd code
  3085. *
  3086. * Revision 1.2  2003/12/18 17:43:33  shomrat
  3087. * context.hpp moved
  3088. *
  3089. * Revision 1.1  2003/12/17 20:20:52  shomrat
  3090. * Initial Revision (adapted from flat lib)
  3091. *
  3092. * Revision 1.10  2003/10/17 20:58:41  ucko
  3093. * Don't assume coding-region features have their "product" fields set.
  3094. *
  3095. * Revision 1.9  2003/10/16 20:21:53  ucko
  3096. * Fix a copy-and-paste error in CFeatureItem::x_AddQuals
  3097. *
  3098. * Revision 1.8  2003/10/08 21:11:12  ucko
  3099. * Add a couple of accessors to CFeatureItemBase for the GFF/GTF formatter.
  3100. *
  3101. * Revision 1.7  2003/07/22 18:04:13  dicuccio
  3102. * Fixed access of unset optional variables
  3103. *
  3104. * Revision 1.6  2003/06/02 16:06:42  dicuccio
  3105. * Rearranged src/objects/ subtree.  This includes the following shifts:
  3106. *     - src/objects/asn2asn --> arc/app/asn2asn
  3107. *     - src/objects/testmedline --> src/objects/ncbimime/test
  3108. *     - src/objects/objmgr --> src/objmgr
  3109. *     - src/objects/util --> src/objmgr/util
  3110. *     - src/objects/alnmgr --> src/objtools/alnmgr
  3111. *     - src/objects/flat --> src/objtools/flat
  3112. *     - src/objects/validator --> src/objtools/validator
  3113. *     - src/objects/cddalignview --> src/objtools/cddalignview
  3114. * In addition, libseq now includes six of the objects/seq... libs, and libmmdb
  3115. * replaces the three libmmdb? libs.
  3116. *
  3117. * Revision 1.5  2003/04/24 16:15:58  vasilche
  3118. * Added missing includes and forward class declarations.
  3119. *
  3120. * Revision 1.4  2003/03/21 18:49:17  ucko
  3121. * Turn most structs into (accessor-requiring) classes; replace some
  3122. * formerly copied fields with pointers to the original data.
  3123. *
  3124. * Revision 1.3  2003/03/11 15:37:51  kuznets
  3125. * iterate -> ITERATE
  3126. *
  3127. * Revision 1.2  2003/03/10 22:01:36  ucko
  3128. * Change SLegalImport::m_Name from string to const char* (needed by MSVC).
  3129. *
  3130. * Revision 1.1  2003/03/10 16:39:09  ucko
  3131. * Initial check-in of new flat-file generator
  3132. *
  3133. *
  3134. * ===========================================================================
  3135. */