Use typed wrap_under_{create,get}_rule() functions

poiru · poiru · commit 46213a7ab046 · 2018-01-30T20:49:10.000+05:30
Just some minor cleanup; no functional changes.
diff --git a/src/font.rs b/src/font.rs
@@ -91,7 +91,7 @@ pub fn new_from_CGFont(cgfont: &CGFont, pt_size: f64) -> CTFont {
                                                     pt_size as CGFloat,
                                                     ptr::null(),
                                                     ptr::null());
-        TCFType::wrap_under_create_rule(font_ref)
+        CTFont::wrap_under_create_rule(font_ref)
     }
 }
 
@@ -100,7 +100,7 @@ pub fn new_from_descriptor(desc: &CTFontDescriptor, pt_size: f64) -> CTFont {
         let font_ref = CTFontCreateWithFontDescriptor(desc.as_concrete_TypeRef(),
                                                       pt_size as CGFloat,
                                                       ptr::null());
-        TCFType::wrap_under_create_rule(font_ref)
+        CTFont::wrap_under_create_rule(font_ref)
     }
 }
 
@@ -113,7 +113,7 @@ pub fn new_from_name(name: &str, pt_size: f64) -> Result<CTFont, ()> {
         if font_ref.is_null() {
             Err(())
         } else {
-            Ok(TCFType::wrap_under_create_rule(font_ref))
+            Ok(CTFont::wrap_under_create_rule(font_ref))
         }
     }
 }
@@ -142,7 +142,7 @@ impl CTFont {
                                                           size as CGFloat,
                                                           ptr::null(),
                                                           ptr::null());
-            TCFType::wrap_under_create_rule(font_ref)
+            CTFont::wrap_under_create_rule(font_ref)
         }
     }
 
@@ -177,7 +177,7 @@ impl CTFont {
 
     pub fn all_traits(&self) -> CTFontTraits {
         unsafe {
-            TCFType::wrap_under_create_rule(CTFontCopyTraits(self.0))
+            CTFontTraits::wrap_under_create_rule(CTFontCopyTraits(self.0))
         }
     }
 
@@ -262,7 +262,7 @@ impl CTFont {
             if result.is_null() {
                 None
             } else {
-                Some(TCFType::wrap_under_create_rule(result))
+                Some(CFData::wrap_under_create_rule(result))
             }
         }
     }
@@ -296,7 +296,7 @@ impl CTFont {
             if result.is_null() {
                 None
             } else {
-                Some(TCFType::wrap_under_create_rule(result as CFURLRef))
+                Some(CFURL::wrap_under_create_rule(result as CFURLRef))
             }
         }
     }
@@ -321,8 +321,7 @@ fn get_string_by_name_key(font: &CTFont, name_key: CFStringRef) -> Option<String
         if result.is_null() {
             None
         } else {
-            let string: CFString = TCFType::wrap_under_create_rule(result);
-            Some(string.to_string())
+            Some(CFString::wrap_under_create_rule(result).to_string())
         }
     }
 }
@@ -362,7 +361,7 @@ pub fn cascade_list_for_languages(font: &CTFont, language_pref_list: &CFArray<CF
         let font_collection_ref =
             CTFontCopyDefaultCascadeListForLanguages(font.as_concrete_TypeRef(),
                                                      language_pref_list.as_concrete_TypeRef());
-        TCFType::wrap_under_create_rule(font_collection_ref)
+        CFArray::wrap_under_create_rule(font_collection_ref)
     }
 }
 
@@ -419,7 +418,7 @@ extern {
                                       matrix: *const CGAffineTransform) -> CTFontRef;
     //fn CTFontCreateWithFontDescriptorAndOptions
     //fn CTFontCreateUIFontForLanguage
-    fn CTFontCreateCopyWithAttributes(font: CTFontRef, size: CGFloat, matrix: *const CGAffineTransform, 
+    fn CTFontCreateCopyWithAttributes(font: CTFontRef, size: CGFloat, matrix: *const CGAffineTransform,
                                       attributes: CTFontDescriptorRef) -> CTFontRef;
     //fn CTFontCreateCopyWithSymbolicTraits
     //fn CTFontCreateCopyWithFamily
@@ -439,7 +438,7 @@ extern {
     //fn CTFontCopyFullName(font: CTFontRef) -> CFStringRef;
     //fn CTFontCopyDisplayName(font: CTFontRef) -> CFStringRef;
     fn CTFontCopyName(font: CTFontRef, nameKey: CFStringRef) -> CFStringRef;
-    //fn CTFontCopyLocalizedName(font: CTFontRef, nameKey: CFStringRef, 
+    //fn CTFontCopyLocalizedName(font: CTFontRef, nameKey: CFStringRef,
     //                           language: *CFStringRef) -> CFStringRef;
     #[cfg(feature = "mountainlion")]
     fn CTFontCopyDefaultCascadeListForLanguages(font: CTFontRef, languagePrefList: CFArrayRef) -> CFArrayRef;
@@ -496,8 +495,8 @@ extern {
     /* Converting Fonts */
     fn CTFontCopyGraphicsFont(font: CTFontRef, attributes: *mut CTFontDescriptorRef)
                               -> CGFontRef;
-    fn CTFontCreateWithGraphicsFont(graphicsFont: CGFontRef, size: CGFloat, 
-                                    matrix: *const CGAffineTransform, 
+    fn CTFontCreateWithGraphicsFont(graphicsFont: CGFontRef, size: CGFloat,
+                                    matrix: *const CGAffineTransform,
                                     attributes: CTFontDescriptorRef) -> CTFontRef;
     //fn CTFontGetPlatformFont
     //fn CTFontCreateWithPlatformFont
diff --git a/src/font_collection.rs b/src/font_collection.rs
@@ -38,39 +38,39 @@ impl CTFontCollection {
         // surprise! this function follows the Get rule, despite being named *Create*.
         // So we have to addRef it to avoid CTFontCollection from double freeing it later.
         unsafe {
-            TCFType::wrap_under_get_rule(CTFontCollectionCreateMatchingFontDescriptors(self.0))
+            CFArray::wrap_under_get_rule(CTFontCollectionCreateMatchingFontDescriptors(self.0))
         }
     }
 }
 
 pub fn new_from_descriptors(descs: &CFArray<CTFontDescriptor>) -> CTFontCollection {
     unsafe {
-        let key: CFString = TCFType::wrap_under_get_rule(kCTFontCollectionRemoveDuplicatesOption);
+        let key = CFString::wrap_under_get_rule(kCTFontCollectionRemoveDuplicatesOption);
         let value = CFNumber::from(1i64);
         let options = CFDictionary::from_CFType_pairs(&[ (key.as_CFType(), value.as_CFType()) ]);
         let font_collection_ref =
             CTFontCollectionCreateWithFontDescriptors(descs.as_concrete_TypeRef(),
                                                       options.as_concrete_TypeRef());
-        TCFType::wrap_under_create_rule(font_collection_ref)
+        CTFontCollection::wrap_under_create_rule(font_collection_ref)
     }
 }
 
 pub fn create_for_all_families() -> CTFontCollection {
     unsafe {
-        let key: CFString = TCFType::wrap_under_get_rule(kCTFontCollectionRemoveDuplicatesOption);
+        let key = CFString::wrap_under_get_rule(kCTFontCollectionRemoveDuplicatesOption);
         let value = CFNumber::from(1i64);
         let options = CFDictionary::from_CFType_pairs(&[ (key.as_CFType(), value.as_CFType()) ]);
         let font_collection_ref =
             CTFontCollectionCreateFromAvailableFonts(options.as_concrete_TypeRef());
-        TCFType::wrap_under_create_rule(font_collection_ref)
+        CTFontCollection::wrap_under_create_rule(font_collection_ref)
     }
 }
 
 pub fn create_for_family(family: &str) -> Option<CTFontCollection> {
     use font_descriptor::kCTFontFamilyNameAttribute;
 
     unsafe {
-        let family_attr: CFString = TCFType::wrap_under_get_rule(kCTFontFamilyNameAttribute);
+        let family_attr = CFString::wrap_under_get_rule(kCTFontFamilyNameAttribute);
         let family_name: CFString = family.parse().unwrap();
         let specified_attrs = CFDictionary::from_CFType_pairs(&[
             (family_attr.as_CFType(), family_name.as_CFType())
@@ -85,7 +85,7 @@ pub fn create_for_family(family: &str) -> Option<CTFontCollection> {
         if matched_descs == ptr::null() {
             return None;
         }
-        let matched_descs: CFArray<CTFontDescriptor> = TCFType::wrap_under_create_rule(matched_descs);
+        let matched_descs = CFArray::wrap_under_create_rule(matched_descs);
         // I suppose one doesn't even need the CTFontCollection object at this point.
         // But we stick descriptors into and out of it just to provide a nice wrapper API.
         Some(new_from_descriptors(&matched_descs))
@@ -94,7 +94,7 @@ pub fn create_for_family(family: &str) -> Option<CTFontCollection> {
 
 pub fn get_family_names() -> CFArray<CFString> {
     unsafe {
-        TCFType::wrap_under_create_rule(CTFontManagerCopyAvailableFontFamilyNames())
+        CFArray::wrap_under_create_rule(CTFontManagerCopyAvailableFontFamilyNames())
     }
 }
 
@@ -109,7 +109,7 @@ extern {
     //                                                 descriptors: CFArrayRef,
     //                                                 options: CFDictionaryRef) -> CTFontCollectionRef;
     fn CTFontCollectionCreateFromAvailableFonts(options: CFDictionaryRef) -> CTFontCollectionRef;
-    // this stupid function doesn't actually do any wildcard expansion; 
+    // this stupid function doesn't actually do any wildcard expansion;
     // it just chooses the best match. Use
     // CTFontDescriptorCreateMatchingDescriptors instead.
     fn CTFontCollectionCreateMatchingFontDescriptors(collection: CTFontCollectionRef) -> CFArrayRef;
diff --git a/src/font_descriptor.rs b/src/font_descriptor.rs
@@ -131,7 +131,7 @@ impl TraitAccessorPrivate for CTFontTraits {
     unsafe fn extract_number_for_key(&self, key: CFStringRef) -> CFNumber {
         let cftype = self.get_CFType(mem::transmute(key));
         assert!(cftype.instance_of::<CFNumber>());
-        TCFType::wrap_under_get_rule(mem::transmute(cftype.as_CFTypeRef()))
+        CFNumber::wrap_under_get_rule(mem::transmute(cftype.as_CFTypeRef()))
     }
 
 }
@@ -202,9 +202,9 @@ impl CTFontDescriptor {
                 return None
             }
 
-            let value: CFType = TCFType::wrap_under_create_rule(value);
+            let value = CFType::wrap_under_create_rule(value);
             assert!(value.instance_of::<CFString>());
-            let s: CFString = TCFType::wrap_under_get_rule(mem::transmute(value.as_CFTypeRef()));
+            let s = CFString::wrap_under_get_rule(mem::transmute(value.as_CFTypeRef()));
             Some(s.to_string())
         }
     }
@@ -247,9 +247,9 @@ impl CTFontDescriptor {
                 return None;
             }
 
-            let value: CFType = TCFType::wrap_under_create_rule(value);
+            let value = CFType::wrap_under_create_rule(value);
             assert!(value.instance_of::<CFURL>());
-            let url: CFURL = TCFType::wrap_under_get_rule(mem::transmute(value.as_CFTypeRef()));
+            let url = CFURL::wrap_under_get_rule(mem::transmute(value.as_CFTypeRef()));
             Some(format!("{:?}", url))
         }
     }
@@ -258,10 +258,9 @@ impl CTFontDescriptor {
         unsafe {
             let value = CTFontDescriptorCopyAttribute(self.0, kCTFontTraitsAttribute);
             assert!(!value.is_null());
-            let value: CFType = TCFType::wrap_under_create_rule(value);
+            let value = CFType::wrap_under_create_rule(value);
             assert!(value.instance_of::<CFDictionary>());
-            let dictionary: CFDictionary = TCFType::wrap_under_get_rule(mem::transmute(value.as_CFTypeRef()));
-            dictionary
+            CFDictionary::wrap_under_get_rule(mem::transmute(value.as_CFTypeRef()))
         }
     }
 }
@@ -270,7 +269,7 @@ pub fn new_from_attributes(attributes: &CFDictionary) -> CTFontDescriptor {
     unsafe {
         let result: CTFontDescriptorRef =
             CTFontDescriptorCreateWithAttributes(attributes.as_concrete_TypeRef());
-        TCFType::wrap_under_create_rule(result)
+        CTFontDescriptor::wrap_under_create_rule(result)
     }
 }
 

Original file line number	Diff line number	Diff line change
`@@ -91,7 +91,7 @@ pub fn new_from_CGFont(cgfont: &CGFont, pt_size: f64) -> CTFont {`
`91`	`91`	`pt_size as CGFloat,`
`92`	`92`	`ptr::null(),`
`93`	`93`	`ptr::null());`
`94`		`- TCFType::wrap_under_create_rule(font_ref)`
	`94`	`+ CTFont::wrap_under_create_rule(font_ref)`
`95`	`95`	`}`
`96`	`96`	`}`
`97`	`97`
`@@ -100,7 +100,7 @@ pub fn new_from_descriptor(desc: &CTFontDescriptor, pt_size: f64) -> CTFont {`
`100`	`100`	`let font_ref = CTFontCreateWithFontDescriptor(desc.as_concrete_TypeRef(),`
`101`	`101`	`pt_size as CGFloat,`
`102`	`102`	`ptr::null());`
`103`		`- TCFType::wrap_under_create_rule(font_ref)`
	`103`	`+ CTFont::wrap_under_create_rule(font_ref)`
`104`	`104`	`}`
`105`	`105`	`}`
`106`	`106`
`@@ -113,7 +113,7 @@ pub fn new_from_name(name: &str, pt_size: f64) -> Result<CTFont, ()> {`
`113`	`113`	`if font_ref.is_null() {`
`114`	`114`	`Err(())`
`115`	`115`	`} else {`
`116`		`- Ok(TCFType::wrap_under_create_rule(font_ref))`
	`116`	`+ Ok(CTFont::wrap_under_create_rule(font_ref))`
`117`	`117`	`}`
`118`	`118`	`}`
`119`	`119`	`}`
`@@ -142,7 +142,7 @@ impl CTFont {`
`142`	`142`	`size as CGFloat,`
`143`	`143`	`ptr::null(),`
`144`	`144`	`ptr::null());`
`145`		`- TCFType::wrap_under_create_rule(font_ref)`
	`145`	`+ CTFont::wrap_under_create_rule(font_ref)`
`146`	`146`	`}`
`147`	`147`	`}`
`148`	`148`
`@@ -177,7 +177,7 @@ impl CTFont {`
`177`	`177`
`178`	`178`	`pub fn all_traits(&self) -> CTFontTraits {`
`179`	`179`	`unsafe {`
`180`		`- TCFType::wrap_under_create_rule(CTFontCopyTraits(self.0))`
	`180`	`+ CTFontTraits::wrap_under_create_rule(CTFontCopyTraits(self.0))`
`181`	`181`	`}`
`182`	`182`	`}`
`183`	`183`
`@@ -262,7 +262,7 @@ impl CTFont {`
`262`	`262`	`if result.is_null() {`
`263`	`263`	`None`
`264`	`264`	`} else {`
`265`		`- Some(TCFType::wrap_under_create_rule(result))`
	`265`	`+ Some(CFData::wrap_under_create_rule(result))`
`266`	`266`	`}`
`267`	`267`	`}`
`268`	`268`	`}`
`@@ -296,7 +296,7 @@ impl CTFont {`
`296`	`296`	`if result.is_null() {`
`297`	`297`	`None`
`298`	`298`	`} else {`
`299`		`- Some(TCFType::wrap_under_create_rule(result as CFURLRef))`
	`299`	`+ Some(CFURL::wrap_under_create_rule(result as CFURLRef))`
`300`	`300`	`}`
`301`	`301`	`}`
`302`	`302`	`}`
`@@ -321,8 +321,7 @@ fn get_string_by_name_key(font: &CTFont, name_key: CFStringRef) -> Option<String`
`321`	`321`	`if result.is_null() {`
`322`	`322`	`None`
`323`	`323`	`} else {`
`324`		`- let string: CFString = TCFType::wrap_under_create_rule(result);`
`325`		`- Some(string.to_string())`
	`324`	`+ Some(CFString::wrap_under_create_rule(result).to_string())`
`326`	`325`	`}`
`327`	`326`	`}`
`328`	`327`	`}`
`@@ -362,7 +361,7 @@ pub fn cascade_list_for_languages(font: &CTFont, language_pref_list: &CFArray<CF`
`362`	`361`	`let font_collection_ref =`
`363`	`362`	`CTFontCopyDefaultCascadeListForLanguages(font.as_concrete_TypeRef(),`
`364`	`363`	`language_pref_list.as_concrete_TypeRef());`
`365`		`- TCFType::wrap_under_create_rule(font_collection_ref)`
	`364`	`+ CFArray::wrap_under_create_rule(font_collection_ref)`
`366`	`365`	`}`
`367`	`366`	`}`
`368`	`367`
`@@ -419,7 +418,7 @@ extern {`
`419`	`418`	`matrix: *const CGAffineTransform) -> CTFontRef;`
`420`	`419`	`//fn CTFontCreateWithFontDescriptorAndOptions`
`421`	`420`	`//fn CTFontCreateUIFontForLanguage`
`422`		`- fn CTFontCreateCopyWithAttributes(font: CTFontRef, size: CGFloat, matrix: *const CGAffineTransform,`
	`421`	`+ fn CTFontCreateCopyWithAttributes(font: CTFontRef, size: CGFloat, matrix: *const CGAffineTransform,`
`423`	`422`	`attributes: CTFontDescriptorRef) -> CTFontRef;`
`424`	`423`	`//fn CTFontCreateCopyWithSymbolicTraits`
`425`	`424`	`//fn CTFontCreateCopyWithFamily`
`@@ -439,7 +438,7 @@ extern {`
`439`	`438`	`//fn CTFontCopyFullName(font: CTFontRef) -> CFStringRef;`
`440`	`439`	`//fn CTFontCopyDisplayName(font: CTFontRef) -> CFStringRef;`
`441`	`440`	`fn CTFontCopyName(font: CTFontRef, nameKey: CFStringRef) -> CFStringRef;`
`442`		`- //fn CTFontCopyLocalizedName(font: CTFontRef, nameKey: CFStringRef,`
	`441`	`+ //fn CTFontCopyLocalizedName(font: CTFontRef, nameKey: CFStringRef,`
`443`	`442`	`// language: *CFStringRef) -> CFStringRef;`
`444`	`443`	`#[cfg(feature = "mountainlion")]`
`445`	`444`	`fn CTFontCopyDefaultCascadeListForLanguages(font: CTFontRef, languagePrefList: CFArrayRef) -> CFArrayRef;`
`@@ -496,8 +495,8 @@ extern {`
`496`	`495`	`/* Converting Fonts */`
`497`	`496`	`fn CTFontCopyGraphicsFont(font: CTFontRef, attributes: *mut CTFontDescriptorRef)`
`498`	`497`	`-> CGFontRef;`
`499`		`- fn CTFontCreateWithGraphicsFont(graphicsFont: CGFontRef, size: CGFloat,`
`500`		`- matrix: *const CGAffineTransform,`
	`498`	`+ fn CTFontCreateWithGraphicsFont(graphicsFont: CGFontRef, size: CGFloat,`
	`499`	`+ matrix: *const CGAffineTransform,`
`501`	`500`	`attributes: CTFontDescriptorRef) -> CTFontRef;`
`502`	`501`	`//fn CTFontGetPlatformFont`
`503`	`502`	`//fn CTFontCreateWithPlatformFont`
Original file line number	Diff line number	Diff line change
`@@ -131,7 +131,7 @@ impl TraitAccessorPrivate for CTFontTraits {`
`131`	`131`	`unsafe fn extract_number_for_key(&self, key: CFStringRef) -> CFNumber {`
`132`	`132`	`let cftype = self.get_CFType(mem::transmute(key));`
`133`	`133`	`assert!(cftype.instance_of::<CFNumber>());`
`134`		`- TCFType::wrap_under_get_rule(mem::transmute(cftype.as_CFTypeRef()))`
	`134`	`+ CFNumber::wrap_under_get_rule(mem::transmute(cftype.as_CFTypeRef()))`
`135`	`135`	`}`
`136`	`136`
`137`	`137`	`}`
`@@ -202,9 +202,9 @@ impl CTFontDescriptor {`
`202`	`202`	`return None`
`203`	`203`	`}`
`204`	`204`
`205`		`- let value: CFType = TCFType::wrap_under_create_rule(value);`
	`205`	`+ let value = CFType::wrap_under_create_rule(value);`
`206`	`206`	`assert!(value.instance_of::<CFString>());`
`207`		`- let s: CFString = TCFType::wrap_under_get_rule(mem::transmute(value.as_CFTypeRef()));`
	`207`	`+ let s = CFString::wrap_under_get_rule(mem::transmute(value.as_CFTypeRef()));`
`208`	`208`	`Some(s.to_string())`
`209`	`209`	`}`
`210`	`210`	`}`
`@@ -247,9 +247,9 @@ impl CTFontDescriptor {`
`247`	`247`	`return None;`
`248`	`248`	`}`
`249`	`249`
`250`		`- let value: CFType = TCFType::wrap_under_create_rule(value);`
	`250`	`+ let value = CFType::wrap_under_create_rule(value);`
`251`	`251`	`assert!(value.instance_of::<CFURL>());`
`252`		`- let url: CFURL = TCFType::wrap_under_get_rule(mem::transmute(value.as_CFTypeRef()));`
	`252`	`+ let url = CFURL::wrap_under_get_rule(mem::transmute(value.as_CFTypeRef()));`
`253`	`253`	`Some(format!("{:?}", url))`
`254`	`254`	`}`
`255`	`255`	`}`
`@@ -258,10 +258,9 @@ impl CTFontDescriptor {`
`258`	`258`	`unsafe {`
`259`	`259`	`let value = CTFontDescriptorCopyAttribute(self.0, kCTFontTraitsAttribute);`
`260`	`260`	`assert!(!value.is_null());`
`261`		`- let value: CFType = TCFType::wrap_under_create_rule(value);`
	`261`	`+ let value = CFType::wrap_under_create_rule(value);`
`262`	`262`	`assert!(value.instance_of::<CFDictionary>());`
`263`		`- let dictionary: CFDictionary = TCFType::wrap_under_get_rule(mem::transmute(value.as_CFTypeRef()));`
`264`		`- dictionary`
	`263`	`+ CFDictionary::wrap_under_get_rule(mem::transmute(value.as_CFTypeRef()))`
`265`	`264`	`}`
`266`	`265`	`}`
`267`	`266`	`}`
`@@ -270,7 +269,7 @@ pub fn new_from_attributes(attributes: &CFDictionary) -> CTFontDescriptor {`
`270`	`269`	`unsafe {`
`271`	`270`	`let result: CTFontDescriptorRef =`
`272`	`271`	`CTFontDescriptorCreateWithAttributes(attributes.as_concrete_TypeRef());`
`273`		`- TCFType::wrap_under_create_rule(result)`
	`272`	`+ CTFontDescriptor::wrap_under_create_rule(result)`
`274`	`273`	`}`
`275`	`274`	`}`
`276`	`275`