Update to the new malloc_buffer

Author: SSheldon

Cargo.toml

@@ -24,7 +24,7 @@ exception = ["objc_exception"]
 verify_message = []
 
 [dependencies]
-malloc_buf = "0.0"
+malloc_buf = "1.0"
 
 [dependencies.objc_exception]
 version = "0.1"

src/encode.rs

@@ -1,8 +1,8 @@
-use std::ffi::CStr;
 use std::fmt;
 use std::os::raw::{c_char, c_void};
 use std::str;
-use malloc_buf::MallocBuffer;
+
+use malloc_buf::Malloc;
 
 use runtime::{Class, Object, Sel};
 
@@ -26,7 +26,7 @@ enum Code {
     Slice(&'static str),
     Owned(String),
     Inline(u8, [u8; CODE_INLINE_CAP]),
-    Malloc(MallocBuffer<u8>)
+    Malloc(Malloc<str>)
 }
 
 /// An Objective-C type encoding.
@@ -52,9 +52,7 @@ impl Encoding {
             Code::Inline(len, ref bytes) => unsafe {
                 str::from_utf8_unchecked(&bytes[..len as usize])
             },
-            Code::Malloc(ref buf) => unsafe {
-                str::from_utf8_unchecked(&buf[..buf.len() - 1])
-            },
+            Code::Malloc(ref buf) => &*buf,
         }
     }
 }
@@ -101,11 +99,8 @@ pub fn from_str(code: &str) -> Encoding {
 }
 
 pub unsafe fn from_malloc_str(ptr: *mut c_char) -> Encoding {
-    let s = CStr::from_ptr(ptr);
-    let bytes = s.to_bytes_with_nul();
-    assert!(str::from_utf8(bytes).is_ok());
-    let buf = MallocBuffer::new(ptr as *mut u8, bytes.len()).unwrap();
-    Encoding { code: Code::Malloc(buf) }
+    let buf = Malloc::from_c_str(ptr);
+    Encoding { code: Code::Malloc(buf.unwrap()) }
 }
 
 /// Types that have an Objective-C type encoding.

src/runtime.rs

@@ -8,7 +8,7 @@ use std::fmt;
 use std::os::raw::{c_char, c_int, c_uint, c_void};
 use std::ptr;
 use std::str;
-use malloc_buf::MallocBuffer;
+use malloc_buf::Malloc;
 
 use encode;
 use {Encode, Encoding};
@@ -284,11 +284,11 @@ impl Class {
     }
 
     /// Obtains the list of registered class definitions.
-    pub fn classes() -> MallocBuffer<&'static Class> {
+    pub fn classes() -> Malloc<[&'static Class]> {
         unsafe {
             let mut count: c_uint = 0;
             let classes = objc_copyClassList(&mut count);
-            MallocBuffer::new(classes as *mut _, count as usize).unwrap()
+            Malloc::from_array(classes as *mut _, count as usize)
         }
     }
 
@@ -351,11 +351,11 @@ impl Class {
     }
 
     /// Describes the instance methods implemented by self.
-    pub fn instance_methods(&self) -> MallocBuffer<&Method> {
+    pub fn instance_methods(&self) -> Malloc<[&Method]> {
         unsafe {
             let mut count: c_uint = 0;
             let methods = class_copyMethodList(self, &mut count);
-            MallocBuffer::new(methods as *mut _, count as usize).unwrap()
+            Malloc::from_array(methods as *mut _, count as usize)
         }
 
     }
@@ -366,20 +366,20 @@ impl Class {
     }
 
     /// Get a list of the protocols to which this class conforms.
-    pub fn adopted_protocols(&self) -> MallocBuffer<&Protocol> {
+    pub fn adopted_protocols(&self) -> Malloc<[&Protocol]> {
         unsafe {
             let mut count: c_uint = 0;
             let protos = class_copyProtocolList(self, &mut count);
-            MallocBuffer::new(protos as *mut _, count as usize).unwrap()
+            Malloc::from_array(protos as *mut _, count as usize)
         }
     }
 
     /// Describes the instance variables declared by self.
-    pub fn instance_variables(&self) -> MallocBuffer<&Ivar> {
+    pub fn instance_variables(&self) -> Malloc<[&Ivar]> {
         unsafe {
             let mut count: c_uint = 0;
             let ivars = class_copyIvarList(self, &mut count);
-            MallocBuffer::new(ivars as *mut _, count as usize).unwrap()
+            Malloc::from_array(ivars as *mut _, count as usize)
         }
     }
 }
@@ -412,20 +412,20 @@ impl Protocol {
     }
 
     /// Obtains the list of registered protocol definitions.
-    pub fn protocols() -> MallocBuffer<&'static Protocol> {
+    pub fn protocols() -> Malloc<[&'static Protocol]> {
         unsafe {
             let mut count: c_uint = 0;
             let protocols = objc_copyProtocolList(&mut count);
-            MallocBuffer::new(protocols as *mut _, count as usize).unwrap()
+            Malloc::from_array(protocols as *mut _, count as usize)
         }
     }
 
     /// Get a list of the protocols to which this protocol conforms.
-    pub fn adopted_protocols(&self) -> MallocBuffer<&Protocol> {
+    pub fn adopted_protocols(&self) -> Malloc<[&Protocol]> {
         unsafe {
             let mut count: c_uint = 0;
             let protocols = protocol_copyProtocolList(self, &mut count);
-            MallocBuffer::new(protocols as *mut _, count as usize).unwrap()
+            Malloc::from_array(protocols as *mut _, count as usize)
         }
     }