Inline to_le code and rename to AsByteSliceMut

Author: dhardy

src/lib.rs

@@ -491,9 +491,12 @@ pub trait Rng {
     /// ```
     /// 
     /// [`ErrorKind`]: enum.ErrorKind.html
-    fn fill<T: AsByteSlice + ?Sized>(&mut self, dest: &mut T) where Self: Sized {
-        self.fill_bytes(dest.as_byte_slice());
-        dest.to_le();
+    fn fill<T: AsByteSliceMut + ?Sized>(&mut self, dest: &mut T) where Self: Sized {
+        let slice = dest.as_byte_slice_mut();
+        self.fill_bytes(slice);
+        for mut x in slice {
+            x.to_le();
+        }
     }
 
     /// Fill `dest` entirely with random data.
@@ -522,9 +525,12 @@ pub trait Rng {
     /// ```
     /// 
     /// [`ErrorKind`]: enum.ErrorKind.html
-    fn try_fill<T: AsByteSlice + ?Sized>(&mut self, dest: &mut T) -> Result<(), Error> where Self: Sized {
-        self.try_fill_bytes(dest.as_byte_slice())?;
-        dest.to_le();
+    fn try_fill<T: AsByteSliceMut + ?Sized>(&mut self, dest: &mut T) -> Result<(), Error> where Self: Sized {
+        let slice = dest.as_byte_slice_mut();
+        self.try_fill_bytes(slice)?;
+        for mut x in slice {
+            x.to_le();
+        }
         Ok(())
     }
 
@@ -747,24 +753,21 @@ impl<R: ?Sized> Rng for Box<R> where R: Rng {
 }
 
 /// Trait for casting types to byte slices
-pub trait AsByteSlice {
+pub trait AsByteSliceMut {
     /// Return a mutable reference to self as a byte slice
-    fn as_byte_slice<'a>(&'a mut self) -> &'a mut [u8];
-    /// Perform byte-swapping on BE platforms
-    fn to_le(&mut self);
+    fn as_byte_slice_mut<'a>(&'a mut self) -> &'a mut [u8];
 }
 
-impl AsByteSlice for [u8] {
-    fn as_byte_slice<'a>(&'a mut self) -> &'a mut [u8] {
+impl AsByteSliceMut for [u8] {
+    fn as_byte_slice_mut<'a>(&'a mut self) -> &'a mut [u8] {
         self
     }
-    fn to_le(&mut self) {}
 }
 
 macro_rules! impl_as_byte_slice {
     ($t:ty) => {
-        impl AsByteSlice for [$t] {
-            fn as_byte_slice<'a>(&'a mut self) -> &'a mut [u8] {
+        impl AsByteSliceMut for [$t] {
+            fn as_byte_slice_mut<'a>(&'a mut self) -> &'a mut [u8] {
                 unsafe {
                     slice::from_raw_parts_mut(&mut self[0]
                         as *mut $t
@@ -773,11 +776,6 @@ macro_rules! impl_as_byte_slice {
                     )
                 }
             }
-            fn to_le(&mut self) {
-                for mut x in self {
-                    x.to_le();
-                }
-            }
         }
     }
 }