aligner_restriction.hh

#ifndef LOCARNA_ALIGNER_RESTRICTION
#define LOCARNA_ALIGNER_RESTRICTION
 
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
 
#include <iostream>
 
namespace LocARNA {
 
    class AlignerRestriction {
    private:
        int startA_; 
        int startB_; 
        int endA_;   
        int endB_;   
    public:
        AlignerRestriction(int startA, int startB, int endA, int endB)
            : startA_(startA), startB_(startB), endA_(endA), endB_(endB) {}
 
        size_t
        startA() const {
            return startA_;
        }
 
        size_t
        endA() const {
            return endA_;
        }
 
        size_t
        startB() const {
            return startB_;
        }
 
        size_t
        endB() const {
            return endB_;
        }
 
        void
        set_startA(size_t p) {
            startA_ = p;
        }
 
        void
        set_endA(size_t p) {
            endA_ = p;
        }
 
        void
        set_startB(size_t p) {
            startB_ = p;
        }
 
        void
        set_endB(size_t p) {
            endB_ = p;
        }
    };
 
    inline std::ostream &
    operator<<(std::ostream &out, const AlignerRestriction &r) {
        return out << r.startA() << " " << r.startB() << " " << r.endA() << " "
                   << r.endB();
    }
}
 
#endif