Kmer.hpp

Go to the documentation of this file.

#ifndef BIFROST_KMER_HPP
#define BIFROST_KMER_HPP
 
#ifndef MAX_KMER_SIZE
#define MAX_KMER_SIZE 32
#endif
 
#ifndef MAX_GMER_SIZE
#define MAX_GMER_SIZE MAX_KMER_SIZE
#endif
 
#include <stdint.h>
#include <stdio.h>
 
#include <bitset>
#include <cassert>
#include <cstring>
#include <iostream>
#include <string>
 
#include "Common.hpp"
 
class CompressedSequence;
 
class Kmer {
 
    friend class CompressedSequence;
 
    public:
 
        Kmer();
 
        Kmer(const Kmer& o);
 
        explicit Kmer(const char* s);
 
        Kmer& operator=(const Kmer& o);
 
        BFG_INLINE void set_deleted() {
 
            for (size_t i = 0; i < MAX_K/32; ++i) longs[i] = 0xffffffffffffffffULL;
        }
 
        BFG_INLINE void set_empty() {
 
            for (size_t i = 0; i < MAX_K/32; ++i) longs[i] = 0xfffffffffffffffeULL;
        }
 
        BFG_INLINE bool isDeleted() const {
 
            return (longs[(MAX_K/32)-1] == 0xffffffffffffffffULL);
        }
 
        BFG_INLINE bool isEmpty() const {
 
            return (longs[(MAX_K/32)-1] == 0xfffffffffffffffeULL);
        }
 
        bool operator<(const Kmer& o) const;
 
        bool operator==(const Kmer& o) const;
 
        bool operator!=(const Kmer& o) const;
 
        BFG_INLINE uint64_t hash(const uint64_t seed = 0) const {
 
            return wyhash(bytes, MAX_K/4, seed, _wyp);
        }
 
        Kmer twin() const;
 
        Kmer rep() const;
 
        Kmer forwardBase(const char b) const;
 
        Kmer backwardBase(const char b) const;
 
        void selfForwardBase(const char b);
 
        char getChar(const size_t offset) const;
 
        bool setChar(const size_t offset, const char b);
 
        void toString(char *s) const;
 
        std::string toString() const;
 
        bool write(std::ostream& stream_out) const;
 
        bool read(std::istream& stream_in);
 
        static void set_k(const unsigned int _k);
 
        static unsigned int k;
 
    private:
 
        static const unsigned int MAX_K = MAX_KMER_SIZE;
 
        union {
 
            uint8_t bytes[MAX_K/4];
            uint64_t longs[MAX_K/32];
        };
 
        void set_kmer(const char *s);
 
        Kmer getLink(const size_t index) const;
 
        std::string getBinary() const;
};
 
 
struct KmerHash {
 
    inline size_t operator()(const Kmer& km) const {
 
        return km.hash();
    }
};
 
class Minimizer {
 
    friend class CompressedSequence;
 
    public:
 
        Minimizer();
        Minimizer(const Minimizer& o);
        explicit Minimizer(const char *s);
 
        Minimizer& operator=(const Minimizer& o);
 
        bool operator<(const Minimizer& o) const;
        bool operator==(const Minimizer& o) const;
        bool operator!=(const Minimizer& o) const;
 
        void set_minimizer(const char *s);
 
        BFG_INLINE uint64_t hash(const uint64_t seed = 0) const {
 
            return wyhash(bytes, MAX_G/4, seed, _wyp);
        }
 
        BFG_INLINE void set_deleted() {
 
            for (size_t i = 0; i < MAX_G/32; ++i) longs[i] = 0xffffffffffffffffULL;
        }
 
        BFG_INLINE void set_empty() {
 
            for (size_t i = 0; i < MAX_G/32; ++i) longs[i] = 0xfffffffffffffffeULL;
        }
 
        BFG_INLINE bool isDeleted() const {
 
            return (longs[(MAX_G/32)-1] == 0xffffffffffffffffULL);
        }
 
        BFG_INLINE bool isEmpty() const {
 
            return (longs[(MAX_G/32)-1] == 0xfffffffffffffffeULL);
        }
 
        Minimizer twin() const;
        Minimizer rep() const;
 
        Minimizer getLink(const size_t index) const;
 
        Minimizer forwardBase(const char b) const;
        Minimizer backwardBase(const char b) const;
 
        std::string getBinary() const;
 
        void toString(char *s) const;
        std::string toString() const;
 
        bool write(std::ostream& stream_out) const;
        bool read(std::istream& stream_in);
 
        // static functions
        static void set_g(unsigned int _g);
 
        static unsigned int g;
 
    private:
 
        static const unsigned int MAX_G = MAX_GMER_SIZE;
 
        // data fields
        union {
 
            uint8_t bytes[MAX_G/4];
            uint64_t longs[MAX_G/32];
        };
 
        // By default MAX_K == 64 so the union uses 16 bytes
        // However sizeof(Kmer) == 24
        // Are the 8 extra bytes alignment?
};
 
 
struct MinimizerHash {
 
    inline size_t operator()(const Minimizer& minz) const {
 
        return minz.hash();
    }
};
 
#endif // BFG_KMER_HPP