rune/runtime/
to_value.rs

Help
1use crate::alloc::prelude::*;
2use crate::alloc::{self, HashMap};
3use crate::any::AnyMarker;
4
5use super::{AnyObj, Object, RuntimeError, Value, VmResult};
6
7/// Derive macro for the [`ToValue`] trait for converting types into the dynamic
8/// `Value` container.
9///
10/// # Examples
11///
12/// ```
13/// use rune::{ToValue, Vm};
14/// use std::sync::Arc;
15///
16/// #[derive(ToValue)]
17/// struct Foo {
18///     field: u64,
19/// }
20///
21/// let mut sources = rune::sources! {
22///     entry => {
23///         pub fn main(foo) {
24///             foo.field + 1
25///         }
26///     }
27/// };
28///
29/// let unit = rune::prepare(&mut sources).build()?;
30///
31/// let mut vm = Vm::without_runtime(Arc::new(unit));
32/// let value = vm.call(["main"], (Foo { field: 42 },))?;
33/// let value: u64 = rune::from_value(value)?;
34///
35/// assert_eq!(value, 43);
36/// # Ok::<_, rune::support::Error>(())
37/// ```
38pub use rune_macros::ToValue;
39
40/// Convert something into the dynamic [`Value`].
41///
42/// # Examples
43///
44/// ```
45/// use rune::{ToValue, Vm};
46/// use std::sync::Arc;
47///
48/// #[derive(ToValue)]
49/// struct Foo {
50///     field: u64,
51/// }
52///
53/// let mut sources = rune::sources! {
54///     entry => {
55///         pub fn main(foo) {
56///             foo.field + 1
57///         }
58///     }
59/// };
60///
61/// let unit = rune::prepare(&mut sources).build()?;
62///
63/// let mut vm = Vm::without_runtime(Arc::new(unit));
64/// let foo = vm.call(["main"], (Foo { field: 42 },))?;
65/// let foo: u64 = rune::from_value(foo)?;
66///
67/// assert_eq!(foo, 43);
68/// # Ok::<_, rune::support::Error>(())
69/// ```
70pub fn to_value(value: impl ToValue) -> Result<Value, RuntimeError> {
71    value.to_value()
72}
73
74/// Trait for converting types into the dynamic [`Value`] container.
75///
76/// # Examples
77///
78/// ```
79/// use rune::{ToValue, Vm};
80/// use std::sync::Arc;
81///
82/// #[derive(ToValue)]
83/// struct Foo {
84///     field: u64,
85/// }
86///
87/// let mut sources = rune::sources! {
88///     entry => {
89///         pub fn main(foo) {
90///             foo.field + 1
91///         }
92///     }
93/// };
94///
95/// let unit = rune::prepare(&mut sources).build()?;
96///
97/// let mut vm = Vm::without_runtime(Arc::new(unit));
98/// let foo = vm.call(["main"], (Foo { field: 42 },))?;
99/// let foo: u64 = rune::from_value(foo)?;
100///
101/// assert_eq!(foo, 43);
102/// # Ok::<_, rune::support::Error>(())
103/// ```
104#[diagnostic::on_unimplemented(
105    message = "ToValue is not implemented for `{Self}`",
106    label = "ToValue is not implemented for `{Self}`",
107    note = "This probably means that `{Self}` hasn't derived rune::Any"
108)]
109pub trait ToValue: Sized {
110    /// Convert into a value.
111    fn to_value(self) -> Result<Value, RuntimeError>;
112}
113
114/// Trait governing things that can be returned from native functions.
115pub trait ToReturn: Sized {
116    /// Convert something into a return value.
117    fn to_return(self) -> VmResult<Value>;
118}
119
120impl<T> ToReturn for VmResult<T>
121where
122    T: ToValue,
123{
124    #[inline]
125    fn to_return(self) -> VmResult<Value> {
126        match self {
127            VmResult::Ok(value) => VmResult::Ok(vm_try!(value.to_value())),
128            VmResult::Err(error) => VmResult::Err(error),
129        }
130    }
131}
132
133impl<T> ToReturn for T
134where
135    T: ToValue,
136{
137    #[inline]
138    fn to_return(self) -> VmResult<Value> {
139        VmResult::Ok(vm_try!(T::to_value(self)))
140    }
141}
142
143impl ToValue for Value {
144    #[inline]
145    fn to_value(self) -> Result<Value, RuntimeError> {
146        Ok(self)
147    }
148}
149
150/// Trait for converting types into values.
151pub trait UnsafeToValue: Sized {
152    /// The type used to guard the unsafe value conversion.
153    type Guard: 'static;
154
155    /// Convert into a value.
156    ///
157    /// # Safety
158    ///
159    /// The value returned must not be used after the guard associated with it
160    /// has been dropped.
161    unsafe fn unsafe_to_value(self) -> Result<(Value, Self::Guard), RuntimeError>;
162}
163
164impl<T> ToValue for T
165where
166    T: AnyMarker,
167{
168    #[inline]
169    fn to_value(self) -> Result<Value, RuntimeError> {
170        Ok(Value::from(AnyObj::new(self)?))
171    }
172}
173
174impl<T> UnsafeToValue for T
175where
176    T: ToValue,
177{
178    type Guard = ();
179
180    #[inline]
181    unsafe fn unsafe_to_value(self) -> Result<(Value, Self::Guard), RuntimeError> {
182        Ok((self.to_value()?, ()))
183    }
184}
185
186impl ToValue for &Value {
187    #[inline]
188    fn to_value(self) -> Result<Value, RuntimeError> {
189        Ok(self.clone())
190    }
191}
192
193// Option impls
194
195impl<T> ToValue for Option<T>
196where
197    T: ToValue,
198{
199    #[inline]
200    fn to_value(self) -> Result<Value, RuntimeError> {
201        let option = match self {
202            Some(some) => Some(some.to_value()?),
203            None => None,
204        };
205
206        Ok(Value::try_from(option)?)
207    }
208}
209
210// String impls
211
212impl ToValue for alloc::Box<str> {
213    #[inline]
214    fn to_value(self) -> Result<Value, RuntimeError> {
215        let this = alloc::String::from(self);
216        Ok(Value::new(this)?)
217    }
218}
219
220impl ToValue for &str {
221    #[inline]
222    fn to_value(self) -> Result<Value, RuntimeError> {
223        let this = alloc::String::try_from(self)?;
224        Ok(Value::new(this)?)
225    }
226}
227
228#[cfg(feature = "alloc")]
229impl ToValue for ::rust_alloc::boxed::Box<str> {
230    #[inline]
231    fn to_value(self) -> Result<Value, RuntimeError> {
232        let this = self.try_to_string()?;
233        Ok(Value::new(this)?)
234    }
235}
236
237#[cfg(feature = "alloc")]
238impl ToValue for ::rust_alloc::string::String {
239    #[inline]
240    fn to_value(self) -> Result<Value, RuntimeError> {
241        let string = alloc::String::try_from(self)?;
242        Ok(Value::new(string)?)
243    }
244}
245
246impl<T, E> ToValue for Result<T, E>
247where
248    T: ToValue,
249    E: ToValue,
250{
251    fn to_value(self) -> Result<Value, RuntimeError> {
252        let result = match self {
253            Ok(ok) => Ok(ok.to_value()?),
254            Err(err) => Err(err.to_value()?),
255        };
256
257        Ok(Value::try_from(result)?)
258    }
259}
260
261// map impls
262
263macro_rules! impl_map {
264    ($ty:ty) => {
265        impl<T> ToValue for $ty
266        where
267            T: ToValue,
268        {
269            fn to_value(self) -> Result<Value, RuntimeError> {
270                let mut output = Object::with_capacity(self.len())?;
271
272                for (key, value) in self {
273                    let key = alloc::String::try_from(key)?;
274                    let value = value.to_value()?;
275                    output.insert(key, value)?;
276                }
277
278                Ok(Value::try_from(output)?)
279            }
280        }
281    };
282}
283
284impl_map!(HashMap<::rust_alloc::string::String, T>);
285impl_map!(HashMap<alloc::String, T>);
286
287cfg_std! {
288    impl_map!(::std::collections::HashMap<::rust_alloc::string::String, T>);
289    impl_map!(::std::collections::HashMap<alloc::String, T>);
290}
rune/runtime/to_value.rs

rune/runtime/
to_value.rs
