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>
 
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; 
 
        // ------------------------------------------------------------
        // constructors
 
        AnchorConstraints(size_type lenA,
                          std::vector<std::string> seqCA,
                          size_type lenB,
                          std::vector<std::string> seqCB,
                          bool strict);
 
        AnchorConstraints(size_type lenA,
                          const std::string &seqCA,
                          size_type lenB,
                          const std::string &seqCB,
                          bool strict);
 
        // -----------------------------------------------------------
        // asking for constraint information
 
        bool
        allowed_match(size_type i, size_type j) const {
            assert(i >= 1);
            assert(i < ar_.size());
            return ar_[i].first <= j && j <= ar_[i].second;
        }
 
        bool
        allowed_del_unopt(size_type i, size_type j) const {
            assert(i<=lenA_);
            assert(j<=lenB_);
 
            if (is_anchored_a(i)) return false;
 
            if (strict_) {
                size_type i0 = max_named_leq_a_[i];
                size_type j0 = min_named_geq_b_[j+1];
                size_type i1 = min_named_geq_a_[i];
                size_type j1 = max_named_leq_b_[j];
 
                return
                    names_a_[ i0 ] < names_b_[ j0 ]
                    &&
                    names_a_[ i1 ] > names_b_[ j1 ];
            } else {
                return !conflicts_anchor(i,j);
            }
        }
 
        bool
        allowed_del(size_type i, size_type j) const {
            assert(1<=i); assert(i<=lenA_);
            assert(j<=lenB_);
            return adr_[i].first<=j && j<=adr_[i].second;
        }
 
        bool
        allowed_ins_unopt(size_type i, size_type j) const {
            assert(i<=lenA_);
            assert(j<=lenB_);
 
            if (is_anchored_b(j)) return false;
 
            if (strict_) {
                size_type i0 = max_named_leq_a_[i];
                size_type j0 = min_named_geq_b_[j];
                size_type i1 = min_named_geq_a_[i+1];
                size_type j1 = max_named_leq_b_[j];
 
                return
                    names_a_[ i0 ] < names_b_[ j0 ]
                    &&
                    names_a_[ i1 ] > names_b_[ j1 ];
            } else {
                return !conflicts_anchor(i,j);
            }
        }
 
        bool
        allowed_ins(size_type i, size_type j) const {
            assert(i<=lenA_);
            assert(1<=j); assert(j<=lenB_);
            return air_[j].first<=i && i<=air_[j].second;
        }
 
        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 = lenA_; i >= 1; --i) {
                if (anchors_a_[i] > 0)
                    return size_pair_t(i, anchors_a_[i]);
            }
            return size_pair_t(0, 0);
        }
 
        size_pair_t
        leftmost_anchor() const {
            for (size_type i = 0; i <= lenA_; i++) {
                if (anchors_a_[i] > 0)
                    return size_pair_t(i, anchors_a_[i]);
            }
            return size_pair_t(lenA_ + 1, lenB_ + 1);
        }
 
        bool
        is_anchored_a(size_type i) const {
            return is_anchored(lenA_,anchors_a_,i);
        };
 
        bool
        is_anchored_b(size_type i) const {
            return is_anchored(lenB_,anchors_b_,i);
        };
 
        bool
        is_named_a(size_type i) const {
            return is_named(lenA_,anchors_a_,i);
        };
 
        bool
        is_named_b(size_type i) const {
            return is_named(lenB_,anchors_b_,i);
        };
 
 
        void
        print_debug();
 
    private:
        typedef std::map<std::string, size_type> name_tab_t;
        typedef std::vector<int> int_vec_t;
        typedef std::vector<size_type> size_vec_t;
        typedef std::vector<std::string> name_vec_t;
        typedef std::vector<range_t> range_vec_t; 
 
        const bool strict_;
 
        size_type lenA_;
 
        size_type lenB_;
 
        int_vec_t anchors_a_;
 
        int_vec_t anchors_b_;
 
        range_vec_t ar_;
 
        range_vec_t adr_;
        range_vec_t air_;
 
        name_vec_t names_a_;
        name_vec_t names_b_;
 
        size_type name_size_;
 
        size_vec_t max_anchored_left_a_;
 
        size_vec_t min_anchored_right_a_;
 
        size_vec_t max_named_leq_a_;
 
        size_vec_t min_named_geq_a_;
 
        size_vec_t max_anchored_left_b_;
 
        size_vec_t min_anchored_right_b_;
 
        size_vec_t max_named_leq_b_;
 
        size_vec_t min_named_geq_b_;
 
        static
        bool
        is_named(size_type len, const int_vec_t &anchors, size_type i) {
            assert(i<=len+1);
            return i==0 || i==len+1 || anchors[i]!=0;
        };
 
 
        static
        bool
        is_anchored(size_type len, const int_vec_t &anchors, size_type i) {
            assert(i<=len);
            return i==0 || i==len+1 || anchors[i]>0;
        }
 
        bool
        conflicts_anchor(size_type i, size_type j) const {
            return
                !(static_cast<size_type>(anchors_a_[ max_anchored_left_a_[i] ]) < j
                  &&
                  j < static_cast<size_type>(anchors_a_[ min_anchored_right_a_[i] ])) ;
        }
 
        bool
        is_anchor(size_type i, size_type j) const {
            return is_named_a(i) && static_cast<size_type>(anchors_a_[i]) == j;
        }
 
        // ------------------------------------------------------------
        // construction helper
 
        static void
        transform_input(name_tab_t &nameTab,
                        size_type len,
                        const std::vector<std::string> &seq,
                        bool strict);
 
        void
        init_tables(const name_tab_t &nameTabA, const name_tab_t &nameTabB);
 
        void static init_anchored_tables(size_type len,
                                         const int_vec_t &anchors,
                                         size_vec_t &max_anchored_left,
                                         size_vec_t &min_anchored_right);
 
        void static init_named_tables(size_type len,
                                      const int_vec_t &anchors,
                                      size_vec_t &max_named_leq,
                                      size_vec_t &min_named_geq);
 
        static void
        init_anchors(int_vec_t &seq_tab,
                       name_vec_t &name_vec_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