alignment.hh

#ifndef LOCARNA_ALIGNMENT_HH
#define LOCARNA_ALIGNMENT_HH
 
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
 
#include <iosfwd>
#include <vector>
#include <memory>
#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 {
    public:
        EdgeEnd() : end_(0) {}
 
        EdgeEnd(pos_type end) : end_(int(end)) {}
 
        EdgeEnd(Gap end) : end_(-int(end) - 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 {
            return pos_type(end_);
        }
    private:
        int end_; //<! position or Gap
    };
 
    class AlignmentEdges : public std::vector<std::pair<EdgeEnd,EdgeEnd>> {
    public:
        using edge_t = std::pair<EdgeEnd,EdgeEnd>;
    };
 
    class Alignment {
    public:
        typedef EdgeEnd edge_end_t;
 
        using edge_ends_t = std::vector<EdgeEnd>;
 
        using edge_end_pair_t = std::pair<EdgeEnd,EdgeEnd>;
        using pos_pair_t = std::pair<pos_type, pos_type>;
 
        using edges_t = AlignmentEdges;
 
        static edges_t
        alistrs_to_edges(const std::string &alistrA,
                         const std::string &alistrB);
 
        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
        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
         */
 
        pos_pair_t
        start_positions() const;
 
        pos_pair_t
        end_positions() 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;
 
        bool
        empty() const;
 
    private:
        std::unique_ptr<AlignmentImpl> pimpl_; 
 
        template <int i>
        std::string
        dot_bracket_structure(const std::string &, bool only_local) const;
    };
}
#endif