default.h

#pragma once
 
#include <map>
#include <optional>
#include <set>
#include <variant>
#include <vector>
 
#include <rfl.hpp>
 
#include "hegel/core.h"
#include "hegel/generators/builds.h"
#include "hegel/generators/collections.h"
#include "hegel/generators/combinators.h"
#include "hegel/generators/numeric.h"
#include "hegel/generators/primitives.h"
#include "hegel/generators/strings.h"
 
namespace hegel::generators {

 
    template <typename T> class DerivedGenerator;
 
    // Forward declaration — defined below after all specializations
    template <typename T> DerivedGenerator<T> default_generator();

    namespace detail {
 
        // =================================================================
        // Type traits for container detection
        // =================================================================
 
        template <typename T> struct is_vector : std::false_type {};
        template <typename T>
        struct is_vector<std::vector<T>> : std::true_type {};
 
        template <typename T> struct is_set : std::false_type {};
        template <typename T> struct is_set<std::set<T>> : std::true_type {};
 
        template <typename T> struct is_map : std::false_type {};
        template <typename K, typename V>
        struct is_map<std::map<K, V>> : std::true_type {};
 
        template <typename T> struct is_optional : std::false_type {};
        template <typename T>
        struct is_optional<std::optional<T>> : std::true_type {};
 
        template <typename T> struct is_tuple : std::false_type {};
        template <typename... Ts>
        struct is_tuple<std::tuple<Ts...>> : std::true_type {};
 
        template <typename T> struct is_variant : std::false_type {};
        template <typename... Ts>
        struct is_variant<std::variant<Ts...>> : std::true_type {};
 
        // =================================================================
        // Reflectable struct detection
        // =================================================================
 
        template <typename T, typename = void>
        struct is_reflectable_struct : std::false_type {};
 
        template <typename T>
        struct is_reflectable_struct<
            T, std::void_t<decltype(rfl::to_view(std::declval<T&>()))>>
            : std::true_type {};
 
        // =================================================================
        // DefaultGenerator trait — primary template (struct fallback)
        // =================================================================
 
        template <typename T, typename Enable = void> struct DefaultGenerator {
            static_assert(
                is_reflectable_struct<T>::value,
                "default_generator<T>(): T must be a supported primitive, "
                "container, or reflectable struct");
 
            static Generator<T> generator() {
                return compose([](const TestCase& tc) -> T {
                    T result{};
                    auto view = rfl::to_view(result);
                    view.apply([&tc](const auto& field) {
                        using PtrType =
                            typename std::remove_cvref_t<decltype(field)>::Type;
                        using FieldType = std::remove_pointer_t<PtrType>;
                        *field.value() =
                            default_generator<FieldType>().do_draw(tc);
                    });
                    return result;
                });
            }
        };
 
        // =================================================================
        // Specializations for primitive types
        // =================================================================
 
        template <> struct DefaultGenerator<bool> {
            static Generator<bool> generator() { return booleans(); }
        };
 
        template <> struct DefaultGenerator<std::string> {
            static Generator<std::string> generator() { return text(); }
        };
 
        template <> struct DefaultGenerator<std::monostate> {
            static Generator<std::monostate> generator() {
                return just(std::monostate{});
            }
        };
 
        template <typename T>
        struct DefaultGenerator<T, std::enable_if_t<std::is_integral_v<T> &&
                                                    !std::is_same_v<T, bool>>> {
            static Generator<T> generator() { return integers<T>(); }
        };
 
        template <typename T>
        struct DefaultGenerator<T,
                                std::enable_if_t<std::is_floating_point_v<T>>> {
            static Generator<T> generator() { return floats<T>(); }
        };
 
        // =================================================================
        // Specializations for standard containers
        // =================================================================
 
        template <typename T>
        struct DefaultGenerator<T, std::enable_if_t<is_vector<T>::value>> {
            static Generator<T> generator() {
                using Elem = typename T::value_type;
                return vectors(default_generator<Elem>());
            }
        };
 
        template <typename T>
        struct DefaultGenerator<T, std::enable_if_t<is_set<T>::value>> {
            static Generator<T> generator() {
                using Elem = typename T::value_type;
                return sets(default_generator<Elem>());
            }
        };
 
        template <typename T>
        struct DefaultGenerator<T, std::enable_if_t<is_map<T>::value>> {
            static Generator<T> generator() {
                using K = typename T::key_type;
                using V = typename T::mapped_type;
                return maps(default_generator<K>(), default_generator<V>());
            }
        };
 
        template <typename T>
        struct DefaultGenerator<T, std::enable_if_t<is_optional<T>::value>> {
            static Generator<T> generator() {
                using Inner = typename T::value_type;
                return optional(default_generator<Inner>());
            }
        };
 
        // --- std::tuple<Ts...> ---
 
        template <typename Tuple, size_t... Is>
        auto make_default_tuple_gen(std::index_sequence<Is...>) {
            return tuples(
                default_generator<std::tuple_element_t<Is, Tuple>>()...);
        }
 
        template <typename T>
        struct DefaultGenerator<T, std::enable_if_t<is_tuple<T>::value>> {
            static Generator<T> generator() {
                return make_default_tuple_gen<T>(
                    std::make_index_sequence<std::tuple_size_v<T>>{});
            }
        };
 
        // --- std::variant<Ts...> ---
 
        template <typename Variant, size_t... Is>
        auto make_default_variant_gen(std::index_sequence<Is...>) {
            return variant(default_generator<
                           std::variant_alternative_t<Is, Variant>>()...);
        }
 
        template <typename T>
        struct DefaultGenerator<T, std::enable_if_t<is_variant<T>::value>> {
            static Generator<T> generator() {
                return make_default_variant_gen<T>(
                    std::make_index_sequence<std::variant_size_v<T>>{});
            }
        };
 
    } // namespace detail
 
    // =============================================================================
    // Public API
    // =============================================================================

    template <typename T> class DerivedGenerator : public Generator<T> {
      public:
        DerivedGenerator(Generator<T> base) : Generator<T>(std::move(base)) {}

        template <typename... Fields>
        DerivedGenerator<T> override(Fields... fields) const {
            Generator<T> base = *this;
            auto fields_tuple = std::make_tuple(std::move(fields)...);
            return DerivedGenerator<T>(
                compose([base, fields_tuple](const TestCase& tc) mutable -> T {
                    T result = base.do_draw(tc);
                    std::apply(
                        [&result, &tc](auto&... fs) {
                            ((result.*(std::remove_reference_t<
                                          decltype(fs)>::member_ptr) =
                                  fs.generator.do_draw(tc)),
                             ...);
                        },
                        fields_tuple);
                    return result;
                }));
        }
    };

    template <typename T> DerivedGenerator<T> default_generator() {
        return DerivedGenerator<T>(detail::DefaultGenerator<T>::generator());
    }

 
} // namespace hegel::generators