syncmer.hpp

#ifndef SYNCMER_HPP
#define SYNCMER_HPP
 
#include "digest/digester.hpp"
#include "digest/window_minimizer.hpp"
 
namespace digest {
 
template <BadCharPolicy P, class T> class Syncmer : public WindowMin<P, T> {
  public:
    Syncmer(const char *seq, size_t len, unsigned k, unsigned large_window,
            size_t start = 0,
            MinimizedHashType minimized_h = MinimizedHashType::CANON)
        : WindowMin<P, T>(seq, len, k, large_window, start, minimized_h) {}
 
    Syncmer(const std::string &seq, unsigned k, unsigned large_window,
            size_t start = 0,
            MinimizedHashType minimized_h = MinimizedHashType::CANON)
        : Syncmer<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 (this->ds_size + 1 < this->large_window and this->is_valid_hash) {
            if (this->get_minimized_h() == digest::MinimizedHashType::CANON) {
                this->ds.insert(this->get_pos(), this->chash);
            } else if (this->get_minimized_h() ==
                       digest::MinimizedHashType::FORWARD) {
                this->ds.insert(this->get_pos(), this->fhash);
            } else {
                this->ds.insert(this->get_pos(), this->rhash);
            }
 
            this->roll_one();
            this->ds_size++;
        }
 
        while (this->is_valid_hash and vec.size() < amount) {
            Syncmer::roll_ds_sync(vec);
        }
    }
 
    void
    roll_minimizer(unsigned amount,
                   std::vector<std::pair<uint32_t, uint32_t>> &vec) override {
        amount += vec.size();
 
        while (this->ds_size + 1 < this->large_window and this->is_valid_hash) {
            if (this->get_minimized_h() == digest::MinimizedHashType::CANON) {
                this->ds.insert(this->get_pos(), this->chash);
            } else if (this->get_minimized_h() ==
                       digest::MinimizedHashType::FORWARD) {
                this->ds.insert(this->get_pos(), this->fhash);
            } else {
                this->ds.insert(this->get_pos(), this->rhash);
            }
 
            this->roll_one();
            this->ds_size++;
        }
 
        while (this->is_valid_hash and vec.size() < amount) {
            Syncmer::roll_ds_sync(vec);
        }
    }
 
  private:
    void roll_ds_sync(std::vector<uint32_t> &vec) {
        if (this->get_minimized_h() == digest::MinimizedHashType::CANON) {
            this->ds.insert(this->get_pos(), this->chash);
        } else if (this->get_minimized_h() ==
                   digest::MinimizedHashType::FORWARD) {
            this->ds.insert(this->get_pos(), this->fhash);
        } else {
            this->ds.insert(this->get_pos(), this->rhash);
        }
        this->ds.min_syncmer(vec);
 
        this->roll_one();
    }
 
    void roll_ds_sync(std::vector<std::pair<uint32_t, uint32_t>> &vec) {
        if (this->get_minimized_h() == digest::MinimizedHashType::CANON) {
            this->ds.insert(this->get_pos(), this->chash);
        } else if (this->get_minimized_h() ==
                   digest::MinimizedHashType::FORWARD) {
            this->ds.insert(this->get_pos(), this->fhash);
        } else {
            this->ds.insert(this->get_pos(), this->rhash);
        }
        this->ds.min_syncmer(vec);
 
        this->roll_one();
    }
};
 
} // namespace digest
 
#endif // SYNCMER_HPP