Implement more traits for guard types

src/libcore/cell.rs

@@ -181,6 +181,7 @@
 
 use cmp::Ordering;
 use fmt::{self, Debug, Display};
+use hash::{Hash, Hasher};
 use marker::Unsize;
 use mem;
 use ops::{Deref, DerefMut, CoerceUnsized};
@@ -872,7 +873,7 @@ impl<T: ?Sized + Eq> Eq for RefCell<T> {}
 impl<T: ?Sized + PartialOrd> PartialOrd for RefCell<T> {
     #[inline]
     fn partial_cmp(&self, other: &RefCell<T>) -> Option<Ordering> {
-        self.borrow().partial_cmp(&*other.borrow())
+        self.borrow().partial_cmp(&other.borrow())
     }
 
     #[inline]
@@ -900,7 +901,7 @@ impl<T: ?Sized + PartialOrd> PartialOrd for RefCell<T> {
 impl<T: ?Sized + Ord> Ord for RefCell<T> {
     #[inline]
     fn cmp(&self, other: &RefCell<T>) -> Ordering {
-        self.borrow().cmp(&*other.borrow())
+        self.borrow().cmp(&other.borrow())
     }
 }
 
@@ -1032,6 +1033,61 @@ impl<'a, T: ?Sized + fmt::Display> fmt::Display for Ref<'a, T> {
     }
 }
 
+#[stable(feature = "std_guard_impls_ext", since = "1.22.0")]
+impl<'a, T: ?Sized + Hash> Hash for Ref<'a, T> {
+    #[inline]
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.value.hash(state);
+    }
+}
+
+#[stable(feature = "std_guard_impls_ext", since = "1.22.0")]
+impl<'a, T: ?Sized + PartialEq> PartialEq for Ref<'a, T> {
+    #[inline]
+    fn eq(&self, other: &Ref<T>) -> bool {
+        self.value == other.value
+    }
+}
+
+#[stable(feature = "std_guard_impls_ext", since = "1.22.0")]
+impl<'a, T: ?Sized + Eq> Eq for Ref<'a, T> { }
+
+#[stable(feature = "std_guard_impls_ext", since = "1.22.0")]
+impl<'a, T: ?Sized + Ord> Ord for Ref<'a, T> {
+    #[inline]
+    fn cmp(&self, other: &Ref<T>) -> Ordering {
+        self.value.cmp(other.value)
+    }
+}
+
+#[stable(feature = "std_guard_impls_ext", since = "1.22.0")]
+impl<'a, T: ?Sized + PartialOrd> PartialOrd for Ref<'a, T> {
+    #[inline]
+    fn partial_cmp(&self, other: &Ref<T>) -> Option<Ordering> {
+        self.value.partial_cmp(&other.value)
+    }
+
+    #[inline]
+    fn lt(&self, other: &Ref<T>) -> bool {
+        self.value < other.value
+    }
+
+    #[inline]
+    fn le(&self, other: &Ref<T>) -> bool {
+        self.value <= other.value
+    }
+
+    #[inline]
+    fn gt(&self, other: &Ref<T>) -> bool {
+        self.value > other.value
+    }
+
+    #[inline]
+    fn ge(&self, other: &Ref<T>) -> bool {
+        self.value >= other.value
+    }
+}
+
 impl<'b, T: ?Sized> RefMut<'b, T> {
     /// Make a new `RefMut` for a component of the borrowed data, e.g. an enum
     /// variant.
@@ -1131,6 +1187,61 @@ impl<'a, T: ?Sized + fmt::Display> fmt::Display for RefMut<'a, T> {
     }
 }
 
+#[stable(feature = "std_guard_impls_ext", since = "1.22.0")]
+impl<'a, T: ?Sized + Hash> Hash for RefMut<'a, T> {
+    #[inline]
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.value.hash(state);
+    }
+}
+
+#[stable(feature = "std_guard_impls_ext", since = "1.22.0")]
+impl<'a, T: ?Sized + PartialEq> PartialEq for RefMut<'a, T> {
+    #[inline]
+    fn eq(&self, other: &RefMut<T>) -> bool {
+        self.value == other.value
+    }
+}
+
+#[stable(feature = "std_guard_impls_ext", since = "1.22.0")]
+impl<'a, T: ?Sized + Eq> Eq for RefMut<'a, T> { }
+
+#[stable(feature = "std_guard_impls_ext", since = "1.22.0")]
+impl<'a, T: ?Sized + Ord> Ord for RefMut<'a, T> {
+    #[inline]
+    fn cmp(&self, other: &RefMut<T>) -> Ordering {
+        self.value.cmp(&other.value)
+    }
+}
+
+#[stable(feature = "std_guard_impls_ext", since = "1.22.0")]
+impl<'a, T: ?Sized + PartialOrd> PartialOrd for RefMut<'a, T> {
+    #[inline]
+    fn partial_cmp(&self, other: &RefMut<T>) -> Option<Ordering> {
+        self.value.partial_cmp(&other.value)
+    }
+
+    #[inline]
+    fn lt(&self, other: &RefMut<T>) -> bool {
+        *self.value < *other.value
+    }
+
+    #[inline]
+    fn le(&self, other: &RefMut<T>) -> bool {
+        *self.value <= *other.value
+    }
+
+    #[inline]
+    fn gt(&self, other: &RefMut<T>) -> bool {
+        *self.value > *other.value
+    }
+
+    #[inline]
+    fn ge(&self, other: &RefMut<T>) -> bool {
+        *self.value >= *other.value
+    }
+}
+
 /// The core primitive for interior mutability in Rust.
 ///
 /// `UnsafeCell<T>` is a type that wraps some `T` and indicates unsafe interior operations on the

src/libstd/sync/mutex.rs

@@ -9,7 +9,9 @@
 // except according to those terms.
 
 use cell::UnsafeCell;
+use cmp::{Ordering};
 use fmt;
+use hash::{Hash, Hasher};
 use mem;
 use ops::{Deref, DerefMut};
 use ptr;
@@ -447,6 +449,61 @@ impl<'a, T: ?Sized + fmt::Display> fmt::Display for MutexGuard<'a, T> {
     }
 }
 
+#[stable(feature = "std_guard_impls_ext", since = "1.22.0")]
+impl<'a, T: ?Sized + Hash> Hash for MutexGuard<'a, T> {
+    #[inline]
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        (**self).hash(state);
+    }
+}
+
+#[stable(feature = "std_guard_impls_ext", since = "1.22.0")]
+impl<'a, T: ?Sized + PartialEq> PartialEq for MutexGuard<'a, T> {
+    #[inline]
+    fn eq(&self, other: &MutexGuard<T>) -> bool {
+        **self == **other
+    }
+}
+
+#[stable(feature = "std_guard_impls_ext", since = "1.22.0")]
+impl<'a, T: ?Sized + Eq> Eq for MutexGuard<'a, T> { }
+
+#[stable(feature = "std_guard_impls_ext", since = "1.22.0")]
+impl<'a, T: ?Sized + Ord> Ord for MutexGuard<'a, T> {
+    #[inline]
+    fn cmp(&self, other: &MutexGuard<T>) -> Ordering {
+        self.deref().cmp(&other.deref())
+    }
+}
+
+#[stable(feature = "std_guard_impls_ext", since = "1.22.0")]
+impl<'a, T: ?Sized + PartialOrd> PartialOrd for MutexGuard<'a, T> {
+    #[inline]
+    fn partial_cmp(&self, other: &MutexGuard<T>) -> Option<Ordering> {
+        self.deref().partial_cmp(&other.deref())
+    }
+
+    #[inline]
+    fn lt(&self, other: &MutexGuard<T>) -> bool {
+        **self < **other
+    }
+
+    #[inline]
+    fn le(&self, other: &MutexGuard<T>) -> bool {
+        **self <= **other
+    }
+
+    #[inline]
+    fn gt(&self, other: &MutexGuard<T>) -> bool {
+        **self > **other
+    }
+
+    #[inline]
+    fn ge(&self, other: &MutexGuard<T>) -> bool {
+        **self >= **other
+    }
+}
+
 pub fn guard_lock<'a, T: ?Sized>(guard: &MutexGuard<'a, T>) -> &'a sys::Mutex {
     &guard.__lock.inner
 }

src/libstd/sync/rwlock.rs

@@ -9,7 +9,9 @@
 // except according to those terms.
 
 use cell::UnsafeCell;
+use cmp::Ordering;
 use fmt;
+use hash::{Hash, Hasher};
 use marker;
 use mem;
 use ops::{Deref, DerefMut};
@@ -377,6 +379,61 @@ impl<'a, T: ?Sized + fmt::Display> fmt::Display for RwLockReadGuard<'a, T> {
     }
 }
 
+#[stable(feature = "std_guard_impls_ext", since = "1.22.0")]
+impl<'a, T: ?Sized + Hash> Hash for RwLockReadGuard<'a, T> {
+    #[inline]
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        (**self).hash(state);
+    }
+}
+
+#[stable(feature = "std_guard_impls_ext", since = "1.22.0")]
+impl<'a, T: ?Sized + PartialEq> PartialEq for RwLockReadGuard<'a, T> {
+    #[inline]
+    fn eq(&self, other: &RwLockReadGuard<T>) -> bool {
+        **self == **other
+    }
+}
+
+#[stable(feature = "std_guard_impls_ext", since = "1.22.0")]
+impl<'a, T: ?Sized + Eq> Eq for RwLockReadGuard<'a, T> { }
+
+#[stable(feature = "std_guard_impls_ext", since = "1.22.0")]
+impl<'a, T: ?Sized + Ord> Ord for RwLockReadGuard<'a, T> {
+    #[inline]
+    fn cmp(&self, other: &RwLockReadGuard<T>) -> Ordering {
+        self.deref().cmp(&other.deref())
+    }
+}
+
+#[stable(feature = "std_guard_impls_ext", since = "1.22.0")]
+impl<'a, T: ?Sized + PartialOrd> PartialOrd for RwLockReadGuard<'a, T> {
+    #[inline]
+    fn partial_cmp(&self, other: &RwLockReadGuard<T>) -> Option<Ordering> {
+        self.deref().partial_cmp(&other.deref())
+    }
+
+    #[inline]
+    fn lt(&self, other: &RwLockReadGuard<T>) -> bool {
+        **self < **other
+    }
+
+    #[inline]
+    fn le(&self, other: &RwLockReadGuard<T>) -> bool {
+        **self <= **other
+    }
+
+    #[inline]
+    fn gt(&self, other: &RwLockReadGuard<T>) -> bool {
+        **self > **other
+    }
+
+    #[inline]
+    fn ge(&self, other: &RwLockReadGuard<T>) -> bool {
+        **self >= **other
+    }
+}
+
 #[stable(feature = "std_debug", since = "1.16.0")]
 impl<'a, T: fmt::Debug> fmt::Debug for RwLockWriteGuard<'a, T> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
@@ -393,6 +450,61 @@ impl<'a, T: ?Sized + fmt::Display> fmt::Display for RwLockWriteGuard<'a, T> {
     }
 }
 
+#[stable(feature = "std_guard_impls_ext", since = "1.22.0")]
+impl<'a, T: ?Sized + Hash> Hash for RwLockWriteGuard<'a, T> {
+    #[inline]
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        (**self).hash(state);
+    }
+}
+
+#[stable(feature = "std_guard_impls_ext", since = "1.22.0")]
+impl<'a, T: ?Sized + PartialEq> PartialEq for RwLockWriteGuard<'a, T> {
+    #[inline]
+    fn eq(&self, other: &RwLockWriteGuard<T>) -> bool {
+        **self == **other
+    }
+}
+
+#[stable(feature = "std_guard_impls_ext", since = "1.22.0")]
+impl<'a, T: ?Sized + Eq> Eq for RwLockWriteGuard<'a, T> { }
+
+#[stable(feature = "std_guard_impls_ext", since = "1.22.0")]
+impl<'a, T: ?Sized + Ord> Ord for RwLockWriteGuard<'a, T> {
+    #[inline]
+    fn cmp(&self, other: &RwLockWriteGuard<T>) -> Ordering {
+        self.deref().cmp(&other.deref())
+    }
+}
+
+#[stable(feature = "std_guard_impls_ext", since = "1.22.0")]
+impl<'a, T: ?Sized + PartialOrd> PartialOrd for RwLockWriteGuard<'a, T> {
+    #[inline]
+    fn partial_cmp(&self, other: &RwLockWriteGuard<T>) -> Option<Ordering> {
+        self.deref().partial_cmp(&other.deref())
+    }
+
+    #[inline]
+    fn lt(&self, other: &RwLockWriteGuard<T>) -> bool {
+        **self < **other
+    }
+
+    #[inline]
+    fn le(&self, other: &RwLockWriteGuard<T>) -> bool {
+        **self <= **other
+    }
+
+    #[inline]
+    fn gt(&self, other: &RwLockWriteGuard<T>) -> bool {
+        **self > **other
+    }
+
+    #[inline]
+    fn ge(&self, other: &RwLockWriteGuard<T>) -> bool {
+        **self >= **other
+    }
+}
+
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<'rwlock, T: ?Sized> Deref for RwLockReadGuard<'rwlock, T> {
     type Target = T;