mirascript_vm/value/
bridge.rs1use std::any::type_name;
2
3use crate::{MiraError, Result};
4
5use super::{MiraAny, MiraCallContext, MiraShared};
6
7pub trait MiraRecord: 'static {
9 fn keys(&self) -> Vec<String>;
11
12 fn get(&self, key: &str) -> Result<Option<MiraAny>>;
14}
15
16pub trait MiraArray: 'static {
18 fn len(&self) -> usize;
20
21 fn get(&self, index: usize) -> Result<Option<MiraAny>>;
23
24 fn is_empty(&self) -> bool {
26 self.len() == 0
27 }
28}
29
30pub trait MiraExtern: 'static {
32 fn tag(&self) -> &str {
34 type_name::<Self>()
35 }
36
37 fn keys(&self) -> Vec<String>;
39
40 fn get(&self, key: &str) -> Result<Option<MiraAny>>;
42
43 fn has(&self, key: &str) -> bool {
45 self.keys().iter().any(|candidate| candidate == key)
46 }
47
48 fn set(&mut self, _key: &str, _value: MiraAny) -> Result<bool> {
52 Ok(false)
53 }
54
55 fn is_callable(&self) -> bool {
57 false
58 }
59
60 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 fn array_len(&self) -> Option<usize> {
72 None
73 }
74
75 fn get_index(&self, index: usize) -> Result<Option<MiraAny>> {
79 self.get(&index.to_string())
80 }
81
82 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}