Implement TCFType by macro

All of the manually implemented methods are identical, but can't be made
default implementations unfortunately.

src/array.rs

@@ -9,7 +9,7 @@
 
 //! Heterogeneous immutable arrays.
 
-use base::{CFAllocatorRef, CFIndex, CFIndexConvertible, CFRelease, CFRetain};
+use base::{CFAllocatorRef, CFIndex, CFIndexConvertible, CFRelease};
 use base::{CFTypeID, CFTypeRef, TCFType};
 use base::{kCFAllocatorDefault};
 use libc::c_void;
@@ -73,37 +73,7 @@ impl<'a> Iterator for CFArrayIterator<'a> {
     }
 }
 
-impl TCFType<CFArrayRef> for CFArray {
-    #[inline]
-    fn as_concrete_TypeRef(&self) -> CFArrayRef {
-        self.0
-    }
-
-    #[inline]
-    unsafe fn wrap_under_get_rule(reference: CFArrayRef) -> CFArray {
-        let reference: CFArrayRef = mem::transmute(CFRetain(mem::transmute(reference)));
-        TCFType::wrap_under_create_rule(reference)
-    }
-
-    #[inline]
-    fn as_CFTypeRef(&self) -> CFTypeRef {
-        unsafe {
-            mem::transmute(self.as_concrete_TypeRef())
-        }
-    }
-
-    #[inline]
-    unsafe fn wrap_under_create_rule(obj: CFArrayRef) -> CFArray {
-        CFArray(obj)
-    }
-
-    #[inline]
-    fn type_id() -> CFTypeID {
-        unsafe {
-            CFArrayGetTypeID()
-        }
-    }
-}
+impl_TCFType!(CFArray, CFArrayRef, CFArrayGetTypeID);
 
 impl CFArray {
     /// Creates a new `CFArray` with the given elements, which must be `CFType` objects.

src/boolean.rs

@@ -9,7 +9,7 @@
 
 //! A Boolean type.
 
-use base::{CFRelease, CFRetain, CFTypeID, CFTypeRef, TCFType};
+use base::{CFRelease, CFTypeID, TCFType};
 use std::mem;
 
 pub type Boolean = u32;
@@ -32,36 +32,7 @@ impl Drop for CFBoolean {
     }
 }
 
-impl TCFType<CFBooleanRef> for CFBoolean {
-    #[inline]
-    fn as_concrete_TypeRef(&self) -> CFBooleanRef {
-        self.0
-    }
-
-    #[inline]
-    unsafe fn wrap_under_get_rule(reference: CFBooleanRef) -> CFBoolean {
-        let reference: CFBooleanRef = mem::transmute(CFRetain(mem::transmute(reference)));
-        TCFType::wrap_under_create_rule(reference)
-    }
-
-    #[inline]
-    fn as_CFTypeRef(&self) -> CFTypeRef {
-        unsafe {
-            mem::transmute(self.as_concrete_TypeRef())
-        }
-    }
-
-    unsafe fn wrap_under_create_rule(obj: CFBooleanRef) -> CFBoolean {
-        CFBoolean(obj)
-    }
-
-    #[inline]
-    fn type_id() -> CFTypeID {
-        unsafe {
-            CFBooleanGetTypeID()
-        }
-    }
-}
+impl_TCFType!(CFBoolean, CFBooleanRef, CFBooleanGetTypeID);
 
 impl CFBoolean {
     pub fn true_value() -> CFBoolean {

src/bundle.rs

@@ -9,7 +9,7 @@
 
 //! Core Foundation Bundle Type
 
-use base::{CFRelease, CFRetain, CFTypeID, CFTypeRef, TCFType};
+use base::{CFRelease, CFTypeID, TCFType};
 use std::mem;
 
 use string::CFStringRef;
@@ -31,36 +31,7 @@ impl Drop for CFBundle {
     }
 }
 
-impl TCFType<CFBundleRef> for CFBundle {
-    #[inline]
-    fn as_concrete_TypeRef(&self) -> CFBundleRef {
-        self.0
-    }
-
-    #[inline]
-    unsafe fn wrap_under_get_rule(reference: CFBundleRef) -> CFBundle {
-        let reference: CFBundleRef = mem::transmute(CFRetain(mem::transmute(reference)));
-        TCFType::wrap_under_create_rule(reference)
-    }
-
-    #[inline]
-    fn as_CFTypeRef(&self) -> CFTypeRef {
-        unsafe {
-            mem::transmute(self.as_concrete_TypeRef())
-        }
-    }
-
-    unsafe fn wrap_under_create_rule(obj: CFBundleRef) -> CFBundle {
-        CFBundle(obj)
-    }
-
-    #[inline]
-    fn type_id() -> CFTypeID {
-        unsafe {
-            CFBundleGetTypeID()
-        }
-    }
-}
+impl_TCFType!(CFBundle, CFBundleRef, CFBundleGetTypeID);
 
 #[link(name = "CoreFoundation", kind = "framework")]
 extern {

src/data.rs

@@ -9,8 +9,8 @@
 
 //! Core Foundation byte buffers.
 
-use base::{CFAllocatorRef, CFIndex, CFIndexConvertible, CFRelease, CFRetain};
-use base::{CFTypeID, CFTypeRef, TCFType, kCFAllocatorDefault};
+use base::{CFAllocatorRef, CFIndex, CFIndexConvertible, CFRelease};
+use base::{CFTypeID, TCFType, kCFAllocatorDefault};
 
 use std::mem;
 use std::ops::Deref;
@@ -32,36 +32,7 @@ impl Drop for CFData {
     }
 }
 
-impl TCFType<CFDataRef> for CFData {
-    #[inline]
-    fn as_concrete_TypeRef(&self) -> CFDataRef {
-        self.0
-    }
-
-    #[inline]
-    unsafe fn wrap_under_get_rule(reference: CFDataRef) -> CFData {
-        let reference: CFDataRef = mem::transmute(CFRetain(mem::transmute(reference)));
-        TCFType::wrap_under_create_rule(reference)
-    }
-
-    #[inline]
-    fn as_CFTypeRef(&self) -> CFTypeRef {
-        unsafe {
-            mem::transmute(self.as_concrete_TypeRef())
-        }
-    }
-
-    unsafe fn wrap_under_create_rule(obj: CFDataRef) -> CFData {
-        CFData(obj)
-    }
-
-    #[inline]
-    fn type_id() -> CFTypeID {
-        unsafe {
-            CFDataGetTypeID()
-        }
-    }
-}
+impl_TCFType!(CFData, CFDataRef, CFDataGetTypeID);
 
 impl CFData {
     pub fn from_buffer(buffer: &[u8]) -> CFData {

src/dictionary.rs

@@ -9,7 +9,7 @@
 
 //! Dictionaries of key-value pairs.
 
-use base::{Boolean, CFAllocatorRef, CFIndex, CFIndexConvertible, CFRelease, CFRetain};
+use base::{Boolean, CFAllocatorRef, CFIndex, CFIndexConvertible, CFRelease};
 use base::{CFType, CFTypeID, CFTypeRef, TCFType, kCFAllocatorDefault};
 
 use libc::c_void;
@@ -62,36 +62,7 @@ impl Drop for CFDictionary {
     }
 }
 
-impl TCFType<CFDictionaryRef> for CFDictionary {
-    #[inline]
-    fn as_concrete_TypeRef(&self) -> CFDictionaryRef {
-        self.0
-    }
-
-    #[inline]
-    unsafe fn wrap_under_get_rule(reference: CFDictionaryRef) -> CFDictionary {
-        let reference: CFDictionaryRef = mem::transmute(CFRetain(mem::transmute(reference)));
-        TCFType::wrap_under_create_rule(reference)
-    }
-
-    #[inline]
-    fn as_CFTypeRef(&self) -> CFTypeRef {
-        unsafe {
-            mem::transmute(self.as_concrete_TypeRef())
-        }
-    }
-
-    unsafe fn wrap_under_create_rule(obj: CFDictionaryRef) -> CFDictionary {
-        CFDictionary(obj)
-    }
-
-    #[inline]
-    fn type_id() -> CFTypeID {
-        unsafe {
-            CFDictionaryGetTypeID()
-        }
-    }
-}
+impl_TCFType!(CFDictionary, CFDictionaryRef, CFDictionaryGetTypeID);
 
 impl CFDictionary {
     pub fn from_CFType_pairs<R1, R2, K, V>(pairs: &[(K, V)]) -> CFDictionary

src/lib.rs

@@ -14,6 +14,43 @@
 
 extern crate libc;
 
+#[macro_export]
+macro_rules! impl_TCFType {
+    ($ty:ident, $raw:ident, $ty_id:ident) => {
+        impl $crate::base::TCFType<$raw> for $ty {
+            #[inline]
+            fn as_concrete_TypeRef(&self) -> $raw {
+                self.0
+            }
+
+            #[inline]
+            unsafe fn wrap_under_get_rule(reference: $raw) -> $ty {
+                let reference = mem::transmute($crate::base::CFRetain(mem::transmute(reference)));
+                $crate::base::TCFType::wrap_under_create_rule(reference)
+            }
+
+            #[inline]
+            fn as_CFTypeRef(&self) -> $crate::base::CFTypeRef {
+                unsafe {
+                    mem::transmute(self.as_concrete_TypeRef())
+                }
+            }
+
+            #[inline]
+            unsafe fn wrap_under_create_rule(obj: $raw) -> $ty {
+                $ty(obj)
+            }
+
+            #[inline]
+            fn type_id() -> $crate::base::CFTypeID {
+                unsafe {
+                    $ty_id()
+                }
+            }
+        }
+    }
+}
+
 pub mod array;
 pub mod base;
 pub mod boolean;

src/number.rs

@@ -11,7 +11,7 @@
 
 #![allow(non_upper_case_globals)]
 
-use base::{CFAllocatorRef, CFRelease, CFRetain, CFTypeID, CFTypeRef};
+use base::{CFAllocatorRef, CFRelease, CFTypeID};
 use base::{TCFType, kCFAllocatorDefault};
 
 use libc::c_void;
@@ -54,36 +54,7 @@ impl Drop for CFNumber {
     }
 }
 
-impl TCFType<CFNumberRef> for CFNumber {
-    #[inline]
-    fn as_concrete_TypeRef(&self) -> CFNumberRef {
-        self.0
-    }
-
-    #[inline]
-    unsafe fn wrap_under_get_rule(reference: CFNumberRef) -> CFNumber {
-        let reference: CFNumberRef = mem::transmute(CFRetain(mem::transmute(reference)));
-        TCFType::wrap_under_create_rule(reference)
-    }
-
-    #[inline]
-    fn as_CFTypeRef(&self) -> CFTypeRef {
-        unsafe {
-            mem::transmute(self.as_concrete_TypeRef())
-        }
-    }
-
-    unsafe fn wrap_under_create_rule(obj: CFNumberRef) -> CFNumber {
-        CFNumber(obj)
-    }
-
-    #[inline]
-    fn type_id() -> CFTypeID {
-        unsafe {
-            CFNumberGetTypeID()
-        }
-    }
-}
+impl_TCFType!(CFNumber, CFNumberRef, CFNumberGetTypeID);
 
 // TODO(pcwalton): Floating point.
 impl CFNumber {