alnmap.hpp

ncbi源码

      m_Scores(ds.GetScores()),
      m_Widths(ds.GetWidths()),
      m_Anchor(-1),
      m_RawSegTypes(0)
{
    x_Init();
    SetAnchor(anchor);
}


inline
CAlnMap::~CAlnMap(void)
{
    if (m_RawSegTypes) {
        delete m_RawSegTypes;
    }
}


inline
const CDense_seg& CAlnMap::GetDenseg() const
{
    return *m_DS;
}


inline TSeqPos CAlnMap::GetAlnStart(TNumseg seg) const
{
    return m_AlnStarts[seg];
}


inline
TSeqPos CAlnMap::GetAlnStop(TNumseg seg) const
{
    return m_AlnStarts[seg] + m_Lens[x_GetRawSegFromSeg(seg)] - 1;
}


inline
TSeqPos CAlnMap::GetAlnStop(void) const
{
    return GetAlnStop(GetNumSegs() - 1);
}


inline 
CAlnMap::TSegTypeFlags 
CAlnMap::GetSegType(TNumrow row, TNumseg seg, int offset) const
{
    return x_GetRawSegType(row, x_GetRawSegFromSeg(seg) + offset);
}


inline
CAlnMap::TNumseg CAlnMap::GetNumSegs(void) const
{
    return IsSetAnchor() ? m_AlnSegIdx.size() : m_NumSegs;
}


inline
CAlnMap::TDim CAlnMap::GetNumRows(void) const
{
    return m_NumRows;
}


inline
bool CAlnMap::IsSetAnchor(void) const
{
    return m_Anchor >= 0;
}

inline
CAlnMap::TNumrow CAlnMap::GetAnchor(void) const
{
    return m_Anchor;
}



inline
CAlnMap::CNumSegWithOffset
CAlnMap::x_GetSegFromRawSeg(TNumseg raw_seg) const
{
    return IsSetAnchor() ? m_NumSegWithOffsets[raw_seg] : raw_seg;
}


inline
CAlnMap::TNumseg
CAlnMap::x_GetRawSegFromSeg(TNumseg seg) const
{
    return IsSetAnchor() ? m_AlnSegIdx[seg] : seg;
}


inline
TSignedSeqPos CAlnMap::x_GetRawStart(TNumrow row, TNumseg seg) const
{
    return m_Starts[seg * m_NumRows + row];
}

inline
int CAlnMap::GetWidth(TNumrow row) const
{
    return
        (m_Widths.size() == (size_t) m_NumRows) ? m_Widths[row] : 1;
}

inline
TSeqPos CAlnMap::x_GetLen(TNumrow row, TNumseg seg) const
{
    return m_Lens[seg] * GetWidth(row);
}

inline
TSignedSeqPos CAlnMap::x_GetRawStop(TNumrow row, TNumseg seg) const
{
    TSignedSeqPos start = x_GetRawStart(row, seg);
    return ((start > -1) ? (start + (TSignedSeqPos)x_GetLen(row, seg) - 1)
            : -1);
}


inline
int CAlnMap::StrandSign(TNumrow row) const
{
    return IsPositiveStrand(row) ? 1 : -1;
}


inline
bool CAlnMap::IsPositiveStrand(TNumrow row) const
{
    return (m_Strands.empty()  ||  m_Strands[row] != eNa_strand_minus);
}


inline
bool CAlnMap::IsNegativeStrand(TNumrow row) const
{
    return ! IsPositiveStrand(row);
}


inline
TSignedSeqPos CAlnMap::GetStart(TNumrow row, TNumseg seg, int offset) const
{
    return m_Starts
        [(x_GetRawSegFromSeg(seg) + offset) * m_NumRows + row];
}

inline
TSeqPos CAlnMap::GetLen(TNumseg seg, int offset) const
{
    return m_Lens[x_GetRawSegFromSeg(seg) + offset];
}


inline
TSeqPos CAlnMap::GetSeqLen(TNumrow row, TNumseg seg, int offset) const
{
    return x_GetLen(row, x_GetRawSegFromSeg(seg) + offset);
}


inline
TSignedSeqPos CAlnMap::GetStop(TNumrow row, TNumseg seg, int offset) const
{
    TSignedSeqPos start = GetStart(row, seg, offset);
    return ((start > -1) ? 
            (start + (TSignedSeqPos)GetSeqLen(row, seg, offset) - 1) :
            -1);
}


inline
const CSeq_id& CAlnMap::GetSeqId(TNumrow row) const
{
    return *(m_Ids[row]);
}


inline 
CAlnMap::TSignedRange
CAlnMap::GetRange(TNumrow row, TNumseg seg, int offset) const
{
    TSignedSeqPos start = GetStart(row, seg, offset);
    if (start > -1) {
        return TSignedRange(start, start + GetSeqLen(row, seg, offset) - 1);
    } else {
        return TSignedRange(-1, -1);
    }
}


inline
TSeqPos CAlnMap::GetSeqStart(TNumrow row) const
{
    return 
        m_Starts[(IsPositiveStrand(row) ?
                  x_GetSeqLeftSeg(row) :
                  x_GetSeqRightSeg(row)) * m_NumRows + row];
}


inline
TSeqPos CAlnMap::GetSeqStop(TNumrow row) const
{
    const TNumseg& seg = IsPositiveStrand(row) ?
        x_GetSeqRightSeg(row) : x_GetSeqLeftSeg(row);
    return m_Starts[seg * m_NumRows + row] + x_GetLen(row, seg) - 1;
}


inline
CAlnMap::TRange CAlnMap::GetSeqRange(TNumrow row) const
{
    return TRange(GetSeqStart(row), GetSeqStop(row));
}


inline
CAlnMap::TSignedRange CAlnMap::GetSeqAlnRange(TNumrow row) const
{
    return TSignedRange(GetSeqAlnStart(row), GetSeqAlnStop(row));
}


inline
TSeqPos CAlnMap::GetInsertedSeqLengthOnRight(TNumrow row, TNumseg seg) const
{
    return (IsPositiveStrand(row) ?
            GetStop(row, seg+1) - GetStart(row, seg) :
            GetStart(row, seg+1) - GetStop(row, seg));
}


inline 
CAlnMap::TSegTypeFlags 
CAlnMap::x_GetRawSegType(TNumrow row, TNumseg seg) const
{
    TSegTypeFlags type;
    if (m_RawSegTypes &&
        (type = (*m_RawSegTypes)[row + m_NumRows * seg]) & fTypeIsSet) {
        return type & (~ fTypeIsSet);
    } else {
        return x_SetRawSegType(row, seg);
    }
}

inline
bool CAlnMap::IsTypeInsert(TSegTypeFlags type)
{
    return (type & fInsert) == fInsert;
}

inline 
CAlnMap::TSegTypeFlags 
CAlnMap::GetTypeAtAlnPos(TNumrow row, TSeqPos aln_pos) const
{
    return GetSegType(row, GetSeg(aln_pos));
}


///////////////////////////////////////////////////////////
////////////////// end of inline methods //////////////////
///////////////////////////////////////////////////////////


END_objects_SCOPE // namespace ncbi::objects::

END_NCBI_SCOPE

/*
* ===========================================================================
*
* $Log: alnmap.hpp,v $
* Revision 1000.1  2004/04/12 17:34:39  gouriano
* PRODUCTION: UPGRADED [CATCHUP_003] Dev-tree R1.35
*
* Revision 1.35  2004/03/03 20:33:27  todorov
* +comments
*
* Revision 1.34  2004/03/03 19:39:43  todorov
* +GetResidueIndexMap
*
* Revision 1.33  2004/01/21 20:59:42  todorov
* fDoNotTruncate -> fDoNotTruncateSegs; +comments
*
* Revision 1.32  2004/01/21 20:53:44  todorov
* EGetChunkFlags += fDoNotTruncate
*
* Revision 1.31  2003/12/31 17:26:18  todorov
* +fIgnoreAnchore usage comment
*
* Revision 1.30  2003/09/18 23:05:11  todorov
* Optimized GetSeqAln{Start,Stop}
*
* Revision 1.29  2003/09/09 19:42:37  dicuccio
* Fixed thinko in GetWidth() - properly order ternary operator
*
* Revision 1.28  2003/09/08 19:49:19  todorov
* signed vs unsigned warnings fixed
*
* Revision 1.27  2003/08/29 18:17:17  dicuccio
* Minor change in specification of default parameters - rely only on prameters,
* not on member variables
*
* Revision 1.26  2003/08/25 16:35:06  todorov
* exposed GetWidth
*
* Revision 1.25  2003/08/20 14:35:14  todorov
* Support for NA2AA Densegs
*
* Revision 1.24  2003/07/17 22:46:56  todorov
* name change +TSeqPosList
*
* Revision 1.23  2003/07/08 20:26:28  todorov
* Created seq end segments cache
*
* Revision 1.22  2003/06/05 19:03:29  todorov
* Added const refs to Dense-seg members as a speed optimization
*
* Revision 1.21  2003/06/02 16:01:38  dicuccio
* Rearranged include/objects/ subtree.  This includes the following shifts:
*     - include/objects/alnmgr --> include/objtools/alnmgr
*     - include/objects/cddalignview --> include/objtools/cddalignview
*     - include/objects/flat --> include/objtools/flat
*     - include/objects/objmgr/ --> include/objmgr/
*     - include/objects/util/ --> include/objmgr/util/
*     - include/objects/validator --> include/objtools/validator
*
* Revision 1.20  2003/05/23 18:10:38  todorov
* +fChunkSameAsSeg
*
* Revision 1.19  2003/03/20 16:37:14  todorov
* +fIgnoreGaps for GetXXXChunksalnmap.cpp
*
* Revision 1.18  2003/03/07 17:30:14  todorov
* + ESearchDirection dir, bool try_reverse_dir for GetAlnPosFromSeqPos
*
* Revision 1.17  2003/03/04 16:18:58  todorov
* Added advance search options for GetRawSeg
*
* Revision 1.16  2003/01/15 18:48:36  todorov
* Added GetSeqChunks to be used with native seq range
*
* Revision 1.15  2003/01/09 22:08:11  todorov
* Changed the default TGetChunkFlags for consistency
*
* Revision 1.14  2003/01/07 23:02:48  todorov
* Fixed EGetChunkFlags
*
* Revision 1.13  2002/12/26 12:38:08  dicuccio
* Added Win32 export specifiers
*
* Revision 1.12  2002/10/21 19:14:36  todorov
* reworked aln chunks: now supporting more types; added chunk aln coords
*
* Revision 1.10  2002/10/04 17:05:31  todorov
* Added GetTypeAtAlnPos method
*
* Revision 1.8  2002/09/27 16:58:21  todorov
* changed order of params for GetSeqPosFrom{Seq,Aln}Pos
*
* Revision 1.7  2002/09/27 02:26:32  ucko
* Remove static from the definition of CAlnMap::IsTypeInsert, as
* (like virtual) it should appear only on the initial declaration.
*
* Revision 1.6  2002/09/26 18:43:11  todorov
* Added a static method for convenient check for an insert
*
* Revision 1.5  2002/09/26 17:40:42  todorov
* Changed flag fAlignedToSeqOnAnchor to fNotAlignedToSeqOnAnchor. This proved more convenient.
*
* Revision 1.4  2002/09/25 18:16:26  dicuccio
* Reworked computation of consensus sequence - this is now stored directly
* in the underlying CDense_seg
* Added exception class; currently used only on access of non-existent
* consensus.
*
* Revision 1.3  2002/09/05 19:31:18  dicuccio
* - added ability to reference a consensus sequence for a given alignment
* - added caching of CSeqVector (big performance win)
* - many small bugs fixed
*
* Revision 1.2  2002/08/23 16:05:09  ucko
* Kludge friendship for MSVC.  (Sigh.)
*
* Revision 1.1  2002/08/23 14:43:50  ucko
* Add the new C++ alignment manager to the public tree (thanks, Kamen!)
*
*
* ===========================================================================
*/

#endif // OBJECTS_ALNMGR___ALNMAP__HPP