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 TraceProbs;
 
    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);
 
        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 {
            assert(min_col_.size()>0);
            return min_col_.size() - 1;
        }
 
        size_t
        min_col(size_t i) const {
            assert(i>=0);
            assert(i<min_col_.size());
            return min_col_[i];
        }
 
        size_t
        max_col(size_t i) const {
            assert(i>=0);
            assert(i<max_col_.size());
            return max_col_[i];
        }
 
        TraceRange
        reverse() const;
 
        void
        print_debug(std::ostream &out=std::cerr) const;
 
    protected:
        TraceRange(size_t lenA, size_t lenB)
            : lenA_(lenA),
              lenB_(lenB)
        {}
 
        size_t lenA_; 
        size_t lenB_; 
 
        using idx_vec_t = std::vector<size_t>;
        idx_vec_t min_col_; 
        idx_vec_t max_col_; 
    };
 
    class MatchController {
    public:
        virtual bool
        is_valid_match(size_t i, size_t j) const = 0;
 
        virtual ~MatchController();
    };
 
    class TraceController : public TraceRange, public MatchController {
    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);
 
        void
        restrict_by_trace_probabilities(const TraceProbs &trace_probs,
                                        double min_prob);
 
        TraceController
        reverse() const;
 
        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:
        // 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_;
 
        TraceController(TraceRange &&trace_range, size_type delta)
            : TraceRange(trace_range), delta_(delta) {}
 
        // /**
        //  * switch between strict and relaxed merging of pairwise trace
        //  * ranges
        //  */
        // const bool relaxed_merging_;
 
        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 */