container_of.h

Go to the documentation of this file.

#pragma once
#include "zeroerr/internal/config.h"
 
#include "zeroerr/domains/domain.h"
#include "zeroerr/internal/typetraits.h"
#include <limits>
#include <stdexcept>
 
ZEROERR_SUPPRESS_COMMON_WARNINGS_PUSH
 
namespace zeroerr {

struct ContainerOfBase {
    int min_size = 0, max_size = 100, size = -1;
 
    void WithMaxSize(unsigned value) { max_size = checkedSize(value); }
    void WithMinSize(unsigned value) { min_size = checkedSize(value); }
    void WithSize(unsigned value) { size = checkedSize(value); }
 
protected:
    static int checkedSize(unsigned value) {
        if (value > static_cast<unsigned>((std::numeric_limits<int>::max)()))
            throw std::invalid_argument("Container size exceeds supported range");
        return static_cast<int>(value);
    }
 
    void validate() const {
        if (size < -1 || min_size < 0 || max_size < min_size)
            throw std::invalid_argument("Invalid container size bounds");
    }
 
    unsigned randomSize(Rng& rng) const {
        validate();
        if (size != -1) return static_cast<unsigned>(size);
        return rng.bounded(static_cast<uint32_t>(max_size) -
                           static_cast<uint32_t>(min_size) + 1U) + min_size;
    }
 
    template <class Inner, class Corpus>
    void mutate(Rng& rng, Corpus& v, bool only_shrink, const Inner& inner) const {
        validate();
        const size_t lower = static_cast<size_t>(size == -1 ? min_size : size);
        const size_t upper = static_cast<size_t>(size == -1 ? max_size : size);
        if (v.size() < lower || v.size() > upper)
            throw std::invalid_argument("Corpus violates container size bounds");
        const unsigned action = rng.bounded(5);
        if (size == -1 && action == 0) {
            if (v.size() > lower)
                v.erase(v.begin() + rng.bounded(static_cast<uint32_t>(v.size())));
        } else if (size == -1 && action == 1 && !only_shrink) {
            if (v.size() < upper) v.push_back(inner.GetRandomCorpus(rng));
        } else if (!v.empty()) {
            inner.Mutate(rng, v[rng.bounded(static_cast<uint32_t>(v.size()))], only_shrink);
        }
    }
 
};
 
 
template <typename T, typename InnerDomain>
class AssociativeContainerOf : public Domain<T, std::vector<typename InnerDomain::CorpusType>>,
                               public ContainerOfBase {
    InnerDomain inner_domain;
 
public:
    using ValueType  = T;
    using CorpusType = std::vector<typename InnerDomain::CorpusType>;
 
    AssociativeContainerOf(InnerDomain&& inner_domain) : inner_domain(std::move(inner_domain)) {}
 
    virtual ValueType GetValue(const CorpusType& v) const override {
        ValueType result;
        for (const auto& elem : v) {
            result.insert(inner_domain.GetValue(elem));
        }
        return result;
    }
 
    virtual CorpusType FromValue(const ValueType& v) const override {
        CorpusType result;
        for (const auto& elem : v) {
            result.push_back(inner_domain.FromValue(elem));
        }
        return result;
    }
 
    CorpusType GetRandomCorpus(Rng& rng) const override {
        unsigned   E = randomSize(rng);
        CorpusType result;
        result.reserve(E);
        for (unsigned i = 0; i < E; i++) {
            result.push_back(inner_domain.GetRandomCorpus(rng));
        }
        return result;
    }
 
    void Mutate(Rng& rng, CorpusType& v, bool only_shrink) const override {
        mutate(rng, v, only_shrink, inner_domain);
    }
};
 
template <typename T, typename InnerDomain>
class SequenceContainerOf : public Domain<T, std::vector<typename InnerDomain::CorpusType>>,
                            public ContainerOfBase {
    InnerDomain inner_domain;
 
public:
    using ValueType  = T;
    using CorpusType = std::vector<typename InnerDomain::CorpusType>;
 
    SequenceContainerOf(InnerDomain&& inner_domain) : inner_domain(std::move(inner_domain)) {}
 
    virtual ValueType GetValue(const CorpusType& v) const override {
        return ValueType(v.begin(), v.end());
    }
    virtual CorpusType FromValue(const ValueType& v) const override {
        return CorpusType(v.begin(), v.end());
    }
 
    CorpusType GetRandomCorpus(Rng& rng) const override {
        unsigned   E = randomSize(rng);
        CorpusType result;
        result.reserve(E);
        for (unsigned i = 0; i < E; i++) {
            result.push_back(inner_domain.GetRandomCorpus(rng));
        }
        return result;
    }
 
    void Mutate(Rng& rng, CorpusType& v, bool only_shrink) const override {
        mutate(rng, v, only_shrink, inner_domain);
    }
};
 
 
// ContainerOf<T>(inner) combinator creates a domain for a container T (eg, a
// std::vector, std::set, etc) where elements are created from `inner`.
//
// Example usage:
//
//   ContainerOf<std::vector<int>>(InRange(1, 2021))
//
// The domain also supports customizing the minimum and maximum size via the
// `WithSize`, `WithMinSize` and `WithMaxSize` functions. Eg:
//
//   ContainerOf<std::vector<int>>(Arbitrary<int>()).WithMaxSize(5)
//
template <typename T, typename Inner>
typename std::enable_if<detail::is_associative_container<T>::value,
                        AssociativeContainerOf<T, Inner>>::type
ContainerOf(Inner&& inner) {
    return AssociativeContainerOf<T, Inner>(std::move(inner));
}
 
template <typename T, typename Inner>
typename std::enable_if<!detail::is_associative_container<T>::value &&
                            detail::is_container<T>::value,
                        SequenceContainerOf<T, Inner>>::type
ContainerOf(Inner&& inner) {
    return SequenceContainerOf<T, Inner>(std::move(inner));
}
 
// We can also support with a template template parameter, so that we can use
// the name of the container instead of the complete type. In such case,
// the ValueType of the inner domain should be passed into the container
//
//   ContainerOf<std::vector>(Positive<int>()).WithSize(3);
//
template <template <typename, typename...> class T, typename... Inner,
          typename C = T<typename Inner::ValueType...>>
auto ContainerOf(Inner... inner) -> decltype(ContainerOf<C>(std::move(inner)...)) {
    return ContainerOf<C>(std::move(inner)...);
}
 
 
}  // namespace zeroerr
 
ZEROERR_SUPPRESS_COMMON_WARNINGS_POP