diff options
| -rw-r--r-- | core/variant/variant_construct.cpp | 234 | ||||
| -rw-r--r-- | core/variant/variant_internal.h | 182 |
2 files changed, 319 insertions, 97 deletions
diff --git a/core/variant/variant_construct.cpp b/core/variant/variant_construct.cpp index 5c71f38ef1..5281265294 100644 --- a/core/variant/variant_construct.cpp +++ b/core/variant/variant_construct.cpp @@ -448,6 +448,90 @@ public: } }; +template <class T> +class VariantConstructNoArgs { +public: + static void construct(Variant &r_ret, const Variant **p_args, Callable::CallError &r_error) { + VariantTypeChanger<T>::change_and_reset(&r_ret); + r_error.error = Callable::CallError::CALL_OK; + } + + static void validated_construct(Variant &r_ret, const Variant **p_args) { + VariantTypeChanger<T>::change_and_reset(&r_ret); + } + static void ptr_construct(void *base, const void **p_args) { + PtrToArg<T>::encode(T(), base); + } + + static int get_argument_count() { + return 0; + } + + static Variant::Type get_argument_type(int p_arg) { + return Variant::NIL; + } + + static Variant::Type get_base_type() { + return GetTypeInfo<T>::VARIANT_TYPE; + } +}; + +class VariantConstructNoArgsNil { +public: + static void construct(Variant &r_ret, const Variant **p_args, Callable::CallError &r_error) { + VariantInternal::clear(&r_ret); + r_error.error = Callable::CallError::CALL_OK; + } + + static void validated_construct(Variant &r_ret, const Variant **p_args) { + VariantInternal::clear(&r_ret); + } + static void ptr_construct(void *base, const void **p_args) { + ERR_FAIL_MSG("can't ptrcall nil constructor"); + } + + static int get_argument_count() { + return 0; + } + + static Variant::Type get_argument_type(int p_arg) { + return Variant::NIL; + } + + static Variant::Type get_base_type() { + return Variant::NIL; + } +}; + +class VariantConstructNoArgsObject { +public: + static void construct(Variant &r_ret, const Variant **p_args, Callable::CallError &r_error) { + VariantInternal::clear(&r_ret); + VariantInternal::object_assign_null(&r_ret); + r_error.error = Callable::CallError::CALL_OK; + } + + static void validated_construct(Variant &r_ret, const Variant **p_args) { + VariantInternal::clear(&r_ret); + VariantInternal::object_assign_null(&r_ret); + } + static void ptr_construct(void *base, const void **p_args) { + PtrToArg<Object *>::encode(nullptr, base); + } + + static int get_argument_count() { + return 0; + } + + static Variant::Type get_argument_type(int p_arg) { + return Variant::NIL; + } + + static Variant::Type get_base_type() { + return Variant::OBJECT; + } +}; + struct VariantConstructData { void (*construct)(Variant &r_base, const Variant **p_args, Callable::CallError &r_error); Variant::ValidatedConstructor validated_construct; @@ -459,35 +543,6 @@ struct VariantConstructData { static LocalVector<VariantConstructData> construct_data[Variant::VARIANT_MAX]; -static void variant_initialize_nil(Variant *v) { - VariantInternal::clear(v); -} - -template <class T> -static void variant_initialize(Variant *v) { - VariantTypeChanger<T>::change(v); -} - -template <class T> -static void variant_initialize_zero(Variant *v) { - VariantTypeChanger<T>::change(v); - *VariantGetInternalPtr<T>::get_ptr(v) = 0; -} - -static void variant_initialize_false(Variant *v) { - VariantTypeChanger<bool>::change(v); - *VariantGetInternalPtr<bool>::get_ptr(v) = false; -} - -static void variant_initialize_obj(Variant *v) { - VariantInternal::clear(v); - VariantInternal::object_assign_null(v); -} - -typedef void (*VariantInitializeFunc)(Variant *v); - -static VariantInitializeFunc initialize_funcs[Variant::VARIANT_MAX]; - template <class T> static void add_constructor(const Vector<String> &arg_names) { ERR_FAIL_COND_MSG(arg_names.size() != T::get_argument_count(), "Argument names size mismatch for " + Variant::get_type_name(T::get_base_type()) + "."); @@ -503,93 +558,119 @@ static void add_constructor(const Vector<String> &arg_names) { } void Variant::_register_variant_constructors() { + add_constructor<VariantConstructNoArgsNil>(sarray()); add_constructor<VariantConstructorNil>(sarray("from")); + add_constructor<VariantConstructNoArgs<bool>>(sarray()); add_constructor<VariantConstructor<bool, bool>>(sarray("from")); add_constructor<VariantConstructor<bool, int64_t>>(sarray("from")); add_constructor<VariantConstructor<bool, double>>(sarray("from")); + add_constructor<VariantConstructNoArgs<int64_t>>(sarray()); add_constructor<VariantConstructor<int64_t, int64_t>>(sarray("from")); add_constructor<VariantConstructor<int64_t, double>>(sarray("from")); + add_constructor<VariantConstructNoArgs<double>>(sarray()); add_constructor<VariantConstructor<double, double>>(sarray("from")); add_constructor<VariantConstructor<double, int64_t>>(sarray("from")); + add_constructor<VariantConstructNoArgs<String>>(sarray()); add_constructor<VariantConstructor<String, String>>(sarray("from")); add_constructor<VariantConstructor<String, StringName>>(sarray("from")); add_constructor<VariantConstructor<String, NodePath>>(sarray("from")); + add_constructor<VariantConstructNoArgs<Vector2>>(sarray()); add_constructor<VariantConstructor<Vector2, Vector2>>(sarray("from")); add_constructor<VariantConstructor<Vector2, Vector2i>>(sarray("from")); add_constructor<VariantConstructor<Vector2, double, double>>(sarray("x", "y")); + add_constructor<VariantConstructNoArgs<Vector2i>>(sarray()); add_constructor<VariantConstructor<Vector2i, Vector2i>>(sarray("from")); add_constructor<VariantConstructor<Vector2i, Vector2>>(sarray("from")); add_constructor<VariantConstructor<Vector2i, int64_t, int64_t>>(sarray("x", "y")); + add_constructor<VariantConstructNoArgs<Rect2>>(sarray()); add_constructor<VariantConstructor<Rect2, Rect2>>(sarray("from")); add_constructor<VariantConstructor<Rect2, Rect2i>>(sarray("from")); add_constructor<VariantConstructor<Rect2, Vector2, Vector2>>(sarray("position", "size")); add_constructor<VariantConstructor<Rect2, double, double, double, double>>(sarray("x", "y", "width", "height")); + add_constructor<VariantConstructNoArgs<Rect2i>>(sarray()); add_constructor<VariantConstructor<Rect2i, Rect2i>>(sarray("from")); add_constructor<VariantConstructor<Rect2i, Rect2>>(sarray("from")); add_constructor<VariantConstructor<Rect2i, Vector2i, Vector2i>>(sarray("position", "size")); add_constructor<VariantConstructor<Rect2i, int64_t, int64_t, int64_t, int64_t>>(sarray("x", "y", "width", "height")); + add_constructor<VariantConstructNoArgs<Vector3>>(sarray()); add_constructor<VariantConstructor<Vector3, Vector3>>(sarray("from")); add_constructor<VariantConstructor<Vector3, Vector3i>>(sarray("from")); add_constructor<VariantConstructor<Vector3, double, double, double>>(sarray("x", "y", "z")); + add_constructor<VariantConstructNoArgs<Vector3i>>(sarray()); add_constructor<VariantConstructor<Vector3i, Vector3i>>(sarray("from")); add_constructor<VariantConstructor<Vector3i, Vector3>>(sarray("from")); add_constructor<VariantConstructor<Vector3i, int64_t, int64_t, int64_t>>(sarray("x", "y", "z")); + add_constructor<VariantConstructNoArgs<Transform2D>>(sarray()); add_constructor<VariantConstructor<Transform2D, Transform2D>>(sarray("from")); add_constructor<VariantConstructor<Transform2D, Vector2, Vector2, Vector2>>(sarray("x", "y", "origin")); + add_constructor<VariantConstructNoArgs<Plane>>(sarray()); add_constructor<VariantConstructor<Plane, Plane>>(sarray("from")); add_constructor<VariantConstructor<Plane, Vector3, double>>(sarray("normal", "d")); add_constructor<VariantConstructor<Plane, Vector3, Vector3>>(sarray("point", "normal")); add_constructor<VariantConstructor<Plane, Vector3, Vector3, Vector3>>(sarray("point1", "point2", "point3")); + add_constructor<VariantConstructNoArgs<Quat>>(sarray()); add_constructor<VariantConstructor<Quat, Quat>>(sarray("from")); add_constructor<VariantConstructor<Quat, Basis>>(sarray("from")); add_constructor<VariantConstructor<Quat, Vector3>>(sarray("euler")); add_constructor<VariantConstructor<Quat, Vector3, double>>(sarray("axis", "angle")); add_constructor<VariantConstructor<Quat, Vector3, Vector3>>(sarray("arc_from", "arc_to")); + add_constructor<VariantConstructNoArgs<::AABB>>(sarray()); add_constructor<VariantConstructor<::AABB, ::AABB>>(sarray("from")); add_constructor<VariantConstructor<::AABB, Vector3, Vector3>>(sarray("position", "size")); + add_constructor<VariantConstructNoArgs<Basis>>(sarray()); add_constructor<VariantConstructor<Basis, Basis>>(sarray("from")); add_constructor<VariantConstructor<Basis, Quat>>(sarray("from")); add_constructor<VariantConstructor<Basis, Vector3, Vector3, Vector3>>(sarray("x", "y", "z")); + add_constructor<VariantConstructNoArgs<Transform>>(sarray()); add_constructor<VariantConstructor<Transform, Transform>>(sarray("from")); add_constructor<VariantConstructor<Transform, Basis, Vector3>>(sarray("basis", "origin")); + add_constructor<VariantConstructNoArgs<Color>>(sarray()); add_constructor<VariantConstructor<Color, Color>>(sarray("from")); + add_constructor<VariantConstructNoArgs<StringName>>(sarray()); add_constructor<VariantConstructor<StringName, StringName>>(sarray("from")); add_constructor<VariantConstructor<StringName, String>>(sarray("from")); + add_constructor<VariantConstructNoArgs<NodePath>>(sarray()); add_constructor<VariantConstructor<NodePath, NodePath>>(sarray("from")); add_constructor<VariantConstructor<NodePath, String>>(sarray("from")); + add_constructor<VariantConstructNoArgs<::RID>>(sarray()); add_constructor<VariantConstructor<::RID, ::RID>>(sarray("from")); + add_constructor<VariantConstructNoArgsObject>(sarray()); add_constructor<VariantConstructorObject>(sarray("from")); add_constructor<VariantConstructorNilObject>(sarray("from")); + add_constructor<VariantConstructNoArgs<Callable>>(sarray()); add_constructor<VariantConstructor<Callable, Callable>>(sarray("from")); add_constructor<VariantConstructorCallableArgs>(sarray("object", "method")); + add_constructor<VariantConstructNoArgs<Signal>>(sarray()); add_constructor<VariantConstructor<Signal, Signal>>(sarray("from")); add_constructor<VariantConstructorSignalArgs>(sarray("object", "signal")); + add_constructor<VariantConstructNoArgs<Dictionary>>(sarray()); add_constructor<VariantConstructor<Dictionary, Dictionary>>(sarray("from")); + add_constructor<VariantConstructNoArgs<Array>>(sarray()); add_constructor<VariantConstructor<Array, Array>>(sarray("from")); add_constructor<VariantConstructorToArray<PackedByteArray>>(sarray("from")); add_constructor<VariantConstructorToArray<PackedInt32Array>>(sarray("from")); @@ -601,76 +682,41 @@ void Variant::_register_variant_constructors() { add_constructor<VariantConstructorToArray<PackedVector3Array>>(sarray("from")); add_constructor<VariantConstructorToArray<PackedColorArray>>(sarray("from")); + add_constructor<VariantConstructNoArgs<PackedByteArray>>(sarray()); add_constructor<VariantConstructor<PackedByteArray, PackedByteArray>>(sarray("from")); add_constructor<VariantConstructorFromArray<PackedByteArray>>(sarray("from")); + add_constructor<VariantConstructNoArgs<PackedInt32Array>>(sarray()); add_constructor<VariantConstructor<PackedInt32Array, PackedInt32Array>>(sarray("from")); add_constructor<VariantConstructorFromArray<PackedInt32Array>>(sarray("from")); + add_constructor<VariantConstructNoArgs<PackedInt64Array>>(sarray()); add_constructor<VariantConstructor<PackedInt64Array, PackedInt64Array>>(sarray("from")); add_constructor<VariantConstructorFromArray<PackedInt64Array>>(sarray("from")); + add_constructor<VariantConstructNoArgs<PackedFloat32Array>>(sarray()); add_constructor<VariantConstructor<PackedFloat32Array, PackedFloat32Array>>(sarray("from")); add_constructor<VariantConstructorFromArray<PackedFloat32Array>>(sarray("from")); + add_constructor<VariantConstructNoArgs<PackedFloat64Array>>(sarray()); add_constructor<VariantConstructor<PackedFloat64Array, PackedFloat64Array>>(sarray("from")); add_constructor<VariantConstructorFromArray<PackedFloat64Array>>(sarray("from")); + add_constructor<VariantConstructNoArgs<PackedStringArray>>(sarray()); add_constructor<VariantConstructor<PackedStringArray, PackedStringArray>>(sarray("from")); add_constructor<VariantConstructorFromArray<PackedStringArray>>(sarray("from")); + add_constructor<VariantConstructNoArgs<PackedVector2Array>>(sarray()); add_constructor<VariantConstructor<PackedVector2Array, PackedVector2Array>>(sarray("from")); add_constructor<VariantConstructorFromArray<PackedVector2Array>>(sarray("from")); + add_constructor<VariantConstructNoArgs<PackedVector3Array>>(sarray()); add_constructor<VariantConstructor<PackedVector3Array, PackedVector3Array>>(sarray("from")); add_constructor<VariantConstructorFromArray<PackedVector3Array>>(sarray("from")); + add_constructor<VariantConstructNoArgs<PackedColorArray>>(sarray()); add_constructor<VariantConstructor<PackedColorArray, PackedColorArray>>(sarray("from")); add_constructor<VariantConstructorFromArray<PackedColorArray>>(sarray("from")); - - initialize_funcs[NIL] = variant_initialize_nil; - - // atomic types - initialize_funcs[BOOL] = variant_initialize_false; - initialize_funcs[INT] = variant_initialize_zero<int64_t>; - initialize_funcs[FLOAT] = variant_initialize_zero<double>; - initialize_funcs[STRING] = variant_initialize<String>; - - // math types - initialize_funcs[VECTOR2] = variant_initialize<Vector2>; - initialize_funcs[VECTOR2I] = variant_initialize<Vector2i>; - initialize_funcs[RECT2] = variant_initialize<Rect2>; - initialize_funcs[RECT2I] = variant_initialize<Rect2i>; - initialize_funcs[VECTOR3] = variant_initialize<Vector3>; - initialize_funcs[VECTOR3I] = variant_initialize<Vector3i>; - initialize_funcs[TRANSFORM2D] = variant_initialize<Transform2D>; - initialize_funcs[PLANE] = variant_initialize<Plane>; - initialize_funcs[QUAT] = variant_initialize<Quat>; - initialize_funcs[AABB] = variant_initialize<::AABB>; - initialize_funcs[BASIS] = variant_initialize<Basis>; - initialize_funcs[TRANSFORM] = variant_initialize<Transform>; - - // misc types - initialize_funcs[COLOR] = variant_initialize<Color>; - initialize_funcs[STRING_NAME] = variant_initialize<StringName>; - initialize_funcs[NODE_PATH] = variant_initialize<NodePath>; - initialize_funcs[RID] = variant_initialize<::RID>; - initialize_funcs[OBJECT] = variant_initialize_obj; - initialize_funcs[CALLABLE] = variant_initialize<Callable>; - initialize_funcs[SIGNAL] = variant_initialize<Signal>; - initialize_funcs[DICTIONARY] = variant_initialize<Dictionary>; - initialize_funcs[ARRAY] = variant_initialize<Array>; - - // typed arrays - initialize_funcs[PACKED_BYTE_ARRAY] = variant_initialize<PackedByteArray>; - initialize_funcs[PACKED_INT32_ARRAY] = variant_initialize<PackedInt32Array>; - initialize_funcs[PACKED_INT64_ARRAY] = variant_initialize<PackedInt64Array>; - initialize_funcs[PACKED_FLOAT32_ARRAY] = variant_initialize<PackedFloat32Array>; - initialize_funcs[PACKED_FLOAT64_ARRAY] = variant_initialize<PackedFloat64Array>; - initialize_funcs[PACKED_STRING_ARRAY] = variant_initialize<PackedStringArray>; - initialize_funcs[PACKED_VECTOR2_ARRAY] = variant_initialize<PackedVector2Array>; - initialize_funcs[PACKED_VECTOR3_ARRAY] = variant_initialize<PackedVector3Array>; - initialize_funcs[PACKED_COLOR_ARRAY] = variant_initialize<PackedColorArray>; } void Variant::_unregister_variant_constructors() { @@ -680,35 +726,29 @@ void Variant::_unregister_variant_constructors() { } void Variant::construct(Variant::Type p_type, Variant &base, const Variant **p_args, int p_argcount, Callable::CallError &r_error) { - if (p_argcount == 0) { - initialize_funcs[p_type](&base); - r_error.error = Callable::CallError::CALL_OK; - - } else { - uint32_t s = construct_data[p_type].size(); - for (uint32_t i = 0; i < s; i++) { - int argc = construct_data[p_type][i].argument_count; - if (argc != p_argcount) { - continue; - } - bool args_match = true; - for (int j = 0; j < argc; j++) { - if (!Variant::can_convert_strict(p_args[j]->get_type(), construct_data[p_type][i].get_argument_type(j))) { - args_match = false; - break; - } - } - - if (!args_match) { - continue; + uint32_t s = construct_data[p_type].size(); + for (uint32_t i = 0; i < s; i++) { + int argc = construct_data[p_type][i].argument_count; + if (argc != p_argcount) { + continue; + } + bool args_match = true; + for (int j = 0; j < argc; j++) { + if (!Variant::can_convert_strict(p_args[j]->get_type(), construct_data[p_type][i].get_argument_type(j))) { + args_match = false; + break; } + } - construct_data[p_type][i].construct(base, p_args, r_error); - return; + if (!args_match) { + continue; } - r_error.error = Callable::CallError::CALL_ERROR_INVALID_METHOD; + construct_data[p_type][i].construct(base, p_args, r_error); + return; } + + r_error.error = Callable::CallError::CALL_ERROR_INVALID_METHOD; } int Variant::get_constructor_count(Variant::Type p_type) { diff --git a/core/variant/variant_internal.h b/core/variant/variant_internal.h index eca02ad4ae..3ac7f32dec 100644 --- a/core/variant/variant_internal.h +++ b/core/variant/variant_internal.h @@ -937,6 +937,180 @@ struct VariantInitializer<PackedColorArray> { }; template <class T> +struct VariantZeroAssigner { +}; + +template <> +struct VariantZeroAssigner<bool> { + static _FORCE_INLINE_ void zero(Variant *v) { *VariantInternal::get_bool(v) = false; } +}; + +template <> +struct VariantZeroAssigner<int64_t> { + static _FORCE_INLINE_ void zero(Variant *v) { *VariantInternal::get_int(v) = 0; } +}; + +template <> +struct VariantZeroAssigner<double> { + static _FORCE_INLINE_ void zero(Variant *v) { *VariantInternal::get_float(v) = 0.0; } +}; + +template <> +struct VariantZeroAssigner<float> { + static _FORCE_INLINE_ void zero(Variant *v) { *VariantInternal::get_float(v) = 0.0; } +}; + +template <> +struct VariantZeroAssigner<String> { + static _FORCE_INLINE_ void zero(Variant *v) {} +}; + +template <> +struct VariantZeroAssigner<Vector2> { + static _FORCE_INLINE_ void zero(Variant *v) { *VariantInternal::get_vector2(v) = Vector2(); } +}; + +template <> +struct VariantZeroAssigner<Vector2i> { + static _FORCE_INLINE_ void zero(Variant *v) { *VariantInternal::get_vector2i(v) = Vector2i(); } +}; + +template <> +struct VariantZeroAssigner<Rect2> { + static _FORCE_INLINE_ void zero(Variant *v) { *VariantInternal::get_rect2(v) = Rect2(); } +}; + +template <> +struct VariantZeroAssigner<Rect2i> { + static _FORCE_INLINE_ void zero(Variant *v) { *VariantInternal::get_rect2i(v) = Rect2i(); } +}; + +template <> +struct VariantZeroAssigner<Vector3> { + static _FORCE_INLINE_ void zero(Variant *v) { *VariantInternal::get_vector3(v) = Vector3(); } +}; + +template <> +struct VariantZeroAssigner<Vector3i> { + static _FORCE_INLINE_ void zero(Variant *v) { *VariantInternal::get_vector3i(v) = Vector3i(); } +}; + +template <> +struct VariantZeroAssigner<Transform2D> { + static _FORCE_INLINE_ void zero(Variant *v) { *VariantInternal::get_transform2d(v) = Transform2D(); } +}; + +template <> +struct VariantZeroAssigner<Plane> { + static _FORCE_INLINE_ void zero(Variant *v) { *VariantInternal::get_plane(v) = Plane(); } +}; + +template <> +struct VariantZeroAssigner<Quat> { + static _FORCE_INLINE_ void zero(Variant *v) { *VariantInternal::get_quat(v) = Quat(); } +}; + +template <> +struct VariantZeroAssigner<AABB> { + static _FORCE_INLINE_ void zero(Variant *v) { *VariantInternal::get_aabb(v) = AABB(); } +}; + +template <> +struct VariantZeroAssigner<Basis> { + static _FORCE_INLINE_ void zero(Variant *v) { *VariantInternal::get_basis(v) = Basis(); } +}; + +template <> +struct VariantZeroAssigner<Transform> { + static _FORCE_INLINE_ void zero(Variant *v) { *VariantInternal::get_transform(v) = Transform(); } +}; + +template <> +struct VariantZeroAssigner<Color> { + static _FORCE_INLINE_ void zero(Variant *v) { *VariantInternal::get_color(v) = Color(); } +}; + +template <> +struct VariantZeroAssigner<StringName> { + static _FORCE_INLINE_ void zero(Variant *v) {} +}; + +template <> +struct VariantZeroAssigner<NodePath> { + static _FORCE_INLINE_ void zero(Variant *v) {} +}; + +template <> +struct VariantZeroAssigner<::RID> { + static _FORCE_INLINE_ void zero(Variant *v) { *VariantInternal::get_rid(v) = RID(); } +}; + +template <> +struct VariantZeroAssigner<Callable> { + static _FORCE_INLINE_ void zero(Variant *v) {} +}; + +template <> +struct VariantZeroAssigner<Signal> { + static _FORCE_INLINE_ void zero(Variant *v) {} +}; + +template <> +struct VariantZeroAssigner<Dictionary> { + static _FORCE_INLINE_ void zero(Variant *v) {} +}; + +template <> +struct VariantZeroAssigner<Array> { + static _FORCE_INLINE_ void zero(Variant *v) {} +}; + +template <> +struct VariantZeroAssigner<PackedByteArray> { + static _FORCE_INLINE_ void zero(Variant *v) {} +}; + +template <> +struct VariantZeroAssigner<PackedInt32Array> { + static _FORCE_INLINE_ void zero(Variant *v) {} +}; + +template <> +struct VariantZeroAssigner<PackedInt64Array> { + static _FORCE_INLINE_ void zero(Variant *v) {} +}; + +template <> +struct VariantZeroAssigner<PackedFloat32Array> { + static _FORCE_INLINE_ void zero(Variant *v) {} +}; + +template <> +struct VariantZeroAssigner<PackedFloat64Array> { + static _FORCE_INLINE_ void zero(Variant *v) {} +}; + +template <> +struct VariantZeroAssigner<PackedStringArray> { + static _FORCE_INLINE_ void zero(Variant *v) {} +}; + +template <> +struct VariantZeroAssigner<PackedVector2Array> { + static _FORCE_INLINE_ void zero(Variant *v) {} +}; + +template <> +struct VariantZeroAssigner<PackedVector3Array> { + static _FORCE_INLINE_ void zero(Variant *v) {} +}; + +template <> +struct VariantZeroAssigner<PackedColorArray> { + static _FORCE_INLINE_ void zero(Variant *v) {} +}; + +template <class T> struct VariantTypeChanger { static _FORCE_INLINE_ void change(Variant *v) { if (v->get_type() != GetTypeInfo<T>::VARIANT_TYPE || GetTypeInfo<T>::VARIANT_TYPE >= Variant::PACKED_BYTE_ARRAY) { //second condition removed by optimizer @@ -944,6 +1118,14 @@ struct VariantTypeChanger { VariantInitializer<T>::init(v); } } + static _FORCE_INLINE_ void change_and_reset(Variant *v) { + if (v->get_type() != GetTypeInfo<T>::VARIANT_TYPE || GetTypeInfo<T>::VARIANT_TYPE >= Variant::PACKED_BYTE_ARRAY) { //second condition removed by optimizer + VariantInternal::clear(v); + VariantInitializer<T>::init(v); + } + + VariantZeroAssigner<T>::zero(v); + } }; #endif // VARIANT_INTERNAL_H |