---

yaml
---
r: 118671
b: refs/heads/try
c: ff9f92c
h: refs/heads/master
i:
  118669: 3eb305c
  118667: 67929af
  118663: d7c2671
  118655: d8a9ec6
v: v3

Author: brendanzab

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: b1646cbfd908dc948b251e362669af421100647a
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: d6736a1440d42f6af967a8a20ab8d73522112b72
-refs/heads/try: 4c0f8f49f6fe860efa268efa2f4fa0b5f00a4b07
+refs/heads/try: ff9f92ce5224f5e27b8dc39ffc02eb9481f7cff1
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/src/libcollections/enum_set.rs

@@ -15,8 +15,6 @@
 
 use core::prelude::*;
 
-use core::num::Bitwise;
-
 #[deriving(Clone, PartialEq, Eq, Hash, Show)]
 /// A specialized Set implementation to use enum types.
 pub struct EnumSet<E> {

branches/try/src/libcollections/hash/mod.rs

@@ -103,7 +103,6 @@ macro_rules! impl_hash {
         impl<S: Writer> Hash<S> for $ty {
             #[inline]
             fn hash(&self, state: &mut S) {
-                use core::mem::ByteOrder;
                 let a: [u8, ..::core::$ty::BYTES] = unsafe {
                     mem::transmute((*self as $uty).to_little_endian() as $ty)
                 };

branches/try/src/libcore/mem.rs

@@ -13,10 +13,9 @@
 //! This module contains functions for querying the size and alignment of
 //! types, initializing and manipulating memory.
 
-use clone::Clone;
-use ptr;
 use intrinsics;
-use intrinsics::{bswap16, bswap32, bswap64};
+use num::Int;
+use ptr;
 
 pub use intrinsics::transmute;
 
@@ -170,155 +169,6 @@ pub unsafe fn move_val_init<T>(dst: &mut T, src: T) {
     ptr::write(dst, src)
 }
 
-/// A type that can have its bytes re-ordered.
-pub trait ByteOrder: Clone {
-    /// Reverses the byte order of the value.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use std::mem::ByteOrder;
-    ///
-    /// let n = 0x0123456789ABCDEFu64;
-    /// let m = 0xEFCDAB8967452301u64;
-    ///
-    /// assert_eq!(n.swap_bytes(), m);
-    /// ```
-    fn swap_bytes(&self) -> Self;
-
-    /// Convert a value from big endian to the target's endianness.
-    ///
-    /// On big endian this is a no-op. On little endian the bytes are swapped.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use std::mem::ByteOrder;
-    ///
-    /// let n = 0x0123456789ABCDEFu64;
-    ///
-    /// if cfg!(target_endian = "big") {
-    ///     assert_eq!(ByteOrder::from_big_endian(n), n)
-    /// } else {
-    ///     assert_eq!(ByteOrder::from_big_endian(n), n.swap_bytes())
-    /// }
-    /// ```
-    #[inline]
-    fn from_big_endian(x: Self) -> Self {
-        if cfg!(target_endian = "big") { x } else { x.swap_bytes() }
-    }
-
-    /// Convert a value from little endian to the target's endianness.
-    ///
-    /// On little endian this is a no-op. On big endian the bytes are swapped.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use std::mem::ByteOrder;
-    ///
-    /// let n = 0x0123456789ABCDEFu64;
-    ///
-    /// if cfg!(target_endian = "little") {
-    ///     assert_eq!(ByteOrder::from_little_endian(n), n)
-    /// } else {
-    ///     assert_eq!(ByteOrder::from_little_endian(n), n.swap_bytes())
-    /// }
-    /// ```
-    #[inline]
-    fn from_little_endian(x: Self) -> Self {
-        if cfg!(target_endian = "little") { x } else { x.swap_bytes() }
-    }
-
-    /// Convert the value to big endian from the target's endianness.
-    ///
-    /// On big endian this is a no-op. On little endian the bytes are swapped.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use std::mem::ByteOrder;
-    ///
-    /// let n = 0x0123456789ABCDEFu64;
-    ///
-    /// if cfg!(target_endian = "big") {
-    ///     assert_eq!(n.to_big_endian(), n)
-    /// } else {
-    ///     assert_eq!(n.to_big_endian(), n.swap_bytes())
-    /// }
-    /// ```
-    #[inline]
-    fn to_big_endian(&self) -> Self {
-        if cfg!(target_endian = "big") { self.clone() } else { self.swap_bytes() }
-    }
-
-    /// Convert the value to little endian from the target's endianness.
-    ///
-    /// On little endian this is a no-op. On big endian the bytes are swapped.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use std::mem::ByteOrder;
-    ///
-    /// let n = 0x0123456789ABCDEFu64;
-    ///
-    /// if cfg!(target_endian = "little") {
-    ///     assert_eq!(n.to_little_endian(), n)
-    /// } else {
-    ///     assert_eq!(n.to_little_endian(), n.swap_bytes())
-    /// }
-    /// ```
-    #[inline]
-    fn to_little_endian(&self) -> Self {
-        if cfg!(target_endian = "little") { self.clone() } else { self.swap_bytes() }
-    }
-}
-
-impl ByteOrder for u8 {
-    #[inline]
-    fn swap_bytes(&self) -> u8 {
-        *self // swapping a single byte does nothing
-    }
-}
-
-impl ByteOrder for u16 {
-    #[inline]
-    fn swap_bytes(&self) -> u16 {
-        unsafe { intrinsics::bswap16(*self) }
-    }
-}
-
-impl ByteOrder for u32 {
-    #[inline]
-    fn swap_bytes(&self) -> u32 {
-        unsafe { intrinsics::bswap32(*self) }
-    }
-}
-
-impl ByteOrder for u64 {
-    #[inline]
-    fn swap_bytes(&self) -> u64 {
-        unsafe { intrinsics::bswap64(*self) }
-    }
-}
-
-#[cfg(target_word_size = "32")]
-impl ByteOrder for uint {
-    #[inline]
-    fn swap_bytes(&self) -> uint {
-        (*self as u32).swap_bytes() as uint
-    }
-}
-
-#[cfg(target_word_size = "64")]
-impl ByteOrder for uint {
-    #[inline]
-    fn swap_bytes(&self) -> uint {
-        (*self as u64).swap_bytes() as uint
-    }
-}
-
 /// Convert an u16 to little endian from the target's endianness.
 ///
 /// On little endian, this is a no-op.  On big endian, the bytes are swapped.
@@ -366,42 +216,42 @@ pub fn to_be64(x: u64) -> u64 { x.to_big_endian() }
 /// On little endian, this is a no-op.  On big endian, the bytes are swapped.
 #[inline]
 #[stable]
-pub fn from_le16(x: u16) -> u16 { ByteOrder::from_little_endian(x) }
+pub fn from_le16(x: u16) -> u16 { Int::from_little_endian(x) }
 
 /// Convert an u32 from little endian to the target's endianness.
 ///
 /// On little endian, this is a no-op.  On big endian, the bytes are swapped.
 #[inline]
 #[stable]
-pub fn from_le32(x: u32) -> u32 { ByteOrder::from_little_endian(x) }
+pub fn from_le32(x: u32) -> u32 { Int::from_little_endian(x) }
 
 /// Convert an u64 from little endian to the target's endianness.
 ///
 /// On little endian, this is a no-op.  On big endian, the bytes are swapped.
 #[inline]
 #[stable]
-pub fn from_le64(x: u64) -> u64 { ByteOrder::from_little_endian(x) }
+pub fn from_le64(x: u64) -> u64 { Int::from_little_endian(x) }
 
 /// Convert an u16 from big endian to the target's endianness.
 ///
 /// On big endian, this is a no-op.  On little endian, the bytes are swapped.
 #[inline]
 #[stable]
-pub fn from_be16(x: u16) -> u16 { ByteOrder::from_big_endian(x) }
+pub fn from_be16(x: u16) -> u16 { Int::from_big_endian(x) }
 
 /// Convert an u32 from big endian to the target's endianness.
 ///
 /// On big endian, this is a no-op.  On little endian, the bytes are swapped.
 #[inline]
 #[stable]
-pub fn from_be32(x: u32) -> u32 { ByteOrder::from_big_endian(x) }
+pub fn from_be32(x: u32) -> u32 { Int::from_big_endian(x) }
 
 /// Convert an u64 from big endian to the target's endianness.
 ///
 /// On big endian, this is a no-op.  On little endian, the bytes are swapped.
 #[inline]
 #[stable]
-pub fn from_be64(x: u64) -> u64 { ByteOrder::from_big_endian(x) }
+pub fn from_be64(x: u64) -> u64 { Int::from_big_endian(x) }
 
 /// Swap the values at two mutable locations of the same type, without
 /// deinitialising or copying either one.
@@ -642,60 +492,6 @@ mod tests {
             assert!(Vec::from_slice([76u8]) == transmute("L".to_string()));
         }
     }
-
-    macro_rules! test_byte_order {
-        ($T:ident) => {
-            mod $T {
-                use mem::ByteOrder;
-
-                static A: $T = 0b0101100;
-                static B: $T = 0b0100001;
-                static C: $T = 0b1111001;
-
-                static _0: $T = 0;
-                static _1: $T = !0;
-
-                #[test]
-                fn test_swap_bytes() {
-                    assert_eq!(A.swap_bytes().swap_bytes(), A);
-                    assert_eq!(B.swap_bytes().swap_bytes(), B);
-                    assert_eq!(C.swap_bytes().swap_bytes(), C);
-
-                    // Swapping these should make no difference
-                    assert_eq!(_0.swap_bytes(), _0);
-                    assert_eq!(_1.swap_bytes(), _1);
-                }
-
-                #[test]
-                fn test_little_endian() {
-                    assert_eq!(ByteOrder::from_little_endian(A.to_little_endian()), A);
-                    assert_eq!(ByteOrder::from_little_endian(B.to_little_endian()), B);
-                    assert_eq!(ByteOrder::from_little_endian(C.to_little_endian()), C);
-                    assert_eq!(ByteOrder::from_little_endian(_0), _0);
-                    assert_eq!(ByteOrder::from_little_endian(_1), _1);
-                    assert_eq!(_0.to_little_endian(), _0);
-                    assert_eq!(_1.to_little_endian(), _1);
-                }
-
-                #[test]
-                fn test_big_endian() {
-                    assert_eq!(ByteOrder::from_big_endian(A.to_big_endian()), A);
-                    assert_eq!(ByteOrder::from_big_endian(B.to_big_endian()), B);
-                    assert_eq!(ByteOrder::from_big_endian(C.to_big_endian()), C);
-                    assert_eq!(ByteOrder::from_big_endian(_0), _0);
-                    assert_eq!(ByteOrder::from_big_endian(_1), _1);
-                    assert_eq!(_0.to_big_endian(), _0);
-                    assert_eq!(_1.to_big_endian(), _1);
-                }
-            }
-        }
-    }
-
-    test_byte_order!(u8)
-    test_byte_order!(u16)
-    test_byte_order!(u32)
-    test_byte_order!(u64)
-    test_byte_order!(uint)
 }
 
 // FIXME #13642 (these benchmarks should be in another place)