[−]Trait c3p0_mysql::mysql::driver::prelude::FromValue

pub trait FromValue {
    type Intermediate: ConvIr<Self>;
    fn from_value(v: Value) -> Self { ... }
    fn from_value_opt(v: Value) -> Result<Self, FromValueError> { ... }
    fn get_intermediate(v: Value) -> Result<Self::Intermediate, FromValueError> { ... }
}

Implement this trait to convert value to something.

FromRow requires ability to cheaply rollback FromValue conversion. This ability is provided via Intermediate associated type.

Example implementation:

#[derive(Debug)]
pub struct StringIr {
    bytes: Vec<u8>,
}

impl ConvIr<String> for StringIr {
    fn new(v: Value) -> MyResult<StringIr> {
        match v {
            Value::Bytes(bytes) => match from_utf8(&*bytes) {
                Ok(_) => Ok(StringIr { bytes: bytes }),
                Err(_) => Err(Error::FromValueError(Value::Bytes(bytes))),
            },
            v => Err(Error::FromValueError(v)),
        }
    }
    fn commit(self) -> String {
        unsafe { String::from_utf8_unchecked(self.bytes) }
    }
    fn rollback(self) -> Value {
        Value::Bytes(self.bytes)
    }
}

impl FromValue for String {
    type Intermediate = StringIr;
}

Associated Types

`type Intermediate: ConvIr<Self>`

Loading content...

Provided methods

`fn from_value(v: Value) -> Self`

Will panic if could not convert v to Self.

`fn from_value_opt(v: Value) -> Result<Self, FromValueError>`

Will return Err(Error::FromValueError(v)) if could not convert v to Self.

`fn get_intermediate(v: Value) -> Result<Self::Intermediate, FromValueError>`

Will return Err(Error::FromValueError(v)) if v is not convertible to Self.

Loading content...

Implementations on Foreign Types

`impl<T> FromValue for Option<T> where T: FromValue,`

`type Intermediate = OptionIr<<T as FromValue>::Intermediate>`

`fn from_value(v: Value) -> Option<T>`

`impl FromValue for Duration`

`type Intermediate = ParseIr<Duration>`

`fn from_value(v: Value) -> Duration`

`impl FromValue for u8`

`type Intermediate = ParseIr<u8>`

`fn from_value(v: Value) -> u8`

`impl FromValue for i8`

`type Intermediate = ParseIr<i8>`

`fn from_value(v: Value) -> i8`

`impl FromValue for Decimal`

`type Intermediate = ParseIr<Decimal>`

`fn from_value(v: Value) -> Decimal`

`impl FromValue for u32`

`type Intermediate = ParseIr<u32>`

`fn from_value(v: Value) -> u32`

`impl FromValue for i128`

`type Intermediate = ParseIr<i128>`

`fn from_value(v: Value) -> i128`

`impl FromValue for u16`

`type Intermediate = ParseIr<u16>`

`fn from_value(v: Value) -> u16`

`impl FromValue for u128`

`type Intermediate = ParseIr<u128>`

`fn from_value(v: Value) -> u128`

`impl FromValue for u64`

`type Intermediate = ParseIr<u64>`

`fn from_value(v: Value) -> u64`

`impl FromValue for Vec<u8>`

`type Intermediate = BytesIr`

ⓘImportant traits for Vec<u8>
Important traits for Vec<u8>
`impl Write for Vec<u8>`
`fn from_value(v: Value) -> Vec<u8>`

`impl FromValue for f64`

`type Intermediate = ParseIr<f64>`

`fn from_value(v: Value) -> f64`

`impl FromValue for BigInt`

`type Intermediate = ParseIr<BigInt>`

`fn from_value(v: Value) -> BigInt`

`impl FromValue for isize`

`type Intermediate = ParseIr<isize>`

`fn from_value(v: Value) -> isize`

`impl FromValue for f32`

`type Intermediate = ParseIr<f32>`

`fn from_value(v: Value) -> f32`

`impl FromValue for i32`

`type Intermediate = ParseIr<i32>`

`fn from_value(v: Value) -> i32`

`impl FromValue for BigDecimal`

`type Intermediate = ParseIr<BigDecimal>`

`fn from_value(v: Value) -> BigDecimal`

`impl FromValue for BigUint`

`type Intermediate = ParseIr<BigUint>`

`fn from_value(v: Value) -> BigUint`

`impl FromValue for i16`

`type Intermediate = ParseIr<i16>`

`fn from_value(v: Value) -> i16`

`impl FromValue for i64`

`type Intermediate = ParseIr<i64>`

`fn from_value(v: Value) -> i64`

`impl FromValue for String`

`type Intermediate = StringIr`

`fn from_value(v: Value) -> String`

`impl FromValue for bool`

`type Intermediate = ParseIr<bool>`

`fn from_value(v: Value) -> bool`

`impl FromValue for usize`

`type Intermediate = ParseIr<usize>`

`fn from_value(v: Value) -> usize`

Loading content...

Implementors

`impl FromValue for c3p0_mysql::mysql::driver::Value`

`type Intermediate = Value`

`fn from_value(v: Value) -> Value`

`fn from_value_opt(v: Value) -> Result<Value, FromValueError>`

`impl FromValue for c3p0_mysql::mysql::driver::serde_json::value::Value`

`type Intermediate = JsonIr`

`impl FromValue for NaiveDate`

`type Intermediate = ParseIr<NaiveDate>`

`fn from_value(v: Value) -> NaiveDate`

`impl FromValue for NaiveDateTime`

`type Intermediate = ParseIr<NaiveDateTime>`

`fn from_value(v: Value) -> NaiveDateTime`

`impl FromValue for NaiveTime`

`type Intermediate = ParseIr<NaiveTime>`

`fn from_value(v: Value) -> NaiveTime`

`impl FromValue for c3p0_mysql::mysql::driver::chrono::Duration`

`type Intermediate = ParseIr<Duration>`

`fn from_value(v: Value) -> Duration`

`impl FromValue for Timespec`

`type Intermediate = ParseIr<Timespec>`

`fn from_value(v: Value) -> Timespec`

`impl FromValue for Uuid`

`type Intermediate = UuidIr`

`impl<T> FromValue for Deserialized<T> where T: DeserializeOwned,`

`type Intermediate = DeserializedIr<T>`

Loading content...