window_minimizer.hpp

#ifndef WINDOW_MINIMIZER_HPP
#define WINDOW_MINIMIZER_HPP
 
#include "data_structure.hpp"
#include "digest/digester.hpp"
#include <cstddef>
#include <cstdint>
 
namespace digest {
 
class BadWindowSizeException : public std::exception {
    const char *what() const throw() {
        return "Number of kmers in large window cannot be 0";
    }
};
 
template <BadCharPolicy P, class T> class WindowMin : public Digester<P> {
  public:
    WindowMin(const char *seq, size_t len, unsigned k, unsigned large_window,
              size_t start = 0,
              MinimizedHashType minimized_h = MinimizedHashType::CANON)
        : Digester<P>(seq, len, k, start, minimized_h), ds(large_window),
          large_window(large_window), ds_size(0), is_minimized(false) {
        if (large_window == 0) {
            throw BadWindowSizeException();
        }
    }
 
    WindowMin(const std::string &seq, unsigned k, unsigned large_window,
              size_t start = 0,
              MinimizedHashType minimized_h = MinimizedHashType::CANON)
        : WindowMin<P, T>(seq.c_str(), seq.size(), k, large_window, start,
                          minimized_h) {}
 
    void roll_minimizer(unsigned amount, std::vector<uint32_t> &vec) override {
        amount += vec.size();
 
        while (ds_size + 1 < large_window and this->is_valid_hash) {
            if (this->get_minimized_h() == digest::MinimizedHashType::CANON) {
                ds.insert(this->get_pos(), this->chash);
            } else if (this->get_minimized_h() ==
                       digest::MinimizedHashType::FORWARD) {
                ds.insert(this->get_pos(), this->fhash);
            } else {
                ds.insert(this->get_pos(), this->rhash);
            }
 
            this->roll_one();
            ds_size++;
        }
 
        while (this->is_valid_hash and vec.size() < amount) {
            roll_ds_wind(vec);
        }
    }
 
    void
    roll_minimizer(unsigned amount,
                   std::vector<std::pair<uint32_t, uint32_t>> &vec) override {
        amount += vec.size();
 
        while (ds_size + 1 < large_window and this->is_valid_hash) {
            if (this->get_minimized_h() == digest::MinimizedHashType::CANON) {
                ds.insert(this->get_pos(), this->chash);
            } else if (this->get_minimized_h() ==
                       digest::MinimizedHashType::FORWARD) {
                ds.insert(this->get_pos(), this->fhash);
            } else {
                ds.insert(this->get_pos(), this->rhash);
            }
 
            this->roll_one();
            ds_size++;
        }
 
        while (this->is_valid_hash and vec.size() < amount) {
            roll_ds_wind(vec);
        }
    }
 
    void new_seq(const char *seq, size_t len, size_t start) override {
        ds = T(large_window);
        Digester<P>::new_seq(seq, len, start);
    }
 
    void new_seq(const std::string &seq, size_t pos) override {
        ds = T(large_window);
        Digester<P>::new_seq(seq.c_str(), seq.size(), pos);
    }
 
    unsigned get_large_wind_kmer_am() { return large_window; }
 
    // function is mainly to help with tests
    size_t get_ds_size() { return ds_size; }
 
    // function is mainly to help with tests
    bool get_is_minimized() { return is_minimized; }
 
  protected:
    // data structure which will find miminum
    T ds;
 
    uint32_t large_window;
 
    // internal counter that tracks the number of actual values in the data
    // structure
    size_t ds_size;
 
    // internal bool keeping track of if we have obtained the first minimizer
    // yet, because we don't want to add a position to the vector if it's
    // already in there
    bool is_minimized;
 
    // the index of previous minimizer, a minimizer is only a new minimizer if
    // it is different from the previous minimizer
    uint32_t prev_mini;
 
  private:
    void roll_ds_wind(std::vector<uint32_t> &vec) {
        if (this->get_minimized_h() == digest::MinimizedHashType::CANON) {
            ds.insert(this->get_pos(), this->chash);
        } else if (this->get_minimized_h() ==
                   digest::MinimizedHashType::FORWARD) {
            ds.insert(this->get_pos(), this->fhash);
        } else {
            ds.insert(this->get_pos(), this->rhash);
        }
        check(vec);
 
        this->roll_one();
    }
 
    void roll_ds_wind(std::vector<std::pair<uint32_t, uint32_t>> &vec) {
        if (this->get_minimized_h() == digest::MinimizedHashType::CANON) {
            ds.insert(this->get_pos(), this->chash);
        } else if (this->get_minimized_h() ==
                   digest::MinimizedHashType::FORWARD) {
            ds.insert(this->get_pos(), this->fhash);
        } else {
            ds.insert(this->get_pos(), this->rhash);
        }
        check(vec);
 
        this->roll_one();
    }
 
    void check(std::vector<uint32_t> &vec) {
        if (is_minimized) {
            if (ds.min() != prev_mini) {
                prev_mini = ds.min();
                vec.emplace_back(prev_mini);
            }
        } else {
            is_minimized = true;
            prev_mini = ds.min();
            vec.emplace_back(prev_mini);
        }
    }
 
    void check(std::vector<std::pair<uint32_t, uint32_t>> &vec) {
        if (is_minimized) {
            if (ds.min() != prev_mini) {
                prev_mini = ds.min();
                vec.emplace_back(prev_mini, ds.min_hash());
            }
        } else {
            is_minimized = true;
            prev_mini = ds.min();
            vec.emplace_back(prev_mini, ds.min_hash());
        }
    }
};
 
} // namespace digest
 
#endif // WINDOW_MINIMIZER_HPP