src/LocARNA/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