Added Read and Write access for PoolArrays

include/core/PoolArrays.hpp

@@ -7,6 +7,7 @@
 #include "Color.hpp"
 #include "Vector2.hpp"
 #include "Vector3.hpp"
+#include "GodotGlobal.hpp"
 
 #include <gdnative/pool_arrays.h>
 
@@ -17,10 +18,59 @@ class Array;
 class PoolByteArray {
 	godot_pool_byte_array _godot_array;
 public:
+
+	class Read {
+
+		friend class PoolByteArray;
+		godot_pool_byte_array_read_access *_read_access;
+	public:
+		inline ~Read() {
+			godot::api->godot_pool_byte_array_read_access_destroy(_read_access);
+		}
+
+		inline const uint8_t *ptr() const {
+			return godot::api->godot_pool_byte_array_read_access_ptr(_read_access);
+		}
+
+		inline const uint8_t &operator[](int p_idx) const {
+			return ptr()[p_idx];
+		}
+
+		inline void operator=(const Read& p_other) {
+			godot::api->godot_pool_byte_array_read_access_operator_assign(_read_access, p_other._read_access);
+		}
+	};
+
+	class Write {
+		friend class PoolByteArray;
+		godot_pool_byte_array_write_access *_write_access;
+	public:
+
+		inline ~Write() {
+			godot::api->godot_pool_byte_array_write_access_destroy(_write_access);
+		}
+
+		inline uint8_t *ptr() const {
+			return godot::api->godot_pool_byte_array_write_access_ptr(_write_access);
+		}
+
+		inline uint8_t &operator[](int p_idx) const {
+			return ptr()[p_idx];
+		}
+
+		inline void operator=(const Write& p_other) {
+			godot::api->godot_pool_byte_array_write_access_operator_assign(_write_access, p_other._write_access);
+		}
+	};
+
 	PoolByteArray();
 
 	PoolByteArray(const Array& array);
 
+	Read read() const;
+
+	Write write();
+
 	void append(const uint8_t data);
 
 	void append_array(const PoolByteArray& array);
@@ -48,10 +98,58 @@ public:
 class PoolIntArray {
 	godot_pool_int_array _godot_array;
 public:
+
+	class Read {
+		friend class PoolIntArray;
+		godot_pool_int_array_read_access *_read_access;
+	public:
+		inline ~Read() {
+			godot::api->godot_pool_int_array_read_access_destroy(_read_access);
+		}
+
+		inline const int *ptr() const {
+			return godot::api->godot_pool_int_array_read_access_ptr(_read_access);
+		}
+
+		inline const int &operator[](int p_idx) const {
+			return ptr()[p_idx];
+		}
+
+		inline void operator=(const Read& p_other) {
+			godot::api->godot_pool_int_array_read_access_operator_assign(_read_access, p_other._read_access);
+		}
+	};
+
+	class Write {
+		friend class PoolIntArray;
+		godot_pool_int_array_write_access *_write_access;
+	public:
+
+		inline ~Write() {
+			godot::api->godot_pool_int_array_write_access_destroy(_write_access);
+		}
+
+		inline int *ptr() const {
+			return godot::api->godot_pool_int_array_write_access_ptr(_write_access);
+		}
+
+		inline int &operator[](int p_idx) const {
+			return ptr()[p_idx];
+		}
+
+		inline void operator=(const Write& p_other) {
+			godot::api->godot_pool_int_array_write_access_operator_assign(_write_access, p_other._write_access);
+		}
+	};
+
 	PoolIntArray();
 
 	PoolIntArray(const Array& array);
 
+	Read read() const;
+
+	Write write();
+
 	void append(const int data);
 
 	void append_array(const PoolIntArray& array);
@@ -79,10 +177,58 @@ public:
 class PoolRealArray {
 	godot_pool_real_array _godot_array;
 public:
+
+	class Read {
+		friend class PoolRealArray;
+		godot_pool_real_array_read_access *_read_access;
+	public:
+		inline ~Read() {
+			godot::api->godot_pool_real_array_read_access_destroy(_read_access);
+		}
+
+		inline const real_t *ptr() const {
+			return godot::api->godot_pool_real_array_read_access_ptr(_read_access);
+		}
+
+		inline const real_t &operator[](int p_idx) const {
+			return ptr()[p_idx];
+		}
+
+		inline void operator=(const Read& p_other) {
+			godot::api->godot_pool_real_array_read_access_operator_assign(_read_access, p_other._read_access);
+		}
+	};
+
+	class Write {
+		friend class PoolRealArray;
+		godot_pool_real_array_write_access *_write_access;
+	public:
+
+		inline ~Write() {
+			godot::api->godot_pool_real_array_write_access_destroy(_write_access);
+		}
+
+		inline real_t *ptr() const {
+			return godot::api->godot_pool_real_array_write_access_ptr(_write_access);
+		}
+
+		inline real_t &operator[](int p_idx) const {
+			return ptr()[p_idx];
+		}
+
+		inline void operator=(const Write& p_other) {
+			godot::api->godot_pool_real_array_write_access_operator_assign(_write_access, p_other._write_access);
+		}
+	};
+
 	PoolRealArray();
 
 	PoolRealArray(const Array& array);
 
+	Read read() const;
+
+	Write write();
+
 	void append(const real_t data);
 
 	void append_array(const PoolRealArray& array);
@@ -110,10 +256,58 @@ public:
 class PoolStringArray {
 	godot_pool_string_array _godot_array;
 public:
+
+	class Read {
+		friend class PoolStringArray;
+		godot_pool_string_array_read_access *_read_access;
+	public:
+		inline ~Read() {
+			godot::api->godot_pool_string_array_read_access_destroy(_read_access);
+		}
+
+		inline const String *ptr() const {
+			return (const String *) godot::api->godot_pool_string_array_read_access_ptr(_read_access);
+		}
+
+		inline const String &operator[](int p_idx) const {
+			return ptr()[p_idx];
+		}
+
+		inline void operator=(const Read& p_other) {
+			godot::api->godot_pool_string_array_read_access_operator_assign(_read_access, p_other._read_access);
+		}
+	};
+
+	class Write {
+		friend class PoolStringArray;
+		godot_pool_string_array_write_access *_write_access;
+	public:
+
+		inline ~Write() {
+			godot::api->godot_pool_string_array_write_access_destroy(_write_access);
+		}
+
+		inline String *ptr() const {
+			return (String *) godot::api->godot_pool_string_array_write_access_ptr(_write_access);
+		}
+
+		inline String &operator[](int p_idx) const {
+			return ptr()[p_idx];
+		}
+
+		inline void operator=(const Write& p_other) {
+			godot::api->godot_pool_string_array_write_access_operator_assign(_write_access, p_other._write_access);
+		}
+	};
+
 	PoolStringArray();
 
 	PoolStringArray(const Array& array);
 
+	Read read() const;
+
+	Write write();
+
 	void append(const String& data);
 
 	void append_array(const PoolStringArray& array);
@@ -142,10 +336,58 @@ public:
 class PoolVector2Array {
 	godot_pool_vector2_array _godot_array;
 public:
+
+	class Read {
+		friend class PoolVector2Array;
+		godot_pool_vector2_array_read_access *_read_access;
+	public:
+		inline ~Read() {
+			godot::api->godot_pool_vector2_array_read_access_destroy(_read_access);
+		}
+
+		inline const Vector2 *ptr() const {
+			return (const Vector2 *) godot::api->godot_pool_vector2_array_read_access_ptr(_read_access);
+		}
+
+		inline const Vector2 &operator[](int p_idx) const {
+			return ptr()[p_idx];
+		}
+
+		inline void operator=(const Read& p_other) {
+			godot::api->godot_pool_vector2_array_read_access_operator_assign(_read_access, p_other._read_access);
+		}
+	};
+
+	class Write {
+		friend class PoolVector2Array;
+		godot_pool_vector2_array_write_access *_write_access;
+	public:
+
+		inline ~Write() {
+			godot::api->godot_pool_vector2_array_write_access_destroy(_write_access);
+		}
+
+		inline Vector2 *ptr() const {
+			return (Vector2 *) godot::api->godot_pool_vector2_array_write_access_ptr(_write_access);
+		}
+
+		inline Vector2 &operator[](int p_idx) const {
+			return ptr()[p_idx];
+		}
+
+		inline void operator=(const Write& p_other) {
+			godot::api->godot_pool_vector2_array_write_access_operator_assign(_write_access, p_other._write_access);
+		}
+	};
+
 	PoolVector2Array();
 
 	PoolVector2Array(const Array& array);
 
+	Read read() const;
+
+	Write write();
+
 	void append(const Vector2& data);
 
 	void append_array(const PoolVector2Array& array);
@@ -173,10 +415,58 @@ public:
 class PoolVector3Array {
 	godot_pool_vector3_array _godot_array;
 public:
+
+	class Read {
+		friend class PoolVector3Array;
+		godot_pool_vector3_array_read_access *_read_access;
+	public:
+		inline ~Read() {
+			godot::api->godot_pool_vector3_array_read_access_destroy(_read_access);
+		}
+
+		inline const Vector3 *ptr() const {
+			return (const Vector3 *) godot::api->godot_pool_vector3_array_read_access_ptr(_read_access);
+		}
+
+		inline const Vector3 &operator[](int p_idx) const {
+			return ptr()[p_idx];
+		}
+
+		inline void operator=(const Read& p_other) {
+			godot::api->godot_pool_vector3_array_read_access_operator_assign(_read_access, p_other._read_access);
+		}
+	};
+
+	class Write {
+		friend class PoolVector3Array;
+		godot_pool_vector3_array_write_access *_write_access;
+	public:
+
+		inline ~Write() {
+			godot::api->godot_pool_vector3_array_write_access_destroy(_write_access);
+		}
+
+		inline Vector3 *ptr() const {
+			return (Vector3 *) godot::api->godot_pool_vector3_array_write_access_ptr(_write_access);
+		}
+
+		inline Vector3 &operator[](int p_idx) const {
+			return ptr()[p_idx];
+		}
+
+		inline void operator=(const Write& p_other) {
+			godot::api->godot_pool_vector3_array_write_access_operator_assign(_write_access, p_other._write_access);
+		}
+	};
+
 	PoolVector3Array();
 
 	PoolVector3Array(const Array& array);
 
+	Read read() const;
+
+	Write write();
+
 	void append(const Vector3& data);
 
 	void append_array(const PoolVector3Array& array);
@@ -204,10 +494,58 @@ public:
 class PoolColorArray {
 	godot_pool_color_array _godot_array;
 public:
+
+	class Read {
+		friend class PoolColorArray;
+		godot_pool_color_array_read_access *_read_access;
+	public:
+		inline ~Read() {
+			godot::api->godot_pool_color_array_read_access_destroy(_read_access);
+		}
+
+		inline const Color *ptr() const {
+			return (const Color *) godot::api->godot_pool_color_array_read_access_ptr(_read_access);
+		}
+
+		inline const Color &operator[](int p_idx) const {
+			return ptr()[p_idx];
+		}
+
+		inline void operator=(const Read& p_other) {
+			godot::api->godot_pool_color_array_read_access_operator_assign(_read_access, p_other._read_access);
+		}
+	};
+
+	class Write {
+		friend class PoolColorArray;
+		godot_pool_color_array_write_access *_write_access;
+	public:
+
+		inline ~Write() {
+			godot::api->godot_pool_color_array_write_access_destroy(_write_access);
+		}
+
+		inline Color *ptr() const {
+			return (Color *) godot::api->godot_pool_color_array_write_access_ptr(_write_access);
+		}
+
+		inline Color &operator[](int p_idx) const {
+			return ptr()[p_idx];
+		}
+
+		inline void operator=(const Write& p_other) {
+			godot::api->godot_pool_color_array_write_access_operator_assign(_write_access, p_other._write_access);
+		}
+	};
+
 	PoolColorArray();
 
 	PoolColorArray(const Array& array);
 
+	Read read() const;
+
+	Write write();
+
 	void append(const Color& data);
 
 	void append_array(const PoolColorArray& array);

src/core/PoolArrays.cpp

@@ -20,6 +20,20 @@ PoolByteArray::PoolByteArray(const Array& array)
 	godot::api->godot_pool_byte_array_new_with_array(&_godot_array, (godot_array *) &array);
 }
 
+PoolByteArray::Read PoolByteArray::read() const
+{
+	Read read;
+	read._read_access = godot::api->godot_pool_byte_array_read(&_godot_array);
+	return read;
+}
+
+PoolByteArray::Write PoolByteArray::write()
+{
+	Write write;
+	write._write_access = godot::api->godot_pool_byte_array_write(&_godot_array);
+	return write;
+}
+
 void PoolByteArray::append(const uint8_t data)
 {
 	godot::api->godot_pool_byte_array_append(&_godot_array, data);
@@ -88,6 +102,20 @@ PoolIntArray::PoolIntArray(const Array& array)
 	godot::api->godot_pool_int_array_new_with_array(&_godot_array, (godot_array *) &array);
 }
 
+PoolIntArray::Read PoolIntArray::read() const
+{
+	Read read;
+	read._read_access = godot::api->godot_pool_int_array_read(&_godot_array);
+	return read;
+}
+
+PoolIntArray::Write PoolIntArray::write()
+{
+	Write write;
+	write._write_access = godot::api->godot_pool_int_array_write(&_godot_array);
+	return write;
+}
+
 void PoolIntArray::append(const int data)
 {
 	godot::api->godot_pool_int_array_append(&_godot_array, data);
@@ -150,6 +178,20 @@ PoolRealArray::PoolRealArray()
 	godot::api->godot_pool_real_array_new(&_godot_array);
 }
 
+PoolRealArray::Read PoolRealArray::read() const
+{
+	Read read;
+	read._read_access = godot::api->godot_pool_real_array_read(&_godot_array);
+	return read;
+}
+
+PoolRealArray::Write PoolRealArray::write()
+{
+	Write write;
+	write._write_access = godot::api->godot_pool_real_array_write(&_godot_array);
+	return write;
+}
+
 PoolRealArray::PoolRealArray(const Array& array)
 {
 	godot::api->godot_pool_real_array_new_with_array(&_godot_array, (godot_array *) &array);
@@ -223,6 +265,20 @@ PoolStringArray::PoolStringArray(const Array& array)
 	godot::api->godot_pool_string_array_new_with_array(&_godot_array, (godot_array *) &array);
 }
 
+PoolStringArray::Read PoolStringArray::read() const
+{
+	Read read;
+	read._read_access = godot::api->godot_pool_string_array_read(&_godot_array);
+	return read;
+}
+
+PoolStringArray::Write PoolStringArray::write()
+{
+	Write write;
+	write._write_access = godot::api->godot_pool_string_array_write(&_godot_array);
+	return write;
+}
+
 void PoolStringArray::append(const String& data)
 {
 	godot::api->godot_pool_string_array_append(&_godot_array, (godot_string *) &data);
@@ -295,6 +351,20 @@ PoolVector2Array::PoolVector2Array(const Array& array)
 	godot::api->godot_pool_vector2_array_new_with_array(&_godot_array, (godot_array *) &array);
 }
 
+PoolVector2Array::Read PoolVector2Array::read() const
+{
+	Read read;
+	read._read_access = godot::api->godot_pool_vector2_array_read(&_godot_array);
+	return read;
+}
+
+PoolVector2Array::Write PoolVector2Array::write()
+{
+	Write write;
+	write._write_access = godot::api->godot_pool_vector2_array_write(&_godot_array);
+	return write;
+}
+
 void PoolVector2Array::append(const Vector2& data)
 {
 	godot::api->godot_pool_vector2_array_append(&_godot_array, (godot_vector2 *) &data);
@@ -365,6 +435,20 @@ PoolVector3Array::PoolVector3Array(const Array& array)
 	godot::api->godot_pool_vector3_array_new_with_array(&_godot_array, (godot_array *) &array);
 }
 
+PoolVector3Array::Read PoolVector3Array::read() const
+{
+	Read read;
+	read._read_access = godot::api->godot_pool_vector3_array_read(&_godot_array);
+	return read;
+}
+
+PoolVector3Array::Write PoolVector3Array::write()
+{
+	Write write;
+	write._write_access = godot::api->godot_pool_vector3_array_write(&_godot_array);
+	return write;
+}
+
 void PoolVector3Array::append(const Vector3& data)
 {
 	godot::api->godot_pool_vector3_array_append(&_godot_array, (godot_vector3 *) &data);
@@ -434,6 +518,20 @@ PoolColorArray::PoolColorArray(const Array& array)
 	godot::api->godot_pool_color_array_new_with_array(&_godot_array, (godot_array *) &array);
 }
 
+PoolColorArray::Read PoolColorArray::read() const
+{
+	Read read;
+	read._read_access = godot::api->godot_pool_color_array_read(&_godot_array);
+	return read;
+}
+
+PoolColorArray::Write PoolColorArray::write()
+{
+	Write write;
+	write._write_access = godot::api->godot_pool_color_array_write(&_godot_array);
+	return write;
+}
+
 void PoolColorArray::append(const Color& data)
 {
 	godot::api->godot_pool_color_array_append(&_godot_array, (godot_color *) &data);