src/LocARNA/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