base_pair_filter.hh

#ifndef LOCARNA_BASE_PAIR_FILTER
#define LOCARNA_BASE_PAIR_FILTER
 
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
 
namespace LocARNA {
    namespace BasePairFilter {
 
        typedef std::pair<size_t, size_t> bp_t;
 
        class Filter {
        public:
            Filter(){};
 
            virtual ~Filter(){};
 
            virtual bool
            operator()(size_t i, size_t j) const {
                assert(1 <= i); // sequences are 1-based
                assert(i <= j);
                return true;
            }
 
            virtual bool
            operator()(const bp_t &bp) const {
                return (*this)(bp.first, bp.second);
            }
        };
 
        class BPMinLoopSize : public Filter {
            size_t mls_;
 
        public:
            explicit BPMinLoopSize(size_t mls) : Filter(), mls_(mls) {}
 
            ~BPMinLoopSize(){};
 
            bool
            operator()(size_t i, size_t j) const {
                assert(i >= 1);
                return i + mls_ < j;
            }
        };
 
        class SpanRange : public Filter {
            size_t lo_;
            size_t up_;
 
        public:
            SpanRange(size_t lo, size_t up) : Filter(), lo_(lo), up_(up) {}
 
            ~SpanRange(){};
 
            bool
            operator()(size_t i, size_t j) const {
                assert(i <= j);
                return lo_ <= (j - i + 1) && (up_ == 0 || (j - i + 1) <= up_);
            }
        };
 
        class Canonical : public Filter {
            const std::string &sequence_;
 
        public:
            explicit Canonical(const std::string &sequence)
                : Filter(), sequence_(sequence) {}
 
            ~Canonical(){};
 
            bool
            operator()(size_t i, size_t j) const {
                return Filter::operator()(i, j) &&
                    canonical(sequence_[i], sequence_[j]);
            }
 
        private:
            static bool
            canonical(char x, char y) {
                static std::string cpairs = "AUCGGUUAGCUG";
                for (size_t i = 0; i < cpairs.length(); i += 2) {
                    if (x == cpairs[i] && y == cpairs[i + 1])
                        return true;
                }
                return false;
            }
        };
 
        class Combined : public Filter {
            const Filter &fa_;
            const Filter &fb_;
 
        public:
            Combined(const Filter &fa, const Filter &fb)
                : Filter(), fa_(fa), fb_(fb) {}
 
            ~Combined() {}
 
            bool
            operator()(size_t i, size_t j) const {
                return fa_(i, j) && fb_(i, j);
            }
        };
 
    } // end namespace BasePairFilter
} // end namespace LocARNA
 
#endif // LOCARNA_BASE_PAIR_FILTER