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>

namespace LocARNA {
    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_);}
        
    }; // end class RnaStructure


} // end namespace LocARNA

#endif