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 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_vector_; 
        std::vector<size_t> max_col_vector_; 
        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_vector_.size()-1;}
        
        size_t
        min_col(size_t i) const {return min_col_vector_[i];}
        
        size_t 
        max_col(size_t i) const {return max_col_vector_[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();
        
        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_;}

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

    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 */