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 GenomeContainerType>
        void
        validate_sum_haploid_genome_counts(const GenomeContainerType &haploid_genomes,
                                           const uint_t expected_sum)
        {
            detail::validate_sum_haploid_genome_counts(haploid_genomes, expected_sum);
        }

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

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

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

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

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

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

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

#endif