Implement AtomicRef::map.

MozReview-Commit-ID: 8iOALQylOuK

components/style/atomic_refcell.rs

@@ -2,7 +2,11 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
+#![allow(unsafe_code)]
+
+use owning_ref::{OwningRef, StableAddress};
 use parking_lot::{RwLock, RwLockReadGuard, RwLockWriteGuard};
+use std::ops::{Deref, DerefMut};
 
 /// Container type providing RefCell-like semantics for objects shared across
 /// threads.
@@ -20,17 +24,41 @@ use parking_lot::{RwLock, RwLockReadGuard, RwLockWriteGuard};
 /// RefCell, so we newtype it with some API sugar.
 pub struct AtomicRefCell<T>(RwLock<T>);
 
-pub type AtomicRef<'a, T> = RwLockReadGuard<'a, T>;
-pub type AtomicRefMut<'a, T> = RwLockWriteGuard<'a, T>;
+pub struct AtomicRef<'a, T: 'a>(RwLockReadGuard<'a, T>);
+unsafe impl<'a, T> StableAddress for AtomicRef<'a, T> {}
+
+impl<'a, T> Deref for AtomicRef<'a, T> {
+    type Target = T;
+    fn deref(&self) -> &T {
+        self.0.deref()
+    }
+}
+
+pub struct AtomicRefMut<'a, T: 'a>(RwLockWriteGuard<'a, T>);
+unsafe impl<'a, T> StableAddress for AtomicRefMut<'a, T> {}
+
+impl<'a, T> Deref for AtomicRefMut<'a, T> {
+    type Target = T;
+    fn deref(&self) -> &T {
+        self.0.deref()
+    }
+}
+
+impl<'a, T> DerefMut for AtomicRefMut<'a, T> {
+    fn deref_mut(&mut self) -> &mut T {
+        self.0.deref_mut()
+    }
+}
+
 impl<T> AtomicRefCell<T> {
     pub fn new(value: T) -> Self {
         AtomicRefCell(RwLock::new(value))
     }
     pub fn borrow(&self) -> AtomicRef<T> {
-        self.0.try_read().expect("already mutably borrowed")
+        AtomicRef(self.0.try_read().expect("already mutably borrowed"))
     }
     pub fn borrow_mut(&self) -> AtomicRefMut<T> {
-        self.0.try_write().expect("already borrowed")
+        AtomicRefMut(self.0.try_write().expect("already borrowed"))
     }
 }
 
@@ -39,3 +67,42 @@ impl<T: Default> Default for AtomicRefCell<T> {
         Self::new(T::default())
     }
 }
+
+/*
+ * Implement Ref{,Mut}::map()-like semantics for AtomicRef{,Mut}. We can't quite
+ * use AtomicRef{,Mut} as the mapped type, but we can use some trait tricks to
+ * allow us to pass MappedAtomicRef{,Mut} back into AtomicRef{,Mut}::map().
+ *
+ * Note: We cannot implement an AtomicRefMut::map() method until we have mutable
+ * OwningRef. See https://github.com/Kimundi/owning-ref-rs/pull/16
+ */
+pub type MappedAtomicRef<'a, T: 'a, U: 'a> = OwningRef<AtomicRef<'a, T>, U>;
+
+pub trait Map<'a, Base, Curr> {
+    fn map<New, F>(self, f: F) -> MappedAtomicRef<'a, Base, New>
+        where F: FnOnce(&Curr) -> &New;
+}
+
+impl<'a, Base> Map<'a, Base, Base> for AtomicRef<'a, Base> {
+    fn map<New, F>(self, f: F) -> MappedAtomicRef<'a, Base, New>
+        where F: FnOnce(&Base) -> &New
+    {
+        OwningRef::new(self).map(f)
+    }
+}
+
+impl<'a, Base, Curr> Map<'a, Base, Curr> for MappedAtomicRef<'a, Base, Curr> {
+    fn map<New, F>(self, f: F) -> MappedAtomicRef<'a, Base, New>
+        where F: FnOnce(&Curr) -> &New
+    {
+        self.map(f)
+    }
+}
+
+impl<'a, Base> AtomicRef<'a, Base> {
+    pub fn map<Curr, New, M, F>(orig: M, f: F) -> MappedAtomicRef<'a, Base, New>
+        where F: FnOnce(&Curr) -> &New, M: Map<'a, Base, Curr>
+    {
+        orig.map(f)
+    }
+}