seq_loc_mapper.hpp

ncbi源码

                         const CSeq_id& dst_id,
                         TSeqPos        dst_start,
                         ENa_strand     dst_strand,
                         TSeqPos        length);
    void x_NextMappingRange(const CSeq_id&  src_id,
                            TSeqPos&        src_start,
                            TSeqPos&        src_len,
                            ENa_strand      src_strand,
                            const CSeq_id&  dst_id,
                            TSeqPos&        dst_start,
                            TSeqPos&        dst_len,
                            ENa_strand      dst_strand);

    // Optional frame is used for cd-region only
    void x_Initialize(const CSeq_loc& source,
                      const CSeq_loc& target,
                      int             frame = 0);
    void x_Initialize(const CSeq_align& map_align,
                      const CSeq_id&    to_id);
    void x_Initialize(const CSeq_align& map_align,
                      size_t            to_row);
    void x_Initialize(const CSeqMap& seq_map,
                      const CSeq_id* top_id = 0);
    void x_Initialize(const CSeqMap& seq_map,
                      size_t         depth,
                      const CSeq_id* top_id = 0);

    void x_InitAlign(const CDense_diag& diag, size_t to_row);
    void x_InitAlign(const CDense_seg& denseg, size_t to_row);
    void x_InitAlign(const CStd_seg& sseg, size_t to_row);
    void x_InitAlign(const CPacked_seg& pseg, size_t to_row);

    TRangeIterator x_BeginMappingRanges(CSeq_id_Handle id,
                                        TSeqPos from,
                                        TSeqPos to);

    bool x_MapInterval(const CSeq_id&   src_id,
                       TRange           src_rg,
                       bool             is_set_strand,
                       ENa_strand       src_strand,
                       TRangeFuzz       orig_fuzz);

    void x_PushLocToDstMix(CRef<CSeq_loc> loc);

    // Convert collected ranges into seq-loc and push into destination mix.
    void x_PushRangesToDstMix(void);

    void x_MapSeq_loc(const CSeq_loc& src_loc);
    CRef<CSeq_align> x_MapSeq_align(const CSeq_align& src_align);

    // Access mapped ranges, check vector size
    TMappedRanges& x_GetMappedRanges(const CSeq_id_Handle& id,
                                     int                   strand_idx) const;

    CRef<CSeq_loc> x_RangeToSeq_loc(const CSeq_id_Handle& idh,
                                    TSeqPos               from,
                                    TSeqPos               to,
                                    int                   strand_idx,
                                    TRangeFuzz            rg_fuzz);

    // Check location type, optimize if possible (empty mix to NULL,
    // mix with a single element to this element etc.).
    void x_OptimizeSeq_loc(CRef<CSeq_loc>& loc);

    CRef<CSeq_loc> x_GetMappedSeq_loc(void);

    CRef<CScope>      m_Scope;
    // CSeq_loc_Conversion_Set m_Cvt;
    EMergeFlags       m_MergeFlag;
    EGapFlags         m_GapFlag;
    bool              m_KeepNonmapping;

    // Sources may have different widths, e.g. in an alignment
    TWidthById      m_Widths;
    bool            m_UseWidth;
    int             m_Dst_width;
    TIdMap          m_IdMap;
    bool            m_Partial;

    mutable TRangesById m_MappedLocs;
    CRef<CSeq_loc>      m_Dst_loc;
    TDstStrandMap       m_DstRanges;
};


struct CMappingRangeRef_Less
{
    bool operator()(const CRef<CMappingRange>& x,
                    const CRef<CMappingRange>& y) const;
};


inline
bool CMappingRangeRef_Less::operator()(const CRef<CMappingRange>& x,
                                       const CRef<CMappingRange>& y) const
{
    if (x->m_Src_id_Handle != y->m_Src_id_Handle) {
        return x->m_Src_id_Handle < y->m_Src_id_Handle;
    }
    // Leftmost first
    if (x->m_Src_from != y->m_Src_from) {
        return x->m_Src_from < y->m_Src_from;
    }
    // Longest first
    return x->m_Src_to > y->m_Src_to;
}


inline
bool CMappingRange::GoodSrcId(const CSeq_id& id) const
{
    return m_Src_id_Handle == id;
}


inline
CRef<CSeq_id> CMappingRange::GetDstId(void)
{
    return m_Dst_id_Handle ?
        Ref(&const_cast<CSeq_id&>(*m_Dst_id_Handle.GetSeqId())) :
        CRef<CSeq_id>(0);
}


inline
CSeq_loc_Mapper& CSeq_loc_Mapper::SetMergeNone(void)
{
    m_MergeFlag = eMergeNone;
    return *this;
}


inline
CSeq_loc_Mapper& CSeq_loc_Mapper::SetMergeAbutting(void)
{
    m_MergeFlag = eMergeAbutting;
    return *this;
}


inline
CSeq_loc_Mapper& CSeq_loc_Mapper::SetMergeAll(void)
{
    m_MergeFlag = eMergeAll;
    return *this;
}


inline
CSeq_loc_Mapper& CSeq_loc_Mapper::SetGapPreserve(void)
{
    m_GapFlag = eGapPreserve;
    return *this;
}


inline
CSeq_loc_Mapper& CSeq_loc_Mapper::SetGapRemove(void)
{
    m_GapFlag = eGapRemove;
    return *this;
}


inline
bool CSeq_loc_Mapper::LastIsPartial(void)
{
    return m_Partial;
}


inline
void CSeq_loc_Mapper::KeepNonmappingRanges(void)
{
    m_KeepNonmapping = true;
}


inline
void CSeq_loc_Mapper::TruncateNonmappingRanges(void)
{
    m_KeepNonmapping = false;
}


END_SCOPE(objects)
END_NCBI_SCOPE

/*
* ---------------------------------------------------------------------------
* $Log: seq_loc_mapper.hpp,v $
* Revision 1000.1  2004/06/01 19:21:41  gouriano
* PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.13
*
* Revision 1.13  2004/05/26 14:29:20  grichenk
* Redesigned CSeq_align_Mapper: preserve non-mapping intervals,
* fixed strands handling, improved performance.
*
* Revision 1.12  2004/05/07 13:53:18  grichenk
* Preserve fuzz from original location.
* Better detection of partial locations.
*
* Revision 1.11  2004/05/05 14:04:22  grichenk
* Use fuzz to indicate truncated intervals. Added KeepNonmapping flag.
*
* Revision 1.10  2004/04/23 15:34:49  grichenk
* Added PreserveDestinationLocs().
*
* Revision 1.9  2004/04/12 14:35:59  grichenk
* Fixed mapping of alignments between nucleotides and proteins
*
* Revision 1.8  2004/04/06 13:56:33  grichenk
* Added possibility to remove gaps (NULLs) from mapped location
*
* Revision 1.7  2004/03/30 21:21:09  grichenk
* Reduced number of includes.
*
* Revision 1.6  2004/03/30 17:00:00  grichenk
* Fixed warnings, moved inline functions to hpp.
*
* Revision 1.5  2004/03/30 15:42:33  grichenk
* Moved alignment mapper to separate file, added alignment mapping
* to CSeq_loc_Mapper.
*
* Revision 1.4  2004/03/29 15:13:56  grichenk
* Added mapping down to segments of a bioseq or a seqmap.
* Fixed: preserve ranges already on the target bioseq(s).
*
* Revision 1.3  2004/03/22 21:10:58  grichenk
* Added mapping from segments to master sequence or through a seq-map.
*
* Revision 1.2  2004/03/19 14:19:08  grichenk
* Added seq-loc mapping through a seq-align.
*
* Revision 1.1  2004/03/10 16:22:29  grichenk
* Initial revision
*
*
* ===========================================================================
*/

#endif  // SEQ_LOC_MAPPER__HPP