Added Read and Write access for PoolArrays

2018-01-11 21:26:37 +01:00 · 2018-01-11 21:26:37 +01:00 · e3b20a28a9
parent 5dac1b5887
commit e3b20a28a9
2 changed files with 436 additions and 0 deletions
--- a/include/core/PoolArrays.hpp
+++ b/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);
--- a/src/core/PoolArrays.cpp
+++ b/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);