UnitigMap.hpp

Go to the documentation of this file.

#ifndef BIFROST_UNITIGMAP_HPP
#define BIFROST_UNITIGMAP_HPP
 
#include <string>
#include "Common.hpp"
#include "Kmer.hpp"
 
template<typename U> class Unitig;
template<typename U, typename G> class CompactedDBG;
template<typename U, typename G, bool is_const> class BackwardCDBG;
template<typename U, typename G, bool is_const> class ForwardCDBG;
template<typename U, typename G, bool is_const> class neighborIterator;
 
struct UnitigMapBase {
 
    UnitigMapBase(const size_t length = 1);
 
    UnitigMapBase(const size_t start, const size_t length, const size_t unitig_sz, const bool strand);
 
    bool operator==(const UnitigMapBase& o) const;
 
    bool operator!=(const UnitigMapBase& o) const;
 
    size_t dist;
    size_t len;
    size_t size;
 
    bool strand;
    bool isEmpty;
};
 
template<typename Unitig_data_t = void, typename Graph_data_t = void, bool is_const = false>
class UnitigMap : public UnitigMapBase {
 
    typedef Unitig_data_t U;
    typedef Graph_data_t G;
 
    template<typename U, typename G> friend class CompactedDBG;
    template<typename U, typename G, bool C> friend class BackwardCDBG;
    template<typename U, typename G, bool C> friend class ForwardCDBG;
    template<typename U, typename G, bool C> friend class unitigIterator;
    template<typename U, typename G, bool C> friend class UnitigMap;
 
    typedef typename std::conditional<is_const, const CompactedDBG<U, G>*, CompactedDBG<U, G>*>::type CompactedDBG_ptr_t;
    typedef typename std::conditional<is_const, const U*, U*>::type Unitig_data_ptr_t;
 
    public:
 
        typedef BackwardCDBG<U, G, is_const> UnitigMap_BW;
        typedef ForwardCDBG<U, G, is_const> UnitigMap_FW;
 
        UnitigMap(size_t length = 1, CompactedDBG_ptr_t cdbg_ = nullptr);
 
        UnitigMap(const size_t start, const size_t length, const size_t unitig_sz, const bool strand);
 
        bool operator==(const UnitigMap& o) const;
 
        bool operator!=(const UnitigMap& o) const;
 
        bool isSameReferenceUnitig(const UnitigMap& o) const;
 
        string mappedSequenceToString() const;
 
        string referenceUnitigToString() const;
 
        size_t lcp(const char* s, const size_t pos_s = 0, const size_t pos_um_seq = 0, const bool um_reversed = false) const;
 
        Kmer getUnitigHead() const;
 
        Kmer getUnitigTail() const;
 
        Kmer getUnitigKmer(const size_t pos) const;
 
        Kmer getMappedHead() const;
 
        Kmer getMappedTail() const;
 
        Kmer getMappedKmer(const size_t pos) const;
 
        UnitigMap<U, G, is_const> getKmerMapping(const size_t pos) const;
 
        Unitig_data_ptr_t getData() const;
 
        UnitigMap_BW getPredecessors() const;
 
        UnitigMap_FW getSuccessors() const;
 
        inline CompactedDBG_ptr_t getGraph() const { return cdbg; }
 
        operator UnitigMap<U, G, true>() const {
 
            UnitigMap<U, G, true> um(pos_unitig, dist, len, size, isShort, isAbundant, strand, cdbg);
 
            um.isEmpty = isEmpty;
 
            return um;
        }
 
        void setFullCoverage() const;
        void increaseCoverage() const;
        void decreaseCoverage() const;
 
        bool isCoverageFull() const;
        size_t getCoverage(const size_t pos) const;
 
    private:
 
        UnitigMap(size_t p_unitig, size_t i, size_t l, size_t sz, bool short_, bool abundance, bool strd, CompactedDBG_ptr_t cdbg_);
 
        neighborIterator<U, G, is_const> bw_begin() const;
        neighborIterator<U, G, is_const> bw_end() const;
 
        neighborIterator<U, G, is_const> fw_begin() const;
        neighborIterator<U, G, is_const> fw_end() const;
 
        template<bool is_void> typename std::enable_if<!is_void, Unitig<U>>::type splitData_(const bool last_split) const;
        template<bool is_void> typename std::enable_if<is_void, Unitig<U>>::type splitData_(const bool last_split) const;
 
        Unitig<U> splitData(const bool last_split) const;
 
        template<bool is_void> typename std::enable_if<!is_void, Unitig_data_ptr_t>::type getData_() const;
        template<bool is_void> typename std::enable_if<is_void, Unitig_data_ptr_t>::type getData_() const;
 
        void partialCopy(const UnitigMap<U, G, is_const>& um);
 
        size_t pos_unitig; // unitig pos. in v_unitigs or km_unitigs or h_kmers
 
        bool isShort; // true if the unitig has length k
        bool isAbundant; // true if the unitig has length k and has an abundant minimizer
 
        CompactedDBG_ptr_t cdbg;
};
 
template<typename Unitig_data_t = void, typename Graph_data_t = void, bool is_const = false>
struct UnitigMapHash {
 
    typedef Unitig_data_t U;
    typedef Graph_data_t G;
 
    size_t operator()(const UnitigMap<U, G, is_const>& um) const {
 
        struct UnitigMapTMP {
 
            size_t pos_unitig; // unitig pos. in v_unitigs or km_unitigs or h_kmers
            size_t dist;
            size_t len;
            size_t size;
 
            bool strand;
            bool isEmpty;
 
            bool isShort; // true if the unitig has length k
            bool isAbundant; // true if the unitig has length k and has an abundant minimizer
 
            const void* cdbg;
 
            UnitigMapTMP(const UnitigMap<U, G, is_const>& um) : pos_unitig(um.pos_unitig), dist(um.dist), len(um.len), size(um.size),
                                                                strand(um.strand), isEmpty(um.isEmpty), isShort(um.isShort),
                                                                isAbundant(um.isAbundant), cdbg(static_cast<const void*>(um.cdbg)) {};
        };
 
        UnitigMapTMP tmp(um);
 
        //return static_cast<size_t>(XXH64(static_cast<const void*>(&tmp), sizeof(UnitigMapTMP), 0));
        return static_cast<size_t>(wyhash(&tmp, sizeof(UnitigMapTMP), 0, _wyp));
    }
};
 
#include "UnitigMap.tcc"
 
#endif