feat_ci.cpp

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

/*
 * ===========================================================================
 * PRODUCTION $Log: feat_ci.cpp,v $
 * PRODUCTION Revision 1000.2  2004/06/01 19:23:14  gouriano
 * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.32
 * PRODUCTION
 * ===========================================================================
 */

/*  $Id: feat_ci.cpp,v 1000.2 2004/06/01 19:23:14 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:
*   Object manager iterators
*
*/

#include <ncbi_pch.hpp>
#include <objmgr/feat_ci.hpp>
#include <objmgr/bioseq_handle.hpp>
#include <objmgr/seq_entry_handle.hpp>
#include <objmgr/seq_annot_handle.hpp>
#include <objmgr/impl/annot_object.hpp>
#include <objmgr/impl/seq_annot_info.hpp>
#include <objmgr/impl/snp_annot_info.hpp>
#include <objects/seqfeat/Gb_qual.hpp>
#include <objects/seqfeat/SeqFeatXref.hpp>
#include <objects/general/Dbtag.hpp>
#include <objects/seqloc/Seq_id.hpp>
#include <objects/seqloc/Na_strand.hpp>
#include <objects/seqloc/Seq_loc.hpp>
#include <objects/seqloc/Seq_point.hpp>
#include <objects/seqloc/Seq_interval.hpp>

BEGIN_NCBI_SCOPE
BEGIN_SCOPE(objects)


CFeat_CI::CFeat_CI(void)
{
}


CFeat_CI::CFeat_CI(const CFeat_CI& iter)
    : CAnnotTypes_CI(iter)
{
    Update();
}


CFeat_CI::~CFeat_CI(void)
{
}


CFeat_CI& CFeat_CI::operator= (const CFeat_CI& iter)
{
    CAnnotTypes_CI::operator=(iter);
    Update();
    return *this;
}


CFeat_CI::CFeat_CI(const CBioseq_Handle& bioseq,
                   TSeqPos start, TSeqPos stop,
                   TFeatType feat_type,
                   SAnnotSelector::EOverlapType overlap_type,
                   SAnnotSelector::EResolveMethod resolve,
                   EFeat_Location loc_type)
    : CAnnotTypes_CI(CSeq_annot::C_Data::e_Ftable,
                     bioseq, start, stop,
                     SAnnotSelector(feat_type)
                     .SetByProduct(loc_type == e_Product)
                     .SetOverlapType(overlap_type)
                     .SetResolveMethod(resolve))
{
    Update();
}


CFeat_CI::CFeat_CI(const CBioseq_Handle& bioseq,
                   TSeqPos start, TSeqPos stop,
                   TFeatType feat_type,
                   SAnnotSelector::EOverlapType overlap_type,
                   SAnnotSelector::EResolveMethod resolve,
                   EFeat_Location loc_type,
                   const CSeq_entry_Handle& limitEntry)
    : CAnnotTypes_CI(CSeq_annot::C_Data::e_Ftable,
                     bioseq, start, stop,
                     SAnnotSelector(feat_type)
                     .SetByProduct(loc_type == e_Product)
                     .SetOverlapType(overlap_type)
                     .SetResolveMethod(resolve)
                     .SetLimitSeqEntry(limitEntry))
{
    Update();
}


CFeat_CI::CFeat_CI(const CBioseq_Handle& bioseq,
                   TSeqPos start, TSeqPos stop,
                   TFeatType feat_type,
                   SAnnotSelector::EOverlapType overlap_type,
                   SAnnotSelector::EResolveMethod resolve,
                   EFeat_Location loc_type,
                   const CSeq_entry* limitEntry)
    : CAnnotTypes_CI(CSeq_annot::C_Data::e_Ftable,
                     bioseq, start, stop,
                     SAnnotSelector(feat_type)
                     .SetByProduct(loc_type == e_Product)
                     .SetOverlapType(overlap_type)
                     .SetResolveMethod(resolve)
                     .SetLimitSeqEntry(limitEntry))
{
    Update();
}


CFeat_CI::CFeat_CI(CScope& scope,
                   const CSeq_loc& loc,
                   TFeatType feat_type,
                   SAnnotSelector::EOverlapType overlap_type,
                   SAnnotSelector::EResolveMethod resolve,
                   EFeat_Location loc_type)
    : CAnnotTypes_CI(CSeq_annot::C_Data::e_Ftable,
                     scope, loc,
                     SAnnotSelector(feat_type)
                     .SetByProduct(loc_type == e_Product)
                     .SetOverlapType(overlap_type)
                     .SetResolveMethod(resolve))
{
    Update();
}


CFeat_CI::CFeat_CI(CScope& scope,
                   const CSeq_loc& loc)
    : CAnnotTypes_CI(CSeq_annot::C_Data::e_Ftable,
                     scope, loc,
                     SAnnotSelector::eOverlap_Intervals,
                     SAnnotSelector::eResolve_TSE)
{
    Update();
}


CFeat_CI::CFeat_CI(const CBioseq_Handle& bioseq,
                   TSeqPos start, TSeqPos stop)
    : CAnnotTypes_CI(CSeq_annot::C_Data::e_Ftable,
                     bioseq, start, stop,
                     SAnnotSelector::eOverlap_Intervals,
                     SAnnotSelector::eResolve_TSE)
{
    Update();
}


CFeat_CI::CFeat_CI(CScope& scope,
                   const CSeq_loc& loc,
                   const SAnnotSelector& sel)
    : CAnnotTypes_CI(CSeq_annot::C_Data::e_Ftable,
                     scope, loc,
                     sel)
{
    Update();
}


CFeat_CI::CFeat_CI(const CBioseq_Handle& bioseq,
                   TSeqPos start, TSeqPos stop,
                   const SAnnotSelector& sel)
    : CAnnotTypes_CI(CSeq_annot::C_Data::e_Ftable,
                     bioseq, start, stop,
                     sel)
{
    Update();
}


CFeat_CI::CFeat_CI(const CSeq_annot_Handle& annot)
    : CAnnotTypes_CI(CSeq_annot::C_Data::e_Ftable,
                     annot)
{
    Update();
}


CFeat_CI::CFeat_CI(const CSeq_annot_Handle& annot,
                   const SAnnotSelector& sel)
    : CAnnotTypes_CI(CSeq_annot::C_Data::e_Ftable,
                     annot,
                     sel)
{
    Update();
}


CFeat_CI::CFeat_CI(const CSeq_entry_Handle& entry)
    : CAnnotTypes_CI(CSeq_annot::C_Data::e_Ftable,
                     entry)
{
    Update();
}


CFeat_CI::CFeat_CI(const CSeq_entry_Handle& entry,
                   const SAnnotSelector& sel)
    : CAnnotTypes_CI(CSeq_annot::C_Data::e_Ftable,
                     entry,
                     sel)
{
    Update();
}


CFeat_CI::CFeat_CI(CScope& scope, const CSeq_annot& annot)
    : CAnnotTypes_CI(CSeq_annot::C_Data::e_Ftable,
                     scope.GetSeq_annotHandle(annot))
{
    Update();
}


CFeat_CI::CFeat_CI(CScope& scope, const CSeq_annot& annot,
                   const SAnnotSelector& sel)
    : CAnnotTypes_CI(CSeq_annot::C_Data::e_Ftable,
                     scope.GetSeq_annotHandle(annot),
                     sel)
{
    Update();
}


CFeat_CI::CFeat_CI(CScope& scope, const CSeq_entry& entry)
    : CAnnotTypes_CI(CSeq_annot::C_Data::e_Ftable,
                     scope.GetSeq_entryHandle(entry))
{
    Update();
}


CFeat_CI::CFeat_CI(CScope& scope, const CSeq_entry& entry,
                   const SAnnotSelector& sel)
    : CAnnotTypes_CI(CSeq_annot::C_Data::e_Ftable,
                     scope.GetSeq_entryHandle(entry),
                     sel)
{
    Update();
}


CMappedFeat::CMappedFeat(void)
{
}


CMappedFeat::CMappedFeat(const CMappedFeat& feat)
{
    *this = feat;
}


CMappedFeat& CMappedFeat::operator=(const CMappedFeat& feat)
{
    if ( this != &feat ) {
        m_Collector = feat.m_Collector;
        m_FeatRef = feat.m_FeatRef;
        m_OriginalSeq_feat = feat.m_OriginalSeq_feat;
        m_MappedSeq_feat = feat.m_MappedSeq_feat;
        m_MappedSeq_loc = feat.m_MappedSeq_loc;
    }
    return *this;
}


CMappedFeat::~CMappedFeat(void)
{
}


CSeq_feat_Handle CMappedFeat::GetSeq_feat_Handle(void) const
{
    if ( m_FeatRef->IsSNPFeat() ) {
        return CSeq_feat_Handle(m_Collector->GetScope(),
            m_FeatRef->GetSeq_annot_SNP_Info(),
            m_FeatRef->GetAnnotObjectIndex());
    }
    return CSeq_feat_Handle(m_Collector->GetScope(),
        m_FeatRef->GetSeq_annot_Info(),
        m_FeatRef->GetAnnotObjectIndex());
}


CSeq_annot_Handle CMappedFeat::GetAnnot(void) const
{
    return CSeq_annot_Handle(m_Collector->GetScope(),
        m_FeatRef->GetSeq_annot_Info());
}


const CSeq_annot& CMappedFeat::GetSeq_annot(void) const
{
    ERR_POST_ONCE(Warning<<
                  "CMappedFeat::GetSeq_annot() is deprecated, "
                  "use GetAnnot().");
    return *m_FeatRef->GetSeq_annot_Info().GetCompleteSeq_annot();
}


void CMappedFeat::Reset(void)
{
    m_Collector.Reset();
    m_OriginalSeq_feat.Reset();
    m_MappedSeq_feat.Reset();
    m_MappedSeq_loc.Reset();