Updated foundation to compile with alpha2.

Author: SSheldon

array.rs

@@ -1,8 +1,9 @@
 use std::cmp::Ordering;
+use std::marker::PhantomData;
 use std::ops::{Index, Range};
 
-use objc::runtime::Object;
 use objc::{Id, IdSlice, Owned, Ownership, Shared, ShareId};
+use objc::runtime::{Class, Object};
 
 use {INSCopying, INSFastEnumeration, INSMutableCopying, INSObject, NSEnumerator};
 
@@ -155,10 +156,18 @@ pub trait INSSharedArray : INSArray<Own=Shared> {
     }
 }
 
-pub enum NSArray<T, O = Owned> { }
+pub struct NSArray<T, O = Owned> {
+    item: PhantomData<Id<T, O>>,
+}
 
 object_impl!(NSArray<T, O>);
 
+impl<T, O> INSObject for NSArray<T, O> where T: INSObject, O: Ownership {
+    fn class() -> &'static Class {
+        Class::get("NSArray").unwrap()
+    }
+}
+
 impl<T, O> INSArray for NSArray<T, O> where T: INSObject, O: Ownership {
     type Item = T;
     type Own = O;
@@ -168,15 +177,16 @@ impl<T> INSOwnedArray for NSArray<T, Owned> where T: INSObject { }
 
 impl<T> INSSharedArray for NSArray<T, Shared> where T: INSObject { }
 
-impl<T> INSCopying for NSArray<T, Shared> {
+impl<T> INSCopying for NSArray<T, Shared> where T: INSObject {
     type Output = NSSharedArray<T>;
 }
 
-impl<T> INSMutableCopying for NSArray<T, Shared> {
+impl<T> INSMutableCopying for NSArray<T, Shared> where T: INSObject {
     type Output = NSMutableSharedArray<T>;
 }
 
-impl<T, O> INSFastEnumeration for NSArray<T, O> where T: INSObject {
+impl<T, O> INSFastEnumeration for NSArray<T, O>
+        where T: INSObject, O: Ownership {
     type Item = T;
 }
 
@@ -261,10 +271,18 @@ pub trait INSMutableArray : INSArray {
     }
 }
 
-pub enum NSMutableArray<T, O = Owned> { }
+pub struct NSMutableArray<T, O = Owned> {
+    item: PhantomData<Id<T, O>>,
+}
 
 object_impl!(NSMutableArray<T, O>);
 
+impl<T, O> INSObject for NSMutableArray<T, O> where T: INSObject, O: Ownership {
+    fn class() -> &'static Class {
+        Class::get("NSMutableArray").unwrap()
+    }
+}
+
 impl<T, O> INSArray for NSMutableArray<T, O> where T: INSObject, O: Ownership {
     type Item = T;
     type Own = O;
@@ -277,15 +295,16 @@ impl<T> INSSharedArray for NSMutableArray<T, Shared> where T: INSObject { }
 impl<T, O> INSMutableArray for NSMutableArray<T, O>
         where T: INSObject, O: Ownership { }
 
-impl<T> INSCopying for NSMutableArray<T, Shared> {
+impl<T> INSCopying for NSMutableArray<T, Shared> where T: INSObject {
     type Output = NSSharedArray<T>;
 }
 
-impl<T> INSMutableCopying for NSMutableArray<T, Shared> {
+impl<T> INSMutableCopying for NSMutableArray<T, Shared> where T: INSObject {
     type Output = NSMutableSharedArray<T>;
 }
 
-impl<T, O> INSFastEnumeration for NSMutableArray<T, O> where T: INSObject {
+impl<T, O> INSFastEnumeration for NSMutableArray<T, O>
+        where T: INSObject, O: Ownership {
     type Item = T;
 }
 

dictionary.rs

@@ -1,8 +1,10 @@
 use std::cmp::min;
+use std::marker::PhantomData;
 use std::ops::Index;
 use std::ptr;
 
-use objc::{Id, IdSlice, Owned, Ownership};
+use objc::{Id, IdSlice, Owned, Ownership, ShareId};
+use objc::runtime::Class;
 
 use {
     INSArray, INSFastEnumeration, INSCopying, INSObject,
@@ -111,7 +113,18 @@ pub trait INSDictionary : INSObject {
     }
 }
 
-object_struct!(NSDictionary<K, V>);
+pub struct NSDictionary<K, V> {
+    key: PhantomData<ShareId<K>>,
+    obj: PhantomData<Id<V>>,
+}
+
+object_impl!(NSDictionary<K, V>);
+
+impl<K, V> INSObject for NSDictionary<K, V> where K: INSObject, V: INSObject {
+    fn class() -> &'static Class {
+        Class::get("NSDictionary").unwrap()
+    }
+}
 
 impl<K, V> INSDictionary for NSDictionary<K, V>
         where K: INSObject, V: INSObject {
@@ -120,7 +133,8 @@ impl<K, V> INSDictionary for NSDictionary<K, V>
     type Own = Owned;
 }
 
-impl<K, V> INSFastEnumeration for NSDictionary<K, V> where K: INSObject {
+impl<K, V> INSFastEnumeration for NSDictionary<K, V>
+        where K: INSObject, V: INSObject {
     type Item = K;
 }
 

enumerator.rs

@@ -1,4 +1,4 @@
-use std::marker::ContravariantLifetime;
+use std::marker::PhantomData;
 use std::mem;
 use std::ptr;
 use std::slice;
@@ -9,14 +9,14 @@ use objc::runtime::Object;
 
 use INSObject;
 
-pub struct NSEnumerator<'a, T> {
+pub struct NSEnumerator<'a, T> where T: INSObject {
     id: Id<Object>,
-    marker: ContravariantLifetime<'a>,
+    item: PhantomData<&'a T>,
 }
 
 impl<'a, T> NSEnumerator<'a, T> where T: INSObject {
     pub unsafe fn from_ptr(ptr: *mut Object) -> NSEnumerator<'a, T> {
-        NSEnumerator { id: Id::from_ptr(ptr), marker: ContravariantLifetime }
+        NSEnumerator { id: Id::from_ptr(ptr), item: PhantomData }
     }
 }
 

macros.rs

@@ -10,23 +10,6 @@ macro_rules! object_struct {
         pub enum $name<$($t),*> { }
 
         object_impl!($name $(,$t)*);
-    );
-}
-
-#[macro_export]
-macro_rules! object_impl {
-    ($name:ident) => (
-        object_impl!($name,);
-    );
-    ($name:ident<$($t:ident),+>) => (
-        object_impl!($name, $($t),+);
-    );
-    ($name:ident, $($t:ident),*) => (
-        unsafe impl<$($t),*> ::objc::Message for $name<$($t),*> { }
-
-        impl<$($t),*> ::objc::EncodePtr for $name<$($t),*> {
-            fn ptr_code() -> &'static str { "@" }
-        }
 
         impl<$($t),*> $crate::INSObject for $name<$($t),*> {
             fn class() -> &'static ::objc::runtime::Class {
@@ -47,9 +30,8 @@ macro_rules! object_impl {
 
         impl<$($t),*> ::std::cmp::Eq for $name<$($t),*> { }
 
-        impl<H, $($t),*> ::std::hash::Hash<H> for $name<$($t),*>
-                where H: ::std::hash::Hasher + ::std::hash::Writer {
-            fn hash(&self, state: &mut H) {
+        impl<$($t),*> ::std::hash::Hash for $name<$($t),*> {
+            fn hash<H>(&self, state: &mut H) where H: ::std::hash::Hasher {
                 use $crate::INSObject;
                 self.hash_code().hash(state);
             }
@@ -63,3 +45,20 @@ macro_rules! object_impl {
         }
     );
 }
+
+#[macro_export]
+macro_rules! object_impl {
+    ($name:ident) => (
+        object_impl!($name,);
+    );
+    ($name:ident<$($t:ident),+>) => (
+        object_impl!($name, $($t),+);
+    );
+    ($name:ident, $($t:ident),*) => (
+        unsafe impl<$($t),*> ::objc::Message for $name<$($t),*> { }
+
+        impl<$($t),*> ::objc::EncodePtr for $name<$($t),*> {
+            fn ptr_code() -> &'static str { "@" }
+        }
+    );
+}

value.rs

@@ -1,9 +1,11 @@
 use std::ffi::{CString, self};
+use std::marker::PhantomData;
 use std::mem;
 use std::str;
 use libc::c_char;
 
 use objc::{encode, Encode, Id};
+use objc::runtime::Class;
 
 use {INSCopying, INSObject};
 
@@ -40,13 +42,23 @@ pub trait INSValue : INSObject {
     }
 }
 
-object_struct!(NSValue<T>);
+pub struct NSValue<T> {
+    value: PhantomData<T>,
+}
+
+object_impl!(NSValue<T>);
+
+impl<T> INSObject for NSValue<T> where T: 'static {
+    fn class() -> &'static Class {
+        Class::get("NSValue").unwrap()
+    }
+}
 
 impl<T> INSValue for NSValue<T> where T: 'static + Copy + Encode {
     type Value = T;
 }
 
-impl<T> INSCopying for NSValue<T> {
+impl<T> INSCopying for NSValue<T> where T: 'static {
     type Output = NSValue<T>;
 }