From 406b22d2d550f58909a4134e313b506ef4145063 Mon Sep 17 00:00:00 2001 From: Lukas Tenbrink Date: Thu, 10 Apr 2025 20:19:15 +0200 Subject: [PATCH] Delete `VariantGetInternalPtr` and `VariantImplicitConvert`. Replace uses with `VariantInternalAccessor`. --- core/variant/binder_common.h | 10 +- core/variant/variant.h | 6 +- core/variant/variant_call.cpp | 40 +- core/variant/variant_construct.h | 58 +-- core/variant/variant_internal.h | 389 +++++++++---------- core/variant/variant_op.cpp | 56 +-- core/variant/variant_op.h | 406 ++++++++++---------- core/variant/variant_setget.cpp | 626 +++++++++++++++---------------- core/variant/variant_setget.h | 452 +++++++++++----------- 9 files changed, 1003 insertions(+), 1040 deletions(-) diff --git a/core/variant/binder_common.h b/core/variant/binder_common.h index 1c3b09569d0..0b8f0000fb9 100644 --- a/core/variant/binder_common.h +++ b/core/variant/binder_common.h @@ -531,27 +531,27 @@ void call_with_ptr_args_static_method(void (*p_method)(P...), const void **p_arg template void call_with_validated_variant_args(Variant *base, void (T::*p_method)(P...), const Variant **p_args) { - call_with_validated_variant_args_helper(VariantGetInternalPtr::get_ptr(base), p_method, p_args, BuildIndexSequence{}); + call_with_validated_variant_args_helper(&VariantInternalAccessor::get(base), p_method, p_args, BuildIndexSequence{}); } template void call_with_validated_variant_args_ret(Variant *base, R (T::*p_method)(P...), const Variant **p_args, Variant *r_ret) { - call_with_validated_variant_args_ret_helper(VariantGetInternalPtr::get_ptr(base), p_method, p_args, r_ret, BuildIndexSequence{}); + call_with_validated_variant_args_ret_helper(&VariantInternalAccessor::get(base), p_method, p_args, r_ret, BuildIndexSequence{}); } template void call_with_validated_variant_args_retc(Variant *base, R (T::*p_method)(P...) const, const Variant **p_args, Variant *r_ret) { - call_with_validated_variant_args_retc_helper(VariantGetInternalPtr::get_ptr(base), p_method, p_args, r_ret, BuildIndexSequence{}); + call_with_validated_variant_args_retc_helper(&VariantInternalAccessor::get(base), p_method, p_args, r_ret, BuildIndexSequence{}); } template void call_with_validated_variant_args_static(Variant *base, void (*p_method)(T *, P...), const Variant **p_args) { - call_with_validated_variant_args_static_helper(VariantGetInternalPtr::get_ptr(base), p_method, p_args, BuildIndexSequence{}); + call_with_validated_variant_args_static_helper(&VariantInternalAccessor::get(base), p_method, p_args, BuildIndexSequence{}); } template void call_with_validated_variant_args_static_retc(Variant *base, R (*p_method)(T *, P...), const Variant **p_args, Variant *r_ret) { - call_with_validated_variant_args_static_retc_helper(VariantGetInternalPtr::get_ptr(base), p_method, p_args, r_ret, BuildIndexSequence{}); + call_with_validated_variant_args_static_retc_helper(&VariantInternalAccessor::get(base), p_method, p_args, r_ret, BuildIndexSequence{}); } template diff --git a/core/variant/variant.h b/core/variant/variant.h index 8dbac106120..8e20a87d96f 100644 --- a/core/variant/variant.h +++ b/core/variant/variant.h @@ -174,11 +174,11 @@ private: friend struct _VariantCall; friend class VariantInternal; template - friend struct _VariantGetInternalPtrLocal; + friend struct _VariantInternalAccessorLocal; template - friend struct _VariantGetInternalPtrElsewhere; + friend struct _VariantInternalAccessorElsewhere; template - friend struct _VariantGetInternalPtrPackedArrayRef; + friend struct _VariantInternalAccessorPackedArrayRef; // Variant takes 24 bytes when real_t is float, and 40 bytes if double. // It only allocates extra memory for AABB/Transform2D (24, 48 if double), // Basis/Transform3D (48, 96 if double), Projection (64, 128 if double), diff --git a/core/variant/variant_call.cpp b/core/variant/variant_call.cpp index 2536e789332..33f44c13fed 100644 --- a/core/variant/variant_call.cpp +++ b/core/variant/variant_call.cpp @@ -54,58 +54,58 @@ static _FORCE_INLINE_ void vc_static_method_call(void (*method)(P...), const Var template static _FORCE_INLINE_ void vc_method_call(R (T::*method)(P...), Variant *base, const Variant **p_args, int p_argcount, Variant &r_ret, const Vector &p_defvals, Callable::CallError &r_error) { - call_with_variant_args_ret_dv(VariantGetInternalPtr::get_ptr(base), method, p_args, p_argcount, r_ret, r_error, p_defvals); + call_with_variant_args_ret_dv(&VariantInternalAccessor::get(base), method, p_args, p_argcount, r_ret, r_error, p_defvals); } template static _FORCE_INLINE_ void vc_method_call(R (T::*method)(P...) const, Variant *base, const Variant **p_args, int p_argcount, Variant &r_ret, const Vector &p_defvals, Callable::CallError &r_error) { - call_with_variant_args_retc_dv(VariantGetInternalPtr::get_ptr(base), method, p_args, p_argcount, r_ret, r_error, p_defvals); + call_with_variant_args_retc_dv(&VariantInternalAccessor::get(base), method, p_args, p_argcount, r_ret, r_error, p_defvals); } template static _FORCE_INLINE_ void vc_method_call(void (T::*method)(P...), Variant *base, const Variant **p_args, int p_argcount, Variant &r_ret, const Vector &p_defvals, Callable::CallError &r_error) { VariantInternal::clear(&r_ret); - call_with_variant_args_dv(VariantGetInternalPtr::get_ptr(base), method, p_args, p_argcount, r_error, p_defvals); + call_with_variant_args_dv(&VariantInternalAccessor::get(base), method, p_args, p_argcount, r_error, p_defvals); } template static _FORCE_INLINE_ void vc_method_call(void (T::*method)(P...) const, Variant *base, const Variant **p_args, int p_argcount, Variant &r_ret, const Vector &p_defvals, Callable::CallError &r_error) { VariantInternal::clear(&r_ret); - call_with_variant_argsc_dv(VariantGetInternalPtr::get_ptr(base), method, p_args, p_argcount, r_error, p_defvals); + call_with_variant_argsc_dv(&VariantInternalAccessor::get(base), method, p_args, p_argcount, r_error, p_defvals); } template static _FORCE_INLINE_ void vc_convert_method_call(R (T::*method)(P...), Variant *base, const Variant **p_args, int p_argcount, Variant &r_ret, const Vector &p_defvals, Callable::CallError &r_error) { - T converted(static_cast(*VariantGetInternalPtr::get_ptr(base))); + T converted(static_cast(VariantInternalAccessor::get(base))); call_with_variant_args_ret_dv(&converted, method, p_args, p_argcount, r_ret, r_error, p_defvals); } template static _FORCE_INLINE_ void vc_convert_method_call(R (T::*method)(P...) const, Variant *base, const Variant **p_args, int p_argcount, Variant &r_ret, const Vector &p_defvals, Callable::CallError &r_error) { - T converted(static_cast(*VariantGetInternalPtr::get_ptr(base))); + T converted(static_cast(VariantInternalAccessor::get(base))); call_with_variant_args_retc_dv(&converted, method, p_args, p_argcount, r_ret, r_error, p_defvals); } template static _FORCE_INLINE_ void vc_convert_method_call(void (T::*method)(P...), Variant *base, const Variant **p_args, int p_argcount, Variant &r_ret, const Vector &p_defvals, Callable::CallError &r_error) { - T converted(static_cast(*VariantGetInternalPtr::get_ptr(base))); + T converted(static_cast(VariantInternalAccessor::get(base))); call_with_variant_args_dv(&converted, method, p_args, p_argcount, r_error, p_defvals); } template static _FORCE_INLINE_ void vc_convert_method_call(void (T::*method)(P...) const, Variant *base, const Variant **p_args, int p_argcount, Variant &r_ret, const Vector &p_defvals, Callable::CallError &r_error) { - T converted(static_cast(*VariantGetInternalPtr::get_ptr(base))); + T converted(static_cast(VariantInternalAccessor::get(base))); call_with_variant_argsc_dv(&converted, method, p_args, p_argcount, r_error, p_defvals); } template static _FORCE_INLINE_ void vc_method_call_static(R (*method)(T *, P...), Variant *base, const Variant **p_args, int p_argcount, Variant &r_ret, const Vector &p_defvals, Callable::CallError &r_error) { - call_with_variant_args_retc_static_helper_dv(VariantGetInternalPtr::get_ptr(base), method, p_args, p_argcount, r_ret, p_defvals, r_error); + call_with_variant_args_retc_static_helper_dv(&VariantInternalAccessor::get(base), method, p_args, p_argcount, r_ret, p_defvals, r_error); } template static _FORCE_INLINE_ void vc_method_call_static(void (*method)(T *, P...), Variant *base, const Variant **p_args, int p_argcount, Variant &r_ret, const Vector &p_defvals, Callable::CallError &r_error) { - call_with_variant_args_static_helper_dv(VariantGetInternalPtr::get_ptr(base), method, p_args, p_argcount, p_defvals, r_error); + call_with_variant_args_static_helper_dv(&VariantInternalAccessor::get(base), method, p_args, p_argcount, p_defvals, r_error); } template @@ -129,24 +129,24 @@ static _FORCE_INLINE_ void vc_validated_call(void (T::*method)(P...) const, Vari template static _FORCE_INLINE_ void vc_convert_validated_call(R (T::*method)(P...), Variant *base, const Variant **p_args, Variant *r_ret) { - T converted(static_cast(*VariantGetInternalPtr::get_ptr(base))); + T converted(static_cast(VariantInternalAccessor::get(base))); call_with_validated_variant_args_ret_helper(&converted, method, p_args, r_ret, BuildIndexSequence{}); } template static _FORCE_INLINE_ void vc_convert_validated_call(R (T::*method)(P...) const, Variant *base, const Variant **p_args, Variant *r_ret) { - T converted(static_cast(*VariantGetInternalPtr::get_ptr(base))); + T converted(static_cast(VariantInternalAccessor::get(base))); call_with_validated_variant_args_retc_helper(&converted, method, p_args, r_ret, BuildIndexSequence{}); } template static _FORCE_INLINE_ void vc_convert_validated_call(void (T::*method)(P...), Variant *base, const Variant **p_args, Variant *r_ret) { - T converted(static_cast(*VariantGetInternalPtr::get_ptr(base))); + T converted(static_cast(VariantInternalAccessor::get(base))); call_with_validated_variant_args_helper(&converted, method, p_args, r_ret, BuildIndexSequence{}); } template static _FORCE_INLINE_ void vc_convert_validated_call(void (T::*method)(P...) const, Variant *base, const Variant **p_args, Variant *r_ret) { - T converted(static_cast(*VariantGetInternalPtr::get_ptr(base))); + T converted(static_cast(VariantInternalAccessor::get(base))); call_with_validated_variant_argsc_helper(&converted, method, p_args, r_ret, BuildIndexSequence{}); } @@ -1168,17 +1168,17 @@ struct _VariantCall { } static void func_Callable_call(Variant *v, const Variant **p_args, int p_argcount, Variant &r_ret, Callable::CallError &r_error) { - Callable *callable = VariantGetInternalPtr::get_ptr(v); + Callable *callable = &VariantInternalAccessor::get(v); callable->callp(p_args, p_argcount, r_ret, r_error); } static void func_Callable_call_deferred(Variant *v, const Variant **p_args, int p_argcount, Variant &r_ret, Callable::CallError &r_error) { - Callable *callable = VariantGetInternalPtr::get_ptr(v); + Callable *callable = &VariantInternalAccessor::get(v); callable->call_deferredp(p_args, p_argcount); } static void func_Callable_rpc(Variant *v, const Variant **p_args, int p_argcount, Variant &r_ret, Callable::CallError &r_error) { - Callable *callable = VariantGetInternalPtr::get_ptr(v); + Callable *callable = &VariantInternalAccessor::get(v); callable->rpcp(0, p_args, p_argcount, r_error); } @@ -1191,13 +1191,13 @@ struct _VariantCall { r_error.argument = 0; r_error.expected = Variant::INT; } else { - Callable *callable = VariantGetInternalPtr::get_ptr(v); + Callable *callable = &VariantInternalAccessor::get(v); callable->rpcp(*p_args[0], &p_args[1], p_argcount - 1, r_error); } } static void func_Callable_bind(Variant *v, const Variant **p_args, int p_argcount, Variant &r_ret, Callable::CallError &r_error) { - Callable *callable = VariantGetInternalPtr::get_ptr(v); + Callable *callable = &VariantInternalAccessor::get(v); r_ret = callable->bindp(p_args, p_argcount); } @@ -1206,7 +1206,7 @@ struct _VariantCall { } static void func_Signal_emit(Variant *v, const Variant **p_args, int p_argcount, Variant &r_ret, Callable::CallError &r_error) { - Signal *signal = VariantGetInternalPtr::get_ptr(v); + Signal *signal = &VariantInternalAccessor::get(v); signal->emit(p_args, p_argcount); } diff --git a/core/variant/variant_construct.h b/core/variant/variant_construct.h index 2193982edf8..bd2f48dafcd 100644 --- a/core/variant/variant_construct.h +++ b/core/variant/variant_construct.h @@ -113,7 +113,7 @@ class VariantConstructor { template static _FORCE_INLINE_ void validated_construct_helper(T &base, const Variant **p_args, IndexSequence) { - base = T((*VariantGetInternalPtr

::get_ptr(p_args[Is]))...); + base = T((VariantInternalAccessor

::get(p_args[Is]))...); } template @@ -125,12 +125,12 @@ public: static void construct(Variant &r_ret, const Variant **p_args, Callable::CallError &r_error) { r_error.error = Callable::CallError::CALL_OK; VariantTypeChanger::change(&r_ret); - construct_helper(*VariantGetInternalPtr::get_ptr(&r_ret), p_args, r_error, BuildIndexSequence{}); + construct_helper(VariantInternalAccessor::get(&r_ret), p_args, r_error, BuildIndexSequence{}); } static inline void validated_construct(Variant *r_ret, const Variant **p_args) { VariantTypeChanger::change(r_ret); - validated_construct_helper(*VariantGetInternalPtr::get_ptr(r_ret), p_args, BuildIndexSequence{}); + validated_construct_helper(VariantInternalAccessor::get(r_ret), p_args, BuildIndexSequence{}); } static void ptr_construct(void *base, const void **p_args) { ptr_construct_helper(base, p_args, BuildIndexSequence{}); @@ -249,7 +249,7 @@ public: static inline void validated_construct(Variant *r_ret, const Variant **p_args) { VariantTypeChanger::change(r_ret); - const String &src_str = *VariantGetInternalPtr::get_ptr(p_args[0]); + const String &src_str = VariantInternalAccessor::get(p_args[0]); T ret = Variant(); if (r_ret->get_type() == Variant::Type::INT) { ret = src_str.to_int(); @@ -302,9 +302,9 @@ public: } if (p_args[1]->get_type() == Variant::STRING_NAME) { - method = *VariantGetInternalPtr::get_ptr(p_args[1]); + method = VariantInternalAccessor::get(p_args[1]); } else if (p_args[1]->get_type() == Variant::STRING) { - method = *VariantGetInternalPtr::get_ptr(p_args[1]); + method = VariantInternalAccessor::get(p_args[1]); } else { r_error.error = Callable::CallError::CALL_ERROR_INVALID_ARGUMENT; r_error.argument = 1; @@ -313,12 +313,12 @@ public: } VariantTypeChanger::change(&r_ret); - *VariantGetInternalPtr::get_ptr(&r_ret) = Callable(object_id, method); + VariantInternalAccessor::get(&r_ret) = Callable(object_id, method); } static inline void validated_construct(Variant *r_ret, const Variant **p_args) { VariantTypeChanger::change(r_ret); - *VariantGetInternalPtr::get_ptr(r_ret) = Callable(VariantInternal::get_object_id(p_args[0]), *VariantGetInternalPtr::get_ptr(p_args[1])); + VariantInternalAccessor::get(r_ret) = Callable(VariantInternal::get_object_id(p_args[0]), VariantInternalAccessor::get(p_args[1])); } static void ptr_construct(void *base, const void **p_args) { PtrConstruct::construct(Callable(PtrToArg::convert(p_args[0]), PtrToArg::convert(p_args[1])), base); @@ -359,9 +359,9 @@ public: } if (p_args[1]->get_type() == Variant::STRING_NAME) { - method = *VariantGetInternalPtr::get_ptr(p_args[1]); + method = VariantInternalAccessor::get(p_args[1]); } else if (p_args[1]->get_type() == Variant::STRING) { - method = *VariantGetInternalPtr::get_ptr(p_args[1]); + method = VariantInternalAccessor::get(p_args[1]); } else { r_error.error = Callable::CallError::CALL_ERROR_INVALID_ARGUMENT; r_error.argument = 1; @@ -370,12 +370,12 @@ public: } VariantTypeChanger::change(&r_ret); - *VariantGetInternalPtr::get_ptr(&r_ret) = Signal(object_id, method); + VariantInternalAccessor::get(&r_ret) = Signal(object_id, method); } static inline void validated_construct(Variant *r_ret, const Variant **p_args) { VariantTypeChanger::change(r_ret); - *VariantGetInternalPtr::get_ptr(r_ret) = Signal(VariantInternal::get_object_id(p_args[0]), *VariantGetInternalPtr::get_ptr(p_args[1])); + VariantInternalAccessor::get(r_ret) = Signal(VariantInternal::get_object_id(p_args[0]), VariantInternalAccessor::get(p_args[1])); } static void ptr_construct(void *base, const void **p_args) { PtrConstruct::construct(Signal(PtrToArg::convert(p_args[0]), PtrToArg::convert(p_args[1])), base); @@ -436,20 +436,20 @@ public: return; } - const Dictionary &base_dict = *VariantGetInternalPtr::get_ptr(p_args[0]); + const Dictionary &base_dict = VariantInternalAccessor::get(p_args[0]); const uint32_t key_type = p_args[1]->operator uint32_t(); - const StringName &key_class_name = *VariantGetInternalPtr::get_ptr(p_args[2]); + const StringName &key_class_name = VariantInternalAccessor::get(p_args[2]); const uint32_t value_type = p_args[4]->operator uint32_t(); - const StringName &value_class_name = *VariantGetInternalPtr::get_ptr(p_args[5]); + const StringName &value_class_name = VariantInternalAccessor::get(p_args[5]); r_ret = Dictionary(base_dict, key_type, key_class_name, *p_args[3], value_type, value_class_name, *p_args[6]); } static inline void validated_construct(Variant *r_ret, const Variant **p_args) { - const Dictionary &base_dict = *VariantGetInternalPtr::get_ptr(p_args[0]); + const Dictionary &base_dict = VariantInternalAccessor::get(p_args[0]); const uint32_t key_type = p_args[1]->operator uint32_t(); - const StringName &key_class_name = *VariantGetInternalPtr::get_ptr(p_args[2]); + const StringName &key_class_name = VariantInternalAccessor::get(p_args[2]); const uint32_t value_type = p_args[4]->operator uint32_t(); - const StringName &value_class_name = *VariantGetInternalPtr::get_ptr(p_args[5]); + const StringName &value_class_name = VariantInternalAccessor::get(p_args[5]); *r_ret = Dictionary(base_dict, key_type, key_class_name, *p_args[3], value_type, value_class_name, *p_args[6]); } @@ -528,15 +528,15 @@ public: return; } - const Array &base_arr = *VariantGetInternalPtr::get_ptr(p_args[0]); + const Array &base_arr = VariantInternalAccessor::get(p_args[0]); const uint32_t type = p_args[1]->operator uint32_t(); r_ret = Array(base_arr, type, *p_args[2], *p_args[3]); } static inline void validated_construct(Variant *r_ret, const Variant **p_args) { - const Array &base_arr = *VariantGetInternalPtr::get_ptr(p_args[0]); + const Array &base_arr = VariantInternalAccessor::get(p_args[0]); const uint32_t type = p_args[1]->operator uint32_t(); - const StringName &class_name = *VariantGetInternalPtr::get_ptr(p_args[2]); + const StringName &class_name = VariantInternalAccessor::get(p_args[2]); *r_ret = Array(base_arr, type, class_name, *p_args[3]); } @@ -591,8 +591,8 @@ public: } r_ret = Array(); - Array &dst_arr = *VariantGetInternalPtr::get_ptr(&r_ret); - const T &src_arr = *VariantGetInternalPtr::get_ptr(p_args[0]); + Array &dst_arr = VariantInternalAccessor::get(&r_ret); + const T &src_arr = VariantInternalAccessor::get(p_args[0]); int size = src_arr.size(); dst_arr.resize(size); @@ -603,8 +603,8 @@ public: static inline void validated_construct(Variant *r_ret, const Variant **p_args) { *r_ret = Array(); - Array &dst_arr = *VariantGetInternalPtr::get_ptr(r_ret); - const T &src_arr = *VariantGetInternalPtr::get_ptr(p_args[0]); + Array &dst_arr = VariantInternalAccessor::get(r_ret); + const T &src_arr = VariantInternalAccessor::get(p_args[0]); int size = src_arr.size(); dst_arr.resize(size); @@ -650,8 +650,8 @@ public: } VariantTypeChanger::change(&r_ret); - const Array &src_arr = *VariantGetInternalPtr::get_ptr(p_args[0]); - T &dst_arr = *VariantGetInternalPtr::get_ptr(&r_ret); + const Array &src_arr = VariantInternalAccessor::get(p_args[0]); + T &dst_arr = VariantInternalAccessor::get(&r_ret); int size = src_arr.size(); dst_arr.resize(size); @@ -662,8 +662,8 @@ public: static inline void validated_construct(Variant *r_ret, const Variant **p_args) { VariantTypeChanger::change(r_ret); - const Array &src_arr = *VariantGetInternalPtr::get_ptr(p_args[0]); - T &dst_arr = *VariantGetInternalPtr::get_ptr(r_ret); + const Array &src_arr = VariantInternalAccessor::get(p_args[0]); + T &dst_arr = VariantInternalAccessor::get(r_ret); int size = src_arr.size(); dst_arr.resize(size); diff --git a/core/variant/variant_internal.h b/core/variant/variant_internal.h index 671e4a00220..06525c7c031 100644 --- a/core/variant/variant_internal.h +++ b/core/variant/variant_internal.h @@ -534,222 +534,37 @@ public: } }; -/// Types that can be stored in Variant. -template -struct VariantGetInternalPtr; - -template -struct VariantGetInternalPtr>>> : VariantGetInternalPtr> {}; - -template -struct _VariantGetInternalPtrLocal { - using type = T; - static constexpr bool is_local = true; - static _FORCE_INLINE_ T *get_ptr(Variant *v) { return reinterpret_cast(v->_data._mem); } - static _FORCE_INLINE_ const T *get_ptr(const Variant *v) { return reinterpret_cast(v->_data._mem); } -}; - -template -struct _VariantGetInternalPtrElsewhere { - using type = T; - static constexpr bool is_local = false; - static _FORCE_INLINE_ T *get_ptr(Variant *v) { return reinterpret_cast(v->_data._ptr); } - static _FORCE_INLINE_ const T *get_ptr(const Variant *v) { return reinterpret_cast(v->_data._ptr); } -}; - -template -struct _VariantGetInternalPtrPackedArrayRef { - using type = Vector; - static constexpr bool is_local = false; - static _FORCE_INLINE_ Vector *get_ptr(Variant *v) { return &static_cast *>(v->_data.packed_array)->array; } - static _FORCE_INLINE_ const Vector *get_ptr(const Variant *v) { return &static_cast *>(v->_data.packed_array)->array; } -}; - -template <> -struct VariantGetInternalPtr : _VariantGetInternalPtrLocal {}; - -template <> -struct VariantGetInternalPtr : _VariantGetInternalPtrLocal {}; - -template <> -struct VariantGetInternalPtr : _VariantGetInternalPtrLocal {}; - -template <> -struct VariantGetInternalPtr : _VariantGetInternalPtrLocal {}; - -template <> -struct VariantGetInternalPtr : _VariantGetInternalPtrLocal {}; - -template <> -struct VariantGetInternalPtr : _VariantGetInternalPtrLocal {}; - -template <> -struct VariantGetInternalPtr : _VariantGetInternalPtrLocal {}; - -template <> -struct VariantGetInternalPtr : _VariantGetInternalPtrLocal {}; - -template <> -struct VariantGetInternalPtr : _VariantGetInternalPtrLocal {}; - -template <> -struct VariantGetInternalPtr : _VariantGetInternalPtrLocal {}; - -template <> -struct VariantGetInternalPtr : _VariantGetInternalPtrLocal {}; - -template <> -struct VariantGetInternalPtr : _VariantGetInternalPtrLocal {}; - -template <> -struct VariantGetInternalPtr : _VariantGetInternalPtrElsewhere {}; - -template <> -struct VariantGetInternalPtr : _VariantGetInternalPtrElsewhere {}; - -template <> -struct VariantGetInternalPtr : _VariantGetInternalPtrElsewhere {}; - -template <> -struct VariantGetInternalPtr : _VariantGetInternalPtrLocal {}; - -template <> -struct VariantGetInternalPtr : _VariantGetInternalPtrLocal {}; - -template <> -struct VariantGetInternalPtr<::AABB> : _VariantGetInternalPtrElsewhere<::AABB> {}; - -template <> -struct VariantGetInternalPtr : _VariantGetInternalPtrElsewhere {}; - -template <> -struct VariantGetInternalPtr : _VariantGetInternalPtrLocal {}; - -template <> -struct VariantGetInternalPtr : _VariantGetInternalPtrLocal {}; - -template <> -struct VariantGetInternalPtr : _VariantGetInternalPtrLocal {}; - -template <> -struct VariantGetInternalPtr<::RID> : _VariantGetInternalPtrLocal<::RID> {}; - -// template <> -// struct VariantGetInternalPtr : _VariantGetInternalPtrLocal {}; - -template <> -struct VariantGetInternalPtr : _VariantGetInternalPtrLocal {}; - -template <> -struct VariantGetInternalPtr : _VariantGetInternalPtrLocal {}; - -template <> -struct VariantGetInternalPtr : _VariantGetInternalPtrLocal {}; - -template <> -struct VariantGetInternalPtr : _VariantGetInternalPtrLocal {}; - -template <> -struct VariantGetInternalPtr : _VariantGetInternalPtrPackedArrayRef {}; - -template <> -struct VariantGetInternalPtr : _VariantGetInternalPtrPackedArrayRef {}; - -template <> -struct VariantGetInternalPtr : _VariantGetInternalPtrPackedArrayRef {}; - -template <> -struct VariantGetInternalPtr : _VariantGetInternalPtrPackedArrayRef {}; - -template <> -struct VariantGetInternalPtr : _VariantGetInternalPtrPackedArrayRef {}; - -template <> -struct VariantGetInternalPtr : _VariantGetInternalPtrPackedArrayRef {}; - -template <> -struct VariantGetInternalPtr : _VariantGetInternalPtrPackedArrayRef {}; - -template <> -struct VariantGetInternalPtr : _VariantGetInternalPtrPackedArrayRef {}; - -template <> -struct VariantGetInternalPtr : _VariantGetInternalPtrPackedArrayRef {}; - -template <> -struct VariantGetInternalPtr : _VariantGetInternalPtrPackedArrayRef {}; - -template > -struct IsVariantType : std::false_type {}; - -template -struct IsVariantType::type>> : std::true_type {}; - -template -constexpr bool IsVariantTypeT = IsVariantType::value; - -/// Types that can be implicitly converted to and from Variant, -/// using another type to store the actual value. -template -struct VariantImplicitConvert; - -template -struct _VariantImplicitConvertCast { - using EncodeT = S; - static _FORCE_INLINE_ T read(const Variant &p_variant) { - return T(*VariantGetInternalPtr::get_ptr(&p_variant)); - } - static _FORCE_INLINE_ T read(Variant &p_variant) { - return T(*VariantGetInternalPtr::get_ptr(&p_variant)); - } - static _FORCE_INLINE_ void write(T p_val, Variant &p_variant) { - *VariantGetInternalPtr::get_ptr(&p_variant) = S(std::move(p_val)); - } -}; - -// Integer types. -template -struct VariantImplicitConvert && !std::is_same_v && !std::is_same_v>> : _VariantImplicitConvertCast {}; -template -struct VariantImplicitConvert>> : _VariantImplicitConvertCast {}; -template -struct VariantImplicitConvert, std::enable_if_t>> : _VariantImplicitConvertCast, int64_t> {}; - -template <> -struct VariantImplicitConvert : _VariantImplicitConvertCast {}; - -// Float types. -template <> -struct VariantImplicitConvert : _VariantImplicitConvertCast {}; - -template > -struct IsVariantImplicitConversionType : std::false_type {}; - -template -struct IsVariantImplicitConversionType::EncodeT>> : std::true_type {}; - -template -constexpr bool IsVariantImplicitConversionTypeT = IsVariantImplicitConversionType::value; - template struct VariantInternalAccessor; -template -struct VariantInternalAccessor>> { - static _FORCE_INLINE_ T &get(Variant *v) { return *VariantGetInternalPtr::get_ptr(v); } - static _FORCE_INLINE_ const T &get(const Variant *v) { return *VariantGetInternalPtr::get_ptr(v); } - static _FORCE_INLINE_ void set(Variant *v, T p_value) { *VariantGetInternalPtr::get_ptr(v) = std::move(p_value); } -}; - -template -struct VariantInternalAccessor>> { - static _FORCE_INLINE_ T get(const Variant *v) { return VariantImplicitConvert::read(*v); } - static _FORCE_INLINE_ void set(Variant *v, T p_value) { VariantImplicitConvert::write(std::move(p_value), *v); } -}; - template struct VariantInternalAccessor>>> : VariantInternalAccessor> {}; +template +struct _VariantInternalAccessorLocal { + using declared_when_native_type = void; + static constexpr bool is_local = true; + static _FORCE_INLINE_ T &get(Variant *v) { return *reinterpret_cast(v->_data._mem); } + static _FORCE_INLINE_ const T &get(const Variant *v) { return *reinterpret_cast(v->_data._mem); } + static _FORCE_INLINE_ void set(Variant *v, T p_value) { *reinterpret_cast(v->_data._mem) = std::move(p_value); } +}; + +template +struct _VariantInternalAccessorElsewhere { + using declared_when_native_type = void; + static _FORCE_INLINE_ T &get(Variant *v) { return *reinterpret_cast(v->_data._ptr); } + static _FORCE_INLINE_ const T &get(const Variant *v) { return *reinterpret_cast(v->_data._ptr); } + static _FORCE_INLINE_ void set(Variant *v, T p_value) { *reinterpret_cast(v->_data._ptr) = std::move(p_value); } +}; + +template +struct _VariantInternalAccessorPackedArrayRef { + using declared_when_native_type = void; + static _FORCE_INLINE_ Vector &get(Variant *v) { return static_cast *>(v->_data.packed_array)->array; } + static _FORCE_INLINE_ const Vector &get(const Variant *v) { return static_cast *>(v->_data.packed_array)->array; } + static _FORCE_INLINE_ void set(Variant *v, Vector p_value) { static_cast *>(v->_data.packed_array)->array = std::move(p_value); } +}; + template struct VariantInternalAccessor { static _FORCE_INLINE_ T *get(const Variant *v) { return const_cast(static_cast(*VariantInternal::get_object(v))); } @@ -802,15 +617,163 @@ struct VariantInternalAccessor> { } }; +template <> +struct VariantInternalAccessor : _VariantInternalAccessorLocal {}; + +template <> +struct VariantInternalAccessor : _VariantInternalAccessorLocal {}; + +template <> +struct VariantInternalAccessor : _VariantInternalAccessorLocal {}; + +template <> +struct VariantInternalAccessor : _VariantInternalAccessorLocal {}; + +template <> +struct VariantInternalAccessor : _VariantInternalAccessorLocal {}; + +template <> +struct VariantInternalAccessor : _VariantInternalAccessorLocal {}; + +template <> +struct VariantInternalAccessor : _VariantInternalAccessorLocal {}; + +template <> +struct VariantInternalAccessor : _VariantInternalAccessorLocal {}; + +template <> +struct VariantInternalAccessor : _VariantInternalAccessorLocal {}; + +template <> +struct VariantInternalAccessor : _VariantInternalAccessorLocal {}; + +template <> +struct VariantInternalAccessor : _VariantInternalAccessorLocal {}; + +template <> +struct VariantInternalAccessor : _VariantInternalAccessorLocal {}; + +template <> +struct VariantInternalAccessor : _VariantInternalAccessorElsewhere {}; + +template <> +struct VariantInternalAccessor : _VariantInternalAccessorElsewhere {}; + +template <> +struct VariantInternalAccessor : _VariantInternalAccessorElsewhere {}; + +template <> +struct VariantInternalAccessor : _VariantInternalAccessorLocal {}; + +template <> +struct VariantInternalAccessor : _VariantInternalAccessorLocal {}; + +template <> +struct VariantInternalAccessor<::AABB> : _VariantInternalAccessorElsewhere<::AABB> {}; + +template <> +struct VariantInternalAccessor : _VariantInternalAccessorElsewhere {}; + +template <> +struct VariantInternalAccessor : _VariantInternalAccessorLocal {}; + +template <> +struct VariantInternalAccessor : _VariantInternalAccessorLocal {}; + +template <> +struct VariantInternalAccessor : _VariantInternalAccessorLocal {}; + +template <> +struct VariantInternalAccessor<::RID> : _VariantInternalAccessorLocal<::RID> {}; + +// template <> +// struct VariantInternalAccessor : _VariantInternalAccessorLocal {}; + +template <> +struct VariantInternalAccessor : _VariantInternalAccessorLocal {}; + +template <> +struct VariantInternalAccessor : _VariantInternalAccessorLocal {}; + +template <> +struct VariantInternalAccessor : _VariantInternalAccessorLocal {}; + +template <> +struct VariantInternalAccessor : _VariantInternalAccessorLocal {}; + +template <> +struct VariantInternalAccessor : _VariantInternalAccessorPackedArrayRef {}; + +template <> +struct VariantInternalAccessor : _VariantInternalAccessorPackedArrayRef {}; + +template <> +struct VariantInternalAccessor : _VariantInternalAccessorPackedArrayRef {}; + +template <> +struct VariantInternalAccessor : _VariantInternalAccessorPackedArrayRef {}; + +template <> +struct VariantInternalAccessor : _VariantInternalAccessorPackedArrayRef {}; + +template <> +struct VariantInternalAccessor : _VariantInternalAccessorPackedArrayRef {}; + +template <> +struct VariantInternalAccessor : _VariantInternalAccessorPackedArrayRef {}; + +template <> +struct VariantInternalAccessor : _VariantInternalAccessorPackedArrayRef {}; + +template <> +struct VariantInternalAccessor : _VariantInternalAccessorPackedArrayRef {}; + +template <> +struct VariantInternalAccessor : _VariantInternalAccessorPackedArrayRef {}; + +template > +struct IsVariantType : std::false_type {}; + +template +struct IsVariantType::declared_when_native_type>> : std::true_type {}; + +template +constexpr bool IsVariantTypeT = IsVariantType::value; + +template +struct _VariantInternalAccessorConvert { + static _FORCE_INLINE_ T get(const Variant *v) { + return T(VariantInternalAccessor::get(v)); + } + static _FORCE_INLINE_ void set(Variant *v, const T p_value) { + VariantInternalAccessor::get(v) = S(std::move(p_value)); + } +}; + +// Integer types. +template +struct VariantInternalAccessor && !std::is_same_v && !std::is_same_v>> : _VariantInternalAccessorConvert {}; +template +struct VariantInternalAccessor>> : _VariantInternalAccessorConvert {}; +template +struct VariantInternalAccessor, std::enable_if_t>> : _VariantInternalAccessorConvert, int64_t> {}; + +template <> +struct VariantInternalAccessor : _VariantInternalAccessorConvert {}; + +// Float types. +template <> +struct VariantInternalAccessor : _VariantInternalAccessorConvert {}; + template struct VariantInitializer { static _FORCE_INLINE_ void init(Variant *v) { VariantInternal::init_generic(v); } }; template -struct VariantInitializer::is_local>> { +struct VariantInitializer::is_local>> { static _FORCE_INLINE_ void init(Variant *v) { - memnew_placement(VariantGetInternalPtr::get_ptr(v), T); + memnew_placement(&VariantInternalAccessor::get(v), T); VariantInternal::set_type(*v, GetTypeInfo::VARIANT_TYPE); } }; @@ -902,7 +865,7 @@ struct VariantDefaultInitializer; template struct VariantDefaultInitializer>> { static _FORCE_INLINE_ void init(Variant *v) { - *VariantGetInternalPtr::get_ptr(v) = T(); + VariantInternalAccessor::get(v) = T(); } }; diff --git a/core/variant/variant_op.cpp b/core/variant/variant_op.cpp index 4a062bb9b14..ad19c8bdd94 100644 --- a/core/variant/variant_op.cpp +++ b/core/variant/variant_op.cpp @@ -51,13 +51,13 @@ template <> class OperatorEvaluatorMul { public: static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - const Vector2i &a = *VariantGetInternalPtr::get_ptr(&p_left); - const double &b = *VariantGetInternalPtr::get_ptr(&p_right); + const Vector2i &a = VariantInternalAccessor::get(&p_left); + const double &b = VariantInternalAccessor::get(&p_right); *r_ret = Vector2(a.x, a.y) * b; r_valid = true; } static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) { - *VariantGetInternalPtr::get_ptr(r_ret) = Vector2(VariantGetInternalPtr::get_ptr(left)->x, VariantGetInternalPtr::get_ptr(left)->y) * *VariantGetInternalPtr::get_ptr(right); + VariantInternalAccessor::get(r_ret) = Vector2(VariantInternalAccessor::get(left).x, VariantInternalAccessor::get(left).y) * VariantInternalAccessor::get(right); } static void ptr_evaluate(const void *left, const void *right, void *r_ret) { PtrToArg::encode(Vector2(PtrToArg::convert(left).x, PtrToArg::convert(left).y) * PtrToArg::convert(right), r_ret); @@ -69,13 +69,13 @@ template <> class OperatorEvaluatorMul { public: static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - const Vector2i &a = *VariantGetInternalPtr::get_ptr(&p_right); - const double &b = *VariantGetInternalPtr::get_ptr(&p_left); + const Vector2i &a = VariantInternalAccessor::get(&p_right); + const double &b = VariantInternalAccessor::get(&p_left); *r_ret = Vector2(a.x, a.y) * b; r_valid = true; } static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) { - *VariantGetInternalPtr::get_ptr(r_ret) = Vector2(VariantGetInternalPtr::get_ptr(right)->x, VariantGetInternalPtr::get_ptr(right)->y) * *VariantGetInternalPtr::get_ptr(left); + VariantInternalAccessor::get(r_ret) = Vector2(VariantInternalAccessor::get(right).x, VariantInternalAccessor::get(right).y) * VariantInternalAccessor::get(left); } static void ptr_evaluate(const void *left, const void *right, void *r_ret) { PtrToArg::encode(Vector2(PtrToArg::convert(right).x, PtrToArg::convert(right).y) * PtrToArg::convert(left), r_ret); @@ -87,8 +87,8 @@ template <> class OperatorEvaluatorDivNZ { public: static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - const Vector2i &a = *VariantGetInternalPtr::get_ptr(&p_left); - const double &b = *VariantGetInternalPtr::get_ptr(&p_right); + const Vector2i &a = VariantInternalAccessor::get(&p_left); + const double &b = VariantInternalAccessor::get(&p_right); if (unlikely(b == 0)) { r_valid = false; *r_ret = "Division by zero error"; @@ -98,7 +98,7 @@ public: r_valid = true; } static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) { - *VariantGetInternalPtr::get_ptr(r_ret) = Vector2(VariantGetInternalPtr::get_ptr(left)->x, VariantGetInternalPtr::get_ptr(left)->y) / *VariantGetInternalPtr::get_ptr(right); + VariantInternalAccessor::get(r_ret) = Vector2(VariantInternalAccessor::get(left).x, VariantInternalAccessor::get(left).y) / VariantInternalAccessor::get(right); } static void ptr_evaluate(const void *left, const void *right, void *r_ret) { PtrToArg::encode(Vector2(PtrToArg::convert(left).x, PtrToArg::convert(left).y) / PtrToArg::convert(right), r_ret); @@ -110,13 +110,13 @@ template <> class OperatorEvaluatorMul { public: static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - const Vector3i &a = *VariantGetInternalPtr::get_ptr(&p_left); - const double &b = *VariantGetInternalPtr::get_ptr(&p_right); + const Vector3i &a = VariantInternalAccessor::get(&p_left); + const double &b = VariantInternalAccessor::get(&p_right); *r_ret = Vector3(a.x, a.y, a.z) * b; r_valid = true; } static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) { - *VariantGetInternalPtr::get_ptr(r_ret) = Vector3(VariantGetInternalPtr::get_ptr(left)->x, VariantGetInternalPtr::get_ptr(left)->y, VariantGetInternalPtr::get_ptr(left)->z) * *VariantGetInternalPtr::get_ptr(right); + VariantInternalAccessor::get(r_ret) = Vector3(VariantInternalAccessor::get(left).x, VariantInternalAccessor::get(left).y, VariantInternalAccessor::get(left).z) * VariantInternalAccessor::get(right); } static void ptr_evaluate(const void *left, const void *right, void *r_ret) { PtrToArg::encode(Vector3(PtrToArg::convert(left).x, PtrToArg::convert(left).y, PtrToArg::convert(left).z) * PtrToArg::convert(right), r_ret); @@ -128,13 +128,13 @@ template <> class OperatorEvaluatorMul { public: static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - const Vector3i &a = *VariantGetInternalPtr::get_ptr(&p_right); - const double &b = *VariantGetInternalPtr::get_ptr(&p_left); + const Vector3i &a = VariantInternalAccessor::get(&p_right); + const double &b = VariantInternalAccessor::get(&p_left); *r_ret = Vector3(a.x, a.y, a.z) * b; r_valid = true; } static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) { - *VariantGetInternalPtr::get_ptr(r_ret) = Vector3(VariantGetInternalPtr::get_ptr(right)->x, VariantGetInternalPtr::get_ptr(right)->y, VariantGetInternalPtr::get_ptr(right)->z) * *VariantGetInternalPtr::get_ptr(left); + VariantInternalAccessor::get(r_ret) = Vector3(VariantInternalAccessor::get(right).x, VariantInternalAccessor::get(right).y, VariantInternalAccessor::get(right).z) * VariantInternalAccessor::get(left); } static void ptr_evaluate(const void *left, const void *right, void *r_ret) { PtrToArg::encode(Vector3(PtrToArg::convert(right).x, PtrToArg::convert(right).y, PtrToArg::convert(right).z) * PtrToArg::convert(left), r_ret); @@ -146,8 +146,8 @@ template <> class OperatorEvaluatorDivNZ { public: static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - const Vector3i &a = *VariantGetInternalPtr::get_ptr(&p_left); - const double &b = *VariantGetInternalPtr::get_ptr(&p_right); + const Vector3i &a = VariantInternalAccessor::get(&p_left); + const double &b = VariantInternalAccessor::get(&p_right); if (unlikely(b == 0)) { r_valid = false; *r_ret = "Division by zero error"; @@ -157,7 +157,7 @@ public: r_valid = true; } static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) { - *VariantGetInternalPtr::get_ptr(r_ret) = Vector3(VariantGetInternalPtr::get_ptr(left)->x, VariantGetInternalPtr::get_ptr(left)->y, VariantGetInternalPtr::get_ptr(left)->z) / *VariantGetInternalPtr::get_ptr(right); + VariantInternalAccessor::get(r_ret) = Vector3(VariantInternalAccessor::get(left).x, VariantInternalAccessor::get(left).y, VariantInternalAccessor::get(left).z) / VariantInternalAccessor::get(right); } static void ptr_evaluate(const void *left, const void *right, void *r_ret) { PtrToArg::encode(Vector3(PtrToArg::convert(left).x, PtrToArg::convert(left).y, PtrToArg::convert(left).z) / PtrToArg::convert(right), r_ret); @@ -171,13 +171,13 @@ template <> class OperatorEvaluatorMul { public: static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - const Vector4i &a = *VariantGetInternalPtr::get_ptr(&p_left); - const double &b = *VariantGetInternalPtr::get_ptr(&p_right); + const Vector4i &a = VariantInternalAccessor::get(&p_left); + const double &b = VariantInternalAccessor::get(&p_right); *r_ret = Vector4(a.x, a.y, a.z, a.w) * b; r_valid = true; } static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) { - *VariantGetInternalPtr::get_ptr(r_ret) = Vector4(VariantGetInternalPtr::get_ptr(left)->x, VariantGetInternalPtr::get_ptr(left)->y, VariantGetInternalPtr::get_ptr(left)->z, VariantGetInternalPtr::get_ptr(left)->w) * *VariantGetInternalPtr::get_ptr(right); + VariantInternalAccessor::get(r_ret) = Vector4(VariantInternalAccessor::get(left).x, VariantInternalAccessor::get(left).y, VariantInternalAccessor::get(left).z, VariantInternalAccessor::get(left).w) * VariantInternalAccessor::get(right); } static void ptr_evaluate(const void *left, const void *right, void *r_ret) { PtrToArg::encode(Vector4(PtrToArg::convert(left).x, PtrToArg::convert(left).y, PtrToArg::convert(left).z, PtrToArg::convert(left).w) * PtrToArg::convert(right), r_ret); @@ -189,13 +189,13 @@ template <> class OperatorEvaluatorMul { public: static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - const Vector4i &a = *VariantGetInternalPtr::get_ptr(&p_right); - const double &b = *VariantGetInternalPtr::get_ptr(&p_left); + const Vector4i &a = VariantInternalAccessor::get(&p_right); + const double &b = VariantInternalAccessor::get(&p_left); *r_ret = Vector4(a.x, a.y, a.z, a.w) * b; r_valid = true; } static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) { - *VariantGetInternalPtr::get_ptr(r_ret) = Vector4(VariantGetInternalPtr::get_ptr(right)->x, VariantGetInternalPtr::get_ptr(right)->y, VariantGetInternalPtr::get_ptr(right)->z, VariantGetInternalPtr::get_ptr(right)->w) * *VariantGetInternalPtr::get_ptr(left); + VariantInternalAccessor::get(r_ret) = Vector4(VariantInternalAccessor::get(right).x, VariantInternalAccessor::get(right).y, VariantInternalAccessor::get(right).z, VariantInternalAccessor::get(right).w) * VariantInternalAccessor::get(left); } static void ptr_evaluate(const void *left, const void *right, void *r_ret) { PtrToArg::encode(Vector4(PtrToArg::convert(right).x, PtrToArg::convert(right).y, PtrToArg::convert(right).z, PtrToArg::convert(right).w) * PtrToArg::convert(left), r_ret); @@ -207,8 +207,8 @@ template <> class OperatorEvaluatorDivNZ { public: static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - const Vector4i &a = *VariantGetInternalPtr::get_ptr(&p_left); - const double &b = *VariantGetInternalPtr::get_ptr(&p_right); + const Vector4i &a = VariantInternalAccessor::get(&p_left); + const double &b = VariantInternalAccessor::get(&p_right); if (unlikely(b == 0)) { r_valid = false; *r_ret = "Division by zero error"; @@ -219,7 +219,7 @@ public: } static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) { - *VariantGetInternalPtr::get_ptr(r_ret) = Vector4(VariantGetInternalPtr::get_ptr(left)->x, VariantGetInternalPtr::get_ptr(left)->y, VariantGetInternalPtr::get_ptr(left)->z, VariantGetInternalPtr::get_ptr(left)->w) / *VariantGetInternalPtr::get_ptr(right); + VariantInternalAccessor::get(r_ret) = Vector4(VariantInternalAccessor::get(left).x, VariantInternalAccessor::get(left).y, VariantInternalAccessor::get(left).z, VariantInternalAccessor::get(left).w) / VariantInternalAccessor::get(right); } static void ptr_evaluate(const void *left, const void *right, void *r_ret) { @@ -1166,7 +1166,7 @@ bool Variant::in(const Variant &p_index, bool *r_valid) const { } if (valid) { ERR_FAIL_COND_V(ret.type != BOOL, false); - return *VariantGetInternalPtr::get_ptr(&ret); + return VariantInternalAccessor::get(&ret); } else { return false; } diff --git a/core/variant/variant_op.h b/core/variant/variant_op.h index 424ebd937d7..0f9fa9f9364 100644 --- a/core/variant/variant_op.h +++ b/core/variant/variant_op.h @@ -39,13 +39,13 @@ template class OperatorEvaluatorAdd { public: static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - const A &a = *VariantGetInternalPtr::get_ptr(&p_left); - const B &b = *VariantGetInternalPtr::get_ptr(&p_right); + const A &a = VariantInternalAccessor::get(&p_left); + const B &b = VariantInternalAccessor::get(&p_right); *r_ret = a + b; r_valid = true; } static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) { - *VariantGetInternalPtr::get_ptr(r_ret) = *VariantGetInternalPtr::get_ptr(left) + *VariantGetInternalPtr::get_ptr(right); + VariantInternalAccessor::get(r_ret) = VariantInternalAccessor::get(left) + VariantInternalAccessor::get(right); } static void ptr_evaluate(const void *left, const void *right, void *r_ret) { PtrToArg::encode(PtrToArg::convert(left) + PtrToArg::convert(right), r_ret); @@ -57,13 +57,13 @@ template class OperatorEvaluatorSub { public: static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - const A &a = *VariantGetInternalPtr::get_ptr(&p_left); - const B &b = *VariantGetInternalPtr::get_ptr(&p_right); + const A &a = VariantInternalAccessor::get(&p_left); + const B &b = VariantInternalAccessor::get(&p_right); *r_ret = a - b; r_valid = true; } static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) { - *VariantGetInternalPtr::get_ptr(r_ret) = *VariantGetInternalPtr::get_ptr(left) - *VariantGetInternalPtr::get_ptr(right); + VariantInternalAccessor::get(r_ret) = VariantInternalAccessor::get(left) - VariantInternalAccessor::get(right); } static void ptr_evaluate(const void *left, const void *right, void *r_ret) { PtrToArg::encode(PtrToArg::convert(left) - PtrToArg::convert(right), r_ret); @@ -75,13 +75,13 @@ template class OperatorEvaluatorMul { public: static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - const A &a = *VariantGetInternalPtr::get_ptr(&p_left); - const B &b = *VariantGetInternalPtr::get_ptr(&p_right); + const A &a = VariantInternalAccessor::get(&p_left); + const B &b = VariantInternalAccessor::get(&p_right); *r_ret = a * b; r_valid = true; } static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) { - *VariantGetInternalPtr::get_ptr(r_ret) = *VariantGetInternalPtr::get_ptr(left) * *VariantGetInternalPtr::get_ptr(right); + VariantInternalAccessor::get(r_ret) = VariantInternalAccessor::get(left) * VariantInternalAccessor::get(right); } static void ptr_evaluate(const void *left, const void *right, void *r_ret) { PtrToArg::encode(PtrToArg::convert(left) * PtrToArg::convert(right), r_ret); @@ -93,13 +93,13 @@ template class OperatorEvaluatorPow { public: static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - const A &a = *VariantGetInternalPtr::get_ptr(&p_left); - const B &b = *VariantGetInternalPtr::get_ptr(&p_right); + const A &a = VariantInternalAccessor::get(&p_left); + const B &b = VariantInternalAccessor::get(&p_right); *r_ret = R(Math::pow((double)a, (double)b)); r_valid = true; } static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) { - *VariantGetInternalPtr::get_ptr(r_ret) = R(Math::pow((double)*VariantGetInternalPtr::get_ptr(left), (double)*VariantGetInternalPtr::get_ptr(right))); + VariantInternalAccessor::get(r_ret) = R(Math::pow((double)VariantInternalAccessor::get(left), (double)VariantInternalAccessor::get(right))); } static void ptr_evaluate(const void *left, const void *right, void *r_ret) { PtrToArg::encode(R(Math::pow((double)PtrToArg::convert(left), (double)PtrToArg::convert(right))), r_ret); @@ -111,13 +111,13 @@ template class OperatorEvaluatorXForm { public: static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - const A &a = *VariantGetInternalPtr::get_ptr(&p_left); - const B &b = *VariantGetInternalPtr::get_ptr(&p_right); + const A &a = VariantInternalAccessor::get(&p_left); + const B &b = VariantInternalAccessor::get(&p_right); *r_ret = a.xform(b); r_valid = true; } static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) { - *VariantGetInternalPtr::get_ptr(r_ret) = VariantGetInternalPtr::get_ptr(left)->xform(*VariantGetInternalPtr::get_ptr(right)); + VariantInternalAccessor::get(r_ret) = VariantInternalAccessor::get(left).xform(VariantInternalAccessor::get(right)); } static void ptr_evaluate(const void *left, const void *right, void *r_ret) { PtrToArg::encode(PtrToArg::convert(left).xform(PtrToArg::convert(right)), r_ret); @@ -129,13 +129,13 @@ template class OperatorEvaluatorXFormInv { public: static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - const A &a = *VariantGetInternalPtr::get_ptr(&p_left); - const B &b = *VariantGetInternalPtr::get_ptr(&p_right); + const A &a = VariantInternalAccessor::get(&p_left); + const B &b = VariantInternalAccessor::get(&p_right); *r_ret = b.xform_inv(a); r_valid = true; } static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) { - *VariantGetInternalPtr::get_ptr(r_ret) = VariantGetInternalPtr::get_ptr(right)->xform_inv(*VariantGetInternalPtr::get_ptr(left)); + VariantInternalAccessor::get(r_ret) = VariantInternalAccessor::get(right).xform_inv(VariantInternalAccessor::get(left)); } static void ptr_evaluate(const void *left, const void *right, void *r_ret) { PtrToArg::encode(PtrToArg::convert(right).xform_inv(PtrToArg::convert(left)), r_ret); @@ -147,13 +147,13 @@ template class OperatorEvaluatorDiv { public: static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - const A &a = *VariantGetInternalPtr::get_ptr(&p_left); - const B &b = *VariantGetInternalPtr::get_ptr(&p_right); + const A &a = VariantInternalAccessor::get(&p_left); + const B &b = VariantInternalAccessor::get(&p_right); *r_ret = a / b; r_valid = true; } static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) { - *VariantGetInternalPtr::get_ptr(r_ret) = *VariantGetInternalPtr::get_ptr(left) / *VariantGetInternalPtr::get_ptr(right); + VariantInternalAccessor::get(r_ret) = VariantInternalAccessor::get(left) / VariantInternalAccessor::get(right); } static void ptr_evaluate(const void *left, const void *right, void *r_ret) { PtrToArg::encode(PtrToArg::convert(left) / PtrToArg::convert(right), r_ret); @@ -165,8 +165,8 @@ template class OperatorEvaluatorDivNZ { public: static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - const A &a = *VariantGetInternalPtr::get_ptr(&p_left); - const B &b = *VariantGetInternalPtr::get_ptr(&p_right); + const A &a = VariantInternalAccessor::get(&p_left); + const B &b = VariantInternalAccessor::get(&p_right); if (b == 0) { r_valid = false; *r_ret = "Division by zero error"; @@ -176,7 +176,7 @@ public: r_valid = true; } static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) { - *VariantGetInternalPtr::get_ptr(r_ret) = *VariantGetInternalPtr::get_ptr(left) / *VariantGetInternalPtr::get_ptr(right); + VariantInternalAccessor::get(r_ret) = VariantInternalAccessor::get(left) / VariantInternalAccessor::get(right); } static void ptr_evaluate(const void *left, const void *right, void *r_ret) { PtrToArg::encode(PtrToArg::convert(left) / PtrToArg::convert(right), r_ret); @@ -188,8 +188,8 @@ template <> class OperatorEvaluatorDivNZ { public: static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - const Vector2i &a = *VariantGetInternalPtr::get_ptr(&p_left); - const Vector2i &b = *VariantGetInternalPtr::get_ptr(&p_right); + const Vector2i &a = VariantInternalAccessor::get(&p_left); + const Vector2i &b = VariantInternalAccessor::get(&p_right); if (unlikely(b.x == 0 || b.y == 0)) { r_valid = false; *r_ret = "Division by zero error"; @@ -200,7 +200,7 @@ public: } static void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) { VariantTypeChanger::change(r_ret); - *VariantGetInternalPtr::get_ptr(r_ret) = *VariantGetInternalPtr::get_ptr(left) / *VariantGetInternalPtr::get_ptr(right); + VariantInternalAccessor::get(r_ret) = VariantInternalAccessor::get(left) / VariantInternalAccessor::get(right); } static void ptr_evaluate(const void *left, const void *right, void *r_ret) { PtrToArg::encode(PtrToArg::convert(left) / PtrToArg::convert(right), r_ret); @@ -212,8 +212,8 @@ template <> class OperatorEvaluatorDivNZ { public: static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - const Vector3i &a = *VariantGetInternalPtr::get_ptr(&p_left); - const Vector3i &b = *VariantGetInternalPtr::get_ptr(&p_right); + const Vector3i &a = VariantInternalAccessor::get(&p_left); + const Vector3i &b = VariantInternalAccessor::get(&p_right); if (unlikely(b.x == 0 || b.y == 0 || b.z == 0)) { r_valid = false; *r_ret = "Division by zero error"; @@ -224,7 +224,7 @@ public: } static void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) { VariantTypeChanger::change(r_ret); - *VariantGetInternalPtr::get_ptr(r_ret) = *VariantGetInternalPtr::get_ptr(left) / *VariantGetInternalPtr::get_ptr(right); + VariantInternalAccessor::get(r_ret) = VariantInternalAccessor::get(left) / VariantInternalAccessor::get(right); } static void ptr_evaluate(const void *left, const void *right, void *r_ret) { PtrToArg::encode(PtrToArg::convert(left) / PtrToArg::convert(right), r_ret); @@ -236,8 +236,8 @@ template <> class OperatorEvaluatorDivNZ { public: static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - const Vector4i &a = *VariantGetInternalPtr::get_ptr(&p_left); - const Vector4i &b = *VariantGetInternalPtr::get_ptr(&p_right); + const Vector4i &a = VariantInternalAccessor::get(&p_left); + const Vector4i &b = VariantInternalAccessor::get(&p_right); if (unlikely(b.x == 0 || b.y == 0 || b.z == 0 || b.w == 0)) { r_valid = false; *r_ret = "Division by zero error"; @@ -248,7 +248,7 @@ public: } static void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) { VariantTypeChanger::change(r_ret); - *VariantGetInternalPtr::get_ptr(r_ret) = *VariantGetInternalPtr::get_ptr(left) / *VariantGetInternalPtr::get_ptr(right); + VariantInternalAccessor::get(r_ret) = VariantInternalAccessor::get(left) / VariantInternalAccessor::get(right); } static void ptr_evaluate(const void *left, const void *right, void *r_ret) { PtrToArg::encode(PtrToArg::convert(left) / PtrToArg::convert(right), r_ret); @@ -260,13 +260,13 @@ template class OperatorEvaluatorMod { public: static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - const A &a = *VariantGetInternalPtr::get_ptr(&p_left); - const B &b = *VariantGetInternalPtr::get_ptr(&p_right); + const A &a = VariantInternalAccessor::get(&p_left); + const B &b = VariantInternalAccessor::get(&p_right); *r_ret = a % b; r_valid = true; } static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) { - *VariantGetInternalPtr::get_ptr(r_ret) = *VariantGetInternalPtr::get_ptr(left) % *VariantGetInternalPtr::get_ptr(right); + VariantInternalAccessor::get(r_ret) = VariantInternalAccessor::get(left) % VariantInternalAccessor::get(right); } static void ptr_evaluate(const void *left, const void *right, void *r_ret) { PtrToArg::encode(PtrToArg::convert(left) % PtrToArg::convert(right), r_ret); @@ -278,8 +278,8 @@ template class OperatorEvaluatorModNZ { public: static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - const A &a = *VariantGetInternalPtr::get_ptr(&p_left); - const B &b = *VariantGetInternalPtr::get_ptr(&p_right); + const A &a = VariantInternalAccessor::get(&p_left); + const B &b = VariantInternalAccessor::get(&p_right); if (b == 0) { r_valid = false; *r_ret = "Modulo by zero error"; @@ -289,7 +289,7 @@ public: r_valid = true; } static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) { - *VariantGetInternalPtr::get_ptr(r_ret) = *VariantGetInternalPtr::get_ptr(left) % *VariantGetInternalPtr::get_ptr(right); + VariantInternalAccessor::get(r_ret) = VariantInternalAccessor::get(left) % VariantInternalAccessor::get(right); } static void ptr_evaluate(const void *left, const void *right, void *r_ret) { PtrToArg::encode(PtrToArg::convert(left) % PtrToArg::convert(right), r_ret); @@ -301,8 +301,8 @@ template <> class OperatorEvaluatorModNZ { public: static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - const Vector2i &a = *VariantGetInternalPtr::get_ptr(&p_left); - const Vector2i &b = *VariantGetInternalPtr::get_ptr(&p_right); + const Vector2i &a = VariantInternalAccessor::get(&p_left); + const Vector2i &b = VariantInternalAccessor::get(&p_right); if (unlikely(b.x == 0 || b.y == 0)) { r_valid = false; *r_ret = "Modulo by zero error"; @@ -313,7 +313,7 @@ public: } static void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) { VariantTypeChanger::change(r_ret); - *VariantGetInternalPtr::get_ptr(r_ret) = *VariantGetInternalPtr::get_ptr(left) % *VariantGetInternalPtr::get_ptr(right); + VariantInternalAccessor::get(r_ret) = VariantInternalAccessor::get(left) % VariantInternalAccessor::get(right); } static void ptr_evaluate(const void *left, const void *right, void *r_ret) { PtrToArg::encode(PtrToArg::convert(left) % PtrToArg::convert(right), r_ret); @@ -325,8 +325,8 @@ template <> class OperatorEvaluatorModNZ { public: static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - const Vector3i &a = *VariantGetInternalPtr::get_ptr(&p_left); - const Vector3i &b = *VariantGetInternalPtr::get_ptr(&p_right); + const Vector3i &a = VariantInternalAccessor::get(&p_left); + const Vector3i &b = VariantInternalAccessor::get(&p_right); if (unlikely(b.x == 0 || b.y == 0 || b.z == 0)) { r_valid = false; *r_ret = "Modulo by zero error"; @@ -337,7 +337,7 @@ public: } static void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) { VariantTypeChanger::change(r_ret); - *VariantGetInternalPtr::get_ptr(r_ret) = *VariantGetInternalPtr::get_ptr(left) % *VariantGetInternalPtr::get_ptr(right); + VariantInternalAccessor::get(r_ret) = VariantInternalAccessor::get(left) % VariantInternalAccessor::get(right); } static void ptr_evaluate(const void *left, const void *right, void *r_ret) { PtrToArg::encode(PtrToArg::convert(left) % PtrToArg::convert(right), r_ret); @@ -349,8 +349,8 @@ template <> class OperatorEvaluatorModNZ { public: static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - const Vector4i &a = *VariantGetInternalPtr::get_ptr(&p_left); - const Vector4i &b = *VariantGetInternalPtr::get_ptr(&p_right); + const Vector4i &a = VariantInternalAccessor::get(&p_left); + const Vector4i &b = VariantInternalAccessor::get(&p_right); if (unlikely(b.x == 0 || b.y == 0 || b.z == 0 || b.w == 0)) { r_valid = false; *r_ret = "Modulo by zero error"; @@ -361,7 +361,7 @@ public: } static void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) { VariantTypeChanger::change(r_ret); - *VariantGetInternalPtr::get_ptr(r_ret) = *VariantGetInternalPtr::get_ptr(left) % *VariantGetInternalPtr::get_ptr(right); + VariantInternalAccessor::get(r_ret) = VariantInternalAccessor::get(left) % VariantInternalAccessor::get(right); } static void ptr_evaluate(const void *left, const void *right, void *r_ret) { PtrToArg::encode(PtrToArg::convert(left) % PtrToArg::convert(right), r_ret); @@ -373,12 +373,12 @@ template class OperatorEvaluatorNeg { public: static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - const A &a = *VariantGetInternalPtr::get_ptr(&p_left); + const A &a = VariantInternalAccessor::get(&p_left); *r_ret = -a; r_valid = true; } static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) { - *VariantGetInternalPtr::get_ptr(r_ret) = -*VariantGetInternalPtr::get_ptr(left); + VariantInternalAccessor::get(r_ret) = -VariantInternalAccessor::get(left); } static void ptr_evaluate(const void *left, const void *right, void *r_ret) { PtrToArg::encode(-PtrToArg::convert(left), r_ret); @@ -390,12 +390,12 @@ template class OperatorEvaluatorPos { public: static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - const A &a = *VariantGetInternalPtr::get_ptr(&p_left); + const A &a = VariantInternalAccessor::get(&p_left); *r_ret = a; r_valid = true; } static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) { - *VariantGetInternalPtr::get_ptr(r_ret) = *VariantGetInternalPtr::get_ptr(left); + VariantInternalAccessor::get(r_ret) = VariantInternalAccessor::get(left); } static void ptr_evaluate(const void *left, const void *right, void *r_ret) { PtrToArg::encode(PtrToArg::convert(left), r_ret); @@ -407,8 +407,8 @@ template class OperatorEvaluatorShiftLeft { public: static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - const A &a = *VariantGetInternalPtr::get_ptr(&p_left); - const B &b = *VariantGetInternalPtr::get_ptr(&p_right); + const A &a = VariantInternalAccessor::get(&p_left); + const B &b = VariantInternalAccessor::get(&p_right); #if defined(DEBUG_ENABLED) if (b < 0 || a < 0) { @@ -421,7 +421,7 @@ public: r_valid = true; } static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) { - *VariantGetInternalPtr::get_ptr(r_ret) = *VariantGetInternalPtr::get_ptr(left) << *VariantGetInternalPtr::get_ptr(right); + VariantInternalAccessor::get(r_ret) = VariantInternalAccessor::get(left) << VariantInternalAccessor::get(right); } static void ptr_evaluate(const void *left, const void *right, void *r_ret) { PtrToArg::encode(PtrToArg::convert(left) << PtrToArg::convert(right), r_ret); @@ -433,8 +433,8 @@ template class OperatorEvaluatorShiftRight { public: static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - const A &a = *VariantGetInternalPtr::get_ptr(&p_left); - const B &b = *VariantGetInternalPtr::get_ptr(&p_right); + const A &a = VariantInternalAccessor::get(&p_left); + const B &b = VariantInternalAccessor::get(&p_right); #if defined(DEBUG_ENABLED) if (b < 0 || a < 0) { @@ -447,7 +447,7 @@ public: r_valid = true; } static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) { - *VariantGetInternalPtr::get_ptr(r_ret) = *VariantGetInternalPtr::get_ptr(left) >> *VariantGetInternalPtr::get_ptr(right); + VariantInternalAccessor::get(r_ret) = VariantInternalAccessor::get(left) >> VariantInternalAccessor::get(right); } static void ptr_evaluate(const void *left, const void *right, void *r_ret) { PtrToArg::encode(PtrToArg::convert(left) >> PtrToArg::convert(right), r_ret); @@ -459,13 +459,13 @@ template class OperatorEvaluatorBitOr { public: static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - const A &a = *VariantGetInternalPtr::get_ptr(&p_left); - const B &b = *VariantGetInternalPtr::get_ptr(&p_right); + const A &a = VariantInternalAccessor::get(&p_left); + const B &b = VariantInternalAccessor::get(&p_right); *r_ret = a | b; r_valid = true; } static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) { - *VariantGetInternalPtr::get_ptr(r_ret) = *VariantGetInternalPtr::get_ptr(left) | *VariantGetInternalPtr::get_ptr(right); + VariantInternalAccessor::get(r_ret) = VariantInternalAccessor::get(left) | VariantInternalAccessor::get(right); } static void ptr_evaluate(const void *left, const void *right, void *r_ret) { PtrToArg::encode(PtrToArg::convert(left) | PtrToArg::convert(right), r_ret); @@ -477,13 +477,13 @@ template class OperatorEvaluatorBitAnd { public: static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - const A &a = *VariantGetInternalPtr::get_ptr(&p_left); - const B &b = *VariantGetInternalPtr::get_ptr(&p_right); + const A &a = VariantInternalAccessor::get(&p_left); + const B &b = VariantInternalAccessor::get(&p_right); *r_ret = a & b; r_valid = true; } static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) { - *VariantGetInternalPtr::get_ptr(r_ret) = *VariantGetInternalPtr::get_ptr(left) & *VariantGetInternalPtr::get_ptr(right); + VariantInternalAccessor::get(r_ret) = VariantInternalAccessor::get(left) & VariantInternalAccessor::get(right); } static void ptr_evaluate(const void *left, const void *right, void *r_ret) { PtrToArg::encode(PtrToArg::convert(left) & PtrToArg::convert(right), r_ret); @@ -495,13 +495,13 @@ template class OperatorEvaluatorBitXor { public: static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - const A &a = *VariantGetInternalPtr::get_ptr(&p_left); - const B &b = *VariantGetInternalPtr::get_ptr(&p_right); + const A &a = VariantInternalAccessor::get(&p_left); + const B &b = VariantInternalAccessor::get(&p_right); *r_ret = a ^ b; r_valid = true; } static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) { - *VariantGetInternalPtr::get_ptr(r_ret) = *VariantGetInternalPtr::get_ptr(left) ^ *VariantGetInternalPtr::get_ptr(right); + VariantInternalAccessor::get(r_ret) = VariantInternalAccessor::get(left) ^ VariantInternalAccessor::get(right); } static void ptr_evaluate(const void *left, const void *right, void *r_ret) { PtrToArg::encode(PtrToArg::convert(left) ^ PtrToArg::convert(right), r_ret); @@ -513,12 +513,12 @@ template class OperatorEvaluatorBitNeg { public: static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - const A &a = *VariantGetInternalPtr::get_ptr(&p_left); + const A &a = VariantInternalAccessor::get(&p_left); *r_ret = ~a; r_valid = true; } static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) { - *VariantGetInternalPtr::get_ptr(r_ret) = ~*VariantGetInternalPtr::get_ptr(left); + VariantInternalAccessor::get(r_ret) = ~VariantInternalAccessor::get(left); } static void ptr_evaluate(const void *left, const void *right, void *r_ret) { PtrToArg::encode(~PtrToArg::convert(left), r_ret); @@ -530,13 +530,13 @@ template class OperatorEvaluatorEqual { public: static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - const A &a = *VariantGetInternalPtr::get_ptr(&p_left); - const B &b = *VariantGetInternalPtr::get_ptr(&p_right); + const A &a = VariantInternalAccessor::get(&p_left); + const B &b = VariantInternalAccessor::get(&p_right); *r_ret = a == b; r_valid = true; } static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) { - *VariantGetInternalPtr::get_ptr(r_ret) = *VariantGetInternalPtr::get_ptr(left) == *VariantGetInternalPtr::get_ptr(right); + VariantInternalAccessor::get(r_ret) = VariantInternalAccessor::get(left) == VariantInternalAccessor::get(right); } static void ptr_evaluate(const void *left, const void *right, void *r_ret) { PtrToArg::encode(PtrToArg::convert(left) == PtrToArg::convert(right), r_ret); @@ -555,7 +555,7 @@ public: static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) { const Object *a = left->get_validated_object(); const Object *b = right->get_validated_object(); - *VariantGetInternalPtr::get_ptr(r_ret) = a == b; + VariantInternalAccessor::get(r_ret) = a == b; } static void ptr_evaluate(const void *left, const void *right, void *r_ret) { PtrToArg::encode(PtrToArg::convert(left) == PtrToArg::convert(right), r_ret); @@ -572,7 +572,7 @@ public: } static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) { const Object *a = left->get_validated_object(); - *VariantGetInternalPtr::get_ptr(r_ret) = a == nullptr; + VariantInternalAccessor::get(r_ret) = a == nullptr; } static void ptr_evaluate(const void *left, const void *right, void *r_ret) { PtrToArg::encode(PtrToArg::convert(left) == nullptr, r_ret); @@ -589,7 +589,7 @@ public: } static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) { const Object *b = right->get_validated_object(); - *VariantGetInternalPtr::get_ptr(r_ret) = nullptr == b; + VariantInternalAccessor::get(r_ret) = nullptr == b; } static void ptr_evaluate(const void *left, const void *right, void *r_ret) { PtrToArg::encode(nullptr == PtrToArg::convert(right), r_ret); @@ -601,13 +601,13 @@ template class OperatorEvaluatorNotEqual { public: static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - const A &a = *VariantGetInternalPtr::get_ptr(&p_left); - const B &b = *VariantGetInternalPtr::get_ptr(&p_right); + const A &a = VariantInternalAccessor::get(&p_left); + const B &b = VariantInternalAccessor::get(&p_right); *r_ret = a != b; r_valid = true; } static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) { - *VariantGetInternalPtr::get_ptr(r_ret) = *VariantGetInternalPtr::get_ptr(left) != *VariantGetInternalPtr::get_ptr(right); + VariantInternalAccessor::get(r_ret) = VariantInternalAccessor::get(left) != VariantInternalAccessor::get(right); } static void ptr_evaluate(const void *left, const void *right, void *r_ret) { PtrToArg::encode(PtrToArg::convert(left) != PtrToArg::convert(right), r_ret); @@ -626,7 +626,7 @@ public: static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) { Object *a = left->get_validated_object(); Object *b = right->get_validated_object(); - *VariantGetInternalPtr::get_ptr(r_ret) = a != b; + VariantInternalAccessor::get(r_ret) = a != b; } static void ptr_evaluate(const void *left, const void *right, void *r_ret) { PtrToArg::encode(PtrToArg::convert(left) != PtrToArg::convert(right), r_ret); @@ -643,7 +643,7 @@ public: } static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) { Object *a = left->get_validated_object(); - *VariantGetInternalPtr::get_ptr(r_ret) = a != nullptr; + VariantInternalAccessor::get(r_ret) = a != nullptr; } static void ptr_evaluate(const void *left, const void *right, void *r_ret) { PtrToArg::encode(PtrToArg::convert(left) != nullptr, r_ret); @@ -660,7 +660,7 @@ public: } static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) { Object *b = right->get_validated_object(); - *VariantGetInternalPtr::get_ptr(r_ret) = nullptr != b; + VariantInternalAccessor::get(r_ret) = nullptr != b; } static void ptr_evaluate(const void *left, const void *right, void *r_ret) { PtrToArg::encode(nullptr != PtrToArg::convert(right), r_ret); @@ -672,13 +672,13 @@ template class OperatorEvaluatorLess { public: static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - const A &a = *VariantGetInternalPtr::get_ptr(&p_left); - const B &b = *VariantGetInternalPtr::get_ptr(&p_right); + const A &a = VariantInternalAccessor::get(&p_left); + const B &b = VariantInternalAccessor::get(&p_right); *r_ret = a < b; r_valid = true; } static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) { - *VariantGetInternalPtr::get_ptr(r_ret) = *VariantGetInternalPtr::get_ptr(left) < *VariantGetInternalPtr::get_ptr(right); + VariantInternalAccessor::get(r_ret) = VariantInternalAccessor::get(left) < VariantInternalAccessor::get(right); } static void ptr_evaluate(const void *left, const void *right, void *r_ret) { PtrToArg::encode(PtrToArg::convert(left) < PtrToArg::convert(right), r_ret); @@ -690,13 +690,13 @@ template class OperatorEvaluatorLessEqual { public: static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - const A &a = *VariantGetInternalPtr::get_ptr(&p_left); - const B &b = *VariantGetInternalPtr::get_ptr(&p_right); + const A &a = VariantInternalAccessor::get(&p_left); + const B &b = VariantInternalAccessor::get(&p_right); *r_ret = a <= b; r_valid = true; } static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) { - *VariantGetInternalPtr::get_ptr(r_ret) = *VariantGetInternalPtr::get_ptr(left) <= *VariantGetInternalPtr::get_ptr(right); + VariantInternalAccessor::get(r_ret) = VariantInternalAccessor::get(left) <= VariantInternalAccessor::get(right); } static void ptr_evaluate(const void *left, const void *right, void *r_ret) { PtrToArg::encode(PtrToArg::convert(left) <= PtrToArg::convert(right), r_ret); @@ -708,13 +708,13 @@ template class OperatorEvaluatorGreater { public: static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - const A &a = *VariantGetInternalPtr::get_ptr(&p_left); - const B &b = *VariantGetInternalPtr::get_ptr(&p_right); + const A &a = VariantInternalAccessor::get(&p_left); + const B &b = VariantInternalAccessor::get(&p_right); *r_ret = a > b; r_valid = true; } static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) { - *VariantGetInternalPtr::get_ptr(r_ret) = *VariantGetInternalPtr::get_ptr(left) > *VariantGetInternalPtr::get_ptr(right); + VariantInternalAccessor::get(r_ret) = VariantInternalAccessor::get(left) > VariantInternalAccessor::get(right); } static void ptr_evaluate(const void *left, const void *right, void *r_ret) { PtrToArg::encode(PtrToArg::convert(left) > PtrToArg::convert(right), r_ret); @@ -726,13 +726,13 @@ template class OperatorEvaluatorGreaterEqual { public: static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - const A &a = *VariantGetInternalPtr::get_ptr(&p_left); - const B &b = *VariantGetInternalPtr::get_ptr(&p_right); + const A &a = VariantInternalAccessor::get(&p_left); + const B &b = VariantInternalAccessor::get(&p_right); *r_ret = a >= b; r_valid = true; } static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) { - *VariantGetInternalPtr::get_ptr(r_ret) = *VariantGetInternalPtr::get_ptr(left) >= *VariantGetInternalPtr::get_ptr(right); + VariantInternalAccessor::get(r_ret) = VariantInternalAccessor::get(left) >= VariantInternalAccessor::get(right); } static void ptr_evaluate(const void *left, const void *right, void *r_ret) { PtrToArg::encode(PtrToArg::convert(left) >= PtrToArg::convert(right), r_ret); @@ -744,13 +744,13 @@ template class OperatorEvaluatorAnd { public: static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - const A &a = *VariantGetInternalPtr::get_ptr(&p_left); - const B &b = *VariantGetInternalPtr::get_ptr(&p_right); + const A &a = VariantInternalAccessor::get(&p_left); + const B &b = VariantInternalAccessor::get(&p_right); *r_ret = a && b; r_valid = true; } static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) { - *VariantGetInternalPtr::get_ptr(r_ret) = *VariantGetInternalPtr::get_ptr(left) && *VariantGetInternalPtr::get_ptr(right); + VariantInternalAccessor::get(r_ret) = VariantInternalAccessor::get(left) && VariantInternalAccessor::get(right); } static void ptr_evaluate(const void *left, const void *right, void *r_ret) { PtrToArg::encode(PtrToArg::convert(left) && PtrToArg::convert(right), r_ret); @@ -762,13 +762,13 @@ template class OperatorEvaluatorOr { public: static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - const A &a = *VariantGetInternalPtr::get_ptr(&p_left); - const B &b = *VariantGetInternalPtr::get_ptr(&p_right); + const A &a = VariantInternalAccessor::get(&p_left); + const B &b = VariantInternalAccessor::get(&p_right); *r_ret = a || b; r_valid = true; } static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) { - *VariantGetInternalPtr::get_ptr(r_ret) = *VariantGetInternalPtr::get_ptr(left) || *VariantGetInternalPtr::get_ptr(right); + VariantInternalAccessor::get(r_ret) = VariantInternalAccessor::get(left) || VariantInternalAccessor::get(right); } static void ptr_evaluate(const void *left, const void *right, void *r_ret) { PtrToArg::encode(PtrToArg::convert(left) || PtrToArg::convert(right), r_ret); @@ -784,13 +784,13 @@ public: return ((a) || (b)) && !((a) && (b)); } static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - const A &a = *VariantGetInternalPtr::get_ptr(&p_left); - const B &b = *VariantGetInternalPtr::get_ptr(&p_right); + const A &a = VariantInternalAccessor::get(&p_left); + const B &b = VariantInternalAccessor::get(&p_right); *r_ret = xor_op(a, b); r_valid = true; } static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) { - *VariantGetInternalPtr::get_ptr(r_ret) = xor_op(*VariantGetInternalPtr::get_ptr(left), *VariantGetInternalPtr::get_ptr(right)); + VariantInternalAccessor::get(r_ret) = xor_op(VariantInternalAccessor::get(left), VariantInternalAccessor::get(right)); } static void ptr_evaluate(const void *left, const void *right, void *r_ret) { PtrToArg::encode(xor_op(PtrToArg::convert(left), PtrToArg::convert(right)), r_ret); @@ -802,12 +802,12 @@ template class OperatorEvaluatorNot { public: static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - const A &a = *VariantGetInternalPtr::get_ptr(&p_left); + const A &a = VariantInternalAccessor::get(&p_left); *r_ret = a == A(); r_valid = true; } static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) { - *VariantGetInternalPtr::get_ptr(r_ret) = *VariantGetInternalPtr::get_ptr(left) == A(); + VariantInternalAccessor::get(r_ret) = VariantInternalAccessor::get(left) == A(); } static void ptr_evaluate(const void *left, const void *right, void *r_ret) { PtrToArg::encode(PtrToArg::convert(left) == A(), r_ret); @@ -836,8 +836,8 @@ public: } } static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - const Array &array_a = *VariantGetInternalPtr::get_ptr(&p_left); - const Array &array_b = *VariantGetInternalPtr::get_ptr(&p_right); + const Array &array_a = VariantInternalAccessor::get(&p_left); + const Array &array_b = VariantInternalAccessor::get(&p_right); Array sum; _add_arrays(sum, array_a, array_b); *r_ret = sum; @@ -845,7 +845,7 @@ public: } static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) { *r_ret = Array(); - _add_arrays(*VariantGetInternalPtr::get_ptr(r_ret), *VariantGetInternalPtr::get_ptr(left), *VariantGetInternalPtr::get_ptr(right)); + _add_arrays(VariantInternalAccessor::get(r_ret), VariantInternalAccessor::get(left), VariantInternalAccessor::get(right)); } static void ptr_evaluate(const void *left, const void *right, void *r_ret) { Array ret; @@ -859,16 +859,16 @@ template class OperatorEvaluatorAppendArray { public: static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - const Vector &array_a = *VariantGetInternalPtr>::get_ptr(&p_left); - const Vector &array_b = *VariantGetInternalPtr>::get_ptr(&p_right); + const Vector &array_a = VariantInternalAccessor>::get(&p_left); + const Vector &array_b = VariantInternalAccessor>::get(&p_right); Vector sum = array_a; sum.append_array(array_b); *r_ret = sum; r_valid = true; } static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) { - *VariantGetInternalPtr>::get_ptr(r_ret) = *VariantGetInternalPtr>::get_ptr(left); - VariantGetInternalPtr>::get_ptr(r_ret)->append_array(*VariantGetInternalPtr>::get_ptr(right)); + VariantInternalAccessor>::get(r_ret) = VariantInternalAccessor>::get(left); + VariantInternalAccessor>::get(r_ret).append_array(VariantInternalAccessor>::get(right)); } static void ptr_evaluate(const void *left, const void *right, void *r_ret) { Vector sum = PtrToArg>::convert(left); @@ -882,15 +882,15 @@ template class OperatorEvaluatorStringConcat { public: static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - const String a(*VariantGetInternalPtr::get_ptr(&p_left)); - const String b(*VariantGetInternalPtr::get_ptr(&p_right)); + const String a(VariantInternalAccessor::get(&p_left)); + const String b(VariantInternalAccessor::get(&p_right)); *r_ret = a + b; r_valid = true; } static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) { - const String a(*VariantGetInternalPtr::get_ptr(left)); - const String b(*VariantGetInternalPtr::get_ptr(right)); - *VariantGetInternalPtr::get_ptr(r_ret) = a + b; + const String a(VariantInternalAccessor::get(left)); + const String b(VariantInternalAccessor::get(right)); + VariantInternalAccessor::get(r_ret) = a + b; } static void ptr_evaluate(const void *left, const void *right, void *r_ret) { const String a(PtrToArg::convert(left)); @@ -915,16 +915,16 @@ public: return a; } static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - *r_ret = do_mod(*VariantGetInternalPtr::get_ptr(&p_left), &r_valid); + *r_ret = do_mod(VariantInternalAccessor::get(&p_left), &r_valid); } static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) { bool valid = true; - String result = do_mod(*VariantGetInternalPtr::get_ptr(left), &valid); + String result = do_mod(VariantInternalAccessor::get(left), &valid); if (unlikely(!valid)) { - *VariantGetInternalPtr::get_ptr(r_ret) = *VariantGetInternalPtr::get_ptr(left); + VariantInternalAccessor::get(r_ret) = VariantInternalAccessor::get(left); ERR_FAIL_MSG(vformat("String formatting error: %s.", result)); } - *VariantGetInternalPtr::get_ptr(r_ret) = result; + VariantInternalAccessor::get(r_ret) = result; } static void ptr_evaluate(const void *left, const void *right, void *r_ret) { PtrToArg::encode(do_mod(PtrToArg::convert(left), nullptr), r_ret); @@ -943,16 +943,16 @@ public: return a; } static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - *r_ret = do_mod(*VariantGetInternalPtr::get_ptr(&p_left), *VariantGetInternalPtr::get_ptr(&p_right), &r_valid); + *r_ret = do_mod(VariantInternalAccessor::get(&p_left), VariantInternalAccessor::get(&p_right), &r_valid); } static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) { bool valid = true; - String result = do_mod(*VariantGetInternalPtr::get_ptr(left), *VariantGetInternalPtr::get_ptr(right), &valid); + String result = do_mod(VariantInternalAccessor::get(left), VariantInternalAccessor::get(right), &valid); if (unlikely(!valid)) { - *VariantGetInternalPtr::get_ptr(r_ret) = *VariantGetInternalPtr::get_ptr(left); + VariantInternalAccessor::get(r_ret) = VariantInternalAccessor::get(left); ERR_FAIL_MSG(vformat("String formatting error: %s.", result)); } - *VariantGetInternalPtr::get_ptr(r_ret) = result; + VariantInternalAccessor::get(r_ret) = result; } static void ptr_evaluate(const void *left, const void *right, void *r_ret) { PtrToArg::encode(do_mod(PtrToArg::convert(left), PtrToArg::convert(right), nullptr), r_ret); @@ -973,16 +973,16 @@ public: return a; } static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - *r_ret = do_mod(*VariantGetInternalPtr::get_ptr(&p_left), p_right.get_validated_object(), &r_valid); + *r_ret = do_mod(VariantInternalAccessor::get(&p_left), p_right.get_validated_object(), &r_valid); } static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) { bool valid = true; - String result = do_mod(*VariantGetInternalPtr::get_ptr(left), right->get_validated_object(), &valid); + String result = do_mod(VariantInternalAccessor::get(left), right->get_validated_object(), &valid); if (unlikely(!valid)) { - *VariantGetInternalPtr::get_ptr(r_ret) = *VariantGetInternalPtr::get_ptr(left); + VariantInternalAccessor::get(r_ret) = VariantInternalAccessor::get(left); ERR_FAIL_MSG(vformat("String formatting error: %s.", result)); } - *VariantGetInternalPtr::get_ptr(r_ret) = result; + VariantInternalAccessor::get(r_ret) = result; } static void ptr_evaluate(const void *left, const void *right, void *r_ret) { PtrToArg::encode(do_mod(PtrToArg::convert(left), PtrToArg::convert(right), nullptr), r_ret); @@ -1002,16 +1002,16 @@ public: return a; } static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - *r_ret = do_mod(*VariantGetInternalPtr::get_ptr(&p_left), *VariantGetInternalPtr::get_ptr(&p_right), &r_valid); + *r_ret = do_mod(VariantInternalAccessor::get(&p_left), VariantInternalAccessor::get(&p_right), &r_valid); } static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) { bool valid = true; - String result = do_mod(*VariantGetInternalPtr::get_ptr(left), *VariantGetInternalPtr::get_ptr(right), &valid); + String result = do_mod(VariantInternalAccessor::get(left), VariantInternalAccessor::get(right), &valid); if (unlikely(!valid)) { - *VariantGetInternalPtr::get_ptr(r_ret) = *VariantGetInternalPtr::get_ptr(left); + VariantInternalAccessor::get(r_ret) = VariantInternalAccessor::get(left); ERR_FAIL_MSG(vformat("String formatting error: %s.", result)); } - *VariantGetInternalPtr::get_ptr(r_ret) = result; + VariantInternalAccessor::get(r_ret) = result; } static void ptr_evaluate(const void *left, const void *right, void *r_ret) { PtrToArg::encode(do_mod(PtrToArg::convert(left), PtrToArg::convert(right), nullptr), r_ret); @@ -1027,7 +1027,7 @@ public: r_valid = true; } static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) { - *VariantGetInternalPtr::get_ptr(r_ret) = true; + VariantInternalAccessor::get(r_ret) = true; } static void ptr_evaluate(const void *left, const void *right, void *r_ret) { PtrToArg::encode(true, r_ret); @@ -1043,7 +1043,7 @@ public: r_valid = true; } static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) { - *VariantGetInternalPtr::get_ptr(r_ret) = false; + VariantInternalAccessor::get(r_ret) = false; } static void ptr_evaluate(const void *left, const void *right, void *r_ret) { PtrToArg::encode(false, r_ret); @@ -1070,15 +1070,15 @@ _FORCE_INLINE_ static bool _operate_get_nil(const Variant *p_ptr) { } _FORCE_INLINE_ static bool _operate_get_bool(const Variant *p_ptr) { - return *VariantGetInternalPtr::get_ptr(p_ptr); + return VariantInternalAccessor::get(p_ptr); } _FORCE_INLINE_ static bool _operate_get_int(const Variant *p_ptr) { - return *VariantGetInternalPtr::get_ptr(p_ptr) != 0; + return VariantInternalAccessor::get(p_ptr) != 0; } _FORCE_INLINE_ static bool _operate_get_float(const Variant *p_ptr) { - return *VariantGetInternalPtr::get_ptr(p_ptr) != 0.0; + return VariantInternalAccessor::get(p_ptr) != 0.0; } _FORCE_INLINE_ static bool _operate_get_object(const Variant *p_ptr) { @@ -1105,25 +1105,25 @@ _FORCE_INLINE_ static bool _operate_get_ptr_object(const void *p_ptr) { return PtrToArg::convert(p_ptr) != nullptr; } -#define OP_EVALUATOR(m_class_name, m_left, m_right, m_op) \ - class m_class_name { \ - public: \ - static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { \ - *r_ret = m_op(_operate_get_##m_left(&p_left), _operate_get_##m_right(&p_right)); \ - r_valid = true; \ - } \ - \ - static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) { \ - *VariantGetInternalPtr::get_ptr(r_ret) = m_op(_operate_get_##m_left(left), _operate_get_##m_right(right)); \ - } \ - \ - static void ptr_evaluate(const void *left, const void *right, void *r_ret) { \ - PtrToArg::encode(m_op(_operate_get_ptr_##m_left(left), _operate_get_ptr_##m_right(right)), r_ret); \ - } \ - \ - static Variant::Type get_return_type() { \ - return Variant::BOOL; \ - } \ +#define OP_EVALUATOR(m_class_name, m_left, m_right, m_op) \ + class m_class_name { \ + public: \ + static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { \ + *r_ret = m_op(_operate_get_##m_left(&p_left), _operate_get_##m_right(&p_right)); \ + r_valid = true; \ + } \ + \ + static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) { \ + VariantInternalAccessor::get(r_ret) = m_op(_operate_get_##m_left(left), _operate_get_##m_right(right)); \ + } \ + \ + static void ptr_evaluate(const void *left, const void *right, void *r_ret) { \ + PtrToArg::encode(m_op(_operate_get_ptr_##m_left(left), _operate_get_ptr_##m_right(right)), r_ret); \ + } \ + \ + static Variant::Type get_return_type() { \ + return Variant::BOOL; \ + } \ }; // OR @@ -1264,11 +1264,11 @@ OP_EVALUATOR(OperatorEvaluatorObjectXObjectXor, object, object, _operate_xor) class OperatorEvaluatorNotBool { public: static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - *r_ret = !*VariantGetInternalPtr::get_ptr(&p_left); + *r_ret = !VariantInternalAccessor::get(&p_left); r_valid = true; } static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) { - *VariantGetInternalPtr::get_ptr(r_ret) = !*VariantGetInternalPtr::get_ptr(left); + VariantInternalAccessor::get(r_ret) = !VariantInternalAccessor::get(left); } static void ptr_evaluate(const void *left, const void *right, void *r_ret) { PtrToArg::encode(!PtrToArg::convert(left), r_ret); @@ -1279,11 +1279,11 @@ public: class OperatorEvaluatorNotInt { public: static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - *r_ret = !*VariantGetInternalPtr::get_ptr(&p_left); + *r_ret = !VariantInternalAccessor::get(&p_left); r_valid = true; } static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) { - *VariantGetInternalPtr::get_ptr(r_ret) = !*VariantGetInternalPtr::get_ptr(left); + VariantInternalAccessor::get(r_ret) = !VariantInternalAccessor::get(left); } static void ptr_evaluate(const void *left, const void *right, void *r_ret) { PtrToArg::encode(!PtrToArg::convert(left), r_ret); @@ -1294,11 +1294,11 @@ public: class OperatorEvaluatorNotFloat { public: static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - *r_ret = !*VariantGetInternalPtr::get_ptr(&p_left); + *r_ret = !VariantInternalAccessor::get(&p_left); r_valid = true; } static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) { - *VariantGetInternalPtr::get_ptr(r_ret) = !*VariantGetInternalPtr::get_ptr(left); + VariantInternalAccessor::get(r_ret) = !VariantInternalAccessor::get(left); } static void ptr_evaluate(const void *left, const void *right, void *r_ret) { PtrToArg::encode(!PtrToArg::convert(left), r_ret); @@ -1313,7 +1313,7 @@ public: r_valid = true; } static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) { - *VariantGetInternalPtr::get_ptr(r_ret) = left->get_validated_object() == nullptr; + VariantInternalAccessor::get(r_ret) = left->get_validated_object() == nullptr; } static void ptr_evaluate(const void *left, const void *right, void *r_ret) { PtrToArg::encode(PtrToArg::convert(left) == nullptr, r_ret); @@ -1330,16 +1330,16 @@ template class OperatorEvaluatorInStringFind { public: static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - const Left &str_a = *VariantGetInternalPtr::get_ptr(&p_left); - const String &str_b = *VariantGetInternalPtr::get_ptr(&p_right); + const Left &str_a = VariantInternalAccessor::get(&p_left); + const String &str_b = VariantInternalAccessor::get(&p_right); *r_ret = str_b.find(str_a) != -1; r_valid = true; } static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) { - const Left &str_a = *VariantGetInternalPtr::get_ptr(left); - const String &str_b = *VariantGetInternalPtr::get_ptr(right); - *VariantGetInternalPtr::get_ptr(r_ret) = str_b.find(str_a) != -1; + const Left &str_a = VariantInternalAccessor::get(left); + const String &str_b = VariantInternalAccessor::get(right); + VariantInternalAccessor::get(r_ret) = str_b.find(str_a) != -1; } static void ptr_evaluate(const void *left, const void *right, void *r_ret) { PtrToArg::encode(PtrToArg::convert(right).find(PtrToArg::convert(left)) != -1, r_ret); @@ -1351,16 +1351,16 @@ template class OperatorEvaluatorInStringFind { public: static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - const Left &str_a = *VariantGetInternalPtr::get_ptr(&p_left); - const String str_b = VariantGetInternalPtr::get_ptr(&p_right)->operator String(); + const Left &str_a = VariantInternalAccessor::get(&p_left); + const String str_b = VariantInternalAccessor::get(&p_right).operator String(); *r_ret = str_b.find(str_a) != -1; r_valid = true; } static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) { - const Left &str_a = *VariantGetInternalPtr::get_ptr(left); - const String str_b = VariantGetInternalPtr::get_ptr(right)->operator String(); - *VariantGetInternalPtr::get_ptr(r_ret) = str_b.find(str_a) != -1; + const Left &str_a = VariantInternalAccessor::get(left); + const String str_b = VariantInternalAccessor::get(right).operator String(); + VariantInternalAccessor::get(r_ret) = str_b.find(str_a) != -1; } static void ptr_evaluate(const void *left, const void *right, void *r_ret) { PtrToArg::encode(PtrToArg::convert(right).operator String().find(PtrToArg::convert(left)) != -1, r_ret); @@ -1372,16 +1372,16 @@ template class OperatorEvaluatorInArrayFind { public: static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - const A &a = *VariantGetInternalPtr::get_ptr(&p_left); - const B &b = *VariantGetInternalPtr::get_ptr(&p_right); + const A &a = VariantInternalAccessor::get(&p_left); + const B &b = VariantInternalAccessor::get(&p_right); *r_ret = b.find(a) != -1; r_valid = true; } static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) { - const A &a = *VariantGetInternalPtr::get_ptr(left); - const B &b = *VariantGetInternalPtr::get_ptr(right); - *VariantGetInternalPtr::get_ptr(r_ret) = b.find(a) != -1; + const A &a = VariantInternalAccessor::get(left); + const B &b = VariantInternalAccessor::get(right); + VariantInternalAccessor::get(r_ret) = b.find(a) != -1; } static void ptr_evaluate(const void *left, const void *right, void *r_ret) { PtrToArg::encode(PtrToArg::convert(right).find(PtrToArg::convert(left)) != -1, r_ret); @@ -1392,13 +1392,13 @@ public: class OperatorEvaluatorInArrayFindNil { public: static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - const Array &b = *VariantGetInternalPtr::get_ptr(&p_right); + const Array &b = VariantInternalAccessor::get(&p_right); *r_ret = b.find(Variant()) != -1; r_valid = true; } static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) { - const Array &b = *VariantGetInternalPtr::get_ptr(right); - *VariantGetInternalPtr::get_ptr(r_ret) = b.find(Variant()) != -1; + const Array &b = VariantInternalAccessor::get(right); + VariantInternalAccessor::get(r_ret) = b.find(Variant()) != -1; } static void ptr_evaluate(const void *left, const void *right, void *r_ret) { PtrToArg::encode(PtrToArg::convert(right).find(Variant()) != -1, r_ret); @@ -1409,13 +1409,13 @@ public: class OperatorEvaluatorInArrayFindObject { public: static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - const Array &b = *VariantGetInternalPtr::get_ptr(&p_right); + const Array &b = VariantInternalAccessor::get(&p_right); *r_ret = b.find(p_left) != -1; r_valid = true; } static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) { - const Array &b = *VariantGetInternalPtr::get_ptr(right); - *VariantGetInternalPtr::get_ptr(r_ret) = b.find(*left) != -1; + const Array &b = VariantInternalAccessor::get(right); + VariantInternalAccessor::get(r_ret) = b.find(*left) != -1; } static void ptr_evaluate(const void *left, const void *right, void *r_ret) { PtrToArg::encode(PtrToArg::convert(right).find(PtrToArg::convert(left)) != -1, r_ret); @@ -1427,16 +1427,16 @@ template class OperatorEvaluatorInDictionaryHas { public: static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - const Dictionary &b = *VariantGetInternalPtr::get_ptr(&p_right); - const A &a = *VariantGetInternalPtr::get_ptr(&p_left); + const Dictionary &b = VariantInternalAccessor::get(&p_right); + const A &a = VariantInternalAccessor::get(&p_left); *r_ret = b.has(a); r_valid = true; } static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) { - const Dictionary &b = *VariantGetInternalPtr::get_ptr(right); - const A &a = *VariantGetInternalPtr::get_ptr(left); - *VariantGetInternalPtr::get_ptr(r_ret) = b.has(a); + const Dictionary &b = VariantInternalAccessor::get(right); + const A &a = VariantInternalAccessor::get(left); + VariantInternalAccessor::get(r_ret) = b.has(a); } static void ptr_evaluate(const void *left, const void *right, void *r_ret) { PtrToArg::encode(PtrToArg::convert(right).has(PtrToArg::convert(left)), r_ret); @@ -1447,14 +1447,14 @@ public: class OperatorEvaluatorInDictionaryHasNil { public: static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - const Dictionary &b = *VariantGetInternalPtr::get_ptr(&p_right); + const Dictionary &b = VariantInternalAccessor::get(&p_right); *r_ret = b.has(Variant()); r_valid = true; } static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) { - const Dictionary &b = *VariantGetInternalPtr::get_ptr(right); - *VariantGetInternalPtr::get_ptr(r_ret) = b.has(Variant()); + const Dictionary &b = VariantInternalAccessor::get(right); + VariantInternalAccessor::get(r_ret) = b.has(Variant()); } static void ptr_evaluate(const void *left, const void *right, void *r_ret) { PtrToArg::encode(PtrToArg::convert(right).has(Variant()), r_ret); @@ -1465,14 +1465,14 @@ public: class OperatorEvaluatorInDictionaryHasObject { public: static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - const Dictionary &b = *VariantGetInternalPtr::get_ptr(&p_right); + const Dictionary &b = VariantInternalAccessor::get(&p_right); *r_ret = b.has(p_left); r_valid = true; } static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) { - const Dictionary &b = *VariantGetInternalPtr::get_ptr(right); - *VariantGetInternalPtr::get_ptr(r_ret) = b.has(*left); + const Dictionary &b = VariantInternalAccessor::get(right); + VariantInternalAccessor::get(r_ret) = b.has(*left); } static void ptr_evaluate(const void *left, const void *right, void *r_ret) { PtrToArg::encode(PtrToArg::convert(right).has(PtrToArg::convert(left)), r_ret); @@ -1490,7 +1490,7 @@ public: return; } - const String &a = *VariantGetInternalPtr::get_ptr(&p_left); + const String &a = VariantInternalAccessor::get(&p_left); bool exist; b->get(a, &exist); @@ -1500,14 +1500,14 @@ public: static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) { Object *l = right->get_validated_object(); if (unlikely(!l)) { - *VariantGetInternalPtr::get_ptr(r_ret) = false; + VariantInternalAccessor::get(r_ret) = false; ERR_FAIL_MSG("Invalid base object for 'in'."); } - const String &a = *VariantGetInternalPtr::get_ptr(left); + const String &a = VariantInternalAccessor::get(left); bool valid; l->get(a, &valid); - *VariantGetInternalPtr::get_ptr(r_ret) = valid; + VariantInternalAccessor::get(r_ret) = valid; } static void ptr_evaluate(const void *left, const void *right, void *r_ret) { bool valid; @@ -1527,7 +1527,7 @@ public: return; } - const StringName &a = *VariantGetInternalPtr::get_ptr(&p_left); + const StringName &a = VariantInternalAccessor::get(&p_left); bool exist; b->get(a, &exist); @@ -1537,14 +1537,14 @@ public: static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) { Object *l = right->get_validated_object(); if (unlikely(!l)) { - *VariantGetInternalPtr::get_ptr(r_ret) = false; + VariantInternalAccessor::get(r_ret) = false; ERR_FAIL_MSG("Invalid base object for 'in'."); } - const StringName &a = *VariantGetInternalPtr::get_ptr(left); + const StringName &a = VariantInternalAccessor::get(left); bool valid; l->get(a, &valid); - *VariantGetInternalPtr::get_ptr(r_ret) = valid; + VariantInternalAccessor::get(r_ret) = valid; } static void ptr_evaluate(const void *left, const void *right, void *r_ret) { bool valid; diff --git a/core/variant/variant_setget.cpp b/core/variant/variant_setget.cpp index b6e0dbe6d06..90c976d6e66 100644 --- a/core/variant/variant_setget.cpp +++ b/core/variant/variant_setget.cpp @@ -256,7 +256,7 @@ void Variant::set_named(const StringName &p_member, const Variant &p_value, bool return; } } else if (type == Variant::DICTIONARY) { - Dictionary &dict = *VariantGetInternalPtr::get_ptr(this); + Dictionary &dict = VariantInternalAccessor::get(this); r_valid = dict.set(p_member, p_value); } else { r_valid = false; @@ -287,7 +287,7 @@ Variant Variant::get_named(const StringName &p_member, bool &r_valid) const { } } break; case Variant::DICTIONARY: { - const Variant *v = VariantGetInternalPtr::get_ptr(this)->getptr(p_member); + const Variant *v = VariantInternalAccessor::get(this).getptr(p_member); if (v) { r_valid = true; return *v; @@ -329,207 +329,67 @@ Variant Variant::get_named(const StringName &p_member, bool &r_valid) const { #endif -#define INDEXED_SETGET_STRUCT_TYPED(m_base_type, m_elem_type) \ - struct VariantIndexedSetGet_##m_base_type { \ - static void get(const Variant *base, int64_t index, Variant *value, bool *oob) { \ - int64_t size = VariantGetInternalPtr::get_ptr(base)->size(); \ - if (index < 0) { \ - index += size; \ - } \ - if (index < 0 || index >= size) { \ - *oob = true; \ - return; \ - } \ - VariantTypeAdjust::adjust(value); \ - *VariantGetInternalPtr::get_ptr(value) = (*VariantGetInternalPtr::get_ptr(base))[index]; \ - *oob = false; \ - } \ - static void ptr_get(const void *base, int64_t index, void *member) { \ - /* avoid ptrconvert for performance*/ \ - const m_base_type &v = *reinterpret_cast(base); \ - if (index < 0) \ - index += v.size(); \ - OOB_TEST(index, v.size()); \ - PtrToArg::encode(v[index], member); \ - } \ - static void set(Variant *base, int64_t index, const Variant *value, bool *valid, bool *oob) { \ - if (value->get_type() != GetTypeInfo::VARIANT_TYPE) { \ - *oob = false; \ - *valid = false; \ - return; \ - } \ - int64_t size = VariantGetInternalPtr::get_ptr(base)->size(); \ - if (index < 0) { \ - index += size; \ - } \ - if (index < 0 || index >= size) { \ - *oob = true; \ - *valid = false; \ - return; \ - } \ - (*VariantGetInternalPtr::get_ptr(base)).write[index] = *VariantGetInternalPtr::get_ptr(value); \ - *oob = false; \ - *valid = true; \ - } \ - static void validated_set(Variant *base, int64_t index, const Variant *value, bool *oob) { \ - int64_t size = VariantGetInternalPtr::get_ptr(base)->size(); \ - if (index < 0) { \ - index += size; \ - } \ - if (index < 0 || index >= size) { \ - *oob = true; \ - return; \ - } \ - (*VariantGetInternalPtr::get_ptr(base)).write[index] = *VariantGetInternalPtr::get_ptr(value); \ - *oob = false; \ - } \ - static void ptr_set(void *base, int64_t index, const void *member) { \ - /* avoid ptrconvert for performance*/ \ - m_base_type &v = *reinterpret_cast(base); \ - if (index < 0) \ - index += v.size(); \ - OOB_TEST(index, v.size()); \ - v.write[index] = PtrToArg::convert(member); \ - } \ - static Variant::Type get_index_type() { \ - return GetTypeInfo::VARIANT_TYPE; \ - } \ - static uint32_t get_index_usage() { \ - return GetTypeInfo::get_class_info().usage; \ - } \ - static uint64_t get_indexed_size(const Variant *base) { \ - return VariantGetInternalPtr::get_ptr(base)->size(); \ - } \ - }; - -#define INDEXED_SETGET_STRUCT_TYPED_NUMERIC(m_base_type, m_elem_type, m_assign_type) \ - struct VariantIndexedSetGet_##m_base_type { \ - static void get(const Variant *base, int64_t index, Variant *value, bool *oob) { \ - int64_t size = VariantGetInternalPtr::get_ptr(base)->size(); \ - if (index < 0) { \ - index += size; \ - } \ - if (index < 0 || index >= size) { \ - *oob = true; \ - return; \ - } \ - VariantTypeAdjust::adjust(value); \ - *VariantGetInternalPtr::get_ptr(value) = (*VariantGetInternalPtr::get_ptr(base))[index]; \ - *oob = false; \ - } \ - static void ptr_get(const void *base, int64_t index, void *member) { \ - /* avoid ptrconvert for performance*/ \ - const m_base_type &v = *reinterpret_cast(base); \ - if (index < 0) \ - index += v.size(); \ - OOB_TEST(index, v.size()); \ - PtrToArg::encode(v[index], member); \ - } \ - static void set(Variant *base, int64_t index, const Variant *value, bool *valid, bool *oob) { \ - int64_t size = VariantGetInternalPtr::get_ptr(base)->size(); \ - if (index < 0) { \ - index += size; \ - } \ - if (index < 0 || index >= size) { \ - *oob = true; \ - *valid = false; \ - return; \ - } \ - m_assign_type num; \ - if (value->get_type() == Variant::INT) { \ - num = (m_assign_type) * VariantGetInternalPtr::get_ptr(value); \ - } else if (value->get_type() == Variant::FLOAT) { \ - num = (m_assign_type) * VariantGetInternalPtr::get_ptr(value); \ - } else { \ - *oob = false; \ - *valid = false; \ - return; \ - } \ - (*VariantGetInternalPtr::get_ptr(base)).write[index] = num; \ - *oob = false; \ - *valid = true; \ - } \ - static void validated_set(Variant *base, int64_t index, const Variant *value, bool *oob) { \ - int64_t size = VariantGetInternalPtr::get_ptr(base)->size(); \ - if (index < 0) { \ - index += size; \ - } \ - if (index < 0 || index >= size) { \ - *oob = true; \ - return; \ - } \ - (*VariantGetInternalPtr::get_ptr(base)).write[index] = *VariantGetInternalPtr::get_ptr(value); \ - *oob = false; \ - } \ - static void ptr_set(void *base, int64_t index, const void *member) { \ - /* avoid ptrconvert for performance*/ \ - m_base_type &v = *reinterpret_cast(base); \ - if (index < 0) \ - index += v.size(); \ - OOB_TEST(index, v.size()); \ - v.write[index] = PtrToArg::convert(member); \ - } \ - static Variant::Type get_index_type() { \ - return GetTypeInfo::VARIANT_TYPE; \ - } \ - static uint32_t get_index_usage() { \ - return GetTypeInfo::get_class_info().usage; \ - } \ - static uint64_t get_indexed_size(const Variant *base) { \ - return VariantGetInternalPtr::get_ptr(base)->size(); \ - } \ - }; - -#define INDEXED_SETGET_STRUCT_BUILTIN_NUMERIC(m_base_type, m_elem_type, m_assign_type, m_max) \ +#define INDEXED_SETGET_STRUCT_TYPED(m_base_type, m_elem_type) \ struct VariantIndexedSetGet_##m_base_type { \ static void get(const Variant *base, int64_t index, Variant *value, bool *oob) { \ - if (index < 0 || index >= m_max) { \ + int64_t size = VariantInternalAccessor::get(base).size(); \ + if (index < 0) { \ + index += size; \ + } \ + if (index < 0 || index >= size) { \ *oob = true; \ return; \ } \ VariantTypeAdjust::adjust(value); \ - *VariantGetInternalPtr::get_ptr(value) = (*VariantGetInternalPtr::get_ptr(base))[index]; \ + VariantInternalAccessor::get(value) = (VariantInternalAccessor::get(base))[index]; \ *oob = false; \ } \ static void ptr_get(const void *base, int64_t index, void *member) { \ /* avoid ptrconvert for performance*/ \ const m_base_type &v = *reinterpret_cast(base); \ - OOB_TEST(index, m_max); \ + if (index < 0) \ + index += v.size(); \ + OOB_TEST(index, v.size()); \ PtrToArg::encode(v[index], member); \ } \ static void set(Variant *base, int64_t index, const Variant *value, bool *valid, bool *oob) { \ - if (index < 0 || index >= m_max) { \ - *oob = true; \ - *valid = false; \ - return; \ - } \ - m_assign_type num; \ - if (value->get_type() == Variant::INT) { \ - num = (m_assign_type) * VariantGetInternalPtr::get_ptr(value); \ - } else if (value->get_type() == Variant::FLOAT) { \ - num = (m_assign_type) * VariantGetInternalPtr::get_ptr(value); \ - } else { \ + if (value->get_type() != GetTypeInfo::VARIANT_TYPE) { \ *oob = false; \ *valid = false; \ return; \ } \ - (*VariantGetInternalPtr::get_ptr(base))[index] = num; \ + int64_t size = VariantInternalAccessor::get(base).size(); \ + if (index < 0) { \ + index += size; \ + } \ + if (index < 0 || index >= size) { \ + *oob = true; \ + *valid = false; \ + return; \ + } \ + (VariantInternalAccessor::get(base)).write[index] = VariantInternalAccessor::get(value); \ *oob = false; \ *valid = true; \ } \ static void validated_set(Variant *base, int64_t index, const Variant *value, bool *oob) { \ - if (index < 0 || index >= m_max) { \ + int64_t size = VariantInternalAccessor::get(base).size(); \ + if (index < 0) { \ + index += size; \ + } \ + if (index < 0 || index >= size) { \ *oob = true; \ return; \ } \ - (*VariantGetInternalPtr::get_ptr(base))[index] = *VariantGetInternalPtr::get_ptr(value); \ + (VariantInternalAccessor::get(base)).write[index] = VariantInternalAccessor::get(value); \ *oob = false; \ } \ static void ptr_set(void *base, int64_t index, const void *member) { \ /* avoid ptrconvert for performance*/ \ m_base_type &v = *reinterpret_cast(base); \ - OOB_TEST(index, m_max); \ - v[index] = PtrToArg::convert(member); \ + if (index < 0) \ + index += v.size(); \ + OOB_TEST(index, v.size()); \ + v.write[index] = PtrToArg::convert(member); \ } \ static Variant::Type get_index_type() { \ return GetTypeInfo::VARIANT_TYPE; \ @@ -538,125 +398,265 @@ Variant Variant::get_named(const StringName &p_member, bool &r_valid) const { return GetTypeInfo::get_class_info().usage; \ } \ static uint64_t get_indexed_size(const Variant *base) { \ - return m_max; \ + return VariantInternalAccessor::get(base).size(); \ } \ }; -#define INDEXED_SETGET_STRUCT_BUILTIN_ACCESSOR(m_base_type, m_elem_type, m_accessor, m_max) \ - struct VariantIndexedSetGet_##m_base_type { \ - static void get(const Variant *base, int64_t index, Variant *value, bool *oob) { \ - if (index < 0 || index >= m_max) { \ - *oob = true; \ - return; \ - } \ - VariantTypeAdjust::adjust(value); \ - *VariantGetInternalPtr::get_ptr(value) = (*VariantGetInternalPtr::get_ptr(base))m_accessor[index]; \ - *oob = false; \ - } \ - static void ptr_get(const void *base, int64_t index, void *member) { \ - /* avoid ptrconvert for performance*/ \ - const m_base_type &v = *reinterpret_cast(base); \ - OOB_TEST(index, m_max); \ - PtrToArg::encode(v m_accessor[index], member); \ - } \ - static void set(Variant *base, int64_t index, const Variant *value, bool *valid, bool *oob) { \ - if (value->get_type() != GetTypeInfo::VARIANT_TYPE) { \ - *oob = false; \ - *valid = false; \ - } \ - if (index < 0 || index >= m_max) { \ - *oob = true; \ - *valid = false; \ - return; \ - } \ - (*VariantGetInternalPtr::get_ptr(base)) m_accessor[index] = *VariantGetInternalPtr::get_ptr(value); \ - *oob = false; \ - *valid = true; \ - } \ - static void validated_set(Variant *base, int64_t index, const Variant *value, bool *oob) { \ - if (index < 0 || index >= m_max) { \ - *oob = true; \ - return; \ - } \ - (*VariantGetInternalPtr::get_ptr(base)) m_accessor[index] = *VariantGetInternalPtr::get_ptr(value); \ - *oob = false; \ - } \ - static void ptr_set(void *base, int64_t index, const void *member) { \ - /* avoid ptrconvert for performance*/ \ - m_base_type &v = *reinterpret_cast(base); \ - OOB_TEST(index, m_max); \ - v m_accessor[index] = PtrToArg::convert(member); \ - } \ - static Variant::Type get_index_type() { \ - return GetTypeInfo::VARIANT_TYPE; \ - } \ - static uint32_t get_index_usage() { \ - return GetTypeInfo::get_class_info().usage; \ - } \ - static uint64_t get_indexed_size(const Variant *base) { \ - return m_max; \ - } \ +#define INDEXED_SETGET_STRUCT_TYPED_NUMERIC(m_base_type, m_elem_type, m_assign_type) \ + struct VariantIndexedSetGet_##m_base_type { \ + static void get(const Variant *base, int64_t index, Variant *value, bool *oob) { \ + int64_t size = VariantInternalAccessor::get(base).size(); \ + if (index < 0) { \ + index += size; \ + } \ + if (index < 0 || index >= size) { \ + *oob = true; \ + return; \ + } \ + VariantTypeAdjust::adjust(value); \ + VariantInternalAccessor::get(value) = (VariantInternalAccessor::get(base))[index]; \ + *oob = false; \ + } \ + static void ptr_get(const void *base, int64_t index, void *member) { \ + /* avoid ptrconvert for performance*/ \ + const m_base_type &v = *reinterpret_cast(base); \ + if (index < 0) \ + index += v.size(); \ + OOB_TEST(index, v.size()); \ + PtrToArg::encode(v[index], member); \ + } \ + static void set(Variant *base, int64_t index, const Variant *value, bool *valid, bool *oob) { \ + int64_t size = VariantInternalAccessor::get(base).size(); \ + if (index < 0) { \ + index += size; \ + } \ + if (index < 0 || index >= size) { \ + *oob = true; \ + *valid = false; \ + return; \ + } \ + m_assign_type num; \ + if (value->get_type() == Variant::INT) { \ + num = (m_assign_type) * &VariantInternalAccessor::get(value); \ + } else if (value->get_type() == Variant::FLOAT) { \ + num = (m_assign_type) * &VariantInternalAccessor::get(value); \ + } else { \ + *oob = false; \ + *valid = false; \ + return; \ + } \ + (VariantInternalAccessor::get(base)).write[index] = num; \ + *oob = false; \ + *valid = true; \ + } \ + static void validated_set(Variant *base, int64_t index, const Variant *value, bool *oob) { \ + int64_t size = VariantInternalAccessor::get(base).size(); \ + if (index < 0) { \ + index += size; \ + } \ + if (index < 0 || index >= size) { \ + *oob = true; \ + return; \ + } \ + (VariantInternalAccessor::get(base)).write[index] = VariantInternalAccessor::get(value); \ + *oob = false; \ + } \ + static void ptr_set(void *base, int64_t index, const void *member) { \ + /* avoid ptrconvert for performance*/ \ + m_base_type &v = *reinterpret_cast(base); \ + if (index < 0) \ + index += v.size(); \ + OOB_TEST(index, v.size()); \ + v.write[index] = PtrToArg::convert(member); \ + } \ + static Variant::Type get_index_type() { \ + return GetTypeInfo::VARIANT_TYPE; \ + } \ + static uint32_t get_index_usage() { \ + return GetTypeInfo::get_class_info().usage; \ + } \ + static uint64_t get_indexed_size(const Variant *base) { \ + return VariantInternalAccessor::get(base).size(); \ + } \ }; -#define INDEXED_SETGET_STRUCT_BUILTIN_FUNC(m_base_type, m_elem_type, m_set, m_get, m_max) \ - struct VariantIndexedSetGet_##m_base_type { \ - static void get(const Variant *base, int64_t index, Variant *value, bool *oob) { \ - if (index < 0 || index >= m_max) { \ - *oob = true; \ - return; \ - } \ - VariantTypeAdjust::adjust(value); \ - *VariantGetInternalPtr::get_ptr(value) = VariantGetInternalPtr::get_ptr(base)->m_get(index); \ - *oob = false; \ - } \ - static void ptr_get(const void *base, int64_t index, void *member) { \ - /* avoid ptrconvert for performance*/ \ - const m_base_type &v = *reinterpret_cast(base); \ - OOB_TEST(index, m_max); \ - PtrToArg::encode(v.m_get(index), member); \ - } \ - static void set(Variant *base, int64_t index, const Variant *value, bool *valid, bool *oob) { \ - if (value->get_type() != GetTypeInfo::VARIANT_TYPE) { \ - *oob = false; \ - *valid = false; \ - } \ - if (index < 0 || index >= m_max) { \ - *oob = true; \ - *valid = false; \ - return; \ - } \ - VariantGetInternalPtr::get_ptr(base)->m_set(index, *VariantGetInternalPtr::get_ptr(value)); \ - *oob = false; \ - *valid = true; \ - } \ - static void validated_set(Variant *base, int64_t index, const Variant *value, bool *oob) { \ - if (index < 0 || index >= m_max) { \ - *oob = true; \ - return; \ - } \ - VariantGetInternalPtr::get_ptr(base)->m_set(index, *VariantGetInternalPtr::get_ptr(value)); \ - *oob = false; \ - } \ - static void ptr_set(void *base, int64_t index, const void *member) { \ - /* avoid ptrconvert for performance*/ \ - m_base_type &v = *reinterpret_cast(base); \ - OOB_TEST(index, m_max); \ - v.m_set(index, PtrToArg::convert(member)); \ - } \ - static Variant::Type get_index_type() { \ - return GetTypeInfo::VARIANT_TYPE; \ - } \ - static uint32_t get_index_usage() { \ - return GetTypeInfo::get_class_info().usage; \ - } \ - static uint64_t get_indexed_size(const Variant *base) { \ - return m_max; \ - } \ +#define INDEXED_SETGET_STRUCT_BUILTIN_NUMERIC(m_base_type, m_elem_type, m_assign_type, m_max) \ + struct VariantIndexedSetGet_##m_base_type { \ + static void get(const Variant *base, int64_t index, Variant *value, bool *oob) { \ + if (index < 0 || index >= m_max) { \ + *oob = true; \ + return; \ + } \ + VariantTypeAdjust::adjust(value); \ + VariantInternalAccessor::get(value) = (VariantInternalAccessor::get(base))[index]; \ + *oob = false; \ + } \ + static void ptr_get(const void *base, int64_t index, void *member) { \ + /* avoid ptrconvert for performance*/ \ + const m_base_type &v = *reinterpret_cast(base); \ + OOB_TEST(index, m_max); \ + PtrToArg::encode(v[index], member); \ + } \ + static void set(Variant *base, int64_t index, const Variant *value, bool *valid, bool *oob) { \ + if (index < 0 || index >= m_max) { \ + *oob = true; \ + *valid = false; \ + return; \ + } \ + m_assign_type num; \ + if (value->get_type() == Variant::INT) { \ + num = (m_assign_type) * &VariantInternalAccessor::get(value); \ + } else if (value->get_type() == Variant::FLOAT) { \ + num = (m_assign_type) * &VariantInternalAccessor::get(value); \ + } else { \ + *oob = false; \ + *valid = false; \ + return; \ + } \ + (VariantInternalAccessor::get(base))[index] = num; \ + *oob = false; \ + *valid = true; \ + } \ + static void validated_set(Variant *base, int64_t index, const Variant *value, bool *oob) { \ + if (index < 0 || index >= m_max) { \ + *oob = true; \ + return; \ + } \ + (VariantInternalAccessor::get(base))[index] = VariantInternalAccessor::get(value); \ + *oob = false; \ + } \ + static void ptr_set(void *base, int64_t index, const void *member) { \ + /* avoid ptrconvert for performance*/ \ + m_base_type &v = *reinterpret_cast(base); \ + OOB_TEST(index, m_max); \ + v[index] = PtrToArg::convert(member); \ + } \ + static Variant::Type get_index_type() { \ + return GetTypeInfo::VARIANT_TYPE; \ + } \ + static uint32_t get_index_usage() { \ + return GetTypeInfo::get_class_info().usage; \ + } \ + static uint64_t get_indexed_size(const Variant *base) { \ + return m_max; \ + } \ + }; + +#define INDEXED_SETGET_STRUCT_BUILTIN_ACCESSOR(m_base_type, m_elem_type, m_accessor, m_max) \ + struct VariantIndexedSetGet_##m_base_type { \ + static void get(const Variant *base, int64_t index, Variant *value, bool *oob) { \ + if (index < 0 || index >= m_max) { \ + *oob = true; \ + return; \ + } \ + VariantTypeAdjust::adjust(value); \ + VariantInternalAccessor::get(value) = (VariantInternalAccessor::get(base))m_accessor[index]; \ + *oob = false; \ + } \ + static void ptr_get(const void *base, int64_t index, void *member) { \ + /* avoid ptrconvert for performance*/ \ + const m_base_type &v = *reinterpret_cast(base); \ + OOB_TEST(index, m_max); \ + PtrToArg::encode(v m_accessor[index], member); \ + } \ + static void set(Variant *base, int64_t index, const Variant *value, bool *valid, bool *oob) { \ + if (value->get_type() != GetTypeInfo::VARIANT_TYPE) { \ + *oob = false; \ + *valid = false; \ + } \ + if (index < 0 || index >= m_max) { \ + *oob = true; \ + *valid = false; \ + return; \ + } \ + (VariantInternalAccessor::get(base)) m_accessor[index] = VariantInternalAccessor::get(value); \ + *oob = false; \ + *valid = true; \ + } \ + static void validated_set(Variant *base, int64_t index, const Variant *value, bool *oob) { \ + if (index < 0 || index >= m_max) { \ + *oob = true; \ + return; \ + } \ + (VariantInternalAccessor::get(base)) m_accessor[index] = VariantInternalAccessor::get(value); \ + *oob = false; \ + } \ + static void ptr_set(void *base, int64_t index, const void *member) { \ + /* avoid ptrconvert for performance*/ \ + m_base_type &v = *reinterpret_cast(base); \ + OOB_TEST(index, m_max); \ + v m_accessor[index] = PtrToArg::convert(member); \ + } \ + static Variant::Type get_index_type() { \ + return GetTypeInfo::VARIANT_TYPE; \ + } \ + static uint32_t get_index_usage() { \ + return GetTypeInfo::get_class_info().usage; \ + } \ + static uint64_t get_indexed_size(const Variant *base) { \ + return m_max; \ + } \ + }; + +#define INDEXED_SETGET_STRUCT_BUILTIN_FUNC(m_base_type, m_elem_type, m_set, m_get, m_max) \ + struct VariantIndexedSetGet_##m_base_type { \ + static void get(const Variant *base, int64_t index, Variant *value, bool *oob) { \ + if (index < 0 || index >= m_max) { \ + *oob = true; \ + return; \ + } \ + VariantTypeAdjust::adjust(value); \ + VariantInternalAccessor::get(value) = VariantInternalAccessor::get(base).m_get(index); \ + *oob = false; \ + } \ + static void ptr_get(const void *base, int64_t index, void *member) { \ + /* avoid ptrconvert for performance*/ \ + const m_base_type &v = *reinterpret_cast(base); \ + OOB_TEST(index, m_max); \ + PtrToArg::encode(v.m_get(index), member); \ + } \ + static void set(Variant *base, int64_t index, const Variant *value, bool *valid, bool *oob) { \ + if (value->get_type() != GetTypeInfo::VARIANT_TYPE) { \ + *oob = false; \ + *valid = false; \ + } \ + if (index < 0 || index >= m_max) { \ + *oob = true; \ + *valid = false; \ + return; \ + } \ + VariantInternalAccessor::get(base).m_set(index, VariantInternalAccessor::get(value)); \ + *oob = false; \ + *valid = true; \ + } \ + static void validated_set(Variant *base, int64_t index, const Variant *value, bool *oob) { \ + if (index < 0 || index >= m_max) { \ + *oob = true; \ + return; \ + } \ + VariantInternalAccessor::get(base).m_set(index, VariantInternalAccessor::get(value)); \ + *oob = false; \ + } \ + static void ptr_set(void *base, int64_t index, const void *member) { \ + /* avoid ptrconvert for performance*/ \ + m_base_type &v = *reinterpret_cast(base); \ + OOB_TEST(index, m_max); \ + v.m_set(index, PtrToArg::convert(member)); \ + } \ + static Variant::Type get_index_type() { \ + return GetTypeInfo::VARIANT_TYPE; \ + } \ + static uint32_t get_index_usage() { \ + return GetTypeInfo::get_class_info().usage; \ + } \ + static uint64_t get_indexed_size(const Variant *base) { \ + return m_max; \ + } \ }; struct VariantIndexedSetGet_Array { static void get(const Variant *base, int64_t index, Variant *value, bool *oob) { - int64_t size = VariantGetInternalPtr::get_ptr(base)->size(); + int64_t size = VariantInternalAccessor::get(base).size(); if (index < 0) { index += size; } @@ -664,7 +664,7 @@ struct VariantIndexedSetGet_Array { *oob = true; return; } - *value = (*VariantGetInternalPtr::get_ptr(base))[index]; + *value = (VariantInternalAccessor::get(base))[index]; *oob = false; } static void ptr_get(const void *base, int64_t index, void *member) { @@ -677,12 +677,12 @@ struct VariantIndexedSetGet_Array { PtrToArg::encode(v[index], member); } static void set(Variant *base, int64_t index, const Variant *value, bool *valid, bool *oob) { - if (VariantGetInternalPtr::get_ptr(base)->is_read_only()) { + if (VariantInternalAccessor::get(base).is_read_only()) { *valid = false; *oob = true; return; } - int64_t size = VariantGetInternalPtr::get_ptr(base)->size(); + int64_t size = VariantInternalAccessor::get(base).size(); if (index < 0) { index += size; } @@ -691,16 +691,16 @@ struct VariantIndexedSetGet_Array { *valid = false; return; } - VariantGetInternalPtr::get_ptr(base)->set(index, *value); + VariantInternalAccessor::get(base).set(index, *value); *oob = false; *valid = true; } static void validated_set(Variant *base, int64_t index, const Variant *value, bool *oob) { - if (VariantGetInternalPtr::get_ptr(base)->is_read_only()) { + if (VariantInternalAccessor::get(base).is_read_only()) { *oob = true; return; } - int64_t size = VariantGetInternalPtr::get_ptr(base)->size(); + int64_t size = VariantInternalAccessor::get(base).size(); if (index < 0) { index += size; } @@ -708,7 +708,7 @@ struct VariantIndexedSetGet_Array { *oob = true; return; } - VariantGetInternalPtr::get_ptr(base)->set(index, *value); + VariantInternalAccessor::get(base).set(index, *value); *oob = false; } static void ptr_set(void *base, int64_t index, const void *member) { @@ -727,7 +727,7 @@ struct VariantIndexedSetGet_Array { struct VariantIndexedSetGet_Dictionary { static void get(const Variant *base, int64_t index, Variant *value, bool *oob) { - const Variant *ptr = VariantGetInternalPtr::get_ptr(base)->getptr(index); + const Variant *ptr = VariantInternalAccessor::get(base).getptr(index); if (!ptr) { *oob = true; return; @@ -743,12 +743,12 @@ struct VariantIndexedSetGet_Dictionary { PtrToArg::encode(*ptr, member); } static void set(Variant *base, int64_t index, const Variant *value, bool *valid, bool *oob) { - *valid = VariantGetInternalPtr::get_ptr(base)->set(index, *value); - *oob = VariantGetInternalPtr::get_ptr(base)->is_read_only(); + *valid = VariantInternalAccessor::get(base).set(index, *value); + *oob = VariantInternalAccessor::get(base).is_read_only(); } static void validated_set(Variant *base, int64_t index, const Variant *value, bool *oob) { - VariantGetInternalPtr::get_ptr(base)->set(index, *value); - *oob = VariantGetInternalPtr::get_ptr(base)->is_read_only(); + VariantInternalAccessor::get(base).set(index, *value); + *oob = VariantInternalAccessor::get(base).is_read_only(); } static void ptr_set(void *base, int64_t index, const void *member) { Dictionary &v = *reinterpret_cast(base); @@ -756,12 +756,12 @@ struct VariantIndexedSetGet_Dictionary { } static Variant::Type get_index_type() { return Variant::NIL; } static uint32_t get_index_usage() { return PROPERTY_USAGE_DEFAULT; } - static uint64_t get_indexed_size(const Variant *base) { return VariantGetInternalPtr::get_ptr(base)->size(); } + static uint64_t get_indexed_size(const Variant *base) { return VariantInternalAccessor::get(base).size(); } }; struct VariantIndexedSetGet_String { static void get(const Variant *base, int64_t index, Variant *value, bool *oob) { - int64_t length = VariantGetInternalPtr::get_ptr(base)->length(); + int64_t length = VariantInternalAccessor::get(base).length(); if (index < 0) { index += length; } @@ -769,7 +769,7 @@ struct VariantIndexedSetGet_String { *oob = true; return; } - *value = String::chr((*VariantGetInternalPtr::get_ptr(base))[index]); + *value = String::chr((VariantInternalAccessor::get(base))[index]); *oob = false; } static void ptr_get(const void *base, int64_t index, void *member) { @@ -787,7 +787,7 @@ struct VariantIndexedSetGet_String { *valid = false; return; } - int64_t length = VariantGetInternalPtr::get_ptr(base)->length(); + int64_t length = VariantInternalAccessor::get(base).length(); if (index < 0) { index += length; } @@ -796,7 +796,7 @@ struct VariantIndexedSetGet_String { *valid = false; return; } - String *b = VariantGetInternalPtr::get_ptr(base); + String *b = &VariantInternalAccessor::get(base); const String *v = VariantInternal::get_string(value); if (v->length() == 0) { b->remove_at(index); @@ -807,7 +807,7 @@ struct VariantIndexedSetGet_String { *valid = true; } static void validated_set(Variant *base, int64_t index, const Variant *value, bool *oob) { - int64_t length = VariantGetInternalPtr::get_ptr(base)->length(); + int64_t length = VariantInternalAccessor::get(base).length(); if (index < 0) { index += length; } @@ -815,7 +815,7 @@ struct VariantIndexedSetGet_String { *oob = true; return; } - String *b = VariantGetInternalPtr::get_ptr(base); + String *b = &VariantInternalAccessor::get(base); const String *v = VariantInternal::get_string(value); if (v->length() == 0) { b->remove_at(index); @@ -1004,7 +1004,7 @@ uint64_t Variant::get_indexed_size() const { struct VariantKeyedSetGetDictionary { static void get(const Variant *base, const Variant *key, Variant *value, bool *r_valid) { - const Variant *ptr = VariantGetInternalPtr::get_ptr(base)->getptr(*key); + const Variant *ptr = VariantInternalAccessor::get(base).getptr(*key); if (!ptr) { *r_valid = false; return; @@ -1020,7 +1020,7 @@ struct VariantKeyedSetGetDictionary { PtrToArg::encode(*ptr, value); } static void set(Variant *base, const Variant *key, const Variant *value, bool *r_valid) { - *r_valid = VariantGetInternalPtr::get_ptr(base)->set(*key, *value); + *r_valid = VariantInternalAccessor::get(base).set(*key, *value); } static void ptr_set(void *base, const void *key, const void *value) { Dictionary &v = *reinterpret_cast(base); @@ -1029,7 +1029,7 @@ struct VariantKeyedSetGetDictionary { static bool has(const Variant *base, const Variant *key, bool *r_valid) { *r_valid = true; - return VariantGetInternalPtr::get_ptr(base)->has(*key); + return VariantInternalAccessor::get(base).has(*key); } static uint32_t ptr_has(const void *base, const void *key) { /* avoid ptrconvert for performance*/ @@ -1197,13 +1197,13 @@ void Variant::set(const Variant &p_index, const Variant &p_value, bool *r_valid, } else { bool valid = false; if (p_index.get_type() == STRING_NAME) { - set_named(*VariantGetInternalPtr::get_ptr(&p_index), p_value, valid); + set_named(VariantInternalAccessor::get(&p_index), p_value, valid); if (!valid && err_code) { *err_code = VariantSetError::SET_NAMED_ERR; } } else if (p_index.get_type() == INT) { bool obb; - set_indexed(*VariantGetInternalPtr::get_ptr(&p_index), p_value, valid, obb); + set_indexed(VariantInternalAccessor::get(&p_index), p_value, valid, obb); if (obb) { valid = false; if (err_code) { @@ -1211,13 +1211,13 @@ void Variant::set(const Variant &p_index, const Variant &p_value, bool *r_valid, } } } else if (p_index.get_type() == STRING) { // less efficient version of named - set_named(*VariantGetInternalPtr::get_ptr(&p_index), p_value, valid); + set_named(VariantInternalAccessor::get(&p_index), p_value, valid); if (!valid && err_code) { *err_code = VariantSetError::SET_NAMED_ERR; } } else if (p_index.get_type() == FLOAT) { // less efficient version of indexed bool obb; - set_indexed(*VariantGetInternalPtr::get_ptr(&p_index), p_value, valid, obb); + set_indexed(VariantInternalAccessor::get(&p_index), p_value, valid, obb); if (obb) { valid = false; if (err_code) { @@ -1248,13 +1248,13 @@ Variant Variant::get(const Variant &p_index, bool *r_valid, VariantGetError *err } else { bool valid = false; if (p_index.get_type() == STRING_NAME) { - ret = get_named(*VariantGetInternalPtr::get_ptr(&p_index), valid); + ret = get_named(VariantInternalAccessor::get(&p_index), valid); if (!valid && err_code) { *err_code = VariantGetError::GET_NAMED_ERR; } } else if (p_index.get_type() == INT) { bool obb; - ret = get_indexed(*VariantGetInternalPtr::get_ptr(&p_index), valid, obb); + ret = get_indexed(VariantInternalAccessor::get(&p_index), valid, obb); if (obb) { valid = false; if (err_code) { @@ -1262,13 +1262,13 @@ Variant Variant::get(const Variant &p_index, bool *r_valid, VariantGetError *err } } } else if (p_index.get_type() == STRING) { // less efficient version of named - ret = get_named(*VariantGetInternalPtr::get_ptr(&p_index), valid); + ret = get_named(VariantInternalAccessor::get(&p_index), valid); if (!valid && err_code) { *err_code = VariantGetError::GET_NAMED_ERR; } } else if (p_index.get_type() == FLOAT) { // less efficient version of indexed bool obb; - ret = get_indexed(*VariantGetInternalPtr::get_ptr(&p_index), valid, obb); + ret = get_indexed(VariantInternalAccessor::get(&p_index), valid, obb); if (obb) { valid = false; if (err_code) { diff --git a/core/variant/variant_setget.h b/core/variant/variant_setget.h index 67049dae14e..470184b8b6b 100644 --- a/core/variant/variant_setget.h +++ b/core/variant/variant_setget.h @@ -38,244 +38,244 @@ /**** NAMED SETTERS AND GETTERS ****/ -#define SETGET_STRUCT(m_base_type, m_member_type, m_member) \ - struct VariantSetGet_##m_base_type##_##m_member { \ - static void get(const Variant *base, Variant *member) { \ - VariantTypeAdjust::adjust(member); \ - *VariantGetInternalPtr::get_ptr(member) = VariantGetInternalPtr::get_ptr(base)->m_member; \ - } \ - static inline void validated_get(const Variant *base, Variant *member) { \ - *VariantGetInternalPtr::get_ptr(member) = VariantGetInternalPtr::get_ptr(base)->m_member; \ - } \ - static void ptr_get(const void *base, void *member) { \ - PtrToArg::encode(PtrToArg::convert(base).m_member, member); \ - } \ - static void set(Variant *base, const Variant *value, bool &valid) { \ - if (value->get_type() == GetTypeInfo::VARIANT_TYPE) { \ - VariantGetInternalPtr::get_ptr(base)->m_member = *VariantGetInternalPtr::get_ptr(value); \ - valid = true; \ - } else { \ - valid = false; \ - } \ - } \ - static inline void validated_set(Variant *base, const Variant *value) { \ - VariantGetInternalPtr::get_ptr(base)->m_member = *VariantGetInternalPtr::get_ptr(value); \ - } \ - static void ptr_set(void *base, const void *member) { \ - m_base_type b = PtrToArg::convert(base); \ - b.m_member = PtrToArg::convert(member); \ - PtrToArg::encode(b, base); \ - } \ - static Variant::Type get_type() { \ - return GetTypeInfo::VARIANT_TYPE; \ - } \ +#define SETGET_STRUCT(m_base_type, m_member_type, m_member) \ + struct VariantSetGet_##m_base_type##_##m_member { \ + static void get(const Variant *base, Variant *member) { \ + VariantTypeAdjust::adjust(member); \ + VariantInternalAccessor::get(member) = VariantInternalAccessor::get(base).m_member; \ + } \ + static inline void validated_get(const Variant *base, Variant *member) { \ + VariantInternalAccessor::get(member) = VariantInternalAccessor::get(base).m_member; \ + } \ + static void ptr_get(const void *base, void *member) { \ + PtrToArg::encode(PtrToArg::convert(base).m_member, member); \ + } \ + static void set(Variant *base, const Variant *value, bool &valid) { \ + if (value->get_type() == GetTypeInfo::VARIANT_TYPE) { \ + VariantInternalAccessor::get(base).m_member = VariantInternalAccessor::get(value); \ + valid = true; \ + } else { \ + valid = false; \ + } \ + } \ + static inline void validated_set(Variant *base, const Variant *value) { \ + VariantInternalAccessor::get(base).m_member = VariantInternalAccessor::get(value); \ + } \ + static void ptr_set(void *base, const void *member) { \ + m_base_type b = PtrToArg::convert(base); \ + b.m_member = PtrToArg::convert(member); \ + PtrToArg::encode(b, base); \ + } \ + static Variant::Type get_type() { \ + return GetTypeInfo::VARIANT_TYPE; \ + } \ }; -#define SETGET_NUMBER_STRUCT(m_base_type, m_member_type, m_member) \ - struct VariantSetGet_##m_base_type##_##m_member { \ - static void get(const Variant *base, Variant *member) { \ - VariantTypeAdjust::adjust(member); \ - *VariantGetInternalPtr::get_ptr(member) = VariantGetInternalPtr::get_ptr(base)->m_member; \ - } \ - static inline void validated_get(const Variant *base, Variant *member) { \ - *VariantGetInternalPtr::get_ptr(member) = VariantGetInternalPtr::get_ptr(base)->m_member; \ - } \ - static void ptr_get(const void *base, void *member) { \ - PtrToArg::encode(PtrToArg::convert(base).m_member, member); \ - } \ - static void set(Variant *base, const Variant *value, bool &valid) { \ - if (value->get_type() == Variant::FLOAT) { \ - VariantGetInternalPtr::get_ptr(base)->m_member = *VariantGetInternalPtr::get_ptr(value); \ - valid = true; \ - } else if (value->get_type() == Variant::INT) { \ - VariantGetInternalPtr::get_ptr(base)->m_member = *VariantGetInternalPtr::get_ptr(value); \ - valid = true; \ - } else { \ - valid = false; \ - } \ - } \ - static inline void validated_set(Variant *base, const Variant *value) { \ - VariantGetInternalPtr::get_ptr(base)->m_member = *VariantGetInternalPtr::get_ptr(value); \ - } \ - static void ptr_set(void *base, const void *member) { \ - m_base_type b = PtrToArg::convert(base); \ - b.m_member = PtrToArg::convert(member); \ - PtrToArg::encode(b, base); \ - } \ - static Variant::Type get_type() { \ - return GetTypeInfo::VARIANT_TYPE; \ - } \ +#define SETGET_NUMBER_STRUCT(m_base_type, m_member_type, m_member) \ + struct VariantSetGet_##m_base_type##_##m_member { \ + static void get(const Variant *base, Variant *member) { \ + VariantTypeAdjust::adjust(member); \ + VariantInternalAccessor::get(member) = VariantInternalAccessor::get(base).m_member; \ + } \ + static inline void validated_get(const Variant *base, Variant *member) { \ + VariantInternalAccessor::get(member) = VariantInternalAccessor::get(base).m_member; \ + } \ + static void ptr_get(const void *base, void *member) { \ + PtrToArg::encode(PtrToArg::convert(base).m_member, member); \ + } \ + static void set(Variant *base, const Variant *value, bool &valid) { \ + if (value->get_type() == Variant::FLOAT) { \ + VariantInternalAccessor::get(base).m_member = VariantInternalAccessor::get(value); \ + valid = true; \ + } else if (value->get_type() == Variant::INT) { \ + VariantInternalAccessor::get(base).m_member = VariantInternalAccessor::get(value); \ + valid = true; \ + } else { \ + valid = false; \ + } \ + } \ + static inline void validated_set(Variant *base, const Variant *value) { \ + VariantInternalAccessor::get(base).m_member = VariantInternalAccessor::get(value); \ + } \ + static void ptr_set(void *base, const void *member) { \ + m_base_type b = PtrToArg::convert(base); \ + b.m_member = PtrToArg::convert(member); \ + PtrToArg::encode(b, base); \ + } \ + static Variant::Type get_type() { \ + return GetTypeInfo::VARIANT_TYPE; \ + } \ }; -#define SETGET_STRUCT_CUSTOM(m_base_type, m_member_type, m_member, m_custom) \ - struct VariantSetGet_##m_base_type##_##m_member { \ - static void get(const Variant *base, Variant *member) { \ - VariantTypeAdjust::adjust(member); \ - *VariantGetInternalPtr::get_ptr(member) = VariantGetInternalPtr::get_ptr(base)->m_custom; \ - } \ - static inline void validated_get(const Variant *base, Variant *member) { \ - *VariantGetInternalPtr::get_ptr(member) = VariantGetInternalPtr::get_ptr(base)->m_custom; \ - } \ - static void ptr_get(const void *base, void *member) { \ - PtrToArg::encode(PtrToArg::convert(base).m_custom, member); \ - } \ - static void set(Variant *base, const Variant *value, bool &valid) { \ - if (value->get_type() == GetTypeInfo::VARIANT_TYPE) { \ - VariantGetInternalPtr::get_ptr(base)->m_custom = *VariantGetInternalPtr::get_ptr(value); \ - valid = true; \ - } else { \ - valid = false; \ - } \ - } \ - static inline void validated_set(Variant *base, const Variant *value) { \ - VariantGetInternalPtr::get_ptr(base)->m_custom = *VariantGetInternalPtr::get_ptr(value); \ - } \ - static void ptr_set(void *base, const void *member) { \ - m_base_type b = PtrToArg::convert(base); \ - b.m_custom = PtrToArg::convert(member); \ - PtrToArg::encode(b, base); \ - } \ - static Variant::Type get_type() { \ - return GetTypeInfo::VARIANT_TYPE; \ - } \ +#define SETGET_STRUCT_CUSTOM(m_base_type, m_member_type, m_member, m_custom) \ + struct VariantSetGet_##m_base_type##_##m_member { \ + static void get(const Variant *base, Variant *member) { \ + VariantTypeAdjust::adjust(member); \ + VariantInternalAccessor::get(member) = VariantInternalAccessor::get(base).m_custom; \ + } \ + static inline void validated_get(const Variant *base, Variant *member) { \ + VariantInternalAccessor::get(member) = VariantInternalAccessor::get(base).m_custom; \ + } \ + static void ptr_get(const void *base, void *member) { \ + PtrToArg::encode(PtrToArg::convert(base).m_custom, member); \ + } \ + static void set(Variant *base, const Variant *value, bool &valid) { \ + if (value->get_type() == GetTypeInfo::VARIANT_TYPE) { \ + VariantInternalAccessor::get(base).m_custom = VariantInternalAccessor::get(value); \ + valid = true; \ + } else { \ + valid = false; \ + } \ + } \ + static inline void validated_set(Variant *base, const Variant *value) { \ + VariantInternalAccessor::get(base).m_custom = VariantInternalAccessor::get(value); \ + } \ + static void ptr_set(void *base, const void *member) { \ + m_base_type b = PtrToArg::convert(base); \ + b.m_custom = PtrToArg::convert(member); \ + PtrToArg::encode(b, base); \ + } \ + static Variant::Type get_type() { \ + return GetTypeInfo::VARIANT_TYPE; \ + } \ }; -#define SETGET_NUMBER_STRUCT_CUSTOM(m_base_type, m_member_type, m_member, m_custom) \ - struct VariantSetGet_##m_base_type##_##m_member { \ - static void get(const Variant *base, Variant *member) { \ - VariantTypeAdjust::adjust(member); \ - *VariantGetInternalPtr::get_ptr(member) = VariantGetInternalPtr::get_ptr(base)->m_custom; \ - } \ - static inline void validated_get(const Variant *base, Variant *member) { \ - *VariantGetInternalPtr::get_ptr(member) = VariantGetInternalPtr::get_ptr(base)->m_custom; \ - } \ - static void ptr_get(const void *base, void *member) { \ - PtrToArg::encode(PtrToArg::convert(base).m_custom, member); \ - } \ - static void set(Variant *base, const Variant *value, bool &valid) { \ - if (value->get_type() == Variant::FLOAT) { \ - VariantGetInternalPtr::get_ptr(base)->m_custom = *VariantGetInternalPtr::get_ptr(value); \ - valid = true; \ - } else if (value->get_type() == Variant::INT) { \ - VariantGetInternalPtr::get_ptr(base)->m_custom = *VariantGetInternalPtr::get_ptr(value); \ - valid = true; \ - } else { \ - valid = false; \ - } \ - } \ - static inline void validated_set(Variant *base, const Variant *value) { \ - VariantGetInternalPtr::get_ptr(base)->m_custom = *VariantGetInternalPtr::get_ptr(value); \ - } \ - static void ptr_set(void *base, const void *member) { \ - m_base_type b = PtrToArg::convert(base); \ - b.m_custom = PtrToArg::convert(member); \ - PtrToArg::encode(b, base); \ - } \ - static Variant::Type get_type() { \ - return GetTypeInfo::VARIANT_TYPE; \ - } \ +#define SETGET_NUMBER_STRUCT_CUSTOM(m_base_type, m_member_type, m_member, m_custom) \ + struct VariantSetGet_##m_base_type##_##m_member { \ + static void get(const Variant *base, Variant *member) { \ + VariantTypeAdjust::adjust(member); \ + VariantInternalAccessor::get(member) = VariantInternalAccessor::get(base).m_custom; \ + } \ + static inline void validated_get(const Variant *base, Variant *member) { \ + VariantInternalAccessor::get(member) = VariantInternalAccessor::get(base).m_custom; \ + } \ + static void ptr_get(const void *base, void *member) { \ + PtrToArg::encode(PtrToArg::convert(base).m_custom, member); \ + } \ + static void set(Variant *base, const Variant *value, bool &valid) { \ + if (value->get_type() == Variant::FLOAT) { \ + VariantInternalAccessor::get(base).m_custom = VariantInternalAccessor::get(value); \ + valid = true; \ + } else if (value->get_type() == Variant::INT) { \ + VariantInternalAccessor::get(base).m_custom = VariantInternalAccessor::get(value); \ + valid = true; \ + } else { \ + valid = false; \ + } \ + } \ + static inline void validated_set(Variant *base, const Variant *value) { \ + VariantInternalAccessor::get(base).m_custom = VariantInternalAccessor::get(value); \ + } \ + static void ptr_set(void *base, const void *member) { \ + m_base_type b = PtrToArg::convert(base); \ + b.m_custom = PtrToArg::convert(member); \ + PtrToArg::encode(b, base); \ + } \ + static Variant::Type get_type() { \ + return GetTypeInfo::VARIANT_TYPE; \ + } \ }; -#define SETGET_STRUCT_FUNC(m_base_type, m_member_type, m_member, m_setter, m_getter) \ - struct VariantSetGet_##m_base_type##_##m_member { \ - static void get(const Variant *base, Variant *member) { \ - VariantTypeAdjust::adjust(member); \ - *VariantGetInternalPtr::get_ptr(member) = VariantGetInternalPtr::get_ptr(base)->m_getter(); \ - } \ - static inline void validated_get(const Variant *base, Variant *member) { \ - *VariantGetInternalPtr::get_ptr(member) = VariantGetInternalPtr::get_ptr(base)->m_getter(); \ - } \ - static void ptr_get(const void *base, void *member) { \ - PtrToArg::encode(PtrToArg::convert(base).m_getter(), member); \ - } \ - static void set(Variant *base, const Variant *value, bool &valid) { \ - if (value->get_type() == GetTypeInfo::VARIANT_TYPE) { \ - VariantGetInternalPtr::get_ptr(base)->m_setter(*VariantGetInternalPtr::get_ptr(value)); \ - valid = true; \ - } else { \ - valid = false; \ - } \ - } \ - static inline void validated_set(Variant *base, const Variant *value) { \ - VariantGetInternalPtr::get_ptr(base)->m_setter(*VariantGetInternalPtr::get_ptr(value)); \ - } \ - static void ptr_set(void *base, const void *member) { \ - m_base_type b = PtrToArg::convert(base); \ - b.m_setter(PtrToArg::convert(member)); \ - PtrToArg::encode(b, base); \ - } \ - static Variant::Type get_type() { \ - return GetTypeInfo::VARIANT_TYPE; \ - } \ +#define SETGET_STRUCT_FUNC(m_base_type, m_member_type, m_member, m_setter, m_getter) \ + struct VariantSetGet_##m_base_type##_##m_member { \ + static void get(const Variant *base, Variant *member) { \ + VariantTypeAdjust::adjust(member); \ + VariantInternalAccessor::get(member) = VariantInternalAccessor::get(base).m_getter(); \ + } \ + static inline void validated_get(const Variant *base, Variant *member) { \ + VariantInternalAccessor::get(member) = VariantInternalAccessor::get(base).m_getter(); \ + } \ + static void ptr_get(const void *base, void *member) { \ + PtrToArg::encode(PtrToArg::convert(base).m_getter(), member); \ + } \ + static void set(Variant *base, const Variant *value, bool &valid) { \ + if (value->get_type() == GetTypeInfo::VARIANT_TYPE) { \ + VariantInternalAccessor::get(base).m_setter(VariantInternalAccessor::get(value)); \ + valid = true; \ + } else { \ + valid = false; \ + } \ + } \ + static inline void validated_set(Variant *base, const Variant *value) { \ + VariantInternalAccessor::get(base).m_setter(VariantInternalAccessor::get(value)); \ + } \ + static void ptr_set(void *base, const void *member) { \ + m_base_type b = PtrToArg::convert(base); \ + b.m_setter(PtrToArg::convert(member)); \ + PtrToArg::encode(b, base); \ + } \ + static Variant::Type get_type() { \ + return GetTypeInfo::VARIANT_TYPE; \ + } \ }; -#define SETGET_NUMBER_STRUCT_FUNC(m_base_type, m_member_type, m_member, m_setter, m_getter) \ - struct VariantSetGet_##m_base_type##_##m_member { \ - static void get(const Variant *base, Variant *member) { \ - VariantTypeAdjust::adjust(member); \ - *VariantGetInternalPtr::get_ptr(member) = VariantGetInternalPtr::get_ptr(base)->m_getter(); \ - } \ - static inline void validated_get(const Variant *base, Variant *member) { \ - *VariantGetInternalPtr::get_ptr(member) = VariantGetInternalPtr::get_ptr(base)->m_getter(); \ - } \ - static void ptr_get(const void *base, void *member) { \ - PtrToArg::encode(PtrToArg::convert(base).m_getter(), member); \ - } \ - static void set(Variant *base, const Variant *value, bool &valid) { \ - if (value->get_type() == Variant::FLOAT) { \ - VariantGetInternalPtr::get_ptr(base)->m_setter(*VariantGetInternalPtr::get_ptr(value)); \ - valid = true; \ - } else if (value->get_type() == Variant::INT) { \ - VariantGetInternalPtr::get_ptr(base)->m_setter(*VariantGetInternalPtr::get_ptr(value)); \ - valid = true; \ - } else { \ - valid = false; \ - } \ - } \ - static inline void validated_set(Variant *base, const Variant *value) { \ - VariantGetInternalPtr::get_ptr(base)->m_setter(*VariantGetInternalPtr::get_ptr(value)); \ - } \ - static void ptr_set(void *base, const void *member) { \ - m_base_type b = PtrToArg::convert(base); \ - b.m_setter(PtrToArg::convert(member)); \ - PtrToArg::encode(b, base); \ - } \ - static Variant::Type get_type() { \ - return GetTypeInfo::VARIANT_TYPE; \ - } \ +#define SETGET_NUMBER_STRUCT_FUNC(m_base_type, m_member_type, m_member, m_setter, m_getter) \ + struct VariantSetGet_##m_base_type##_##m_member { \ + static void get(const Variant *base, Variant *member) { \ + VariantTypeAdjust::adjust(member); \ + VariantInternalAccessor::get(member) = VariantInternalAccessor::get(base).m_getter(); \ + } \ + static inline void validated_get(const Variant *base, Variant *member) { \ + VariantInternalAccessor::get(member) = VariantInternalAccessor::get(base).m_getter(); \ + } \ + static void ptr_get(const void *base, void *member) { \ + PtrToArg::encode(PtrToArg::convert(base).m_getter(), member); \ + } \ + static void set(Variant *base, const Variant *value, bool &valid) { \ + if (value->get_type() == Variant::FLOAT) { \ + VariantInternalAccessor::get(base).m_setter(VariantInternalAccessor::get(value)); \ + valid = true; \ + } else if (value->get_type() == Variant::INT) { \ + VariantInternalAccessor::get(base).m_setter(VariantInternalAccessor::get(value)); \ + valid = true; \ + } else { \ + valid = false; \ + } \ + } \ + static inline void validated_set(Variant *base, const Variant *value) { \ + VariantInternalAccessor::get(base).m_setter(VariantInternalAccessor::get(value)); \ + } \ + static void ptr_set(void *base, const void *member) { \ + m_base_type b = PtrToArg::convert(base); \ + b.m_setter(PtrToArg::convert(member)); \ + PtrToArg::encode(b, base); \ + } \ + static Variant::Type get_type() { \ + return GetTypeInfo::VARIANT_TYPE; \ + } \ }; -#define SETGET_STRUCT_FUNC_INDEX(m_base_type, m_member_type, m_member, m_setter, m_getter, m_index) \ - struct VariantSetGet_##m_base_type##_##m_member { \ - static void get(const Variant *base, Variant *member) { \ - VariantTypeAdjust::adjust(member); \ - *VariantGetInternalPtr::get_ptr(member) = VariantGetInternalPtr::get_ptr(base)->m_getter(m_index); \ - } \ - static inline void validated_get(const Variant *base, Variant *member) { \ - *VariantGetInternalPtr::get_ptr(member) = VariantGetInternalPtr::get_ptr(base)->m_getter(m_index); \ - } \ - static void ptr_get(const void *base, void *member) { \ - PtrToArg::encode(PtrToArg::convert(base).m_getter(m_index), member); \ - } \ - static void set(Variant *base, const Variant *value, bool &valid) { \ - if (value->get_type() == GetTypeInfo::VARIANT_TYPE) { \ - VariantGetInternalPtr::get_ptr(base)->m_setter(m_index, *VariantGetInternalPtr::get_ptr(value)); \ - valid = true; \ - } else { \ - valid = false; \ - } \ - } \ - static inline void validated_set(Variant *base, const Variant *value) { \ - VariantGetInternalPtr::get_ptr(base)->m_setter(m_index, *VariantGetInternalPtr::get_ptr(value)); \ - } \ - static void ptr_set(void *base, const void *member) { \ - m_base_type b = PtrToArg::convert(base); \ - b.m_setter(m_index, PtrToArg::convert(member)); \ - PtrToArg::encode(b, base); \ - } \ - static Variant::Type get_type() { \ - return GetTypeInfo::VARIANT_TYPE; \ - } \ +#define SETGET_STRUCT_FUNC_INDEX(m_base_type, m_member_type, m_member, m_setter, m_getter, m_index) \ + struct VariantSetGet_##m_base_type##_##m_member { \ + static void get(const Variant *base, Variant *member) { \ + VariantTypeAdjust::adjust(member); \ + VariantInternalAccessor::get(member) = VariantInternalAccessor::get(base).m_getter(m_index); \ + } \ + static inline void validated_get(const Variant *base, Variant *member) { \ + VariantInternalAccessor::get(member) = VariantInternalAccessor::get(base).m_getter(m_index); \ + } \ + static void ptr_get(const void *base, void *member) { \ + PtrToArg::encode(PtrToArg::convert(base).m_getter(m_index), member); \ + } \ + static void set(Variant *base, const Variant *value, bool &valid) { \ + if (value->get_type() == GetTypeInfo::VARIANT_TYPE) { \ + VariantInternalAccessor::get(base).m_setter(m_index, VariantInternalAccessor::get(value)); \ + valid = true; \ + } else { \ + valid = false; \ + } \ + } \ + static inline void validated_set(Variant *base, const Variant *value) { \ + VariantInternalAccessor::get(base).m_setter(m_index, VariantInternalAccessor::get(value)); \ + } \ + static void ptr_set(void *base, const void *member) { \ + m_base_type b = PtrToArg::convert(base); \ + b.m_setter(m_index, PtrToArg::convert(member)); \ + PtrToArg::encode(b, base); \ + } \ + static Variant::Type get_type() { \ + return GetTypeInfo::VARIANT_TYPE; \ + } \ }; SETGET_NUMBER_STRUCT(Vector2, double, x)