Now everything compiles once again

Author: vincentisambart

src/avfoundation.rs

@@ -45,37 +45,33 @@ extern "C" {
 
 pub trait CFTypeInterface
 where
-    // to be able to have default implementations of methods returning Self
+    Self: ptr::AsRaw,
     Self: Sized,
-    // all objects should be clonable (here cloning just means increasing the reference count)
-    Self: Clone,
 {
-    fn as_raw(&self) -> ptr::cf::RawRef;
-
     fn equal(&self, other: &impl CFTypeInterface) -> bool {
-        let self_raw = self.as_raw();
-        let other_raw = other.as_raw();
+        let self_raw = self.as_raw_ref();
+        let other_raw = other.as_raw_ref();
         let ret = unsafe { CFEqual(self_raw, other_raw) };
         ret.into()
     }
 
     fn show(&self) {
-        let self_raw = self.as_raw();
+        let self_raw = self.as_raw_ref();
         unsafe { CFShow(self_raw) };
     }
 
     fn retain_count(&self) -> isize {
-        let self_raw = self.as_raw();
+        let self_raw = self.as_raw_ref();
         unsafe { CFGetRetainCount(self_raw) }
     }
 
     fn hash(&self) -> usize {
-        let self_raw = self.as_raw();
+        let self_raw = self.as_raw_ref();
         unsafe { CFHash(self_raw) }
     }
 
     fn type_id(&self) -> CFTypeID {
-        let self_raw = self.as_raw();
+        let self_raw = self.as_raw_ref();
         unsafe { CFGetTypeID(self_raw) }
     }
 }

src/base/core_foundation.rs

@@ -1,4 +1,4 @@
-use crate::base::ptr;
+use crate::base::ptr::{self, FromOwned};
 use std::ptr::NonNull;
 
 pub type NSInteger = isize;
@@ -44,62 +44,57 @@ extern "C" {
     ) -> ptr::objc::NullableRawPtr;
 }
 
-// TODO: Move to ptr module
-pub trait FromOwnedPtr {
-    unsafe fn from_owned_ptr_unchecked(owned_ptr: ptr::objc::OwnedPtr) -> Self;
-}
-
 // TODO: Is that really safe?
 impl<T> ptr::Retain for T
 where
-    T: ptr::objc::AsRawPtr + FromOwnedPtr,
+    T: ptr::AsRaw + ptr::FromOwned,
 {
     type Owned = Self;
 
     fn retain(&self) -> Self::Owned {
-        unsafe { Self::from_owned_ptr_unchecked(self.as_raw().retain()) }
+        unsafe { Self::from_owned_ptr_unchecked(self.as_raw_ptr().retain()) }
     }
 }
 
 /// Indicates that the type can be used as type parameter for Objective-C classes like NSArray.
 /// That does not include special types like StaticNSString or ImmutableNSString.
-pub trait ValidObjCGeneric: ptr::objc::AsRawPtr + FromOwnedPtr {}
+pub trait ValidObjCGeneric: ptr::AsRaw + ptr::FromOwned {}
 
-// TODO: IsKinfOf should maybe be unsafe
+// TODO: IsKindOf should maybe be unsafe
 /// Marker trait used for handling of type parameters in NSArray and NSDictionary.
-pub trait IsKindOf<T: ValidObjCGeneric>: ptr::objc::AsRawPtr {}
+pub trait IsKindOf<T: ValidObjCGeneric>: ptr::AsRaw {}
 impl<T: ValidObjCGeneric> IsKindOf<T> for T {}
 
 pub trait NSObjectProtocol
 where
-    Self: ptr::objc::AsRawPtr,
+    Self: ptr::AsRaw,
     Self: Sized,
 {
-    type Owned: FromOwnedPtr;
+    type Owned: ptr::FromOwned;
 
     /// Objective-C class represented by the struct implementing this trait..
     fn class() -> ptr::objc::ClassPtr;
 
     fn hash(&self) -> usize {
-        unsafe { choco_base_NSObjectProtocol_instance_hash(self.as_raw()) }
+        unsafe { choco_base_NSObjectProtocol_instance_hash(self.as_raw_ptr()) }
     }
     // In Objective-C, the parameter to -[NSObject isEqual:] is nullable,
     // we consider it non-nullable to makes things simpler.
     fn is_equal(&self, obj: &impl NSObjectProtocol) -> bool {
-        let self_raw = self.as_raw();
-        let obj_raw = obj.as_raw();
+        let self_raw = self.as_raw_ptr();
+        let obj_raw = obj.as_raw_ptr();
         let ret = unsafe { choco_base_NSObjectProtocol_instance_isEqual(self_raw, obj_raw.into()) };
         ret.into()
     }
 
     fn is_kind_of(&self, class: ptr::objc::ClassPtr) -> bool {
-        let self_raw = self.as_raw();
+        let self_raw = self.as_raw_ptr();
         let ret = unsafe { choco_base_NSObjectProtocol_instance_isKindOfClass(self_raw, class) };
         ret.into()
     }
 
     fn description(&self) -> crate::foundation::NSString {
-        let self_raw = self.as_raw();
+        let self_raw = self.as_raw_ptr();
         unsafe {
             let owned_ptr = choco_base_NSObjectProtocol_instance_description(self_raw)
                 .unwrap()
@@ -109,7 +104,7 @@ where
     }
 
     fn debug_description(&self) -> crate::foundation::NSString {
-        let self_raw = self.as_raw();
+        let self_raw = self.as_raw_ptr();
         unsafe {
             let owned_ptr = choco_base_NSObjectProtocol_instance_debugDescription(self_raw)
                 .unwrap()
@@ -134,13 +129,13 @@ pub struct NSObject {
     ptr: ptr::objc::OwnedPtr,
 }
 
-impl ptr::objc::AsRawPtr for NSObject {
-    fn as_raw(&self) -> ptr::objc::RawPtr {
-        self.ptr.as_raw()
+impl ptr::AsRaw for NSObject {
+    fn as_raw_ptr(&self) -> ptr::objc::RawPtr {
+        self.ptr.as_raw_ptr()
     }
 }
 
-impl FromOwnedPtr for NSObject {
+impl ptr::FromOwned for NSObject {
     unsafe fn from_owned_ptr_unchecked(ptr: ptr::objc::OwnedPtr) -> Self {
         Self { ptr }
     }

src/base/objc.rs

@@ -3,6 +3,32 @@ pub trait Retain {
     fn retain(&self) -> Self::Owned;
 }
 
+/// At least one of the two methods must be implemented (or else you'll end up with infinite recursion).
+pub trait AsRaw {
+    fn as_raw_ptr(&self) -> objc::RawPtr {
+        objc::RawPtr {
+            ptr: self.as_raw_ref().ptr.cast(),
+        }
+    }
+
+    fn as_raw_ref(&self) -> cf::RawRef {
+        cf::RawRef {
+            ptr: self.as_raw_ptr().ptr.cast(),
+        }
+    }
+}
+
+/// At least one of the two methods must be implemented (or else you'll end up with infinite recursion).
+pub trait FromOwned: Sized {
+    unsafe fn from_owned_ptr_unchecked(owned_ptr: objc::OwnedPtr) -> Self {
+        Self::from_owned_ref_unchecked(owned_ptr.into())
+    }
+
+    unsafe fn from_owned_ref_unchecked(owned_ref: cf::OwnedRef) -> Self {
+        Self::from_owned_ptr_unchecked(owned_ref.into())
+    }
+}
+
 pub(crate) mod objc {
     use std::ptr::NonNull;
 
@@ -62,10 +88,6 @@ pub(crate) mod objc {
         }
     }
 
-    pub trait AsRawPtr {
-        fn as_raw(&self) -> RawPtr;
-    }
-
     pub struct OwnedPtr {
         raw: RawPtr,
     }
@@ -93,19 +115,20 @@ pub(crate) mod objc {
         }
     }
 
-    impl AsRawPtr for OwnedPtr {
-        fn as_raw(&self) -> RawPtr {
+    impl super::AsRaw for OwnedPtr {
+        fn as_raw_ptr(&self) -> RawPtr {
             self.raw
         }
     }
 
     #[derive(Copy, Clone)]
+    #[repr(transparent)]
     pub struct StaticPtr {
         raw: RawPtr,
     }
 
-    impl AsRawPtr for StaticPtr {
-        fn as_raw(&self) -> RawPtr {
+    impl super::AsRaw for StaticPtr {
+        fn as_raw_ptr(&self) -> RawPtr {
             self.raw
         }
     }
@@ -209,6 +232,12 @@ pub(crate) mod cf {
         }
     }
 
+    impl super::AsRaw for OwnedRef {
+        fn as_raw_ref(&self) -> RawRef {
+            self.raw
+        }
+    }
+
     impl super::Retain for OwnedRef {
         type Owned = Self;
         fn retain(&self) -> Self::Owned {
@@ -247,10 +276,18 @@ pub(crate) mod cf {
     }
 }
 
-impl objc::AsRawPtr for cf::OwnedRef {
-    fn as_raw(&self) -> objc::RawPtr {
-        objc::RawPtr {
-            ptr: self.raw.ptr.cast(),
-        }
+impl From<cf::OwnedRef> for objc::OwnedPtr {
+    fn from(ptr: cf::OwnedRef) -> Self {
+        let raw = ptr.as_raw_ptr();
+        std::mem::forget(ptr);
+        unsafe { Self::from_owned_raw(raw) }
+    }
+}
+
+impl From<objc::OwnedPtr> for cf::OwnedRef {
+    fn from(ptr: objc::OwnedPtr) -> Self {
+        let raw = ptr.as_raw_ref();
+        std::mem::forget(ptr);
+        unsafe { Self::from_owned_raw(raw) }
     }
 }

src/base/ptr.rs

@@ -147,7 +147,7 @@ pub trait CMFormatDescriptionInterface: CFTypeInterface {
     }
 
     fn media_type(&self) -> CMMediaType {
-        let self_raw = self.as_raw();
+        let self_raw = self.as_raw_ref();
         unsafe { CMFormatDescriptionGetMediaType(self_raw) }
     }
 }
@@ -156,6 +156,13 @@ pub struct CMFormatDescription {
     ptr: ptr::cf::OwnedRef,
 }
 
+impl ptr::AsRaw for CMFormatDescription {
+    fn as_raw_ref(&self) -> ptr::cf::RawRef {
+        self.ptr.as_raw_ref()
+    }
+}
+
+impl CFTypeInterface for CMFormatDescription {}
 impl CMFormatDescriptionInterface for CMFormatDescription {}
 pub trait CMAudioFormatDescriptionInterface: CMFormatDescriptionInterface {}
 impl ValidObjCGeneric for CMFormatDescription {}
@@ -164,6 +171,19 @@ pub struct CMAudioFormatDescription {
     ptr: ptr::cf::OwnedRef,
 }
 
+impl ptr::AsRaw for CMAudioFormatDescription {
+    fn as_raw_ref(&self) -> ptr::cf::RawRef {
+        self.ptr.as_raw_ref()
+    }
+}
+
+impl ptr::FromOwned for CMFormatDescription {
+    unsafe fn from_owned_ref_unchecked(owned_ref: ptr::cf::OwnedRef) -> Self {
+        Self { ptr: owned_ref }
+    }
+}
+
+impl CFTypeInterface for CMAudioFormatDescription {}
 impl CMFormatDescriptionInterface for CMAudioFormatDescription {}
 impl CMAudioFormatDescriptionInterface for CMAudioFormatDescription {}
 
@@ -176,12 +196,12 @@ pub struct CMVideoDimensions {
 
 pub trait CMVideoFormatDescriptionInterface: CMFormatDescriptionInterface {
     fn clean_aperture(&self, origin_is_at_top_left: bool) -> CGRect {
-        let self_raw = self.as_raw();
+        let self_raw = self.as_raw_ref();
         unsafe { CMVideoFormatDescriptionGetCleanAperture(self_raw, origin_is_at_top_left.into()) }
     }
 
     fn dimensions(&self) -> CMVideoDimensions {
-        let self_raw = self.as_raw();
+        let self_raw = self.as_raw_ref();
         unsafe { CMVideoFormatDescriptionGetDimensions(self_raw) }
     }
 }
@@ -190,6 +210,13 @@ pub struct CMVideoFormatDescription {
     ptr: ptr::cf::OwnedRef,
 }
 
+impl ptr::AsRaw for CMVideoFormatDescription {
+    fn as_raw_ref(&self) -> ptr::cf::RawRef {
+        self.ptr.as_raw_ref()
+    }
+}
+
+impl CFTypeInterface for CMVideoFormatDescription {}
 impl CMFormatDescriptionInterface for CMVideoFormatDescription {}
 impl CMVideoFormatDescriptionInterface for CMVideoFormatDescription {}
 
@@ -199,6 +226,13 @@ pub struct CMMuxedFormatDescription {
     ptr: ptr::cf::OwnedRef,
 }
 
+impl ptr::AsRaw for CMMuxedFormatDescription {
+    fn as_raw_ref(&self) -> ptr::cf::RawRef {
+        self.ptr.as_raw_ref()
+    }
+}
+
+impl CFTypeInterface for CMMuxedFormatDescription {}
 impl CMFormatDescriptionInterface for CMMuxedFormatDescription {}
 impl CMMuxedFormatDescriptionInterface for CMMuxedFormatDescription {}
 
@@ -208,6 +242,13 @@ pub struct CMMetadataFormatDescription {
     ptr: ptr::cf::OwnedRef,
 }
 
+impl ptr::AsRaw for CMMetadataFormatDescription {
+    fn as_raw_ref(&self) -> ptr::cf::RawRef {
+        self.ptr.as_raw_ref()
+    }
+}
+
+impl CFTypeInterface for CMMetadataFormatDescription {}
 impl CMFormatDescriptionInterface for CMMetadataFormatDescription {}
 impl CMMetadataFormatDescriptionInterface for CMMetadataFormatDescription {}
 
@@ -217,6 +258,13 @@ pub struct CMTextFormatDescription {
     ptr: ptr::cf::OwnedRef,
 }
 
+impl ptr::AsRaw for CMTextFormatDescription {
+    fn as_raw_ref(&self) -> ptr::cf::RawRef {
+        self.ptr.as_raw_ref()
+    }
+}
+
+impl CFTypeInterface for CMTextFormatDescription {}
 impl CMFormatDescriptionInterface for CMTextFormatDescription {}
 impl CMTextFormatDescriptionInterface for CMTextFormatDescription {}
 
@@ -226,6 +274,13 @@ pub struct CMTimeCodeFormatDescription {
     ptr: ptr::cf::OwnedRef,
 }
 
+impl ptr::AsRaw for CMTimeCodeFormatDescription {
+    fn as_raw_ref(&self) -> ptr::cf::RawRef {
+        self.ptr.as_raw_ref()
+    }
+}
+
+impl CFTypeInterface for CMTimeCodeFormatDescription {}
 impl CMFormatDescriptionInterface for CMTimeCodeFormatDescription {}
 impl CMTimeCodeFormatDescriptionInterface for CMTimeCodeFormatDescription {}
 
@@ -235,5 +290,12 @@ pub struct CMClosedCaptionFormatDescription {
     ptr: ptr::cf::OwnedRef,
 }
 
+impl ptr::AsRaw for CMClosedCaptionFormatDescription {
+    fn as_raw_ref(&self) -> ptr::cf::RawRef {
+        self.ptr.as_raw_ref()
+    }
+}
+
+impl CFTypeInterface for CMClosedCaptionFormatDescription {}
 impl CMFormatDescriptionInterface for CMClosedCaptionFormatDescription {}
 impl CMClosedCaptionFormatDescriptionInterface for CMClosedCaptionFormatDescription {}