Program Listing for File debug.hpp

↰ Return to documentation for file (fwdpp/debug.hpp)

#ifndef FWDPP_DEBUG_HPP
#define FWDPP_DEBUG_HPP

#include <algorithm>
#include <numeric>
#include <fwdpp/forward_types.hpp>
#include <fwdpp/type_traits.hpp>
#include "internal/debug_details.hpp"

namespace fwdpp
{
    namespace debug
    {
        template <typename gcont_t>
        void
        validate_sum_haploid_genome_counts(const gcont_t &haploid_genomes,
                                           const uint_t expected_sum)
        {
            detail::validate_sum_haploid_genome_counts(haploid_genomes,
                                                       expected_sum);
        }

        template <typename mcont_t, typename iterator>
        void
        validate_mutation_key_ranges(const mcont_t &mutations,
                                     const iterator beg, const iterator end)
        {
            detail::validate_mutation_key_ranges(mutations, beg, end);
        }

        template <typename haploid_genome_t>
        void
        haploid_genome_is_extant(const haploid_genome_t &haploid_genome)
        {
            detail::haploid_genome_is_extant(haploid_genome);
        }

        template <typename haploid_genome_t, typename mcont_t>
        void
        haploid_genome_is_sorted(const haploid_genome_t &g,
                                 const mcont_t &mutations)
        {
            detail::haploid_genome_is_sorted(g, mutations);
        }

        template <typename haploid_genome_t, typename mcont_t>
        void
        haploid_genome_data_valid(const haploid_genome_t &g,
                                  const mcont_t &mutations,
                                  const std::vector<uint_t> &mutcounts)
        {
            detail::haploid_genome_data_valid(g, mutations, mutcounts);
        }

        template <typename poptype>
        void
        validate_pop_data(const poptype &pop)
        {
            detail::validate_pop_data(pop);
        }

        template <typename mutation_type>
        void
        check_mutation_neutrality(const mutation_type &mutation,
                                  const bool expected_neutrality)
        {
            detail::check_mutation_neutrality(mutation, expected_neutrality);
        }

        template <typename poptype>
        void
        all_haploid_genomes_extant(const poptype &pop)
        {
            detail::all_haploid_genomes_extant(pop,
                                               typename poptype::popmodel_t());
        }
    } // namespace debug
} // namespace fwdpp

#endif