rcmut/
lib.rs

1#![cfg_attr(test, deny(warnings))]
2#![deny(missing_docs)]
3
4//! # RcMut
5//!
6//! An unchecked shared mutability primitive.
7//!
8//! RcMut provides unchecked shared mutability and ownership.
9//! It is extremely unsafe to use directly.
10//!
11
12use std::cell::UnsafeCell;
13use std::sync::Arc;
14use std::rc::Rc;
15use std::mem;
16
17/// A reference counted smart pointer with unrestricted mutability.
18pub struct RcMut<T> {
19    inner: Rc<UnsafeCell<T>>
20}
21
22impl<T> Clone for RcMut<T> {
23    fn clone(&self) -> RcMut<T> {
24        RcMut { inner: self.inner.clone() }
25    }
26}
27
28impl<T> RcMut<T> {
29    /// Create a new RcMut for a value.
30    pub fn new(val: T) -> RcMut<T> {
31        RcMut {
32            inner: Rc::new(UnsafeCell::new(val))
33        }
34    }
35
36    /// Retrieve the inner Rc as a reference.
37    pub unsafe fn as_rc(&self) -> &Rc<T> {
38        mem::transmute(&self.inner)
39    }
40
41    /// Retrieve the inner Rc as a mutable reference.
42    pub unsafe fn as_rc_mut(&mut self) -> &mut Rc<T> {
43        mem::transmute(&mut self.inner)
44    }
45
46    /// Get a reference to the value.
47    pub unsafe fn borrow(&self) -> &T {
48        mem::transmute(self.inner.get())
49    }
50
51    /// Get a mutable reference to the value.
52    pub unsafe fn borrow_mut(&mut self) -> &mut T {
53        mem::transmute(self.inner.get())
54    }
55}
56
57/// A reference counted smart pointer with unrestricted mutability.
58pub struct ArcMut<T> {
59    inner: Arc<UnsafeCell<T>>
60}
61
62impl<T> Clone for ArcMut<T> {
63    fn clone(&self) -> ArcMut<T> {
64        ArcMut { inner: self.inner.clone() }
65    }
66}
67
68impl<T> ArcMut<T> {
69    /// Create a new ArcMut for a value.
70    pub fn new(val: T) -> ArcMut<T> {
71        ArcMut {
72            inner: Arc::new(UnsafeCell::new(val))
73        }
74    }
75
76    /// Retrieve the inner Rc as a reference.
77    pub unsafe fn as_arc(&self) -> &Arc<T> {
78        mem::transmute(&self.inner)
79    }
80
81    /// Retrieve the inner Rc as a mutable reference.
82    pub unsafe fn as_arc_mut(&mut self) -> &mut Arc<T> {
83        mem::transmute(&mut self.inner)
84    }
85
86    /// Get a reference to the value.
87    pub unsafe fn borrow(&self) -> &T {
88        mem::transmute(self.inner.get())
89    }
90
91    /// Get a mutable reference to the value.
92    pub unsafe fn borrow_mut(&mut self) -> &mut T {
93        mem::transmute(self.inner.get())
94    }
95}
96