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

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

生物技术

开发平台：

C/C++

gather_items.cpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: gather_items.cpp,v $
  4.  * PRODUCTION Revision 1000.2  2004/06/01 19:44:32  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.21
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. /*  $Id: gather_items.cpp,v 1000.2 2004/06/01 19:44:32 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, NCBI
  37. *
  38. * File Description:
  39. *   
  40. *
  41. * ===========================================================================
  42. */
  43. #include <ncbi_pch.hpp>
  44. #include <corelib/ncbistd.hpp>
  46. #include <objects/seq/Bioseq.hpp>
  47. #include <objects/seq/Seq_inst.hpp>
  48. #include <objects/seq/Seq_hist.hpp>
  49. #include <objects/seq/Seq_hist_rec.hpp>
  50. #include <objects/seq/Seqdesc.hpp>
  51. #include <objects/seq/Seq_descr.hpp>
  52. #include <objects/seqset/Seq_entry.hpp>
  53. #include <objects/general/User_object.hpp>
  54. #include <objects/general/User_field.hpp>
  55. #include <objects/general/Object_id.hpp>
  56. #include <objects/seqblock/GB_block.hpp>
  57. #include <objects/seqfeat/BioSource.hpp>
  59. #include <objmgr/scope.hpp>
  60. #include <objmgr/bioseq_handle.hpp>
  61. #include <objmgr/bioseq_ci.hpp>
  62. #include <objmgr/seq_entry_handle.hpp>
  63. #include <objmgr/seq_entry_ci.hpp>
  64. #include <objmgr/seq_map.hpp>
  65. #include <objmgr/seqdesc_ci.hpp>
  66. #include <objmgr/feat_ci.hpp>
  67. #include <objmgr/util/sequence.hpp>
  68. #include <objmgr/seq_loc_mapper.hpp>
  70. #include <algorithm>
  72. #include <objtools/format/item_ostream.hpp>
  73. #include <objtools/format/flat_expt.hpp>
  74. #include <objtools/format/items/locus_item.hpp>
  75. #include <objtools/format/items/defline_item.hpp>
  76. #include <objtools/format/items/accession_item.hpp>
  77. #include <objtools/format/items/version_item.hpp>
  78. #include <objtools/format/items/keywords_item.hpp>
  79. #include <objtools/format/items/source_item.hpp>
  80. #include <objtools/format/items/reference_item.hpp>
  81. #include <objtools/format/items/comment_item.hpp>
  82. #include <objtools/format/items/basecount_item.hpp>
  83. #include <objtools/format/items/sequence_item.hpp>
  84. #include <objtools/format/items/feature_item.hpp>
  85. #include <objtools/format/items/segment_item.hpp>
  86. #include <objtools/format/items/ctrl_items.hpp>
  87. #include <objtools/format/gather_items.hpp>
  88. #include <objtools/format/genbank_gather.hpp>
  89. #include <objtools/format/embl_gather.hpp>
  90. #include <objtools/format/gff_gather.hpp>
  91. #include <objtools/format/ftable_gather.hpp>
  92. #include <objtools/format/context.hpp>
  93. #include "utils.hpp"
  96. BEGIN_NCBI_SCOPE
  97. BEGIN_SCOPE(objects)
  98. USING_SCOPE(sequence);
  101. /////////////////////////////////////////////////////////////////////////////
  102. //
  103. // Public:
  105. // "virtual constructor"
  106. CFlatGatherer* CFlatGatherer::New(CFlatFileConfig::TFormat format)
  107. {
  108.     switch ( format ) {
  109.     case CFlatFileConfig::eFormat_GenBank:
  110.     case CFlatFileConfig::eFormat_GBSeq:
  111.         //case CFlatFileGenerator<>::eFormat_Index:
  112.         return new CGenbankGatherer;
  113.         
  114.     case CFlatFileConfig::eFormat_EMBL:
  115.         return new CEmblGatherer;
  117.     case CFlatFileConfig::eFormat_GFF:
  118.         return new CGFFGatherer;
  119.     
  120.     case CFlatFileConfig::eFormat_FTable:
  121.         return new CFtableGatherer;
  123.     case CFlatFileConfig::eFormat_DDBJ:
  124.     default:
  125.         NCBI_THROW(CFlatException, eNotSupported, 
  126.             "This format is currently not supported");
  127.     }
  129.     return 0;
  130. }
  133. void CFlatGatherer::Gather(CFlatFileContext& ctx, CFlatItemOStream& os) const
  134. {
  135.     m_ItemOS.Reset(&os);
  136.     m_Context.Reset(&ctx);
  138.     os << new CStartItem();
  139.     x_GatherSeqEntry(ctx.GetEntry());
  140.     os << new CEndItem();
  141. }
  144. CFlatGatherer::~CFlatGatherer(void)
  145. {
  146. }
  149. /////////////////////////////////////////////////////////////////////////////
  150. //
  151. // Protected:
  154. void CFlatGatherer::x_GatherSeqEntry(const CSeq_entry_Handle& entry) const
  155. {
  156.     if ( entry.IsSet()  &&  entry.GetSet().IsSetClass() ) {
  157.         CBioseq_set::TClass clss = entry.GetSet().GetClass();
  158.         if ( clss == CBioseq_set::eClass_genbank  ||
  159.              clss == CBioseq_set::eClass_mut_set  ||
  160.              clss == CBioseq_set::eClass_pop_set  ||
  161.              clss == CBioseq_set::eClass_phy_set  ||
  162.              clss == CBioseq_set::eClass_eco_set  ||
  163.              clss == CBioseq_set::eClass_wgs_set  ||
  164.              clss == CBioseq_set::eClass_gen_prod_set ) {
  165.             for ( CSeq_entry_CI it(entry); it; ++it ) {
  166.                 x_GatherSeqEntry(*it);
  167.             }
  168.             return;
  169.         }
  170.     }
  172.     // visit each bioseq in the entry (excluding segments)
  173.     CBioseq_CI seq_iter(entry, CSeq_inst::eMol_not_set,
  174.         CBioseq_CI::eLevel_Mains);
  175.     for ( ; seq_iter; ++seq_iter ) {
  176.         if ( x_DisplayBioseq(entry, *seq_iter) ) {
  177.             x_GatherBioseq(*seq_iter);
  178.         }
  179.     }
  180. } 
  183. bool CFlatGatherer::x_DisplayBioseq
  184. (const CSeq_entry_Handle& entry,
  185.  const CBioseq_Handle& seq) const
  186. {
  187.     const CFlatFileConfig& cfg = Config();
  189.     const CSeq_id& id = GetId(seq, eGetId_Best);
  190.     if ( id.IsLocal()  &&  cfg.SuppressLocalId() ) {
  191.         return false;
  192.     }
  194.     if ( (CSeq_inst::IsNa(seq.GetInst_Mol())  &&  cfg.IsViewNuc())  ||
  195.          (CSeq_inst::IsAa(seq.GetInst_Mol())  &&  cfg.IsViewProt()) ) {
  196.         return true;
  197.     }
  199.     return false;
  200. }
  203. bool s_IsSegmented(const CBioseq_Handle& seq)
  204. {
  205.     return seq  &&
  206.            seq.IsSetInst()  &&
  207.            seq.IsSetInst_Repr()  &&
  208.            seq.GetInst_Repr() == CSeq_inst::eRepr_seg;
  209. }
  212. // a defualt implementation for GenBank /  DDBJ formats
  213. void CFlatGatherer::x_GatherBioseq(const CBioseq_Handle& seq) const
  214. {
  215.     bool segmented = s_IsSegmented(seq);
  216.     const CFlatFileConfig& cfg = Config();
  218.     // Do multiple sections (segmented style) if:
  219.     // a. the bioseq is segmented
  220.     // b. style is normal or segmented (not master)
  221.     // c. user didn't specify a location
  222.     // d. not FTable format
  223.     if ( segmented                                        &&
  224.          (cfg.IsStyleNormal()  ||  cfg.IsStyleSegment())  &&
  225.          (m_Context->GetLocation() == 0)                  &&
  226.          !cfg.IsFormatFTable() ) {
  227.         x_DoMultipleSections(seq);
  228.     } else {
  229.         // display as a single bioseq (single section)
  230.         m_Current.Reset(new CBioseqContext(seq, *m_Context));
  231.         m_Context->AddSection(m_Current);
  232.         x_DoSingleSection(*m_Current);
  233.     }   
  234. }
  237. void CFlatGatherer::x_DoMultipleSections(const CBioseq_Handle& seq) const
  238. {
  239.     CRef<CMasterContext> mctx(new CMasterContext(seq));
  241.     CScope* scope = &seq.GetScope();
  242.     const CSeqMap& seqmap = seq.GetSeqMap();
  244.     CSeqMap::TSegment_CI it = seqmap.BeginResolved(scope, 1, CSeqMap::fFindRef);
  245.     while ( it ) {
  246.         CSeq_id_Handle id = it.GetRefSeqid();
  247.         CBioseq_Handle part = scope->GetBioseqHandleFromTSE(id, seq);
  248.         if ( part ) {
  249.             m_Current.Reset(new CBioseqContext(part, *m_Context, mctx));
  250.             m_Context->AddSection(m_Current);
  251.             x_DoSingleSection(*m_Current);
  252.         }
  253.         ++it;
  254.     }
  255. }
  257.     
  258. /////////////////////////////////////////////////////////////////////////////
  259. //
  260. // REFERENCES
  262. bool s_FilterPubdesc(const CPubdesc& pubdesc, CBioseqContext& ctx)
  263. {
  264.     if ( pubdesc.CanGetComment() ) {
  265.         const string& comment = pubdesc.GetComment();
  266.         bool is_gene_rif = NStr::StartsWith(comment, "GeneRIF", NStr::eNocase);
  268.         const CFlatFileConfig& cfg = ctx.Config();
  269.         if ( (cfg.HideGeneRIFs()  &&  is_gene_rif)  ||
  270.              ((cfg.OnlyGeneRIFs()  ||  cfg.LatestGeneRIFs())  &&  !is_gene_rif) ) {
  271.             return true;
  272.         }
  273.     }
  275.     return false;
  276. }
  279. void CFlatGatherer::x_GatherReferences(void) const
  280. {
  281.     CBioseqContext::TReferences& refs = m_Current->SetReferences();
  283.     // gather references from descriptors
  284.     for (CSeqdesc_CI it(m_Current->GetHandle(), CSeqdesc::e_Pub); it; ++it) {
  285.         const CPubdesc& pubdesc = it->GetPub();
  286.         if ( s_FilterPubdesc(pubdesc, *m_Current) ) {
  287.             continue;
  288.         }
  289.         
  290.         refs.push_back(CBioseqContext::TRef(new CReferenceItem(*it, *m_Current)));
  291.     }
  293.     // gather references from features
  294.     SAnnotSelector sel(CSeqFeatData::e_Pub);
  295.     sel.SetCombineMethod(SAnnotSelector::eCombine_All);
  296.     CFeat_CI it(m_Current->GetScope(), m_Current->GetLocation(), sel);
  297.     for ( ; it; ++it) {
  298.         refs.push_back(CBioseqContext::TRef(new CReferenceItem(it->GetData().GetPub(),
  299.                                         *m_Current, &it->GetLocation())));
  300.     }
  301.     CReferenceItem::Rearrange(refs, *m_Current);
  302.     ITERATE (CBioseqContext::TReferences, ref, refs) {
  303.         *m_ItemOS << *ref;
  304.     }
  305. }
  308. /////////////////////////////////////////////////////////////////////////////
  309. //
  310. // COMMENTS
  313. void CFlatGatherer::x_GatherComments(void) const
  314. {
  315.     CBioseqContext& ctx = *m_Current;
  317.     // Gather comments related to the seq-id
  318.     x_IdComments(ctx);
  319.     x_RefSeqComments(ctx);
  321.     if ( CCommentItem::NsAreGaps(ctx.GetHandle(), ctx) ) {
  322.         x_AddComment(new CCommentItem(CCommentItem::kNsAreGaps, ctx));
  323.     }
  325.     x_HistoryComments(ctx);
  326.     x_WGSComment(ctx);
  327.     if ( ctx.ShowGBBSource() ) {
  328.         x_GBBSourceComment(ctx);
  329.     }
  330.     x_DescComments(ctx);
  331.     x_MaplocComments(ctx);
  332.     x_RegionComments(ctx);
  333.     x_HTGSComments(ctx);
  334.     x_FeatComments(ctx);
  336.     x_FlushComments();
  337. }
  340. void CFlatGatherer::x_AddComment(CCommentItem* comment) const
  341. {
  342.     CRef<CCommentItem> com(comment);
  343.     if ( !com->Skip() ) {
  344.         m_Comments.push_back(com);
  345.     }
  346. }
  349. void CFlatGatherer::x_AddGSDBComment
  350. (const CDbtag& dbtag,
  351.  CBioseqContext& ctx) const
  352. {
  353.     CRef<CCommentItem> gsdb_comment(new CGsdbComment(dbtag, ctx));
  354.     if ( !gsdb_comment->Skip() ) {
  355.         m_Comments.push_back(gsdb_comment);
  356.     }
  357. }
  360. void CFlatGatherer::x_FlushComments(void) const
  361. {
  362.     if ( m_Comments.empty() ) {
  363.         return;
  364.     }
  365.     // add a period to the last comment (if not local id)
  366.     if ( dynamic_cast<CLocalIdComment*>(&*m_Comments.back()) == 0 ) {
  367.         m_Comments.back()->AddPeriod();
  368.     }
  369.     
  370.     // add a period to a GSDB comment (if exist and not last)
  371.     TCommentVec::iterator last = m_Comments.end();
  372.     --last;
  373.     NON_CONST_ITERATE (TCommentVec, it, m_Comments) {
  374.         CGsdbComment* gsdb = dynamic_cast<CGsdbComment*>(it->GetPointerOrNull());
  375.         if ( gsdb != 0   &&  it != last ) {
  376.             gsdb->AddPeriod();
  377.         }
  378.         *m_ItemOS << *it;
  379.     }
  381.     m_Comments.clear();
  382. }
  385. string s_GetGenomeBuildNumber(const CBioseq_Handle& bsh)
  386. {
  387.     for (CSeqdesc_CI it(bsh, CSeqdesc::e_User);  it;  ++it) {
  388.         const CUser_object& uo = it->GetUser();
  389.         if ( uo.IsSetType()  &&  uo.GetType().IsStr()  &&
  390.              uo.GetType().GetStr() == "GenomeBuild" ) {
  391.             if ( uo.HasField("NcbiAnnotation") ) {
  392.                 const CUser_field& uf = uo.GetField("NcbiAnnotation");
  393.                 if ( uf.CanGetData()  &&  uf.GetData().IsStr()  &&
  394.                      !uf.GetData().GetStr().empty() ) {
  395.                     return uf.GetData().GetStr();
  396.                 }
  397.             } else if ( uo.HasField("Annotation") ) {
  398.                 const CUser_field& uf = uo.GetField("Annotation");
  399.                 if ( uf.CanGetData()  &&  uf.GetData().IsStr()  &&
  400.                      !uf.GetData().GetStr().empty() ) {
  401.                     static const string prefix = "NCBI build ";
  402.                     if ( NStr::StartsWith(uf.GetData().GetStr(), prefix) ) {
  403.                         return uf.GetData().GetStr().substr(prefix.length());
  404.                     }
  405.                 }
  406.             }
  407.         }
  408.     }
  410.     return kEmptyStr;
  411. }
  414. bool s_HasRefTrackStatus(const CBioseq_Handle& bsh) {
  415.     for (CSeqdesc_CI it(bsh, CSeqdesc::e_User);  it;  ++it) {
  416.         CCommentItem::TRefTrackStatus status = 
  417.             CCommentItem::GetRefTrackStatus(it->GetUser());
  418.         if ( status != CCommentItem::eRefTrackStatus_Unknown ) { 
  419.             return true;
  420.         }
  421.     }
  423.     return false;
  424. }
  427. void CFlatGatherer::x_IdComments(CBioseqContext& ctx) const
  428. {
  429.     const CObject_id* local_id = 0;
  431.     string genome_build_number = s_GetGenomeBuildNumber(ctx.GetHandle());
  432.     bool has_ref_track_status = s_HasRefTrackStatus(ctx.GetHandle());
  434.     ITERATE( CBioseq::TId, id_iter, ctx.GetBioseqIds() ) {
  435.         const CSeq_id& id = **id_iter;
  437.         switch ( id.Which() ) {
  438.         case CSeq_id::e_Other:
  439.             {{
  440.                 if ( ctx.IsRSCompleteGenomic() ) {
  441.                     if ( !genome_build_number.empty() ) {
  442.                         x_AddComment(new CGenomeAnnotComment(ctx, genome_build_number));
  443.                     }
  444.                 }
  445.                 if ( ctx.IsRSContig()  ||  ctx.IsRSIntermedWGS() ) {
  446.                     if ( !has_ref_track_status ) {
  447.                         x_AddComment(new CGenomeAnnotComment(ctx, genome_build_number));
  448.                     }
  449.                 }
  450.                 if ( ctx.IsRSPredictedProtein()  ||
  451.                      ctx.IsRSPredictedMRna()     ||
  452.                      ctx.IsRSPredictedNCRna()    ||
  453.                      ctx.IsRSWGSProt() ) {
  454.                     SModelEvidance me;
  455.                     if ( GetModelEvidance(ctx.GetHandle(), me) ) {
  456.                         string str = CCommentItem::GetStringForModelEvidance(me);
  457.                         if ( !str.empty() ) {
  458.                             x_AddComment(new CCommentItem(str, ctx));
  459.                         }
  460.                     }
  461.                 }
  462.             }}
  463.             break;
  464.         case CSeq_id::e_General:
  465.             {{
  466.                 const CDbtag& dbtag = id.GetGeneral();
  467.                 if ( dbtag.CanGetDb()  &&  dbtag.GetDb() == "GSDB"  &&
  468.                      dbtag.CanGetTag()  &&  dbtag.GetTag().IsId() ) {
  469.                     x_AddGSDBComment(dbtag, ctx);
  470.                 }
  471.             }}
  472.             break;
  473.         case CSeq_id::e_Local:
  474.             {{
  475.                 local_id = &(id.GetLocal());
  476.             }}
  477.             break;
  478.         default:
  479.             break;
  480.         }
  481.     }
  483.     if ( local_id != 0 ) {
  484.         if ( ctx.IsTPA()  ||  ctx.IsGED() ) {
  485.             if ( ctx.Config().IsModeGBench()  ||  ctx.Config().IsModeDump() ) {
  486.                 x_AddComment(new CLocalIdComment(*local_id, ctx));
  487.             }
  488.         }
  489.     }
  490. }
  493. void CFlatGatherer::x_RefSeqComments(CBioseqContext& ctx) const
  494. {
  495.     bool did_tpa = false, did_ref_track = false, did_genome = false;
  497.     for (CSeqdesc_CI it(ctx.GetHandle(), CSeqdesc::e_User);  it;  ++it) {
  498.         const CUser_object& uo = it->GetUser();
  500.         // TPA
  501.         {{
  502.             if ( !did_tpa ) {
  503.                 string str = CCommentItem::GetStringForTPA(uo, ctx);
  504.                 if ( !str.empty() ) {
  505.                     x_AddComment(new CCommentItem(str, ctx, &uo));
  506.                     did_tpa = true;
  507.                 }
  508.             }
  509.         }}
  511.         // BankIt
  512.         {{
  513.             if ( !ctx.Config().HideBankItComment() ) {
  514.                 string str = CCommentItem::GetStringForBankIt(uo);
  515.                 if ( !str.empty() ) {
  516.                     x_AddComment(new CCommentItem(str, ctx, &uo));
  517.                 }
  518.             }
  519.         }}
  521.         // RefTrack
  522.         {{
  523.             if ( !did_ref_track ) {
  524.                 string str = CCommentItem::GetStringForRefTrack(uo);
  525.                 if ( !str.empty() ) {
  527.                     x_AddComment(new CCommentItem(str, ctx, &uo));
  528.                     did_ref_track = true;
  529.                 }
  530.             }
  531.         }}
  533.         // Genome
  534.         {{
  535.             if ( !did_genome ) {
  536.                 // !!! Not implememnted in the C version. should it be?
  537.             }
  538.         }}
  539.     }
  540. }
  543. void CFlatGatherer::x_HistoryComments(CBioseqContext& ctx) const
  544. {
  545.     const CBioseq_Handle& seq = ctx.GetHandle();
  546.     if ( !seq.IsSetInst_Hist() ) {
  547.         return;
  548.     }
  550.     const CSeq_hist& hist = seq.GetInst_Hist();
  552.     if ( hist.CanGetReplaced_by() ) {
  553.         const CSeq_hist::TReplaced_by& r = hist.GetReplaced_by();
  554.         if ( r.CanGetDate()  &&  !r.GetIds().empty() ) {
  555.             x_AddComment(new CHistComment(CHistComment::eReplaced_by,
  556.                 hist, ctx));
  557.         }
  558.     }
  560.     if ( hist.IsSetReplaces()  &&  !ctx.Config().IsModeGBench() ) {
  561.         const CSeq_hist::TReplaces& r = hist.GetReplaces();
  562.         if ( r.CanGetDate()  &&  !r.GetIds().empty() ) {
  563.             x_AddComment(new CHistComment(CHistComment::eReplaces,
  564.                 hist, ctx));
  565.         }
  566.     }
  567. }
  570. void CFlatGatherer::x_WGSComment(CBioseqContext& ctx) const
  571. {
  572.     if ( !ctx.IsWGSMaster()  ||  ctx.GetWGSMasterName().empty() ) {
  573.         return;
  574.     }
  576.     if ( ctx.GetTech() == CMolInfo::eTech_wgs ) {
  577.         string str = CCommentItem::GetStringForWGS(ctx);
  578.         if ( !str.empty() ) {
  579.             x_AddComment(new CCommentItem(str, ctx));
  580.         }
  581.     }
  582. }
  585. void CFlatGatherer::x_GBBSourceComment(CBioseqContext& ctx) const
  586. {
  587.     _ASSERT(ctx.ShowGBBSource());
  589.     for (CSeqdesc_CI it(ctx.GetHandle(), CSeqdesc::e_Genbank); it; ++it) {
  590.         const CGB_block& gbb = it->GetGenbank();
  591.         if ( gbb.CanGetSource()  &&  !gbb.GetSource().empty() ) {
  592.             x_AddComment(new CCommentItem(
  593.                 "Original source text: " + gbb.GetSource(),
  594.                 ctx,
  595.                 &(*it)));
  596.         }
  597.     }
  599. }
  602. void CFlatGatherer::x_DescComments(CBioseqContext& ctx) const
  603. {
  604.     for (CSeqdesc_CI it(ctx.GetHandle(), CSeqdesc::e_Comment); it; ++it) {
  605.         x_AddComment(new CCommentItem(*it, ctx));
  606.     }
  607. }
  610. void CFlatGatherer::x_MaplocComments(CBioseqContext& ctx) const
  611. {
  612.     for (CSeqdesc_CI it(ctx.GetHandle(), CSeqdesc::e_Maploc); it; ++it) {
  613.         x_AddComment(new CCommentItem(*it, ctx));
  614.     }
  615. }
  618. void CFlatGatherer::x_RegionComments(CBioseqContext& ctx) const
  619. {
  620.     for (CSeqdesc_CI it(ctx.GetHandle(), CSeqdesc::e_Region); it; ++it) {
  621.         x_AddComment(new CCommentItem(*it, ctx));
  622.     }
  623. }
  626. void CFlatGatherer::x_HTGSComments(CBioseqContext& ctx) const
  627. {
  628.     CSeqdesc_CI desc(ctx.GetHandle(), CSeqdesc::e_Molinfo);
  629.     if ( !desc ) {
  630.         return;
  631.     }
  632.     const CMolInfo& mi = *ctx.GetMolinfo();
  634.     if ( ctx.IsRefSeq()  &&  
  635.          mi.GetCompleteness() != CMolInfo::eCompleteness_unknown ) {
  636.         string str = CCommentItem::GetStringForMolinfo(mi, ctx);
  637.         if ( !str.empty() ) {
  638.             x_AddComment(new CCommentItem(str, ctx, &(*desc)));
  639.         }
  640.     }
  642.     CMolInfo::TTech tech = mi.GetTech();
  643.     if ( tech == CMolInfo::eTech_htgs_0  ||
  644.          tech == CMolInfo::eTech_htgs_1  ||
  645.          tech == CMolInfo::eTech_htgs_2 ) {
  646.         x_AddComment(new CCommentItem(
  647.             CCommentItem::GetStringForHTGS(ctx), ctx, &(*desc)));
  648.     } else {
  649.         const string& tech_str = GetTechString(tech);
  650.         if ( !tech_str.empty() ) {
  651.             x_AddComment(new CCommentItem("Method: " + tech_str, ctx, &(*desc)));
  652.         }
  653.     }
  654. }
  657. void CFlatGatherer::x_FeatComments(CBioseqContext& ctx) const
  658. {
  659.     // !!!
  660. }
  663. /////////////////////////////////////////////////////////////////////////////
  664. //
  665. // SEQUENCE
  667. // We use multiple items to represent the sequence.
  668. void CFlatGatherer::x_GatherSequence(void) const
  669. {
  670.     static const TSeqPos kChunkSize = 2400; // 20 lines
  671.     
  672.     bool first = true;
  673.     TSeqPos size = GetLength(m_Current->GetLocation(), &m_Current->GetScope());
  674.     for ( TSeqPos start = 0; start < size; start += kChunkSize ) {
  675.         TSeqPos end = min(start + kChunkSize, size);
  676.         *m_ItemOS << new CSequenceItem(start, end, first, *m_Current);
  677.         first = false;
  678.     }
  679. }
  682. /////////////////////////////////////////////////////////////////////////////
  683. //
  684. // FEATURES
  687. // source
  689. void CFlatGatherer::x_CollectSourceDescriptors
  690. (const CBioseq_Handle& bh,
  691.  CBioseqContext& ctx,
  692.  TSourceFeatSet& srcs) const
  693. {
  694.     CRef<CSourceFeatureItem> sf;
  695.     CScope* scope = &ctx.GetScope();
  696.     const CSeq_loc& loc = ctx.GetLocation();
  698.     TRange print_range(0, GetLength(loc, scope) - 1);
  700.     for ( CSeqdesc_CI dit(bh, CSeqdesc::e_Source); dit;  ++dit) {
  701.         sf.Reset(new CSourceFeatureItem(dit->GetSource(), print_range, ctx));
  702.         srcs.push_back(sf);
  703.     }
  704.     
  705.     // if segmented collect descriptors from segments
  706.     if ( ctx.IsSegmented() ) {
  707.         CConstRef<CSeqMap> seq_map = CSeqMap::CreateSeqMapForSeq_loc(loc, scope);
  708.               
  709.         // iterate over segments
  710.         CSeqMap_CI smit(seq_map->begin_resolved(scope, 1, CSeqMap::fFindRef));
  711.         for ( ; smit; ++smit ) {
  712.             CBioseq_Handle segh = scope->GetBioseqHandle(smit.GetRefSeqid());
  713.             if ( !segh  ||  !segh.IsSetDescr() ) {
  714.                 continue;
  715.             }
  717.             CRange<TSeqPos> seg_range(smit.GetPosition(), smit.GetEndPosition());
  718.             // collect descriptors only from the segment 
  719.             ITERATE(CBioseq_Handle::TDescr::Tdata, it, segh.GetDescr().Get()) {
  720.                 if ( (*it)->IsSource() ) {
  721.                     sf.Reset(new CSourceFeatureItem((*it)->GetSource(), seg_range, ctx));
  722.                     srcs.push_back(sf);
  723.                 }
  724.             }
  725.         }
  726.     }
  727. }
  730. void CFlatGatherer::x_CollectSourceFeatures
  731. (const CBioseq_Handle& bh,
  732.  const TRange& range,
  733.  CBioseqContext& ctx,
  734.  TSourceFeatSet& srcs) const
  735. {
  736.     SAnnotSelector as;
  737.     as.SetFeatType(CSeqFeatData::e_Biosrc);
  738.     as.SetOverlapIntervals();
  739.     as.SetCombineMethod(SAnnotSelector::eCombine_All);
  740.     as.SetResolveDepth(1);  // in case segmented
  741.     as.SetNoMapping(false);
  743.     for ( CFeat_CI fi(bh, range.GetFrom(), range.GetTo(), as); fi; ++fi ) {
  744.         TSeqPos stop = fi->GetLocation().GetTotalRange().GetTo();
  745.         if ( stop >= range.GetFrom()  &&  stop  <= range.GetTo() ) {
  746.             CRef<CSourceFeatureItem> sf(new CSourceFeatureItem(*fi, ctx));
  747.             srcs.push_back(sf);
  748.         }
  749.     }
  750. }
  753. void CFlatGatherer::x_CollectBioSourcesOnBioseq
  754. (const CBioseq_Handle& bh,
  755.  const TRange& range,
  756.  CBioseqContext& ctx,
  757.  TSourceFeatSet& srcs) const
  758. {
  759.     const CFlatFileConfig& cfg = ctx.Config();
  761.     // collect biosources descriptors on bioseq
  762.     if ( !cfg.IsFormatFTable()  ||  cfg.IsModeDump() ) {
  763.         x_CollectSourceDescriptors(bh, ctx, srcs);
  764.     }
  766.     // collect biosources features on bioseq
  767.     if ( !ctx.DoContigStyle()  ||  cfg.ShowContigSources() ) {
  768.         x_CollectSourceFeatures(bh, range, ctx, srcs);
  769.     }
  770. }
  773. void CFlatGatherer::x_CollectBioSources(TSourceFeatSet& srcs) const
  774. {
  775.     CBioseqContext& ctx = *m_Current;
  776.     CScope* scope = &ctx.GetScope();
  777.     const CFlatFileConfig& cfg = ctx.Config();
  779.     x_CollectBioSourcesOnBioseq(ctx.GetHandle(),
  780.                                 ctx.GetLocation().GetTotalRange(),
  781.                                 ctx,
  782.                                 srcs);
  783.     
  784.     // if protein with no sources, get sources applicable to DNA location of CDS
  785.     if ( srcs.empty()  &&  ctx.IsProt() ) {
  786.         const CSeq_feat* cds = GetCDSForProduct(ctx.GetHandle());
  787.         if ( cds != 0 ) {
  788.             const CSeq_loc& cds_loc = cds->GetLocation();
  789.             x_CollectBioSourcesOnBioseq(
  790.                 scope->GetBioseqHandle(cds_loc),
  791.                 cds_loc.GetTotalRange(),
  792.                 ctx,
  793.                 srcs);
  794.         }
  795.     }
  797.     // if no source found create one (only if not FTable format or Dump mode)
  798.     if ( srcs.empty()  &&  !cfg.IsFormatFTable()  ||  cfg.IsModeDump() ) {
  799.         CRef<CBioSource> bsrc(new CBioSource);
  800.         CRef<CSourceFeatureItem> sf(new CSourceFeatureItem(*bsrc, CRange<TSeqPos>::GetWhole(), ctx));
  801.         srcs.push_back(sf);
  802.     }
  803. }
  807. void CFlatGatherer::x_MergeEqualBioSources(TSourceFeatSet& srcs) const
  808. {
  809.     if ( srcs.size() < 2 ) {
  810.         return;
  811.     }
  812.     // !!! To Do:
  813.     // !!! * sort based on biosource
  814.     // !!! * merge equal biosources (merge locations)
  815. }
  818. void CFlatGatherer::x_SubtractFromFocus(TSourceFeatSet& srcs) const
  819. {
  820.     if ( srcs.size() < 2 ) {
  821.         return;
  822.     }
  823.     // !!! To Do:
  824.     // !!! * implement SeqLocSubtract
  825. }
  828. struct SSortByLoc
  829. {
  830.     bool operator()(const CRef<CSourceFeatureItem>& sfp1,
  831.                     const CRef<CSourceFeatureItem>& sfp2) 
  832.     {
  833.         // descriptor always goes first
  834.         if ( sfp1->WasDesc()  &&  !sfp2->WasDesc() ) {
  835.             return true;
  836.         }
  838.         
  839.         CSeq_loc::TRange range1 = sfp1->GetLoc().GetTotalRange();
  840.         CSeq_loc::TRange range2 = sfp2->GetLoc().GetTotalRange();
  841.         // feature with smallest left extreme is first
  842.         if ( range1.GetFrom() != range2.GetFrom() ) {
  843.             return range1.GetFrom() < range2.GetFrom();
  844.         }
  845.         
  846.         // shortest first (just for flatfile)
  847.         if ( range1.GetToOpen() != range2.GetToOpen() ) {
  848.             return range1.GetToOpen() < range2.GetToOpen();
  849.         }
  850.         
  851.         return false;
  852.     }
  853. };
  856. void CFlatGatherer::x_GatherSourceFeatures(void) const
  857. {
  858.     TSourceFeatSet srcs;
  859.     
  860.     x_CollectBioSources(srcs);
  861.     if ( srcs.empty() ) {
  862.         return;
  863.     }
  864.     x_MergeEqualBioSources(srcs);
  865.     
  866.     // sort by type (descriptor / feature) and location
  867.     sort(srcs.begin(), srcs.end(), SSortByLoc());
  868.     
  869.     // if the descriptor has a focus, subtract out all other source locations.
  870.     if ( srcs.front()->GetSource().IsSetIs_focus() ) {
  871.         x_SubtractFromFocus(srcs);
  873.         // if features completely subtracted descriptor intervals,
  874.         // suppress in release, entrez modes.
  875.         if ( srcs.front()->GetLoc().GetTotalRange().GetLength() == 0  &&
  876.              m_Current->Config().HideEmptySource()  &&  srcs.size() > 1 ) {
  877.             srcs.pop_front();
  878.         }
  879.     }
  880.   
  881.     ITERATE( TSourceFeatSet, it, srcs ) {
  882.         *m_ItemOS << *it;
  883.     }
  884. }
  887. void s_SetSelection(SAnnotSelector& sel, CBioseqContext& ctx)
  888. {
  889.     const CFlatFileConfig& cfg = ctx.Config();
  891.     // set feature types to be collected
  892.     {{
  893.         sel.SetAnnotType(CSeq_annot::C_Data::e_Ftable);
  894.         // source features are collected elsewhere
  895.         sel.ExcludeFeatType(CSeqFeatData::e_Biosrc);
  896.         // pub features are used in the REFERENCES section
  897.         sel.ExcludeFeatSubtype(CSeqFeatData::eSubtype_pub);
  898.         // some feature types are always excluded (deprecated?)
  899.         sel.ExcludeFeatSubtype(CSeqFeatData::eSubtype_non_std_residue);
  900.         sel.ExcludeFeatSubtype(CSeqFeatData::eSubtype_rsite);
  901.         sel.ExcludeFeatSubtype(CSeqFeatData::eSubtype_seq);
  902.         // exclude other types based on user flags
  903.         if ( cfg.HideImpFeats() ) {
  904.             sel.ExcludeFeatType(CSeqFeatData::e_Imp);
  905.         }
  906.         if ( cfg.HideRemoteImpFeats() ) {
  907.             sel.ExcludeFeatSubtype(CSeqFeatData::eSubtype_variation);
  908.             sel.ExcludeFeatSubtype(CSeqFeatData::eSubtype_exon);
  909.             sel.ExcludeFeatSubtype(CSeqFeatData::eSubtype_intron);
  910.             sel.ExcludeFeatSubtype(CSeqFeatData::eSubtype_misc_feature);
  911.         }
  912.         if ( cfg.HideSNPFeatures() ) {
  913.             sel.ExcludeFeatSubtype(CSeqFeatData::eSubtype_variation);
  914.         }
  915.         if ( cfg.HideExonFeatures() ) {
  916.             sel.ExcludeFeatSubtype(CSeqFeatData::eSubtype_exon);
  917.         }
  918.         if ( cfg.HideIntronFeatures() ) {
  919.             sel.ExcludeFeatSubtype(CSeqFeatData::eSubtype_intron);
  920.         }
  921.     }}
  922.     sel.SetOverlapType(SAnnotSelector::eOverlap_Intervals);
  923.     if ( GetStrand(ctx.GetLocation(), &ctx.GetScope()) == eNa_strand_minus ) {
  924.         sel.SetSortOrder(SAnnotSelector::eSortOrder_Reverse);  // sort in reverse biological order
  925.     } else {
  926.         sel.SetSortOrder(SAnnotSelector::eSortOrder_Normal);
  927.     }
  928.     sel.SetLimitTSE(ctx.GetHandle().GetTopLevelEntry());
  929.     sel.SetResolveTSE();
  930. }
  933. static bool s_FeatEndsOnBioseq(const CSeq_feat& feat, const CBioseq_Handle& seq)
  934. {
  935.     CSeq_loc_CI last;
  936.     for ( CSeq_loc_CI it(feat.GetLocation()); it; ++it ) {
  937.         last = it;
  938.     }
  939.     
  940.     return (last  &&  seq.IsSynonym(last.GetSeq_id()));
  941. }
  944. static CSeq_loc_Mapper* s_CreateMapper(CBioseqContext& ctx)
  945. {
  946.     if ( ctx.GetMapper() != 0 ) {
  947.         return ctx.GetMapper();
  948.     }
  950.     // do not create mapper if not segmented or segmented but not doing master style.
  951.     const CFlatFileConfig& cfg = ctx.Config();
  952.     if ( !ctx.IsSegmented()  || !(cfg.IsStyleMaster()  ||  cfg.IsFormatFTable()) ) {
  953.         return 0;
  954.     }
  956.     CSeq_loc_Mapper* mapper = new CSeq_loc_Mapper(ctx.GetHandle());
  957.     if ( mapper != 0 ) {
  958.         mapper->SetMergeAbutting();
  959.         mapper->PreserveDestinationLocs();
  960.         mapper->KeepNonmappingRanges();
  961.     }
  962.     return mapper;
  963. }
  966. static bool s_CopyCDSFromCDNA(CBioseqContext& ctx)
  967. {
  968.     return ctx.IsInGPS()  &&  !ctx.IsInNucProt()  &&  ctx.Config().CopyCDSFromCDNA();
  969. }
  972. static void s_FixLocation(CConstRef<CSeq_loc>& feat_loc, CBioseqContext& ctx)
  973. {
  974.     if ( !feat_loc->IsMix() ) {
  975.         return;
  976.     }
  978.     bool partial5 = feat_loc->IsPartialLeft();
  979.     bool partial3 = feat_loc->IsPartialRight();
  981.     CRef<CSeq_loc> loc(SeqLocMerge(ctx.GetHandle(), feat_loc->GetMix().Get(),
  982.         fFuseAbutting | fMergeIntervals));
  983.     loc->SetPartialLeft(partial5);
  984.     loc->SetPartialRight(partial3);
  986.     feat_loc.Reset(loc);
  987. }
  990. void CFlatGatherer::x_GatherFeaturesOnLocation
  991. (const CSeq_loc& loc,
  992.  SAnnotSelector& sel,
  993.  CBioseqContext& ctx) const
  994. {
  995.     CScope& scope = ctx.GetScope();
  996.     CFlatItemOStream& out = *m_ItemOS;
  998.     CRef<CSeq_loc_Mapper> mapper(s_CreateMapper(ctx));
  1000.     for ( CFeat_CI it(scope, loc, sel); it; ++it ) {
  1001.         const CSeq_feat& feat = it->GetOriginalFeature();
  1002.         
  1003.         // if part show only features ending on that part
  1004.         if ( ctx.IsPart()  &&  
  1005.              !s_FeatEndsOnBioseq(feat, ctx.GetHandle()) ) {
  1006.             continue;
  1007.         }
  1008.         
  1009.         CConstRef<CSeq_loc> feat_loc(&feat.GetLocation());
  1010.         if ( mapper ) {
  1011.             feat_loc.Reset(mapper->Map(*feat_loc));
  1012.             s_FixLocation(feat_loc, ctx);
  1013.         }
  1014.                 
  1015.         out << new CFeatureItem(feat, ctx, feat_loc);
  1017.         // Add more features depending on user preferences
  1018.         switch ( feat.GetData().GetSubtype() ) {
  1019.         case CSeqFeatData::eSubtype_mRNA:
  1020.             {{
  1021.                 // optionally map CDS from cDNA onto genomic
  1022.                 if ( s_CopyCDSFromCDNA(ctx)   &&  feat.IsSetProduct() ) {
  1023.                     x_CopyCDSFromCDNA(feat, ctx);
  1024.                 }
  1025.                 break;
  1026.             }}
  1027.         case CSeqFeatData::eSubtype_cdregion:
  1028.             {{  
  1029.                 if ( !ctx.Config().IsFormatFTable() ) {
  1030.                     x_GetFeatsOnCdsProduct(it->GetOriginalFeature(), ctx, mapper);
  1031.                 }
  1032.                 break;
  1033.             }}
  1034.         default:
  1035.             break;
  1036.         }
  1037.     }
  1038. }
  1041. void CFlatGatherer::x_CopyCDSFromCDNA
  1042. (const CSeq_feat& feat,
  1043.  CBioseqContext& ctx) const
  1044. {
  1045.     CScope& scope = ctx.GetScope();
  1047.     CBioseq_Handle cdna = scope.GetBioseqHandle(feat.GetProduct());
  1048.     if ( !cdna ) {
  1049.         return;
  1050.     }
  1051.     // NB: There is only one CDS on an mRNA
  1052.     CFeat_CI cds(cdna, 0, 0, CSeqFeatData::e_Cdregion);
  1053.     if ( cds ) {
  1054.         // map mRNA location to the genomic
  1055.         CSeq_loc_Mapper mapper(feat,
  1056.                                CSeq_loc_Mapper::eProductToLocation,
  1057.                                &scope);
  1058.         CRef<CSeq_loc> cds_loc = mapper.Map(cds->GetLocation());
  1060.         *m_ItemOS << new CFeatureItem(cds->GetOriginalFeature(), ctx, cds_loc,
  1061.                                       CFeatureItem::eMapped_from_cdna);
  1062.     }
  1063. }
  1066. void CFlatGatherer::x_GatherFeatures(void) const
  1067. {
  1068.     CBioseqContext& ctx = *m_Current;
  1069.     const CFlatFileConfig& cfg = ctx.Config();
  1070.     CScope& scope = ctx.GetScope();
  1071.     CFlatItemOStream& out = *m_ItemOS;
  1073.     SAnnotSelector sel;
  1074.     const SAnnotSelector* selp = ctx.GetAnnotSelector();
  1075.     if ( selp == 0 ) {
  1076.         s_SetSelection(sel, ctx);
  1077.         selp = &sel;
  1078.     }
  1080.     // optionally map gene from genomic onto cDNA
  1081.     if ( ctx.IsInGPS()  &&  cfg.CopyGeneToCDNA()  &&
  1082.          ctx.GetBiomol() == CMolInfo::eBiomol_mRNA ) {
  1083.         const CSeq_feat* mrna = GetmRNAForProduct(ctx.GetHandle());
  1084.         if ( mrna != 0 ) {
  1085.             CConstRef<CSeq_feat> gene = 
  1086.                 GetOverlappingGene(mrna->GetLocation(), scope);
  1087.             if ( gene != 0 ) {
  1088.                 CRef<CSeq_loc> loc(new CSeq_loc);
  1089.                 loc->SetWhole(*ctx.GetPrimaryId());
  1090.                 out << new CFeatureItem(*gene, ctx, loc, 
  1091.                                         CFeatureItem::eMapped_from_genomic);
  1092.             }
  1093.         }
  1094.     }
  1096.     CSeq_loc loc;
  1097.     if ( ctx.GetMasterLocation() != 0 ) {
  1098.         loc.Assign(*ctx.GetMasterLocation());
  1099.     } else {
  1100.         loc.SetWhole().Assign(*ctx.GetHandle().GetSeqId());
  1101.     }
  1103.     // collect features
  1104.     if ( ctx.IsSegmented()  &&  cfg.IsStyleMaster()  &&  cfg.OldFeatsOrder() ) {
  1105.         if ( ctx.GetAnnotSelector() == 0 ) {
  1106.             sel.SetResolveNone();
  1107.         }
  1108.         
  1109.         // first do the master bioeseq
  1110.         x_GatherFeaturesOnLocation(loc, sel, ctx);
  1112.         // map the location on the segments        
  1113.         CSeq_loc_Mapper mapper(1, ctx.GetHandle());
  1114.         CRef<CSeq_loc> seg_loc(mapper.Map(loc));
  1115.         if ( seg_loc ) {
  1116.             // now go over each of the segments
  1117.             for ( CSeq_loc_CI it(*seg_loc); it; ++it ) {
  1118.                 x_GatherFeaturesOnLocation(it.GetSeq_loc(), sel, ctx);
  1119.             }
  1120.         }
  1121.     } else {
  1122.         x_GatherFeaturesOnLocation(loc, sel, ctx);
  1123.     }
  1124.     
  1125.     if ( ctx.IsProt() ) {
  1126.         // Also collect features which this protein is their product.
  1127.         // Currently there are only two possible candidates: Coding regions
  1128.         // and Prot features (rare).
  1129.         
  1130.         // look for the Cdregion feature for this protein
  1131.         const CSeq_feat* cds = GetCDSForProduct(ctx.GetHandle());
  1132.         if ( cds != 0 ) {
  1133.             out << new CFeatureItem(*cds, ctx, &cds->GetProduct(), 
  1134.                     CFeatureItem::eMapped_from_cdna);
  1135.         }
  1137.         // look for Prot features (only for RefSeq records or
  1138.         // GenBank not release_mode).
  1139.         if ( ctx.IsRefSeq()  ||  !cfg.ForGBRelease() ) {
  1140.             SAnnotSelector sel(CSeqFeatData::e_Prot, true);
  1141.             sel.SetLimitTSE(ctx.GetHandle().GetTopLevelEntry());
  1142.             sel.SetResolveMethod(SAnnotSelector::eResolve_TSE);
  1143.             sel.SetOverlapType(SAnnotSelector::eOverlap_Intervals);
  1144.             for ( CFeat_CI it(ctx.GetHandle(), 0, 0, sel); it; ++it ) {  
  1145.                 out << new CFeatureItem(it->GetOriginalFeature(),
  1146.                                         ctx,
  1147.                                         &it->GetProduct(),
  1148.                                         CFeatureItem::eMapped_from_prot);
  1149.             }
  1150.         }
  1151.     }
  1152. }
  1155. static bool s_IsCDD(const CSeq_feat& feat)
  1156. {
  1157.     ITERATE(CSeq_feat::TDbxref, it, feat.GetDbxref()) {
  1158.         if ( (*it)->GetType() == CDbtag::eDbtagType_CDD ) {
  1159.             return true;
  1160.         }
  1161.     }
  1162.     return false;
  1163. }
  1166. void CFlatGatherer::x_GetFeatsOnCdsProduct
  1167. (const CSeq_feat& feat,
  1168.  CBioseqContext& ctx,
  1169.  CRef<CSeq_loc_Mapper>& mapper) const
  1170. {
  1171.     _ASSERT(feat.GetData().IsCdregion());
  1173.     const CFlatFileConfig& cfg = ctx.Config();
  1174.     
  1175.     if ( cfg.HideCDSProdFeatures() ) {
  1176.         return;
  1177.     }
  1178.     
  1179.     if ( !feat.CanGetProduct() ) {
  1180.         return;
  1181.     }
  1183.     CScope& scope = ctx.GetScope();
  1184.     CBioseq_Handle  prot = scope.GetBioseqHandle(feat.GetProduct());
  1185.     if ( !prot ) {
  1186.         return;
  1187.     }
  1188.         
  1189.     CFeat_CI prev;
  1190.     bool first = true;
  1191.     CSeq_loc_Mapper prot_to_nuc(feat, CSeq_loc_Mapper::eProductToLocation, &scope);
  1192.     // explore mat_peptides, sites, etc.
  1193.     for ( CFeat_CI it(prot, 0, 0); it; ++it ) {
  1194.         CSeqFeatData::ESubtype subtype = it->GetData().GetSubtype();
  1195.         if ( !(subtype == CSeqFeatData::eSubtype_region)              &&
  1196.              !(subtype == CSeqFeatData::eSubtype_site)                &&
  1197.              !(subtype == CSeqFeatData::eSubtype_bond)                &&
  1198.              !(subtype == CSeqFeatData::eSubtype_mat_peptide_aa)      &&
  1199.              !(subtype == CSeqFeatData::eSubtype_sig_peptide_aa)      &&
  1200.              !(subtype == CSeqFeatData::eSubtype_transit_peptide_aa)  &&
  1201.              !(subtype == CSeqFeatData::eSubtype_preprotein) ) {
  1202.             continue;
  1203.         }
  1205.         if ( cfg.HideCDDFeats()  &&
  1206.              subtype == CSeqFeatData::eSubtype_region  &&
  1207.              s_IsCDD(it->GetOriginalFeature()) ) {
  1208.             // passing this test prevents mapping of COG CDD region features
  1209.             continue;
  1210.         }
  1212.         // suppress duplicate features (on protein)
  1213.         if ( !first ) {
  1214.             const CSeq_loc& loc_curr = it->GetLocation();
  1215.             const CSeq_loc& loc_prev = prev->GetLocation();
  1216.             const CSeq_feat& feat_curr = it->GetOriginalFeature();
  1217.             const CSeq_feat& feat_prev = prev->GetOriginalFeature();
  1219.             if ( feat_prev.Compare(feat_curr, loc_curr, loc_prev) == 0 ) {
  1220.                 continue;
  1221.             }
  1222.         }
  1224.         // map prot location to nuc location
  1225.         CRef<CSeq_loc> loc(prot_to_nuc.Map(it->GetLocation()));
  1226.         // possibly map again (e.g. from part to master)
  1227.         if ( loc.NotEmpty()  &&  mapper.NotEmpty() ) {
  1228.             loc.Reset(mapper->Map(*loc));
  1229.         }
  1230.         if ( !loc  ||  loc->IsNull() ) {
  1231.             continue;
  1232.         }
  1233.         // make sure feature is within sublocation
  1234.         if ( ctx.GetMasterLocation() != 0 ) {
  1235.             const CSeq_loc& mloc = *ctx.GetMasterLocation();
  1236.             if ( Compare(mloc, *loc, &scope) != eContains ) {
  1237.                 continue;
  1238.             }
  1239.         }
  1240.         
  1241.         *m_ItemOS << new CFeatureItem(it->GetOriginalFeature(), ctx, 
  1242.             loc, CFeatureItem::eMapped_from_prot);
  1244.         prev = it;
  1245.         first = false;
  1246.     }    
  1247. }
  1250. END_SCOPE(objects)
  1251. END_NCBI_SCOPE
  1254. /*
  1255. * ===========================================================================
  1256. *
  1257. * $Log: gather_items.cpp,v $
  1258. * Revision 1000.2  2004/06/01 19:44:32  gouriano
  1259. * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.21
  1260. *
  1261. * Revision 1.21  2004/05/21 21:42:54  gorelenk
  1262. * Added PCH ncbi_pch.hpp
  1263. *
  1264. * Revision 1.20  2004/05/06 17:52:21  shomrat
  1265. * Fixed feature location
  1266. *
  1267. * Revision 1.19  2004/04/27 15:12:16  shomrat
  1268. * Added logic for partial range formatting
  1269. *
  1270. * Revision 1.18  2004/04/22 16:00:25  shomrat
  1271. * Changes in context
  1272. *
  1273. * Revision 1.17  2004/04/13 16:47:15  shomrat
  1274. * Added GBSeq format
  1275. *
  1276. * Revision 1.16  2004/04/07 14:51:24  shomrat
  1277. * Fixed typo
  1278. *
  1279. * Revision 1.15  2004/04/07 14:27:47  shomrat
  1280. * FTable format always on master bioseq
  1281. *
  1282. * Revision 1.14  2004/03/31 17:16:04  shomrat
  1283. * Set current bioseq once in calling function
  1284. *
  1285. * Revision 1.13  2004/03/30 20:31:09  shomrat
  1286. * Bug fix
  1287. *
  1288. * Revision 1.12  2004/03/26 17:24:55  shomrat
  1289. * Changes to comment gathering
  1290. *
  1291. * Revision 1.11  2004/03/25 20:39:47  shomrat
  1292. * Use handles
  1293. *
  1294. * Revision 1.10  2004/03/18 15:39:40  shomrat
  1295. * + Filtering of displayed records
  1296. *
  1297. * Revision 1.9  2004/03/12 16:57:54  shomrat
  1298. * Filter viewable bioseqs; Use new location mapping
  1299. *
  1300. * Revision 1.8  2004/03/10 16:22:44  shomrat
  1301. * Use reference to object
  1302. *
  1303. * Revision 1.7  2004/03/05 18:45:19  shomrat
  1304. * changes to feature gathering
  1305. *
  1306. * Revision 1.6  2004/02/19 18:11:25  shomrat
  1307. * Set feature iterator selector based on user flags
  1308. *
  1309. * Revision 1.5  2004/02/11 22:52:41  shomrat
  1310. * using types in flag file
  1311. *
  1312. * Revision 1.4  2004/02/11 16:52:12  shomrat
  1313. * completed implementation of featture gathering
  1314. *
  1315. * Revision 1.3  2004/01/14 16:15:03  shomrat
  1316. * minor changes to accomodate for GFF format
  1317. *
  1318. * Revision 1.2  2003/12/18 17:43:34  shomrat
  1319. * context.hpp moved
  1320. *
  1321. * Revision 1.1  2003/12/17 20:21:48  shomrat
  1322. * Initial Revision (adapted from flat lib)
  1323. *
  1324. *
  1325. * ===========================================================================
  1326. */