basepairs.hh

#ifndef LOCARNA_BASEPAIRS_HH
#define LOCARNA_BASEPAIRS_HH
 
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
 
#include <iosfwd>
 
#include <vector>
#include <set>
#include <assert.h>
 
#include "sparse_matrix.hh"
 
namespace LocARNA {
 
    class RnaData;
    class Sequence;
 
    class BasePairs__Arc {
    private:
        size_t idx_;
        size_t left_;
        size_t right_;
 
    public:
        BasePairs__Arc(size_t idx, size_t left, size_t right)
            : idx_(idx), left_(left), right_(right) {}
 
        /*
         * @brief Virtual destructor
         */
        virtual ~BasePairs__Arc();
 
        size_t
        left() const {
            return left_;
        }
 
        size_t
        right() const {
            return right_;
        }
 
        size_t
        idx() const {
            return idx_;
        }
    };
 
    // ============================================================
    class BasePairs {
    public:
        typedef size_t size_type; 
 
        typedef BasePairs__Arc Arc; 
 
        class LeftAdjEntry : public Arc {
        public:
            explicit LeftAdjEntry(const Arc &a) : Arc(a) {}
        };
 
        class RightAdjEntry : public Arc {
        public:
            explicit RightAdjEntry(const Arc &a) : Arc(a) {}
        };
 
        typedef std::vector<Arc> arc_vec_t;
 
        /* types for data structures for the access of an arc in the structure,
           by its right end, its left end, or left and right end
 
           the access structure is implemented as a hash map,
        */
 
        typedef std::vector<LeftAdjEntry> LeftAdjList;
 
        typedef std::vector<RightAdjEntry> RightAdjList;
 
        typedef SparseMatrix<int> arc_matrix_t;
 
        typedef std::pair<size_type, size_type> bpair_t;
 
        typedef std::set<bpair_t> bpair_set_t;
 
        BasePairs(const RnaData *rna_data, double min_prob);
 
        BasePairs(size_type len, const bpair_set_t &bps);
 
        void
        register_arc(int i, int j);
 
        const LeftAdjList &
        left_adjlist_s(size_type i) const {
            auto & xs = left_adjlists_[i];
            assert(xs[xs.size() - 1].right() == len_+1 /* check sentinel */);
            return xs;
        }
 
        const RightAdjList &
        right_adjlist_s(size_type i) const {
            auto & xs = right_adjlists_[i];
            assert(xs[xs.size() - 1].left() == 0  /* check sentinel */);
            return xs;
        }
 
        const Arc &
        arc(int i, int j) const {
            return arc_vec_[arcs_(i, j)];
        }
 
        const Arc &
        arc(size_type idx) const {
            assert(idx < arc_vec_.size());
            return arc_vec_[idx];
        }
 
        bool
        exists_arc(int i, int j) const {
            return -1 != arcs_(i, j);
        }
 
        size_type
        num_bps() const {
            return arc_vec_.size();
        }
 
        size_type
        seqlen() const;
 
        double
        prob_min() const; 
 
        // /**
        //  * @brief Access to corresponding RnaData object
        //  *
        //  * @return reference to RnaData object
        //  */
        // const RnaData &
        // get_rna_data() const {
        //     assert(rna_data_!=NULL);
        //     return *rna_data_;
        // }
 
    private:
        const RnaData *rna_data_;
        double min_prob_;
        double len_;
 
        std::vector<LeftAdjList> left_adjlists_;
        std::vector<RightAdjList> right_adjlists_;
 
        arc_vec_t arc_vec_;
        arc_matrix_t arcs_;
 
        void
        resize(size_type seq_len);
 
        void
        generateBPLists(const RnaData &rna_data);
 
        void
        sort_adj_lists();
 
        void
        add_adj_list_sentinels();
    };
 
    std::ostream &
    operator<<(std::ostream &out, const BasePairs::Arc &arc);
}
#endif