src/LocARNA/trace_controller.hh

#ifndef LOCARNA_TRACE_CONTROLLER_HH
#define LOCARNA_TRACE_CONTROLLER_HH

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

#include <vector>
#include <assert.h>

#include "aux.hh"
#include "multiple_alignment.hh"

namespace LocARNA {

    class Sequence;
    class AnchorConstraints;

    class TraceRange {
    public:
        typedef MultipleAlignment::SeqEntry SeqEntry;

        typedef std::pair<SeqEntry, SeqEntry> seqentry_pair_t;

        static seqentry_pair_t
        remove_common_gaps(const SeqEntry &aliA, const SeqEntry &aliB);

    protected:
        std::vector<size_t> min_col_; 
        std::vector<size_t> max_col_; 

        TraceRange() {}

    public:
        TraceRange(const SeqEntry &pseqA,
                   const SeqEntry &pseqB,
                   const SeqEntry &aliA,
                   const SeqEntry &aliB,
                   size_type delta);

        TraceRange(size_type lenA,
                   size_type lenB,
                   const std::vector<TraceRange> &trs,
                   size_type delta);

        size_type
        consensus_cost(size_type i,
                       size_type j,
                       const std::vector<TraceRange> &trs) const;

        size_t
        rows() const {
            return min_col_.size() - 1;
        }

        size_t
        min_col(size_t i) const {
            return min_col_[i];
        }

        size_t
        max_col(size_t i) const {
            return max_col_[i];
        }

        void
        print_debug(std::ostream &out) const;
    };

    class MatchController {
    public:
        virtual bool
        is_valid_match(size_t i, size_t j) const = 0;

        virtual ~MatchController();
    };

    class TraceController : public TraceRange, public MatchController {
    private:
        // The delimiter character separating the two sequences in the alignment
        // string
        static const char delimiter = '&';

        void
        merge_in_trace_range(const TraceRange &tr);

        const size_type delta_;

        // /**
        //  * switch between strict and relaxed merging of pairwise trace
        //  * ranges
        //  */
        // const bool relaxed_merging_;

    public:
        TraceController(const Sequence &seqA,
                        const Sequence &seqB,
                        const MultipleAlignment *ma,
                        int delta,
                        bool relaxed_merging = false);

        virtual ~TraceController();

        void
        restrict_by_anchors(const AnchorConstraints &constraints);

        bool
        is_valid(size_type i, size_type j) const;

        virtual bool
        is_valid_match(size_type i, size_type j) const;

        size_type
        get_delta() const {
            return delta_;
        }

    private:
        void
        constrain_wo_ref(size_type lenA, size_type lenB, size_type delta);
    };

    inline bool
    TraceController::is_valid(size_type i, size_type j) const {
        return min_col(i) <= j && j <= max_col(i);
    }

    inline bool
    TraceController::is_valid_match(size_type i, size_type j) const {
        return is_valid(i, j) && is_valid(i - 1, j - 1);
    }

} // end namespace

#endif /* LOCARNA_TRACE_CONTROLLER_HH */