variadic_value.hxx

#pragma once
 
#include <StormByte/exception.hxx>
 
#include <variant>
#include <memory>
#include <type_traits>
#include <stdexcept>
#include <concepts>
 
namespace StormByte {
    template <typename T> concept ValidVariadicType =
        (!std::is_pointer_v<T>) &&
        (std::is_same_v<T, std::shared_ptr<typename T::element_type>> ||
            std::is_same_v<T, std::unique_ptr<typename T::element_type>> ||
            !std::is_class_v<T> ||
            std::is_class_v<T>);
 
    template <ValidVariadicType... Types> class VariadicValue {
        public:
            VariadicValue()                             = default;
 
            template <typename T, typename = std::enable_if_t<(std::is_same_v<T, Types> || ...)>>
            explicit VariadicValue(T value) : m_values(std::move(value)) {}
 
            ~VariadicValue() noexcept = default;
 
            VariadicValue(const VariadicValue& other) {
                _processCopy(other.m_values);
            }
 
            VariadicValue& operator=(const VariadicValue& other) {
                if (this != &other) {
                    _processCopy(other.m_values);
                }
                return *this;
            }
 
            VariadicValue(VariadicValue&&) noexcept = default;
 
            VariadicValue& operator=(VariadicValue&&) noexcept = default;
 
            constexpr bool operator==(const VariadicValue& other) const {
                return m_values == other.m_values;
            }
 
            constexpr bool operator!=(const VariadicValue& other) const {
                return !(*this == other);
            }
 
            template <typename T> T& Get() {
                constexpr bool isDirectMatch = (std::is_same_v<T, Types> || ...);
                constexpr bool isDereferencedMatch = (
                    ([]<typename U>() constexpr {
                        if constexpr (std::is_same_v<U, std::shared_ptr<T>> || std::is_same_v<U, std::unique_ptr<T>>) {
                            return true;
                        }
                        return false;
                    }.template operator()<Types>() || ...)
                );
    
                static_assert(isDirectMatch || isDereferencedMatch,
                            "Requested type is not in the variant or is not compatible with smart pointers");
    
                if constexpr (isDirectMatch) {
                    if (std::holds_alternative<T>(m_values)) {
                        return std::get<T>(m_values);
                    }
                    throw Exception("Variant does not hold the requested type");
                }
    
                if constexpr (isDereferencedMatch) {
                    return std::visit([](auto& value) -> T& {
                        using ValueType = std::decay_t<decltype(value)>;
                        if constexpr (std::is_same_v<ValueType, std::shared_ptr<T>> || std::is_same_v<ValueType, std::unique_ptr<T>>) {
                            if (value) {
                                return *value;
                            }
                            throw Exception("Pointer is null");
                        }
                        throw Exception("Invalid type for dereferencing");
                    }, m_values);
                }
    
                throw Exception("Value type mismatch");
            }
 
            template <typename T> const T& Get() const {
                return const_cast<VariadicValue*>(this)->Get<T>();
            }
 
        private:
            template <typename T>
            struct is_unique_ptr : std::false_type {};
        
            template <typename T>
            struct is_unique_ptr<std::unique_ptr<T>> : std::true_type {};
        
            template <typename T>
            struct is_shared_ptr : std::false_type {};
        
            template <typename T>
            struct is_shared_ptr<std::shared_ptr<T>> : std::true_type {};
        
            void _processCopy(const std::variant<Types...>& variant) {
                std::visit([this](const auto& value) {
                    using ValueType = std::decay_t<decltype(value)>;
                    if constexpr (is_unique_ptr<ValueType>::value) {
                        // Handle std::unique_ptr<Foo>
                        using Foo = typename ValueType::element_type;
                        if constexpr (!std::is_abstract_v<Foo>) { // Only process non-abstract types
                            if (value) {
                                m_values = std::make_unique<Foo>(*value);
                            } else {
                                m_values = std::unique_ptr<Foo>(); // Assign a null unique_ptr
                            }
                        } else {
                            static_assert(!std::is_abstract_v<Foo>, "Abstract classes cannot be copied directly");
                        }
                    } else if constexpr (is_shared_ptr<ValueType>::value) {
                        // Copy shared_ptr (no deep copy necessary)
                        m_values = value;
                    } else {
                        // For other types, simply copy the value
                        m_values = value;
                    }
                }, variant);
            }       
 
            std::variant<Types...> m_values;
    };
}