bioseq_handle.cpp

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

/*
 * ===========================================================================
 * PRODUCTION $Log: bioseq_handle.cpp,v $
 * PRODUCTION Revision 1000.5  2004/06/01 19:22:54  gouriano
 * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.66
 * PRODUCTION
 * ===========================================================================
 */

/*  $Id: bioseq_handle.cpp,v 1000.5 2004/06/01 19:22:54 gouriano Exp $
* ===========================================================================
*
*                            PUBLIC DOMAIN NOTICE
*               National Center for Biotechnology Information
*
*  This software/database is a "United States Government Work" under the
*  terms of the United States Copyright Act.  It was written as part of
*  the author's official duties as a United States Government employee and
*  thus cannot be copyrighted.  This software/database is freely available
*  to the public for use. The National Library of Medicine and the U.S.
*  Government have not placed any restriction on its use or reproduction.
*
*  Although all reasonable efforts have been taken to ensure the accuracy
*  and reliability of the software and data, the NLM and the U.S.
*  Government do not and cannot warrant the performance or results that
*  may be obtained by using this software or data. The NLM and the U.S.
*  Government disclaim all warranties, express or implied, including
*  warranties of performance, merchantability or fitness for any particular
*  purpose.
*
*  Please cite the author in any work or product based on this material.
*
* ===========================================================================
*
* Author: Aleksey Grichenko, Eugene Vasilchenko
*
* File Description:
*
*/

#include <ncbi_pch.hpp>
#include <objmgr/bioseq_handle.hpp>
#include <objmgr/seq_annot_handle.hpp>
#include <objmgr/seq_entry_handle.hpp>

#include <objmgr/impl/scope_impl.hpp>

#include <objmgr/seq_vector.hpp>
#include <objmgr/seqmatch_info.hpp>

#include <objmgr/impl/data_source.hpp>
#include <objmgr/impl/tse_info.hpp>
#include <objmgr/impl/handle_range.hpp>
#include <objmgr/impl/bioseq_info.hpp>
#include <objmgr/impl/seq_entry_info.hpp>
#include <objmgr/impl/bioseq_set_info.hpp>
#include <objmgr/impl/tse_info.hpp>
#include <objmgr/impl/synonyms.hpp>
#include <objmgr/seq_loc_mapper.hpp>

#include <objects/general/Object_id.hpp>
#include <objects/seqloc/Seq_loc.hpp>
#include <objects/seqloc/Seq_interval.hpp>
#include <objects/seqloc/Seq_point.hpp>
#include <objects/seqloc/Seq_id.hpp>

#include <objects/seq/Bioseq.hpp>
#include <objects/seqset/Seq_entry.hpp>


BEGIN_NCBI_SCOPE
BEGIN_SCOPE(objects)

/////////////////////////////////////////////////////////////////////////////
// CBioseq_Handle
/////////////////////////////////////////////////////////////////////////////

CBioseq_Handle::CBioseq_Handle(const CSeq_id_Handle& id,
                               CBioseq_ScopeInfo* bioseq_info)
    : m_Seq_id(id),
      m_Bioseq_Info(bioseq_info)
{
}


bool CBioseq_Handle::operator==(const CBioseq_Handle& h) const
{
    if ( m_Scope != m_Scope ) {
        return false;
    }
    if ( *this && h )
        return &x_GetInfo() == &h.x_GetInfo();
    // Compare by id key
    return GetSeq_id_Handle() == h.GetSeq_id_Handle();
}


bool CBioseq_Handle::operator< (const CBioseq_Handle& h) const
{
    if ( m_Scope != h.m_Scope ) {
        return m_Scope < h.m_Scope;
    }
    if ( *this && h )
        return &x_GetInfo() < &h.x_GetInfo();
    return GetSeq_id_Handle() < h.GetSeq_id_Handle();
}


const CBioseq_Info& CBioseq_Handle::x_GetInfo(void) const
{
    return x_GetScopeInfo().GetBioseq_Info();
}


CConstRef<CSeq_id> CBioseq_Handle::GetSeqId(void) const
{
    return GetSeq_id_Handle().GetSeqIdOrNull();
}


CConstRef<CBioseq> CBioseq_Handle::GetCompleteBioseq(void) const
{
    return x_GetInfo().GetCompleteBioseq();
}


const CBioseq& CBioseq_Handle::GetBioseq(void) const
{
    ERR_POST_ONCE(Warning<<
                  "CBioseq_Handle::GetBioseq() is deprecated, "
                  "use GetCompleteBioseq() or GetBioseqCore().");
    return *GetCompleteBioseq();
}


const CSeq_entry& CBioseq_Handle::GetTopLevelSeqEntry(void) const
{
    ERR_POST_ONCE(Warning<<
                  "CBioseq_Handle::GetTopLevelSeqEntry() is deprecated, "
                  "use GetTopLevelEntry().");
    return *GetTopLevelEntry().GetCompleteSeq_entry();
}


CBioseq_Handle::TBioseqCore CBioseq_Handle::GetBioseqCore(void) const
{
    return x_GetInfo().GetBioseqCore();
}


CBioseq_EditHandle CBioseq_Handle::GetEditHandle(void) const
{
    return m_Scope->GetEditHandle(*this);
}


/////////////////////////////////////////////////////////////////////////////
// Bioseq members

bool CBioseq_Handle::IsSetId(void) const
{
    return x_GetInfo().IsSetId();
}


bool CBioseq_Handle::CanGetId(void) const
{
    return bool(m_Bioseq_Info)  &&  x_GetInfo().CanGetId();
}


const CBioseq_Handle::TId& CBioseq_Handle::GetId(void) const
{
    return x_GetInfo().GetId();
}


bool CBioseq_Handle::IsSetDescr(void) const
{
    return x_GetInfo().IsSetDescr();
}


bool CBioseq_Handle::CanGetDescr(void) const
{
    return bool(m_Bioseq_Info)  &&  x_GetInfo().CanGetDescr();
}


const CSeq_descr& CBioseq_Handle::GetDescr(void) const
{
    return x_GetInfo().GetDescr();
}


bool CBioseq_Handle::IsSetInst(void) const
{
    return x_GetInfo().IsSetInst();
}


bool CBioseq_Handle::CanGetInst(void) const
{
    return bool(m_Bioseq_Info)  &&  x_GetInfo().CanGetInst();
}


const CSeq_inst& CBioseq_Handle::GetInst(void) const
{
    return x_GetInfo().GetInst();
}


bool CBioseq_Handle::IsSetInst_Repr(void) const
{
    return x_GetInfo().IsSetInst_Repr();
}


bool CBioseq_Handle::CanGetInst_Repr(void) const
{
    return bool(m_Bioseq_Info)  &&  x_GetInfo().CanGetInst_Repr();
}


CBioseq_Handle::TInst_Repr CBioseq_Handle::GetInst_Repr(void) const
{
    return x_GetInfo().GetInst_Repr();
}


bool CBioseq_Handle::IsSetInst_Mol(void) const
{
    return x_GetInfo().IsSetInst_Mol();
}


bool CBioseq_Handle::CanGetInst_Mol(void) const
{
    return bool(m_Bioseq_Info)  &&  x_GetInfo().CanGetInst_Mol();
}


CBioseq_Handle::TInst_Mol CBioseq_Handle::GetInst_Mol(void) const
{
    return x_GetInfo().GetInst_Mol();
}


bool CBioseq_Handle::IsSetInst_Length(void) const
{
    return x_GetInfo().IsSetInst_Length();
}


bool CBioseq_Handle::CanGetInst_Length(void) const
{
    return bool(m_Bioseq_Info)  &&  x_GetInfo().CanGetInst_Length();
}


CBioseq_Handle::TInst_Length CBioseq_Handle::GetInst_Length(void) const
{
    return x_GetInfo().GetInst_Length();
}


TSeqPos CBioseq_Handle::GetBioseqLength(void) const
{
    return x_GetInfo().GetBioseqLength();
}


bool CBioseq_Handle::IsSetInst_Fuzz(void) const
{
    return x_GetInfo().IsSetInst_Fuzz();
}


bool CBioseq_Handle::CanGetInst_Fuzz(void) const
{
    return bool(m_Bioseq_Info)  &&  x_GetInfo().CanGetInst_Fuzz();
}


const CBioseq_Handle::TInst_Fuzz& CBioseq_Handle::GetInst_Fuzz(void) const
{
    return x_GetInfo().GetInst_Fuzz();
}


bool CBioseq_Handle::IsSetInst_Topology(void) const
{
    return x_GetInfo().IsSetInst_Topology();
}


bool CBioseq_Handle::CanGetInst_Topology(void) const
{
    return bool(m_Bioseq_Info)  &&  x_GetInfo().CanGetInst_Topology();
}


CBioseq_Handle::TInst_Topology CBioseq_Handle::GetInst_Topology(void) const
{
    return x_GetInfo().GetInst_Topology();
}


bool CBioseq_Handle::IsSetInst_Strand(void) const
{
    return x_GetInfo().IsSetInst_Strand();
}


bool CBioseq_Handle::CanGetInst_Strand(void) const
{
    return bool(m_Bioseq_Info)  &&  x_GetInfo().CanGetInst_Strand();
}


CBioseq_Handle::TInst_Strand CBioseq_Handle::GetInst_Strand(void) const
{
    return x_GetInfo().GetInst_Strand();
}


bool CBioseq_Handle::IsSetInst_Seq_data(void) const
{
    return x_GetInfo().IsSetInst_Seq_data();
}


bool CBioseq_Handle::CanGetInst_Seq_data(void) const
{
    return bool(m_Bioseq_Info)  &&  x_GetInfo().CanGetInst_Seq_data();
}


const CBioseq_Handle::TInst_Seq_data&
CBioseq_Handle::GetInst_Seq_data(void) const
{
    return x_GetInfo().GetInst_Seq_data();
}


bool CBioseq_Handle::IsSetInst_Ext(void) const
{
    return x_GetInfo().IsSetInst_Ext();
}


bool CBioseq_Handle::CanGetInst_Ext(void) const
{
    return bool(m_Bioseq_Info)  &&  x_GetInfo().CanGetInst_Ext();
}


const CBioseq_Handle::TInst_Ext& CBioseq_Handle::GetInst_Ext(void) const
{
    return x_GetInfo().GetInst_Ext();
}


bool CBioseq_Handle::IsSetInst_Hist(void) const
{
    return x_GetInfo().IsSetInst_Hist();
}


bool CBioseq_Handle::CanGetInst_Hist(void) const
{
    return bool(m_Bioseq_Info)  &&  x_GetInfo().CanGetInst_Hist();
}


const CBioseq_Handle::TInst_Hist& CBioseq_Handle::GetInst_Hist(void) const
{
    return x_GetInfo().GetInst_Hist();
}


bool CBioseq_Handle::HasAnnots(void) const
{
    return x_GetInfo().HasAnnots();
}


// end of Bioseq members
/////////////////////////////////////////////////////////////////////////////


CSeq_inst::TMol CBioseq_Handle::GetBioseqMolType(void) const
{
    return x_GetInfo().GetInst_Mol();
}


const CSeqMap& CBioseq_Handle::GetSeqMap(void) const
{
    return x_GetInfo().GetSeqMap();
}


CSeqVector CBioseq_Handle::GetSeqVector(EVectorCoding coding,
                                        ENa_strand strand) const
{
    return CSeqVector(GetSeqMap(), GetScope(), coding, strand);
}


CSeqVector CBioseq_Handle::GetSeqVector(ENa_strand strand) const
{
    return CSeqVector(GetSeqMap(), GetScope(), eCoding_Ncbi, strand);
}


CSeqVector CBioseq_Handle::GetSeqVector(EVectorCoding coding,
                                        EVectorStrand strand) const
{
    return CSeqVector(GetSeqMap(), GetScope(), coding,
                      strand == eStrand_Minus?
                      eNa_strand_minus: eNa_strand_plus);
}


CSeqVector CBioseq_Handle::GetSeqVector(EVectorStrand strand) const
{
    return CSeqVector(GetSeqMap(), GetScope(), eCoding_Ncbi,
                      strand == eStrand_Minus?
                      eNa_strand_minus: eNa_strand_plus);
}


CConstRef<CSynonymsSet> CBioseq_Handle::GetSynonyms(void) const
{
    if ( !*this ) {
        return CConstRef<CSynonymsSet>();
    }
    return GetScope().GetSynonyms(*this);
}


bool CBioseq_Handle::IsSynonym(const CSeq_id& id) const
{
    CConstRef<CSynonymsSet> syns = GetSynonyms();
    return bool(syns) && syns->ContainsSynonym(CSeq_id_Handle::GetHandle(id));
}


CSeqVector CBioseq_Handle::GetSequenceView(const CSeq_loc& location,
                                           ESequenceViewMode mode,
                                           EVectorCoding coding,
                                           ENa_strand strand) const
{
    if ( mode != eViewConstructed )
        strand = eNa_strand_unknown;
    return CSeqVector(GetSeqMapByLocation(location, mode), GetScope(),
                      coding, strand);
}


CConstRef<CSeqMap>
CBioseq_Handle::GetSeqMapByLocation(const CSeq_loc& loc,
                                    ESequenceViewMode mode) const
{
    CConstRef<CSeqMap> ret;
    if ( mode == eViewConstructed ) {
        ret = CSeqMap::CreateSeqMapForSeq_loc(loc, &GetScope());
    }
    else {
        // Parse the location
        CHandleRange rlist;      // all intervals pointing to the sequence
        CSeq_loc_CI loc_it(loc);
        for ( ; loc_it; ++loc_it) {
            if ( !IsSynonym(loc_it.GetSeq_id()) )
                continue;
            rlist.AddRange(loc_it.GetRange(), loc_it.GetStrand());
        }

        // Make mode-dependent parsing of the range list
        CHandleRange mode_rlist; // processed intervals (merged, excluded)
        switch (mode) {
        case eViewMerged:
        {
            // Merge intervals from "rlist"
            ITERATE (CHandleRange, rit, rlist) {
                mode_rlist.MergeRange(rit->first, rit->second);
            }
            break;
        }
        case eViewExcluded:
        {
            // Exclude intervals from "rlist"
            TSeqPos last_from = 0;
            ITERATE (CHandleRange, rit, rlist) {
                if (last_from < rit->first.GetFrom()) {
                    mode_rlist.MergeRange(
                        CHandleRange::TRange(last_from, rit->first.GetFrom()-1),
                        eNa_strand_unknown);
                }
                if ( !rit->first.IsWholeTo() ) {
                    last_from = rit->first.GetTo()+1;
                }
                else {
                    last_from = CHandleRange::TRange::GetWholeTo();
                }
            }
            TSeqPos total_length = GetSeqMap().GetLength(&GetScope());
            if (last_from < total_length) {
                mode_rlist.MergeRange(
                    CHandleRange::TRange(last_from, total_length-1),
                    eNa_strand_unknown);
            }
            break;
        }
        default:
            break;
        }

        // Convert ranges to seq-loc
        CRef<CSeq_loc> view_loc(new CSeq_loc);
        ITERATE (CHandleRange, rit, mode_rlist) {
            CRef<CSeq_loc> seg_loc(new CSeq_loc);
            CRef<CSeq_id> id(new CSeq_id);
            id->Assign(*GetSeqId());