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;
 
        RnaStructure(size_t length = 0) : length_(length), 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;
 
        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);
 
    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_);
        }
 
        std::string
        to_string(const bps_t &bps) const;
 
    }; // end class RnaStructure
 
    std::ostream &
    operator<<(std::ostream &out, const RnaStructure &structure);
 
} // end namespace LocARNA
 
#endif