From e3b20a28a93c35ef33865d2f05ba6ac82fc170ae Mon Sep 17 00:00:00 2001 From: karroffel Date: Thu, 11 Jan 2018 21:26:37 +0100 Subject: [PATCH] Added Read and Write access for PoolArrays --- include/core/PoolArrays.hpp | 338 ++++++++++++++++++++++++++++++++++++ src/core/PoolArrays.cpp | 98 +++++++++++ 2 files changed, 436 insertions(+) diff --git a/include/core/PoolArrays.hpp b/include/core/PoolArrays.hpp index e10d8e97..17f08a62 100644 --- 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 @@ -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); diff --git a/src/core/PoolArrays.cpp b/src/core/PoolArrays.cpp index 38be75a8..40385746 100644 --- 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);