src/LocARNA/rna_structure.hh

#ifndef LOCARNA_RNA_STRUCTURE_HH
#define LOCARNA_RNA_STRUCTURE_HH

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <assert.h>
#include <set>
#include <string>
#include <ostream>

namespace LocARNA {

    namespace BasePairFilter {
        class Filter;
    }

    class RnaStructure {
    public:
        typedef std::pair<size_t, size_t> bp_t;

        typedef std::set<bp_t, std::less<bp_t> > bps_t;

    private:
        size_t length_;
        bps_t bps_;

        static const char unpaired_symbol_ = '.';
        static const std::string open_symbols_;
        static const std::string close_symbols_;

        bool
        parse(const std::string &s, bps_t &bps, char op, char cl);

        bool
        parse(const std::string &s,
              bps_t &bps,
              const std::string &op_syms,
              const std::string &cl_syms);

        void
        assert_valid_bp(const bp_t &bp) {
            assert(1 <= bp.first);
            assert(bp.first < bp.second);
            assert(bp.second <= length_);
        }

    public:
        RnaStructure() : length_(0), bps_() {}

        explicit RnaStructure(const std::string &structure);

        bool
        operator==(const RnaStructure &s) const {
            return this->length_ == s.length_ && this->bps_ == s.bps_;
        }

        bool
        contains(const bp_t &x) const {
            return bps_.find(x) != bps_.end();
        }

        size_t
        length() const {
            return length_;
        }

        size_t
        size() const {
            return bps_.size();
        }

        void
        insert(const bp_t &bp) {
            assert_valid_bp(bp);
            bps_.insert(bp);
        }

        void
        remove(const bp_t &bp) {
            assert_valid_bp(bp);
            bps_.erase(bp);
        }

        void
        clear() {
            bps_.clear();
        }

        // This is not well supported by the current structure
        // represenation. Therefore, we don't offer such functionality.
        // /**
        //  * @brief Check whether a loop contains a position
        //  *
        //  * @param k position
        //  * @param x loop; (0,length+1) means external loop
        //  *
        //  * @return whether the loop enclosed by x contains k
        //  *
        //  * Definition: the loop enclosed by (i,j) contains k iff i<k<j
        //  * and there is no base pair (i',j') in the structure, where
        //  * i<i'<k<j'<j. Note that we don't require (i,j) to be element
        //  * of the structure.
        //  *
        //  * k can be member of more than one loop unless nested().
        //  */
        // bp_t
        // in_loop_of(size_t k, bp_t x) const;

        // support contant iteration over base pair set

        typedef bps_t::const_iterator const_iterator;

        const_iterator
        begin() const {
            return bps_.begin();
        }

        const_iterator
        end() const {
            return bps_.end();
        }

        std::string
        to_string() const;

    private:
        std::string
        to_string(const bps_t &bps) const;

    public:
        static bool
        empty(const bps_t &bps);

        bool
        empty() const {
            return empty(bps_);
        }

        static bool
        nested(const bps_t &bps);

        bool
        nested() const {
            return nested(bps_);
        }

        static bool
        crossing(const bps_t &bps);

        bool
        crossing() const {
            return crossing(bps_);
        }

        // base pair filter operations

        void
        remove_lonely_pairs();

        void
        apply_bpfilter(const BasePairFilter::Filter &filter);

    }; // end class RnaStructure

    std::ostream &
    operator<<(std::ostream &out, const RnaStructure &structure);

} // end namespace LocARNA

#endif