Add support for initializer_list to Array and TypedArray

Author: tomfull123

binding_generator.py

@@ -541,7 +541,7 @@ def generate_builtin_class_header(builtin_api, size, used_classes, fully_used_cl
         result.append("#include <godot_cpp/variant/vector4.hpp>")
         result.append("")
 
-    if is_packed_array(class_name):
+    if is_packed_array(class_name) or class_name == "Array":
         result.append("#include <godot_cpp/core/error_macros.hpp>")
         result.append("#include <initializer_list>")
         result.append("")
@@ -907,6 +907,53 @@ def generate_builtin_class_header(builtin_api, size, used_classes, fully_used_cl
         result.append("\tVariant &operator[](int64_t p_index);")
         result.append("\tvoid set_typed(uint32_t p_type, const StringName &p_class_name, const Variant &p_script);")
         result.append("\tvoid _ref(const Array &p_from) const;")
+        result.append("""
+	struct Iterator {
+		_FORCE_INLINE_ Variant &operator*() const;
+		_FORCE_INLINE_ Variant *operator->() const;
+		_FORCE_INLINE_ Iterator &operator++();
+		_FORCE_INLINE_ Iterator &operator--();
+
+		_FORCE_INLINE_ bool operator==(const Iterator &b) const { return elem_ptr == b.elem_ptr; }
+		_FORCE_INLINE_ bool operator!=(const Iterator &b) const { return elem_ptr != b.elem_ptr; }
+
+		Iterator(Variant *p_ptr) { elem_ptr = p_ptr; }
+		Iterator() {}
+		Iterator(const Iterator &p_it) { elem_ptr = p_it.elem_ptr; }
+
+	private:
+		Variant *elem_ptr = nullptr;
+	};
+
+	struct ConstIterator {
+		_FORCE_INLINE_ const Variant &operator*() const;
+		_FORCE_INLINE_ const Variant *operator->() const;
+		_FORCE_INLINE_ ConstIterator &operator++();
+		_FORCE_INLINE_ ConstIterator &operator--();
+
+		_FORCE_INLINE_ bool operator==(const ConstIterator &b) const { return elem_ptr == b.elem_ptr; }
+		_FORCE_INLINE_ bool operator!=(const ConstIterator &b) const { return elem_ptr != b.elem_ptr; }
+
+		ConstIterator(const Variant *p_ptr) { elem_ptr = p_ptr; }
+		ConstIterator() {}
+		ConstIterator(const ConstIterator &p_it) { elem_ptr = p_it.elem_ptr; }
+
+	private:
+		const Variant *elem_ptr = nullptr;
+	};
+
+	_FORCE_INLINE_ Iterator begin();
+	_FORCE_INLINE_ Iterator end();
+
+	_FORCE_INLINE_ ConstIterator begin() const;
+	_FORCE_INLINE_ ConstIterator end() const;
+	""")
+        result.append("\t_FORCE_INLINE_ Array(std::initializer_list<Variant> p_init);")
+        result.append("")
+        result.append("\tprotected:")
+        result.append("")
+        result.append("\tconst Variant *ptr() const;")
+        result.append("\tVariant *ptrw();")
 
     if class_name == "Dictionary":
         result.append("\tconst Variant &operator[](const Variant &p_key) const;")

include/godot_cpp/variant/typed_array.hpp

@@ -53,6 +53,8 @@ class TypedArray : public Array {
 			assign(p_array);
 		}
 	}
+	_FORCE_INLINE_ TypedArray(std::initializer_list<Variant> p_init) :
+			TypedArray(Array(p_init)) {}
 	_FORCE_INLINE_ TypedArray() {
 		set_typed(Variant::OBJECT, T::get_class_static(), Variant());
 	}
@@ -68,6 +70,9 @@ class TypedArray : public Array {
 			ERR_FAIL_COND_MSG(!is_same_typed(p_array), "Cannot assign an array with a different element type."); \
 			_ref(p_array);                                                                                       \
 		}                                                                                                        \
+		_FORCE_INLINE_ TypedArray(std::initializer_list<Variant> p_init) :                                       \
+				Array(Array(p_init), m_variant_type, StringName(), Variant()) {                                  \
+		}                                                                                                        \
 		_FORCE_INLINE_ TypedArray(const Variant &p_variant) :                                                    \
 				TypedArray(Array(p_variant)) {                                                                   \
 		}                                                                                                        \

include/godot_cpp/variant/variant.hpp

@@ -357,6 +357,65 @@ String vformat(const String &p_text, const VarArgs... p_args) {
 	return p_text % args_array;
 }
 
+Variant &Array::Iterator::operator*() const {
+	return *elem_ptr;
+}
+
+Variant *Array::Iterator::operator->() const {
+	return elem_ptr;
+}
+
+Array::Iterator &Array::Iterator::operator++() {
+	elem_ptr++;
+	return *this;
+}
+
+Array::Iterator &Array::Iterator::operator--() {
+	elem_ptr--;
+	return *this;
+}
+
+const Variant &Array::ConstIterator::operator*() const {
+	return *elem_ptr;
+}
+
+const Variant *Array::ConstIterator::operator->() const {
+	return elem_ptr;
+}
+
+Array::ConstIterator &Array::ConstIterator::operator++() {
+	elem_ptr++;
+	return *this;
+}
+
+Array::ConstIterator &Array::ConstIterator::operator--() {
+	elem_ptr--;
+	return *this;
+}
+
+Array::Iterator Array::begin() {
+	return Array::Iterator(ptrw());
+}
+Array::Iterator Array::end() {
+	return Array::Iterator(ptrw() + size());
+}
+
+Array::ConstIterator Array::begin() const {
+	return Array::ConstIterator(ptr());
+}
+Array::ConstIterator Array::end() const {
+	return Array::ConstIterator(ptr() + size());
+}
+
+Array::Array(std::initializer_list<Variant> p_init) {
+	ERR_FAIL_COND(resize(p_init.size()) != 0);
+
+	size_t i = 0;
+	for (const Variant &element : p_init) {
+		set(i++, element);
+	}
+}
+
 #include <godot_cpp/variant/builtin_vararg_methods.hpp>
 
 #ifdef REAL_T_IS_DOUBLE