Added support for enum class (#47)

This change adds support for enum classes as part nautilus vals
Signed-off-by: Nils Schubert <nilslpschubert@gmail.com>
Co-authored-by: Philipp Grulich <philippgrulich@hotmail.de>

nautilus/include/nautilus/val_concepts.hpp

@@ -20,11 +20,11 @@ concept convertible_to_integral = (std::is_convertible_v<T, int> || std::is_conv
 template <typename T>
 concept is_fundamental_val = requires {
 	typename std::remove_reference_t<T>::basic_type; // Ensure T has a member type 'basic_type'
-	requires std::is_fundamental_v<typename std::remove_reference_t<T>::basic_type>; // Ensure 'basic_type' is integral
+	requires !std::is_enum_v<typename std::remove_reference_t<T>::basic_type> && std::is_fundamental_v<typename std::remove_reference_t<T>::basic_type>; // Ensure 'basic_type' is integral
 };
 
 template <typename T>
-concept convertible_to_fundamental = !is_fundamental_val<T> && (convertible_to_integral<T> || std::is_convertible_v<T, float> || std::is_convertible_v<T, double> || std::is_convertible_v<T, bool>);
+concept convertible_to_fundamental = !std::is_enum_v<T> && !is_fundamental_val<T> && (convertible_to_integral<T> || std::is_convertible_v<T, float> || std::is_convertible_v<T, double> || std::is_convertible_v<T, bool>);
 
 template <typename T>
 concept is_arithmetic = std::is_arithmetic_v<T>;

nautilus/include/nautilus/val_enum.hpp

@@ -3,6 +3,7 @@
 #include "nautilus/val_concepts.hpp"
 #include <iostream>
 #include <memory>
+#include <utility>
 
 #ifdef ENABLE_TRACING
 
@@ -20,21 +21,80 @@ class val<T> {
 	using raw_type = underlying_type_t;
 	using basic_type = raw_type;
 
-	val() : value() {}
-
 #ifdef ENABLE_TRACING
-	val(val<underlying_type_t> t) : state(t.state), value((T) details::getRawValue(t)) {}
-	val(val<T>& t) : state(tracing::traceCopy(t.state)), value(t.value) {}
-	val(val<T>&& t) : state(t.state), value(t.value) {}
-	val(T val) : state(tracing::traceConstant((underlying_type_t) val)), value(val) {}
+	template <T>
+	    requires std::is_enum_v<T> && (!std::is_convertible_v<T, std::underlying_type_t<T>>)
+	val(T val) : state(tracing::traceConstant(static_cast<std::underlying_type_t<T>>(val))), value(static_cast<std::underlying_type_t<T>>(val)) {
+	}
+
+	template <T>
+	    requires std::is_enum_v<T> && (!std::is_convertible_v<T, std::underlying_type_t<T>>)
+	val(val<T>& val) : state(tracing::traceConstant(static_cast<std::underlying_type_t<T>>(val))), value(static_cast<std::underlying_type_t<T>>(val)) {
+	}
+	val(val<underlying_type_t> t) : state(t.state), value((T) details::getRawValue(t)) {
+	}
+	val(val<T>& t) : state(tracing::traceCopy(t.state)), value(t.value) {
+	}
+	val(val<T>&& t) : state(t.state), value(t.value) {
+	}
+	val(T val) : state(tracing::traceConstant(static_cast<std::underlying_type_t<T>>(val))), value(val) {
+	}
 #else
-	val(val<underlying_type_t> t) : value((T) details::getRawValue(t)) {}
-	val(val<T>& t) : value(t.value) {}
-	val(T val) : value(val) {}
+	template <T>
+	    requires std::is_enum_v<T> && (!std::is_convertible_v<T, std::underlying_type_t<T>>)
+	val(T val) : value(static_cast<std::underlying_type_t<T>>(val)) {
+	}
+
+	template <T>
+	    requires std::is_enum_v<T> && (!std::is_convertible_v<T, std::underlying_type_t<T>>)
+	val(val<T>& val) : value(static_cast<std::underlying_type_t<T>>(val)) {
+	}
+
+	val(val<underlying_type_t> t) : value((T) details::getRawValue(t)) {
+	}
+	val(val<T>& t) : value(t.value) {
+	}
+	val(T val) : value(val) {
+	}
 #endif
 
+
+	val<bool> operator==(val<T>& other) const {
+#ifdef ENABLE_TRACING
+		if (tracing::inTracer()) {
+			auto tc = tracing::traceBinaryOp(tracing::EQ, Type::b, state, other.state);
+			return val<bool>(tc);
+		}
+#endif
+		return value == other.value;
+	}
+
+	val<bool> operator==(const T& other) const {
+		auto res = val<T>(other);
+		return *this == res;
+	}
+
+	val<bool> operator!=(val<T>& other) const {
+#ifdef ENABLE_TRACING
+		if (tracing::inTracer()) {
+			auto tc = tracing::traceBinaryOp(tracing::NEQ, Type::b, state, other.state);
+			return val<bool>(tc);
+		}
+#endif
+		return value != other.value;
+	}
+
+	val<bool> operator!=(const T& other) const {
+		return *this == val<T>(other);
+	}
+
 	operator val<underlying_type_t>() const {
-		return value;
+#ifdef ENABLE_TRACING
+		if (tracing::inTracer()) {
+			return val<underlying_type_t>(state);
+		}
+#endif
+		return val<underlying_type_t>(static_cast<std::underlying_type_t<T>>(value));
 	}
 
 	val<T>& operator=(const val<T>& other) {
@@ -56,4 +116,10 @@ class val<T> {
 	const T value;
 };
 
+template <typename Type>
+requires std::is_enum_v<Type>
+auto inline make_value(const Type& value) {
+	return val<Type>(value);
+}
+
 } // namespace nautilus

nautilus/test/common/EnumFunction.hpp

@@ -1,15 +1,22 @@
 #pragma once
 
 #include <nautilus/Engine.hpp>
+#include <nautilus/val.hpp>
 
 namespace nautilus {
 
 enum Color { BLUE, GREEN };
+enum class LogLevel : uint8_t { LOG_NONE = 1, LOG_FATAL_ERROR = 2, LOG_ERROR = 3, LOG_WARNING = 4, LOG_INFO = 5, LOG_DEBUG = 6, LOG_TRACE = 7 };
+
 
 val<bool> handleEnum(val<Color> enumVal) {
 	return enumVal == Color::BLUE;
 }
 
+val<bool> handleEnumLogLevel(val<LogLevel> enumVal) {
+	return enumVal == LogLevel::LOG_DEBUG || enumVal == LogLevel::LOG_INFO;
+}
+
 val<int32_t> isEnum(val<Color> enumVal) {
 	if (enumVal == Color::BLUE) {
 		return 1;
@@ -33,7 +40,32 @@ int32_t enumFunction(Color value) {
 	}
 }
 
+auto enumClassFunction(LogLevel level) {
+	switch (level) {
+	case LogLevel::LOG_NONE:
+		return 1;
+	case LogLevel::LOG_FATAL_ERROR:
+		return 2;
+	case LogLevel::LOG_ERROR:
+		return 3;
+	case LogLevel::LOG_WARNING:
+		return 4;
+	case LogLevel::LOG_INFO:
+		return 5;
+	case LogLevel::LOG_DEBUG:
+		return 6;
+	case LogLevel::LOG_TRACE:
+		return 7;
+	}
+
+	return 43;
+}
+
 val<int32_t> callEnumFunction(val<Color> enumVal) {
 	return invoke(enumFunction, enumVal);
 }
-} // namespace nautilus
+
+val<int32_t> callEnumClassFunction(val<LogLevel> enumClassVal) {
+	return invoke(enumClassFunction, enumClassVal);
+}
+} // namespace nautilus

nautilus/test/execution-tests/ExecutionTest.cpp

@@ -86,6 +86,19 @@ void expressionTests(engine::NautilusEngine& engine) {
 		REQUIRE(f((char) CHAR_MIN) == (char) CHAR_MAX);
 	}
 
+	SECTION("callEnumClassFunction") {
+		auto f = engine.registerFunction(callEnumClassFunction);
+		REQUIRE(f(LogLevel::LOG_DEBUG) == 6);
+		REQUIRE(f(LogLevel::LOG_NONE) == 1);
+	}
+
+	SECTION("handleEnumLogLevel") {
+		auto f = engine.registerFunction(handleEnumLogLevel);
+		REQUIRE(f(LogLevel::LOG_INFO));
+		REQUIRE(f(LogLevel::LOG_DEBUG));
+		REQUIRE(!f(LogLevel::LOG_NONE));
+	}
+
 	SECTION("callEnumFunction") {
 		auto f = engine.registerFunction(callEnumFunction);
 		REQUIRE(f(Color::BLUE) == 42);

nautilus/test/execution-tests/TracingTest.cpp

@@ -135,8 +135,8 @@ void runTraceTests(const std::string& category, std::vector<std::tuple<std::stri
 	for (auto& test : tests) {
 		auto func = std::get<1>(test);
 		auto name = std::get<0>(test);
-		auto executionTrace = tracing::TraceContext::trace(func);
 		DYNAMIC_SECTION(name) {
+			auto executionTrace = tracing::TraceContext::trace(func);
 			DYNAMIC_SECTION("tracing") {
 				REQUIRE(checkTestFile(executionTrace.get(), category, "tracing", name));
 			}
@@ -276,6 +276,8 @@ TEST_CASE("Enum Trace Test") {
 	    {"isEnum", details::createFunctionWrapper(isEnum)},
 	    {"getEnum", details::createFunctionWrapper(getEnum)},
 	    {"callEnumFunction", details::createFunctionWrapper(callEnumFunction)},
+	    {"callEnumClassFunction", details::createFunctionWrapper(callEnumClassFunction)},
+	    {"handleEnumLogLevel", details::createFunctionWrapper(handleEnumLogLevel)},
 	};
 	runTraceTests("enum-tests", tests);
 }