src/LocARNA/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,
                          const std::vector<std::string> &seqCA,
                          size_type lenB,
                          const 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