counting_bloom_filter.hpp

#ifndef BTLLIB_COUNTING_BLOOM_FILTER_HPP
#define BTLLIB_COUNTING_BLOOM_FILTER_HPP
 
#include "btllib/bloom_filter.hpp"
#include "btllib/counting_bloom_filter.hpp"
#include "btllib/nthash.hpp"
#include "btllib/status.hpp"
 
// clang-format off
// NOLINTBEGIN llvm-include-order
#include <limits>
#include "cpptoml.h"
// NOLINTEND llvm-include-order
// clang-format on
 
#include <atomic>
#include <cmath>
#include <cstdint>
#include <fstream>
#include <memory>
#include <string>
#include <vector>
 
namespace btllib {
 
// NOLINTNEXTLINE(clang-diagnostic-unneeded-internal-declaration)
static const char* const COUNTING_BLOOM_FILTER_SIGNATURE =
  "[BTLCountingBloomFilter_v5]";
// NOLINTNEXTLINE(clang-diagnostic-unneeded-internal-declaration)
static const char* const KMER_COUNTING_BLOOM_FILTER_SIGNATURE =
  "[BTLKmerCountingBloomFilter_v5]";
 
template<typename T>
class KmerCountingBloomFilter;
 
template<typename T>
class CountingBloomFilter
{
 
public:
  CountingBloomFilter() {}
 
  CountingBloomFilter(size_t bytes,
                      unsigned hash_num,
                      std::string hash_fn = "");
 
  explicit CountingBloomFilter(const std::string& path);
 
  CountingBloomFilter(const CountingBloomFilter&) = delete;
  CountingBloomFilter(CountingBloomFilter&&) = delete;
 
  CountingBloomFilter& operator=(const CountingBloomFilter&) = delete;
  CountingBloomFilter& operator=(CountingBloomFilter&&) = delete;
 
  void insert(const uint64_t* hashes, T n = 1);
 
  void insert(const std::vector<uint64_t>& hashes, T n = 1)
  {
    insert(hashes.data(), n);
  }
 
  void remove(const uint64_t* hashes);
 
  void remove(const std::vector<uint64_t>& hashes) { remove(hashes.data()); }
 
  void clear(const uint64_t* hashes);
 
  void clear(const std::vector<uint64_t>& hashes) { clear(hashes.data()); }
 
  T contains(const uint64_t* hashes) const;
 
  T contains(const std::vector<uint64_t>& hashes) const
  {
    return contains(hashes.data());
  }
 
  T contains_insert(const uint64_t* hashes, T n = 1);
 
  T contains_insert(const std::vector<uint64_t>& hashes, T n = 1)
  {
    return contains_insert(hashes.data(), n);
  }
 
  T insert_contains(const uint64_t* hashes, T n = 1);
 
  T insert_contains(const std::vector<uint64_t>& hashes, T n = 1)
  {
    return insert_contains(hashes.data(), n);
  }
 
  T insert_thresh_contains(const uint64_t* hashes, T threshold);
 
  T insert_thresh_contains(const std::vector<uint64_t>& hashes,
                           const T threshold)
  {
    return insert_thresh_contains(hashes.data(), threshold);
  }
 
  T contains_insert_thresh(const uint64_t* hashes, T threshold);
 
  T contains_insert_thresh(const std::vector<uint64_t>& hashes,
                           const T threshold)
  {
    return contains_insert_thresh(hashes.data(), threshold);
  }
 
  size_t get_bytes() const { return bytes; }
  uint64_t get_pop_cnt(T threshold = 1) const;
  double get_occupancy(T threshold = 1) const;
  unsigned get_hash_num() const { return hash_num; }
  double get_fpr(T threshold = 1) const;
  const std::string& get_hash_fn() const { return hash_fn; }
 
  void save(const std::string& path);
 
  static bool is_bloom_file(const std::string& path)
  {
    return btllib::BloomFilter::check_file_signature(
      path, COUNTING_BLOOM_FILTER_SIGNATURE);
  }
 
private:
  CountingBloomFilter(const std::shared_ptr<BloomFilterInitializer>& bfi);
 
  void set(const uint64_t* hashes, T min_val, T new_val);
 
  friend class KmerCountingBloomFilter<T>;
 
  size_t bytes = 0;
  size_t array_size = 0;
  unsigned hash_num = 0;
  std::string hash_fn;
  std::unique_ptr<std::atomic<T>[]> array;
};
 
template<typename T>
class KmerCountingBloomFilter
{
 
public:
  KmerCountingBloomFilter() {}
 
  KmerCountingBloomFilter(size_t bytes, unsigned hash_num, unsigned k);
 
  explicit KmerCountingBloomFilter(const std::string& path);
 
  KmerCountingBloomFilter(const KmerCountingBloomFilter&) = delete;
  KmerCountingBloomFilter(KmerCountingBloomFilter&&) = delete;
 
  KmerCountingBloomFilter& operator=(const KmerCountingBloomFilter&) = delete;
  KmerCountingBloomFilter& operator=(KmerCountingBloomFilter&&) = delete;
 
  void insert(const char* seq, size_t seq_len);
 
  void insert(const std::string& seq) { insert(seq.c_str(), seq.size()); }
 
  void insert(const uint64_t* hashes, T n = 1)
  {
    counting_bloom_filter.insert(hashes, n);
  }
 
  void insert(const std::vector<uint64_t>& hashes, T n = 1)
  {
    counting_bloom_filter.insert(hashes, n);
  }
 
  void remove(const char* seq, size_t seq_len);
 
  void remove(const std::string& seq) { remove(seq.c_str(), seq.size()); }
 
  void remove(const uint64_t* hashes) { counting_bloom_filter.remove(hashes); }
 
  void remove(const std::vector<uint64_t>& hashes)
  {
    counting_bloom_filter.remove(hashes);
  }
 
  void clear(const char* seq, size_t seq_len);
 
  void clear(const std::string& seq) { clear(seq.c_str(), seq.size()); }
 
  void clear(const uint64_t* hashes) { counting_bloom_filter.clear(hashes); }
 
  void clear(const std::vector<uint64_t>& hashes)
  {
    counting_bloom_filter.clear(hashes);
  }
 
  uint64_t contains(const char* seq, size_t seq_len) const;
 
  uint64_t contains(const std::string& seq) const
  {
    return contains(seq.c_str(), seq.size());
  }
 
  T contains(const uint64_t* hashes) const
  {
    return counting_bloom_filter.contains(hashes);
  }
 
  T contains(const std::vector<uint64_t>& hashes) const
  {
    return counting_bloom_filter.contains(hashes);
  }
 
  T contains_insert(const char* seq, size_t seq_len);
 
  T contains_insert(const std::string& seq)
  {
    return contains_insert(seq.c_str(), seq.size());
  }
 
  T contains_insert(const uint64_t* hashes, T n = 1)
  {
    return counting_bloom_filter.contains_insert(hashes, n);
  }
 
  T contains_insert(const std::vector<uint64_t>& hashes, T n = 1)
  {
    return counting_bloom_filter.contains_insert(hashes, n);
  }
 
  T insert_contains(const char* seq, size_t seq_len);
 
  T insert_contains(const std::string& seq)
  {
    return insert_contains(seq.c_str(), seq.size());
  }
 
  T insert_contains(const uint64_t* hashes, T n = 1)
  {
    return counting_bloom_filter.insert_contains(hashes, n);
  }
 
  T insert_contains(const std::vector<uint64_t>& hashes, T n = 1)
  {
    return counting_bloom_filter.insert_contains(hashes, n);
  }
 
  T insert_thresh_contains(const char* seq, size_t seq_len, T threshold);
 
  T insert_thresh_contains(const std::string& seq, const T threshold)
  {
    return insert_thresh_contains(seq.c_str(), seq.size(), threshold);
  }
 
  T insert_thresh_contains(const uint64_t* hashes, const T threshold)
  {
    return counting_bloom_filter.insert_thresh_contains(hashes, threshold);
  }
 
  T insert_thresh_contains(const std::vector<uint64_t>& hashes,
                           const T threshold)
  {
    return counting_bloom_filter.insert_thresh_contains(hashes, threshold);
  }
 
  T contains_insert_thresh(const char* seq, size_t seq_len, T threshold);
 
  T contains_insert_thresh(const std::string& seq, const T threshold)
  {
    return contains_insert_thresh(seq.c_str(), seq.size(), threshold);
  }
 
  T contains_insert_thresh(const uint64_t* hashes, const T threshold)
  {
    return counting_bloom_filter.contains_insert_thresh(hashes, threshold);
  }
 
  T contains_insert_thresh(const std::vector<uint64_t>& hashes,
                           const T threshold)
  {
    return counting_bloom_filter.contains_insert_thresh(hashes, threshold);
  }
 
  size_t get_bytes() const { return counting_bloom_filter.get_bytes(); }
  uint64_t get_pop_cnt(T threshold = 1) const
  {
    return counting_bloom_filter.get_pop_cnt(threshold);
  }
  double get_occupancy(T threshold = 1) const
  {
    return counting_bloom_filter.get_occupancy(threshold);
  }
  unsigned get_hash_num() const { return counting_bloom_filter.get_hash_num(); }
  double get_fpr(T threshold = 1) const
  {
    return counting_bloom_filter.get_fpr(threshold);
  }
  unsigned get_k() const { return k; }
  const std::string& get_hash_fn() const
  {
    return counting_bloom_filter.get_hash_fn();
  }
  CountingBloomFilter<T>& get_counting_bloom_filter()
  {
    return counting_bloom_filter;
  }
 
  void save(const std::string& path);
 
  static bool is_bloom_file(const std::string& path)
  {
    return btllib::BloomFilter::check_file_signature(
      path, KMER_COUNTING_BLOOM_FILTER_SIGNATURE);
  }
 
private:
  KmerCountingBloomFilter(const std::shared_ptr<BloomFilterInitializer>& bfi);
 
  unsigned k = 0;
  CountingBloomFilter<T> counting_bloom_filter;
};
 
} // namespace btllib
 
#include "counting_bloom_filter-inl.hpp"
 
#endif