This is trying to remove the num_bytes argument from usize/isize methods.

If num_bytes can be removed then a generic to_bytes and from_bytes
trait can be created that will help with serializing structures
and generic data.

src/endian.rs

@@ -32,14 +32,14 @@ pub type PlatformEndian = LittleEndian;
 /// and turning them into the requested type.
 macro_rules! read_bytes
 {
-   ($buffer: expr, $return_type: ident, $convert_func: ident) =>
+   ($buffer: expr, $returnType: ident, $convertFunc: ident) =>
    ({
-      use std::$return_type;
+      use std::$returnType;
 
-      assert!($return_type::BYTES <= $buffer.len());
+      assert!($returnType::BYTES <= $buffer.len());
       unsafe
       {
-         (*($buffer.as_ptr() as *const $return_type)).$convert_func()
+         (*($buffer.as_ptr() as *const $returnType)).$convertFunc()
       }
    })
 }
@@ -48,21 +48,23 @@ macro_rules! read_bytes
 /// and writing them to a buffer.
 macro_rules! write_bytes
 {
-   ($buffer: expr, $value_type: ident, $num: expr, $convert_func: ident) =>
+   ($buffer: expr, $valueType: ident, $num: expr, $convertFunc: ident) =>
    ({
-      use std::$value_type;
+      use std::$valueType;
 
-      assert!($value_type::BYTES <= $buffer.len());
+      assert!($valueType::BYTES <= $buffer.len());
       unsafe
       {
          let size: usize;
-         let bytes: [u8; $value_type::BYTES];
+         let bytes: [u8; $valueType::BYTES];
 
-         size = $value_type::BYTES as usize;
+         size = $valueType::BYTES as usize;
 
          bytes =
-            mem::transmute::<_,[u8; $value_type::BYTES]>($num.$convert_func());
-         copy_nonoverlapping((&bytes).as_ptr(), $buffer.as_mut_ptr(), size);
+            mem::transmute::<_,[u8; $valueType::BYTES]>($num.$convertFunc());
+         copy_nonoverlapping::<u8>((&bytes).as_ptr(),
+                                   $buffer.as_mut_ptr(),
+                                   size);
       }
    })
 }
@@ -86,21 +88,20 @@ impl Transmutable for BigEndian
       read_bytes!(buffer, u64, to_be)
    }
 
-   fn bytes_to_usize(buffer: &[u8], num_bytes: u8) -> usize
+   fn bytes_to_usize(buffer: &[u8]) -> usize
    {
       let mut out: [u8; 8];
       let ptr_out: *mut u8;
 
-      assert!(1 <= num_bytes && num_bytes <= 8);
-      assert!(num_bytes as usize <= buffer.len());
+      assert!(1 <= buffer.len() && buffer.len() <= 8);
 
       out = [0u8; 8];
       ptr_out = out.as_mut_ptr();
       unsafe
       {
-         copy_nonoverlapping(buffer.as_ptr(),
-                             ptr_out.offset((8 - num_bytes) as isize),
-                             num_bytes as usize);
+         copy_nonoverlapping::<u8>(buffer.as_ptr(),
+                                   ptr_out.offset((8 - buffer.len()) as isize),
+                                   buffer.len());
 
          (*(ptr_out as *const u64)).to_be() as usize
       }
@@ -122,18 +123,21 @@ impl Transmutable for BigEndian
       write_bytes!(buffer, u64, num, to_be);
    }
 
-   fn usize_to_bytes(buffer: &mut [u8], num: usize, num_bytes: u8)
+   fn usize_to_bytes(buffer: &mut [u8], num: usize)
    {
       let bytes: [u8; 8];
+      let num_bytes: u8;
+
+      num_bytes = buffer.len() as u8;
 
       assert!(determine_size(num as u64) <= num_bytes && num_bytes <= 8);
-      assert!(num_bytes as usize <= buffer.len());
+
       unsafe
       {
-
          bytes = mem::transmute::<usize, [u8; 8]>(num.to_be());
-         copy_nonoverlapping(bytes.as_ptr().offset((8 - num_bytes) as isize),
-                             buffer.as_mut_ptr(), num_bytes as usize);
+         copy_nonoverlapping::<u8>(
+            bytes.as_ptr().offset((8 - num_bytes) as isize),
+            buffer.as_mut_ptr(), num_bytes as usize);
       }
    }
 }
@@ -155,19 +159,18 @@ impl Transmutable for LittleEndian
       read_bytes!(buffer, u64, to_le)
    }
 
-   fn bytes_to_usize(buffer: &[u8], num_bytes: u8) -> usize
+   fn bytes_to_usize(buffer: &[u8]) -> usize
    {
       let mut out: [u8; 8];
       let ptr_out: *mut u8;
 
-      assert!(1 <= num_bytes && num_bytes <= 8);
-      assert!(num_bytes as usize <= buffer.len());
+      assert!(1 <= buffer.len() && buffer.len() <= 8);
 
       out = [0u8; 8];
       ptr_out = out.as_mut_ptr();
       unsafe
       {
-         copy_nonoverlapping(buffer.as_ptr(), ptr_out, num_bytes as usize);
+         copy_nonoverlapping::<u8>(buffer.as_ptr(), ptr_out, buffer.len());
          (*(ptr_out as *const u64)).to_le() as usize
       }
    }
@@ -188,18 +191,20 @@ impl Transmutable for LittleEndian
       write_bytes!(buffer, u64, num, to_le);
    }
 
-   fn usize_to_bytes(buffer: &mut [u8], num: usize, num_bytes: u8)
+   fn usize_to_bytes(buffer: &mut [u8], num: usize)
    {
       let bytes: [u8; 8];
+      let num_bytes: u8;
+
+      num_bytes = buffer.len() as u8;
 
       assert!(determine_size(num as u64) <= num_bytes && num_bytes <= 8);
-      assert!(num_bytes as usize <= buffer.len());
+
       unsafe
       {
-
          bytes = mem::transmute::<usize, [u8; 8]>(num.to_le());
-         copy_nonoverlapping(bytes.as_ptr(), buffer.as_mut_ptr(),
-                             num_bytes as usize);
+         copy_nonoverlapping::<u8>(bytes.as_ptr(), buffer.as_mut_ptr(),
+                                   num_bytes as usize);
       }
    }
 }