1use crate::{
2 lifetime::{ValueReadAccess, ValueWriteAccess},
3 managed::{
4 DynamicManaged, DynamicManagedLazy, DynamicManagedRef, DynamicManagedRefMut, Managed,
5 ManagedLazy, ManagedRef, ManagedRefMut,
6 gc::{DynamicManagedGc, ManagedGc},
7 },
8};
9
10pub enum ManagedValue<T> {
11 Owned(Managed<T>),
12 Ref(ManagedRef<T>),
13 RefMut(ManagedRefMut<T>),
14 Lazy(ManagedLazy<T>),
15 Gc(ManagedGc<T>),
16}
17
18impl<T> ManagedValue<T> {
19 pub fn as_owned(&self) -> Option<&Managed<T>> {
20 match self {
21 Self::Owned(value) => Some(value),
22 _ => None,
23 }
24 }
25
26 pub fn as_mut_owned(&mut self) -> Option<&mut Managed<T>> {
27 match self {
28 Self::Owned(value) => Some(value),
29 _ => None,
30 }
31 }
32
33 pub fn as_ref(&self) -> Option<&ManagedRef<T>> {
34 match self {
35 Self::Ref(value) => Some(value),
36 _ => None,
37 }
38 }
39
40 pub fn as_mut_ref(&mut self) -> Option<&mut ManagedRef<T>> {
41 match self {
42 Self::Ref(value) => Some(value),
43 _ => None,
44 }
45 }
46
47 pub fn as_ref_mut(&self) -> Option<&ManagedRefMut<T>> {
48 match self {
49 Self::RefMut(value) => Some(value),
50 _ => None,
51 }
52 }
53
54 pub fn as_mut_ref_mut(&mut self) -> Option<&mut ManagedRefMut<T>> {
55 match self {
56 Self::RefMut(value) => Some(value),
57 _ => None,
58 }
59 }
60
61 pub fn as_lazy(&self) -> Option<&ManagedLazy<T>> {
62 match self {
63 Self::Lazy(value) => Some(value),
64 _ => None,
65 }
66 }
67
68 pub fn as_mut_lazy(&mut self) -> Option<&mut ManagedLazy<T>> {
69 match self {
70 Self::Lazy(value) => Some(value),
71 _ => None,
72 }
73 }
74
75 pub fn as_gc(&self) -> Option<&ManagedGc<T>> {
76 match self {
77 Self::Gc(value) => Some(value),
78 _ => None,
79 }
80 }
81
82 pub fn as_mut_gc(&mut self) -> Option<&mut ManagedGc<T>> {
83 match self {
84 Self::Gc(value) => Some(value),
85 _ => None,
86 }
87 }
88
89 pub fn read(&'_ self) -> Option<ValueReadAccess<'_, T>> {
90 match self {
91 Self::Owned(value) => value.read(),
92 Self::Ref(value) => value.read(),
93 Self::RefMut(value) => value.read(),
94 Self::Lazy(value) => value.read(),
95 Self::Gc(value) => value.try_read(),
96 }
97 }
98
99 pub fn write(&'_ mut self) -> Option<ValueWriteAccess<'_, T>> {
100 match self {
101 Self::Owned(value) => value.write(),
102 Self::RefMut(value) => value.write(),
103 Self::Lazy(value) => value.write(),
104 Self::Gc(value) => value.try_write(),
105 _ => None,
106 }
107 }
108
109 pub fn borrow(&self) -> Option<ManagedRef<T>> {
110 match self {
111 Self::Owned(value) => value.borrow(),
112 Self::Ref(value) => value.borrow(),
113 Self::RefMut(value) => value.borrow(),
114 Self::Gc(value) => value.try_borrow(),
115 _ => None,
116 }
117 }
118
119 pub fn borrow_mut(&mut self) -> Option<ManagedRefMut<T>> {
120 match self {
121 Self::Owned(value) => value.borrow_mut(),
122 Self::RefMut(value) => value.borrow_mut(),
123 Self::Gc(value) => value.try_borrow_mut(),
124 _ => None,
125 }
126 }
127
128 pub fn lazy(&mut self) -> Option<ManagedLazy<T>> {
129 match self {
130 Self::Owned(value) => Some(value.lazy()),
131 Self::Lazy(value) => Some(value.clone()),
132 Self::RefMut(value) => Some(value.lazy()),
133 Self::Gc(value) => Some(value.lazy()),
134 _ => None,
135 }
136 }
137
138 pub unsafe fn lazy_immutable(&self) -> ManagedLazy<T> {
140 unsafe {
141 match self {
142 Self::Owned(value) => value.lazy_immutable(),
143 Self::Lazy(value) => value.clone(),
144 Self::Ref(value) => value.lazy_immutable(),
145 Self::RefMut(value) => value.lazy(),
146 Self::Gc(value) => value.lazy(),
147 }
148 }
149 }
150
151 pub fn into_dynamic(self) -> Result<DynamicManagedValue, Self> {
152 match self {
153 Self::Owned(value) => match value.into_dynamic() {
154 Ok(dynamic) => Ok(DynamicManagedValue::Owned(dynamic)),
155 Err(original) => Err(Self::Owned(original)),
156 },
157 Self::Ref(value) => Ok(DynamicManagedValue::Ref(value.into_dynamic())),
158 Self::RefMut(value) => Ok(DynamicManagedValue::RefMut(value.into_dynamic())),
159 Self::Lazy(value) => Ok(DynamicManagedValue::Lazy(value.into_dynamic())),
160 Self::Gc(value) => Ok(DynamicManagedValue::Gc(value.into_dynamic())),
161 }
162 }
163}
164
165impl<T> From<Managed<T>> for ManagedValue<T> {
166 fn from(value: Managed<T>) -> Self {
167 Self::Owned(value)
168 }
169}
170
171impl<T> TryFrom<ManagedValue<T>> for Managed<T> {
172 type Error = ();
173
174 fn try_from(value: ManagedValue<T>) -> Result<Self, Self::Error> {
175 match value {
176 ManagedValue::Owned(value) => Ok(value),
177 _ => Err(()),
178 }
179 }
180}
181
182impl<T> From<ManagedRef<T>> for ManagedValue<T> {
183 fn from(value: ManagedRef<T>) -> Self {
184 Self::Ref(value)
185 }
186}
187
188impl<T> From<ManagedRefMut<T>> for ManagedValue<T> {
189 fn from(value: ManagedRefMut<T>) -> Self {
190 Self::RefMut(value)
191 }
192}
193
194impl<T> From<ManagedLazy<T>> for ManagedValue<T> {
195 fn from(value: ManagedLazy<T>) -> Self {
196 Self::Lazy(value)
197 }
198}
199
200impl<T> From<ManagedGc<T>> for ManagedValue<T> {
201 fn from(value: ManagedGc<T>) -> Self {
202 Self::Gc(value)
203 }
204}
205
206pub enum DynamicManagedValue {
207 Owned(DynamicManaged),
208 Ref(DynamicManagedRef),
209 RefMut(DynamicManagedRefMut),
210 Lazy(DynamicManagedLazy),
211 Gc(DynamicManagedGc),
212}
213
214impl DynamicManagedValue {
215 pub fn as_owned(&self) -> Option<&DynamicManaged> {
216 match self {
217 Self::Owned(value) => Some(value),
218 _ => None,
219 }
220 }
221
222 pub fn as_mut_owned(&mut self) -> Option<&mut DynamicManaged> {
223 match self {
224 Self::Owned(value) => Some(value),
225 _ => None,
226 }
227 }
228
229 pub fn as_ref(&self) -> Option<&DynamicManagedRef> {
230 match self {
231 Self::Ref(value) => Some(value),
232 _ => None,
233 }
234 }
235
236 pub fn as_mut_ref(&mut self) -> Option<&mut DynamicManagedRef> {
237 match self {
238 Self::Ref(value) => Some(value),
239 _ => None,
240 }
241 }
242
243 pub fn as_ref_mut(&self) -> Option<&DynamicManagedRefMut> {
244 match self {
245 Self::RefMut(value) => Some(value),
246 _ => None,
247 }
248 }
249
250 pub fn as_mut_ref_mut(&mut self) -> Option<&mut DynamicManagedRefMut> {
251 match self {
252 Self::RefMut(value) => Some(value),
253 _ => None,
254 }
255 }
256
257 pub fn as_lazy(&self) -> Option<&DynamicManagedLazy> {
258 match self {
259 Self::Lazy(value) => Some(value),
260 _ => None,
261 }
262 }
263
264 pub fn as_mut_lazy(&mut self) -> Option<&mut DynamicManagedLazy> {
265 match self {
266 Self::Lazy(value) => Some(value),
267 _ => None,
268 }
269 }
270
271 pub fn as_gc(&self) -> Option<&DynamicManagedGc> {
272 match self {
273 Self::Gc(value) => Some(value),
274 _ => None,
275 }
276 }
277
278 pub fn as_mut_gc(&mut self) -> Option<&mut DynamicManagedGc> {
279 match self {
280 Self::Gc(value) => Some(value),
281 _ => None,
282 }
283 }
284
285 pub fn read<T>(&'_ self) -> Option<ValueReadAccess<'_, T>> {
286 match self {
287 Self::Owned(value) => value.read::<T>(),
288 Self::Ref(value) => value.read::<T>(),
289 Self::RefMut(value) => value.read::<T>(),
290 Self::Lazy(value) => value.read::<T>(),
291 Self::Gc(value) => value.try_read::<T>(),
292 }
293 }
294
295 pub fn write<T>(&'_ mut self) -> Option<ValueWriteAccess<'_, T>> {
296 match self {
297 Self::Owned(value) => value.write::<T>(),
298 Self::RefMut(value) => value.write::<T>(),
299 Self::Lazy(value) => value.write::<T>(),
300 Self::Gc(value) => value.try_write::<T>(),
301 _ => None,
302 }
303 }
304
305 pub fn borrow(&self) -> Option<DynamicManagedRef> {
306 match self {
307 Self::Owned(value) => value.borrow(),
308 Self::Ref(value) => value.borrow(),
309 Self::RefMut(value) => value.borrow(),
310 Self::Gc(value) => value.try_borrow(),
311 _ => None,
312 }
313 }
314
315 pub fn borrow_mut(&mut self) -> Option<DynamicManagedRefMut> {
316 match self {
317 Self::Owned(value) => value.borrow_mut(),
318 Self::RefMut(value) => value.borrow_mut(),
319 Self::Gc(value) => value.try_borrow_mut(),
320 _ => None,
321 }
322 }
323
324 pub fn lazy(&self) -> Option<DynamicManagedLazy> {
325 match self {
326 Self::Owned(value) => Some(value.lazy()),
327 Self::Lazy(value) => Some(value.clone()),
328 Self::RefMut(value) => Some(value.lazy()),
329 Self::Gc(value) => Some(value.lazy()),
330 _ => None,
331 }
332 }
333
334 pub unsafe fn lazy_immutable(&self) -> DynamicManagedLazy {
336 unsafe {
337 match self {
338 Self::Owned(value) => value.lazy(),
339 Self::Lazy(value) => value.clone(),
340 Self::Ref(value) => value.lazy_immutable(),
341 Self::RefMut(value) => value.lazy(),
342 Self::Gc(value) => value.lazy(),
343 }
344 }
345 }
346
347 pub fn into_typed<T>(self) -> Result<ManagedValue<T>, Self> {
348 match self {
349 Self::Owned(value) => match value.into_typed() {
350 Ok(typed) => Ok(ManagedValue::Owned(typed)),
351 Err(original) => Err(Self::Owned(original)),
352 },
353 Self::Ref(value) => match value.into_typed() {
354 Ok(typed) => Ok(ManagedValue::Ref(typed)),
355 Err(original) => Err(Self::Ref(original)),
356 },
357 Self::RefMut(value) => match value.into_typed() {
358 Ok(typed) => Ok(ManagedValue::RefMut(typed)),
359 Err(original) => Err(Self::RefMut(original)),
360 },
361 Self::Lazy(value) => match value.into_typed() {
362 Ok(typed) => Ok(ManagedValue::Lazy(typed)),
363 Err(original) => Err(Self::Lazy(original)),
364 },
365 Self::Gc(value) => Ok(ManagedValue::Gc(value.into_typed())),
366 }
367 }
368}
369
370impl From<DynamicManaged> for DynamicManagedValue {
371 fn from(value: DynamicManaged) -> Self {
372 Self::Owned(value)
373 }
374}
375
376impl From<DynamicManagedRef> for DynamicManagedValue {
377 fn from(value: DynamicManagedRef) -> Self {
378 Self::Ref(value)
379 }
380}
381
382impl From<DynamicManagedRefMut> for DynamicManagedValue {
383 fn from(value: DynamicManagedRefMut) -> Self {
384 Self::RefMut(value)
385 }
386}
387
388impl From<DynamicManagedLazy> for DynamicManagedValue {
389 fn from(value: DynamicManagedLazy) -> Self {
390 Self::Lazy(value)
391 }
392}
393
394impl From<DynamicManagedGc> for DynamicManagedValue {
395 fn from(value: DynamicManagedGc) -> Self {
396 Self::Gc(value)
397 }
398}