alignment.hh

#ifndef LOCARNA_ALIGNMENT_HH
#define LOCARNA_ALIGNMENT_HH

#ifdef HAVE_CONFIG_H
#  include <config.h>
#endif

#include <iosfwd>
#include <vector>
#include "aux.hh"
#include "scoring_fwd.hh"

namespace LocARNA {
    
    class AlignmentImpl;    
    class RnaData;
    class Sequence;
    class RnaStructure;
    class string1;
    class AnchorConstraints;
    
    // unnest definitions of alignment edges

    class EdgeEnd {
        int end_; //<! position or Gap
    public:
        
        EdgeEnd(): end_(0) {}
            
        EdgeEnd(pos_type end): end_(int(end)) {}
        
        EdgeEnd(Gap end): end_(-int(end.idx())-1) {}
            
        bool is_gap() const {return end_<0;}
            
        bool is_pos() const {return end_>0;}

        Gap gap() const {assert(end_<0); return Gap(size_t(-(end_+1)));}

        operator pos_type() const {assert(end_>0); return pos_type(end_);}
    };
    
    typedef std::vector<EdgeEnd> Alignment__edge_ends_t;
        
    class AlignmentEdges : public std::pair<Alignment__edge_ends_t,Alignment__edge_ends_t> {
        typedef Alignment__edge_ends_t edge_ends_t;
        typedef std::pair<edge_ends_t,edge_ends_t> parent_t;
    public:
        
        AlignmentEdges(const edge_ends_t &x,
                       const edge_ends_t &y) 
            :parent_t(x,y)
        {
            assert(x.size()==y.size());
        };
        
        size_t
        size() const {return first.size();}
    };


    class Alignment {
        
        AlignmentImpl *pimpl_; 
        
    public:
        
        typedef EdgeEnd edge_end_t;
        
        typedef Alignment__edge_ends_t edge_ends_t;
        
        typedef AlignmentEdges edges_t;
        

        static 
        edge_ends_t 
        alistr_to_edge_ends(const std::string &alistr);
        
        
        Alignment(const Sequence &seqA,const Sequence &seqB);

        ~Alignment();

        Alignment(const Sequence &seqA, const Sequence &seqB,
                  const edges_t &edges);

        Alignment(const Alignment &alignment);
        
        Alignment &operator =(const Alignment &alignment);

        void
        swap(Alignment &a1,Alignment &a2);
    
        
        void
        set_consensus_structure(const RnaStructure &structure);

        void
        set_structures(const RnaStructure &structureA,const RnaStructure &structureB);
        
        void 
        clear();

        void
        append(edge_end_t i, edge_end_t j);
        
        void
        add_basepairA(int i, int j);

        void
        add_basepairB(int i, int j);

        
        void add_deleted_basepairA(int i, int j);
        void add_deleted_basepairB(int i, int j);

        const edges_t
        alignment_edges(bool only_local) const;
        
        /* start/end of (locally) aligned subsequences 
           (this is used when finding k-best alignments in Aligner)
         */
        
        size_type
        local_startA() const;
    
        size_type
        local_endA() const;

        size_type
        local_startB() const;
        
        size_type
        local_endB() const;


        std::string
        dot_bracket_structureA(bool only_local) const;

        std::string
        dot_bracket_structureB(bool only_local) const;


        /* access */
    
        const Sequence &seqA() const;

        const Sequence &seqB() const;
        
    };
    

}
#endif