Change ConcreteTypeRef to an associated value

Author: faern

core-foundation/src/array.rs

@@ -83,7 +83,7 @@ impl_CFTypeDescriptionGeneric!(CFArray);
 
 impl<T> CFArray<T> {
     /// Creates a new `CFArray` with the given elements, which must be `CFType` objects.
-    pub fn from_CFTypes<R>(elems: &[T]) -> CFArray<T> where T: TCFType<R> {
+    pub fn from_CFTypes(elems: &[T]) -> CFArray<T> where T: TCFType {
         unsafe {
             let elems: Vec<CFTypeRef> = elems.iter().map(|elem| elem.as_CFTypeRef()).collect();
             let array_ref = CFArrayCreate(kCFAllocatorDefault,

core-foundation/src/base.rs

@@ -91,16 +91,20 @@ impl CFAllocator {
     }
 }
 
+
 /// All Core Foundation types implement this trait. The type parameter `TypeRef` specifies the
 /// associated Core Foundation type: e.g. for `CFType` this is `CFTypeRef`; for `CFArray` this is
 /// `CFArrayRef`.
-pub trait TCFType<ConcreteTypeRef> {
+pub trait TCFType {
+    /// The reference type wrapped inside this type.
+    type ConcreteTypeRef: TCFReference;
+
     /// Returns the object as its concrete TypeRef.
-    fn as_concrete_TypeRef(&self) -> ConcreteTypeRef;
+    fn as_concrete_TypeRef(&self) -> Self::ConcreteTypeRef;
 
     /// Returns an instance of the object, wrapping the underlying `CFTypeRef` subclass. Use this
     /// when following Core Foundation's "Create Rule". The reference count is *not* bumped.
-    unsafe fn wrap_under_create_rule(obj: ConcreteTypeRef) -> Self;
+    unsafe fn wrap_under_create_rule(obj: Self::ConcreteTypeRef) -> Self;
 
     /// Returns the type ID for this class.
     fn type_id() -> CFTypeID;
@@ -118,7 +122,7 @@ pub trait TCFType<ConcreteTypeRef> {
 
     /// Returns an instance of the object, wrapping the underlying `CFTypeRef` subclass. Use this
     /// when following Core Foundation's "Get Rule". The reference count *is* bumped.
-    unsafe fn wrap_under_get_rule(reference: ConcreteTypeRef) -> Self;
+    unsafe fn wrap_under_get_rule(reference: Self::ConcreteTypeRef) -> Self;
 
     /// Returns the reference count of the object. It is unwise to do anything other than test
     /// whether the return value of this method is greater than zero.
@@ -146,12 +150,14 @@ pub trait TCFType<ConcreteTypeRef> {
 
     /// Returns true if this value is an instance of another type.
     #[inline]
-    fn instance_of<OtherConcreteTypeRef,OtherCFType:TCFType<OtherConcreteTypeRef>>(&self) -> bool {
-        self.type_of() == <OtherCFType as TCFType<_>>::type_id()
+    fn instance_of<OtherCFType: TCFType>(&self) -> bool {
+        self.type_of() == <OtherCFType as TCFType>::type_id()
     }
 }
 
-impl TCFType<CFTypeRef> for CFType {
+impl TCFType for CFType {
+    type ConcreteTypeRef = CFTypeRef;
+
     #[inline]
     fn as_concrete_TypeRef(&self) -> CFTypeRef {
         self.0
@@ -180,7 +186,7 @@ impl TCFType<CFTypeRef> for CFType {
     }
 
     #[inline]
-    fn instance_of<OtherConcreteTypeRef,OtherCFType:TCFType<OtherConcreteTypeRef>>(&self) -> bool {
+    fn instance_of<OtherCFType: TCFType>(&self) -> bool {
         // Since this is the root of the type hierarchy, we always answer yes.
         true
     }

core-foundation/src/dictionary.rs

@@ -16,7 +16,7 @@ use libc::c_void;
 use std::mem;
 use std::ptr;
 
-use base::{CFType, CFIndexConvertible, TCFType};
+use base::{CFType, CFIndexConvertible, TCFType, TCFReference};
 
 /// An immutable dictionary of key-value pairs.
 pub struct CFDictionary(CFDictionaryRef);
@@ -33,8 +33,8 @@ impl_TCFType!(CFDictionary, CFDictionaryRef, CFDictionaryGetTypeID);
 impl_CFTypeDescription!(CFDictionary);
 
 impl CFDictionary {
-    pub fn from_CFType_pairs<R1, R2, K, V>(pairs: &[(K, V)]) -> CFDictionary
-            where K: TCFType<R1>, V: TCFType<R2> {
+    pub fn from_CFType_pairs<K, V>(pairs: &[(K, V)]) -> CFDictionary
+            where K: TCFType, V: TCFType {
         let (keys, values): (Vec<CFTypeRef>,Vec<CFTypeRef>) =
             pairs.iter()
             .map(|&(ref key, ref value)| (key.as_CFTypeRef(), value.as_CFTypeRef()))
@@ -73,8 +73,8 @@ impl CFDictionary {
     /// Similar to `contains_key` but acts on a higher level, automatically converting from any
     /// `TCFType` to the raw pointer of its concrete TypeRef.
     #[inline]
-    pub fn contains_key2<X, K: TCFType<*const X>>(&self, key: &K) -> bool {
-        self.contains_key(key.as_concrete_TypeRef() as *const c_void)
+    pub fn contains_key2<K: TCFType>(&self, key: &K) -> bool {
+        self.contains_key(key.as_concrete_TypeRef().as_void_ptr())
     }
 
     #[inline]
@@ -92,8 +92,8 @@ impl CFDictionary {
     /// Similar to `find` but acts on a higher level, automatically converting from any `TCFType`
     /// to the raw pointer of its concrete TypeRef.
     #[inline]
-    pub fn find2<X, K: TCFType<*const X>>(&self, key: &K) -> Option<*const c_void> {
-        self.find(key.as_concrete_TypeRef() as *const c_void)
+    pub fn find2<K: TCFType>(&self, key: &K) -> Option<*const c_void> {
+        self.find(key.as_concrete_TypeRef().as_void_ptr())
     }
 
     /// # Panics
@@ -131,3 +131,30 @@ impl CFDictionary {
         (keys, values)
     }
 }
+
+
+#[cfg(test)]
+pub mod test {
+    use super::*;
+    use ::string::CFString;
+    use ::boolean::{CFBoolean, CFBooleanRef};
+
+    #[test]
+    fn dict_find2_and_contains_key2() {
+        let dict = CFDictionary::from_CFType_pairs(&[
+            (
+                CFString::from_static_string("hello"),
+                CFBoolean::true_value(),
+            ),
+        ]);
+        let key = CFString::from_static_string("hello");
+        let invalid_key = CFString::from_static_string("foobar");
+
+        assert!(dict.contains_key2(&key));
+        assert!(!dict.contains_key2(&invalid_key));
+
+        let value = unsafe { CFBoolean::wrap_under_get_rule(dict.find2(&key).unwrap() as CFBooleanRef) };
+        assert_eq!(value, CFBoolean::true_value());
+        assert_eq!(dict.find2(&invalid_key), None);
+    }
+}

core-foundation/src/lib.rs

@@ -17,7 +17,9 @@ extern crate chrono;
 #[macro_export]
 macro_rules! impl_TCFType {
     ($ty:ident, $raw:ident, $ty_id:ident) => {
-        impl $crate::base::TCFType<$raw> for $ty {
+        impl $crate::base::TCFType for $ty {
+            type ConcreteTypeRef = $raw;
+
             #[inline]
             fn as_concrete_TypeRef(&self) -> $raw {
                 self.0
@@ -74,7 +76,9 @@ macro_rules! impl_TCFType {
 #[macro_export]
 macro_rules! impl_TCFTypeGeneric {
     ($ty:ident, $raw:ident, $ty_id:ident) => {
-        impl<T> $crate::base::TCFType<$raw> for $ty<T> {
+        impl<T> $crate::base::TCFType for $ty<T> {
+            type ConcreteTypeRef = $raw;
+
             #[inline]
             fn as_concrete_TypeRef(&self) -> $raw {
                 self.0

core-foundation/src/propertylist.rs

@@ -16,7 +16,7 @@ use libc::c_void;
 
 use error::CFError;
 use data::CFData;
-use base::{CFType, TCFType};
+use base::{CFType, TCFType, TCFReference};
 
 pub use core_foundation_sys::propertylist::*;
 use core_foundation_sys::error::CFErrorRef;
@@ -62,22 +62,22 @@ pub fn create_data(property_list: *const c_void, format: CFPropertyListFormat) -
 /// Trait for all subclasses of [`CFPropertyList`].
 ///
 /// [`CFPropertyList`]: struct.CFPropertyList.html
-pub trait CFPropertyListSubClass<Raw>: TCFType<*const Raw> {
+pub trait CFPropertyListSubClass: TCFType {
     /// Create an instance of the superclass type [`CFPropertyList`] for this instance.
     ///
     /// [`CFPropertyList`]: struct.CFPropertyList.html
     fn to_CFPropertyList(&self) -> CFPropertyList {
-        unsafe { CFPropertyList::wrap_under_get_rule(self.as_concrete_TypeRef() as *const c_void) }
+        unsafe { CFPropertyList::wrap_under_get_rule(self.as_concrete_TypeRef().as_void_ptr()) }
     }
 }
 
-impl CFPropertyListSubClass<::data::__CFData> for ::data::CFData {}
-impl CFPropertyListSubClass<::string::__CFString> for ::string::CFString {}
-impl CFPropertyListSubClass<::array::__CFArray> for ::array::CFArray {}
-impl CFPropertyListSubClass<::dictionary::__CFDictionary> for ::dictionary::CFDictionary {}
-impl CFPropertyListSubClass<::date::__CFDate> for ::date::CFDate {}
-impl CFPropertyListSubClass<::number::__CFBoolean> for ::boolean::CFBoolean {}
-impl CFPropertyListSubClass<::number::__CFNumber> for ::number::CFNumber {}
+impl CFPropertyListSubClass for ::data::CFData {}
+impl CFPropertyListSubClass for ::string::CFString {}
+impl CFPropertyListSubClass for ::array::CFArray {}
+impl CFPropertyListSubClass for ::dictionary::CFDictionary {}
+impl CFPropertyListSubClass for ::date::CFDate {}
+impl CFPropertyListSubClass for ::boolean::CFBoolean {}
+impl CFPropertyListSubClass for ::number::CFNumber {}
 
 /// A CFPropertyList struct. This is superclass to [`CFData`], [`CFString`], [`CFArray`],
 /// [`CFDictionary`], [`CFDate`], [`CFBoolean`], and [`CFNumber`].
@@ -151,10 +151,8 @@ impl CFPropertyList {
 
     /// Returns true if this value is an instance of another type.
     #[inline]
-    pub fn instance_of<OtherConcreteTypeRef, OtherCFType: TCFType<OtherConcreteTypeRef>>(
-        &self,
-    ) -> bool {
-        self.type_of() == <OtherCFType as TCFType<_>>::type_id()
+    pub fn instance_of<OtherCFType: TCFType>(&self) -> bool {
+        self.type_of() == <OtherCFType as TCFType>::type_id()
     }
 }
 
@@ -190,14 +188,17 @@ impl CFPropertyList {
     /// // Cast it up to a property list.
     /// let propertylist: CFPropertyList = string.to_CFPropertyList();
     /// // Cast it down again.
-    /// assert!(propertylist.downcast::<_, CFString>().unwrap().to_string() == "FooBar");
+    /// assert!(propertylist.downcast::<CFString>().unwrap().to_string() == "FooBar");
     /// ```
     ///
     /// [`CFPropertyList`]: struct.CFPropertyList.html
     /// [`Box::downcast`]: https://doc.rust-lang.org/std/boxed/struct.Box.html#method.downcast
-    pub fn downcast<Raw, T: CFPropertyListSubClass<Raw>>(&self) -> Option<T> {
-        if self.instance_of::<_, T>() {
-            Some(unsafe { T::wrap_under_get_rule(self.0 as *const Raw) })
+    pub fn downcast<T: CFPropertyListSubClass>(&self) -> Option<T> {
+        if self.instance_of::<T>() {
+            let subclass_ref = <T as TCFType>::ConcreteTypeRef::from_void_ptr(self.0);
+            unsafe {
+                Some(T::wrap_under_get_rule(subclass_ref))
+            }
         } else {
             None
         }
@@ -242,14 +243,14 @@ pub mod test {
     #[test]
     fn downcast_string() {
         let propertylist = CFString::from_static_string("Bar").to_CFPropertyList();
-        assert!(propertylist.downcast::<_, CFString>().unwrap().to_string() == "Bar");
-        assert!(propertylist.downcast::<_, CFBoolean>().is_none());
+        assert!(propertylist.downcast::<CFString>().unwrap().to_string() == "Bar");
+        assert!(propertylist.downcast::<CFBoolean>().is_none());
     }
 
     #[test]
     fn downcast_boolean() {
         let propertylist = CFBoolean::true_value().to_CFPropertyList();
-        assert!(propertylist.downcast::<_, CFBoolean>().is_some());
-        assert!(propertylist.downcast::<_, CFString>().is_none());
+        assert!(propertylist.downcast::<CFBoolean>().is_some());
+        assert!(propertylist.downcast::<CFString>().is_none());
     }
 }

core-foundation/src/set.rs

@@ -33,7 +33,7 @@ impl_CFTypeDescription!(CFSet);
 
 impl CFSet {
     /// Creates a new set from a list of `CFType` instances.
-    pub fn from_slice<R, T>(elems: &[T]) -> CFSet where T: TCFType<R> {
+    pub fn from_slice<T>(elems: &[T]) -> CFSet where T: TCFType {
         unsafe {
             let elems: Vec<CFTypeRef> = elems.iter().map(|elem| elem.as_CFTypeRef()).collect();
             let set_ref = CFSetCreate(kCFAllocatorDefault,