1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77
use crate::reflection::{FromValue, ReflectValueType, ToValue, UnsafeFromValue}; use crate::value::{Object, ValuePtr, ValueType, ValueTypeInfo}; use crate::vm::{RawRefGuard, Ref, StackError, Vm}; impl<T> ReflectValueType for Object<T> { fn value_type() -> ValueType { ValueType::Object } fn value_type_info() -> ValueTypeInfo { ValueTypeInfo::Object } } impl<'a, T> ReflectValueType for &'a Object<T> { fn value_type() -> ValueType { ValueType::Object } fn value_type_info() -> ValueTypeInfo { ValueTypeInfo::Object } } impl<'a, T> ReflectValueType for &'a mut Object<T> { fn value_type() -> ValueType { ValueType::Object } fn value_type_info() -> ValueTypeInfo { ValueTypeInfo::Object } } impl<T> FromValue for Object<T> where T: FromValue, { fn from_value(value: ValuePtr, vm: &mut Vm) -> Result<Self, StackError> { let slot = value.into_object(vm)?; let value = vm.object_take(slot)?; let mut object = Object::with_capacity(value.len()); for (key, value) in value { object.insert(key, T::from_value(value, vm)?); } Ok(object) } } impl<'a> UnsafeFromValue for &'a Object<ValuePtr> { type Guard = RawRefGuard; unsafe fn unsafe_from_value( value: ValuePtr, vm: &mut Vm, ) -> Result<(Self, Self::Guard), StackError> { let slot = value.into_object(vm)?; Ok(Ref::unsafe_into_ref(vm.object_ref(slot)?)) } } impl<T> ToValue for Object<T> where T: ToValue, { fn to_value(self, vm: &mut Vm) -> Result<ValuePtr, StackError> { let mut object = Object::with_capacity(self.len()); for (key, value) in self { object.insert(key, value.to_value(vm)?); } Ok(vm.object_allocate(object)) } }