gbseq_formatter.cpp

来自「ncbi源码」· C++ 代码 · 共 632 行 · 第 1/2 页

///////////////////////////////////////////////////////////////////////////
//
// Source

void CGBSeqFormatter::FormatSource
(const CSourceItem& source,
 IFlatTextOStream&)
{
    _ASSERT(m_GBSeq);
    CNcbiOstrstream source_line;
    source_line << source.GetOrganelle() << source.GetTaxname();
    if ( !source.GetCommon().empty() ) {
        source_line << (source.IsUsingAnamorph() ? " (anamorph: " : " (") 
                    << source.GetCommon() << ")";
    }

    m_GBSeq->SetSource(CNcbiOstrstreamToString(source_line));
    m_GBSeq->SetOrganism(source.GetTaxname());
    m_GBSeq->SetTaxonomy(source.GetLineage());
}


///////////////////////////////////////////////////////////////////////////
//
// Keywords

void CGBSeqFormatter::FormatKeywords
(const CKeywordsItem& keys,
 IFlatTextOStream&)
{
    ITERATE (CKeywordsItem::TKeywords, it, keys.GetKeywords()) {
        m_GBSeq->SetKeywords().push_back(CGBKeyword(*it));
    }
}


///////////////////////////////////////////////////////////////////////////
//
// REFERENCE

void CGBSeqFormatter::FormatReference
(const CReferenceItem& ref,
 IFlatTextOStream&)
{
    _ASSERT(m_GBSeq);
    CBioseqContext& ctx = *ref.GetContext();

    CRef<CGBReference> gbref(new CGBReference);
    const CSeq_loc* loc = (ref.GetLoc() != 0) ?
        ref.GetLoc() : &ctx.GetLocation();
    CNcbiOstrstream refstr;
    refstr << ref.GetSerial() << ' ';
    x_FormatRefLocation(refstr, *loc, " to ", "; ", ctx);
    gbref->SetReference(CNcbiOstrstreamToString(refstr));
    list<string> authors;
    CReferenceItem::GetAuthNames(authors, ref.GetAuthors());
    ITERATE (list<string>, it, authors) {
        CGBAuthor author(*it);
        gbref->SetAuthors().push_back(author);
    }
    if ( !ref.GetConsortium().empty() ) {
        gbref->SetConsortium(ref.GetConsortium());
    }
    if ( !ref.GetTitle().empty() ) {
        if ( NStr::EndsWith(ref.GetTitle(), ".") ) {
            string title = ref.GetTitle();
            title.resize(title.length() - 1);
            gbref->SetTitle(title);
        } else {
            gbref->SetTitle(ref.GetTitle());
        }
    }
    string journal;
    x_FormatRefJournal(journal, ref);
    NON_CONST_ITERATE (string, it, journal) {
        if ( (*it == '\n')  ||  (*it == '\t')  ||  (*it == '\r') ) {
            *it = ' ';
        }
    }
    if ( !journal.empty() ) {
        gbref->SetJournal(journal);
    }
    if ( ref.GetMUID() != 0 ) {
        gbref->SetMedline(ref.GetMUID());
    }
    if ( ref.GetPMID() != 0 ) {
        gbref->SetPubmed(ref.GetPMID());
    }
    if ( !ref.GetRemark().empty() ) {
        gbref->SetRemark(ref.GetRemark());
    }
    m_GBSeq->SetReferences().push_back(gbref);
}

///////////////////////////////////////////////////////////////////////////
//
// COMMENT


void CGBSeqFormatter::FormatComment
(const CCommentItem& comment,
 IFlatTextOStream&)
{
    string str = comment.GetComment();
    s_GBSeqStringCleanup(str);
    
    if ( !m_GBSeq->IsSetComment() ) {
        m_GBSeq->SetComment(str);
    } else {    
        m_GBSeq->SetComment() += "; ";
        m_GBSeq->SetComment() += str;
    }
}


///////////////////////////////////////////////////////////////////////////
//
// FEATURES

static void s_SetIntervals(CGBFeature::TIntervals& intervals,
                    const CSeq_loc& loc,
                    CScope& scope)
{
    for (CSeq_loc_CI it(loc); it; ++it) {
        CRef<CGBInterval> ival(new CGBInterval);
        CSeq_loc_CI::TRange range = it.GetRange();
        CConstRef<CSeq_id> best(&it.GetSeq_id());
        if ( best->IsGi() ) {
            CConstRef<CSynonymsSet> syns = scope.GetSynonyms(*best);
            vector< CRef<CSeq_id> > ids;
            ITERATE (CSynonymsSet, id_iter, *syns) {
                CConstRef<CSeq_id> id = (*id_iter)->first.GetSeqId();
                CRef<CSeq_id> sip(const_cast<CSeq_id*>(id.GetPointerOrNull()));
                ids.push_back(sip);
            }
            best.Reset(FindBestChoice(ids, CSeq_id::Score));
        }
        ival->SetAccession(best->GetSeqIdString(true));  
        if ( range.GetLength() == 1 ) {  // point
            ival->SetPoint(range.GetFrom() + 1);
        } else {
            TSeqPos from, to;
            if ( range.IsWhole() ) {
                from = 1;
                to = sequence::GetLength(it.GetSeq_loc(), &scope);
            } else {
                from = range.GetFrom() + 1;
                to = range.GetTo() + 1;
            }
            if ( it.GetStrand() == eNa_strand_minus ) {
                swap(from, to);
            }
            ival->SetFrom(from);
            ival->SetTo(to);
        }
        
        intervals.push_back(ival);
    }
}


static void s_SetQuals(CGBFeature::TQuals& gbquals,
                       const CFlatFeature::TQuals& quals)
{
    ITERATE (CFlatFeature::TQuals, it, quals) {
        CRef<CGBQualifier> qual(new CGBQualifier);
        qual->SetName((*it)->GetName());
        if ((*it)->GetStyle() != CFormatQual::eEmpty) {
            qual->SetValue((*it)->GetValue());
            s_GBSeqQualCleanup(qual->SetValue());
        }
        gbquals.push_back(qual);
    }
}


void CGBSeqFormatter::FormatFeature
(const CFeatureItemBase& f,
 IFlatTextOStream&)
{
    CConstRef<CFlatFeature> feat = f.Format();

    CRef<CGBFeature>    gbfeat(new CGBFeature);
    gbfeat->SetKey(feat->GetKey());
    
    string location = feat->GetLoc().GetString();
    s_GBSeqStringCleanup(location, true);
    gbfeat->SetLocation(location);
    if ( feat->GetKey() != "source" ) {
        s_SetIntervals(gbfeat->SetIntervals(), f.GetLoc(), 
            f.GetContext()->GetScope());
    }
    if ( !feat->GetQuals().empty() ) {
        s_SetQuals(gbfeat->SetQuals(), feat->GetQuals());
    }
    
    m_GBSeq->SetFeature_table().push_back(gbfeat);
}


///////////////////////////////////////////////////////////////////////////
//
// SEQUENCE

void CGBSeqFormatter::FormatSequence
(const CSequenceItem& seq,
 IFlatTextOStream&)
{
    string data;

    CSeqVector_CI vec_ci(seq.GetSequence());
    vec_ci.GetSeqData(data, seq.GetSequence().size());

    if ( !m_GBSeq->IsSetSequence() ) {
        m_GBSeq->SetSequence(kEmptyStr);
    }
    m_GBSeq->SetSequence() += data;
}


///////////////////////////////////////////////////////////////////////////
//
// CONTIG

void CGBSeqFormatter::FormatContig
(const CContigItem& contig,
 IFlatTextOStream&)
{
    string assembly = CFlatSeqLoc(contig.GetLoc(), *contig.GetContext(), 
        CFlatSeqLoc::eType_assembly).GetString();
    s_GBSeqStringCleanup(assembly, true);
    m_GBSeq->SetContig(assembly);
}


//=========================================================================//
//                                Private                                  //
//=========================================================================//


void CGBSeqFormatter::x_WriteFileHeader(IFlatTextOStream& text_os)
{
    m_Out.reset(CObjectOStream::Open(eSerial_Xml, m_StrStream));
    const CClassTypeInfo* gbset_info
        = dynamic_cast<const CClassTypeInfo*>(CGBSet::GetTypeInfo());
    m_Out->WriteFileHeader(gbset_info);
    x_StrOStreamToTextOStream(text_os);
}


void CGBSeqFormatter::x_StartWriteGBSet(IFlatTextOStream& text_os)
{
    m_Cont.reset(new SOStreamContainer(*m_Out, CGBSet::GetTypeInfo()));
    x_StrOStreamToTextOStream(text_os);
}


void CGBSeqFormatter::x_WriteGBSeq(IFlatTextOStream& text_os)
{
    m_Cont->WriteElement(ConstObjectInfo(*m_GBSeq));
    x_StrOStreamToTextOStream(text_os);
}


void CGBSeqFormatter::x_EndWriteGBSet(IFlatTextOStream& text_os)
{
    m_Cont.reset();
    x_StrOStreamToTextOStream(text_os);
}


void CGBSeqFormatter::x_StrOStreamToTextOStream(IFlatTextOStream& text_os)
{
    list<string> l;

    // flush ObjectOutputStream to underlying strstream
    m_Out->Flush();
    // read text from strstream
    NStr::Split(CNcbiOstrstreamToString(m_StrStream), "\n", l);
    // add text to TextOStream
    text_os.AddParagraph(l);
    // reset strstream
    m_StrStream.seekp(0);
}


END_SCOPE(objects)
END_NCBI_SCOPE


/*
* ===========================================================================
*
* $Log: gbseq_formatter.cpp,v $
* Revision 1000.1  2004/06/01 19:44:34  gouriano
* PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.4
*
* Revision 1.4  2004/05/21 21:42:54  gorelenk
* Added PCH ncbi_pch.hpp
*
* Revision 1.3  2004/05/06 17:52:53  shomrat
* CFlatQual -> CFormatQual
*
* Revision 1.2  2004/04/22 15:53:26  shomrat
* Changes in context
*
* Revision 1.1  2004/04/13 16:49:54  shomrat
* Initial revision
*
*
* ===========================================================================
*/