mod_minimizer.hpp

#ifndef MOD_MINIMIZER_HPP
#define MOD_MINIMIZER_HPP
 
#include "digest/digester.hpp"
#include <cassert>
#include <cstdint>
 
namespace digest {
 
class BadModException : public std::exception {
    const char *what() const throw() {
        return "mod must be greater than congruence.";
    }
};
 
template <BadCharPolicy P> class ModMin : public Digester<P> {
  public:
    ModMin(const char *seq, size_t len, unsigned k, uint32_t mod,
           uint32_t congruence = 0, size_t start = 0,
           MinimizedHashType minimized_h = MinimizedHashType::CANON)
        : Digester<P>(seq, len, k, start, minimized_h), mod(mod),
          congruence(congruence) {
        if (congruence >= mod) {
            throw BadModException();
        }
    }
 
    ModMin(const std::string &seq, unsigned k, uint32_t mod,
           uint32_t congruence = 0, size_t start = 0,
           MinimizedHashType minimized_h = MinimizedHashType::CANON)
        : ModMin<P>(seq.c_str(), seq.size(), k, mod, congruence, start,
                    minimized_h) {}
 
    void roll_minimizer(unsigned amount, std::vector<uint32_t> &vec) override {
        if (!this->is_valid_hash)
            return;
 
        if (this->get_minimized_h() == digest::MinimizedHashType::CANON) {
            do {
                if ((uint32_t)this->chash % mod == congruence) {
                    vec.emplace_back(this->get_pos());
                }
            } while (this->roll_one() && vec.size() < amount);
            return;
        }
 
        if (this->get_minimized_h() == digest::MinimizedHashType::FORWARD) {
            do {
                if ((uint32_t)this->fhash % mod == congruence) {
                    vec.emplace_back(this->get_pos());
                }
            } while (this->roll_one() && vec.size() < amount);
            return;
        }
 
        // reverse
        do {
            if ((uint32_t)this->rhash % mod == congruence) {
                vec.emplace_back(this->get_pos());
            }
        } while (this->roll_one() && vec.size() < amount);
    }
 
    void
    roll_minimizer(unsigned amount,
                   std::vector<std::pair<uint32_t, uint32_t>> &vec) override {
        if (!this->is_valid_hash)
            return;
 
        if (this->get_minimized_h() == digest::MinimizedHashType::CANON) {
            do {
                if ((uint32_t)this->chash % mod == congruence) {
                    vec.emplace_back(this->get_pos(), this->chash);
                }
            } while (this->roll_one() && vec.size() < amount);
            return;
        }
 
        if (this->get_minimized_h() == digest::MinimizedHashType::FORWARD) {
            do {
                if ((uint32_t)this->fhash % mod == congruence) {
                    vec.emplace_back(this->get_pos(), this->fhash);
                }
            } while (this->roll_one() && vec.size() < amount);
            return;
        }
 
        // reverse
        do {
            if ((uint32_t)this->rhash % mod == congruence) {
                vec.emplace_back(this->get_pos(), this->rhash);
            }
        } while (this->roll_one() && vec.size() < amount);
    }
 
    uint32_t get_mod() { return mod; }
 
    uint32_t get_congruence() { return congruence; }
 
  private:
    uint32_t mod;
    uint32_t congruence;
};
 
} // namespace digest
 
#endif // MOD_MINIMIZER_HPP