From 5f7566a72ec265335b006a337287b976fd77e3fd Mon Sep 17 00:00:00 2001 From: aaronp64 Date: Mon, 24 Nov 2025 17:57:45 -0500 Subject: [PATCH] Reuse/optimize common OperatorEvaluator*::evaluate logic Added CommonEvaluate class to be used by OperatorEvaluator* classes that have the same logic for `evaluate` and `validated_evaluate`. CommonEvaluate initializes the return Variant to the correct type, then passes through to validated_evaluate, reducing code duplication between evaluate/validated_evaluate and avoiding the overhead of creating/destroying temporary Variants from previous evaluate implementations. --- core/variant/variant_op.cpp | 364 +++++++++++++-------------- core/variant/variant_op.h | 476 ++++++++---------------------------- 2 files changed, 269 insertions(+), 571 deletions(-) diff --git a/core/variant/variant_op.cpp b/core/variant/variant_op.cpp index ad19c8bdd94..b25556a903f 100644 --- a/core/variant/variant_op.cpp +++ b/core/variant/variant_op.cpp @@ -48,39 +48,27 @@ void register_op(Variant::Operator p_op, Variant::Type p_type_a, Variant::Type p // Special cases that can't be done otherwise because of the forced casting to float. template <> -class OperatorEvaluatorMul { +class OperatorEvaluatorMul : public CommonEvaluate> { public: - static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - 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) { 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); } - static Variant::Type get_return_type() { return GetTypeInfo::VARIANT_TYPE; } + using ReturnType = Vector2; }; template <> -class OperatorEvaluatorMul { +class OperatorEvaluatorMul : public CommonEvaluate> { public: - static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - 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) { 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); } - static Variant::Type get_return_type() { return GetTypeInfo::VARIANT_TYPE; } + using ReturnType = Vector2; }; template <> @@ -107,39 +95,27 @@ public: }; template <> -class OperatorEvaluatorMul { +class OperatorEvaluatorMul : public CommonEvaluate> { public: - static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - 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) { 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); } - static Variant::Type get_return_type() { return GetTypeInfo::VARIANT_TYPE; } + using ReturnType = Vector3; }; template <> -class OperatorEvaluatorMul { +class OperatorEvaluatorMul : public CommonEvaluate> { public: - static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - 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) { 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); } - static Variant::Type get_return_type() { return GetTypeInfo::VARIANT_TYPE; } + using ReturnType = Vector3; }; template <> @@ -168,39 +144,27 @@ public: // template <> -class OperatorEvaluatorMul { +class OperatorEvaluatorMul : public CommonEvaluate> { public: - static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - 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) { 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); } - static Variant::Type get_return_type() { return GetTypeInfo::VARIANT_TYPE; } + using ReturnType = Vector4; }; template <> -class OperatorEvaluatorMul { +class OperatorEvaluatorMul : public CommonEvaluate> { public: - static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - 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) { 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); } - static Variant::Type get_return_type() { return GetTypeInfo::VARIANT_TYPE; } + using ReturnType = Vector4; }; template <> @@ -520,7 +484,7 @@ void Variant::_register_variant_operators() { register_op>(Variant::OP_BIT_XOR, Variant::INT, Variant::INT); register_op>(Variant::OP_BIT_NEGATE, Variant::INT, Variant::NIL); - register_op>(Variant::OP_EQUAL, Variant::NIL, Variant::NIL); + register_op(Variant::OP_EQUAL, Variant::NIL, Variant::NIL); register_op>(Variant::OP_EQUAL, Variant::BOOL, Variant::BOOL); register_op>(Variant::OP_EQUAL, Variant::INT, Variant::INT); register_op>(Variant::OP_EQUAL, Variant::INT, Variant::FLOAT); @@ -566,83 +530,83 @@ void Variant::_register_variant_operators() { register_op>(Variant::OP_EQUAL, Variant::PACKED_COLOR_ARRAY, Variant::PACKED_COLOR_ARRAY); register_op>(Variant::OP_EQUAL, Variant::PACKED_VECTOR4_ARRAY, Variant::PACKED_VECTOR4_ARRAY); - register_op>(Variant::OP_EQUAL, Variant::BOOL, Variant::NIL); - register_op>(Variant::OP_EQUAL, Variant::INT, Variant::NIL); - register_op>(Variant::OP_EQUAL, Variant::FLOAT, Variant::NIL); - register_op>(Variant::OP_EQUAL, Variant::STRING, Variant::NIL); - register_op>(Variant::OP_EQUAL, Variant::VECTOR2, Variant::NIL); - register_op>(Variant::OP_EQUAL, Variant::VECTOR2I, Variant::NIL); - register_op>(Variant::OP_EQUAL, Variant::RECT2, Variant::NIL); - register_op>(Variant::OP_EQUAL, Variant::RECT2I, Variant::NIL); - register_op>(Variant::OP_EQUAL, Variant::VECTOR3, Variant::NIL); - register_op>(Variant::OP_EQUAL, Variant::VECTOR3I, Variant::NIL); - register_op>(Variant::OP_EQUAL, Variant::VECTOR4, Variant::NIL); - register_op>(Variant::OP_EQUAL, Variant::VECTOR4I, Variant::NIL); - register_op>(Variant::OP_EQUAL, Variant::TRANSFORM2D, Variant::NIL); - register_op>(Variant::OP_EQUAL, Variant::PLANE, Variant::NIL); - register_op>(Variant::OP_EQUAL, Variant::QUATERNION, Variant::NIL); - register_op>(Variant::OP_EQUAL, Variant::AABB, Variant::NIL); - register_op>(Variant::OP_EQUAL, Variant::BASIS, Variant::NIL); - register_op>(Variant::OP_EQUAL, Variant::TRANSFORM3D, Variant::NIL); - register_op>(Variant::OP_EQUAL, Variant::PROJECTION, Variant::NIL); - register_op>(Variant::OP_EQUAL, Variant::COLOR, Variant::NIL); - register_op>(Variant::OP_EQUAL, Variant::STRING_NAME, Variant::NIL); - register_op>(Variant::OP_EQUAL, Variant::NODE_PATH, Variant::NIL); - register_op>(Variant::OP_EQUAL, Variant::RID, Variant::NIL); - register_op>(Variant::OP_EQUAL, Variant::CALLABLE, Variant::NIL); - register_op>(Variant::OP_EQUAL, Variant::SIGNAL, Variant::NIL); - register_op>(Variant::OP_EQUAL, Variant::DICTIONARY, Variant::NIL); - register_op>(Variant::OP_EQUAL, Variant::ARRAY, Variant::NIL); - register_op>(Variant::OP_EQUAL, Variant::PACKED_BYTE_ARRAY, Variant::NIL); - register_op>(Variant::OP_EQUAL, Variant::PACKED_INT32_ARRAY, Variant::NIL); - register_op>(Variant::OP_EQUAL, Variant::PACKED_INT64_ARRAY, Variant::NIL); - register_op>(Variant::OP_EQUAL, Variant::PACKED_FLOAT32_ARRAY, Variant::NIL); - register_op>(Variant::OP_EQUAL, Variant::PACKED_FLOAT64_ARRAY, Variant::NIL); - register_op>(Variant::OP_EQUAL, Variant::PACKED_STRING_ARRAY, Variant::NIL); - register_op>(Variant::OP_EQUAL, Variant::PACKED_VECTOR2_ARRAY, Variant::NIL); - register_op>(Variant::OP_EQUAL, Variant::PACKED_VECTOR3_ARRAY, Variant::NIL); - register_op>(Variant::OP_EQUAL, Variant::PACKED_COLOR_ARRAY, Variant::NIL); - register_op>(Variant::OP_EQUAL, Variant::PACKED_VECTOR4_ARRAY, Variant::NIL); + register_op(Variant::OP_EQUAL, Variant::BOOL, Variant::NIL); + register_op(Variant::OP_EQUAL, Variant::INT, Variant::NIL); + register_op(Variant::OP_EQUAL, Variant::FLOAT, Variant::NIL); + register_op(Variant::OP_EQUAL, Variant::STRING, Variant::NIL); + register_op(Variant::OP_EQUAL, Variant::VECTOR2, Variant::NIL); + register_op(Variant::OP_EQUAL, Variant::VECTOR2I, Variant::NIL); + register_op(Variant::OP_EQUAL, Variant::RECT2, Variant::NIL); + register_op(Variant::OP_EQUAL, Variant::RECT2I, Variant::NIL); + register_op(Variant::OP_EQUAL, Variant::VECTOR3, Variant::NIL); + register_op(Variant::OP_EQUAL, Variant::VECTOR3I, Variant::NIL); + register_op(Variant::OP_EQUAL, Variant::VECTOR4, Variant::NIL); + register_op(Variant::OP_EQUAL, Variant::VECTOR4I, Variant::NIL); + register_op(Variant::OP_EQUAL, Variant::TRANSFORM2D, Variant::NIL); + register_op(Variant::OP_EQUAL, Variant::PLANE, Variant::NIL); + register_op(Variant::OP_EQUAL, Variant::QUATERNION, Variant::NIL); + register_op(Variant::OP_EQUAL, Variant::AABB, Variant::NIL); + register_op(Variant::OP_EQUAL, Variant::BASIS, Variant::NIL); + register_op(Variant::OP_EQUAL, Variant::TRANSFORM3D, Variant::NIL); + register_op(Variant::OP_EQUAL, Variant::PROJECTION, Variant::NIL); + register_op(Variant::OP_EQUAL, Variant::COLOR, Variant::NIL); + register_op(Variant::OP_EQUAL, Variant::STRING_NAME, Variant::NIL); + register_op(Variant::OP_EQUAL, Variant::NODE_PATH, Variant::NIL); + register_op(Variant::OP_EQUAL, Variant::RID, Variant::NIL); + register_op(Variant::OP_EQUAL, Variant::CALLABLE, Variant::NIL); + register_op(Variant::OP_EQUAL, Variant::SIGNAL, Variant::NIL); + register_op(Variant::OP_EQUAL, Variant::DICTIONARY, Variant::NIL); + register_op(Variant::OP_EQUAL, Variant::ARRAY, Variant::NIL); + register_op(Variant::OP_EQUAL, Variant::PACKED_BYTE_ARRAY, Variant::NIL); + register_op(Variant::OP_EQUAL, Variant::PACKED_INT32_ARRAY, Variant::NIL); + register_op(Variant::OP_EQUAL, Variant::PACKED_INT64_ARRAY, Variant::NIL); + register_op(Variant::OP_EQUAL, Variant::PACKED_FLOAT32_ARRAY, Variant::NIL); + register_op(Variant::OP_EQUAL, Variant::PACKED_FLOAT64_ARRAY, Variant::NIL); + register_op(Variant::OP_EQUAL, Variant::PACKED_STRING_ARRAY, Variant::NIL); + register_op(Variant::OP_EQUAL, Variant::PACKED_VECTOR2_ARRAY, Variant::NIL); + register_op(Variant::OP_EQUAL, Variant::PACKED_VECTOR3_ARRAY, Variant::NIL); + register_op(Variant::OP_EQUAL, Variant::PACKED_COLOR_ARRAY, Variant::NIL); + register_op(Variant::OP_EQUAL, Variant::PACKED_VECTOR4_ARRAY, Variant::NIL); - register_op>(Variant::OP_EQUAL, Variant::NIL, Variant::BOOL); - register_op>(Variant::OP_EQUAL, Variant::NIL, Variant::INT); - register_op>(Variant::OP_EQUAL, Variant::NIL, Variant::FLOAT); - register_op>(Variant::OP_EQUAL, Variant::NIL, Variant::STRING); - register_op>(Variant::OP_EQUAL, Variant::NIL, Variant::VECTOR2); - register_op>(Variant::OP_EQUAL, Variant::NIL, Variant::VECTOR2I); - register_op>(Variant::OP_EQUAL, Variant::NIL, Variant::RECT2); - register_op>(Variant::OP_EQUAL, Variant::NIL, Variant::RECT2I); - register_op>(Variant::OP_EQUAL, Variant::NIL, Variant::VECTOR3); - register_op>(Variant::OP_EQUAL, Variant::NIL, Variant::VECTOR3I); - register_op>(Variant::OP_EQUAL, Variant::NIL, Variant::VECTOR4); - register_op>(Variant::OP_EQUAL, Variant::NIL, Variant::VECTOR4I); - register_op>(Variant::OP_EQUAL, Variant::NIL, Variant::TRANSFORM2D); - register_op>(Variant::OP_EQUAL, Variant::NIL, Variant::PLANE); - register_op>(Variant::OP_EQUAL, Variant::NIL, Variant::QUATERNION); - register_op>(Variant::OP_EQUAL, Variant::NIL, Variant::AABB); - register_op>(Variant::OP_EQUAL, Variant::NIL, Variant::BASIS); - register_op>(Variant::OP_EQUAL, Variant::NIL, Variant::TRANSFORM3D); - register_op>(Variant::OP_EQUAL, Variant::NIL, Variant::PROJECTION); - register_op>(Variant::OP_EQUAL, Variant::NIL, Variant::COLOR); - register_op>(Variant::OP_EQUAL, Variant::NIL, Variant::STRING_NAME); - register_op>(Variant::OP_EQUAL, Variant::NIL, Variant::NODE_PATH); - register_op>(Variant::OP_EQUAL, Variant::NIL, Variant::RID); - register_op>(Variant::OP_EQUAL, Variant::NIL, Variant::CALLABLE); - register_op>(Variant::OP_EQUAL, Variant::NIL, Variant::SIGNAL); - register_op>(Variant::OP_EQUAL, Variant::NIL, Variant::DICTIONARY); - register_op>(Variant::OP_EQUAL, Variant::NIL, Variant::ARRAY); - register_op>(Variant::OP_EQUAL, Variant::NIL, Variant::PACKED_BYTE_ARRAY); - register_op>(Variant::OP_EQUAL, Variant::NIL, Variant::PACKED_INT32_ARRAY); - register_op>(Variant::OP_EQUAL, Variant::NIL, Variant::PACKED_INT64_ARRAY); - register_op>(Variant::OP_EQUAL, Variant::NIL, Variant::PACKED_FLOAT32_ARRAY); - register_op>(Variant::OP_EQUAL, Variant::NIL, Variant::PACKED_FLOAT64_ARRAY); - register_op>(Variant::OP_EQUAL, Variant::NIL, Variant::PACKED_STRING_ARRAY); - register_op>(Variant::OP_EQUAL, Variant::NIL, Variant::PACKED_VECTOR2_ARRAY); - register_op>(Variant::OP_EQUAL, Variant::NIL, Variant::PACKED_VECTOR3_ARRAY); - register_op>(Variant::OP_EQUAL, Variant::NIL, Variant::PACKED_COLOR_ARRAY); - register_op>(Variant::OP_EQUAL, Variant::NIL, Variant::PACKED_VECTOR4_ARRAY); + register_op(Variant::OP_EQUAL, Variant::NIL, Variant::BOOL); + register_op(Variant::OP_EQUAL, Variant::NIL, Variant::INT); + register_op(Variant::OP_EQUAL, Variant::NIL, Variant::FLOAT); + register_op(Variant::OP_EQUAL, Variant::NIL, Variant::STRING); + register_op(Variant::OP_EQUAL, Variant::NIL, Variant::VECTOR2); + register_op(Variant::OP_EQUAL, Variant::NIL, Variant::VECTOR2I); + register_op(Variant::OP_EQUAL, Variant::NIL, Variant::RECT2); + register_op(Variant::OP_EQUAL, Variant::NIL, Variant::RECT2I); + register_op(Variant::OP_EQUAL, Variant::NIL, Variant::VECTOR3); + register_op(Variant::OP_EQUAL, Variant::NIL, Variant::VECTOR3I); + register_op(Variant::OP_EQUAL, Variant::NIL, Variant::VECTOR4); + register_op(Variant::OP_EQUAL, Variant::NIL, Variant::VECTOR4I); + register_op(Variant::OP_EQUAL, Variant::NIL, Variant::TRANSFORM2D); + register_op(Variant::OP_EQUAL, Variant::NIL, Variant::PLANE); + register_op(Variant::OP_EQUAL, Variant::NIL, Variant::QUATERNION); + register_op(Variant::OP_EQUAL, Variant::NIL, Variant::AABB); + register_op(Variant::OP_EQUAL, Variant::NIL, Variant::BASIS); + register_op(Variant::OP_EQUAL, Variant::NIL, Variant::TRANSFORM3D); + register_op(Variant::OP_EQUAL, Variant::NIL, Variant::PROJECTION); + register_op(Variant::OP_EQUAL, Variant::NIL, Variant::COLOR); + register_op(Variant::OP_EQUAL, Variant::NIL, Variant::STRING_NAME); + register_op(Variant::OP_EQUAL, Variant::NIL, Variant::NODE_PATH); + register_op(Variant::OP_EQUAL, Variant::NIL, Variant::RID); + register_op(Variant::OP_EQUAL, Variant::NIL, Variant::CALLABLE); + register_op(Variant::OP_EQUAL, Variant::NIL, Variant::SIGNAL); + register_op(Variant::OP_EQUAL, Variant::NIL, Variant::DICTIONARY); + register_op(Variant::OP_EQUAL, Variant::NIL, Variant::ARRAY); + register_op(Variant::OP_EQUAL, Variant::NIL, Variant::PACKED_BYTE_ARRAY); + register_op(Variant::OP_EQUAL, Variant::NIL, Variant::PACKED_INT32_ARRAY); + register_op(Variant::OP_EQUAL, Variant::NIL, Variant::PACKED_INT64_ARRAY); + register_op(Variant::OP_EQUAL, Variant::NIL, Variant::PACKED_FLOAT32_ARRAY); + register_op(Variant::OP_EQUAL, Variant::NIL, Variant::PACKED_FLOAT64_ARRAY); + register_op(Variant::OP_EQUAL, Variant::NIL, Variant::PACKED_STRING_ARRAY); + register_op(Variant::OP_EQUAL, Variant::NIL, Variant::PACKED_VECTOR2_ARRAY); + register_op(Variant::OP_EQUAL, Variant::NIL, Variant::PACKED_VECTOR3_ARRAY); + register_op(Variant::OP_EQUAL, Variant::NIL, Variant::PACKED_COLOR_ARRAY); + register_op(Variant::OP_EQUAL, Variant::NIL, Variant::PACKED_VECTOR4_ARRAY); - register_op>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::NIL); + register_op(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::NIL); register_op>(Variant::OP_NOT_EQUAL, Variant::BOOL, Variant::BOOL); register_op>(Variant::OP_NOT_EQUAL, Variant::INT, Variant::INT); register_op>(Variant::OP_NOT_EQUAL, Variant::INT, Variant::FLOAT); @@ -688,81 +652,81 @@ void Variant::_register_variant_operators() { register_op>(Variant::OP_NOT_EQUAL, Variant::PACKED_COLOR_ARRAY, Variant::PACKED_COLOR_ARRAY); register_op>(Variant::OP_NOT_EQUAL, Variant::PACKED_VECTOR4_ARRAY, Variant::PACKED_VECTOR4_ARRAY); - register_op>(Variant::OP_NOT_EQUAL, Variant::BOOL, Variant::NIL); - register_op>(Variant::OP_NOT_EQUAL, Variant::INT, Variant::NIL); - register_op>(Variant::OP_NOT_EQUAL, Variant::FLOAT, Variant::NIL); - register_op>(Variant::OP_NOT_EQUAL, Variant::STRING, Variant::NIL); - register_op>(Variant::OP_NOT_EQUAL, Variant::VECTOR2, Variant::NIL); - register_op>(Variant::OP_NOT_EQUAL, Variant::VECTOR2I, Variant::NIL); - register_op>(Variant::OP_NOT_EQUAL, Variant::RECT2, Variant::NIL); - register_op>(Variant::OP_NOT_EQUAL, Variant::RECT2I, Variant::NIL); - register_op>(Variant::OP_NOT_EQUAL, Variant::VECTOR3, Variant::NIL); - register_op>(Variant::OP_NOT_EQUAL, Variant::VECTOR3I, Variant::NIL); - register_op>(Variant::OP_NOT_EQUAL, Variant::TRANSFORM2D, Variant::NIL); - register_op>(Variant::OP_NOT_EQUAL, Variant::VECTOR4, Variant::NIL); - register_op>(Variant::OP_NOT_EQUAL, Variant::VECTOR4I, Variant::NIL); - register_op>(Variant::OP_NOT_EQUAL, Variant::PLANE, Variant::NIL); - register_op>(Variant::OP_NOT_EQUAL, Variant::QUATERNION, Variant::NIL); - register_op>(Variant::OP_NOT_EQUAL, Variant::AABB, Variant::NIL); - register_op>(Variant::OP_NOT_EQUAL, Variant::BASIS, Variant::NIL); - register_op>(Variant::OP_NOT_EQUAL, Variant::TRANSFORM3D, Variant::NIL); - register_op>(Variant::OP_NOT_EQUAL, Variant::PROJECTION, Variant::NIL); - register_op>(Variant::OP_NOT_EQUAL, Variant::COLOR, Variant::NIL); - register_op>(Variant::OP_NOT_EQUAL, Variant::STRING_NAME, Variant::NIL); - register_op>(Variant::OP_NOT_EQUAL, Variant::NODE_PATH, Variant::NIL); - register_op>(Variant::OP_NOT_EQUAL, Variant::RID, Variant::NIL); - register_op>(Variant::OP_NOT_EQUAL, Variant::CALLABLE, Variant::NIL); - register_op>(Variant::OP_NOT_EQUAL, Variant::SIGNAL, Variant::NIL); - register_op>(Variant::OP_NOT_EQUAL, Variant::DICTIONARY, Variant::NIL); - register_op>(Variant::OP_NOT_EQUAL, Variant::ARRAY, Variant::NIL); - register_op>(Variant::OP_NOT_EQUAL, Variant::PACKED_BYTE_ARRAY, Variant::NIL); - register_op>(Variant::OP_NOT_EQUAL, Variant::PACKED_INT32_ARRAY, Variant::NIL); - register_op>(Variant::OP_NOT_EQUAL, Variant::PACKED_INT64_ARRAY, Variant::NIL); - register_op>(Variant::OP_NOT_EQUAL, Variant::PACKED_FLOAT32_ARRAY, Variant::NIL); - register_op>(Variant::OP_NOT_EQUAL, Variant::PACKED_FLOAT64_ARRAY, Variant::NIL); - register_op>(Variant::OP_NOT_EQUAL, Variant::PACKED_STRING_ARRAY, Variant::NIL); - register_op>(Variant::OP_NOT_EQUAL, Variant::PACKED_VECTOR2_ARRAY, Variant::NIL); - register_op>(Variant::OP_NOT_EQUAL, Variant::PACKED_VECTOR3_ARRAY, Variant::NIL); - register_op>(Variant::OP_NOT_EQUAL, Variant::PACKED_COLOR_ARRAY, Variant::NIL); - register_op>(Variant::OP_NOT_EQUAL, Variant::PACKED_VECTOR4_ARRAY, Variant::NIL); + register_op(Variant::OP_NOT_EQUAL, Variant::BOOL, Variant::NIL); + register_op(Variant::OP_NOT_EQUAL, Variant::INT, Variant::NIL); + register_op(Variant::OP_NOT_EQUAL, Variant::FLOAT, Variant::NIL); + register_op(Variant::OP_NOT_EQUAL, Variant::STRING, Variant::NIL); + register_op(Variant::OP_NOT_EQUAL, Variant::VECTOR2, Variant::NIL); + register_op(Variant::OP_NOT_EQUAL, Variant::VECTOR2I, Variant::NIL); + register_op(Variant::OP_NOT_EQUAL, Variant::RECT2, Variant::NIL); + register_op(Variant::OP_NOT_EQUAL, Variant::RECT2I, Variant::NIL); + register_op(Variant::OP_NOT_EQUAL, Variant::VECTOR3, Variant::NIL); + register_op(Variant::OP_NOT_EQUAL, Variant::VECTOR3I, Variant::NIL); + register_op(Variant::OP_NOT_EQUAL, Variant::TRANSFORM2D, Variant::NIL); + register_op(Variant::OP_NOT_EQUAL, Variant::VECTOR4, Variant::NIL); + register_op(Variant::OP_NOT_EQUAL, Variant::VECTOR4I, Variant::NIL); + register_op(Variant::OP_NOT_EQUAL, Variant::PLANE, Variant::NIL); + register_op(Variant::OP_NOT_EQUAL, Variant::QUATERNION, Variant::NIL); + register_op(Variant::OP_NOT_EQUAL, Variant::AABB, Variant::NIL); + register_op(Variant::OP_NOT_EQUAL, Variant::BASIS, Variant::NIL); + register_op(Variant::OP_NOT_EQUAL, Variant::TRANSFORM3D, Variant::NIL); + register_op(Variant::OP_NOT_EQUAL, Variant::PROJECTION, Variant::NIL); + register_op(Variant::OP_NOT_EQUAL, Variant::COLOR, Variant::NIL); + register_op(Variant::OP_NOT_EQUAL, Variant::STRING_NAME, Variant::NIL); + register_op(Variant::OP_NOT_EQUAL, Variant::NODE_PATH, Variant::NIL); + register_op(Variant::OP_NOT_EQUAL, Variant::RID, Variant::NIL); + register_op(Variant::OP_NOT_EQUAL, Variant::CALLABLE, Variant::NIL); + register_op(Variant::OP_NOT_EQUAL, Variant::SIGNAL, Variant::NIL); + register_op(Variant::OP_NOT_EQUAL, Variant::DICTIONARY, Variant::NIL); + register_op(Variant::OP_NOT_EQUAL, Variant::ARRAY, Variant::NIL); + register_op(Variant::OP_NOT_EQUAL, Variant::PACKED_BYTE_ARRAY, Variant::NIL); + register_op(Variant::OP_NOT_EQUAL, Variant::PACKED_INT32_ARRAY, Variant::NIL); + register_op(Variant::OP_NOT_EQUAL, Variant::PACKED_INT64_ARRAY, Variant::NIL); + register_op(Variant::OP_NOT_EQUAL, Variant::PACKED_FLOAT32_ARRAY, Variant::NIL); + register_op(Variant::OP_NOT_EQUAL, Variant::PACKED_FLOAT64_ARRAY, Variant::NIL); + register_op(Variant::OP_NOT_EQUAL, Variant::PACKED_STRING_ARRAY, Variant::NIL); + register_op(Variant::OP_NOT_EQUAL, Variant::PACKED_VECTOR2_ARRAY, Variant::NIL); + register_op(Variant::OP_NOT_EQUAL, Variant::PACKED_VECTOR3_ARRAY, Variant::NIL); + register_op(Variant::OP_NOT_EQUAL, Variant::PACKED_COLOR_ARRAY, Variant::NIL); + register_op(Variant::OP_NOT_EQUAL, Variant::PACKED_VECTOR4_ARRAY, Variant::NIL); - register_op>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::BOOL); - register_op>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::INT); - register_op>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::FLOAT); - register_op>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::STRING); - register_op>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::VECTOR2); - register_op>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::VECTOR2I); - register_op>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::RECT2); - register_op>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::RECT2I); - register_op>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::VECTOR3); - register_op>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::VECTOR3I); - register_op>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::VECTOR4); - register_op>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::VECTOR4I); - register_op>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::TRANSFORM2D); - register_op>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::PLANE); - register_op>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::QUATERNION); - register_op>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::AABB); - register_op>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::BASIS); - register_op>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::TRANSFORM3D); - register_op>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::PROJECTION); - register_op>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::COLOR); - register_op>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::STRING_NAME); - register_op>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::NODE_PATH); - register_op>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::RID); - register_op>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::CALLABLE); - register_op>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::SIGNAL); - register_op>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::DICTIONARY); - register_op>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::ARRAY); - register_op>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::PACKED_BYTE_ARRAY); - register_op>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::PACKED_INT32_ARRAY); - register_op>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::PACKED_INT64_ARRAY); - register_op>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::PACKED_FLOAT32_ARRAY); - register_op>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::PACKED_FLOAT64_ARRAY); - register_op>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::PACKED_STRING_ARRAY); - register_op>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::PACKED_VECTOR2_ARRAY); - register_op>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::PACKED_VECTOR3_ARRAY); - register_op>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::PACKED_COLOR_ARRAY); - register_op>(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::PACKED_VECTOR4_ARRAY); + register_op(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::BOOL); + register_op(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::INT); + register_op(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::FLOAT); + register_op(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::STRING); + register_op(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::VECTOR2); + register_op(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::VECTOR2I); + register_op(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::RECT2); + register_op(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::RECT2I); + register_op(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::VECTOR3); + register_op(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::VECTOR3I); + register_op(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::VECTOR4); + register_op(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::VECTOR4I); + register_op(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::TRANSFORM2D); + register_op(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::PLANE); + register_op(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::QUATERNION); + register_op(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::AABB); + register_op(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::BASIS); + register_op(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::TRANSFORM3D); + register_op(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::PROJECTION); + register_op(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::COLOR); + register_op(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::STRING_NAME); + register_op(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::NODE_PATH); + register_op(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::RID); + register_op(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::CALLABLE); + register_op(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::SIGNAL); + register_op(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::DICTIONARY); + register_op(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::ARRAY); + register_op(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::PACKED_BYTE_ARRAY); + register_op(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::PACKED_INT32_ARRAY); + register_op(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::PACKED_INT64_ARRAY); + register_op(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::PACKED_FLOAT32_ARRAY); + register_op(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::PACKED_FLOAT64_ARRAY); + register_op(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::PACKED_STRING_ARRAY); + register_op(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::PACKED_VECTOR2_ARRAY); + register_op(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::PACKED_VECTOR3_ARRAY); + register_op(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::PACKED_COLOR_ARRAY); + register_op(Variant::OP_NOT_EQUAL, Variant::NIL, Variant::PACKED_VECTOR4_ARRAY); register_op>(Variant::OP_LESS, Variant::BOOL, Variant::BOOL); register_op>(Variant::OP_LESS, Variant::INT, Variant::INT); @@ -826,7 +790,7 @@ void Variant::_register_variant_operators() { register_op>(Variant::OP_GREATER_EQUAL, Variant::RID, Variant::RID); register_op>(Variant::OP_GREATER_EQUAL, Variant::ARRAY, Variant::ARRAY); - register_op>(Variant::OP_OR, Variant::NIL, Variant::NIL); + register_op(Variant::OP_OR, Variant::NIL, Variant::NIL); // OR register_op(Variant::OP_OR, Variant::NIL, Variant::BOOL); @@ -915,7 +879,7 @@ void Variant::_register_variant_operators() { register_op(Variant::OP_XOR, Variant::OBJECT, Variant::FLOAT); register_op(Variant::OP_XOR, Variant::OBJECT, Variant::OBJECT); - register_op>(Variant::OP_NOT, Variant::NIL, Variant::NIL); + register_op(Variant::OP_NOT, Variant::NIL, Variant::NIL); register_op(Variant::OP_NOT, Variant::BOOL, Variant::NIL); register_op(Variant::OP_NOT, Variant::INT, Variant::NIL); register_op(Variant::OP_NOT, Variant::FLOAT, Variant::NIL); diff --git a/core/variant/variant_op.h b/core/variant/variant_op.h index 0f9fa9f9364..e9eb66f9c9a 100644 --- a/core/variant/variant_op.h +++ b/core/variant/variant_op.h @@ -35,130 +35,99 @@ #include "core/debugger/engine_debugger.h" #include "core/object/class_db.h" -template -class OperatorEvaluatorAdd { +template +class CommonEvaluate { public: static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - const A &a = VariantInternalAccessor::get(&p_left); - const B &b = VariantInternalAccessor::get(&p_right); - *r_ret = a + b; + VariantTypeChanger::change(r_ret); + Evaluator::validated_evaluate(&p_left, &p_right, r_ret); r_valid = true; } + static Variant::Type get_return_type() { return GetTypeInfo::VARIANT_TYPE; } +}; + +template +class OperatorEvaluatorAdd : public CommonEvaluate> { +public: static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) { 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); } - static Variant::Type get_return_type() { return GetTypeInfo::VARIANT_TYPE; } + using ReturnType = R; }; template -class OperatorEvaluatorSub { +class OperatorEvaluatorSub : public CommonEvaluate> { public: - static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - 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) { 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); } - static Variant::Type get_return_type() { return GetTypeInfo::VARIANT_TYPE; } + using ReturnType = R; }; template -class OperatorEvaluatorMul { +class OperatorEvaluatorMul : public CommonEvaluate> { public: - static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - 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) { 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); } - static Variant::Type get_return_type() { return GetTypeInfo::VARIANT_TYPE; } + using ReturnType = R; }; template -class OperatorEvaluatorPow { +class OperatorEvaluatorPow : public CommonEvaluate> { public: - static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - 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) { 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); } - static Variant::Type get_return_type() { return GetTypeInfo::VARIANT_TYPE; } + using ReturnType = R; }; template -class OperatorEvaluatorXForm { +class OperatorEvaluatorXForm : public CommonEvaluate> { public: - static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - 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) { 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); } - static Variant::Type get_return_type() { return GetTypeInfo::VARIANT_TYPE; } + using ReturnType = R; }; template -class OperatorEvaluatorXFormInv { +class OperatorEvaluatorXFormInv : public CommonEvaluate> { public: - static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - 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) { 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); } - static Variant::Type get_return_type() { return GetTypeInfo::VARIANT_TYPE; } + using ReturnType = R; }; template -class OperatorEvaluatorDiv { +class OperatorEvaluatorDiv : public CommonEvaluate> { public: - static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - 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) { 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); } - static Variant::Type get_return_type() { return GetTypeInfo::VARIANT_TYPE; } + using ReturnType = R; }; template @@ -257,21 +226,15 @@ public: }; template -class OperatorEvaluatorMod { +class OperatorEvaluatorMod : public CommonEvaluate> { public: - static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - 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) { 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); } - static Variant::Type get_return_type() { return GetTypeInfo::VARIANT_TYPE; } + using ReturnType = R; }; template @@ -370,37 +333,27 @@ public: }; template -class OperatorEvaluatorNeg { +class OperatorEvaluatorNeg : public CommonEvaluate> { public: - static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - 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) { 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); } - static Variant::Type get_return_type() { return GetTypeInfo::VARIANT_TYPE; } + using ReturnType = R; }; template -class OperatorEvaluatorPos { +class OperatorEvaluatorPos : public CommonEvaluate> { public: - static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - 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) { 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); } - static Variant::Type get_return_type() { return GetTypeInfo::VARIANT_TYPE; } + using ReturnType = R; }; template @@ -456,102 +409,67 @@ public: }; template -class OperatorEvaluatorBitOr { +class OperatorEvaluatorBitOr : public CommonEvaluate> { public: - static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - 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) { 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); } - static Variant::Type get_return_type() { return GetTypeInfo::VARIANT_TYPE; } + using ReturnType = R; }; template -class OperatorEvaluatorBitAnd { +class OperatorEvaluatorBitAnd : public CommonEvaluate> { public: - static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - 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) { 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); } - static Variant::Type get_return_type() { return GetTypeInfo::VARIANT_TYPE; } + using ReturnType = R; }; template -class OperatorEvaluatorBitXor { +class OperatorEvaluatorBitXor : public CommonEvaluate> { public: - static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - 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) { 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); } - static Variant::Type get_return_type() { return GetTypeInfo::VARIANT_TYPE; } + using ReturnType = R; }; template -class OperatorEvaluatorBitNeg { +class OperatorEvaluatorBitNeg : public CommonEvaluate> { public: - static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - 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) { 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); } - static Variant::Type get_return_type() { return GetTypeInfo::VARIANT_TYPE; } + using ReturnType = R; }; template -class OperatorEvaluatorEqual { +class OperatorEvaluatorEqual : public CommonEvaluate> { public: - static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - 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) { 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); } - static Variant::Type get_return_type() { return Variant::BOOL; } + using ReturnType = bool; }; -class OperatorEvaluatorEqualObject { +class OperatorEvaluatorEqualObject : public CommonEvaluate { public: - static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - const Object *a = p_left.get_validated_object(); - const Object *b = p_right.get_validated_object(); - *r_ret = a == b; - r_valid = true; - } 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(); @@ -560,16 +478,11 @@ public: static void ptr_evaluate(const void *left, const void *right, void *r_ret) { PtrToArg::encode(PtrToArg::convert(left) == PtrToArg::convert(right), r_ret); } - static Variant::Type get_return_type() { return Variant::BOOL; } + using ReturnType = bool; }; -class OperatorEvaluatorEqualObjectNil { +class OperatorEvaluatorEqualObjectNil : public CommonEvaluate { public: - static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - const Object *a = p_left.get_validated_object(); - *r_ret = a == nullptr; - r_valid = true; - } static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) { const Object *a = left->get_validated_object(); VariantInternalAccessor::get(r_ret) = a == nullptr; @@ -577,16 +490,11 @@ public: static void ptr_evaluate(const void *left, const void *right, void *r_ret) { PtrToArg::encode(PtrToArg::convert(left) == nullptr, r_ret); } - static Variant::Type get_return_type() { return Variant::BOOL; } + using ReturnType = bool; }; -class OperatorEvaluatorEqualNilObject { +class OperatorEvaluatorEqualNilObject : public CommonEvaluate { public: - static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - const Object *b = p_right.get_validated_object(); - *r_ret = nullptr == b; - r_valid = true; - } static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) { const Object *b = right->get_validated_object(); VariantInternalAccessor::get(r_ret) = nullptr == b; @@ -594,35 +502,23 @@ public: static void ptr_evaluate(const void *left, const void *right, void *r_ret) { PtrToArg::encode(nullptr == PtrToArg::convert(right), r_ret); } - static Variant::Type get_return_type() { return Variant::BOOL; } + using ReturnType = bool; }; template -class OperatorEvaluatorNotEqual { +class OperatorEvaluatorNotEqual : public CommonEvaluate> { public: - static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - 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) { 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); } - static Variant::Type get_return_type() { return Variant::BOOL; } + using ReturnType = bool; }; -class OperatorEvaluatorNotEqualObject { +class OperatorEvaluatorNotEqualObject : public CommonEvaluate { public: - static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - Object *a = p_left.get_validated_object(); - Object *b = p_right.get_validated_object(); - *r_ret = a != b; - r_valid = true; - } 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(); @@ -631,16 +527,11 @@ public: static void ptr_evaluate(const void *left, const void *right, void *r_ret) { PtrToArg::encode(PtrToArg::convert(left) != PtrToArg::convert(right), r_ret); } - static Variant::Type get_return_type() { return Variant::BOOL; } + using ReturnType = bool; }; -class OperatorEvaluatorNotEqualObjectNil { +class OperatorEvaluatorNotEqualObjectNil : public CommonEvaluate { public: - static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - Object *a = p_left.get_validated_object(); - *r_ret = a != nullptr; - r_valid = true; - } static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) { Object *a = left->get_validated_object(); VariantInternalAccessor::get(r_ret) = a != nullptr; @@ -648,16 +539,11 @@ public: static void ptr_evaluate(const void *left, const void *right, void *r_ret) { PtrToArg::encode(PtrToArg::convert(left) != nullptr, r_ret); } - static Variant::Type get_return_type() { return Variant::BOOL; } + using ReturnType = bool; }; -class OperatorEvaluatorNotEqualNilObject { +class OperatorEvaluatorNotEqualNilObject : public CommonEvaluate { public: - static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - Object *b = p_right.get_validated_object(); - *r_ret = nullptr != b; - r_valid = true; - } static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) { Object *b = right->get_validated_object(); VariantInternalAccessor::get(r_ret) = nullptr != b; @@ -665,159 +551,112 @@ public: static void ptr_evaluate(const void *left, const void *right, void *r_ret) { PtrToArg::encode(nullptr != PtrToArg::convert(right), r_ret); } - static Variant::Type get_return_type() { return Variant::BOOL; } + using ReturnType = bool; }; template -class OperatorEvaluatorLess { +class OperatorEvaluatorLess : public CommonEvaluate> { public: - static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - 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) { 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); } - static Variant::Type get_return_type() { return Variant::BOOL; } + using ReturnType = bool; }; template -class OperatorEvaluatorLessEqual { +class OperatorEvaluatorLessEqual : public CommonEvaluate> { public: - static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - 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) { 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); } - static Variant::Type get_return_type() { return Variant::BOOL; } + using ReturnType = bool; }; template -class OperatorEvaluatorGreater { +class OperatorEvaluatorGreater : public CommonEvaluate> { public: - static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - 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) { 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); } - static Variant::Type get_return_type() { return Variant::BOOL; } + using ReturnType = bool; }; template -class OperatorEvaluatorGreaterEqual { +class OperatorEvaluatorGreaterEqual : public CommonEvaluate> { public: - static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - 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) { 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); } - static Variant::Type get_return_type() { return Variant::BOOL; } + using ReturnType = bool; }; template -class OperatorEvaluatorAnd { +class OperatorEvaluatorAnd : public CommonEvaluate> { public: - static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - 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) { 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); } - static Variant::Type get_return_type() { return Variant::BOOL; } + using ReturnType = bool; }; template -class OperatorEvaluatorOr { +class OperatorEvaluatorOr : public CommonEvaluate> { public: - static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - 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) { 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); } - static Variant::Type get_return_type() { return Variant::BOOL; } + using ReturnType = bool; }; #define XOR_OP(m_a, m_b) (((m_a) || (m_b)) && !((m_a) && (m_b))) template -class OperatorEvaluatorXor { +class OperatorEvaluatorXor : public CommonEvaluate> { public: _FORCE_INLINE_ static bool xor_op(const A &a, const B &b) { 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 = 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) { 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); } - static Variant::Type get_return_type() { return Variant::BOOL; } + using ReturnType = bool; }; template -class OperatorEvaluatorNot { +class OperatorEvaluatorNot : public CommonEvaluate> { public: - static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - 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) { 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); } - static Variant::Type get_return_type() { return Variant::BOOL; } + using ReturnType = bool; }; //// CUSTOM //// -class OperatorEvaluatorAddArray { +class OperatorEvaluatorAddArray : public CommonEvaluate { public: _FORCE_INLINE_ static void _add_arrays(Array &sum, const Array &array_a, const Array &array_b) { int asize = array_a.size(); @@ -835,14 +674,6 @@ public: sum[i + asize] = array_b[i]; } } - static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - 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; - r_valid = true; - } static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) { *r_ret = Array(); _add_arrays(VariantInternalAccessor::get(r_ret), VariantInternalAccessor::get(left), VariantInternalAccessor::get(right)); @@ -852,20 +683,12 @@ public: _add_arrays(ret, PtrToArg::convert(left), PtrToArg::convert(right)); PtrToArg::encode(ret, r_ret); } - static Variant::Type get_return_type() { return Variant::ARRAY; } + using ReturnType = Array; }; template -class OperatorEvaluatorAppendArray { +class OperatorEvaluatorAppendArray : public CommonEvaluate> { public: - static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - 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) { VariantInternalAccessor>::get(r_ret) = VariantInternalAccessor>::get(left); VariantInternalAccessor>::get(r_ret).append_array(VariantInternalAccessor>::get(right)); @@ -875,18 +698,12 @@ public: sum.append_array(PtrToArg>::convert(right)); PtrToArg>::encode(sum, r_ret); } - static Variant::Type get_return_type() { return GetTypeInfo>::VARIANT_TYPE; } + using ReturnType = Vector; }; template -class OperatorEvaluatorStringConcat { +class OperatorEvaluatorStringConcat : public CommonEvaluate> { public: - static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - 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(VariantInternalAccessor::get(left)); const String b(VariantInternalAccessor::get(right)); @@ -897,7 +714,7 @@ public: const String b(PtrToArg::convert(right)); PtrToArg::encode(a + b, r_ret); } - static Variant::Type get_return_type() { return Variant::STRING; } + using ReturnType = String; }; template @@ -1019,36 +836,26 @@ public: static Variant::Type get_return_type() { return Variant::STRING; } }; -template -class OperatorEvaluatorAlwaysTrue { +class OperatorEvaluatorAlwaysTrue : public CommonEvaluate { public: - static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - *r_ret = true; - r_valid = true; - } static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) { VariantInternalAccessor::get(r_ret) = true; } static void ptr_evaluate(const void *left, const void *right, void *r_ret) { PtrToArg::encode(true, r_ret); } - static Variant::Type get_return_type() { return Variant::BOOL; } + using ReturnType = bool; }; -template -class OperatorEvaluatorAlwaysFalse { +class OperatorEvaluatorAlwaysFalse : public CommonEvaluate { public: - static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - *r_ret = false; - r_valid = true; - } static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) { VariantInternalAccessor::get(r_ret) = false; } static void ptr_evaluate(const void *left, const void *right, void *r_ret) { PtrToArg::encode(false, r_ret); } - static Variant::Type get_return_type() { return Variant::BOOL; } + using ReturnType = bool; }; ///// OR /////// @@ -1106,13 +913,8 @@ _FORCE_INLINE_ static bool _operate_get_ptr_object(const void *p_ptr) { } #define OP_EVALUATOR(m_class_name, m_left, m_right, m_op) \ - class m_class_name { \ + class m_class_name : public CommonEvaluate { \ 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)); \ } \ @@ -1121,9 +923,7 @@ _FORCE_INLINE_ static bool _operate_get_ptr_object(const void *p_ptr) { 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; \ - } \ + using ReturnType = bool; \ }; // OR @@ -1261,64 +1061,48 @@ OP_EVALUATOR(OperatorEvaluatorObjectXFloatXor, object, float, _operate_xor) // object OP_EVALUATOR(OperatorEvaluatorObjectXObjectXor, object, object, _operate_xor) -class OperatorEvaluatorNotBool { +class OperatorEvaluatorNotBool : public CommonEvaluate { public: - static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - *r_ret = !VariantInternalAccessor::get(&p_left); - r_valid = true; - } static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) { 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); } - static Variant::Type get_return_type() { return Variant::BOOL; } + using ReturnType = bool; }; -class OperatorEvaluatorNotInt { +class OperatorEvaluatorNotInt : public CommonEvaluate { public: - static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - *r_ret = !VariantInternalAccessor::get(&p_left); - r_valid = true; - } static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) { 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); } - static Variant::Type get_return_type() { return Variant::BOOL; } + using ReturnType = bool; }; -class OperatorEvaluatorNotFloat { +class OperatorEvaluatorNotFloat : public CommonEvaluate { public: - static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - *r_ret = !VariantInternalAccessor::get(&p_left); - r_valid = true; - } static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) { 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); } - static Variant::Type get_return_type() { return Variant::BOOL; } + using ReturnType = bool; }; -class OperatorEvaluatorNotObject { +class OperatorEvaluatorNotObject : public CommonEvaluate { public: - static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - *r_ret = p_left.get_validated_object() == nullptr; - r_valid = true; - } static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) { 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); } - static Variant::Type get_return_type() { return Variant::BOOL; } + using ReturnType = bool; }; //// @@ -1327,15 +1111,8 @@ template class OperatorEvaluatorInStringFind; template -class OperatorEvaluatorInStringFind { +class OperatorEvaluatorInStringFind : public CommonEvaluate> { public: - static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - 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 = VariantInternalAccessor::get(left); const String &str_b = VariantInternalAccessor::get(right); @@ -1344,19 +1121,12 @@ public: 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); } - static Variant::Type get_return_type() { return Variant::BOOL; } + using ReturnType = bool; }; template -class OperatorEvaluatorInStringFind { +class OperatorEvaluatorInStringFind : public CommonEvaluate> { public: - static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - 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 = VariantInternalAccessor::get(left); const String str_b = VariantInternalAccessor::get(right).operator String(); @@ -1365,19 +1135,12 @@ public: 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); } - static Variant::Type get_return_type() { return Variant::BOOL; } + using ReturnType = bool; }; template -class OperatorEvaluatorInArrayFind { +class OperatorEvaluatorInArrayFind : public CommonEvaluate> { public: - static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - 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 = VariantInternalAccessor::get(left); const B &b = VariantInternalAccessor::get(right); @@ -1386,16 +1149,11 @@ public: 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); } - static Variant::Type get_return_type() { return Variant::BOOL; } + using ReturnType = bool; }; -class OperatorEvaluatorInArrayFindNil { +class OperatorEvaluatorInArrayFindNil : public CommonEvaluate { public: - static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - 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 = VariantInternalAccessor::get(right); VariantInternalAccessor::get(r_ret) = b.find(Variant()) != -1; @@ -1403,16 +1161,11 @@ public: static void ptr_evaluate(const void *left, const void *right, void *r_ret) { PtrToArg::encode(PtrToArg::convert(right).find(Variant()) != -1, r_ret); } - static Variant::Type get_return_type() { return Variant::BOOL; } + using ReturnType = bool; }; -class OperatorEvaluatorInArrayFindObject { +class OperatorEvaluatorInArrayFindObject : public CommonEvaluate { public: - static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - 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 = VariantInternalAccessor::get(right); VariantInternalAccessor::get(r_ret) = b.find(*left) != -1; @@ -1420,19 +1173,12 @@ public: 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); } - static Variant::Type get_return_type() { return Variant::BOOL; } + using ReturnType = bool; }; template -class OperatorEvaluatorInDictionaryHas { +class OperatorEvaluatorInDictionaryHas : public CommonEvaluate> { public: - static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - 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 = VariantInternalAccessor::get(right); const A &a = VariantInternalAccessor::get(left); @@ -1441,17 +1187,11 @@ public: static void ptr_evaluate(const void *left, const void *right, void *r_ret) { PtrToArg::encode(PtrToArg::convert(right).has(PtrToArg::convert(left)), r_ret); } - static Variant::Type get_return_type() { return Variant::BOOL; } + using ReturnType = bool; }; -class OperatorEvaluatorInDictionaryHasNil { +class OperatorEvaluatorInDictionaryHasNil : public CommonEvaluate { public: - static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - 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 = VariantInternalAccessor::get(right); VariantInternalAccessor::get(r_ret) = b.has(Variant()); @@ -1459,17 +1199,11 @@ public: static void ptr_evaluate(const void *left, const void *right, void *r_ret) { PtrToArg::encode(PtrToArg::convert(right).has(Variant()), r_ret); } - static Variant::Type get_return_type() { return Variant::BOOL; } + using ReturnType = bool; }; -class OperatorEvaluatorInDictionaryHasObject { +class OperatorEvaluatorInDictionaryHasObject : public CommonEvaluate { public: - static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { - 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 = VariantInternalAccessor::get(right); VariantInternalAccessor::get(r_ret) = b.has(*left); @@ -1477,7 +1211,7 @@ public: static void ptr_evaluate(const void *left, const void *right, void *r_ret) { PtrToArg::encode(PtrToArg::convert(right).has(PtrToArg::convert(left)), r_ret); } - static Variant::Type get_return_type() { return Variant::BOOL; } + using ReturnType = bool; }; class OperatorEvaluatorObjectHasPropertyString {