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

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

生物技术

开发平台：

C/C++

reference_item.cpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: reference_item.cpp,v $
  4.  * PRODUCTION Revision 1000.2  2004/06/01 19:45:23  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.18
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. /*  $Id: reference_item.cpp,v 1000.2 2004/06/01 19:45:23 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. *   flat-file generator -- bibliographic references
  40. *
  41. * ===========================================================================
  42. */
  43. #include <ncbi_pch.hpp>
  44. #include <corelib/ncbistd.hpp>
  46. #include <serial/iterator.hpp>
  47. #include <util/static_set.hpp>
  48. #include <objects/biblio/biblio__.hpp>
  49. #include <objects/general/Name_std.hpp>
  50. #include <objects/general/Person_id.hpp>
  51. #include <objects/medline/Medline_entry.hpp>
  52. #include <objects/pub/Pub.hpp>
  53. #include <objects/pub/Pub_equiv.hpp>
  54. #include <objects/pub/Pub_set.hpp>
  55. #include <objects/seqloc/Patent_seq_id.hpp>
  56. #include <objects/seq/Bioseq.hpp>
  57. #include <objects/seq/Seqdesc.hpp>
  58. #include <objects/seqfeat/Seq_feat.hpp>
  59. #include <objects/seqfeat/SeqFeatData.hpp>
  60. #include <objects/biblio/Imprint.hpp>
  61. #include <objmgr/util/sequence.hpp>
  63. #include <algorithm>
  65. #include <objtools/format/text_ostream.hpp>
  66. #include <objtools/format/formatter.hpp>
  67. #include <objtools/format/items/reference_item.hpp>
  68. #include <objtools/format/context.hpp>
  69. #include "utils.hpp"
  72. BEGIN_NCBI_SCOPE
  73. BEGIN_SCOPE(objects)
  74. USING_SCOPE(sequence);
  76. /////////////////////////////////////////////////////////////////////////////
  77. //
  78. // LessEqual - predicate class for sorting references
  80. class LessEqual
  81. {
  82. public:
  83.     LessEqual(bool serial_first, bool is_refseq);
  84.     bool operator()(const CRef<CReferenceItem>& ref1, const CRef<CReferenceItem>& ref2);
  85. private:
  86.     bool m_SerialFirst;
  87.     bool m_IsRefSeq;
  88. };
  90. /////////////////////////////////////////////////////////////////////////////
  93. void CReferenceItem::FormatAffil(const CAffil& affil, string& result)
  94. {
  95.     if (affil.IsStr()) {
  96.         result = affil.GetStr();
  97.     } else {
  98.         result.erase();
  99.         const CAffil::C_Std& std = affil.GetStd();
  100.         if (std.IsSetDiv()) {
  101.             result = std.GetDiv();
  102.         }
  103.         if (std.IsSetAffil()) {
  104.             if (!result.empty()) {
  105.                 result += ", ";
  106.             }
  107.             result += std.GetAffil();
  108.         }
  109.         if (std.IsSetStreet()) {
  110.             if (!result.empty()) {
  111.                 result += ", ";
  112.             }
  113.             result += std.GetStreet();
  114.         }
  115.         if (std.IsSetCity()) {
  116.             if (!result.empty()) {
  117.                 result += ", ";
  118.             }
  119.             result += std.GetCity();
  120.         }
  121.         if (std.IsSetSub()) {
  122.             if (!result.empty()) {
  123.                 result += ", ";
  124.             }
  125.             result += std.GetSub();
  126.         }
  127.         if (std.IsSetPostal_code()) {
  128.             if (!result.empty()) {
  129.                 result += " ";
  130.             }
  131.             result += std.GetPostal_code();
  132.         }
  133.         if (std.IsSetCountry()) {
  134.             if (!result.empty()) {
  135.                 result += ", ";
  136.             }
  137.             result += std.GetCountry();
  138.         }
  139.     }
  140. }
  143. static void s_FixPages(string& pages)
  144. {
  145.     // Restore redundant leading digits of the second number if needed
  146.     SIZE_TYPE digits1 = pages.find_first_not_of("0123456789");
  147.     if ( digits1 != NPOS) {
  148.         SIZE_TYPE hyphen = pages.find('-', digits1);
  149.         if ( hyphen != NPOS ) {
  150.             SIZE_TYPE digits2 = pages.find_first_not_of("0123456789",
  151.                 hyphen + 1);
  152.             digits2 -= hyphen + 1;
  153.             if ( digits2 < digits1 ) {
  154.                 // lengths of the tail portions
  155.                 SIZE_TYPE len1 = hyphen + digits2 - digits1;
  156.                 SIZE_TYPE len2 = pages.size() - hyphen - 1;
  157.                 int x = NStr::strncasecmp(&pages[digits1 - digits2],
  158.                     &pages[hyphen + 1],
  159.                     min(len1, len2));
  160.                 if ( x > 0  ||  (x == 0  &&  len1 >= len2) ) {
  161.                     // complain?
  162.                 } else {
  163.                     pages.insert(hyphen + 1, pages, 0,
  164.                         digits1 - digits2);
  165.                 }
  166.             }
  167.         }
  168.     }
  169. }
  172. CReferenceItem::CReferenceItem(const CSeqdesc& desc, CBioseqContext& ctx) :
  173.     CFlatItem(&ctx), m_PMID(0), m_MUID(0), m_Category(eUnknown), m_Serial(0),
  174.     m_JustUids(false), m_Prepub(CImprint::ePrepub_other)
  175. {
  176.     _ASSERT(desc.IsPub());
  177.     
  178.     x_SetObject(desc.GetPub());
  179.     m_Pubdesc.Reset(&(desc.GetPub()));
  181.     if ( ctx.GetMapper() != 0 ) {
  182.         m_Loc.Reset(ctx.GetMapper()->Map(ctx.GetLocation()));
  183.     } else {
  184.         m_Loc.Reset(&ctx.GetLocation());
  185.     }
  187.     x_GatherInfo(ctx);
  188. }
  191. CReferenceItem::CReferenceItem(const CSeq_feat& feat, CBioseqContext& ctx) :
  192.     CFlatItem(&ctx), m_PMID(0), m_MUID(0), m_Category(eUnknown), m_Serial(0),
  193.     m_JustUids(false), m_Prepub(CImprint::ePrepub_other)
  194. {
  195.     _ASSERT(feat.GetData().IsPub());
  197.     x_SetObject(feat);
  199.     m_Pubdesc.Reset(&(feat.GetData().GetPub()));
  200.     if ( ctx.GetMapper() != 0 ) {
  201.         m_Loc.Reset(ctx.GetMapper()->Map(feat.GetLocation()));
  202.     } else {
  203.         m_Loc.Reset(&(feat.GetLocation()));
  204.     }
  205. }
  208. CReferenceItem::CReferenceItem
  209. (const CPubdesc& pub,
  210.  CBioseqContext& ctx,
  211.  const CSeq_loc* loc) :
  212.     CFlatItem(&ctx), m_Pubdesc(&pub), m_Loc(loc), m_PMID(0), m_MUID(0),
  213.     m_Category(eUnknown), m_Serial(0), m_JustUids(false),
  214.     m_Prepub(CImprint::ePrepub_other)
  215. {
  216.     x_SetObject(pub);
  218.     if ( !m_Loc ) {
  219.         m_Loc.Reset(&ctx.GetLocation());
  220.     }
  221.     if ( ctx.GetMapper() != 0 ) {
  222.         m_Loc.Reset(ctx.GetMapper()->Map(*m_Loc));
  223.     }
  225.     x_GatherInfo(ctx);
  226. }
  229. void CReferenceItem::SetLoc(const CConstRef<CSeq_loc>& loc)
  230. {
  231.     m_Loc = loc;
  232. }
  235. static void s_MergeDuplicates
  236. (CReferenceItem::TReferences& refs,
  237.  CBioseqContext& ctx)
  238. {
  239.     if ( refs.size() < 2 ) {
  240.         return;
  241.     }
  243.     CReferenceItem::TReferences::iterator curr = refs.begin();
  244.     CReferenceItem::TReferences::iterator prev = curr;
  246.     while ( curr != refs.end() ) {
  247.         if ( !*curr ) {
  248.             curr = refs.erase(curr);
  249.             if ( curr == refs.end() ) {
  250.                 break;
  251.             }
  252.         }
  253.         _ASSERT(*curr);
  254.         bool remove = false;
  255.         bool merge  = true;
  257.         const CReferenceItem& curr_ref = **curr;
  258.         if ( curr_ref.JustUids() ) {
  259.             remove = true;
  260.         } else {
  261.             // EMBL patent records do not need author or title - A29528.1
  262.             // do not allow no author reference to appear by itself - U07000.1
  263.             if ( !(ctx.IsEMBL()  &&  ctx.IsPatent())  &&
  264.                  curr_ref.GetAuthors() == 0 ) {
  265.                 remove = true;
  266.                 merge = false;
  267.             }
  268.         }
  269.         if ( (prev != curr)  &&  prev->NotEmpty() ) {
  270.             const CReferenceItem& prev_ref = **prev;
  271.             if ( curr_ref.GetPMID() == prev_ref.GetPMID()  &&  curr_ref.GetPMID() != 0 ) {
  272.                 remove = true;
  273.             }
  274.             if ( remove  &&
  275.                  prev_ref.GetReftype() == CPubdesc::eReftype_seq  &&
  276.                  curr_ref.GetReftype() != CPubdesc::eReftype_seq ) {
  277.                 // real range trumps sites
  278.                 merge = false;
  279.             }
  280.             if ( prev_ref.GetLoc() == 0 ) {
  281.                 merge = false;
  282.             }
  283.         } else {
  284.             merge = false;
  285.         }
  286.         if ( remove ) {
  287.             CConstRef<CSeq_loc> merged_loc;
  288.             if ( merge  &&  (curr_ref.GetLoc() != 0) ) {
  289.                 merged_loc.Reset(SeqLocMerge(ctx.GetHandle(),
  290.                     *(*prev)->GetLoc(), *curr_ref.GetLoc(), fFuseAbutting));
  291.             }
  292.             (*prev)->SetLoc(merged_loc);
  293.             curr = refs.erase(curr);
  294.             if ( curr == refs.end() ) {
  295.                 break;
  296.             }
  297.         } else {
  298.             prev = curr;
  299.             ++curr;
  300.         }
  301.     }
  302. }
  305. void CReferenceItem::Rearrange(TReferences& refs, CBioseqContext& ctx)
  306. {
  307.     {{
  308.         sort(refs.begin(), refs.end(), LessEqual(false, ctx.IsRefSeq()));
  309.     }}
  311.     {{
  312.         // merge duplicate references
  313.         s_MergeDuplicates(refs, ctx);
  314.     }}
  316.     {{
  317.         // !!! add submit reference
  318.     }}
  320.     {{
  321.         // re-sort, take serial number into consideration.
  322.         sort(refs.begin(), refs.end(), LessEqual(true, ctx.IsRefSeq()));
  323.     }}
  324.     
  325.     // assign final serial numbers
  326.     size_t size = refs.size();
  327.     for ( size_t i = 0;  i < size; ++i ) {
  328.         refs[i]->m_Serial = i + 1;
  329.     }
  330. }
  333. void CReferenceItem::Format
  334. (IFormatter& formatter,
  335.  IFlatTextOStream& text_os) const
  336. {
  337.     formatter.FormatReference(*this, text_os);
  338. }
  341. bool CReferenceItem::Matches(const CPub_set& ps) const
  342. {
  343.     if ( !ps.IsPub() ) {
  344.         return false;
  345.     }
  347.     ITERATE (CPub_set::TPub, it, ps.GetPub()) {
  348.         if ( x_Matches(**it) ) {
  349.             return true;
  350.         }
  351.     }
  352.     return false;
  353. }
  356. bool CReferenceItem::x_Matches(const CPub& pub) const
  357. {
  358.     switch ( pub.Which() ) {
  359.     case CPub::e_Muid:
  360.         return pub.GetMuid() == GetMUID();
  361.     case CPub::e_Pmid:
  362.         return pub.GetPmid() == GetPMID();
  363.     case CPub::e_Equiv:
  364.         ITERATE (CPub::TEquiv::Tdata, it, pub.GetEquiv().Get()) {
  365.             if ( x_Matches(**it) ) {
  366.                 return true;
  367.             }
  368.         }
  369.         break;
  370.     default:
  371.         {
  372.             if ( !m_UniqueStr.empty() ) {
  373.                 string unique;
  374.                 pub.GetLabel(&unique, CPub::eContent, true);
  375.                 size_t len = unique.length();
  376.                 if ( len > 0  &&  unique[len - 1] == '>' ) {
  377.                     --len;
  378.                 }
  379.                 len = min(len , m_UniqueStr.length());
  380.                 unique.resize(len);
  381.                 if ( NStr::StartsWith(m_UniqueStr, unique, NStr::eNocase) ) {
  382.                     return true;
  383.                 }
  384.             }
  385.         break;
  386.         }
  387.     }
  388.     return false;
  389. }
  393. void CReferenceItem::x_GatherInfo(CBioseqContext& ctx)
  394. {
  395.     if ( !m_Pubdesc->CanGetPub() ) {
  396.         x_SetSkip();
  397.     }
  399.     if ( ctx.GetSubmitBlock() != 0 ) {
  400.         m_Title = "Direct Submission";
  401.         m_Category = eSubmission;
  402.     }
  403.     CPub_equiv::Tdata::const_iterator last = m_Pubdesc->GetPub().Get().end()--;
  404.     ITERATE (CPub_equiv::Tdata, it, m_Pubdesc->GetPub().Get()) {
  405.         x_Init(**it, ctx);
  407.         // set unique str
  408.         // skip over just serial number
  409.         if ( (*it)->IsGen()  &&  it != last ) {
  410.             const CCit_gen& gen = (*it)->GetGen();
  412.             if ( !gen.CanGetCit()  ||
  413.                  !NStr::StartsWith(gen.GetCit(), "BackBone id_pub", NStr::eNocase) ) {
  414.                 if ( !gen.CanGetCit()  &&
  415.                       !gen.CanGetJournal()  &&
  416.                       !gen.CanGetDate()  &&
  417.                       gen.CanGetSerial_number()  &&
  418.                       gen.GetSerial_number() > 0 ) {
  419.                      continue;
  420.                 }
  421.             }
  422.         }
  423.         if ( m_UniqueStr.empty() ) {
  424.             (*it)->GetLabel(&m_UniqueStr, CPub::eContent, true);
  425.         }
  426.     }
  427.     x_CleanData();
  429.     // gather Genbank specific fields (formats: Genbank, GBSeq, DDBJ)
  430.     if ( ctx.IsGenbankFormat() ) {
  431.         x_GatherRemark(ctx);
  432.     }
  433. }
  434.  
  436. void CReferenceItem::x_Init(const CPub& pub, CBioseqContext& ctx)
  437. {
  438.     switch (pub.Which()) {
  439.     case CPub::e_Gen:
  440.         x_Init(pub.GetGen(), ctx);
  441.         break;
  443.     case CPub::e_Sub:
  444.         x_Init(pub.GetSub(), ctx);
  445.         break;
  447.     case CPub::e_Medline:
  448.         x_Init(pub.GetMedline(), ctx);
  449.         break;
  451.     case CPub::e_Muid:
  452.         if ( m_MUID == 0 ) {
  453.             m_MUID = pub.GetMuid();
  454.             m_Category = ePublished;
  455.         }
  456.         break;
  458.     case CPub::e_Article:
  459.         x_Init(pub.GetArticle(), ctx);
  460.         break;
  462.     case CPub::e_Journal:
  463.         x_Init(pub.GetJournal(), ctx);
  464.         break;
  466.     case CPub::e_Book:
  467.         x_Init(pub.GetBook(), ctx);
  468.         break;
  470.     case CPub::e_Proc:
  471.         x_Init(pub.GetProc().GetBook(), ctx);
  472.         break;
  474.     case CPub::e_Patent:
  475.         x_Init(pub.GetPatent(), ctx);
  476.         break;
  478.     case CPub::e_Man:
  479.         x_Init(pub.GetMan(), ctx);
  480.         break;
  482.     case CPub::e_Equiv:
  483.         ITERATE (CPub_equiv::Tdata, it, pub.GetEquiv().Get()) {
  484.             x_Init(**it, ctx);
  485.         }
  486.         break;
  488.     case CPub::e_Pmid:
  489.         if ( m_PMID == 0 ) {
  490.             m_PMID = pub.GetPmid();
  491.             m_Category = ePublished;
  492.         }
  493.         break;
  495.     default:
  496.         break;
  497.     }
  498. }
  501. void CReferenceItem::x_Init(const CCit_gen& gen, CBioseqContext& ctx)
  502. {
  503.     // serial
  504.     if ( gen.CanGetSerial_number()  &&  m_Serial == 0 ) {
  505.         m_Serial = gen.GetSerial_number();
  506.     }
  508.     // title
  509.     if ( m_Title.empty() ) {
  510.         if ( gen.CanGetTitle()  &&  !gen.GetTitle().empty() ) {
  511.             m_Title = gen.GetTitle();
  512.         } else {
  513.             if ( gen.CanGetCit()  &&  !gen.GetCit().empty() ) {
  514.                 const string& cit = gen.GetCit();
  515.                 SIZE_TYPE pos = NStr::Find(cit, "Title="");
  516.                 if ( pos != NPOS ) {
  517.                     pos += 7;
  518.                     SIZE_TYPE end = cit.find_first_of('"', pos);
  519.                     m_Title = cit.substr(pos, end - pos);
  520.                 }
  521.             }
  522.         }
  523.     }
  524.     
  525.     // Journal
  526.     x_SetJournal(gen, ctx);
  527.     
  528.     // Authors
  529.     if ( gen.CanGetAuthors() ) {
  530.         x_AddAuthors(gen.GetAuthors());
  531.     }
  533.     // MUID
  534.     if ( gen.CanGetMuid()  &&  m_MUID == 0 ) {
  535.         m_MUID = gen.GetMuid();
  536.     }
  537.     
  538.     // PMID
  539.     if ( gen.CanGetPmid()  &&  m_PMID == 0 ) {
  540.         m_PMID = gen.GetPmid();
  541.     }
  543.     // Volume
  544.     if ( gen.CanGetVolume()  &&  m_Volume.empty() ) {
  545.         m_Volume = gen.GetVolume();
  546.     }
  548.     // Issue
  549.     if ( gen.CanGetIssue()  &&  m_Issue.empty() ) {
  550.         m_Issue = gen.GetIssue();
  551.     }
  553.     // Pages
  554.     if ( gen.CanGetPages()  &&  m_Pages.empty() ) {
  555.         m_Pages = gen.GetPages();
  556.         s_FixPages(m_Pages);
  557.     }
  559.     // Date
  560.     if ( gen.CanGetDate()  &&  !m_Date ) {
  561.         m_Date = &gen.GetDate();
  562.     }
  563. }
  566. void CReferenceItem::x_Init(const CCit_sub& sub, CBioseqContext& ctx)
  567. {
  568.     // Title
  569.     m_Title = "Direct Submission";
  571.     // Authors
  572.     x_AddAuthors(sub.GetAuthors());
  573.     if ( sub.GetAuthors().CanGetAffil() ) {
  574.         FormatAffil(sub.GetAuthors().GetAffil(), m_Journal);
  575.     }
  577.     // Date
  578.     if ( sub.CanGetDate() ) {
  579.         m_Date = &sub.GetDate();
  580.     } else {
  581.         // complain?
  582.         if ( sub.CanGetImp() ) {
  583.             m_Date = &sub.GetImp().GetDate();
  584.         }
  585.     }
  587.     m_Category = eSubmission;
  588. }
  591. void CReferenceItem::x_Init(const CMedline_entry& mle, CBioseqContext& ctx)
  592. {
  593.     m_Category = ePublished;
  595.     if ( mle.CanGetUid()  &&  m_MUID == 0 ) {
  596.         m_MUID = mle.GetUid();
  597.     }
  599.     if ( !m_Date ) {
  600.         m_Date = &mle.GetEm();
  601.     }
  603.     if ( mle.CanGetPmid()  &&  m_PMID == 0 ) {
  604.         m_PMID = mle.GetPmid();
  605.     }
  607.     if ( mle.CanGetCit() ) {
  608.         x_Init(mle.GetCit(), ctx);
  609.     }
  610. }
  613. void CReferenceItem::x_Init(const CCit_art& art, CBioseqContext& ctx)
  614. {
  615.     // Title
  616.     if ( art.CanGetTitle()  &&  !art.GetTitle().Get().empty() ) {
  617.         m_Title = art.GetTitle().GetTitle();
  618.     }
  620.     // Authors
  621.     if ( art.CanGetAuthors() ) {
  622.         x_AddAuthors(art.GetAuthors());
  623.     }
  625.     // Journal
  626.     switch ( art.GetFrom().Which() ) {
  627.     case CCit_art::C_From::e_Journal:
  628.         x_Init(art.GetFrom().GetJournal(), ctx);
  629.         break;
  630.     case CCit_art::C_From::e_Book:
  631.         x_Init(art.GetFrom().GetBook(), ctx, true);
  632.         break;
  633.     case CCit_art::C_From::e_Proc:
  634.         x_Init(art.GetFrom().GetProc().GetBook(), ctx, true);
  635.         break;
  636.     default:
  637.         break;
  638.     }
  640.     if ( art.CanGetIds() ) {
  641.         ITERATE (CArticleIdSet::Tdata, it, art.GetIds().Get()) {
  642.             switch ( (*it)->Which() ) {
  643.             case CArticleId::e_Pubmed:
  644.                 if ( m_PMID == 0 ) {
  645.                     m_PMID = (*it)->GetPubmed();
  646.                 }
  647.                 break;
  648.             case CArticleId::e_Medline:
  649.                 if ( m_MUID == 0 ) {
  650.                     m_MUID = (*it)->GetMedline();
  651.                 }
  652.                 break;
  653.             default:
  654.                 break;
  655.             }
  656.         }
  657.     }
  658. }
  661. void CReferenceItem::x_Init(const CCit_jour& jour, CBioseqContext& ctx)
  662. {
  663.     x_SetJournal(jour.GetTitle(), ctx);
  664.     x_AddImprint(jour.GetImp(), ctx);
  665. }
  671. void CReferenceItem::x_Init
  672. (const CCit_book& book,
  673.  CBioseqContext& ctx,
  674.  bool for_art)
  675. {
  676.     if ( !for_art ) {
  677.         if ( book.CanGetImp() ) {
  678.             x_AddImprint(book.GetImp(), ctx);
  679.         }
  680.         if ( book.CanGetTitle()  &&  !book.GetTitle().Get().empty() ) {
  681.             m_Journal = book.GetTitle().GetTitle();
  682.         }
  683.         if ( m_Authors.Empty()  &&  book.CanGetAuthors() ) {
  684.             x_AddAuthors(book.GetAuthors());
  685.         }
  686.     }  else if ( book.CanGetTitle()  &&  book.CanGetImp() ) {
  687.         m_Book.Reset(&book);
  688.         x_AddImprint(book.GetImp(), ctx);
  689.     }
  690. }
  693. void CReferenceItem::x_Init(const CCit_pat& pat, CBioseqContext& ctx)
  694. {
  695.     bool embl = ctx.Config().IsFormatEMBL();
  696.     m_Category = ePublished;
  698.     m_Title = pat.GetTitle();
  699.     x_AddAuthors(pat.GetAuthors());
  701.     m_Journal = (embl ? "Patent number " : "Patent: ") + pat.GetCountry() + ' ';
  702.     if ( pat.CanGetNumber()  &&  !pat.GetNumber().empty() ) {
  703.         m_Journal += pat.GetNumber();
  704.     } else if ( pat.CanGetApp_number()  &&  !pat.GetApp_number().empty() ) {
  705.         m_Journal += pat.GetApp_number();
  706.     }
  707.     if ( pat.CanGetDoc_type()  &&  !pat.GetDoc_type().empty() ) {
  708.         m_Journal += '-';
  709.         m_Journal += pat.GetDoc_type();
  710.     }
  712.     CPatent_seq_id::TSeqid seqid = 0;
  713.     ITERATE (CBioseq::TId, it, ctx.GetBioseqIds()) {
  714.         if ((*it)->IsPatent()) {
  715.             seqid = (*it)->GetPatent().GetSeqid();
  716.         }
  717.     }
  718.     if ( seqid > 0 ) {
  719.         m_Journal += embl ? '/' : ' ';
  720.         m_Journal += NStr::IntToString(seqid);
  721.         if ( embl ) {
  722.             m_Journal += ", ";
  723.         }
  724.     } else {
  725.         m_Journal += ' ';
  726.     }
  727.     if ( pat.CanGetDate_issue() ) {
  728.         m_Journal += ' ';
  729.         DateToString(pat.GetDate_issue(), m_Journal);
  730.     } else if ( pat.CanGetApp_date() ) {
  731.         m_Journal += ' ';
  732.         DateToString(pat.GetApp_date(), m_Journal);
  733.     }
  734.     m_Journal += (embl ? '.' : ';');
  735. }
  738. void CReferenceItem::x_Init(const CCit_let& man, CBioseqContext& ctx)
  739. {
  740.     x_Init(man.GetCit(), ctx);
  742.     if (man.CanGetType()  &&  man.GetType() == CCit_let::eType_thesis) {
  743.         const CImprint& imp = man.GetCit().GetImp();
  744.         if ( !m_Journal.empty() ) {
  745.             m_Title = m_Journal;
  746.             m_Journal.erase();
  747.         }
  748.         m_Journal = "Thesis (";
  749.         imp.GetDate().GetDate(&m_Journal, "%Y");
  750.         m_Journal += ')';
  751.         if (imp.CanGetPrepub()
  752.             &&  imp.GetPrepub() == CImprint::ePrepub_in_press) {
  753.             m_Journal += ", In press";
  754.         }
  755.         if (imp.CanGetPub()) {
  756.             string affil;
  757.             FormatAffil(imp.GetPub(), affil);
  758.             replace(affil.begin(), affil.end(), '"', ''');
  759.             m_Journal += ' ' + affil;
  760.         }
  761.         m_Date.Reset();
  762.     }
  763. }
  766. void CReferenceItem::x_AddAuthors(const CAuth_list& auth_list)
  767. {
  768.     m_Authors.Reset(&auth_list);
  770.     if ( !auth_list.CanGetNames() ) return;
  771.     
  772.     // also populate the consortium (if available)
  773.     if ( !m_Consortium.empty() ) return;
  775.     const CAuth_list::TNames& names = auth_list.GetNames();
  776.     
  777.     if ( names.IsStd() ) {
  778.         ITERATE (CAuth_list::TNames::TStd, it, names.GetStd()) {
  779.             const CAuthor& auth = **it;
  780.             if ( auth.CanGetName()  &&  
  781.                  auth.GetName().IsConsortium() ) {
  782.                 m_Consortium = auth.GetName().GetConsortium();
  783.                 break;
  784.             }
  785.         }
  786.     }
  787. }
  790. void CReferenceItem::x_SetJournal(const CTitle& title, CBioseqContext& ctx)
  791. {
  792.     // Only GenBank/EMBL/DDBJ require ISO JTA in ENTREZ/RELEASE modes.
  793.     bool require_iso_jta = ctx.Config().CitArtIsoJta();
  794.     if ( !ctx.IsGED()  &&  !ctx.IsTPA() ) {
  795.         require_iso_jta = false;
  796.     }
  797.     // always use iso_jta title if present
  798.     const CTitle::C_E* ttl = 0;
  799.     ITERATE (CTitle::Tdata, it, title.Get()) {
  800.         if ( (*it)->IsIso_jta() ) {
  801.             ttl = *it;
  802.             break;
  803.         }
  804.     }
  806.     bool electronic_journal = false;
  807.     if ( ttl == 0 ) {
  808.         ttl = title.Get().front();
  809.         if ( ttl != 0  &&  ttl->IsName() ) {
  810.             if ( NStr::StartsWith(ttl->GetName(), "(er)", NStr::eNocase) ) {
  811.                 electronic_journal = true;
  812.             }
  813.         }
  814.         if ( require_iso_jta  &&  !electronic_journal ) {
  815.             return;
  816.         }
  818.         m_Journal = title.GetTitle();
  819.     } else {
  820.         m_Journal = ttl->GetIso_jta();
  821.     }
  822. }
  825. void CReferenceItem::x_SetJournal(const CCit_gen& gen, CBioseqContext& ctx)
  826. {
  827.     if ( !gen.CanGetCit()  &&  !gen.CanGetJournal()  &&  !gen.CanGetDate()  &&
  828.          gen.CanGetSerial_number()  &&  gen.GetSerial_number() != 0 ) {
  829.         return;
  830.     }
  832.     if ( !gen.CanGetJournal()  &&
  833.           gen.CanGetCit()  &&  
  834.           NStr::StartsWith(gen.GetCit(), "unpublished", NStr::eNocase) ) {
  835.         const string& cit = gen.GetCit();
  837.         if ( ctx.Config().NoAffilOnUnpub() ) {
  838.             m_Category = eUnpublished;
  839.             m_Journal = "Unpublished";
  840.             return;
  841.         }
  843.         if ( gen.CanGetAuthors()  &&  gen.GetAuthors().CanGetAffil() ) {
  844.             string affil;
  845.             (gen.GetAuthors().GetAffil(), affil);
  846.             if ( !affil.empty() ) {
  847.                 m_Category = eUnpublished;
  848.                 m_Journal = "Unpublished " + affil;
  849.                 return;
  850.             }
  851.         }
  853.         m_Journal = cit;
  854.         return;
  855.     }
  856.     
  857.     string result, in_press;
  858.     if ( gen.CanGetJournal() ) {
  859.         x_SetJournal(gen.GetJournal(), ctx);
  860.         result = m_Journal;
  861.     }
  863.     if ( gen.CanGetCit() ) {
  864.         const string& cit = gen.GetCit();
  866.         SIZE_TYPE pos = NStr::FindNoCase(cit, "Journal="");
  867.         if ( pos != NPOS ) {
  868.             result = cit.substr(pos + 9);
  869.         } else if ( NStr::StartsWith(cit, "submitted", NStr::eNocase)  ||
  870.                     NStr::StartsWith(cit, "unpublished", NStr::eNocase) ) {
  871.             if ( !ctx.Config().DropBadCitGens()  ||  !result.empty() ) {
  872.                 in_press = cit;
  873.             } else {
  874.                 in_press = "Unpublished";
  875.             }
  876.         } else if ( NStr::StartsWith(cit, "Online Publication", NStr::eNocase)  ||
  877.                     NStr::StartsWith(cit, "Published Only in DataBase", NStr::eNocase) ) {
  878.             in_press = cit;
  879.         } else if ( !ctx.Config().DropBadCitGens()  &&  result.empty() ) {
  880.             result = cit;
  881.         }
  882.     }
  884.     if ( !result.empty() ) {
  885.         SIZE_TYPE pos = result.find_first_of("="");
  886.         if ( pos != NPOS ) {
  887.             result.erase(pos);
  888.         }
  889.     }
  890.     
  891.     m_Journal = result;
  892.     if ( !in_press.empty() ) {
  893.         m_Journal += ' ';
  894.         m_Journal += in_press;
  895.     }
  896. }
  899. void CReferenceItem::x_AddImprint(const CImprint& imp, CBioseqContext& ctx)
  900. {
  901.     if ( !m_Date ) {
  902.         m_Date.Reset(&imp.GetDate());
  903.     }
  904.     if ( imp.IsSetVolume()  &&  !imp.GetVolume().empty()  ) {
  905.         m_Volume = imp.GetVolume();
  906.         if ( imp.IsSetPart_sup()  &&  !imp.GetPart_sup().empty() ) {
  907.             m_Volume += " (" + imp.GetPart_sup() + ")";
  908.         }
  909.     }
  910.     
  911.     if ( imp.IsSetIssue()  &&  !imp.GetIssue().empty() ) {
  912.         m_Issue = imp.GetIssue();
  913.         if ( imp.IsSetPart_supi()  &&  !imp.GetPart_supi().empty() ) {
  914.             m_Issue += " (" + imp.GetPart_supi() + ")";
  915.         }
  916.     }
  917.     if ( imp.IsSetPages()  &&  !imp.GetPages().empty() ) {
  918.         m_Pages = imp.GetPages();
  919.         s_FixPages(m_Pages);
  920.     }
  921.     if ( imp.IsSetPrepub() ) {
  922.         m_Prepub = imp.GetPrepub();
  923.         m_Category = 
  924.             m_Prepub != CImprint::ePrepub_in_press ? eUnpublished : ePublished;
  925.     } else {
  926.         m_Category = ePublished;
  927.     }
  928. }
  932. void CReferenceItem::GetAuthNames
  933. (list<string>& authors,
  934.  const CAuth_list* alp)
  935. {   
  936.     authors.clear();
  938.     if ( alp == 0 ) {
  939.         return;
  940.     }
  942.     const CAuth_list::TNames& names = alp->GetNames();
  943.     switch ( names.Which() ) {
  944.     case CAuth_list::TNames::e_Std:
  945.         ITERATE (CAuth_list::TNames::TStd, it, names.GetStd()) {
  946.             if ( !(*it)->CanGetName() ) {
  947.                 continue;
  948.             }
  949.             const CPerson_id& pid = (*it)->GetName();
  950.             string name;
  951.             pid.GetLabel(&name, CPerson_id::eGenbank);
  952.             authors.push_back(name);
  953.         }
  954.         break;
  955.         
  956.     case CAuth_list::TNames::e_Ml:
  957.         authors.insert(authors.end(),
  958.             names.GetMl().begin(), names.GetMl().end());
  959.         break;
  960.         
  961.     case CAuth_list::TNames::e_Str:
  962.         authors.insert(authors.end(),
  963.             names.GetStr().begin(), names.GetStr().end());
  964.         break;
  965.         
  966.     default:
  967.         break;
  968.     }
  969. }
  972. string CReferenceItem::GetAuthString(const CAuth_list* alp)
  973. {
  974.     list<string> authors;
  976.     if ( alp == 0 ) {
  977.         authors.push_back(".");
  978.     } else {
  979.         GetAuthNames(authors, alp);
  980.     }
  982.     CNcbiOstrstream auth_line;
  983.     list<string>::const_iterator last = --(authors.end());
  985.     string separator = kEmptyStr;
  986.     bool first = true;
  987.     ITERATE(list<string>, it, authors) {
  988.         if ( it == last ) {
  989.             separator = " and ";
  990.         }
  991.         auth_line << (first ? kEmptyStr : separator) << *it;
  992.         separator = ", ";
  993.         first = false;
  994.     }
  996.     return CNcbiOstrstreamToString(auth_line);
  997. }
  1000. void CReferenceItem::x_CleanData(void)
  1001. {
  1002.     // !!!
  1003.     // remove spaces from title etc.
  1004. }
  1007. /////////////////////////////////////////////////////////////////////////////
  1008. //
  1009. // Genbank Format Specific
  1011. // these must be in "ASCIIbetical" order; beware of the fact that
  1012. // closing quotes sort after spaces.
  1013. static const string sc_RemarkText[] = {
  1014.   "full automatic",
  1015.   "full staff_entry",
  1016.   "full staff_review",
  1017.   "simple automatic",
  1018.   "simple staff_entry",
  1019.   "simple staff_review",
  1020.   "unannotated automatic",
  1021.   "unannotated staff_entry",
  1022.   "unannotated staff_review"
  1023. };
  1024. static const CStaticArraySet<string> sc_Remarks(sc_RemarkText, sizeof(sc_RemarkText));
  1027. void CReferenceItem::x_GatherRemark(CBioseqContext& ctx)
  1028. {
  1029.     list<string> l;
  1031.     // comment
  1032.     if ( m_Pubdesc->IsSetComment()  &&  !m_Pubdesc->GetComment().empty() ) {
  1033.         const string& comment = m_Pubdesc->GetComment();
  1034.         
  1035.         if ( sc_Remarks.find(comment) == sc_Remarks.end() ) {
  1036.             l.push_back(comment);
  1037.         }
  1038.     }
  1040.     // for GBSeq format collect remarks only from comments.
  1041.     if ( ctx.Config().IsFormatGBSeq() ) {
  1042.         if ( !l.empty() ) {
  1043.             m_Remark = l.front();
  1044.         }
  1045.         return;
  1046.     }
  1048.     // GIBBSQ
  1049.     CSeq_id::TGibbsq gibbsq = 0;
  1050.     ITERATE (CBioseq::TId, it, ctx.GetBioseqIds()) {
  1051.         if ( (*it)->IsGibbsq() ) {
  1052.             gibbsq = (*it)->GetGibbsq();
  1053.         }
  1054.     }
  1055.     if ( gibbsq > 0 ) {
  1056.         static const string str1 = 
  1057.             "GenBank staff at the National Library of Medicine created this entry [NCBI gibbsq ";
  1058.         static const string str2 = "] from the original journal article.";
  1059.         l.push_back(str1 + NStr::IntToString(gibbsq) + str2);
  1061.         // Figure
  1062.         if ( m_Pubdesc->IsSetFig()  &&  !m_Pubdesc->GetFig().empty()) {
  1063.             l.push_back("This sequence comes from " + m_Pubdesc->GetFig());
  1064.         }
  1066.         // Poly_a
  1067.         if ( m_Pubdesc->IsSetPoly_a()  &&  m_Pubdesc->GetPoly_a() ) {
  1068.         l.push_back("Polyadenylate residues occurring in the figure were 
  1069.             omitted from the sequence.");
  1070.         }
  1072.         // Maploc
  1073.         if ( m_Pubdesc->IsSetMaploc()  &&  !m_Pubdesc->GetMaploc().empty()) {
  1074.             l.push_back("Map location: " + m_Pubdesc->GetMaploc());
  1075.         }
  1076.     }
  1077.     
  1078.     if ( m_Pubdesc->CanGetPub() ) {
  1079.         ITERATE (CPubdesc::TPub::Tdata, it, m_Pubdesc->GetPub().Get()) {
  1080.             if ( (*it)->IsArticle() ) {
  1081.                 if ( (*it)->GetArticle().GetFrom().IsJournal() ) {
  1082.                     const CCit_jour& jour = 
  1083.                         (*it)->GetArticle().GetFrom().GetJournal();
  1084.                     if ( jour.IsSetImp() ) {
  1085.                         const CCit_jour::TImp& imp = jour.GetImp();
  1086.                         if ( imp.IsSetRetract() ) {
  1087.                             const CCitRetract& ret = imp.GetRetract();
  1088.                             if ( ret.IsSetType()  &&
  1089.                                 ret.GetType() == CCitRetract::eType_in_error  &&
  1090.                                 ret.IsSetExp()  &&
  1091.                                 !ret.GetExp().empty() ) {
  1092.                                 l.push_back("Erratum:[" + ret.GetExp() + "]");
  1093.                             }
  1094.                         }
  1095.                     }
  1096.                 }
  1097.             } else if ( (*it)->IsSub() ) {
  1098.                 const CCit_sub& sub = (*it)->GetSub();
  1099.                 if ( sub.IsSetDescr()  &&  !sub.GetDescr().empty() ) {
  1100.                     l.push_back(sub.GetDescr());
  1101.                 }
  1102.             }
  1103.         }
  1104.     }
  1106.     m_Remark = NStr::Join(l, "n");
  1107. }
  1110. /////////////////////////////////////////////////////////////////////////////
  1111. //
  1112. // Reference Sorting
  1115. static size_t s_CountFields(const CDate& date)
  1116. {
  1117.     _ASSERT(date.IsStd());
  1119.     const CDate::TStd& std = date.GetStd();
  1120.     size_t count = 0;
  1122.     if ( std.IsSetYear() ) {
  1123.         ++count;
  1124.     }
  1125.     if ( std.IsSetMonth() ) {
  1126.         ++count;
  1127.     }
  1128.     if ( std.IsSetDay() ) {
  1129.         ++count;
  1130.     }
  1131.     if ( std.IsSetHour() ) {
  1132.         ++count;
  1133.     }
  1134.     if ( std.IsSetMinute() ) {
  1135.         ++count;
  1136.     }
  1137.     if ( std.IsSetSecond() ) {
  1138.         ++count;
  1139.     }
  1141.     return count;
  1142. }
  1145. LessEqual::LessEqual(bool serial_first, bool is_refseq) :
  1146.     m_SerialFirst(serial_first), m_IsRefSeq(is_refseq)
  1147. {}
  1150. bool LessEqual::operator()
  1151. (const CRef<CReferenceItem>& ref1,
  1152.  const CRef<CReferenceItem>& ref2)
  1153. {
  1154.     if ( m_SerialFirst  &&  ref1->GetSerial() != ref2->GetSerial() ) {
  1155.         return ref1->GetSerial() < ref2->GetSerial();
  1156.     }
  1158.     // sort by category (published / unpublished / submission)
  1159.     if ( ref1->GetCategory() != ref2->GetCategory() ) {
  1160.         return ref1->GetCategory() < ref2->GetCategory();
  1161.     }
  1163.     // sort by date:
  1164.     // - publications with date come before those without one.
  1165.     // - more specific dates come before less specific ones.
  1166.     // - older publication comes first (except RefSeq).
  1167.     const CDate* d1 = ref1->GetDate();
  1168.     const CDate* d2 = ref2->GetDate();
  1169.     if ( (d1 != 0)  &&  (d2 == 0) ) {
  1170.         return true;
  1171.     } else if ( (d1 == 0)  &&  (d2 != 0) ) {
  1172.         return false;
  1173.     }
  1174.     if ( (d1 != 0)  &&  (d2 != 0) ) {
  1175.         CDate::ECompare status = ref1->GetDate()->Compare(*ref2->GetDate());
  1176.         if ( status == CDate::eCompare_unknown  &&
  1177.              d1->IsStd()  &&  d2->IsStd() ) {
  1178.             // one object is more specific than the other.
  1179.             size_t s1 = s_CountFields(*d1);
  1180.             size_t s2 = s_CountFields(*d2);
  1181.             return m_IsRefSeq ? s1 > s2 : s1 < s2;
  1182.         } else if ( status != CDate::eCompare_same ) {
  1183.             return m_IsRefSeq ? (status == CDate::eCompare_after) :
  1184.                                 (status == CDate::eCompare_before);
  1185.         }
  1186.     }
  1187.     // dates are the same, or both missing.
  1188.     
  1189.     // distinguish by uids (swap order for RefSeq)
  1190.     if ( ref1->GetPMID() != 0  &&  ref2->GetPMID() != 0  &&
  1191.          !(ref1->GetPMID() == ref2->GetPMID()) ) {
  1192.         return m_IsRefSeq ? (ref1->GetPMID() > ref2->GetPMID()) :
  1193.             (ref1->GetPMID() < ref2->GetPMID());
  1194.     }
  1195.     if ( ref1->GetMUID() != 0  &&  ref2->GetMUID() != 0  &&
  1196.          !(ref1->GetMUID() == ref2->GetMUID()) ) {
  1197.         return m_IsRefSeq ? (ref1->GetMUID() > ref2->GetMUID()) :
  1198.             (ref1->GetMUID() < ref2->GetMUID());
  1199.     }
  1201.     // just uids goes last
  1202.     if ( (ref1->GetPMID() != 0  &&  ref2->GetPMID() != 0)  ||
  1203.          (ref1->GetMUID() != 0  &&  ref2->GetMUID() != 0) ) {
  1204.         if ( ref1->JustUids()  &&  !ref2->JustUids() ) {
  1205.             return true;
  1206.         } else if ( !ref1->JustUids()  &&  ref2->JustUids() ) {
  1207.             return false;
  1208.         }
  1209.     }
  1211.     if ( ref1->GetReftype() != CPubdesc::eReftype_seq ) {
  1212.         return true;
  1213.     } else if ( ref2->GetReftype() != CPubdesc::eReftype_seq ) {
  1214.         return false;
  1215.     }
  1216.     
  1217.     // next use AUTHOR string
  1218.     string auth1 = CReferenceItem::GetAuthString(ref1->GetAuthors());
  1219.     string auth2 = CReferenceItem::GetAuthString(ref2->GetAuthors());
  1220.     int comp = NStr::CompareNocase(auth1, auth2);
  1221.     if ( comp != 0 ) {
  1222.         return comp < 0;
  1223.     }
  1225.     // !!! unique string ???
  1227.     if ( !m_SerialFirst ) {
  1228.         return ref1->GetSerial() < ref2->GetSerial();
  1229.     }
  1231.     return true;
  1232. }
  1235. END_SCOPE(objects)
  1236. END_NCBI_SCOPE
  1238. /*
  1239. * ===========================================================================
  1240. *
  1241. * $Log: reference_item.cpp,v $
  1242. * Revision 1000.2  2004/06/01 19:45:23  gouriano
  1243. * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.18
  1244. *
  1245. * Revision 1.18  2004/05/21 21:42:54  gorelenk
  1246. * Added PCH ncbi_pch.hpp
  1247. *
  1248. * Revision 1.17  2004/05/20 17:11:45  ucko
  1249. * Reset strings with erase() rather than clear(), which isn't 100% portable.
  1250. *
  1251. * Revision 1.16  2004/05/20 13:47:54  shomrat
  1252. * Fixed Pub-set match
  1253. *
  1254. * Revision 1.15  2004/05/15 13:22:45  ucko
  1255. * Sort sc_RemarkText, and note the requirement.
  1256. *
  1257. * Revision 1.14  2004/05/14 13:15:25  shomrat
  1258. * Fixed use of CStaticArraySet
  1259. *
  1260. * Revision 1.13  2004/05/06 17:59:30  shomrat
  1261. * Handle duplicate references
  1262. *
  1263. * Revision 1.12  2004/04/27 15:14:04  shomrat
  1264. * Added logic for partial range formatting
  1265. *
  1266. * Revision 1.11  2004/04/22 15:56:30  shomrat
  1267. * Changes in context
  1268. *
  1269. * Revision 1.10  2004/04/13 16:49:36  shomrat
  1270. * GBSeq format changes
  1271. *
  1272. * Revision 1.9  2004/03/26 17:26:34  shomrat
  1273. * Set category to unpublished where needed
  1274. *
  1275. * Revision 1.8  2004/03/18 15:44:21  shomrat
  1276. * Fixes to REFERENCE formatting
  1277. *
  1278. * Revision 1.7  2004/03/10 16:21:17  shomrat
  1279. * Fixed reference sorting, Added REMARK gathering
  1280. *
  1281. * Revision 1.6  2004/03/05 18:42:59  shomrat
  1282. * Set category to Published if title exist
  1283. *
  1284. * Revision 1.5  2004/02/24 17:24:27  vasilche
  1285. * Added missing include <Pub.hpp>
  1286. *
  1287. * Revision 1.4  2004/02/11 22:55:44  shomrat
  1288. * use IsModeRelease method
  1289. *
  1290. * Revision 1.3  2004/02/11 17:00:46  shomrat
  1291. * minor changes to Matches method
  1292. *
  1293. * Revision 1.2  2003/12/18 17:43:36  shomrat
  1294. * context.hpp moved
  1295. *
  1296. * Revision 1.1  2003/12/17 20:24:12  shomrat
  1297. * Initial Revision (adapted from flat lib)
  1298. *
  1299. *
  1300. * ===========================================================================
  1301. */