From 7390c358f51edaf82f0836989fd25e429f22d970 Mon Sep 17 00:00:00 2001 From: Thaddeus Crews Date: Tue, 14 Oct 2025 18:52:47 -0500 Subject: [PATCH] Core: Consolidate typed container logic --- core/variant/method_ptrcall.h | 22 +++ core/variant/type_info.h | 54 ++++++ core/variant/typed_array.h | 184 +-------------------- core/variant/typed_dictionary.h | 282 ++------------------------------ core/variant/variant.h | 14 ++ core/variant/variant_internal.h | 12 ++ 6 files changed, 117 insertions(+), 451 deletions(-) diff --git a/core/variant/method_ptrcall.h b/core/variant/method_ptrcall.h index 639a3d2933e..886b1facb20 100644 --- a/core/variant/method_ptrcall.h +++ b/core/variant/method_ptrcall.h @@ -335,3 +335,25 @@ struct PtrToArg> { } } }; + +template +struct PtrToArg> { + _FORCE_INLINE_ static TypedArray convert(const void *p_ptr) { + return TypedArray(*reinterpret_cast(p_ptr)); + } + typedef Array EncodeT; + _FORCE_INLINE_ static void encode(TypedArray p_val, void *p_ptr) { + *(Array *)p_ptr = p_val; + } +}; + +template +struct PtrToArg> { + _FORCE_INLINE_ static TypedDictionary convert(const void *p_ptr) { + return TypedDictionary(*reinterpret_cast(p_ptr)); + } + typedef Dictionary EncodeT; + _FORCE_INLINE_ static void encode(TypedDictionary p_val, void *p_ptr) { + *(Dictionary *)p_ptr = p_val; + } +}; diff --git a/core/variant/type_info.h b/core/variant/type_info.h index b6e4f21c1ce..c52885e7131 100644 --- a/core/variant/type_info.h +++ b/core/variant/type_info.h @@ -246,3 +246,57 @@ struct ZeroInitializer { } } }; + +namespace GodotTypeInfo { +namespace Internal { + +template +Variant::Type get_variant_type() { + if constexpr (std::is_base_of_v) { + return Variant::Type::OBJECT; + } else { + return GetTypeInfo::VARIANT_TYPE; + } +} + +template +const String get_object_class_name_or_empty() { + if constexpr (std::is_base_of_v) { + return T::get_class_static(); + } else { + return ""; + } +} + +template +const String get_variant_type_identifier() { + if constexpr (std::is_base_of_v) { + return T::get_class_static(); + } else if constexpr (std::is_same_v) { + return "Variant"; + } else { + return Variant::get_type_name(GetTypeInfo::VARIANT_TYPE); + } +} + +} //namespace Internal +} //namespace GodotTypeInfo + +template +struct GetTypeInfo> { + static const Variant::Type VARIANT_TYPE = Variant::ARRAY; + static const GodotTypeInfo::Metadata METADATA = GodotTypeInfo::METADATA_NONE; + static inline PropertyInfo get_class_info() { + return PropertyInfo(Variant::ARRAY, String(), PROPERTY_HINT_ARRAY_TYPE, GodotTypeInfo::Internal::get_variant_type_identifier()); + } +}; + +template +struct GetTypeInfo> { + static const Variant::Type VARIANT_TYPE = Variant::DICTIONARY; + static const GodotTypeInfo::Metadata METADATA = GodotTypeInfo::METADATA_NONE; + static inline PropertyInfo get_class_info() { + return PropertyInfo(Variant::DICTIONARY, String(), PROPERTY_HINT_DICTIONARY_TYPE, + vformat("%s;%s", GodotTypeInfo::Internal::get_variant_type_identifier(), GodotTypeInfo::Internal::get_variant_type_identifier())); + } +}; diff --git a/core/variant/typed_array.h b/core/variant/typed_array.h index bb1412f5c4f..f456367ca2e 100644 --- a/core/variant/typed_array.h +++ b/core/variant/typed_array.h @@ -30,12 +30,7 @@ #pragma once -#include "core/object/object.h" -#include "core/variant/array.h" -#include "core/variant/binder_common.h" -#include "core/variant/method_ptrcall.h" #include "core/variant/type_info.h" -#include "core/variant/variant.h" template class TypedArray : public Array { @@ -44,189 +39,20 @@ public: ERR_FAIL_COND_MSG(!is_same_typed(p_array), "Cannot assign an array with a different element type."); Array::operator=(p_array); } - _FORCE_INLINE_ TypedArray(const Variant &p_variant) : - TypedArray(Array(p_variant)) { - } + _FORCE_INLINE_ TypedArray(const Array &p_array) { - set_typed(Variant::OBJECT, T::get_class_static(), Variant()); + set_typed(GodotTypeInfo::Internal::get_variant_type(), GodotTypeInfo::Internal::get_object_class_name_or_empty(), Variant()); if (is_same_typed(p_array)) { Array::operator=(p_array); } else { assign(p_array); } } + _FORCE_INLINE_ TypedArray(std::initializer_list p_init) : TypedArray(Array(p_init)) {} + _FORCE_INLINE_ TypedArray() { - set_typed(Variant::OBJECT, T::get_class_static(), Variant()); + set_typed(GodotTypeInfo::Internal::get_variant_type(), GodotTypeInfo::Internal::get_object_class_name_or_empty(), Variant()); } }; - -template -struct VariantInternalAccessor> { - static _FORCE_INLINE_ TypedArray get(const Variant *v) { return *VariantInternal::get_array(v); } - static _FORCE_INLINE_ void set(Variant *v, const TypedArray &p_array) { *VariantInternal::get_array(v) = p_array; } -}; -template -struct VariantInternalAccessor &> { - static _FORCE_INLINE_ TypedArray get(const Variant *v) { return *VariantInternal::get_array(v); } - static _FORCE_INLINE_ void set(Variant *v, const TypedArray &p_array) { *VariantInternal::get_array(v) = p_array; } -}; - -//specialization for the rest of variant types - -#define MAKE_TYPED_ARRAY(m_type, m_variant_type) \ - template <> \ - class TypedArray : public Array { \ - public: \ - _FORCE_INLINE_ void operator=(const Array &p_array) { \ - ERR_FAIL_COND_MSG(!is_same_typed(p_array), "Cannot assign an array with a different element type."); \ - Array::operator=(p_array); \ - } \ - _FORCE_INLINE_ TypedArray(std::initializer_list p_init) : \ - Array(Array(p_init), m_variant_type, StringName(), Variant()) { \ - } \ - _FORCE_INLINE_ TypedArray(const Variant &p_variant) : \ - TypedArray(Array(p_variant)) { \ - } \ - _FORCE_INLINE_ TypedArray(const Array &p_array) { \ - set_typed(m_variant_type, StringName(), Variant()); \ - if (is_same_typed(p_array)) { \ - Array::operator=(p_array); \ - } else { \ - assign(p_array); \ - } \ - } \ - _FORCE_INLINE_ TypedArray() { \ - set_typed(m_variant_type, StringName(), Variant()); \ - } \ - }; - -// All Variant::OBJECT types are intentionally omitted from this list because they are handled by -// the unspecialized TypedArray definition. -MAKE_TYPED_ARRAY(bool, Variant::BOOL) -MAKE_TYPED_ARRAY(uint8_t, Variant::INT) -MAKE_TYPED_ARRAY(int8_t, Variant::INT) -MAKE_TYPED_ARRAY(uint16_t, Variant::INT) -MAKE_TYPED_ARRAY(int16_t, Variant::INT) -MAKE_TYPED_ARRAY(uint32_t, Variant::INT) -MAKE_TYPED_ARRAY(int32_t, Variant::INT) -MAKE_TYPED_ARRAY(uint64_t, Variant::INT) -MAKE_TYPED_ARRAY(int64_t, Variant::INT) -MAKE_TYPED_ARRAY(float, Variant::FLOAT) -MAKE_TYPED_ARRAY(double, Variant::FLOAT) -MAKE_TYPED_ARRAY(String, Variant::STRING) -MAKE_TYPED_ARRAY(Vector2, Variant::VECTOR2) -MAKE_TYPED_ARRAY(Vector2i, Variant::VECTOR2I) -MAKE_TYPED_ARRAY(Rect2, Variant::RECT2) -MAKE_TYPED_ARRAY(Rect2i, Variant::RECT2I) -MAKE_TYPED_ARRAY(Vector3, Variant::VECTOR3) -MAKE_TYPED_ARRAY(Vector3i, Variant::VECTOR3I) -MAKE_TYPED_ARRAY(Transform2D, Variant::TRANSFORM2D) -MAKE_TYPED_ARRAY(Vector4, Variant::VECTOR4) -MAKE_TYPED_ARRAY(Vector4i, Variant::VECTOR4I) -MAKE_TYPED_ARRAY(Plane, Variant::PLANE) -MAKE_TYPED_ARRAY(Quaternion, Variant::QUATERNION) -MAKE_TYPED_ARRAY(AABB, Variant::AABB) -MAKE_TYPED_ARRAY(Basis, Variant::BASIS) -MAKE_TYPED_ARRAY(Transform3D, Variant::TRANSFORM3D) -MAKE_TYPED_ARRAY(Projection, Variant::PROJECTION) -MAKE_TYPED_ARRAY(Color, Variant::COLOR) -MAKE_TYPED_ARRAY(StringName, Variant::STRING_NAME) -MAKE_TYPED_ARRAY(NodePath, Variant::NODE_PATH) -MAKE_TYPED_ARRAY(RID, Variant::RID) -MAKE_TYPED_ARRAY(Callable, Variant::CALLABLE) -MAKE_TYPED_ARRAY(Signal, Variant::SIGNAL) -MAKE_TYPED_ARRAY(Dictionary, Variant::DICTIONARY) -MAKE_TYPED_ARRAY(Array, Variant::ARRAY) -MAKE_TYPED_ARRAY(PackedByteArray, Variant::PACKED_BYTE_ARRAY) -MAKE_TYPED_ARRAY(PackedInt32Array, Variant::PACKED_INT32_ARRAY) -MAKE_TYPED_ARRAY(PackedInt64Array, Variant::PACKED_INT64_ARRAY) -MAKE_TYPED_ARRAY(PackedFloat32Array, Variant::PACKED_FLOAT32_ARRAY) -MAKE_TYPED_ARRAY(PackedFloat64Array, Variant::PACKED_FLOAT64_ARRAY) -MAKE_TYPED_ARRAY(PackedStringArray, Variant::PACKED_STRING_ARRAY) -MAKE_TYPED_ARRAY(PackedVector2Array, Variant::PACKED_VECTOR2_ARRAY) -MAKE_TYPED_ARRAY(PackedVector3Array, Variant::PACKED_VECTOR3_ARRAY) -MAKE_TYPED_ARRAY(PackedColorArray, Variant::PACKED_COLOR_ARRAY) -MAKE_TYPED_ARRAY(PackedVector4Array, Variant::PACKED_VECTOR4_ARRAY) -MAKE_TYPED_ARRAY(IPAddress, Variant::STRING) - -template -struct PtrToArg> { - _FORCE_INLINE_ static TypedArray convert(const void *p_ptr) { - return TypedArray(*reinterpret_cast(p_ptr)); - } - typedef Array EncodeT; - _FORCE_INLINE_ static void encode(TypedArray p_val, void *p_ptr) { - *(Array *)p_ptr = p_val; - } -}; - -template -struct GetTypeInfo> { - static const Variant::Type VARIANT_TYPE = Variant::ARRAY; - static const GodotTypeInfo::Metadata METADATA = GodotTypeInfo::METADATA_NONE; - static inline PropertyInfo get_class_info() { - return PropertyInfo(Variant::ARRAY, String(), PROPERTY_HINT_ARRAY_TYPE, T::get_class_static()); - } -}; - -#define MAKE_TYPED_ARRAY_INFO(m_type, m_variant_type) \ - template <> \ - struct GetTypeInfo> { \ - static const Variant::Type VARIANT_TYPE = Variant::ARRAY; \ - static const GodotTypeInfo::Metadata METADATA = GodotTypeInfo::METADATA_NONE; \ - static inline PropertyInfo get_class_info() { \ - return PropertyInfo(Variant::ARRAY, String(), PROPERTY_HINT_ARRAY_TYPE, Variant::get_type_name(m_variant_type)); \ - } \ - }; - -MAKE_TYPED_ARRAY_INFO(bool, Variant::BOOL) -MAKE_TYPED_ARRAY_INFO(uint8_t, Variant::INT) -MAKE_TYPED_ARRAY_INFO(int8_t, Variant::INT) -MAKE_TYPED_ARRAY_INFO(uint16_t, Variant::INT) -MAKE_TYPED_ARRAY_INFO(int16_t, Variant::INT) -MAKE_TYPED_ARRAY_INFO(uint32_t, Variant::INT) -MAKE_TYPED_ARRAY_INFO(int32_t, Variant::INT) -MAKE_TYPED_ARRAY_INFO(uint64_t, Variant::INT) -MAKE_TYPED_ARRAY_INFO(int64_t, Variant::INT) -MAKE_TYPED_ARRAY_INFO(float, Variant::FLOAT) -MAKE_TYPED_ARRAY_INFO(double, Variant::FLOAT) -MAKE_TYPED_ARRAY_INFO(String, Variant::STRING) -MAKE_TYPED_ARRAY_INFO(Vector2, Variant::VECTOR2) -MAKE_TYPED_ARRAY_INFO(Vector2i, Variant::VECTOR2I) -MAKE_TYPED_ARRAY_INFO(Rect2, Variant::RECT2) -MAKE_TYPED_ARRAY_INFO(Rect2i, Variant::RECT2I) -MAKE_TYPED_ARRAY_INFO(Vector3, Variant::VECTOR3) -MAKE_TYPED_ARRAY_INFO(Vector3i, Variant::VECTOR3I) -MAKE_TYPED_ARRAY_INFO(Transform2D, Variant::TRANSFORM2D) -MAKE_TYPED_ARRAY_INFO(Vector4, Variant::VECTOR4) -MAKE_TYPED_ARRAY_INFO(Vector4i, Variant::VECTOR4I) -MAKE_TYPED_ARRAY_INFO(Plane, Variant::PLANE) -MAKE_TYPED_ARRAY_INFO(Quaternion, Variant::QUATERNION) -MAKE_TYPED_ARRAY_INFO(AABB, Variant::AABB) -MAKE_TYPED_ARRAY_INFO(Basis, Variant::BASIS) -MAKE_TYPED_ARRAY_INFO(Transform3D, Variant::TRANSFORM3D) -MAKE_TYPED_ARRAY_INFO(Projection, Variant::PROJECTION) -MAKE_TYPED_ARRAY_INFO(Color, Variant::COLOR) -MAKE_TYPED_ARRAY_INFO(StringName, Variant::STRING_NAME) -MAKE_TYPED_ARRAY_INFO(NodePath, Variant::NODE_PATH) -MAKE_TYPED_ARRAY_INFO(RID, Variant::RID) -MAKE_TYPED_ARRAY_INFO(Callable, Variant::CALLABLE) -MAKE_TYPED_ARRAY_INFO(Signal, Variant::SIGNAL) -MAKE_TYPED_ARRAY_INFO(Dictionary, Variant::DICTIONARY) -MAKE_TYPED_ARRAY_INFO(Array, Variant::ARRAY) -MAKE_TYPED_ARRAY_INFO(PackedByteArray, Variant::PACKED_BYTE_ARRAY) -MAKE_TYPED_ARRAY_INFO(PackedInt32Array, Variant::PACKED_INT32_ARRAY) -MAKE_TYPED_ARRAY_INFO(PackedInt64Array, Variant::PACKED_INT64_ARRAY) -MAKE_TYPED_ARRAY_INFO(PackedFloat32Array, Variant::PACKED_FLOAT32_ARRAY) -MAKE_TYPED_ARRAY_INFO(PackedFloat64Array, Variant::PACKED_FLOAT64_ARRAY) -MAKE_TYPED_ARRAY_INFO(PackedStringArray, Variant::PACKED_STRING_ARRAY) -MAKE_TYPED_ARRAY_INFO(PackedVector2Array, Variant::PACKED_VECTOR2_ARRAY) -MAKE_TYPED_ARRAY_INFO(PackedVector3Array, Variant::PACKED_VECTOR3_ARRAY) -MAKE_TYPED_ARRAY_INFO(PackedColorArray, Variant::PACKED_COLOR_ARRAY) -MAKE_TYPED_ARRAY_INFO(PackedVector4Array, Variant::PACKED_VECTOR4_ARRAY) -MAKE_TYPED_ARRAY_INFO(IPAddress, Variant::STRING) - -#undef MAKE_TYPED_ARRAY -#undef MAKE_TYPED_ARRAY_INFO diff --git a/core/variant/typed_dictionary.h b/core/variant/typed_dictionary.h index e75c8a1b3bb..ab2f67fc980 100644 --- a/core/variant/typed_dictionary.h +++ b/core/variant/typed_dictionary.h @@ -30,293 +30,31 @@ #pragma once -#include "core/object/object.h" -#include "core/variant/binder_common.h" -#include "core/variant/dictionary.h" -#include "core/variant/method_ptrcall.h" #include "core/variant/type_info.h" -#include "core/variant/variant.h" template class TypedDictionary : public Dictionary { public: _FORCE_INLINE_ void operator=(const Dictionary &p_dictionary) { - ERR_FAIL_COND_MSG(!is_same_typed(p_dictionary), "Cannot assign a dictionary with a different element type."); + ERR_FAIL_COND_MSG(!is_same_typed(p_dictionary), "Cannot assign a dictionary with different element types."); Dictionary::operator=(p_dictionary); } - _FORCE_INLINE_ TypedDictionary(const Variant &p_variant) : - TypedDictionary(Dictionary(p_variant)) { - } + _FORCE_INLINE_ TypedDictionary(const Dictionary &p_dictionary) { - set_typed(Variant::OBJECT, K::get_class_static(), Variant(), Variant::OBJECT, V::get_class_static(), Variant()); + set_typed(GodotTypeInfo::Internal::get_variant_type(), GodotTypeInfo::Internal::get_object_class_name_or_empty(), Variant(), + GodotTypeInfo::Internal::get_variant_type(), GodotTypeInfo::Internal::get_object_class_name_or_empty(), Variant()); if (is_same_typed(p_dictionary)) { Dictionary::operator=(p_dictionary); } else { assign(p_dictionary); } } + + _FORCE_INLINE_ TypedDictionary(std::initializer_list> p_init) : + TypedDictionary(Dictionary(p_init)) {} + _FORCE_INLINE_ TypedDictionary() { - set_typed(Variant::OBJECT, K::get_class_static(), Variant(), Variant::OBJECT, V::get_class_static(), Variant()); - } - - _FORCE_INLINE_ TypedDictionary(std::initializer_list> p_init) : - Dictionary() { - set_typed(Variant::OBJECT, K::get_class_static(), Variant(), Variant::OBJECT, V::get_class_static(), Variant()); - for (const KeyValue &E : p_init) { - operator[](E.key) = E.value; - } + set_typed(GodotTypeInfo::Internal::get_variant_type(), GodotTypeInfo::Internal::get_object_class_name_or_empty(), Variant(), + GodotTypeInfo::Internal::get_variant_type(), GodotTypeInfo::Internal::get_object_class_name_or_empty(), Variant()); } }; - -template -struct VariantInternalAccessor> { - static _FORCE_INLINE_ TypedDictionary get(const Variant *v) { return *VariantInternal::get_dictionary(v); } - static _FORCE_INLINE_ void set(Variant *v, const TypedDictionary &p_dictionary) { *VariantInternal::get_dictionary(v) = p_dictionary; } -}; - -template -struct VariantInternalAccessor &> { - static _FORCE_INLINE_ TypedDictionary get(const Variant *v) { return *VariantInternal::get_dictionary(v); } - static _FORCE_INLINE_ void set(Variant *v, const TypedDictionary &p_dictionary) { *VariantInternal::get_dictionary(v) = p_dictionary; } -}; - -template -struct PtrToArg> { - _FORCE_INLINE_ static TypedDictionary convert(const void *p_ptr) { - return TypedDictionary(*reinterpret_cast(p_ptr)); - } - typedef Dictionary EncodeT; - _FORCE_INLINE_ static void encode(TypedDictionary p_val, void *p_ptr) { - *(Dictionary *)p_ptr = p_val; - } -}; - -template -struct GetTypeInfo> { - static const Variant::Type VARIANT_TYPE = Variant::DICTIONARY; - static const GodotTypeInfo::Metadata METADATA = GodotTypeInfo::METADATA_NONE; - static inline PropertyInfo get_class_info() { - return PropertyInfo(Variant::DICTIONARY, String(), PROPERTY_HINT_DICTIONARY_TYPE, vformat("%s;%s", K::get_class_static(), V::get_class_static())); - } -}; - -// Specialization for the rest of the Variant types. - -#define MAKE_TYPED_DICTIONARY_WITH_OBJECT(m_type, m_variant_type) \ - template \ - class TypedDictionary : public Dictionary { \ - public: \ - _FORCE_INLINE_ void operator=(const Dictionary &p_dictionary) { \ - ERR_FAIL_COND_MSG(!is_same_typed(p_dictionary), "Cannot assign an dictionary with a different element type."); \ - Dictionary::operator=(p_dictionary); \ - } \ - _FORCE_INLINE_ TypedDictionary(const Variant &p_variant) : \ - TypedDictionary(Dictionary(p_variant)) { \ - } \ - _FORCE_INLINE_ TypedDictionary(const Dictionary &p_dictionary) { \ - set_typed(Variant::OBJECT, T::get_class_static(), Variant(), m_variant_type, StringName(), Variant()); \ - if (is_same_typed(p_dictionary)) { \ - Dictionary::operator=(p_dictionary); \ - } else { \ - assign(p_dictionary); \ - } \ - } \ - _FORCE_INLINE_ TypedDictionary() { \ - set_typed(Variant::OBJECT, T::get_class_static(), Variant(), m_variant_type, StringName(), Variant()); \ - } \ - _FORCE_INLINE_ TypedDictionary(std::initializer_list> p_init) : \ - Dictionary() { \ - set_typed(Variant::OBJECT, T::get_class_static(), Variant(), m_variant_type, StringName(), Variant()); \ - for (const KeyValue &E : p_init) { \ - operator[](E.key) = E.value; \ - } \ - } \ - }; \ - template \ - struct GetTypeInfo> { \ - static const Variant::Type VARIANT_TYPE = Variant::DICTIONARY; \ - static const GodotTypeInfo::Metadata METADATA = GodotTypeInfo::METADATA_NONE; \ - static inline PropertyInfo get_class_info() { \ - return PropertyInfo(Variant::DICTIONARY, String(), PROPERTY_HINT_DICTIONARY_TYPE, \ - vformat("%s;%s", T::get_class_static(), m_variant_type == Variant::NIL ? "Variant" : Variant::get_type_name(m_variant_type))); \ - } \ - }; \ - template \ - class TypedDictionary : public Dictionary { \ - public: \ - _FORCE_INLINE_ void operator=(const Dictionary &p_dictionary) { \ - ERR_FAIL_COND_MSG(!is_same_typed(p_dictionary), "Cannot assign an dictionary with a different element type."); \ - Dictionary::operator=(p_dictionary); \ - } \ - _FORCE_INLINE_ TypedDictionary(const Variant &p_variant) : \ - TypedDictionary(Dictionary(p_variant)) { \ - } \ - _FORCE_INLINE_ TypedDictionary(const Dictionary &p_dictionary) { \ - set_typed(m_variant_type, StringName(), Variant(), Variant::OBJECT, T::get_class_static(), Variant()); \ - if (is_same_typed(p_dictionary)) { \ - Dictionary::operator=(p_dictionary); \ - } else { \ - assign(p_dictionary); \ - } \ - } \ - _FORCE_INLINE_ TypedDictionary() { \ - set_typed(m_variant_type, StringName(), Variant(), Variant::OBJECT, T::get_class_static(), Variant()); \ - } \ - _FORCE_INLINE_ TypedDictionary(std::initializer_list> p_init) : \ - Dictionary() { \ - set_typed(m_variant_type, StringName(), Variant(), Variant::OBJECT, std::remove_pointer::type::get_class_static(), Variant()); \ - for (const KeyValue &E : p_init) { \ - operator[](E.key) = E.value; \ - } \ - } \ - }; \ - template \ - struct GetTypeInfo> { \ - static const Variant::Type VARIANT_TYPE = Variant::DICTIONARY; \ - static const GodotTypeInfo::Metadata METADATA = GodotTypeInfo::METADATA_NONE; \ - static inline PropertyInfo get_class_info() { \ - return PropertyInfo(Variant::DICTIONARY, String(), PROPERTY_HINT_DICTIONARY_TYPE, \ - vformat("%s;%s", m_variant_type == Variant::NIL ? "Variant" : Variant::get_type_name(m_variant_type), T::get_class_static())); \ - } \ - }; - -#define MAKE_TYPED_DICTIONARY_EXPANDED(m_type_key, m_variant_type_key, m_type_value, m_variant_type_value) \ - template <> \ - class TypedDictionary : public Dictionary { \ - public: \ - _FORCE_INLINE_ void operator=(const Dictionary &p_dictionary) { \ - ERR_FAIL_COND_MSG(!is_same_typed(p_dictionary), "Cannot assign an dictionary with a different element type."); \ - Dictionary::operator=(p_dictionary); \ - } \ - _FORCE_INLINE_ TypedDictionary(const Variant &p_variant) : \ - TypedDictionary(Dictionary(p_variant)) { \ - } \ - _FORCE_INLINE_ TypedDictionary(const Dictionary &p_dictionary) { \ - set_typed(m_variant_type_key, StringName(), Variant(), m_variant_type_value, StringName(), Variant()); \ - if (is_same_typed(p_dictionary)) { \ - Dictionary::operator=(p_dictionary); \ - } else { \ - assign(p_dictionary); \ - } \ - } \ - _FORCE_INLINE_ TypedDictionary() { \ - set_typed(m_variant_type_key, StringName(), Variant(), m_variant_type_value, StringName(), Variant()); \ - } \ - _FORCE_INLINE_ TypedDictionary(std::initializer_list> p_init) : \ - Dictionary() { \ - set_typed(m_variant_type_key, StringName(), Variant(), m_variant_type_value, StringName(), Variant()); \ - for (const KeyValue &E : p_init) { \ - operator[](E.key) = E.value; \ - } \ - } \ - }; \ - template <> \ - struct GetTypeInfo> { \ - static const Variant::Type VARIANT_TYPE = Variant::DICTIONARY; \ - static const GodotTypeInfo::Metadata METADATA = GodotTypeInfo::METADATA_NONE; \ - static inline PropertyInfo get_class_info() { \ - return PropertyInfo(Variant::DICTIONARY, String(), PROPERTY_HINT_DICTIONARY_TYPE, \ - vformat("%s;%s", m_variant_type_key == Variant::NIL ? "Variant" : Variant::get_type_name(m_variant_type_key), \ - m_variant_type_value == Variant::NIL ? "Variant" : Variant::get_type_name(m_variant_type_value))); \ - } \ - }; - -#define MAKE_TYPED_DICTIONARY_NIL(m_type, m_variant_type) \ - MAKE_TYPED_DICTIONARY_WITH_OBJECT(m_type, m_variant_type) \ - MAKE_TYPED_DICTIONARY_EXPANDED(m_type, m_variant_type, bool, Variant::BOOL) \ - MAKE_TYPED_DICTIONARY_EXPANDED(m_type, m_variant_type, uint8_t, Variant::INT) \ - MAKE_TYPED_DICTIONARY_EXPANDED(m_type, m_variant_type, int8_t, Variant::INT) \ - MAKE_TYPED_DICTIONARY_EXPANDED(m_type, m_variant_type, uint16_t, Variant::INT) \ - MAKE_TYPED_DICTIONARY_EXPANDED(m_type, m_variant_type, int16_t, Variant::INT) \ - MAKE_TYPED_DICTIONARY_EXPANDED(m_type, m_variant_type, uint32_t, Variant::INT) \ - MAKE_TYPED_DICTIONARY_EXPANDED(m_type, m_variant_type, int32_t, Variant::INT) \ - MAKE_TYPED_DICTIONARY_EXPANDED(m_type, m_variant_type, uint64_t, Variant::INT) \ - MAKE_TYPED_DICTIONARY_EXPANDED(m_type, m_variant_type, int64_t, Variant::INT) \ - MAKE_TYPED_DICTIONARY_EXPANDED(m_type, m_variant_type, float, Variant::FLOAT) \ - MAKE_TYPED_DICTIONARY_EXPANDED(m_type, m_variant_type, double, Variant::FLOAT) \ - MAKE_TYPED_DICTIONARY_EXPANDED(m_type, m_variant_type, String, Variant::STRING) \ - MAKE_TYPED_DICTIONARY_EXPANDED(m_type, m_variant_type, Vector2, Variant::VECTOR2) \ - MAKE_TYPED_DICTIONARY_EXPANDED(m_type, m_variant_type, Vector2i, Variant::VECTOR2I) \ - MAKE_TYPED_DICTIONARY_EXPANDED(m_type, m_variant_type, Rect2, Variant::RECT2) \ - MAKE_TYPED_DICTIONARY_EXPANDED(m_type, m_variant_type, Rect2i, Variant::RECT2I) \ - MAKE_TYPED_DICTIONARY_EXPANDED(m_type, m_variant_type, Vector3, Variant::VECTOR3) \ - MAKE_TYPED_DICTIONARY_EXPANDED(m_type, m_variant_type, Vector3i, Variant::VECTOR3I) \ - MAKE_TYPED_DICTIONARY_EXPANDED(m_type, m_variant_type, Transform2D, Variant::TRANSFORM2D) \ - MAKE_TYPED_DICTIONARY_EXPANDED(m_type, m_variant_type, Plane, Variant::PLANE) \ - MAKE_TYPED_DICTIONARY_EXPANDED(m_type, m_variant_type, Quaternion, Variant::QUATERNION) \ - MAKE_TYPED_DICTIONARY_EXPANDED(m_type, m_variant_type, AABB, Variant::AABB) \ - MAKE_TYPED_DICTIONARY_EXPANDED(m_type, m_variant_type, Basis, Variant::BASIS) \ - MAKE_TYPED_DICTIONARY_EXPANDED(m_type, m_variant_type, Transform3D, Variant::TRANSFORM3D) \ - MAKE_TYPED_DICTIONARY_EXPANDED(m_type, m_variant_type, Color, Variant::COLOR) \ - MAKE_TYPED_DICTIONARY_EXPANDED(m_type, m_variant_type, StringName, Variant::STRING_NAME) \ - MAKE_TYPED_DICTIONARY_EXPANDED(m_type, m_variant_type, NodePath, Variant::NODE_PATH) \ - MAKE_TYPED_DICTIONARY_EXPANDED(m_type, m_variant_type, RID, Variant::RID) \ - MAKE_TYPED_DICTIONARY_EXPANDED(m_type, m_variant_type, Callable, Variant::CALLABLE) \ - MAKE_TYPED_DICTIONARY_EXPANDED(m_type, m_variant_type, Signal, Variant::SIGNAL) \ - MAKE_TYPED_DICTIONARY_EXPANDED(m_type, m_variant_type, Dictionary, Variant::DICTIONARY) \ - MAKE_TYPED_DICTIONARY_EXPANDED(m_type, m_variant_type, Array, Variant::ARRAY) \ - MAKE_TYPED_DICTIONARY_EXPANDED(m_type, m_variant_type, PackedByteArray, Variant::PACKED_BYTE_ARRAY) \ - MAKE_TYPED_DICTIONARY_EXPANDED(m_type, m_variant_type, PackedInt32Array, Variant::PACKED_INT32_ARRAY) \ - MAKE_TYPED_DICTIONARY_EXPANDED(m_type, m_variant_type, PackedInt64Array, Variant::PACKED_INT64_ARRAY) \ - MAKE_TYPED_DICTIONARY_EXPANDED(m_type, m_variant_type, PackedFloat32Array, Variant::PACKED_FLOAT32_ARRAY) \ - MAKE_TYPED_DICTIONARY_EXPANDED(m_type, m_variant_type, PackedFloat64Array, Variant::PACKED_FLOAT64_ARRAY) \ - MAKE_TYPED_DICTIONARY_EXPANDED(m_type, m_variant_type, PackedStringArray, Variant::PACKED_STRING_ARRAY) \ - MAKE_TYPED_DICTIONARY_EXPANDED(m_type, m_variant_type, PackedVector2Array, Variant::PACKED_VECTOR2_ARRAY) \ - MAKE_TYPED_DICTIONARY_EXPANDED(m_type, m_variant_type, PackedVector3Array, Variant::PACKED_VECTOR3_ARRAY) \ - MAKE_TYPED_DICTIONARY_EXPANDED(m_type, m_variant_type, PackedColorArray, Variant::PACKED_COLOR_ARRAY) \ - MAKE_TYPED_DICTIONARY_EXPANDED(m_type, m_variant_type, PackedVector4Array, Variant::PACKED_VECTOR4_ARRAY) \ - MAKE_TYPED_DICTIONARY_EXPANDED(m_type, m_variant_type, IPAddress, Variant::STRING) - -#define MAKE_TYPED_DICTIONARY(m_type, m_variant_type) \ - MAKE_TYPED_DICTIONARY_EXPANDED(m_type, m_variant_type, Variant, Variant::NIL) \ - MAKE_TYPED_DICTIONARY_NIL(m_type, m_variant_type) - -MAKE_TYPED_DICTIONARY_NIL(Variant, Variant::NIL) -MAKE_TYPED_DICTIONARY(bool, Variant::BOOL) -MAKE_TYPED_DICTIONARY(uint8_t, Variant::INT) -MAKE_TYPED_DICTIONARY(int8_t, Variant::INT) -MAKE_TYPED_DICTIONARY(uint16_t, Variant::INT) -MAKE_TYPED_DICTIONARY(int16_t, Variant::INT) -MAKE_TYPED_DICTIONARY(uint32_t, Variant::INT) -MAKE_TYPED_DICTIONARY(int32_t, Variant::INT) -MAKE_TYPED_DICTIONARY(uint64_t, Variant::INT) -MAKE_TYPED_DICTIONARY(int64_t, Variant::INT) -MAKE_TYPED_DICTIONARY(float, Variant::FLOAT) -MAKE_TYPED_DICTIONARY(double, Variant::FLOAT) -MAKE_TYPED_DICTIONARY(String, Variant::STRING) -MAKE_TYPED_DICTIONARY(Vector2, Variant::VECTOR2) -MAKE_TYPED_DICTIONARY(Vector2i, Variant::VECTOR2I) -MAKE_TYPED_DICTIONARY(Rect2, Variant::RECT2) -MAKE_TYPED_DICTIONARY(Rect2i, Variant::RECT2I) -MAKE_TYPED_DICTIONARY(Vector3, Variant::VECTOR3) -MAKE_TYPED_DICTIONARY(Vector3i, Variant::VECTOR3I) -MAKE_TYPED_DICTIONARY(Transform2D, Variant::TRANSFORM2D) -MAKE_TYPED_DICTIONARY(Plane, Variant::PLANE) -MAKE_TYPED_DICTIONARY(Quaternion, Variant::QUATERNION) -MAKE_TYPED_DICTIONARY(AABB, Variant::AABB) -MAKE_TYPED_DICTIONARY(Basis, Variant::BASIS) -MAKE_TYPED_DICTIONARY(Transform3D, Variant::TRANSFORM3D) -MAKE_TYPED_DICTIONARY(Color, Variant::COLOR) -MAKE_TYPED_DICTIONARY(StringName, Variant::STRING_NAME) -MAKE_TYPED_DICTIONARY(NodePath, Variant::NODE_PATH) -MAKE_TYPED_DICTIONARY(RID, Variant::RID) -MAKE_TYPED_DICTIONARY(Callable, Variant::CALLABLE) -MAKE_TYPED_DICTIONARY(Signal, Variant::SIGNAL) -MAKE_TYPED_DICTIONARY(Dictionary, Variant::DICTIONARY) -MAKE_TYPED_DICTIONARY(Array, Variant::ARRAY) -MAKE_TYPED_DICTIONARY(PackedByteArray, Variant::PACKED_BYTE_ARRAY) -MAKE_TYPED_DICTIONARY(PackedInt32Array, Variant::PACKED_INT32_ARRAY) -MAKE_TYPED_DICTIONARY(PackedInt64Array, Variant::PACKED_INT64_ARRAY) -MAKE_TYPED_DICTIONARY(PackedFloat32Array, Variant::PACKED_FLOAT32_ARRAY) -MAKE_TYPED_DICTIONARY(PackedFloat64Array, Variant::PACKED_FLOAT64_ARRAY) -MAKE_TYPED_DICTIONARY(PackedStringArray, Variant::PACKED_STRING_ARRAY) -MAKE_TYPED_DICTIONARY(PackedVector2Array, Variant::PACKED_VECTOR2_ARRAY) -MAKE_TYPED_DICTIONARY(PackedVector3Array, Variant::PACKED_VECTOR3_ARRAY) -MAKE_TYPED_DICTIONARY(PackedColorArray, Variant::PACKED_COLOR_ARRAY) -MAKE_TYPED_DICTIONARY(PackedVector4Array, Variant::PACKED_VECTOR4_ARRAY) -MAKE_TYPED_DICTIONARY(IPAddress, Variant::STRING) - -#undef MAKE_TYPED_DICTIONARY -#undef MAKE_TYPED_DICTIONARY_NIL -#undef MAKE_TYPED_DICTIONARY_EXPANDED -#undef MAKE_TYPED_DICTIONARY_WITH_OBJECT diff --git a/core/variant/variant.h b/core/variant/variant.h index 5b2e7a9631a..44cd11c7be7 100644 --- a/core/variant/variant.h +++ b/core/variant/variant.h @@ -70,6 +70,10 @@ template class Ref; template class BitField; +template +class TypedArray; +template +class TypedDictionary; struct PropertyInfo; struct MethodInfo; @@ -495,6 +499,10 @@ public: _FORCE_INLINE_ operator T() const { return static_cast(operator int64_t()); } template _FORCE_INLINE_ operator BitField() const { return static_cast(operator uint64_t()); } + template + _FORCE_INLINE_ operator TypedArray() const { return operator Array(); } + template + _FORCE_INLINE_ operator TypedDictionary() const { return operator Dictionary(); } Object *get_validated_object() const; Object *get_validated_object_with_check(bool &r_previously_freed) const; @@ -565,6 +573,12 @@ public: template _FORCE_INLINE_ Variant(BitField p_bitfield) : Variant(static_cast(p_bitfield)) {} + template + _FORCE_INLINE_ Variant(const TypedArray &p_typed_array) : + Variant(static_cast(p_typed_array)) {} + template + _FORCE_INLINE_ Variant(const TypedDictionary &p_typed_dictionary) : + Variant(static_cast(p_typed_dictionary)) {} // If this changes the table in variant_op must be updated enum Operator { diff --git a/core/variant/variant_internal.h b/core/variant/variant_internal.h index 68b3f7e3c0e..3fe5f553066 100644 --- a/core/variant/variant_internal.h +++ b/core/variant/variant_internal.h @@ -590,6 +590,18 @@ struct VariantInternalAccessor { static _FORCE_INLINE_ void set(Variant *v, IPAddress p_value) { *VariantInternal::get_string(v) = String(p_value); } }; +template +struct VariantInternalAccessor> { + static _FORCE_INLINE_ TypedArray get(const Variant *v) { return TypedArray(*VariantInternal::get_array(v)); } + static _FORCE_INLINE_ void set(Variant *v, const TypedArray &p_array) { *VariantInternal::get_array(v) = Array(p_array); } +}; + +template +struct VariantInternalAccessor> { + static _FORCE_INLINE_ TypedDictionary get(const Variant *v) { return TypedDictionary(*VariantInternal::get_dictionary(v)); } + static _FORCE_INLINE_ void set(Variant *v, const TypedDictionary &p_dictionary) { *VariantInternal::get_dictionary(v) = Dictionary(p_dictionary); } +}; + template <> struct VariantInternalAccessor { static _FORCE_INLINE_ Object *get(const Variant *v) { return const_cast(*VariantInternal::get_object(v)); }