nthash.hpp

#pragma once
 
#include <array>
#include <cstdint>
#include <cstring>
#include <deque>
#include <memory>
#include <string>
#include <vector>
 
namespace nthash {
 
static const char* const NTHASH_FN_NAME = "ntHash_v2";
 
namespace typedefs {
using NUM_HASHES_TYPE = uint8_t;
using K_TYPE = uint16_t;
using SpacedSeedBlocks = std::vector<std::array<unsigned, 2>>;
using SpacedSeedMonomers = std::vector<unsigned>;
} // namespace typedefs
 
class NtHash;
 
class BlindNtHash;
 
class SeedNtHash;
 
class BlindSeedNtHash;
 
std::vector<std::vector<unsigned>>
parse_seeds(const std::vector<std::string>& seed_strings);
 
class NtHash
{
 
public:
  NtHash(const char* seq,
         size_t seq_len,
         typedefs::NUM_HASHES_TYPE num_hashes,
         typedefs::K_TYPE k,
         size_t pos = 0);
 
  NtHash(const std::string& seq,
         typedefs::NUM_HASHES_TYPE num_hashes,
         typedefs::K_TYPE k,
         size_t pos = 0)
    : NtHash(seq.data(), seq.size(), num_hashes, k, pos)
  {
  }
 
  NtHash(const NtHash& obj)
    : seq(obj.seq)
    , num_hashes(obj.num_hashes)
    , k(obj.k)
    , pos(obj.pos)
    , initialized(obj.initialized)
    , fwd_hash(obj.fwd_hash)
    , rev_hash(obj.rev_hash)
    , hash_arr(new uint64_t[obj.num_hashes])
  {
    std::memcpy(
      hash_arr.get(), obj.hash_arr.get(), num_hashes * sizeof(uint64_t));
  }
 
  NtHash(NtHash&&) = default;
 
  bool roll();
 
  bool roll_back();
 
  bool peek();
 
  bool peek_back();
 
  bool peek(char char_in);
 
  bool peek_back(char char_in);
 
  const uint64_t* hashes() const { return hash_arr.get(); }
 
  size_t get_pos() const { return pos; }
 
  typedefs::NUM_HASHES_TYPE get_hash_num() const { return num_hashes; }
 
  typedefs::K_TYPE get_k() const { return k; }
 
  uint64_t get_forward_hash() const { return fwd_hash; }
 
  uint64_t get_reverse_hash() const { return rev_hash; }
 
private:
  std::string_view seq;
  typedefs::NUM_HASHES_TYPE num_hashes;
  typedefs::K_TYPE k;
  size_t pos;
  bool initialized;
  uint64_t fwd_hash = 0;
  uint64_t rev_hash = 0;
  std::unique_ptr<uint64_t[]> hash_arr;
 
  bool init();
};
 
class BlindNtHash
{
 
public:
  BlindNtHash(const char* seq,
              typedefs::NUM_HASHES_TYPE num_hashes,
              typedefs::K_TYPE k,
              ssize_t pos = 0);
 
  BlindNtHash(const BlindNtHash& obj)
    : seq(obj.seq)
    , num_hashes(obj.num_hashes)
    , pos(obj.pos)
    , fwd_hash(obj.fwd_hash)
    , rev_hash(obj.rev_hash)
    , hash_arr(new uint64_t[obj.num_hashes])
  {
    std::memcpy(
      hash_arr.get(), obj.hash_arr.get(), num_hashes * sizeof(uint64_t));
  }
 
  BlindNtHash(BlindNtHash&&) = default;
 
  void roll(char char_in);
 
  void roll_back(char char_in);
 
  void peek(char char_in);
 
  void peek_back(char char_in);
 
  const uint64_t* hashes() const { return hash_arr.get(); }
 
  ssize_t get_pos() const { return pos; }
 
  typedefs::NUM_HASHES_TYPE get_hash_num() const { return num_hashes; }
 
  typedefs::K_TYPE get_k() const { return seq.size(); }
 
  uint64_t get_forward_hash() const { return fwd_hash; }
 
  uint64_t get_reverse_hash() const { return rev_hash; }
 
private:
  std::deque<char> seq;
  typedefs::NUM_HASHES_TYPE num_hashes;
  ssize_t pos;
  uint64_t fwd_hash = 0;
  uint64_t rev_hash = 0;
  std::unique_ptr<uint64_t[]> hash_arr;
};
 
class SeedNtHash
{
 
public:
  SeedNtHash(const char* seq,
             size_t seq_len,
             const std::vector<std::string>& seeds,
             typedefs::NUM_HASHES_TYPE num_hashes_per_seed,
             typedefs::K_TYPE k,
             size_t pos = 0);
 
  SeedNtHash(const std::string& seq,
             const std::vector<std::string>& seeds,
             typedefs::NUM_HASHES_TYPE num_hashes_per_seed,
             typedefs::K_TYPE k,
             size_t pos = 0)
    : SeedNtHash(seq.data(), seq.size(), seeds, num_hashes_per_seed, k, pos)
  {
  }
 
  SeedNtHash(const char* seq,
             size_t seq_len,
             const std::vector<std::vector<unsigned>>& seeds,
             typedefs::NUM_HASHES_TYPE num_hashes_per_seed,
             typedefs::K_TYPE k,
             size_t pos = 0);
 
  SeedNtHash(const std::string& seq,
             const std::vector<std::vector<unsigned>>& seeds,
             typedefs::NUM_HASHES_TYPE num_hashes_per_seed,
             typedefs::K_TYPE k,
             size_t pos = 0)
    : SeedNtHash(seq.data(), seq.size(), seeds, num_hashes_per_seed, k, pos)
  {
  }
 
  SeedNtHash(const SeedNtHash& obj)
    : seq(obj.seq)
    , num_hashes_per_seed(obj.num_hashes_per_seed)
    , k(obj.k)
    , pos(obj.pos)
    , initialized(obj.initialized)
    , blocks(obj.blocks)
    , monomers(obj.monomers)
    , fwd_hash_nomonos(new uint64_t[obj.blocks.size()])
    , rev_hash_nomonos(new uint64_t[obj.blocks.size()])
    , fwd_hash(new uint64_t[obj.blocks.size()])
    , rev_hash(new uint64_t[obj.blocks.size()])
    , hash_arr(new uint64_t[obj.num_hashes_per_seed * obj.blocks.size()])
  {
    std::memcpy(fwd_hash_nomonos.get(),
                obj.fwd_hash_nomonos.get(),
                obj.blocks.size() * sizeof(uint64_t));
    std::memcpy(rev_hash_nomonos.get(),
                obj.rev_hash_nomonos.get(),
                obj.blocks.size() * sizeof(uint64_t));
    std::memcpy(
      fwd_hash.get(), obj.fwd_hash.get(), obj.blocks.size() * sizeof(uint64_t));
    std::memcpy(
      rev_hash.get(), obj.rev_hash.get(), obj.blocks.size() * sizeof(uint64_t));
    std::memcpy(hash_arr.get(),
                obj.hash_arr.get(),
                obj.num_hashes_per_seed * obj.blocks.size() * sizeof(uint64_t));
  }
 
  SeedNtHash(SeedNtHash&&) = default;
 
  bool roll();
 
  bool roll_back();
 
  bool peek();
 
  bool peek_back();
 
  bool peek(char char_in);
 
  bool peek_back(char char_in);
 
  const uint64_t* hashes() const { return hash_arr.get(); }
 
  size_t get_pos() const { return pos; }
 
  unsigned get_hash_num() const { return num_hashes_per_seed * blocks.size(); }
 
  typedefs::NUM_HASHES_TYPE get_hash_num_per_seed() const
  {
    return num_hashes_per_seed;
  }
 
  typedefs::K_TYPE get_k() const { return k; }
 
  uint64_t* get_forward_hash() const { return fwd_hash.get(); }
 
  uint64_t* get_reverse_hash() const { return rev_hash.get(); }
 
private:
  std::string_view seq;
  typedefs::NUM_HASHES_TYPE num_hashes_per_seed;
  typedefs::K_TYPE k;
  size_t pos;
  bool initialized;
  std::vector<typedefs::SpacedSeedBlocks> blocks;
  std::vector<typedefs::SpacedSeedMonomers> monomers;
  std::unique_ptr<uint64_t[]> fwd_hash_nomonos;
  std::unique_ptr<uint64_t[]> rev_hash_nomonos;
  std::unique_ptr<uint64_t[]> fwd_hash;
  std::unique_ptr<uint64_t[]> rev_hash;
  std::unique_ptr<uint64_t[]> hash_arr;
 
  bool init();
};
 
class BlindSeedNtHash
{
 
public:
  BlindSeedNtHash(const char* seq,
                  const std::vector<std::string>& seeds,
                  typedefs::NUM_HASHES_TYPE num_hashes_per_seed,
                  typedefs::K_TYPE k,
                  ssize_t pos = 0);
 
  BlindSeedNtHash(const BlindSeedNtHash& seed_nthash)
    : seq(seed_nthash.seq)
    , num_hashes_per_seed(seed_nthash.num_hashes_per_seed)
    , k(seed_nthash.k)
    , pos(seed_nthash.pos)
    , blocks(seed_nthash.blocks)
    , monomers(seed_nthash.monomers)
    , fwd_hash_nomonos(new uint64_t[seed_nthash.blocks.size()])
    , rev_hash_nomonos(new uint64_t[seed_nthash.blocks.size()])
    , fwd_hash(new uint64_t[seed_nthash.blocks.size()])
    , rev_hash(new uint64_t[seed_nthash.blocks.size()])
    , hash_arr(new uint64_t[num_hashes_per_seed * seed_nthash.blocks.size()])
  {
    std::memcpy(fwd_hash_nomonos.get(),
                seed_nthash.fwd_hash_nomonos.get(),
                seed_nthash.blocks.size() * sizeof(uint64_t));
    std::memcpy(rev_hash_nomonos.get(),
                seed_nthash.rev_hash_nomonos.get(),
                seed_nthash.blocks.size() * sizeof(uint64_t));
    std::memcpy(fwd_hash.get(),
                seed_nthash.fwd_hash.get(),
                seed_nthash.blocks.size() * sizeof(uint64_t));
    std::memcpy(rev_hash.get(),
                seed_nthash.rev_hash.get(),
                seed_nthash.blocks.size() * sizeof(uint64_t));
    std::memcpy(hash_arr.get(),
                seed_nthash.hash_arr.get(),
                num_hashes_per_seed * seed_nthash.blocks.size() *
                  sizeof(uint64_t));
  }
 
  BlindSeedNtHash(BlindSeedNtHash&&) = default;
 
  void roll(char char_in);
 
  void roll_back(char char_in);
 
  const uint64_t* hashes() const { return hash_arr.get(); }
 
  ssize_t get_pos() const { return pos; }
 
  unsigned get_hash_num() const { return num_hashes_per_seed * blocks.size(); }
 
  typedefs::NUM_HASHES_TYPE get_hash_num_per_seed() const
  {
    return num_hashes_per_seed;
  }
 
  typedefs::K_TYPE get_k() const { return k; }
 
  uint64_t* get_forward_hash() const { return fwd_hash.get(); }
 
  uint64_t* get_reverse_hash() const { return rev_hash.get(); }
 
private:
  std::deque<char> seq;
  typedefs::NUM_HASHES_TYPE num_hashes_per_seed;
  typedefs::K_TYPE k;
  ssize_t pos;
  std::vector<typedefs::SpacedSeedBlocks> blocks;
  std::vector<typedefs::SpacedSeedMonomers> monomers;
  std::unique_ptr<uint64_t[]> fwd_hash_nomonos;
  std::unique_ptr<uint64_t[]> rev_hash_nomonos;
  std::unique_ptr<uint64_t[]> fwd_hash;
  std::unique_ptr<uint64_t[]> rev_hash;
  std::unique_ptr<uint64_t[]> hash_arr;
};
 
} // namespace nthash