reference_item.cpp

来自「ncbi源码」· C++ 代码 · 共 1,302 行 · 第 1/3 页

void CReferenceItem::x_Init(const CPub& pub, CBioseqContext& ctx)
{
    switch (pub.Which()) {
    case CPub::e_Gen:
        x_Init(pub.GetGen(), ctx);
        break;

    case CPub::e_Sub:
        x_Init(pub.GetSub(), ctx);
        break;

    case CPub::e_Medline:
        x_Init(pub.GetMedline(), ctx);
        break;

    case CPub::e_Muid:
        if ( m_MUID == 0 ) {
            m_MUID = pub.GetMuid();
            m_Category = ePublished;
        }
        break;

    case CPub::e_Article:
        x_Init(pub.GetArticle(), ctx);
        break;

    case CPub::e_Journal:
        x_Init(pub.GetJournal(), ctx);
        break;

    case CPub::e_Book:
        x_Init(pub.GetBook(), ctx);
        break;

    case CPub::e_Proc:
        x_Init(pub.GetProc().GetBook(), ctx);
        break;

    case CPub::e_Patent:
        x_Init(pub.GetPatent(), ctx);
        break;

    case CPub::e_Man:
        x_Init(pub.GetMan(), ctx);
        break;

    case CPub::e_Equiv:
        ITERATE (CPub_equiv::Tdata, it, pub.GetEquiv().Get()) {
            x_Init(**it, ctx);
        }
        break;

    case CPub::e_Pmid:
        if ( m_PMID == 0 ) {
            m_PMID = pub.GetPmid();
            m_Category = ePublished;
        }
        break;

    default:
        break;
    }
}


void CReferenceItem::x_Init(const CCit_gen& gen, CBioseqContext& ctx)
{
    // serial
    if ( gen.CanGetSerial_number()  &&  m_Serial == 0 ) {
        m_Serial = gen.GetSerial_number();
    }

    // title
    if ( m_Title.empty() ) {
        if ( gen.CanGetTitle()  &&  !gen.GetTitle().empty() ) {
            m_Title = gen.GetTitle();
        } else {
            if ( gen.CanGetCit()  &&  !gen.GetCit().empty() ) {
                const string& cit = gen.GetCit();
                SIZE_TYPE pos = NStr::Find(cit, "Title=\"");
                if ( pos != NPOS ) {
                    pos += 7;
                    SIZE_TYPE end = cit.find_first_of('"', pos);
                    m_Title = cit.substr(pos, end - pos);
                }
            }
        }
    }
    
    // Journal
    x_SetJournal(gen, ctx);
    
    // Authors
    if ( gen.CanGetAuthors() ) {
        x_AddAuthors(gen.GetAuthors());
    }

    // MUID
    if ( gen.CanGetMuid()  &&  m_MUID == 0 ) {
        m_MUID = gen.GetMuid();
    }
    
    // PMID
    if ( gen.CanGetPmid()  &&  m_PMID == 0 ) {
        m_PMID = gen.GetPmid();
    }

    // Volume
    if ( gen.CanGetVolume()  &&  m_Volume.empty() ) {
        m_Volume = gen.GetVolume();
    }

    // Issue
    if ( gen.CanGetIssue()  &&  m_Issue.empty() ) {
        m_Issue = gen.GetIssue();
    }

    // Pages
    if ( gen.CanGetPages()  &&  m_Pages.empty() ) {
        m_Pages = gen.GetPages();
        s_FixPages(m_Pages);
    }

    // Date
    if ( gen.CanGetDate()  &&  !m_Date ) {
        m_Date = &gen.GetDate();
    }
}


void CReferenceItem::x_Init(const CCit_sub& sub, CBioseqContext& ctx)
{
    // Title
    m_Title = "Direct Submission";

    // Authors
    x_AddAuthors(sub.GetAuthors());
    if ( sub.GetAuthors().CanGetAffil() ) {
        FormatAffil(sub.GetAuthors().GetAffil(), m_Journal);
    }

    // Date
    if ( sub.CanGetDate() ) {
        m_Date = &sub.GetDate();
    } else {
        // complain?
        if ( sub.CanGetImp() ) {
            m_Date = &sub.GetImp().GetDate();
        }
    }

    m_Category = eSubmission;
}


void CReferenceItem::x_Init(const CMedline_entry& mle, CBioseqContext& ctx)
{
    m_Category = ePublished;

    if ( mle.CanGetUid()  &&  m_MUID == 0 ) {
        m_MUID = mle.GetUid();
    }

    if ( !m_Date ) {
        m_Date = &mle.GetEm();
    }

    if ( mle.CanGetPmid()  &&  m_PMID == 0 ) {
        m_PMID = mle.GetPmid();
    }

    if ( mle.CanGetCit() ) {
        x_Init(mle.GetCit(), ctx);
    }
}


void CReferenceItem::x_Init(const CCit_art& art, CBioseqContext& ctx)
{
    // Title
    if ( art.CanGetTitle()  &&  !art.GetTitle().Get().empty() ) {
        m_Title = art.GetTitle().GetTitle();
    }

    // Authors
    if ( art.CanGetAuthors() ) {
        x_AddAuthors(art.GetAuthors());
    }

    // Journal
    switch ( art.GetFrom().Which() ) {
    case CCit_art::C_From::e_Journal:
        x_Init(art.GetFrom().GetJournal(), ctx);
        break;
    case CCit_art::C_From::e_Book:
        x_Init(art.GetFrom().GetBook(), ctx, true);
        break;
    case CCit_art::C_From::e_Proc:
        x_Init(art.GetFrom().GetProc().GetBook(), ctx, true);
        break;
    default:
        break;
    }

    if ( art.CanGetIds() ) {
        ITERATE (CArticleIdSet::Tdata, it, art.GetIds().Get()) {
            switch ( (*it)->Which() ) {
            case CArticleId::e_Pubmed:
                if ( m_PMID == 0 ) {
                    m_PMID = (*it)->GetPubmed();
                }
                break;
            case CArticleId::e_Medline:
                if ( m_MUID == 0 ) {
                    m_MUID = (*it)->GetMedline();
                }
                break;
            default:
                break;
            }
        }
    }
}


void CReferenceItem::x_Init(const CCit_jour& jour, CBioseqContext& ctx)
{
    x_SetJournal(jour.GetTitle(), ctx);
    x_AddImprint(jour.GetImp(), ctx);
}





void CReferenceItem::x_Init
(const CCit_book& book,
 CBioseqContext& ctx,
 bool for_art)
{
    if ( !for_art ) {
        if ( book.CanGetImp() ) {
            x_AddImprint(book.GetImp(), ctx);
        }
        if ( book.CanGetTitle()  &&  !book.GetTitle().Get().empty() ) {
            m_Journal = book.GetTitle().GetTitle();
        }
        if ( m_Authors.Empty()  &&  book.CanGetAuthors() ) {
            x_AddAuthors(book.GetAuthors());
        }
    }  else if ( book.CanGetTitle()  &&  book.CanGetImp() ) {
        m_Book.Reset(&book);
        x_AddImprint(book.GetImp(), ctx);
    }
}


void CReferenceItem::x_Init(const CCit_pat& pat, CBioseqContext& ctx)
{
    bool embl = ctx.Config().IsFormatEMBL();
    m_Category = ePublished;

    m_Title = pat.GetTitle();
    x_AddAuthors(pat.GetAuthors());

    m_Journal = (embl ? "Patent number " : "Patent: ") + pat.GetCountry() + ' ';
    if ( pat.CanGetNumber()  &&  !pat.GetNumber().empty() ) {
        m_Journal += pat.GetNumber();
    } else if ( pat.CanGetApp_number()  &&  !pat.GetApp_number().empty() ) {
        m_Journal += pat.GetApp_number();
    }
    if ( pat.CanGetDoc_type()  &&  !pat.GetDoc_type().empty() ) {
        m_Journal += '-';
        m_Journal += pat.GetDoc_type();
    }

    CPatent_seq_id::TSeqid seqid = 0;
    ITERATE (CBioseq::TId, it, ctx.GetBioseqIds()) {
        if ((*it)->IsPatent()) {
            seqid = (*it)->GetPatent().GetSeqid();
        }
    }
    if ( seqid > 0 ) {
        m_Journal += embl ? '/' : ' ';
        m_Journal += NStr::IntToString(seqid);
        if ( embl ) {
            m_Journal += ", ";
        }
    } else {
        m_Journal += ' ';
    }
    if ( pat.CanGetDate_issue() ) {
        m_Journal += ' ';
        DateToString(pat.GetDate_issue(), m_Journal);
    } else if ( pat.CanGetApp_date() ) {
        m_Journal += ' ';
        DateToString(pat.GetApp_date(), m_Journal);
    }
    m_Journal += (embl ? '.' : ';');
}


void CReferenceItem::x_Init(const CCit_let& man, CBioseqContext& ctx)
{
    x_Init(man.GetCit(), ctx);

    if (man.CanGetType()  &&  man.GetType() == CCit_let::eType_thesis) {
        const CImprint& imp = man.GetCit().GetImp();
        if ( !m_Journal.empty() ) {
            m_Title = m_Journal;
            m_Journal.erase();
        }
        m_Journal = "Thesis (";
        imp.GetDate().GetDate(&m_Journal, "%Y");
        m_Journal += ')';
        if (imp.CanGetPrepub()
            &&  imp.GetPrepub() == CImprint::ePrepub_in_press) {
            m_Journal += ", In press";
        }
        if (imp.CanGetPub()) {
            string affil;
            FormatAffil(imp.GetPub(), affil);
            replace(affil.begin(), affil.end(), '\"', '\'');
            m_Journal += ' ' + affil;
        }
        m_Date.Reset();
    }
}


void CReferenceItem::x_AddAuthors(const CAuth_list& auth_list)
{
    m_Authors.Reset(&auth_list);

    if ( !auth_list.CanGetNames() ) return;
    
    // also populate the consortium (if available)
    if ( !m_Consortium.empty() ) return;

    const CAuth_list::TNames& names = auth_list.GetNames();
    
    if ( names.IsStd() ) {
        ITERATE (CAuth_list::TNames::TStd, it, names.GetStd()) {
            const CAuthor& auth = **it;
            if ( auth.CanGetName()  &&  
                 auth.GetName().IsConsortium() ) {
                m_Consortium = auth.GetName().GetConsortium();
                break;
            }
        }
    }
}


void CReferenceItem::x_SetJournal(const CTitle& title, CBioseqContext& ctx)
{
    // Only GenBank/EMBL/DDBJ require ISO JTA in ENTREZ/RELEASE modes.
    bool require_iso_jta = ctx.Config().CitArtIsoJta();
    if ( !ctx.IsGED()  &&  !ctx.IsTPA() ) {
        require_iso_jta = false;
    }
    // always use iso_jta title if present
    const CTitle::C_E* ttl = 0;
    ITERATE (CTitle::Tdata, it, title.Get()) {
        if ( (*it)->IsIso_jta() ) {
            ttl = *it;
            break;
        }
    }

    bool electronic_journal = false;
    if ( ttl == 0 ) {
        ttl = title.Get().front();
        if ( ttl != 0  &&  ttl->IsName() ) {
            if ( NStr::StartsWith(ttl->GetName(), "(er)", NStr::eNocase) ) {
                electronic_journal = true;
            }
        }
        if ( require_iso_jta  &&  !electronic_journal ) {
            return;
        }

        m_Journal = title.GetTitle();
    } else {
        m_Journal = ttl->GetIso_jta();
    }
}


void CReferenceItem::x_SetJournal(const CCit_gen& gen, CBioseqContext& ctx)
{
    if ( !gen.CanGetCit()  &&  !gen.CanGetJournal()  &&  !gen.CanGetDate()  &&
         gen.CanGetSerial_number()  &&  gen.GetSerial_number() != 0 ) {
        return;
    }

    if ( !gen.CanGetJournal()  &&
          gen.CanGetCit()  &&  
          NStr::StartsWith(gen.GetCit(), "unpublished", NStr::eNocase) ) {
        const string& cit = gen.GetCit();

        if ( ctx.Config().NoAffilOnUnpub() ) {
            m_Category = eUnpublished;
            m_Journal = "Unpublished";
            return;
        }

        if ( gen.CanGetAuthors()  &&  gen.GetAuthors().CanGetAffil() ) {
            string affil;
            (gen.GetAuthors().GetAffil(), affil);
            if ( !affil.empty() ) {
                m_Category = eUnpublished;
                m_Journal = "Unpublished " + affil;
                return;
            }
        }

        m_Journal = cit;
        return;
    }
    
    string result, in_press;
    if ( gen.CanGetJournal() ) {
        x_SetJournal(gen.GetJournal(), ctx);
        result = m_Journal;
    }

    if ( gen.CanGetCit() ) {
        const string& cit = gen.GetCit();

        SIZE_TYPE pos = NStr::FindNoCase(cit, "Journal=\"");
        if ( pos != NPOS ) {
            result = cit.substr(pos + 9);