/*************************************************************************/ /* variant.h */ /*************************************************************************/ /* This file is part of: */ /* GODOT ENGINE */ /* https://godotengine.org */ /*************************************************************************/ /* Copyright (c) 2007-2018 Juan Linietsky, Ariel Manzur. */ /* Copyright (c) 2014-2018 Godot Engine contributors (cf. AUTHORS.md) */ /* */ /* Permission is hereby granted, free of charge, to any person obtaining */ /* a copy of this software and associated documentation files (the */ /* "Software"), to deal in the Software without restriction, including */ /* without limitation the rights to use, copy, modify, merge, publish, */ /* distribute, sublicense, and/or sell copies of the Software, and to */ /* permit persons to whom the Software is furnished to do so, subject to */ /* the following conditions: */ /* */ /* The above copyright notice and this permission notice shall be */ /* included in all copies or substantial portions of the Software. */ /* */ /* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ /* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ /* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ /* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ /* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ /* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ /*************************************************************************/ #ifndef VARIANT_H #define VARIANT_H /** @author Juan Linietsky <reduzio@gmail.com> */ #include "core/array.h" #include "core/color.h" #include "core/dictionary.h" #include "core/dvector.h" #include "core/io/ip_address.h" #include "core/math/aabb.h" #include "core/math/face3.h" #include "core/math/matrix3.h" #include "core/math/plane.h" #include "core/math/quat.h" #include "core/math/transform.h" #include "core/math/transform_2d.h" #include "core/math/vector3.h" #include "core/node_path.h" #include "core/ref_ptr.h" #include "core/rid.h" #include "core/ustring.h" class RefPtr; class Object; class Node; // helper class Control; // helper struct PropertyInfo; struct MethodInfo; typedef PoolVector<uint8_t> PoolByteArray; typedef PoolVector<int> PoolIntArray; typedef PoolVector<real_t> PoolRealArray; typedef PoolVector<String> PoolStringArray; typedef PoolVector<Vector2> PoolVector2Array; typedef PoolVector<Vector3> PoolVector3Array; typedef PoolVector<Color> PoolColorArray; class Variant { public: // If this changes the table in variant_op must be updated enum Type { NIL, // atomic types BOOL, INT, REAL, STRING, // math types VECTOR2, // 5 RECT2, VECTOR3, TRANSFORM2D, PLANE, QUAT, // 10 AABB, BASIS, TRANSFORM, // misc types COLOR, NODE_PATH, // 15 _RID, OBJECT, DICTIONARY, ARRAY, // arrays POOL_BYTE_ARRAY, // 20 POOL_INT_ARRAY, POOL_REAL_ARRAY, POOL_STRING_ARRAY, POOL_VECTOR2_ARRAY, POOL_VECTOR3_ARRAY, // 25 POOL_COLOR_ARRAY, VARIANT_MAX }; private: friend struct _VariantCall; // Variant takes 20 bytes when real_t is float, and 36 if double // it only allocates extra memory for aabb/matrix. Type type; struct ObjData { Object *obj; RefPtr ref; }; _FORCE_INLINE_ ObjData &_get_obj(); _FORCE_INLINE_ const ObjData &_get_obj() const; union { bool _bool; int64_t _int; double _real; Transform2D *_transform2d; ::AABB *_aabb; Basis *_basis; Transform *_transform; void *_ptr; //generic pointer uint8_t _mem[sizeof(ObjData) > (sizeof(real_t) * 4) ? sizeof(ObjData) : (sizeof(real_t) * 4)]; } _data; void reference(const Variant &p_variant); void clear(); public: _FORCE_INLINE_ Type get_type() const { return type; } static String get_type_name(Variant::Type p_type); static bool can_convert(Type p_type_from, Type p_type_to); static bool can_convert_strict(Type p_type_from, Type p_type_to); bool is_ref() const; _FORCE_INLINE_ bool is_num() const { return type == INT || type == REAL; }; _FORCE_INLINE_ bool is_array() const { return type >= ARRAY; }; bool is_shared() const; bool is_zero() const; bool is_one() const; operator bool() const; operator signed int() const; operator unsigned int() const; // this is the real one operator signed short() const; operator unsigned short() const; operator signed char() const; operator unsigned char() const; //operator long unsigned int() const; operator int64_t() const; operator uint64_t() const; #ifdef NEED_LONG_INT operator signed long() const; operator unsigned long() const; #endif operator CharType() const; operator float() const; operator double() const; operator String() const; operator StringName() const; operator Vector2() const; operator Rect2() const; operator Vector3() const; operator Plane() const; operator ::AABB() const; operator Quat() const; operator Basis() const; operator Transform() const; operator Transform2D() const; operator Color() const; operator NodePath() const; operator RefPtr() const; operator RID() const; operator Object *() const; operator Node *() const; operator Control *() const; operator Dictionary() const; operator Array() const; operator PoolVector<uint8_t>() const; operator PoolVector<int>() const; operator PoolVector<real_t>() const; operator PoolVector<String>() const; operator PoolVector<Vector3>() const; operator PoolVector<Color>() const; operator PoolVector<Plane>() const; operator PoolVector<Face3>() const; operator Vector<Variant>() const; operator Vector<uint8_t>() const; operator Vector<int>() const; operator Vector<real_t>() const; operator Vector<String>() const; operator Vector<StringName>() const; operator Vector<Vector3>() const; operator Vector<Color>() const; operator Vector<RID>() const; operator Vector<Vector2>() const; operator PoolVector<Vector2>() const; operator Vector<Plane>() const; // some core type enums to convert to operator Margin() const; operator Orientation() const; operator IP_Address() const; Variant(bool p_bool); Variant(signed int p_int); // real one Variant(unsigned int p_int); #ifdef NEED_LONG_INT Variant(signed long p_long); // real one Variant(unsigned long p_long); //Variant(long unsigned int p_long); #endif Variant(signed short p_short); // real one Variant(unsigned short p_short); Variant(signed char p_char); // real one Variant(unsigned char p_char); Variant(int64_t p_char); // real one Variant(uint64_t p_char); Variant(float p_float); Variant(double p_double); Variant(const String &p_string); Variant(const StringName &p_string); Variant(const char *const p_cstring); Variant(const CharType *p_wstring); Variant(const Vector2 &p_vector2); Variant(const Rect2 &p_rect2); Variant(const Vector3 &p_vector3); Variant(const Plane &p_plane); Variant(const ::AABB &p_aabb); Variant(const Quat &p_quat); Variant(const Basis &p_transform); Variant(const Transform2D &p_transform); Variant(const Transform &p_transform); Variant(const Color &p_color); Variant(const NodePath &p_path); Variant(const RefPtr &p_resource); Variant(const RID &p_rid); Variant(const Object *p_object); Variant(const Dictionary &p_dictionary); Variant(const Array &p_array); Variant(const PoolVector<Plane> &p_array); // helper Variant(const PoolVector<uint8_t> &p_raw_array); Variant(const PoolVector<int> &p_int_array); Variant(const PoolVector<real_t> &p_real_array); Variant(const PoolVector<String> &p_string_array); Variant(const PoolVector<Vector3> &p_vector3_array); Variant(const PoolVector<Color> &p_color_array); Variant(const PoolVector<Face3> &p_face_array); Variant(const Vector<Variant> &p_array); Variant(const Vector<uint8_t> &p_raw_array); Variant(const Vector<int> &p_int_array); Variant(const Vector<real_t> &p_real_array); Variant(const Vector<String> &p_string_array); Variant(const Vector<StringName> &p_string_array); Variant(const Vector<Vector3> &p_vector3_array); Variant(const Vector<Color> &p_color_array); Variant(const Vector<Plane> &p_array); // helper Variant(const Vector<RID> &p_array); // helper Variant(const Vector<Vector2> &p_array); // helper Variant(const PoolVector<Vector2> &p_array); // helper Variant(const IP_Address &p_address); // If this changes the table in variant_op must be updated enum Operator { //comparison OP_EQUAL, OP_NOT_EQUAL, OP_LESS, OP_LESS_EQUAL, OP_GREATER, OP_GREATER_EQUAL, //mathematic OP_ADD, OP_SUBTRACT, OP_MULTIPLY, OP_DIVIDE, OP_NEGATE, OP_POSITIVE, OP_MODULE, OP_STRING_CONCAT, //bitwise OP_SHIFT_LEFT, OP_SHIFT_RIGHT, OP_BIT_AND, OP_BIT_OR, OP_BIT_XOR, OP_BIT_NEGATE, //logic OP_AND, OP_OR, OP_XOR, OP_NOT, //containment OP_IN, OP_MAX }; static String get_operator_name(Operator p_op); static void evaluate(const Operator &p_op, const Variant &p_a, const Variant &p_b, Variant &r_ret, bool &r_valid); static _FORCE_INLINE_ Variant evaluate(const Operator &p_op, const Variant &p_a, const Variant &p_b) { bool valid = true; Variant res; evaluate(p_op, p_a, p_b, res, valid); return res; } void zero(); Variant duplicate(bool deep = false) const; static void blend(const Variant &a, const Variant &b, float c, Variant &r_dst); static void interpolate(const Variant &a, const Variant &b, float c, Variant &r_dst); struct CallError { enum Error { CALL_OK, CALL_ERROR_INVALID_METHOD, CALL_ERROR_INVALID_ARGUMENT, CALL_ERROR_TOO_MANY_ARGUMENTS, CALL_ERROR_TOO_FEW_ARGUMENTS, CALL_ERROR_INSTANCE_IS_NULL, }; Error error; int argument; Type expected; }; void call_ptr(const StringName &p_method, const Variant **p_args, int p_argcount, Variant *r_ret, CallError &r_error); Variant call(const StringName &p_method, const Variant **p_args, int p_argcount, CallError &r_error); Variant call(const StringName &p_method, const Variant &p_arg1 = Variant(), const Variant &p_arg2 = Variant(), const Variant &p_arg3 = Variant(), const Variant &p_arg4 = Variant(), const Variant &p_arg5 = Variant()); static String get_call_error_text(Object *p_base, const StringName &p_method, const Variant **p_argptrs, int p_argcount, const Variant::CallError &ce); static Variant construct(const Variant::Type, const Variant **p_args, int p_argcount, CallError &r_error, bool p_strict = true); void get_method_list(List<MethodInfo> *p_list) const; bool has_method(const StringName &p_method) const; static Vector<Variant::Type> get_method_argument_types(Variant::Type p_type, const StringName &p_method); static Vector<Variant> get_method_default_arguments(Variant::Type p_type, const StringName &p_method); static Variant::Type get_method_return_type(Variant::Type p_type, const StringName &p_method, bool *r_has_return = NULL); static Vector<StringName> get_method_argument_names(Variant::Type p_type, const StringName &p_method); static bool is_method_const(Variant::Type p_type, const StringName &p_method); void set_named(const StringName &p_index, const Variant &p_value, bool *r_valid = NULL); Variant get_named(const StringName &p_index, bool *r_valid = NULL) const; void set(const Variant &p_index, const Variant &p_value, bool *r_valid = NULL); Variant get(const Variant &p_index, bool *r_valid = NULL) const; bool in(const Variant &p_index, bool *r_valid = NULL) const; bool iter_init(Variant &r_iter, bool &r_valid) const; bool iter_next(Variant &r_iter, bool &r_valid) const; Variant iter_get(const Variant &r_iter, bool &r_valid) const; void get_property_list(List<PropertyInfo> *p_list) const; //argsVariant call() bool operator==(const Variant &p_variant) const; bool operator!=(const Variant &p_variant) const; bool operator<(const Variant &p_variant) const; uint32_t hash() const; bool hash_compare(const Variant &p_variant) const; bool booleanize() const; void static_assign(const Variant &p_variant); static void get_constructor_list(Variant::Type p_type, List<MethodInfo> *p_list); static void get_constants_for_type(Variant::Type p_type, List<StringName> *p_constants); static bool has_constant(Variant::Type p_type, const StringName &p_value); static Variant get_constant_value(Variant::Type p_type, const StringName &p_value, bool *r_valid = NULL); typedef String (*ObjectDeConstruct)(const Variant &p_object, void *ud); typedef void (*ObjectConstruct)(const String &p_text, void *ud, Variant &r_value); String get_construct_string() const; static void construct_from_string(const String &p_string, Variant &r_value, ObjectConstruct p_obj_construct = NULL, void *p_construct_ud = NULL); void operator=(const Variant &p_variant); // only this is enough for all the other types Variant(const Variant &p_variant); _FORCE_INLINE_ Variant() { type = NIL; } _FORCE_INLINE_ ~Variant() { if (type != Variant::NIL) clear(); } }; //typedef Dictionary Dictionary; no //typedef Array Array; Vector<Variant> varray(); Vector<Variant> varray(const Variant &p_arg1); Vector<Variant> varray(const Variant &p_arg1, const Variant &p_arg2); Vector<Variant> varray(const Variant &p_arg1, const Variant &p_arg2, const Variant &p_arg3); Vector<Variant> varray(const Variant &p_arg1, const Variant &p_arg2, const Variant &p_arg3, const Variant &p_arg4); Vector<Variant> varray(const Variant &p_arg1, const Variant &p_arg2, const Variant &p_arg3, const Variant &p_arg4, const Variant &p_arg5); struct VariantHasher { static _FORCE_INLINE_ uint32_t hash(const Variant &p_variant) { return p_variant.hash(); } }; struct VariantComparator { static _FORCE_INLINE_ bool compare(const Variant &p_lhs, const Variant &p_rhs) { return p_lhs.hash_compare(p_rhs); } }; Variant::ObjData &Variant::_get_obj() { return *reinterpret_cast<ObjData *>(&_data._mem[0]); } const Variant::ObjData &Variant::_get_obj() const { return *reinterpret_cast<const ObjData *>(&_data._mem[0]); } String vformat(const String &p_text, const Variant &p1 = Variant(), const Variant &p2 = Variant(), const Variant &p3 = Variant(), const Variant &p4 = Variant(), const Variant &p5 = Variant()); #endif