Replaced the EncodePtr trait with a macro.

Author: SSheldon

core/block.rs

@@ -52,7 +52,7 @@ use std::ptr;
 use libc::{c_int, c_ulong};
 
 use runtime::{Class, Object};
-use {EncodePtr, Id, Message};
+use {Id, Message};
 
 #[link(name = "Foundation", kind = "framework")]
 extern {
@@ -121,9 +121,7 @@ impl<A: BlockArguments, R> Block<A, R> where A: BlockArguments {
 
 unsafe impl<A, R> Message for Block<A, R> { }
 
-impl<A, R> EncodePtr for Block<A, R> {
-    fn ptr_code() -> &'static str { "@?" }
-}
+encode_message_impl!("@?", Block, A, R);
 
 /// Types that may be converted into a `ConcreteBlock`.
 pub trait IntoConcreteBlock<A> where A: BlockArguments {

core/encode.rs

@@ -96,47 +96,9 @@ impl Encode for Sel {
     fn code() -> &'static str { ":" }
 }
 
-/// Types that pointers to have an Objective-C type encoding.
-///
-/// This trait is largely for convenience, so that it can be implemnted once
-/// to implement encode for the 6 pointer types: immutable/mutable references,
-/// optional immutable/mutable references, and const/mutable pointers.
-pub trait EncodePtr : PhantomFn<Self> {
-    /// Returns the encoding for pointers to Self.
-    fn ptr_code() -> &'static str;
-}
+encode_message_impl!("@", Object);
 
-impl<'a, T> Encode for &'a T where T: EncodePtr {
-    fn code() -> &'static str { T::ptr_code() }
-}
-
-impl<'a, T> Encode for &'a mut T where T: EncodePtr {
-    fn code() -> &'static str { T::ptr_code() }
-}
-
-impl<'a, T> Encode for Option<&'a T> where T: EncodePtr {
-    fn code() -> &'static str { T::ptr_code() }
-}
-
-impl<'a, T> Encode for Option<&'a mut T> where T: EncodePtr {
-    fn code() -> &'static str { T::ptr_code() }
-}
-
-impl<T> Encode for *const T where T: EncodePtr {
-    fn code() -> &'static str { T::ptr_code() }
-}
-
-impl<T> Encode for *mut T where T: EncodePtr {
-    fn code() -> &'static str { T::ptr_code() }
-}
-
-impl EncodePtr for Object {
-    fn ptr_code() -> &'static str { "@" }
-}
-
-impl EncodePtr for Class {
-    fn ptr_code() -> &'static str { "#" }
-}
+encode_message_impl!("#", Class);
 
 /// Returns the Objective-C type encoding for a type.
 pub fn encode<T>() -> &'static str where T: Encode {

core/lib.rs

@@ -13,7 +13,7 @@ extern crate malloc_buf;
 extern crate objc_test_utils;
 
 pub use id::{Id, Owned, Ownership, Shared, ShareId};
-pub use encode::{encode, Encode, EncodePtr};
+pub use encode::{encode, Encode};
 pub use message::{send_message, send_super_message, Message, MessageArguments, ToMessage};
 pub use weak::WeakId;
 

core/macros.rs

@@ -71,3 +71,51 @@ macro_rules! msg_send {
         $crate::send_message(&$obj, sel, ($($arg,)*))
     });
 }
+
+/// Implements the `Encode` trait for a `Message` type.
+/// Specifically, this will implement `Encode` for reference, pointers, and
+/// `Option` references of the given type.
+///
+/// The first argument should be a static string that is the type encoding
+/// to use in the implementation. The second argument is the ident of the name
+/// of the type to implement `Encode` for, and any further arguments are
+/// used as type parameters for the type.
+///
+/// # Example
+/// ``` ignore
+/// impl Message for Object { }
+/// encode_message_impl!("@", Object)
+///
+/// impl<T> Message for Array<T> { }
+/// encode_message_impl!("@", Array, T)
+/// ```
+macro_rules! encode_message_impl {
+    ($code:expr, $name:ident) => (
+        encode_message_impl!($code, $name,);
+    );
+    ($code:expr, $name:ident, $($t:ident),*) => (
+        impl<'a $(, $t)*> $crate::Encode for &'a $name<$($t),*> {
+            fn code() -> &'static str { $code }
+        }
+
+        impl<'a $(, $t)*> $crate::Encode for &'a mut $name<$($t),*> {
+            fn code() -> &'static str { $code }
+        }
+
+        impl<'a $(, $t)*> $crate::Encode for Option<&'a $name<$($t),*>> {
+            fn code() -> &'static str { $code }
+        }
+
+        impl<'a $(, $t)*> $crate::Encode for Option<&'a mut $name<$($t),*>> {
+            fn code() -> &'static str { $code }
+        }
+
+        impl<$($t),*> $crate::Encode for *const $name<$($t),*> {
+            fn code() -> &'static str { $code }
+        }
+
+        impl<$($t),*> $crate::Encode for *mut $name<$($t),*> {
+            fn code() -> &'static str { $code }
+        }
+    );
+}