element.hpp

#ifndef HALCHECK_GEN_ELEMENT_HPP
#define HALCHECK_GEN_ELEMENT_HPP
 
#include <halcheck/gen/discard.hpp>
#include <halcheck/gen/range.hpp>
#include <halcheck/gen/sample.hpp>
#include <halcheck/gen/shrink.hpp>
#include <halcheck/lib/atom.hpp>
#include <halcheck/lib/iterator.hpp>
#include <halcheck/lib/pp.hpp>
#include <halcheck/lib/type_traits.hpp>
 
#include <array>
#include <cstdint>
#include <iterator>
#include <type_traits>
#include <utility>
 
namespace halcheck { namespace gen {
 
HALCHECK_INLINE_CONSTEXPR struct {
  template<typename T, HALCHECK_REQUIRE(lib::is_input_range<T>()), HALCHECK_REQUIRE(lib::is_sized_range<T>())>
  lib::conditional_t<lib::is_forward_range<T>::value, lib::range_reference_t<T>, lib::range_value_t<T>>
  operator()(lib::atom id, T &range) const {
    auto it = lib::begin(range);
    auto index = gen::range(id, 0, lib::size(range));
    std::advance(it, index);
    return *it;
  }
 
  template<typename T, HALCHECK_REQUIRE(lib::is_forward_range<T>()), HALCHECK_REQUIRE(!lib::is_sized_range<T>())>
  lib::range_reference_t<T> operator()(lib::atom id, T &range) const {
    return *gen::range(id, lib::begin(range), lib::end(range));
  }
 
  template<
      typename T,
      HALCHECK_REQUIRE(
          (lib::is_input_range<lib::remove_reference_t<T>>() && lib::is_sized_range<lib::remove_reference_t<T>>()) ||
          lib::is_forward_range<lib::remove_reference_t<T>>()),
      HALCHECK_REQUIRE(!std::is_lvalue_reference<T>())>
  lib::range_value_t<lib::remove_reference_t<T>> operator()(lib::atom id, T &&range) const {
    return std::move((*this)(id, range));
  }
} element_of;
 
HALCHECK_INLINE_CONSTEXPR struct {
  template<typename... Args>
  lib::common_type_t<Args...> operator()(lib::atom id, Args &&...args) const {
    std::array<lib::common_type_t<Args...>, sizeof...(Args)> range{std::forward<Args>(args)...};
    return gen::element_of(id, std::move(range));
  }
} element;
 
// TODO: weighted_element_of, weighted_element
 
}} // namespace halcheck::gen
 
#endif