Trait ToValues

pub trait ToValues {
    // Required method
    fn to_values(self, mv8: &MiniV8) -> Result<Values>;
}

Trait for types convertible to any number of JavaScript values.

This is a generalization of ToValue, allowing any number of resulting JavaScript values instead of just one. Any type that implements ToValue will automatically implement this trait.

Required Methods

fn to_values(self, mv8: &MiniV8) -> Result<Values>

Performs the conversion.

Implementations on Foreign Types

impl ToValues for ()

fn to_values(self, _mv8: &MiniV8) -> Result<Values>

impl<A> ToValues for (A,)

where A: ToValue,

fn to_values(self, mv8: &MiniV8) -> Result<Values>

impl<A, B> ToValues for (A, B)

where A: ToValue, B: ToValue,

fn to_values(self, mv8: &MiniV8) -> Result<Values>

impl<A, B, C> ToValues for (A, B, C)

where A: ToValue, B: ToValue, C: ToValue,

fn to_values(self, mv8: &MiniV8) -> Result<Values>

impl<A, B, C, D> ToValues for (A, B, C, D)

where A: ToValue, B: ToValue, C: ToValue, D: ToValue,

fn to_values(self, mv8: &MiniV8) -> Result<Values>

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

where A: ToValue, B: ToValue, C: ToValue, D: ToValue, E: ToValue,

fn to_values(self, mv8: &MiniV8) -> Result<Values>

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

where A: ToValue, B: ToValue, C: ToValue, D: ToValue, E: ToValue, F: ToValue,

fn to_values(self, mv8: &MiniV8) -> Result<Values>

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

where A: ToValue, B: ToValue, C: ToValue, D: ToValue, E: ToValue, F: ToValue, G: ToValue,

fn to_values(self, mv8: &MiniV8) -> Result<Values>

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

where A: ToValue, B: ToValue, C: ToValue, D: ToValue, E: ToValue, F: ToValue, G: ToValue, H: ToValue,

fn to_values(self, mv8: &MiniV8) -> Result<Values>

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

where A: ToValue, B: ToValue, C: ToValue, D: ToValue, E: ToValue, F: ToValue, G: ToValue, H: ToValue, I: ToValue,

fn to_values(self, mv8: &MiniV8) -> Result<Values>

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

where A: ToValue, B: ToValue, C: ToValue, D: ToValue, E: ToValue, F: ToValue, G: ToValue, H: ToValue, I: ToValue, J: ToValue,

fn to_values(self, mv8: &MiniV8) -> Result<Values>

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

where A: ToValue, B: ToValue, C: ToValue, D: ToValue, E: ToValue, F: ToValue, G: ToValue, H: ToValue, I: ToValue, J: ToValue, K: ToValue,

fn to_values(self, mv8: &MiniV8) -> Result<Values>

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

where A: ToValue, B: ToValue, C: ToValue, D: ToValue, E: ToValue, F: ToValue, G: ToValue, H: ToValue, I: ToValue, J: ToValue, K: ToValue, L: ToValue,

fn to_values(self, mv8: &MiniV8) -> Result<Values>

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

where A: ToValue, B: ToValue, C: ToValue, D: ToValue, E: ToValue, F: ToValue, G: ToValue, H: ToValue, I: ToValue, J: ToValue, K: ToValue, L: ToValue, M: ToValue,

fn to_values(self, mv8: &MiniV8) -> Result<Values>

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

where A: ToValue, B: ToValue, C: ToValue, D: ToValue, E: ToValue, F: ToValue, G: ToValue, H: ToValue, I: ToValue, J: ToValue, K: ToValue, L: ToValue, M: ToValue, N: ToValue,

fn to_values(self, mv8: &MiniV8) -> Result<Values>

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

where A: ToValue, B: ToValue, C: ToValue, D: ToValue, E: ToValue, F: ToValue, G: ToValue, H: ToValue, I: ToValue, J: ToValue, K: ToValue, L: ToValue, M: ToValue, N: ToValue, O: ToValue,

fn to_values(self, mv8: &MiniV8) -> Result<Values>

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

where A: ToValue, B: ToValue, C: ToValue, D: ToValue, E: ToValue, F: ToValue, G: ToValue, H: ToValue, I: ToValue, J: ToValue, K: ToValue, L: ToValue, M: ToValue, N: ToValue, O: ToValue, P: ToValue,

fn to_values(self, mv8: &MiniV8) -> Result<Values>

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

where A: ToValue, B: ToValue, C: ToValue, D: ToValue, E: ToValue, F: ToValue, G: ToValue, H: ToValue, I: ToValue, J: ToValue, K: ToValue, L: ToValue, M: ToValue, N: ToValue, O: ToValue, P: ToValue, VAR: ToValue,

fn to_values(self, mv8: &MiniV8) -> Result<Values>

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

where A: ToValue, B: ToValue, C: ToValue, D: ToValue, E: ToValue, F: ToValue, G: ToValue, H: ToValue, I: ToValue, J: ToValue, K: ToValue, L: ToValue, M: ToValue, N: ToValue, O: ToValue, VAR: ToValue,

fn to_values(self, mv8: &MiniV8) -> Result<Values>

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

where A: ToValue, B: ToValue, C: ToValue, D: ToValue, E: ToValue, F: ToValue, G: ToValue, H: ToValue, I: ToValue, J: ToValue, K: ToValue, L: ToValue, M: ToValue, N: ToValue, VAR: ToValue,

fn to_values(self, mv8: &MiniV8) -> Result<Values>

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

where A: ToValue, B: ToValue, C: ToValue, D: ToValue, E: ToValue, F: ToValue, G: ToValue, H: ToValue, I: ToValue, J: ToValue, K: ToValue, L: ToValue, M: ToValue, VAR: ToValue,

fn to_values(self, mv8: &MiniV8) -> Result<Values>

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

where A: ToValue, B: ToValue, C: ToValue, D: ToValue, E: ToValue, F: ToValue, G: ToValue, H: ToValue, I: ToValue, J: ToValue, K: ToValue, L: ToValue, VAR: ToValue,

fn to_values(self, mv8: &MiniV8) -> Result<Values>

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

where A: ToValue, B: ToValue, C: ToValue, D: ToValue, E: ToValue, F: ToValue, G: ToValue, H: ToValue, I: ToValue, J: ToValue, K: ToValue, VAR: ToValue,

fn to_values(self, mv8: &MiniV8) -> Result<Values>

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

where A: ToValue, B: ToValue, C: ToValue, D: ToValue, E: ToValue, F: ToValue, G: ToValue, H: ToValue, I: ToValue, J: ToValue, VAR: ToValue,

fn to_values(self, mv8: &MiniV8) -> Result<Values>

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

where A: ToValue, B: ToValue, C: ToValue, D: ToValue, E: ToValue, F: ToValue, G: ToValue, H: ToValue, I: ToValue, VAR: ToValue,

fn to_values(self, mv8: &MiniV8) -> Result<Values>

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

where A: ToValue, B: ToValue, C: ToValue, D: ToValue, E: ToValue, F: ToValue, G: ToValue, H: ToValue, VAR: ToValue,

fn to_values(self, mv8: &MiniV8) -> Result<Values>

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

where A: ToValue, B: ToValue, C: ToValue, D: ToValue, E: ToValue, F: ToValue, G: ToValue, VAR: ToValue,

fn to_values(self, mv8: &MiniV8) -> Result<Values>

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

where A: ToValue, B: ToValue, C: ToValue, D: ToValue, E: ToValue, F: ToValue, VAR: ToValue,

fn to_values(self, mv8: &MiniV8) -> Result<Values>

impl<A, B, C, D, E, VAR> ToValues for (A, B, C, D, E, Variadic<VAR>)

where A: ToValue, B: ToValue, C: ToValue, D: ToValue, E: ToValue, VAR: ToValue,

fn to_values(self, mv8: &MiniV8) -> Result<Values>

impl<A, B, C, D, VAR> ToValues for (A, B, C, D, Variadic<VAR>)

where A: ToValue, B: ToValue, C: ToValue, D: ToValue, VAR: ToValue,

fn to_values(self, mv8: &MiniV8) -> Result<Values>

impl<A, B, C, VAR> ToValues for (A, B, C, Variadic<VAR>)

where A: ToValue, B: ToValue, C: ToValue, VAR: ToValue,

fn to_values(self, mv8: &MiniV8) -> Result<Values>

impl<A, B, VAR> ToValues for (A, B, Variadic<VAR>)

where A: ToValue, B: ToValue, VAR: ToValue,

fn to_values(self, mv8: &MiniV8) -> Result<Values>

impl<A, VAR> ToValues for (A, Variadic<VAR>)

where A: ToValue, VAR: ToValue,

fn to_values(self, mv8: &MiniV8) -> Result<Values>

Implementors

impl ToValues for Values

impl<T: ToValue> ToValues for Variadic<T>