src/LocARNA/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 "params.hh"
#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 {
    private:
        const RnaData *rna_data_;
        double min_prob_;
        double len_;

    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;

    private:
        std::vector<LeftAdjList> left_;
        std::vector<RightAdjList> right_;

        arc_vec_t arc_vec_;
        arc_matrix_t arcs_;

        void
        resize(size_type seq_len);

        void
        generateBPLists(const RnaData &rna_data);

        void
        sortAdjLists();

    public:
        BasePairs(const RnaData *rna_data, double min_prob)
            : rna_data_(rna_data),
              min_prob_(min_prob),
              len_(get_length_from_rna_data()),
              left_(),
              right_(),
              arc_vec_(),
              arcs_(-1) {
            generateBPLists(*rna_data_);
        }

        BasePairs(size_type len, const bpair_set_t &bps)
            : rna_data_(0),
              min_prob_(1.0),
              len_(len),
              left_(),
              right_(),
              arc_vec_(),
              arcs_(-1) {
            resize(seqlen());
            for (bpair_set_t::const_iterator it = bps.begin(); bps.end() != it;
                 ++it) {
                register_arc(it->first, it->second);
            }
            sortAdjLists();
        }

        // /**
        //  * @brief Copy constructor
        //  */
        // BasePairs(const BasePairs &bps);

        // /**
        //  * @brief Assignment operator
        //  */
        // BasePairs &
        // operator =(const BasePairs &bps);

        void
        register_arc(int i, int j);

        const LeftAdjList &
        left_adjlist(int i) const {
            // std::cout<<"size of left adjlist of "<<i<<"is
            // "<<left_[i].size()<<std::endl;
            return left_[i];
        }

        const RightAdjList &
        right_adjlist(int i) const {
            return right_[i];
        }

        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:
        // return length from rna data
        // pre: rna data available
        size_type
        get_length_from_rna_data() const;
    };

    std::ostream &
    operator<<(std::ostream &out, const BasePairs::Arc &arc);
}
#endif