Id conversion traits

objc2-foundation/examples/basic_usage.rs

@@ -1,4 +1,4 @@
-use objc2::rc::autoreleasepool;
+use objc2::rc::{autoreleasepool, FromId, Id, IntoId};
 use objc2_foundation::{
     INSArray, INSCopying, INSDictionary, INSString, NSArray, NSDictionary, NSObject, NSString,
 };
@@ -13,14 +13,14 @@ fn main() {
 
     // Create an NSArray from a Vec
     let objs = vec![obj, obj2];
-    let array = NSArray::from_vec(objs);
+    let array: Id<NSArray<_, _>, _> = objs.into_id();
     for obj in array.iter() {
         println!("{:?}", obj);
     }
     println!("{}", array.len());
 
     // Turn the NSArray back into a Vec
-    let mut objs = NSArray::into_vec(array);
+    let mut objs = Vec::from_id(array);
     let obj = objs.pop().unwrap();
 
     // Create an NSString from a str slice

objc2-foundation/src/array.rs

@@ -112,10 +112,6 @@ pub unsafe trait INSArray: INSObject {
         }
     }
 
-    fn from_vec(vec: Vec<Id<Self::Item, Self::ItemOwnership>>) -> Id<Self, Self::Ownership> {
-        unsafe { from_refs(vec.as_slice_ref()) }
-    }
-
     fn objects_in_range(&self, range: Range<usize>) -> Vec<&Self::Item> {
         let range = NSRange::from(range);
         let mut vec = Vec::with_capacity(range.length);
@@ -126,35 +122,12 @@ pub unsafe trait INSArray: INSObject {
         vec
     }
 
-    fn to_vec(&self) -> Vec<&Self::Item> {
-        self.objects_in_range(0..self.len())
-    }
-
-    // TODO: Take Id<Self, Self::ItemOwnership> ?
-    fn into_vec(array: Id<Self, Owned>) -> Vec<Id<Self::Item, Self::ItemOwnership>> {
-        array
-            .to_vec()
-            .into_iter()
-            .map(|obj| unsafe { Id::retain(obj.into()) })
-            .collect()
-    }
-
     fn from_slice(slice: &[Id<Self::Item, Shared>]) -> Id<Self, Self::Ownership>
     where
         Self: INSArray<ItemOwnership = Shared>,
     {
         unsafe { from_refs(slice.as_slice_ref()) }
     }
-
-    fn to_shared_vec(&self) -> Vec<Id<Self::Item, Shared>>
-    where
-        Self: INSArray<ItemOwnership = Shared>,
-    {
-        self.to_vec()
-            .into_iter()
-            .map(|obj| unsafe { Id::retain(obj.into()) })
-            .collect()
-    }
 }
 
 /// TODO
@@ -211,6 +184,52 @@ impl<T: INSObject, O: Ownership> Index<usize> for NSArray<T, O> {
     }
 }
 
+impl<T, O> FromId<NSArray<T, O>, Owned> for Vec<Id<T, O>>
+where
+    T: INSObject,
+    O: Ownership,
+{
+    fn from_id(array: Id<NSArray<T, O>, Owned>) -> Self {
+        let vec: Vec<&T> = (&*array).into();
+        vec.into_iter()
+            .map(|obj| unsafe { Id::retain(obj.into()) })
+            .collect()
+    }
+}
+
+impl<T, O> IntoId<NSArray<T, O>, Owned> for Vec<Id<T, O>>
+where
+    T: INSObject,
+    O: Ownership,
+{
+    fn into_id(self) -> Id<NSArray<T, O>, Owned> {
+        unsafe { from_refs(self.as_slice_ref()) }
+    }
+}
+
+impl<'a, T, O> From<&'a NSArray<T, O>> for Vec<&'a T>
+where
+    T: INSObject,
+    O: Ownership,
+{
+    fn from(array: &'a NSArray<T, O>) -> Self {
+        array.objects_in_range(0..array.count())
+    }
+}
+
+impl<T> From<&'_ NSArray<T, Shared>> for Vec<Id<T, Shared>>
+where
+    T: INSObject,
+{
+    fn from(array: &NSArray<T, Shared>) -> Self {
+        array
+            .objects_in_range(0..array.count())
+            .into_iter()
+            .map(|obj| unsafe { Id::retain(obj.into()) })
+            .collect()
+    }
+}
+
 pub unsafe trait INSMutableArray: INSArray {
     #[doc(alias = "addObject:")]
     fn push(&mut self, obj: Id<Self::Item, Self::ItemOwnership>) {
@@ -358,6 +377,16 @@ impl<T: INSObject, O: Ownership> Index<usize> for NSMutableArray<T, O> {
     }
 }
 
+impl<T, O> IntoId<NSMutableArray<T, O>, Owned> for Vec<Id<T, O>>
+where
+    T: INSObject,
+    O: Ownership,
+{
+    fn into_id(self) -> Id<NSMutableArray<T, O>, Owned> {
+        unsafe { from_refs(self.as_slice_ref()) }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use alloc::vec;
@@ -374,7 +403,7 @@ mod tests {
         for _ in 0..len {
             vec.push(NSObject::new());
         }
-        NSArray::from_vec(vec)
+        vec.into_id()
     }
 
     fn retain_count<T: INSObject>(obj: &T) -> usize {
@@ -455,7 +484,7 @@ mod tests {
     fn test_into_vec() {
         let array = sample_array(4);
 
-        let vec = INSArray::into_vec(array);
+        let vec = Vec::from_id(array);
         assert_eq!(vec.len(), 4);
     }
 
@@ -504,7 +533,7 @@ mod tests {
     #[test]
     fn test_sort() {
         let strings = vec![NSString::from_str("hello"), NSString::from_str("hi")];
-        let mut strings = NSMutableArray::from_vec(strings);
+        let mut strings: Id<NSMutableArray<_, _>, Owned> = strings.into_id();
 
         autoreleasepool(|pool| {
             strings.sort_by(|s1, s2| s1.as_str(pool).len().cmp(&s2.as_str(pool).len()));

objc2-foundation/src/enumerator.rs

@@ -169,13 +169,16 @@ impl<'a, C: INSFastEnumeration> Iterator for NSFastEnumerator<'a, C> {
 
 #[cfg(test)]
 mod tests {
+    use alloc::vec::Vec;
+    use objc2::rc::{Id, IntoId};
+
     use super::INSFastEnumeration;
     use crate::{INSArray, INSValue, NSArray, NSValue};
 
     #[test]
     fn test_enumerator() {
-        let vec = (0u32..4).map(NSValue::new).collect();
-        let array = NSArray::from_vec(vec);
+        let vec: Vec<_> = (0u32..4).map(NSValue::new).collect();
+        let array: Id<NSArray<_, _>, _> = vec.into_id();
 
         let enumerator = array.iter();
         assert!(enumerator.count() == 4);
@@ -186,8 +189,8 @@ mod tests {
 
     #[test]
     fn test_fast_enumerator() {
-        let vec = (0u32..4).map(NSValue::new).collect();
-        let array = NSArray::from_vec(vec);
+        let vec: Vec<_> = (0u32..4).map(NSValue::new).collect();
+        let array: Id<NSArray<_, _>, _> = vec.into_id();
 
         let enumerator = array.enumerator();
         assert!(enumerator.count() == 4);

objc2/src/rc/id_traits.rs

@@ -1,5 +1,7 @@
 //! Helper traits for Id.
 
+use core::convert::Infallible;
+
 use super::{Id, Owned, Ownership};
 use crate::Message;
 
@@ -70,3 +72,51 @@ impl<T: DefaultId> Default for Id<T, T::Ownership> {
         T::default_id()
     }
 }
+
+pub trait FromId<T, O: Ownership> {
+    fn from_id(obj: Id<T, O>) -> Self;
+}
+
+pub trait TryFromId<T, O: Ownership>: Sized {
+    type Error;
+    fn try_from_id(obj: Id<T, O>) -> Result<Self, Self::Error>;
+}
+
+impl<T, O: Ownership, U: FromId<T, O>> TryFromId<T, O> for U {
+    type Error = Infallible;
+
+    fn try_from_id(obj: Id<T, O>) -> Result<Self, Self::Error> {
+        Ok(FromId::from_id(obj))
+    }
+}
+
+/// TODO.
+///
+/// This is similar to [`Into`] in that it is implemented automatically for
+/// all [`Id`] that implement [`FromId`]; but you will have to implement this
+/// yourself in many more cases!
+pub trait IntoId<T, O: Ownership> {
+    fn into_id(self) -> Id<T, O>;
+}
+
+impl<T, O: Ownership, U> IntoId<U, O> for Id<T, O>
+where
+    Id<U, O>: FromId<T, O>,
+{
+    fn into_id(self) -> Id<U, O> {
+        FromId::from_id(self)
+    }
+}
+
+pub trait TryIntoId<T, O: Ownership> {
+    type Error;
+    fn try_into_id(self) -> Result<Id<T, O>, Self::Error>;
+}
+
+impl<T, O: Ownership, U: IntoId<T, O>> TryIntoId<T, O> for U {
+    type Error = Infallible;
+
+    fn try_into_id(self) -> Result<Id<T, O>, Self::Error> {
+        Ok(IntoId::into_id(self))
+    }
+}

objc2/src/rc/mod.rs

@@ -35,7 +35,7 @@ mod weak_id;
 
 pub use self::autorelease::{autoreleasepool, AutoreleasePool, AutoreleaseSafe};
 pub use self::id::Id;
-pub use self::id_traits::{DefaultId, SliceId, SliceIdMut};
+pub use self::id_traits::{DefaultId, FromId, IntoId, SliceId, SliceIdMut, TryFromId, TryIntoId};
 pub use self::ownership::{Owned, Ownership, Shared};
 pub use self::weak_id::WeakId;