Trait FromValues

Source
pub trait FromValues: Sized {
    // Required method
    fn from_values(values: Values, mv8: &MiniV8) -> Result<Self>;
}
Expand description

Trait for types that can be created from an arbitrary number of JavaScript values.

This is a generalization of FromValue, allowing an arbitrary number of JavaScript values to participate in the conversion. Any type that implements FromValue will automatically implement this trait.

Required Methods§

Source

fn from_values(values: Values, mv8: &MiniV8) -> Result<Self>

Performs the conversion.

In case values contains more values than needed to perform the conversion, the excess values should be ignored. Similarly, if not enough values are given, conversions should assume that any missing values are undefined.

Dyn Compatibility§

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types§

Source§

impl FromValues for ()

Source§

fn from_values(_values: Values, _mv8: &MiniV8) -> Result<Self>

Source§

impl<A> FromValues for (A,)
where A: FromValue,

Source§

fn from_values(values: Values, mv8: &MiniV8) -> Result<Self>

Source§

impl<A, B> FromValues for (A, B)
where A: FromValue, B: FromValue,

Source§

fn from_values(values: Values, mv8: &MiniV8) -> Result<Self>

Source§

impl<A, B, C> FromValues for (A, B, C)
where A: FromValue, B: FromValue, C: FromValue,

Source§

fn from_values(values: Values, mv8: &MiniV8) -> Result<Self>

Source§

impl<A, B, C, D> FromValues for (A, B, C, D)
where A: FromValue, B: FromValue, C: FromValue, D: FromValue,

Source§

fn from_values(values: Values, mv8: &MiniV8) -> Result<Self>

Source§

impl<A, B, C, D, E> FromValues for (A, B, C, D, E)
where A: FromValue, B: FromValue, C: FromValue, D: FromValue, E: FromValue,

Source§

fn from_values(values: Values, mv8: &MiniV8) -> Result<Self>

Source§

impl<A, B, C, D, E, F> FromValues for (A, B, C, D, E, F)

Source§

fn from_values(values: Values, mv8: &MiniV8) -> Result<Self>

Source§

impl<A, B, C, D, E, F, G> FromValues for (A, B, C, D, E, F, G)

Source§

fn from_values(values: Values, mv8: &MiniV8) -> Result<Self>

Source§

impl<A, B, C, D, E, F, G, H> FromValues for (A, B, C, D, E, F, G, H)

Source§

fn from_values(values: Values, mv8: &MiniV8) -> Result<Self>

Source§

impl<A, B, C, D, E, F, G, H, I> FromValues for (A, B, C, D, E, F, G, H, I)

Source§

fn from_values(values: Values, mv8: &MiniV8) -> Result<Self>

Source§

impl<A, B, C, D, E, F, G, H, I, J> FromValues for (A, B, C, D, E, F, G, H, I, J)

Source§

fn from_values(values: Values, mv8: &MiniV8) -> Result<Self>

Source§

impl<A, B, C, D, E, F, G, H, I, J, K> FromValues for (A, B, C, D, E, F, G, H, I, J, K)

Source§

fn from_values(values: Values, mv8: &MiniV8) -> Result<Self>

Source§

impl<A, B, C, D, E, F, G, H, I, J, K, L> FromValues for (A, B, C, D, E, F, G, H, I, J, K, L)

Source§

fn from_values(values: Values, mv8: &MiniV8) -> Result<Self>

Source§

impl<A, B, C, D, E, F, G, H, I, J, K, L, M> FromValues for (A, B, C, D, E, F, G, H, I, J, K, L, M)

Source§

fn from_values(values: Values, mv8: &MiniV8) -> Result<Self>

Source§

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N> FromValues for (A, B, C, D, E, F, G, H, I, J, K, L, M, N)

Source§

fn from_values(values: Values, mv8: &MiniV8) -> Result<Self>

Source§

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> FromValues for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)

Source§

fn from_values(values: Values, mv8: &MiniV8) -> Result<Self>

Source§

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> FromValues for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)

Source§

fn from_values(values: Values, mv8: &MiniV8) -> Result<Self>

Source§

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, VAR> FromValues for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Variadic<VAR>)

Source§

fn from_values(values: Values, mv8: &MiniV8) -> Result<Self>

Source§

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, VAR> FromValues for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, Variadic<VAR>)

Source§

fn from_values(values: Values, mv8: &MiniV8) -> Result<Self>

Source§

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, VAR> FromValues for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, Variadic<VAR>)

Source§

fn from_values(values: Values, mv8: &MiniV8) -> Result<Self>

Source§

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, VAR> FromValues for (A, B, C, D, E, F, G, H, I, J, K, L, M, Variadic<VAR>)

Source§

fn from_values(values: Values, mv8: &MiniV8) -> Result<Self>

Source§

impl<A, B, C, D, E, F, G, H, I, J, K, L, VAR> FromValues for (A, B, C, D, E, F, G, H, I, J, K, L, Variadic<VAR>)

Source§

fn from_values(values: Values, mv8: &MiniV8) -> Result<Self>

Source§

impl<A, B, C, D, E, F, G, H, I, J, K, VAR> FromValues for (A, B, C, D, E, F, G, H, I, J, K, Variadic<VAR>)

Source§

fn from_values(values: Values, mv8: &MiniV8) -> Result<Self>

Source§

impl<A, B, C, D, E, F, G, H, I, J, VAR> FromValues for (A, B, C, D, E, F, G, H, I, J, Variadic<VAR>)

Source§

fn from_values(values: Values, mv8: &MiniV8) -> Result<Self>

Source§

impl<A, B, C, D, E, F, G, H, I, VAR> FromValues for (A, B, C, D, E, F, G, H, I, Variadic<VAR>)

Source§

fn from_values(values: Values, mv8: &MiniV8) -> Result<Self>

Source§

impl<A, B, C, D, E, F, G, H, VAR> FromValues for (A, B, C, D, E, F, G, H, Variadic<VAR>)

Source§

fn from_values(values: Values, mv8: &MiniV8) -> Result<Self>

Source§

impl<A, B, C, D, E, F, G, VAR> FromValues for (A, B, C, D, E, F, G, Variadic<VAR>)

Source§

fn from_values(values: Values, mv8: &MiniV8) -> Result<Self>

Source§

impl<A, B, C, D, E, F, VAR> FromValues for (A, B, C, D, E, F, Variadic<VAR>)
where A: FromValue, B: FromValue, C: FromValue, D: FromValue, E: FromValue, F: FromValue, VAR: FromValue,

Source§

fn from_values(values: Values, mv8: &MiniV8) -> Result<Self>

Source§

impl<A, B, C, D, E, VAR> FromValues for (A, B, C, D, E, Variadic<VAR>)
where A: FromValue, B: FromValue, C: FromValue, D: FromValue, E: FromValue, VAR: FromValue,

Source§

fn from_values(values: Values, mv8: &MiniV8) -> Result<Self>

Source§

impl<A, B, C, D, VAR> FromValues for (A, B, C, D, Variadic<VAR>)
where A: FromValue, B: FromValue, C: FromValue, D: FromValue, VAR: FromValue,

Source§

fn from_values(values: Values, mv8: &MiniV8) -> Result<Self>

Source§

impl<A, B, C, VAR> FromValues for (A, B, C, Variadic<VAR>)
where A: FromValue, B: FromValue, C: FromValue, VAR: FromValue,

Source§

fn from_values(values: Values, mv8: &MiniV8) -> Result<Self>

Source§

impl<A, B, VAR> FromValues for (A, B, Variadic<VAR>)
where A: FromValue, B: FromValue, VAR: FromValue,

Source§

fn from_values(values: Values, mv8: &MiniV8) -> Result<Self>

Source§

impl<A, VAR> FromValues for (A, Variadic<VAR>)
where A: FromValue, VAR: FromValue,

Source§

fn from_values(values: Values, mv8: &MiniV8) -> Result<Self>

Implementors§