Merge pull request SSheldon#4 from madsmtm/objc-foundation-encoding

Make `objc_foundation` use new encoding types

Author: madsmtm

objc/src/declare.rs

@@ -10,7 +10,7 @@ The following example demonstrates declaring a class named `MyNumber` that has
 one ivar, a `u32` named `_number` and a `number` method that returns it:
 
 ``` no_run
-# use objc::class;
+# use objc::{class, sel};
 # use objc::declare::ClassDecl;
 # use objc::runtime::{Class, Object, Sel};
 # fn main() {

objc/src/macros.rs

@@ -6,6 +6,7 @@ To check for a class that may not exist, use `Class::get`.
 
 # Example
 ``` no_run
+# use objc::class;
 # fn main() {
 let cls = class!(NSObject);
 # }
@@ -30,6 +31,7 @@ Registers a selector, returning a `Sel`.
 
 # Example
 ```
+# use objc::sel;
 # fn main() {
 let sel = sel!(description);
 let sel = sel!(setObject:forKey:);
@@ -62,6 +64,7 @@ Variadic arguments are not currently supported.
 
 # Example
 ``` no_run
+# use objc::msg_send;
 # use objc::runtime::Object;
 # fn main() {
 # unsafe {

objc/src/message/mod.rs

@@ -91,7 +91,7 @@ pub unsafe trait Message {
 
     # Example
     ``` no_run
-    # use objc::{class, msg_send};
+    # use objc::{class, msg_send, sel};
     # use objc::runtime::{BOOL, Class, Object};
     # use objc::Message;
     # fn main() {

objc_foundation/Cargo.toml

@@ -14,6 +14,5 @@ exclude = [".gitignore"]
 
 [dependencies]
 block = "0.1"
-# TODO: Refer to the crates in this repo with `path = "XYZ"`
-objc = "0.2.2"
-objc_id = "0.1"
+objc = { path = "../objc", version = "0.2.7" }
+objc_id = { path = "../objc_id", version = "0.1" }

objc_foundation/src/array.rs

@@ -4,6 +4,8 @@ use std::ops::{Index, Range};
 use std::os::raw::c_void;
 
 use objc::runtime::{Class, Object};
+use objc::{class, msg_send};
+use objc::{Encode, Encoding};
 use objc_id::{Id, Owned, Ownership, ShareId, Shared};
 
 use super::{INSCopying, INSFastEnumeration, INSMutableCopying, INSObject, NSEnumerator};
@@ -58,6 +60,11 @@ impl NSRange {
     }
 }
 
+unsafe impl Encode for NSRange {
+    const ENCODING: Encoding<'static> =
+        Encoding::Struct("_NSRange", &[usize::ENCODING, usize::ENCODING]);
+}
+
 unsafe fn from_refs<A>(refs: &[&A::Item]) -> Id<A>
 where
     A: INSArray,

objc_foundation/src/data.rs

@@ -5,6 +5,7 @@ use std::slice;
 
 use super::{INSCopying, INSMutableCopying, INSObject, NSRange};
 use block::{Block, ConcreteBlock};
+use objc::msg_send;
 use objc_id::Id;
 
 pub trait INSData: INSObject {

objc_foundation/src/dictionary.rs

@@ -4,6 +4,7 @@ use std::ops::Index;
 use std::ptr;
 
 use objc::runtime::Class;
+use objc::{class, msg_send};
 use objc_id::{Id, Owned, Ownership, ShareId};
 
 use super::{INSCopying, INSFastEnumeration, INSObject, NSArray, NSEnumerator, NSSharedArray};

objc_foundation/src/enumerator.rs

@@ -4,6 +4,7 @@ use std::os::raw::c_ulong;
 use std::ptr;
 use std::slice;
 
+use objc::msg_send;
 use objc::runtime::Object;
 use objc_id::Id;
 

objc_foundation/src/lib.rs

@@ -1,8 +1,4 @@
 #![crate_name = "objc_foundation"]
-#![crate_type = "lib"]
-
-#[macro_use]
-extern crate objc;
 
 pub use self::array::{
     INSArray, INSMutableArray, NSArray, NSComparisonResult, NSMutableArray, NSMutableSharedArray,

objc_foundation/src/macros.rs

@@ -7,9 +7,17 @@ macro_rules! object_struct {
 
         unsafe impl ::objc::Message for $name {}
 
+        unsafe impl<'a> ::objc::Encode for &'a $name {
+            const ENCODING: ::objc::Encoding<'static> = ::objc::Encoding::Object;
+        }
+
+        unsafe impl<'a> ::objc::Encode for &'a mut $name {
+            const ENCODING: ::objc::Encoding<'static> = ::objc::Encoding::Object;
+        }
+
         impl $crate::INSObject for $name {
             fn class() -> &'static ::objc::runtime::Class {
-                class!($name)
+                ::objc::class!($name)
             }
         }
 
@@ -50,5 +58,13 @@ macro_rules! object_impl {
     );
     ($name:ident, $($t:ident),*) => (
         unsafe impl<$($t),*> ::objc::Message for $name<$($t),*> { }
+
+        unsafe impl<'a, $($t),*> ::objc::Encode for &'a $name<$($t),*> {
+            const ENCODING: ::objc::Encoding<'static> = ::objc::Encoding::Object;
+        }
+
+        unsafe impl<'a, $($t),*> ::objc::Encode for &'a mut $name<$($t),*> {
+            const ENCODING: ::objc::Encoding<'static> = ::objc::Encoding::Object;
+        }
     );
 }

objc_foundation/src/object.rs

@@ -1,5 +1,6 @@
 use std::any::Any;
 
+use objc::msg_send;
 use objc::runtime::{Class, BOOL, NO};
 use objc::Message;
 use objc_id::{Id, ShareId};

objc_foundation/src/string.rs

@@ -3,6 +3,7 @@ use std::os::raw::{c_char, c_void};
 use std::slice;
 use std::str;
 
+use objc::msg_send;
 use objc_id::{Id, ShareId};
 
 use super::INSObject;

objc_foundation/src/value.rs

@@ -6,7 +6,8 @@ use std::os::raw::{c_char, c_void};
 use std::str;
 
 use objc::runtime::Class;
-use objc::{Encode, Encoding};
+use objc::Encode;
+use objc::{class, msg_send};
 use objc_id::Id;
 
 use super::{INSCopying, INSObject};
@@ -15,7 +16,7 @@ pub trait INSValue: INSObject {
     type Value: 'static + Copy + Encode;
 
     fn value(&self) -> Self::Value {
-        assert!(Self::Value::encode() == self.encoding());
+        assert!(&Self::Value::ENCODING == self.encoding());
         let mut value = MaybeUninit::<Self::Value>::uninit();
         let ptr = value.as_mut_ptr() as *mut c_void;
         unsafe {
@@ -24,20 +25,19 @@ pub trait INSValue: INSObject {
         }
     }
 
-    fn encoding(&self) -> Encoding {
+    fn encoding(&self) -> &str {
         unsafe {
             let result: *const c_char = msg_send![self, objCType];
             let s = CStr::from_ptr(result);
-            let s = str::from_utf8(s.to_bytes()).unwrap();
-            Encoding::from_str(s)
+            str::from_utf8(s.to_bytes()).unwrap()
         }
     }
 
     fn from_value(value: Self::Value) -> Id<Self> {
         let cls = Self::class();
         let value_ptr: *const Self::Value = &value;
         let bytes = value_ptr as *const c_void;
-        let encoding = CString::new(Self::Value::encode().as_str()).unwrap();
+        let encoding = CString::new(Self::Value::ENCODING.to_string()).unwrap();
         unsafe {
             let obj: *mut Self = msg_send![cls, alloc];
             let obj: *mut Self = msg_send![obj, initWithBytes:bytes
@@ -85,6 +85,6 @@ mod tests {
     fn test_value() {
         let val = NSValue::from_value(13u32);
         assert!(val.value() == 13);
-        assert!(u32::encode() == val.encoding());
+        assert!(&u32::ENCODING == val.encoding());
     }
 }