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}