anchor_constraints.hh

#ifndef LOCARNA_ANCHOR_CONSTRAINTS_HH
#define LOCARNA_ANCHOR_CONSTRAINTS_HH

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

#include <string>
#include <vector>
#include <map>

#include <exception>

#include <iosfwd>

//#include "aux.hh"

namespace LocARNA {
    

    class AnchorConstraints {
    public:
        typedef size_t size_type; 
        typedef std::pair<size_type,size_type> size_pair_t;  

        typedef size_pair_t range_t; 
        typedef std::vector<range_t> range_seq_t; 
    
    private:
        typedef std::map<std::string,size_type> name_tab_t;
    
        typedef std::vector<int> seq_t;

        typedef std::vector<std::string> name_seq_t;

        seq_t a;
    
        seq_t b;

        range_seq_t ar;

        name_seq_t names_a;
        name_seq_t names_b;
    
        size_type name_size_;
    
    public:
        // ------------------------------------------------------------
        // constructors

        AnchorConstraints(size_type lenA, 
                          const std::vector<std::string> &seqCA,
                          size_type lenB,
                          const std::vector<std::string> &seqCB);
    
        AnchorConstraints(size_type lenA,
                          const std::string &seqCA,
                          size_type lenB,
                          const std::string &seqCB);
        
        // -----------------------------------------------------------
        // asking for constraint information
    
        bool
        allowed_edge(size_type i, size_type j) const {
            return
                ar[i].first <= j 
                && j <= ar[i].second;
        }

        int
        match_to_a(size_type i) const {
            return a[i];
        }
    
        int
        match_to_b(size_type i) const {
            return b[i];
        }
    
        bool
        aligned_in_a(size_type i) const {
            return match_to_a(i)>0;
        }
    
        bool
        aligned_in_b(size_type j) const {
            return match_to_b(j)>0;
        }
    
        std::string
        get_name_a(size_type i) const {return names_a[i];}
    
        std::string
        get_name_b(size_type j) const {return names_b[j];}

        size_type
        name_size() const {return name_size_;};

        bool
        empty() const {return name_size()==0;}
    
        size_pair_t rightmost_anchor() const {
            for (size_type i=a.size(); i>1; ) { // for i=lenA downto 1
                --i;
                if (a[i]>0) return size_pair_t(i,a[i]);
            }
            return size_pair_t(0,0);
        }

        size_pair_t leftmost_anchor() const {
            for (size_type i=0; i<a.size(); i++) {
                if (a[i]>0) return size_pair_t(i,a[i]);
            }
            return size_pair_t(a.size()+1,b.size()+1);
        }

    private:
        // ------------------------------------------------------------
        // construction helper
    
    
        static
        void
        transform_input(name_tab_t &nameTab,
                        size_type len,
                        const std::vector<std::string> &seq);

        void
        init_tables(const name_tab_t &nameTabA,
                    const name_tab_t &nameTabB);

        static
        void
        init_seq_table(seq_t & seq_tab,
                       name_seq_t & name_seq_tab,
                       const name_tab_t &nameTabA,
                       const name_tab_t &nameTabB);

        static
        bool
        only_dont_care(const std::string &s);
    };

}

#endif // LOCARNA_ANCHOR_CONSTRAINTS_HH