New upstream version 1.14.0+dfsg1

[rustc.git] / src / libcollections / enum_set.rs

diff --git a/src/libcollections/enum_set.rs b/src/libcollections/enum_set.rs
index e90e6c065a2c282f19a80b0220a5e0552c4d07fd..2d12b4ccffe01aa246611dd2afa3fb51b86052ef 100644 (file)
--- a/src/libcollections/enum_set.rs
+++ b/src/libcollections/enum_set.rs
@@ -15,12 +15,12 @@
 
 #![unstable(feature = "enumset",
             reason = "matches collection reform specification, \
-                      waiting for dust to settle")]
+                      waiting for dust to settle",
+            issue = "0")]
 
-use core::prelude::*;
 use core::marker;
 use core::fmt;
-use core::iter::{FromIterator};
+use core::iter::{FromIterator, FusedIterator};
 use core::ops::{Sub, BitOr, BitAnd, BitXor};
 
 // FIXME(contentions): implement union family of methods? (general design may be
@@ -43,22 +43,14 @@ pub struct EnumSet<E> {
 impl<E> Copy for EnumSet<E> {}
 
 impl<E> Clone for EnumSet<E> {
-    fn clone(&self) -> EnumSet<E> { *self }
+    fn clone(&self) -> EnumSet<E> {
+        *self
+    }
 }
 
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<E:CLike + fmt::Debug> fmt::Debug for EnumSet<E> {
+impl<E: CLike + fmt::Debug> fmt::Debug for EnumSet<E> {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        try!(write!(fmt, "{{"));
-        let mut first = true;
-        for e in self {
-            if !first {
-                try!(write!(fmt, ", "));
-            }
-            try!(write!(fmt, "{:?}", e));
-            first = false;
-        }
-        write!(fmt, "}}")
+        fmt.debug_set().entries(self).finish()
     }
 }
 
@@ -88,18 +80,23 @@ pub trait CLike {
     fn from_usize(usize) -> Self;
 }
 
-fn bit<E:CLike>(e: &E) -> usize {
-    use core::usize;
+fn bit<E: CLike>(e: &E) -> usize {
+    use core::mem;
     let value = e.to_usize();
-    assert!(value < usize::BITS,
-            "EnumSet only supports up to {} variants.", usize::BITS - 1);
+    let bits = mem::size_of::<usize>() * 8;
+    assert!(value < bits,
+            "EnumSet only supports up to {} variants.",
+            bits - 1);
     1 << value
 }
 
-impl<E:CLike> EnumSet<E> {
+impl<E: CLike> EnumSet<E> {
     /// Returns an empty `EnumSet`.
     pub fn new() -> EnumSet<E> {
-        EnumSet {bits: 0, marker: marker::PhantomData}
+        EnumSet {
+            bits: 0,
+            marker: marker::PhantomData,
+        }
     }
 
     /// Returns the number of elements in the given `EnumSet`.
@@ -133,14 +130,18 @@ impl<E:CLike> EnumSet<E> {
 
     /// Returns the union of both `EnumSets`.
     pub fn union(&self, e: EnumSet<E>) -> EnumSet<E> {
-        EnumSet {bits: self.bits | e.bits,
-                 marker: marker::PhantomData}
+        EnumSet {
+            bits: self.bits | e.bits,
+            marker: marker::PhantomData,
+        }
     }
 
     /// Returns the intersection of both `EnumSets`.
     pub fn intersection(&self, e: EnumSet<E>) -> EnumSet<E> {
-        EnumSet {bits: self.bits & e.bits,
-                 marker: marker::PhantomData}
+        EnumSet {
+            bits: self.bits & e.bits,
+            marker: marker::PhantomData,
+        }
     }
 
     /// Adds an enum to the `EnumSet`, and returns `true` if it wasn't there before
@@ -168,35 +169,47 @@ impl<E:CLike> EnumSet<E> {
     }
 }
 
-impl<E:CLike> Sub for EnumSet<E> {
+impl<E: CLike> Sub for EnumSet<E> {
     type Output = EnumSet<E>;
 
     fn sub(self, e: EnumSet<E>) -> EnumSet<E> {
-        EnumSet {bits: self.bits & !e.bits, marker: marker::PhantomData}
+        EnumSet {
+            bits: self.bits & !e.bits,
+            marker: marker::PhantomData,
+        }
     }
 }
 
-impl<E:CLike> BitOr for EnumSet<E> {
+impl<E: CLike> BitOr for EnumSet<E> {
     type Output = EnumSet<E>;
 
     fn bitor(self, e: EnumSet<E>) -> EnumSet<E> {
-        EnumSet {bits: self.bits | e.bits, marker: marker::PhantomData}
+        EnumSet {
+            bits: self.bits | e.bits,
+            marker: marker::PhantomData,
+        }
     }
 }
 
-impl<E:CLike> BitAnd for EnumSet<E> {
+impl<E: CLike> BitAnd for EnumSet<E> {
     type Output = EnumSet<E>;
 
     fn bitand(self, e: EnumSet<E>) -> EnumSet<E> {
-        EnumSet {bits: self.bits & e.bits, marker: marker::PhantomData}
+        EnumSet {
+            bits: self.bits & e.bits,
+            marker: marker::PhantomData,
+        }
     }
 }
 
-impl<E:CLike> BitXor for EnumSet<E> {
+impl<E: CLike> BitXor for EnumSet<E> {
     type Output = EnumSet<E>;
 
     fn bitxor(self, e: EnumSet<E>) -> EnumSet<E> {
-        EnumSet {bits: self.bits ^ e.bits, marker: marker::PhantomData}
+        EnumSet {
+            bits: self.bits ^ e.bits,
+            marker: marker::PhantomData,
+        }
     }
 }
 
@@ -218,13 +231,17 @@ impl<E> Clone for Iter<E> {
     }
 }
 
-impl<E:CLike> Iter<E> {
+impl<E: CLike> Iter<E> {
     fn new(bits: usize) -> Iter<E> {
-        Iter { index: 0, bits: bits, marker: marker::PhantomData }
+        Iter {
+            index: 0,
+            bits: bits,
+            marker: marker::PhantomData,
+        }
     }
 }
 
-impl<E:CLike> Iterator for Iter<E> {
+impl<E: CLike> Iterator for Iter<E> {
     type Item = E;
 
     fn next(&mut self) -> Option<E> {
@@ -248,16 +265,19 @@ impl<E:CLike> Iterator for Iter<E> {
     }
 }
 
-impl<E:CLike> FromIterator<E> for EnumSet<E> {
-    fn from_iter<I: IntoIterator<Item=E>>(iter: I) -> EnumSet<E> {
+#[unstable(feature = "fused", issue = "35602")]
+impl<E: CLike> FusedIterator for Iter<E> {}
+
+impl<E: CLike> FromIterator<E> for EnumSet<E> {
+    fn from_iter<I: IntoIterator<Item = E>>(iter: I) -> EnumSet<E> {
         let mut ret = EnumSet::new();
         ret.extend(iter);
         ret
     }
 }
 
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, E> IntoIterator for &'a EnumSet<E> where E: CLike {
+impl<'a, E> IntoIterator for &'a EnumSet<E> where E: CLike
+{
     type Item = E;
     type IntoIter = Iter<E>;
 
@@ -266,17 +286,16 @@ impl<'a, E> IntoIterator for &'a EnumSet<E> where E: CLike {
     }
 }
 
-impl<E:CLike> Extend<E> for EnumSet<E> {
-    fn extend<I: IntoIterator<Item=E>>(&mut self, iter: I) {
+impl<E: CLike> Extend<E> for EnumSet<E> {
+    fn extend<I: IntoIterator<Item = E>>(&mut self, iter: I) {
         for element in iter {
             self.insert(element);
         }
     }
 }
 
-#[stable(feature = "extend_ref", since = "1.2.0")]
 impl<'a, E: 'a + CLike + Copy> Extend<&'a E> for EnumSet<E> {
-    fn extend<I: IntoIterator<Item=&'a E>>(&mut self, iter: I) {
+    fn extend<I: IntoIterator<Item = &'a E>>(&mut self, iter: I) {
         self.extend(iter.into_iter().cloned());
     }
 }