Rename ThreadAccess -> Ownership

Author: hesuteia

bindings_generator/src/documentation.rs

@@ -129,8 +129,8 @@ This class is used to interact with Godot's editor."#
 All types in the Godot API have _interior mutability_ in Rust parlance.
 To enforce that the official [thread-safety guidelines][thread-safety] are
 followed, the typestate pattern is used in the `Ref` and `TRef` smart pointers,
-and the `Instance` API. The typestate `Access` in these types tracks whether the
-access is unique, shared, or exclusive to the current thread. For more information,
+and the `Instance` API. The typestate `Ownership` in these types tracks whether
+ownership is unique, shared, or exclusive to the current thread. For more information,
 see the type-level documentation on `Ref`.
 
 [thread-safety]: https://docs.godotengine.org/en/stable/tutorials/threads/thread_safe_apis.html"#;

gdnative-core/src/core_types/dictionary.rs

@@ -20,21 +20,21 @@ use crate::object::ownership::*;
 ///
 /// This is a reference-counted collection with "interior mutability" in Rust parlance.
 /// To enforce that the official [thread-safety guidelines][thread-safety] are
-/// followed this type uses the *typestate* pattern. The typestate `Access` tracks
+/// followed this type uses the *typestate* pattern. The typestate `Ownership` tracks
 /// whether there is thread-local or unique access (where pretty much all operations are safe)
 /// or whether the value might be "shared", in which case not all operations are
 /// safe.
 ///
 /// [thread-safety]: https://docs.godotengine.org/en/stable/tutorials/threads/thread_safe_apis.html
-pub struct Dictionary<Access: ThreadAccess = Shared> {
+pub struct Dictionary<Own: Ownership = Shared> {
     sys: sys::godot_dictionary,
 
     /// Marker preventing the compiler from incorrectly deriving `Send` and `Sync`.
-    _marker: PhantomData<Access>,
+    _marker: PhantomData<Own>,
 }
 
 /// Operations allowed on all Dictionaries at any point in time.
-impl<Access: ThreadAccess> Dictionary<Access> {
+impl<Own: Ownership> Dictionary<Own> {
     /// Returns `true` if the `Dictionary` contains no elements.
     #[inline]
     pub fn is_empty(&self) -> bool {
@@ -58,7 +58,7 @@ impl<Access: ThreadAccess> Dictionary<Access> {
 
     /// Returns true if the `Dictionary` has all of the keys in the given array.
     #[inline]
-    pub fn contains_all<ArrAccess: ThreadAccess>(&self, keys: &VariantArray<ArrAccess>) -> bool {
+    pub fn contains_all<ArrayOws: Ownership>(&self, keys: &VariantArray<ArrayOws>) -> bool {
         unsafe { (get_api().godot_dictionary_has_all)(self.sys(), keys.sys()) }
     }
 
@@ -200,7 +200,7 @@ impl<Access: ThreadAccess> Dictionary<Access> {
     /// Modifying the same underlying collection while observing the safety assumptions will
     /// not violate memory safely, but may lead to surprising behavior in the iterator.
     #[inline]
-    pub fn iter(&self) -> Iter<Access> {
+    pub fn iter(&self) -> Iter<Own> {
         Iter::new(self)
     }
 
@@ -238,7 +238,7 @@ impl<Access: ThreadAccess> Dictionary<Access> {
         }
     }
 
-    unsafe fn cast_access<A: ThreadAccess>(self) -> Dictionary<A> {
+    unsafe fn cast_access<A: Ownership>(self) -> Dictionary<A> {
         let sys = self.sys;
         std::mem::forget(self);
         Dictionary::from_sys(sys)
@@ -264,7 +264,7 @@ impl Dictionary<ThreadLocal> {
 }
 
 /// Operations allowed on Dictionaries that are not unique.
-impl<Access: NonUniqueThreadAccess> Dictionary<Access> {
+impl<Own: NonUniqueOwnership> Dictionary<Own> {
     /// Assume that this is the only reference to this dictionary, on which
     /// operations that change the container size can be safely performed.
     ///
@@ -282,7 +282,7 @@ impl<Access: NonUniqueThreadAccess> Dictionary<Access> {
 }
 
 /// Operations allowed on Dictionaries that can only be referenced to from the current thread.
-impl<Access: LocalThreadAccess> Dictionary<Access> {
+impl<Own: LocalThreadOwnership> Dictionary<Own> {
     #[inline]
     /// Inserts or updates the value of the element corresponding to the key.
     pub fn insert<K, V>(&self, key: K, val: V)
@@ -340,7 +340,7 @@ impl Dictionary<Unique> {
     }
 }
 
-impl<Access: ThreadAccess> Drop for Dictionary<Access> {
+impl<Own: Ownership> Drop for Dictionary<Own> {
     #[inline]
     fn drop(&mut self) {
         unsafe { (get_api().godot_dictionary_destroy)(self.sys_mut()) }
@@ -368,7 +368,7 @@ impl Default for Dictionary<ThreadLocal> {
     }
 }
 
-impl<Access: NonUniqueThreadAccess> NewRef for Dictionary<Access> {
+impl<Own: NonUniqueOwnership> NewRef for Dictionary<Own> {
     #[inline]
     fn new_ref(&self) -> Self {
         unsafe {
@@ -393,15 +393,15 @@ impl From<Dictionary<Unique>> for Dictionary<ThreadLocal> {
     }
 }
 
-impl<Access: ThreadAccess> fmt::Debug for Dictionary<Access> {
+impl<Own: Ownership> fmt::Debug for Dictionary<Own> {
     #[inline]
     fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
         self.to_json().to_string().fmt(f)
     }
 }
 
-unsafe fn iter_next<Access: ThreadAccess>(
-    dic: &Dictionary<Access>,
+unsafe fn iter_next<Own: Ownership>(
+    dic: &Dictionary<Own>,
     last_key: &mut Option<Variant>,
 ) -> Option<(Variant, Variant)> {
     let last_ptr = last_key.as_ref().map_or(std::ptr::null(), Variant::sys);
@@ -421,22 +421,22 @@ unsafe fn iter_next<Access: ThreadAccess>(
 ///
 /// This struct is created by the `iter` method on `Dictionary<Unique>`.
 #[derive(Debug)]
-pub struct Iter<'a, Access: ThreadAccess> {
-    dic: &'a Dictionary<Access>,
+pub struct Iter<'a, Own: Ownership> {
+    dic: &'a Dictionary<Own>,
     last_key: Option<Variant>,
 }
 
-impl<'a, Access: ThreadAccess> Iter<'a, Access> {
+impl<'a, Own: Ownership> Iter<'a, Own> {
     /// Create an Iterator from a unique Dictionary.
-    fn new(dic: &'a Dictionary<Access>) -> Self {
+    fn new(dic: &'a Dictionary<Own>) -> Self {
         Iter {
             dic,
             last_key: None,
         }
     }
 }
 
-impl<'a, Access: ThreadAccess> Iterator for Iter<'a, Access> {
+impl<'a, Own: Ownership> Iterator for Iter<'a, Own> {
     type Item = (Variant, Variant);
 
     #[inline]
@@ -451,9 +451,9 @@ impl<'a, Access: ThreadAccess> Iterator for Iter<'a, Access> {
     }
 }
 
-impl<'a, Access: ThreadAccess> IntoIterator for &'a Dictionary<Access> {
+impl<'a, Own: Ownership> IntoIterator for &'a Dictionary<Own> {
     type Item = (Variant, Variant);
-    type IntoIter = Iter<'a, Access>;
+    type IntoIter = Iter<'a, Own>;
     #[inline]
     fn into_iter(self) -> Self::IntoIter {
         self.iter()
@@ -517,7 +517,7 @@ where
     }
 }
 
-impl<K, V, Access: LocalThreadAccess> Extend<(K, V)> for Dictionary<Access>
+impl<K, V, Own: LocalThreadOwnership> Extend<(K, V)> for Dictionary<Own>
 where
     K: ToVariantEq + OwnedToVariant,
     V: OwnedToVariant,

gdnative-core/src/core_types/variant_array.rs

@@ -30,15 +30,15 @@ use std::fmt;
 /// safe.
 ///
 /// [thread-safety]: https://docs.godotengine.org/en/stable/tutorials/threads/thread_safe_apis.html
-pub struct VariantArray<Access: ThreadAccess = Shared> {
+pub struct VariantArray<Own: Ownership = Shared> {
     sys: sys::godot_array,
 
     /// Marker preventing the compiler from incorrectly deriving `Send` and `Sync`.
-    _marker: PhantomData<Access>,
+    _marker: PhantomData<Own>,
 }
 
 /// Operations allowed on all arrays at any point in time.
-impl<Access: ThreadAccess> VariantArray<Access> {
+impl<Own: Ownership> VariantArray<Own> {
     /// Sets the value of the element at the given offset.
     #[inline]
     pub fn set<T: OwnedToVariant>(&self, idx: i32, val: T) {
@@ -177,7 +177,7 @@ impl<Access: ThreadAccess> VariantArray<Access> {
     /// Modifying the same underlying collection while observing the safety assumptions will
     /// not violate memory safely, but may lead to surprising behavior in the iterator.
     #[inline]
-    pub fn iter(&self) -> Iter<'_, Access> {
+    pub fn iter(&self) -> Iter<'_, Own> {
         self.into_iter()
     }
 
@@ -217,7 +217,7 @@ impl<Access: ThreadAccess> VariantArray<Access> {
         }
     }
 
-    unsafe fn cast_access<A: ThreadAccess>(self) -> VariantArray<A> {
+    unsafe fn cast_access<A: Ownership>(self) -> VariantArray<A> {
         let sys = self.sys;
         std::mem::forget(self);
         VariantArray::from_sys(sys)
@@ -234,7 +234,7 @@ impl<Access: ThreadAccess> VariantArray<Access> {
 }
 
 /// Operations allowed on Dictionaries that can only be referenced to from the current thread.
-impl<Access: LocalThreadAccess> VariantArray<Access> {
+impl<Own: LocalThreadOwnership> VariantArray<Own> {
     /// Clears the array, resizing to 0.
     #[inline]
     pub fn clear(&self) {
@@ -297,7 +297,7 @@ impl<Access: LocalThreadAccess> VariantArray<Access> {
 }
 
 /// Operations allowed on non-unique arrays.
-impl<Access: NonUniqueThreadAccess> VariantArray<Access> {
+impl<Own: NonUniqueOwnership> VariantArray<Own> {
     /// Assume that this is the only reference to this array, on which
     /// operations that change the container size can be safely performed.
     ///
@@ -378,7 +378,7 @@ impl Default for VariantArray<ThreadLocal> {
     }
 }
 
-impl<Access: NonUniqueThreadAccess> NewRef for VariantArray<Access> {
+impl<Own: NonUniqueOwnership> NewRef for VariantArray<Own> {
     #[inline]
     fn new_ref(&self) -> Self {
         unsafe {
@@ -389,27 +389,27 @@ impl<Access: NonUniqueThreadAccess> NewRef for VariantArray<Access> {
     }
 }
 
-impl<Access: ThreadAccess> Drop for VariantArray<Access> {
+impl<Own: Ownership> Drop for VariantArray<Own> {
     #[inline]
     fn drop(&mut self) {
         unsafe { (get_api().godot_array_destroy)(self.sys_mut()) }
     }
 }
 
-impl<Access: ThreadAccess> fmt::Debug for VariantArray<Access> {
+impl<Own: Ownership> fmt::Debug for VariantArray<Own> {
     #[inline]
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_list().entries(self.iter()).finish()
     }
 }
 
 // #[derive(Debug)]
-pub struct Iter<'a, Access: ThreadAccess> {
-    arr: &'a VariantArray<Access>,
+pub struct Iter<'a, Own: Ownership> {
+    arr: &'a VariantArray<Own>,
     range: std::ops::Range<i32>,
 }
 
-impl<'a, Access: ThreadAccess> Iterator for Iter<'a, Access> {
+impl<'a, Own: Ownership> Iterator for Iter<'a, Own> {
     type Item = Variant;
 
     #[inline]
@@ -444,9 +444,9 @@ impl<'a, Access: ThreadAccess> Iterator for Iter<'a, Access> {
     }
 }
 
-impl<'a, Access: ThreadAccess> IntoIterator for &'a VariantArray<Access> {
+impl<'a, Own: Ownership> IntoIterator for &'a VariantArray<Own> {
     type Item = Variant;
-    type IntoIter = Iter<'a, Access>;
+    type IntoIter = Iter<'a, Own>;
     #[inline]
     fn into_iter(self) -> Self::IntoIter {
         Iter {
@@ -518,7 +518,7 @@ impl<T: ToVariant> FromIterator<T> for VariantArray<Unique> {
     }
 }
 
-impl<T: ToVariant, Access: LocalThreadAccess> Extend<T> for VariantArray<Access> {
+impl<T: ToVariant, Own: LocalThreadOwnership> Extend<T> for VariantArray<Own> {
     #[inline]
     fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I) {
         for elem in iter {

gdnative-core/src/export/class.rs

@@ -1,6 +1,6 @@
 use crate::export::user_data::UserData;
 use crate::export::ClassBuilder;
-use crate::object::ownership::{Shared, ThreadAccess, Unique};
+use crate::object::ownership::{Ownership, Shared, Unique};
 use crate::object::{GodotObject, Instance, Instanciable, TRef};
 
 /// Trait used for describing and initializing a Godot script class.
@@ -120,36 +120,36 @@ pub trait NativeClassMethods: NativeClass {
 /// undefined behavior.
 ///
 /// [thread-safety]: https://docs.godotengine.org/en/stable/tutorials/threads/thread_safe_apis.html
-pub trait OwnerArg<'a, T: GodotObject, Access: ThreadAccess + 'static>: private::Sealed {
+pub trait OwnerArg<'a, T: GodotObject, Own: Ownership + 'static>: private::Sealed {
     #[doc(hidden)]
-    fn from_safe_ref(owner: TRef<'a, T, Access>) -> Self;
+    fn from_safe_ref(owner: TRef<'a, T, Own>) -> Self;
 }
 
 impl<'a, T> private::Sealed for &'a T where T: GodotObject {}
-impl<'a, T, Access> OwnerArg<'a, T, Access> for &'a T
+impl<'a, T, Own> OwnerArg<'a, T, Own> for &'a T
 where
     T: GodotObject,
-    Access: ThreadAccess + 'static,
+    Own: Ownership + 'static,
 {
     #[inline]
-    fn from_safe_ref(owner: TRef<'a, T, Access>) -> Self {
+    fn from_safe_ref(owner: TRef<'a, T, Own>) -> Self {
         owner.as_ref()
     }
 }
 
-impl<'a, T, Access> private::Sealed for TRef<'a, T, Access>
+impl<'a, T, Own> private::Sealed for TRef<'a, T, Own>
 where
     T: GodotObject,
-    Access: ThreadAccess + 'static,
+    Own: Ownership + 'static,
 {
 }
-impl<'a, T, Access> OwnerArg<'a, T, Access> for TRef<'a, T, Access>
+impl<'a, T, Own> OwnerArg<'a, T, Own> for TRef<'a, T, Own>
 where
     T: GodotObject,
-    Access: ThreadAccess + 'static,
+    Own: Ownership + 'static,
 {
     #[inline]
-    fn from_safe_ref(owner: TRef<'a, T, Access>) -> Self {
+    fn from_safe_ref(owner: TRef<'a, T, Own>) -> Self {
         owner
     }
 }

gdnative-core/src/object/bounds.rs

@@ -217,17 +217,17 @@ impl<'a, 'r: 'a> LifetimeConstraint<RefCounted> for AssumeSafeLifetime<'a, 'r> {
 
 /// Trait for combinations of `RefKind` and `ThreadAccess` that can be dereferenced safely.
 /// This is an internal interface.
-pub unsafe trait SafeDeref<Kind: RefKind, Access: ThreadAccess> {
+pub unsafe trait SafeDeref<Kind: RefKind, Own: Ownership> {
     /// Returns a safe reference to the underlying object.
     #[doc(hidden)]
-    fn impl_as_ref<T: GodotObject<RefKind = Kind>>(this: &Ref<T, Access>) -> TRef<'_, T, Access>;
+    fn impl_as_ref<T: GodotObject<RefKind = Kind>>(this: &Ref<T, Own>) -> TRef<'_, T, Own>;
 }
 
 /// Trait for persistent `Ref`s that point to valid objects. This is an internal interface.
-pub unsafe trait SafeAsRaw<Kind: RefKind, Access: ThreadAccess> {
+pub unsafe trait SafeAsRaw<Kind: RefKind, Own: Ownership> {
     /// Returns a raw reference to the underlying object.
     #[doc(hidden)]
-    fn impl_as_raw<T: GodotObject<RefKind = Kind>>(this: &Ref<T, Access>) -> &RawObject<T>;
+    fn impl_as_raw<T: GodotObject<RefKind = Kind>>(this: &Ref<T, Own>) -> &RawObject<T>;
 }
 
 // ----------------------------------------------------------------------------------------------------------------------------------------------
@@ -247,11 +247,9 @@ unsafe impl SafeDeref<ManuallyManaged, Unique> for RefImplBound {
     }
 }
 
-unsafe impl<Access: LocalThreadAccess> SafeDeref<RefCounted, Access> for RefImplBound {
+unsafe impl<Own: LocalThreadOwnership> SafeDeref<RefCounted, Own> for RefImplBound {
     #[inline]
-    fn impl_as_ref<T: GodotObject<RefKind = RefCounted>>(
-        this: &Ref<T, Access>,
-    ) -> TRef<'_, T, Access> {
+    fn impl_as_ref<T: GodotObject<RefKind = RefCounted>>(this: &Ref<T, Own>) -> TRef<'_, T, Own> {
         unsafe { this.assume_safe_unchecked() }
     }
 }
@@ -265,9 +263,9 @@ unsafe impl SafeAsRaw<ManuallyManaged, Unique> for RefImplBound {
     }
 }
 
-unsafe impl<Access: ThreadAccess> SafeAsRaw<RefCounted, Access> for RefImplBound {
+unsafe impl<Own: Ownership> SafeAsRaw<RefCounted, Own> for RefImplBound {
     #[inline]
-    fn impl_as_raw<T: GodotObject<RefKind = RefCounted>>(this: &Ref<T, Access>) -> &RawObject<T> {
+    fn impl_as_raw<T: GodotObject<RefKind = RefCounted>>(this: &Ref<T, Own>) -> &RawObject<T> {
         unsafe { this.as_raw_unchecked() }
     }
 }