annot_collector.hpp

ncbi源码

{
    return EObjectType(m_ObjectType);
}


inline
TSeqPos CAnnotObject_Ref::GetFrom(void) const
{
    return m_TotalRange.GetFrom();
}


inline
TSeqPos CAnnotObject_Ref::GetToOpen(void) const
{
    return m_TotalRange.GetToOpen();
}


inline
const CAnnotObject_Ref::TRange& CAnnotObject_Ref::GetTotalRange(void) const
{
    return m_TotalRange;
}


inline
void CAnnotObject_Ref::SetTotalRange(const TRange& range)
{
    m_TotalRange = range;
}


inline
unsigned int CAnnotObject_Ref::GetAnnotObjectIndex(void) const
{
    return m_AnnotObject_Index;
}


inline
const CSeq_annot_Info& CAnnotObject_Ref::GetSeq_annot_Info(void) const
{
    _ASSERT(GetObjectType() == eType_Seq_annot_Info);
    return reinterpret_cast<const CSeq_annot_Info&>(*m_Object);
}


inline
const CSeq_annot_SNP_Info& CAnnotObject_Ref::GetSeq_annot_SNP_Info(void) const
{
    _ASSERT(GetObjectType() == eType_Seq_annot_SNP_Info);
    return reinterpret_cast<const CSeq_annot_SNP_Info&>(*m_Object);
}


inline
bool CAnnotObject_Ref::IsPartial(void) const
{
    return (m_MappedFlags & fMapped_Partial) != 0;
}


inline
bool CAnnotObject_Ref::IsProduct(void) const
{
    return (m_MappedFlags & fMapped_Product) != 0;
}


inline
ENa_strand CAnnotObject_Ref::GetMappedStrand(void) const
{
    return ENa_strand(m_MappedStrand);
}


inline
void CAnnotObject_Ref::SetMappedStrand(ENa_strand strand)
{
    _ASSERT(IsMapped());
    m_MappedStrand = strand;
}


inline
CAnnotObject_Ref::EMappedObjectType
CAnnotObject_Ref::GetMappedObjectType(void) const
{
    return EMappedObjectType(m_MappedObjectType);
}


inline
bool CAnnotObject_Ref::IsMapped(void) const
{
    _ASSERT((GetMappedObjectType() == eMappedObjType_not_set) ==
            !m_MappedObject);
    return GetMappedObjectType() != eMappedObjType_not_set;

}


inline
bool CAnnotObject_Ref::MappedSeq_locNeedsUpdate(void) const
{
    return GetMappedObjectType() == eMappedObjType_Seq_id;

}


inline
bool CAnnotObject_Ref::IsMappedLocation(void) const
{
    return IsMapped() && !IsProduct();
}


inline
bool CAnnotObject_Ref::IsMappedProduct(void) const
{
    return IsMapped() && IsProduct();
}


inline
const CSeq_loc& CAnnotObject_Ref::GetMappedSeq_loc(void) const
{
    _ASSERT(GetMappedObjectType() == eMappedObjType_Seq_loc);
    return static_cast<const CSeq_loc&>(*m_MappedObject);
}


inline
const CSeq_id& CAnnotObject_Ref::GetMappedSeq_id(void) const
{
    _ASSERT(GetMappedObjectType() == eMappedObjType_Seq_id);
    return static_cast<const CSeq_id&>(*m_MappedObject);
}


inline
void CAnnotObject_Ref::SetMappedSeq_loc(CSeq_loc* loc)
{
    _ASSERT(!IsMapped());
    m_MappedObject.Reset(loc);
    m_MappedObjectType = loc? eMappedObjType_Seq_loc: eMappedObjType_not_set;
}


inline
void CAnnotObject_Ref::SetMappedSeq_loc(CSeq_loc& loc)
{
    _ASSERT(!IsMapped());
    m_MappedObject.Reset(&loc);
    m_MappedObjectType = eMappedObjType_Seq_loc;
}


inline
void CAnnotObject_Ref::SetMappedSeq_id(CSeq_id& id)
{
    _ASSERT(!IsMapped());
    m_MappedObject.Reset(&id);
    m_MappedObjectType = eMappedObjType_Seq_id;
}


inline
void CAnnotObject_Ref::SetMappedPoint(bool point)
{
    _ASSERT(GetMappedObjectType() == eMappedObjType_Seq_id);
    if ( point ) {
        m_MappedFlags |= fMapped_Seq_point;
    }
    else {
        m_MappedFlags &= ~fMapped_Seq_point;
    }
}


inline
bool CAnnotObject_Ref::IsMappedPoint(void) const
{
    _ASSERT(GetMappedObjectType() == eMappedObjType_Seq_id);
    return (m_MappedFlags & fMapped_Seq_point) != 0;
}


inline
void CAnnotObject_Ref::SetMappedSeq_id(CSeq_id& id, bool point)
{
    SetMappedSeq_id(id);
    SetMappedPoint(point);
}


inline
bool CAnnotObject_Ref::IsSNPFeat(void) const
{
    return GetObjectType() == eType_Seq_annot_SNP_Info;
}


inline
void CAnnotObject_Ref::SetPartial(bool partial)
{
    if ( partial ) {
        m_MappedFlags |= fMapped_Partial;
    }
    else {
        m_MappedFlags &= ~fMapped_Partial;
    }
}


inline
void CAnnotObject_Ref::SetProduct(bool product)
{
    if ( product ) {
        m_MappedFlags |= fMapped_Product;
    }
    else {
        m_MappedFlags &= ~fMapped_Product;
    }
}


inline
void CAnnotObject_Ref::SetAnnotObjectRange(const TRange& range, bool product)
{
    m_TotalRange = range;
    SetProduct(product);
}


inline
void CAnnotObject_Ref::ResetLocation(void)
{
    m_TotalRange = TRange::GetEmpty();
    m_MappedObject.Reset();
    m_MappedObjectType = eMappedObjType_not_set;
    m_MappedStrand = eNa_strand_unknown;
}


/////////////////////////////////////////////////////////////////////////////
// CAnnot_Collector
/////////////////////////////////////////////////////////////////////////////


inline
const CAnnot_Collector::TAnnotSet&
CAnnot_Collector::GetAnnotSet(void) const
{
    return m_AnnotSet;
}


inline
CScope& CAnnot_Collector::GetScope(void) const
{
    return m_Scope;
}


inline
SAnnotSelector& CAnnot_Collector::GetSelector(void)
{
    return m_Selector;
}


END_SCOPE(objects)
END_NCBI_SCOPE

/*
* ---------------------------------------------------------------------------
* $Log: annot_collector.hpp,v $
* Revision 1000.2  2004/06/01 19:21:50  gouriano
* PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.6
*
* Revision 1.6  2004/05/26 14:29:20  grichenk
* Redesigned CSeq_align_Mapper: preserve non-mapping intervals,
* fixed strands handling, improved performance.
*
* Revision 1.5  2004/05/11 17:45:24  grichenk
* Removed declarations for SetMappedIndex() and SetMappedSeq_align_Mapper()
*
* Revision 1.4  2004/05/10 18:26:37  grichenk
* Fixed 'not used' warnings
*
* Revision 1.3  2004/04/13 21:14:27  vasilche
* Fixed wrong order of object deletion causing "tse is locked" error.
*
* Revision 1.2  2004/04/07 13:20:17  grichenk
* Moved more data from iterators to CAnnot_Collector
*
* Revision 1.1  2004/04/05 15:54:25  grichenk
* Initial revision
*
*
* ===========================================================================
*/

#endif  // ANNOT_COLLECTOR__HPP