include/objects/seqalign/Seq_align.hpp

Go to the documentation of this file.

/* $Id: Seq_align.hpp 169611 2009-09-01 16:21:07Z dicuccio $
 * ===========================================================================
 *
 *                            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:  .......
 *
 * File Description:
 *   .......
 *
 * Remark:
 *   This code was originally generated by application DATATOOL
 *   using specifications from the data definition file
 *   'seqalign.asn'.
 */

#ifndef OBJECTS_SEQALIGN_SEQ_ALIGN_HPP
#define OBJECTS_SEQALIGN_SEQ_ALIGN_HPP


// generated includes
#include <objects/seqalign/Seq_align_.hpp>
#include <objects/seqloc/Na_strand.hpp>
#include <util/range.hpp>

// generated classes

BEGIN_NCBI_SCOPE

BEGIN_objects_SCOPE /// namespace ncbi::objects::

class CSeq_id;

class  CSeq_align : public CSeq_align_Base
{
    typedef CSeq_align_Base Tparent;
public:
    /// enum controlling known named scores
    enum EScoreType {
        //< generic 'score'
        eScore_Score,

        //< blast-style 'bit_score'
        eScore_BitScore,

        //< blast-style 'e_value'
        eScore_EValue,

        //< count of identities (num_ident)
        eScore_IdentityCount,

        //< count of mismatches (num_mismatch)
        eScore_MismatchCount,

        //< percent identity (0.0-100.0) (pct_identity)
        eScore_PercentIdentity,

        //< percent coverage (0.0-100.0) (pct_coverage)
        eScore_PercentCoverage,

        //< blast-style 'sum_e'
        eScore_SumEValue,

        //< Composition-adjustment method from BLAST (comp_adjustment_method)
        eScore_CompAdjMethod
    };

    /// constructor
    CSeq_align(void);
    /// destructor
    ~CSeq_align(void);

    /// Validatiors
    TDim CheckNumRows(void)                   const;
    void Validate    (bool full_test = false) const;

    /// GetSeqRange
    /// NB: On a Spliced-seg, in case the product-type is protein,
    /// these only return the amin part of Prot-pos.  The frame is
    /// ignored.
    CRange<TSeqPos> GetSeqRange(TDim row) const;
    TSeqPos         GetSeqStart(TDim row) const;
    TSeqPos         GetSeqStop (TDim row) const;

    /// Retrieves the total number of gaps in an alignment
    /// @throws CSeqalignException if alignment type is not supported
    TSeqPos         GetTotalGapCount() const;

    /// Retrieves the number of gap openings in an alignment (ignoring how many
    /// gaps are in the gapped region)
    /// @throws CSeqalignException if alignment type is not supported
    TSeqPos         GetNumGapOpenings() const;

    /// Get strand (the first one if segments have different strands).
    ENa_strand      GetSeqStrand(TDim row) const;

    /// Get seq-id (the first one if segments have different ids).
    /// Throw exception if row is invalid.
    const CSeq_id&  GetSeq_id(TDim row) const;

    /// Get score
    bool GetNamedScore(const string& id, int &score) const;
    bool GetNamedScore(const string& id, double &score) const;

    bool GetNamedScore(EScoreType type, int &score) const;
    bool GetNamedScore(EScoreType type, double &score) const;

    void SetNamedScore(const string& id, int score);
    void SetNamedScore(const string& id, double score);

    void SetNamedScore(EScoreType type, int score);
    void SetNamedScore(EScoreType type, double score);


    /// Reverse the segments' orientation
    /// NOTE: currently *only* works for dense-seg
    void Reverse(void);

    /// Swap the position of two rows in the alignment
    /// NOTE: currently *only* works for dense-seg & disc
    void SwapRows(TDim row1, TDim row2);

    /// Create a Dense-seg from a Std-seg
    /// Used by AlnMgr to handle nucl2prot alignments
    //

    /// NOTE: Here we assume that the same rows on different segments
    /// contain the same sequence. Without access to OM we can only check
    /// if the ids are the same via SerialEquals, and we throw an exception
    /// if not equal. Since the same sequence can be represented with a 
    /// different type of seq-id, we provide an optional callback mechanism
    /// to compare id1 and id2, and if both resolve to the same sequence 
    /// and id2 is preferred, to SerialAssign it to id1. Otherwise, again,
    /// an exception should be thrown.
    struct SSeqIdChooser : CObject
    {
        virtual void ChooseSeqId(CSeq_id& id1, const CSeq_id& id2) = 0;
    };
    CRef<CSeq_align> CreateDensegFromStdseg(SSeqIdChooser* SeqIdChooser = 0) const;

    CRef<CSeq_align> CreateDensegFromDisc(SSeqIdChooser* SeqIdChooser = 0) const;

    /// Create a Dense-seg with widths from Dense-seg of nucleotides
    /// Used by AlnMgr to handle translated nucl2nucl alignments
    /// IMPORTANT NOTE: Do *NOT* use for alignments containing proteins;
    ///                 the code will not check for this
    CRef<CSeq_align> CreateTranslatedDensegFromNADenseg(void) const;


    /// Offset row's coords
    void OffsetRow(TDim row, TSignedSeqPos offset);

    /// @deprecated (use sequence::RemapAlignToLoc())
    /// @sa RemapAlignToLoc
    NCBI_DEPRECATED void RemapToLoc(TDim row,
                                    const CSeq_loc& dst_loc,
                                    bool ignore_strand = false);

protected:
    /// retrieve a named score object
    CConstRef<CScore> x_GetNamedScore(const string& name) const;
    CRef<CScore>      x_SetNamedScore(const string& name);

private:
    /// Prohibit copy constructor and assignment operator
    CSeq_align(const CSeq_align& value);
    CSeq_align& operator=(const CSeq_align& value);

};


/// Remap seq-align row to the seq-loc.
/// Treats the given row as being relative to the location, maps it
/// to the sequence(s) referenced by this location.
/// @param align
///   The seq-align object to be mapped (the object will be modified!).
/// @param row
///   Row to be mapped.
/// @param loc
///   Seq-loc to which the row should be mapped.
/// @result
///   Reference to the new seq-align with the mapped row.

CRef<CSeq_align> RemapAlignToLoc(const CSeq_align& align,
                                 CSeq_align::TDim  row,
                                 const CSeq_loc&   loc);


/////////////////// CSeq_align inline methods

// constructor
inline
CSeq_align::CSeq_align(void)
{
}


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


END_objects_SCOPE /// namespace ncbi::objects::

END_NCBI_SCOPE

#endif /// OBJECTS_SEQALIGN_SEQ_ALIGN_HPP
/* Original file checksum: lines: 93, chars: 2426, CRC32: 6ba198f0 */

---