config.hpp

// SPDX-FileCopyrightText: 2006-2024, Knut Reinert & Freie Universität Berlin
// SPDX-FileCopyrightText: 2016-2024, Knut Reinert & MPI für molekulare Genetik
// SPDX-License-Identifier: BSD-3-Clause
 
#pragma once
 
#include <cinttypes>  // for uint32_t, uint8_t
#include <cstddef>    // for size_t
#include <functional> // for function
#include <iosfwd>     // for istream, ostream
 
#include <cereal/access.hpp> // for access
#include <cereal/cereal.hpp> // for make_nvp, CEREAL_NVP
 
#include <hibf/misc/insert_iterator.hpp> // for insert_iterator
#include <hibf/platform.hpp>
 
namespace seqan::hibf
{
 
struct config
{
    std::function<void(size_t const, insert_iterator &&)> input_fn{};
 
    size_t number_of_user_bins{};
 
    size_t number_of_hash_functions{2};
 
    double maximum_fpr{0.05};
 
    double relaxed_fpr{0.3};
 
    size_t threads{1u};
 
    uint8_t sketch_bits{12};
 
    size_t tmax{};
 
    double alpha{1.2};
 
    double max_rearrangement_ratio{0.5};
 
    bool disable_estimate_union{false};
 
    bool disable_rearrangement{false};
 
    void read_from(std::istream & stream);
    void write_to(std::ostream & stream) const;
 
    void validate_and_set_defaults();
 
    constexpr bool operator==(config const & other) const
    {
        // clang-format off
        return number_of_user_bins == other.number_of_user_bins &&
               maximum_fpr == other.maximum_fpr &&
               relaxed_fpr == other.relaxed_fpr &&
               threads == other.threads &&
               sketch_bits == other.sketch_bits &&
               tmax == other.tmax &&
               alpha == other.alpha &&
               max_rearrangement_ratio == other.max_rearrangement_ratio &&
               disable_estimate_union == other.disable_estimate_union &&
               disable_rearrangement == other.disable_rearrangement;
        // clang-format on
    }
 
private:
    friend class cereal::access;
 
    template <typename archive_t>
    void serialize(archive_t & archive)
    {
        uint32_t version{1};
        archive(CEREAL_NVP(version));
 
        archive(CEREAL_NVP(number_of_user_bins));
        archive(CEREAL_NVP(number_of_hash_functions));
        archive(CEREAL_NVP(maximum_fpr));
        archive(CEREAL_NVP(relaxed_fpr));
        archive(CEREAL_NVP(threads));
 
        archive(CEREAL_NVP(sketch_bits));
        archive(CEREAL_NVP(tmax));
        archive(CEREAL_NVP(alpha));
        archive(CEREAL_NVP(max_rearrangement_ratio));
        archive(CEREAL_NVP(disable_estimate_union));
        archive(CEREAL_NVP(disable_rearrangement));
    }
};
 
} // namespace seqan::hibf