config.hpp

// SPDX-FileCopyrightText: 2006-2026, Knut Reinert & Freie Universität Berlin
// SPDX-FileCopyrightText: 2016-2026, Knut Reinert & MPI für molekulare Genetik
// SPDX-License-Identifier: BSD-3-Clause
 
#pragma once
 
#include <cstddef>    // for size_t
#include <cstdint>    // for uint32_t, uint8_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 empty_bin_fraction{};
 
    bool track_occupancy{false};
 
    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 &&
               empty_bin_fraction == other.empty_bin_fraction &&
               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;
 
    static constexpr uint32_t version{3u};
 
    template <typename archive_t>
    void serialize(archive_t & archive)
    {
        uint32_t parsed_version{version};
        archive(cereal::make_nvp("version", parsed_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));
 
        if (parsed_version >= 2u)
        {
            archive(CEREAL_NVP(empty_bin_fraction));
 
            if (parsed_version >= 3u)
                archive(CEREAL_NVP(track_occupancy));
            else
                track_occupancy = empty_bin_fraction != 0.0;
        }
 
        archive(CEREAL_NVP(alpha));
        archive(CEREAL_NVP(max_rearrangement_ratio));
        archive(CEREAL_NVP(disable_estimate_union));
        archive(CEREAL_NVP(disable_rearrangement));
    }
};
 
} // namespace seqan::hibf