Rename TypedArray -> PoolArray

Author: Bromeon

gdnative-core/src/core_types/access.rs

@@ -50,12 +50,12 @@ pub unsafe trait Guard: private::Sealed {
 pub unsafe trait WritePtr: Guard + private::Sealed {}
 
 pub(crate) mod private {
-    use crate::core_types::typed_array::Element;
+    use crate::core_types::pool_array::Element;
 
     pub trait Sealed {}
 
-    impl<'a, T: Element> Sealed for crate::core_types::typed_array::ReadGuard<'a, T> {}
-    impl<'a, T: Element> Sealed for crate::core_types::typed_array::WriteGuard<'a, T> {}
+    impl<'a, T: Element> Sealed for crate::core_types::pool_array::ReadGuard<'a, T> {}
+    impl<'a, T: Element> Sealed for crate::core_types::pool_array::WriteGuard<'a, T> {}
 }
 
 impl<G: Guard> MaybeUnaligned<G> {

gdnative-core/src/core_types/byte_array.rs

@@ -1,7 +1,7 @@
-use crate::core_types::TypedArray;
+use crate::core_types::PoolArray;
 
 /// A reference-counted vector of `u8` that uses Godot's pool allocator.
-pub type ByteArray = TypedArray<u8>;
+pub type ByteArray = PoolArray<u8>;
 
 godot_test!(
     test_byte_array_access {

gdnative-core/src/core_types/color_array.rs

@@ -1,8 +1,8 @@
 use crate::core_types::Color;
-use crate::core_types::TypedArray;
+use crate::core_types::PoolArray;
 
 /// A reference-counted vector of `Color` that uses Godot's pool allocator.
-pub type ColorArray = TypedArray<Color>;
+pub type ColorArray = PoolArray<Color>;
 
 godot_test!(
     test_color_array_access {

gdnative-core/src/core_types/float32_array.rs

@@ -1,7 +1,7 @@
-use crate::core_types::TypedArray;
+use crate::core_types::PoolArray;
 
 /// A reference-counted vector of `f32` that uses Godot's pool allocator.
-pub type Float32Array = TypedArray<f32>;
+pub type Float32Array = PoolArray<f32>;
 
 godot_test!(
     test_float32_array_access {

gdnative-core/src/core_types/int32_array.rs

@@ -1,7 +1,7 @@
-use crate::core_types::TypedArray;
+use crate::core_types::PoolArray;
 
 /// A reference-counted vector of `i32` that uses Godot's pool allocator.
-pub type Int32Array = TypedArray<i32>;
+pub type Int32Array = PoolArray<i32>;
 
 godot_test!(
     test_int32_array_access {

gdnative-core/src/core_types/mod.rs

@@ -16,13 +16,13 @@ mod error;
 mod float32_array;
 mod int32_array;
 mod node_path;
+mod pool_array;
 mod quat;
 mod rect2;
 mod rid;
 mod string;
 mod string_array;
 mod transform2d;
-mod typed_array;
 mod variant;
 mod variant_array;
 mod vector2;
@@ -40,13 +40,13 @@ pub use float32_array::*;
 pub use geom::*;
 pub use int32_array::*;
 pub use node_path::*;
+pub use pool_array::*; // TODO rename Element to something more specific
 pub use quat::*;
 pub use rect2::*;
 pub use rid::*;
 pub use string::*;
 pub use string_array::*;
 pub use transform2d::*;
-pub use typed_array::*; // TODO rename Element to something more specific
 pub use variant::*;
 pub use variant_array::*;
 pub use vector2::*;

gdnative-core/src/core_types/typed_array.rs renamed to gdnative-core/src/core_types/pool_array.rs

@@ -12,7 +12,7 @@ use crate::private::get_api;
 /// A reference-counted CoW typed vector using Godot's pool allocator, generic over possible
 /// element types.
 ///
-/// `TypedArray` unifies all the different `Pool*Array` types exported by Godot. It can be used
+/// `PoolArray` unifies all the different `Pool*Array` types exported by Godot. It can be used
 /// in exported Rust methods as parameter and return types, as well as in exported properties.
 /// However, it is limited to the element types, for which a `Pool*Array` exists in GDScript,
 /// i.e. it cannot contain user-defined types.
@@ -25,7 +25,7 @@ use crate::private::get_api;
 /// When using this type, it's generally better to perform mutations in batch using `write`,
 /// or the `append` methods, as opposed to `push` or `set`, because the latter ones trigger
 /// CoW behavior each time they are called.
-pub struct TypedArray<T: Element> {
+pub struct PoolArray<T: Element> {
     inner: T::SysArray,
 }
 
@@ -36,7 +36,7 @@ pub type Read<'a, T> = Aligned<ReadGuard<'a, T>>;
 /// as opposed to every time with methods like `push`.
 pub type Write<'a, T> = Aligned<WriteGuard<'a, T>>;
 
-impl<T: Element> Drop for TypedArray<T> {
+impl<T: Element> Drop for PoolArray<T> {
     #[inline]
     fn drop(&mut self) {
         unsafe {
@@ -45,47 +45,47 @@ impl<T: Element> Drop for TypedArray<T> {
     }
 }
 
-impl<T: Element> Default for TypedArray<T> {
+impl<T: Element> Default for PoolArray<T> {
     #[inline]
     fn default() -> Self {
-        TypedArray::new()
+        PoolArray::new()
     }
 }
 
-impl<T: Element + fmt::Debug> fmt::Debug for TypedArray<T> {
+impl<T: Element + fmt::Debug> fmt::Debug for PoolArray<T> {
     #[inline]
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_list().entries(self.read().iter()).finish()
     }
 }
 
-impl<T: Element> Clone for TypedArray<T> {
+impl<T: Element> Clone for PoolArray<T> {
     #[inline]
     fn clone(&self) -> Self {
         self.new_ref()
     }
 }
 
-impl<T: Element> NewRef for TypedArray<T> {
+impl<T: Element> NewRef for PoolArray<T> {
     /// Creates a new reference to this reference-counted instance.
     #[inline]
     fn new_ref(&self) -> Self {
         unsafe {
             let mut inner = T::SysArray::default();
             (T::new_copy_fn(get_api()))(&mut inner, self.sys());
-            TypedArray { inner }
+            PoolArray { inner }
         }
     }
 }
 
-impl<T: Element> TypedArray<T> {
+impl<T: Element> PoolArray<T> {
     /// Creates an empty array.
     #[inline]
     pub fn new() -> Self {
         unsafe {
             let mut inner = T::SysArray::default();
             (T::new_fn(get_api()))(&mut inner);
-            TypedArray { inner }
+            PoolArray { inner }
         }
     }
 
@@ -95,11 +95,11 @@ impl<T: Element> TypedArray<T> {
         unsafe {
             let mut inner = T::SysArray::default();
             (T::new_with_array_fn(get_api()))(&mut inner, array.sys());
-            TypedArray { inner }
+            PoolArray { inner }
         }
     }
 
-    /// Creates a `TypedArray` moving elements from `src`.
+    /// Creates a `PoolArray` moving elements from `src`.
     #[inline]
     pub fn from_vec(mut src: Vec<T>) -> Self {
         let mut arr = Self::new();
@@ -261,12 +261,12 @@ impl<T: Element> TypedArray<T> {
     #[doc(hidden)]
     #[inline]
     pub fn from_sys(sys: T::SysArray) -> Self {
-        TypedArray { inner: sys }
+        PoolArray { inner: sys }
     }
 }
 
-impl<T: Element + Copy> TypedArray<T> {
-    /// Creates a new `TypedArray` by copying from `src`.
+impl<T: Element + Copy> PoolArray<T> {
+    /// Creates a new `PoolArray` by copying from `src`.
     ///
     /// # Panics
     ///
@@ -297,23 +297,23 @@ impl<T: Element + Copy> TypedArray<T> {
 // `FromIterator` and `Extend` implementations collect into `Vec` first, because Rust `Vec`s
 // are better at handling unknown lengths than the Godot arrays (`push` CoWs every time!)
 
-impl<T: Element> FromIterator<T> for TypedArray<T> {
+impl<T: Element> FromIterator<T> for PoolArray<T> {
     #[inline]
     fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
         let vec = iter.into_iter().collect::<Vec<_>>();
         Self::from_vec(vec)
     }
 }
 
-impl<T: Element> Extend<T> for TypedArray<T> {
+impl<T: Element> Extend<T> for PoolArray<T> {
     #[inline]
     fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I) {
         let mut vec = iter.into_iter().collect::<Vec<_>>();
         self.append_vec(&mut vec);
     }
 }
 
-impl<T: Element + PartialEq> PartialEq for TypedArray<T> {
+impl<T: Element + PartialEq> PartialEq for PoolArray<T> {
     #[inline]
     fn eq(&self, other: &Self) -> bool {
         if self.len() != other.len() {
@@ -326,7 +326,7 @@ impl<T: Element + PartialEq> PartialEq for TypedArray<T> {
         left.as_slice() == right.as_slice()
     }
 }
-impl<T: Element + Eq> Eq for TypedArray<T> {}
+impl<T: Element + Eq> Eq for PoolArray<T> {}
 
 /// RAII read guard.
 pub struct ReadGuard<'a, T: Element> {
@@ -437,7 +437,7 @@ impl<'a, T: Element> Drop for WriteGuard<'a, T> {
 }
 
 macros::decl_typed_array_element! {
-    /// Trait for element types that can be contained in `TypedArray`. This trait is sealed
+    /// Trait for element types that can be contained in `PoolArray`. This trait is sealed
     /// and has no public interface.
     pub trait Element: private::Sealed { .. }
 }
@@ -495,7 +495,7 @@ mod serialize {
     use std::fmt::Formatter;
     use std::marker::PhantomData;
 
-    impl<T: Serialize + Element> Serialize for TypedArray<T> {
+    impl<T: Serialize + Element> Serialize for PoolArray<T> {
         #[inline]
         fn serialize<S>(&self, ser: S) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
         where
@@ -510,15 +510,15 @@ mod serialize {
         }
     }
 
-    impl<'de, T: Deserialize<'de> + Element> Deserialize<'de> for TypedArray<T> {
+    impl<'de, T: Deserialize<'de> + Element> Deserialize<'de> for PoolArray<T> {
         #[inline]
         fn deserialize<D>(deserializer: D) -> Result<Self, <D as Deserializer<'de>>::Error>
         where
             D: Deserializer<'de>,
         {
             struct TypedArrayVisitor<T>(PhantomData<T>);
             impl<'de, T: Deserialize<'de> + Element> Visitor<'de> for TypedArrayVisitor<T> {
-                type Value = TypedArray<T>;
+                type Value = PoolArray<T>;
 
                 fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
                     formatter.write_str(std::any::type_name::<Self::Value>())

gdnative-core/src/core_types/string_array.rs

@@ -1,8 +1,8 @@
 use crate::core_types::GodotString;
-use crate::core_types::TypedArray;
+use crate::core_types::PoolArray;
 
 /// A reference-counted vector of `GodotString` that uses Godot's pool allocator.
-pub type StringArray = TypedArray<GodotString>;
+pub type StringArray = PoolArray<GodotString>;
 
 godot_test!(
     test_string_array_access {

gdnative-core/src/core_types/variant.rs

@@ -1072,7 +1072,7 @@ pub trait OwnedToVariant {
 ///
 /// This means that for all values `a` and `b`, `a == b` is equivalent to
 /// `a.to_variant() == b.to_variant()`. Most of the time, this means that `to_variant` must
-/// return a "value" type, such as a primitive `i32`, a `GodotString`, or a `TypedArray`.
+/// return a "value" type, such as a primitive `i32`, a `GodotString`, or a `PoolArray`.
 ///
 /// This is mostly useful as a bound for `Dictionary` keys, where the difference between Rust's
 /// structural equality and Godot's referential equality semantics can lead to surprising
@@ -1597,7 +1597,7 @@ from_variant_from_sys!(
     impl FromVariant for Dictionary<Shared> as Dictionary : godot_variant_as_dictionary;
 );
 
-impl<T: crate::core_types::typed_array::Element> ToVariant for TypedArray<T> {
+impl<T: crate::core_types::pool_array::Element> ToVariant for PoolArray<T> {
     #[inline]
     fn to_variant(&self) -> Variant {
         unsafe {
@@ -1608,9 +1608,9 @@ impl<T: crate::core_types::typed_array::Element> ToVariant for TypedArray<T> {
         }
     }
 }
-impl<T: crate::core_types::typed_array::Element + Eq> ToVariantEq for TypedArray<T> {}
+impl<T: crate::core_types::pool_array::Element + Eq> ToVariantEq for PoolArray<T> {}
 
-impl<T: crate::core_types::typed_array::Element> FromVariant for TypedArray<T> {
+impl<T: crate::core_types::pool_array::Element> FromVariant for PoolArray<T> {
     #[inline]
     fn from_variant(variant: &Variant) -> Result<Self, FromVariantError> {
         unsafe {

gdnative-core/src/core_types/vector2_array.rs

@@ -1,8 +1,8 @@
-use crate::core_types::TypedArray;
+use crate::core_types::PoolArray;
 use crate::core_types::Vector2;
 
 /// A reference-counted vector of `Vector2` that uses Godot's pool allocator.
-pub type Vector2Array = TypedArray<Vector2>;
+pub type Vector2Array = PoolArray<Vector2>;
 
 godot_test!(
     test_vector2_array_access {