Trait FromVariable 

pub trait FromVariable {
    type Output;
    type RefOutput<'a>
       where Self: 'a;
    type MutOutput<'a>
       where Self: 'a;

    // Required methods
    fn from_var(var: Variable) -> Result<Self::Output, ParseVariableError>;
    fn from_var_ref(
        var: &Variable,
    ) -> Result<Self::RefOutput<'_>, ParseVariableError>;
    fn from_var_mut(
        var: &mut Variable,
    ) -> Result<Self::MutOutput<'_>, ParseVariableError>;
}

Required Associated Types

type Output

type RefOutput<'a> where Self: 'a

type MutOutput<'a> where Self: 'a

Required Methods

fn from_var(var: Variable) -> Result<Self::Output, ParseVariableError>

fn from_var_ref( var: &Variable, ) -> Result<Self::RefOutput<'_>, ParseVariableError>

fn from_var_mut( var: &mut Variable, ) -> Result<Self::MutOutput<'_>, ParseVariableError>

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

impl FromVariable for bool

type Output = bool

type RefOutput<'a> = &'a bool

type MutOutput<'a> = &'a mut bool

fn from_var(var: Variable) -> Result<Self::Output, ParseVariableError>

fn from_var_ref( var: &Variable, ) -> Result<Self::RefOutput<'_>, ParseVariableError>

fn from_var_mut( var: &mut Variable, ) -> Result<Self::MutOutput<'_>, ParseVariableError>

impl FromVariable for char

type Output = char

type RefOutput<'a> = &'a char

type MutOutput<'a> = &'a mut char

fn from_var(var: Variable) -> Result<Self::Output, ParseVariableError>

fn from_var_ref( var: &Variable, ) -> Result<Self::RefOutput<'_>, ParseVariableError>

fn from_var_mut( var: &mut Variable, ) -> Result<Self::MutOutput<'_>, ParseVariableError>

impl FromVariable for f32

type Output = f32

type RefOutput<'a> = &'a f32

type MutOutput<'a> = &'a mut f32

fn from_var(var: Variable) -> Result<Self::Output, ParseVariableError>

fn from_var_ref( var: &Variable, ) -> Result<Self::RefOutput<'_>, ParseVariableError>

fn from_var_mut( var: &mut Variable, ) -> Result<Self::MutOutput<'_>, ParseVariableError>

impl FromVariable for f64

type Output = f64

type RefOutput<'a> = &'a f64

type MutOutput<'a> = &'a mut f64

fn from_var(var: Variable) -> Result<Self::Output, ParseVariableError>

fn from_var_ref( var: &Variable, ) -> Result<Self::RefOutput<'_>, ParseVariableError>

fn from_var_mut( var: &mut Variable, ) -> Result<Self::MutOutput<'_>, ParseVariableError>

impl FromVariable for i8

type Output = i8

type RefOutput<'a> = &'a i8

type MutOutput<'a> = &'a mut i8

fn from_var(var: Variable) -> Result<Self::Output, ParseVariableError>

fn from_var_ref( var: &Variable, ) -> Result<Self::RefOutput<'_>, ParseVariableError>

fn from_var_mut( var: &mut Variable, ) -> Result<Self::MutOutput<'_>, ParseVariableError>

impl FromVariable for i16

type Output = i16

type RefOutput<'a> = &'a i16

type MutOutput<'a> = &'a mut i16

fn from_var(var: Variable) -> Result<Self::Output, ParseVariableError>

fn from_var_ref( var: &Variable, ) -> Result<Self::RefOutput<'_>, ParseVariableError>

fn from_var_mut( var: &mut Variable, ) -> Result<Self::MutOutput<'_>, ParseVariableError>

impl FromVariable for i32

type Output = i32

type RefOutput<'a> = &'a i32

type MutOutput<'a> = &'a mut i32

fn from_var(var: Variable) -> Result<Self::Output, ParseVariableError>

fn from_var_ref( var: &Variable, ) -> Result<Self::RefOutput<'_>, ParseVariableError>

fn from_var_mut( var: &mut Variable, ) -> Result<Self::MutOutput<'_>, ParseVariableError>

impl FromVariable for i64

type Output = i64

type RefOutput<'a> = &'a i64

type MutOutput<'a> = &'a mut i64

fn from_var(var: Variable) -> Result<Self::Output, ParseVariableError>

fn from_var_ref( var: &Variable, ) -> Result<Self::RefOutput<'_>, ParseVariableError>

fn from_var_mut( var: &mut Variable, ) -> Result<Self::MutOutput<'_>, ParseVariableError>

impl FromVariable for u8

type Output = u8

type RefOutput<'a> = &'a u8

type MutOutput<'a> = &'a mut u8

fn from_var(var: Variable) -> Result<Self::Output, ParseVariableError>

fn from_var_ref( var: &Variable, ) -> Result<Self::RefOutput<'_>, ParseVariableError>

fn from_var_mut( var: &mut Variable, ) -> Result<Self::MutOutput<'_>, ParseVariableError>

impl FromVariable for u16

type Output = u16

type RefOutput<'a> = &'a u16

type MutOutput<'a> = &'a mut u16

fn from_var(var: Variable) -> Result<Self::Output, ParseVariableError>

fn from_var_ref( var: &Variable, ) -> Result<Self::RefOutput<'_>, ParseVariableError>

fn from_var_mut( var: &mut Variable, ) -> Result<Self::MutOutput<'_>, ParseVariableError>

impl FromVariable for u32

type Output = u32

type RefOutput<'a> = &'a u32

type MutOutput<'a> = &'a mut u32

fn from_var(var: Variable) -> Result<Self::Output, ParseVariableError>

fn from_var_ref( var: &Variable, ) -> Result<Self::RefOutput<'_>, ParseVariableError>

fn from_var_mut( var: &mut Variable, ) -> Result<Self::MutOutput<'_>, ParseVariableError>

impl FromVariable for u64

type Output = u64

type RefOutput<'a> = &'a u64

type MutOutput<'a> = &'a mut u64

fn from_var(var: Variable) -> Result<Self::Output, ParseVariableError>

fn from_var_ref( var: &Variable, ) -> Result<Self::RefOutput<'_>, ParseVariableError>

fn from_var_mut( var: &mut Variable, ) -> Result<Self::MutOutput<'_>, ParseVariableError>

impl FromVariable for String

type Output = String

type RefOutput<'a> = &'a String

type MutOutput<'a> = &'a mut String

fn from_var(var: Variable) -> Result<Self::Output, ParseVariableError>

fn from_var_ref( var: &Variable, ) -> Result<Self::RefOutput<'_>, ParseVariableError>

fn from_var_mut( var: &mut Variable, ) -> Result<Self::MutOutput<'_>, ParseVariableError>

impl FromVariable for Vec<Variable>

type Output = Vec<Variable>

type RefOutput<'a> = &'a Vec<Variable>

type MutOutput<'a> = &'a mut Vec<Variable>

fn from_var(var: Variable) -> Result<Self::Output, ParseVariableError>

fn from_var_ref( var: &Variable, ) -> Result<Self::RefOutput<'_>, ParseVariableError>

fn from_var_mut( var: &mut Variable, ) -> Result<Self::MutOutput<'_>, ParseVariableError>

impl<T> FromVariable for Vec<T>

where T: FromVariable,

type Output = Vec<<T as FromVariable>::Output>

type RefOutput<'a> = Vec<<T as FromVariable>::RefOutput<'a>> where T: 'a

type MutOutput<'a> = Vec<<T as FromVariable>::MutOutput<'a>> where T: 'a

fn from_var(var: Variable) -> Result<Self::Output, ParseVariableError>

fn from_var_ref( var: &Variable, ) -> Result<Self::RefOutput<'_>, ParseVariableError>

fn from_var_mut( var: &mut Variable, ) -> Result<Self::MutOutput<'_>, ParseVariableError>

Implementors