Trait conv::ValueFrom

pub trait ValueFrom<Src>: Sized {
    type Err: Error;
    fn value_from(src: Src) -> Result<Self, Self::Err>;
}

This trait is used to perform an exact, value-preserving conversion.

Where possible, prefer implementing this trait over ValueInto, but prefer using ValueInto for generic constraints.

Details

Implementations of this trait should be reflexive, associative and commutative (in the absence of conversion errors). That is, all possible cycles of ValueFrom conversions (for which each "step" has a defined implementation) should produce the same result, with a given value either being "round-tripped" exactly, or an error being produced.

Associated Types

type Err: Error

The error type produced by a failed conversion.

Loading content...

Required methods

fn value_from(src: Src) -> Result<Self, Self::Err>

Convert the given value into an exactly equivalent representation.

Loading content...

Implementations on Foreign Types

impl ValueFrom<i8> for i16

type Err = NoError

fn value_from(src: i8) -> Result<i16, Self::Err>

impl ValueFrom<i8> for i32

type Err = NoError

fn value_from(src: i8) -> Result<i32, Self::Err>

impl ValueFrom<i8> for i64

type Err = NoError

fn value_from(src: i8) -> Result<i64, Self::Err>

impl ValueFrom<i8> for u8

type Err = NegOverflow<i8>

fn value_from(src: i8) -> Result<u8, Self::Err>

impl ValueFrom<i8> for u16

type Err = NegOverflow<i8>

fn value_from(src: i8) -> Result<u16, Self::Err>

impl ValueFrom<i8> for u32

type Err = NegOverflow<i8>

fn value_from(src: i8) -> Result<u32, Self::Err>

impl ValueFrom<i8> for u64

type Err = NegOverflow<i8>

fn value_from(src: i8) -> Result<u64, Self::Err>

impl ValueFrom<i8> for isize

type Err = NoError

fn value_from(src: i8) -> Result<isize, Self::Err>

impl ValueFrom<i8> for usize

type Err = NegOverflow<i8>

fn value_from(src: i8) -> Result<usize, Self::Err>

impl ValueFrom<i16> for i8

type Err = RangeError<i16>

fn value_from(src: i16) -> Result<i8, Self::Err>

impl ValueFrom<i16> for i32

type Err = NoError

fn value_from(src: i16) -> Result<i32, Self::Err>

impl ValueFrom<i16> for i64

type Err = NoError

fn value_from(src: i16) -> Result<i64, Self::Err>

impl ValueFrom<i16> for u8

type Err = RangeError<i16>

fn value_from(src: i16) -> Result<u8, Self::Err>

impl ValueFrom<i16> for u16

type Err = NegOverflow<i16>

fn value_from(src: i16) -> Result<u16, Self::Err>

impl ValueFrom<i16> for u32

type Err = NegOverflow<i16>

fn value_from(src: i16) -> Result<u32, Self::Err>

impl ValueFrom<i16> for u64

type Err = NegOverflow<i16>

fn value_from(src: i16) -> Result<u64, Self::Err>

impl ValueFrom<i16> for isize

type Err = NoError

fn value_from(src: i16) -> Result<isize, Self::Err>

impl ValueFrom<i16> for usize

type Err = NegOverflow<i16>

fn value_from(src: i16) -> Result<usize, Self::Err>

impl ValueFrom<i32> for i8

type Err = RangeError<i32>

fn value_from(src: i32) -> Result<i8, Self::Err>

impl ValueFrom<i32> for i16

type Err = RangeError<i32>

fn value_from(src: i32) -> Result<i16, Self::Err>

impl ValueFrom<i32> for i64

type Err = NoError

fn value_from(src: i32) -> Result<i64, Self::Err>

impl ValueFrom<i32> for u8

type Err = RangeError<i32>

fn value_from(src: i32) -> Result<u8, Self::Err>

impl ValueFrom<i32> for u16

type Err = RangeError<i32>

fn value_from(src: i32) -> Result<u16, Self::Err>

impl ValueFrom<i32> for u32

type Err = NegOverflow<i32>

fn value_from(src: i32) -> Result<u32, Self::Err>

impl ValueFrom<i32> for u64

type Err = NegOverflow<i32>

fn value_from(src: i32) -> Result<u64, Self::Err>

impl ValueFrom<i64> for i8

type Err = RangeError<i64>

fn value_from(src: i64) -> Result<i8, Self::Err>

impl ValueFrom<i64> for i16

type Err = RangeError<i64>

fn value_from(src: i64) -> Result<i16, Self::Err>

impl ValueFrom<i64> for i32

type Err = RangeError<i64>

fn value_from(src: i64) -> Result<i32, Self::Err>

impl ValueFrom<i64> for u8

type Err = RangeError<i64>

fn value_from(src: i64) -> Result<u8, Self::Err>

impl ValueFrom<i64> for u16

type Err = RangeError<i64>

fn value_from(src: i64) -> Result<u16, Self::Err>

impl ValueFrom<i64> for u32

type Err = RangeError<i64>

fn value_from(src: i64) -> Result<u32, Self::Err>

impl ValueFrom<i64> for u64

type Err = NegOverflow<i64>

fn value_from(src: i64) -> Result<u64, Self::Err>

impl ValueFrom<i32> for isize

type Err = NoError

fn value_from(src: i32) -> Result<isize, Self::Err>

impl ValueFrom<i32> for usize

type Err = NegOverflow<i32>

fn value_from(src: i32) -> Result<usize, Self::Err>

impl ValueFrom<i64> for isize

type Err = NoError

fn value_from(src: i64) -> Result<isize, Self::Err>

impl ValueFrom<i64> for usize

type Err = NegOverflow<i64>

fn value_from(src: i64) -> Result<usize, Self::Err>

impl ValueFrom<u8> for i8

type Err = PosOverflow<u8>

fn value_from(src: u8) -> Result<i8, Self::Err>

impl ValueFrom<u8> for i16

type Err = NoError

fn value_from(src: u8) -> Result<i16, Self::Err>

impl ValueFrom<u8> for i32

type Err = NoError

fn value_from(src: u8) -> Result<i32, Self::Err>

impl ValueFrom<u8> for i64

type Err = NoError

fn value_from(src: u8) -> Result<i64, Self::Err>

impl ValueFrom<u8> for u16

type Err = NoError

fn value_from(src: u8) -> Result<u16, Self::Err>

impl ValueFrom<u8> for u32

type Err = NoError

fn value_from(src: u8) -> Result<u32, Self::Err>

impl ValueFrom<u8> for u64

type Err = NoError

fn value_from(src: u8) -> Result<u64, Self::Err>

impl ValueFrom<u8> for isize

type Err = NoError

fn value_from(src: u8) -> Result<isize, Self::Err>

impl ValueFrom<u8> for usize

type Err = NoError

fn value_from(src: u8) -> Result<usize, Self::Err>

impl ValueFrom<u16> for i8

type Err = PosOverflow<u16>

fn value_from(src: u16) -> Result<i8, Self::Err>

impl ValueFrom<u16> for i16

type Err = PosOverflow<u16>

fn value_from(src: u16) -> Result<i16, Self::Err>

impl ValueFrom<u16> for i32

type Err = NoError

fn value_from(src: u16) -> Result<i32, Self::Err>

impl ValueFrom<u16> for i64

type Err = NoError

fn value_from(src: u16) -> Result<i64, Self::Err>

impl ValueFrom<u16> for u8

type Err = PosOverflow<u16>

fn value_from(src: u16) -> Result<u8, Self::Err>

impl ValueFrom<u16> for u32

type Err = NoError

fn value_from(src: u16) -> Result<u32, Self::Err>

impl ValueFrom<u16> for u64

type Err = NoError

fn value_from(src: u16) -> Result<u64, Self::Err>

impl ValueFrom<u16> for isize

type Err = NoError

fn value_from(src: u16) -> Result<isize, Self::Err>

impl ValueFrom<u16> for usize

type Err = NoError

fn value_from(src: u16) -> Result<usize, Self::Err>

impl ValueFrom<u32> for i8

type Err = PosOverflow<u32>

fn value_from(src: u32) -> Result<i8, Self::Err>

impl ValueFrom<u32> for i16

type Err = PosOverflow<u32>

fn value_from(src: u32) -> Result<i16, Self::Err>

impl ValueFrom<u32> for i32

type Err = PosOverflow<u32>

fn value_from(src: u32) -> Result<i32, Self::Err>

impl ValueFrom<u32> for i64

type Err = NoError

fn value_from(src: u32) -> Result<i64, Self::Err>

impl ValueFrom<u32> for u8

type Err = PosOverflow<u32>

fn value_from(src: u32) -> Result<u8, Self::Err>

impl ValueFrom<u32> for u16

type Err = PosOverflow<u32>

fn value_from(src: u32) -> Result<u16, Self::Err>

impl ValueFrom<u32> for u64

type Err = NoError

fn value_from(src: u32) -> Result<u64, Self::Err>

impl ValueFrom<u64> for i8

type Err = PosOverflow<u64>

fn value_from(src: u64) -> Result<i8, Self::Err>

impl ValueFrom<u64> for i16

type Err = PosOverflow<u64>

fn value_from(src: u64) -> Result<i16, Self::Err>

impl ValueFrom<u64> for i32

type Err = PosOverflow<u64>

fn value_from(src: u64) -> Result<i32, Self::Err>

impl ValueFrom<u64> for i64

type Err = PosOverflow<u64>

fn value_from(src: u64) -> Result<i64, Self::Err>

impl ValueFrom<u64> for u8

type Err = PosOverflow<u64>

fn value_from(src: u64) -> Result<u8, Self::Err>

impl ValueFrom<u64> for u16

type Err = PosOverflow<u64>

fn value_from(src: u64) -> Result<u16, Self::Err>

impl ValueFrom<u64> for u32

type Err = PosOverflow<u64>

fn value_from(src: u64) -> Result<u32, Self::Err>

impl ValueFrom<u32> for isize

type Err = NoError

fn value_from(src: u32) -> Result<isize, Self::Err>

impl ValueFrom<u32> for usize

type Err = NoError

fn value_from(src: u32) -> Result<usize, Self::Err>

impl ValueFrom<u64> for isize

type Err = PosOverflow<u64>

fn value_from(src: u64) -> Result<isize, Self::Err>

impl ValueFrom<u64> for usize

type Err = NoError

fn value_from(src: u64) -> Result<usize, Self::Err>

impl ValueFrom<isize> for i8

type Err = RangeError<isize>

fn value_from(src: isize) -> Result<i8, Self::Err>

impl ValueFrom<isize> for i16

type Err = RangeError<isize>

fn value_from(src: isize) -> Result<i16, Self::Err>

impl ValueFrom<isize> for i32

type Err = RangeError<isize>

fn value_from(src: isize) -> Result<i32, Self::Err>

impl ValueFrom<isize> for i64

type Err = NoError

fn value_from(src: isize) -> Result<i64, Self::Err>

impl ValueFrom<isize> for u8

type Err = RangeError<isize>

fn value_from(src: isize) -> Result<u8, Self::Err>

impl ValueFrom<isize> for u16

type Err = RangeError<isize>

fn value_from(src: isize) -> Result<u16, Self::Err>

impl ValueFrom<isize> for u32

type Err = RangeError<isize>

fn value_from(src: isize) -> Result<u32, Self::Err>

impl ValueFrom<isize> for u64

type Err = NegOverflow<isize>

fn value_from(src: isize) -> Result<u64, Self::Err>

impl ValueFrom<isize> for usize

type Err = NegOverflow<isize>

fn value_from(src: isize) -> Result<usize, Self::Err>

impl ValueFrom<usize> for i8

type Err = PosOverflow<usize>

fn value_from(src: usize) -> Result<i8, Self::Err>

impl ValueFrom<usize> for i16

type Err = PosOverflow<usize>

fn value_from(src: usize) -> Result<i16, Self::Err>

impl ValueFrom<usize> for i32

type Err = PosOverflow<usize>

fn value_from(src: usize) -> Result<i32, Self::Err>

impl ValueFrom<usize> for i64

type Err = PosOverflow<usize>

fn value_from(src: usize) -> Result<i64, Self::Err>

impl ValueFrom<usize> for u8

type Err = PosOverflow<usize>

fn value_from(src: usize) -> Result<u8, Self::Err>

impl ValueFrom<usize> for u16

type Err = PosOverflow<usize>

fn value_from(src: usize) -> Result<u16, Self::Err>

impl ValueFrom<usize> for u32

type Err = PosOverflow<usize>

fn value_from(src: usize) -> Result<u32, Self::Err>

impl ValueFrom<usize> for u64

type Err = NoError

fn value_from(src: usize) -> Result<u64, Self::Err>

impl ValueFrom<usize> for isize

type Err = PosOverflow<usize>

fn value_from(src: usize) -> Result<isize, Self::Err>

impl ValueFrom<f32> for f64

type Err = NoError

fn value_from(src: f32) -> Result<f64, Self::Err>

impl ValueFrom<i8> for f32

type Err = NoError

fn value_from(src: i8) -> Result<f32, Self::Err>

impl ValueFrom<i8> for f64

type Err = NoError

fn value_from(src: i8) -> Result<f64, Self::Err>

impl ValueFrom<i16> for f32

type Err = NoError

fn value_from(src: i16) -> Result<f32, Self::Err>

impl ValueFrom<i16> for f64

type Err = NoError

fn value_from(src: i16) -> Result<f64, Self::Err>

impl ValueFrom<i32> for f32

type Err = RangeError<i32>

fn value_from(src: i32) -> Result<f32, Self::Err>

impl ValueFrom<i32> for f64

type Err = NoError

fn value_from(src: i32) -> Result<f64, Self::Err>

impl ValueFrom<i64> for f32

type Err = RangeError<i64>

fn value_from(src: i64) -> Result<f32, Self::Err>

impl ValueFrom<i64> for f64

type Err = RangeError<i64>

fn value_from(src: i64) -> Result<f64, Self::Err>

impl ValueFrom<u8> for f32

type Err = NoError

fn value_from(src: u8) -> Result<f32, Self::Err>

impl ValueFrom<u8> for f64

type Err = NoError

fn value_from(src: u8) -> Result<f64, Self::Err>

impl ValueFrom<u16> for f32

type Err = NoError

fn value_from(src: u16) -> Result<f32, Self::Err>

impl ValueFrom<u16> for f64

type Err = NoError

fn value_from(src: u16) -> Result<f64, Self::Err>

impl ValueFrom<u32> for f32

type Err = PosOverflow<u32>

fn value_from(src: u32) -> Result<f32, Self::Err>

impl ValueFrom<u32> for f64

type Err = NoError

fn value_from(src: u32) -> Result<f64, Self::Err>

impl ValueFrom<u64> for f32

type Err = PosOverflow<u64>

fn value_from(src: u64) -> Result<f32, Self::Err>

impl ValueFrom<u64> for f64

type Err = PosOverflow<u64>

fn value_from(src: u64) -> Result<f64, Self::Err>

impl ValueFrom<isize> for f32

type Err = RangeError<isize>

fn value_from(src: isize) -> Result<f32, Self::Err>

impl ValueFrom<isize> for f64

type Err = RangeError<isize>

fn value_from(src: isize) -> Result<f64, Self::Err>

impl ValueFrom<usize> for f32

type Err = PosOverflow<usize>

fn value_from(src: usize) -> Result<f32, Self::Err>

impl ValueFrom<usize> for f64

type Err = PosOverflow<usize>

fn value_from(src: usize) -> Result<f64, Self::Err>

Loading content...

Implementors

impl<Src> ValueFrom<Src> for Src

type Err = NoError

fn value_from(src: Src) -> Result<Self, Self::Err>

Loading content...