Skip to main content

mirascript_vm/value/
bridge.rs

1use std::any::type_name;
2
3use crate::{MiraError, Result};
4
5use super::{MiraAny, MiraCallContext, MiraShared};
6
7/// A live Rust value that appears as a read-only MiraScript record.
8pub trait MiraRecord: 'static {
9    /// Return the record's visible field names in iteration order.
10    fn keys(&self) -> Vec<String>;
11
12    /// Read a field, returning `None` when the field is absent.
13    fn get(&self, key: &str) -> Result<Option<MiraAny>>;
14}
15
16/// A live Rust value that appears as a read-only MiraScript array.
17pub trait MiraArray: 'static {
18    /// Return the current array length.
19    fn len(&self) -> usize;
20
21    /// Read an element, returning `None` when the index is out of bounds.
22    fn get(&self, index: usize) -> Result<Option<MiraAny>>;
23
24    /// Return whether this array currently contains no elements.
25    fn is_empty(&self) -> bool {
26        self.len() == 0
27    }
28}
29
30/// A live Rust object with MiraScript-visible identity and mutable fields.
31pub trait MiraExtern: 'static {
32    /// Return the type label used in diagnostics and debug output.
33    fn tag(&self) -> &str {
34        type_name::<Self>()
35    }
36
37    /// Return the object's visible field names in iteration order.
38    fn keys(&self) -> Vec<String>;
39
40    /// Read a field, returning `None` when the field is absent.
41    fn get(&self, key: &str) -> Result<Option<MiraAny>>;
42
43    /// Return whether a field exists.
44    fn has(&self, key: &str) -> bool {
45        self.keys().iter().any(|candidate| candidate == key)
46    }
47
48    /// Write a field and return whether it accepted the value.
49    ///
50    /// The default implementation rejects every write.
51    fn set(&mut self, _key: &str, _value: MiraAny) -> Result<bool> {
52        Ok(false)
53    }
54
55    /// Return whether this extern can be called from MiraScript.
56    fn is_callable(&self) -> bool {
57        false
58    }
59
60    /// Invoke this extern as a function.
61    ///
62    /// Implementations may call script callbacks through `context`.
63    fn call(&mut self, _context: &mut MiraCallContext<'_>, _args: &[MiraAny]) -> Result<MiraAny> {
64        Err(MiraError::runtime(format!(
65            "Not a callable extern: {}",
66            self.tag()
67        )))
68    }
69
70    /// Return an array-like length, or `None` when indexing is unsupported.
71    fn array_len(&self) -> Option<usize> {
72        None
73    }
74
75    /// Read an array-like element.
76    ///
77    /// By default this delegates to [`MiraExtern::get`] with a decimal key.
78    fn get_index(&self, index: usize) -> Result<Option<MiraAny>> {
79        self.get(&index.to_string())
80    }
81
82    /// Materialize iterable values, or return `None` when iteration is unsupported.
83    fn iterate(&self) -> Result<Option<Vec<MiraAny>>> {
84        Ok(None)
85    }
86}
87
88#[doc(hidden)]
89pub trait MiraBridge: Sized + 'static {
90    fn into_mira_shared(value: MiraShared<Self>) -> MiraAny;
91}
92
93#[doc(hidden)]
94pub trait RecordObject {
95    fn identity(&self) -> usize;
96    fn tag(&self) -> &'static str;
97    fn keys(&self) -> Result<Vec<String>>;
98    fn get(&self, key: &str) -> Result<Option<MiraAny>>;
99}
100
101impl<T: MiraRecord> RecordObject for MiraShared<T> {
102    fn identity(&self) -> usize {
103        self.identity()
104    }
105
106    fn tag(&self) -> &'static str {
107        type_name::<T>()
108    }
109
110    fn keys(&self) -> Result<Vec<String>> {
111        self.inner
112            .try_borrow()
113            .map(|value| value.keys())
114            .map_err(|_| MiraError::BorrowConflict {
115                operation: "read",
116                tag: type_name::<T>().into(),
117            })
118    }
119
120    fn get(&self, key: &str) -> Result<Option<MiraAny>> {
121        self.inner
122            .try_borrow()
123            .map_err(|_| MiraError::BorrowConflict {
124                operation: "read",
125                tag: type_name::<T>().into(),
126            })?
127            .get(key)
128    }
129}
130
131#[doc(hidden)]
132pub trait ArrayObject {
133    fn identity(&self) -> usize;
134    fn tag(&self) -> &'static str;
135    fn len(&self) -> Result<usize>;
136    fn get(&self, index: usize) -> Result<Option<MiraAny>>;
137}
138
139impl<T: MiraArray> ArrayObject for MiraShared<T> {
140    fn identity(&self) -> usize {
141        self.identity()
142    }
143
144    fn tag(&self) -> &'static str {
145        type_name::<T>()
146    }
147
148    fn len(&self) -> Result<usize> {
149        self.inner
150            .try_borrow()
151            .map(|value| value.len())
152            .map_err(|_| MiraError::BorrowConflict {
153                operation: "read",
154                tag: type_name::<T>().into(),
155            })
156    }
157
158    fn get(&self, index: usize) -> Result<Option<MiraAny>> {
159        self.inner
160            .try_borrow()
161            .map_err(|_| MiraError::BorrowConflict {
162                operation: "read",
163                tag: type_name::<T>().into(),
164            })?
165            .get(index)
166    }
167}
168
169#[doc(hidden)]
170pub trait ExternObject {
171    fn identity(&self) -> usize;
172    fn tag(&self) -> Result<String>;
173    fn keys(&self) -> Result<Vec<String>>;
174    fn has(&self, key: &str) -> Result<bool>;
175    fn get(&self, key: &str) -> Result<Option<MiraAny>>;
176    fn set(&self, key: &str, value: MiraAny) -> Result<bool>;
177    fn is_callable(&self) -> Result<bool>;
178    fn call(&self, context: &mut MiraCallContext<'_>, args: &[MiraAny]) -> Result<MiraAny>;
179    fn array_len(&self) -> Result<Option<usize>>;
180    fn get_index(&self, index: usize) -> Result<Option<MiraAny>>;
181    fn iterate(&self) -> Result<Option<Vec<MiraAny>>>;
182}
183
184impl<T: MiraExtern> ExternObject for MiraShared<T> {
185    fn identity(&self) -> usize {
186        self.identity()
187    }
188
189    fn tag(&self) -> Result<String> {
190        self.try_read("read", |value| Ok(value.tag().to_owned()))
191    }
192
193    fn keys(&self) -> Result<Vec<String>> {
194        self.try_read("read", |value| Ok(value.keys()))
195    }
196
197    fn has(&self, key: &str) -> Result<bool> {
198        self.try_read("read", |value| Ok(value.has(key)))
199    }
200
201    fn get(&self, key: &str) -> Result<Option<MiraAny>> {
202        self.try_read("read", |value| value.get(key))
203    }
204
205    fn set(&self, key: &str, value: MiraAny) -> Result<bool> {
206        self.try_write("write", |object| object.set(key, value))
207    }
208
209    fn is_callable(&self) -> Result<bool> {
210        self.try_read("read", |value| Ok(value.is_callable()))
211    }
212
213    fn call(&self, context: &mut MiraCallContext<'_>, args: &[MiraAny]) -> Result<MiraAny> {
214        self.try_write("call", |value| value.call(context, args))
215    }
216
217    fn array_len(&self) -> Result<Option<usize>> {
218        self.try_read("read", |value| Ok(value.array_len()))
219    }
220
221    fn get_index(&self, index: usize) -> Result<Option<MiraAny>> {
222        self.try_read("read", |value| value.get_index(index))
223    }
224
225    fn iterate(&self) -> Result<Option<Vec<MiraAny>>> {
226        self.try_read("iterate", |value| value.iterate())
227    }
228}
229
230impl<T: MiraExtern> MiraShared<T> {
231    fn try_read<R>(&self, operation: &'static str, f: impl FnOnce(&T) -> Result<R>) -> Result<R> {
232        let value = self
233            .inner
234            .try_borrow()
235            .map_err(|_| MiraError::BorrowConflict {
236                operation,
237                tag: type_name::<T>().into(),
238            })?;
239        f(&value)
240    }
241
242    fn try_write<R>(
243        &self,
244        operation: &'static str,
245        f: impl FnOnce(&mut T) -> Result<R>,
246    ) -> Result<R> {
247        let mut value = self
248            .inner
249            .try_borrow_mut()
250            .map_err(|_| MiraError::BorrowConflict {
251                operation,
252                tag: type_name::<T>().into(),
253            })?;
254        f(&mut value)
255    }
256}