Skip to main content

mirascript_vm/value/
shared.rs

1use std::cell::{Ref, RefCell, RefMut};
2use std::fmt;
3use std::rc::Rc;
4
5/// Shared ownership used when the host needs to retain and mutate a value.
6pub struct MiraShared<T> {
7    pub(super) inner: Rc<RefCell<T>>,
8}
9
10impl<T> MiraShared<T> {
11    /// Wrap a value in single-threaded shared ownership.
12    ///
13    /// # Examples
14    ///
15    /// ```
16    /// use mirascript_vm::MiraShared;
17    ///
18    /// let value = MiraShared::new(vec![1, 2]);
19    /// value.borrow_mut().push(3);
20    /// assert_eq!(&*value.borrow(), &[1, 2, 3]);
21    /// ```
22    pub fn new(value: T) -> Self {
23        Self {
24            inner: Rc::new(RefCell::new(value)),
25        }
26    }
27
28    /// Immutably borrow the wrapped Rust value.
29    ///
30    /// Panics when the value is already mutably borrowed. VM bridge access uses
31    /// checked borrows and reports [`crate::MiraError::BorrowConflict`] instead.
32    pub fn borrow(&self) -> Ref<'_, T> {
33        self.inner.borrow()
34    }
35
36    /// Mutably borrow the wrapped Rust value.
37    ///
38    /// Panics when another borrow is active. VM bridge access uses checked
39    /// borrows and reports [`crate::MiraError::BorrowConflict`] instead.
40    pub fn borrow_mut(&self) -> RefMut<'_, T> {
41        self.inner.borrow_mut()
42    }
43
44    pub(super) fn identity(&self) -> usize {
45        Rc::as_ptr(&self.inner) as usize
46    }
47}
48
49impl<T> Clone for MiraShared<T> {
50    fn clone(&self) -> Self {
51        Self {
52            inner: Rc::clone(&self.inner),
53        }
54    }
55}
56
57impl<T: fmt::Debug> fmt::Debug for MiraShared<T> {
58    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
59        match self.inner.try_borrow() {
60            Ok(value) => f.debug_tuple("MiraShared").field(&*value).finish(),
61            Err(_) => f.write_str("MiraShared(<borrowed>)"),
62        }
63    }
64}