Trait Source 

pub trait Source {
    // Required methods
    fn expand_bool<E>(&mut self, v: &str) -> Result<Option<bool>, E>
       where E: Error;
    fn expand_i8<E>(&mut self, v: &str) -> Result<Option<i8>, E>
       where E: Error;
    fn expand_i16<E>(&mut self, v: &str) -> Result<Option<i16>, E>
       where E: Error;
    fn expand_i32<E>(&mut self, v: &str) -> Result<Option<i32>, E>
       where E: Error;
    fn expand_i64<E>(&mut self, v: &str) -> Result<Option<i64>, E>
       where E: Error;
    fn expand_u8<E>(&mut self, v: &str) -> Result<Option<u8>, E>
       where E: Error;
    fn expand_u16<E>(&mut self, v: &str) -> Result<Option<u16>, E>
       where E: Error;
    fn expand_u32<E>(&mut self, v: &str) -> Result<Option<u32>, E>
       where E: Error;
    fn expand_u64<E>(&mut self, v: &str) -> Result<Option<u64>, E>
       where E: Error;
    fn expand_f32<E>(&mut self, v: &str) -> Result<Option<f32>, E>
       where E: Error;
    fn expand_f64<E>(&mut self, v: &str) -> Result<Option<f64>, E>
       where E: Error;
    fn expand_str<'a, E>(
        &mut self,
        v: Cow<'a, str>,
    ) -> Result<Expansion<Cow<'a, str>>, E>
       where E: Error;
    fn expand_bytes<'a, E>(
        &mut self,
        v: Cow<'a, [u8]>,
    ) -> Result<Expansion<Cow<'a, [u8]>>, E>
       where E: Error;
    fn expand_any<'a, E>(
        &mut self,
        v: Cow<'a, str>,
    ) -> Result<Expansion<Any<'a>, Cow<'a, str>>, E>
       where E: Error;
}

A Source expands a variable string into a concrete value.

A source may choose to not expand a value and indicate that by either returning None or Expansion::Original.

Required Methods

fn expand_bool<E>(&mut self, v: &str) -> Result<Option<bool>, E>

where E: Error,

Expands a variable string to a boolean.

fn expand_i8<E>(&mut self, v: &str) -> Result<Option<i8>, E>

where E: Error,

Expands a variable string to an i8.

fn expand_i16<E>(&mut self, v: &str) -> Result<Option<i16>, E>

where E: Error,

Expands a variable string to an i16.

fn expand_i32<E>(&mut self, v: &str) -> Result<Option<i32>, E>

where E: Error,

Expands a variable string to an i32.

fn expand_i64<E>(&mut self, v: &str) -> Result<Option<i64>, E>

where E: Error,

Expands a variable string to an i64.

fn expand_u8<E>(&mut self, v: &str) -> Result<Option<u8>, E>

where E: Error,

Expands a variable string to an u8.

fn expand_u16<E>(&mut self, v: &str) -> Result<Option<u16>, E>

where E: Error,

Expands a variable string to an u16.

fn expand_u32<E>(&mut self, v: &str) -> Result<Option<u32>, E>

where E: Error,

Expands a variable string to an u32.

fn expand_u64<E>(&mut self, v: &str) -> Result<Option<u64>, E>

where E: Error,

Expands a variable string to an u64.

fn expand_f32<E>(&mut self, v: &str) -> Result<Option<f32>, E>

where E: Error,

Expands a variable string to a f32.

fn expand_f64<E>(&mut self, v: &str) -> Result<Option<f64>, E>

where E: Error,

Expands a variable string to a f64.

fn expand_str<'a, E>( &mut self, v: Cow<'a, str>, ) -> Result<Expansion<Cow<'a, str>>, E>

where E: Error,

Expands a variable string to string.

fn expand_bytes<'a, E>( &mut self, v: Cow<'a, [u8]>, ) -> Result<Expansion<Cow<'a, [u8]>>, E>

where E: Error,

Expands bytes into other bytes.

Implementations which can expand strings, should also expand byte sequences which are valid utf-8.

fn expand_any<'a, E>( &mut self, v: Cow<'a, str>, ) -> Result<Expansion<Any<'a>, Cow<'a, str>>, E>

where E: Error,

Expands a variable string to Any.

Required for self-describing deserialization, where the resulting type depends on the type deserialized.

For strings this needs the same behaviour as Source::expand_str.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

impl<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Source for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)

where T1: Source, T2: Source, T3: Source, T4: Source, T5: Source, T6: Source, T7: Source, T8: Source, T9: Source, T10: Source, T11: Source, T12: Source, T13: Source, T14: Source, T15: Source,

fn expand_bool<E>(&mut self, v: &str) -> Result<Option<bool>, E>

where E: Error,

fn expand_i8<E>(&mut self, v: &str) -> Result<Option<i8>, E>

where E: Error,

fn expand_i16<E>(&mut self, v: &str) -> Result<Option<i16>, E>

where E: Error,

fn expand_i32<E>(&mut self, v: &str) -> Result<Option<i32>, E>

where E: Error,

fn expand_i64<E>(&mut self, v: &str) -> Result<Option<i64>, E>

where E: Error,

fn expand_u8<E>(&mut self, v: &str) -> Result<Option<u8>, E>

where E: Error,

fn expand_u16<E>(&mut self, v: &str) -> Result<Option<u16>, E>

where E: Error,

fn expand_u32<E>(&mut self, v: &str) -> Result<Option<u32>, E>

where E: Error,

fn expand_u64<E>(&mut self, v: &str) -> Result<Option<u64>, E>

where E: Error,

fn expand_f32<E>(&mut self, v: &str) -> Result<Option<f32>, E>

where E: Error,

fn expand_f64<E>(&mut self, v: &str) -> Result<Option<f64>, E>

where E: Error,

fn expand_str<'a, E>( &mut self, v: Cow<'a, str>, ) -> Result<Expansion<Cow<'a, str>>, E>

where E: Error,

fn expand_bytes<'a, E>( &mut self, v: Cow<'a, [u8]>, ) -> Result<Expansion<Cow<'a, [u8]>>, E>

where E: Error,

fn expand_any<'a, E>( &mut self, v: Cow<'a, str>, ) -> Result<Expansion<Any<'a>, Cow<'a, str>>, E>

where E: Error,

impl<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> Source for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)

where T1: Source, T2: Source, T3: Source, T4: Source, T5: Source, T6: Source, T7: Source, T8: Source, T9: Source, T10: Source, T11: Source, T12: Source, T13: Source, T14: Source,

fn expand_bool<E>(&mut self, v: &str) -> Result<Option<bool>, E>

where E: Error,

fn expand_i8<E>(&mut self, v: &str) -> Result<Option<i8>, E>

where E: Error,

fn expand_i16<E>(&mut self, v: &str) -> Result<Option<i16>, E>

where E: Error,

fn expand_i32<E>(&mut self, v: &str) -> Result<Option<i32>, E>

where E: Error,

fn expand_i64<E>(&mut self, v: &str) -> Result<Option<i64>, E>

where E: Error,

fn expand_u8<E>(&mut self, v: &str) -> Result<Option<u8>, E>

where E: Error,

fn expand_u16<E>(&mut self, v: &str) -> Result<Option<u16>, E>

where E: Error,

fn expand_u32<E>(&mut self, v: &str) -> Result<Option<u32>, E>

where E: Error,

fn expand_u64<E>(&mut self, v: &str) -> Result<Option<u64>, E>

where E: Error,

fn expand_f32<E>(&mut self, v: &str) -> Result<Option<f32>, E>

where E: Error,

fn expand_f64<E>(&mut self, v: &str) -> Result<Option<f64>, E>

where E: Error,

fn expand_str<'a, E>( &mut self, v: Cow<'a, str>, ) -> Result<Expansion<Cow<'a, str>>, E>

where E: Error,

fn expand_bytes<'a, E>( &mut self, v: Cow<'a, [u8]>, ) -> Result<Expansion<Cow<'a, [u8]>>, E>

where E: Error,

fn expand_any<'a, E>( &mut self, v: Cow<'a, str>, ) -> Result<Expansion<Any<'a>, Cow<'a, str>>, E>

where E: Error,

impl<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Source for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)

where T1: Source, T2: Source, T3: Source, T4: Source, T5: Source, T6: Source, T7: Source, T8: Source, T9: Source, T10: Source, T11: Source, T12: Source, T13: Source,

fn expand_bool<E>(&mut self, v: &str) -> Result<Option<bool>, E>

where E: Error,

fn expand_i8<E>(&mut self, v: &str) -> Result<Option<i8>, E>

where E: Error,

fn expand_i16<E>(&mut self, v: &str) -> Result<Option<i16>, E>

where E: Error,

fn expand_i32<E>(&mut self, v: &str) -> Result<Option<i32>, E>

where E: Error,

fn expand_i64<E>(&mut self, v: &str) -> Result<Option<i64>, E>

where E: Error,

fn expand_u8<E>(&mut self, v: &str) -> Result<Option<u8>, E>

where E: Error,

fn expand_u16<E>(&mut self, v: &str) -> Result<Option<u16>, E>

where E: Error,

fn expand_u32<E>(&mut self, v: &str) -> Result<Option<u32>, E>

where E: Error,

fn expand_u64<E>(&mut self, v: &str) -> Result<Option<u64>, E>

where E: Error,

fn expand_f32<E>(&mut self, v: &str) -> Result<Option<f32>, E>

where E: Error,

fn expand_f64<E>(&mut self, v: &str) -> Result<Option<f64>, E>

where E: Error,

fn expand_str<'a, E>( &mut self, v: Cow<'a, str>, ) -> Result<Expansion<Cow<'a, str>>, E>

where E: Error,

fn expand_bytes<'a, E>( &mut self, v: Cow<'a, [u8]>, ) -> Result<Expansion<Cow<'a, [u8]>>, E>

where E: Error,

fn expand_any<'a, E>( &mut self, v: Cow<'a, str>, ) -> Result<Expansion<Any<'a>, Cow<'a, str>>, E>

where E: Error,

impl<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Source for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)

where T1: Source, T2: Source, T3: Source, T4: Source, T5: Source, T6: Source, T7: Source, T8: Source, T9: Source, T10: Source, T11: Source, T12: Source,

fn expand_bool<E>(&mut self, v: &str) -> Result<Option<bool>, E>

where E: Error,

fn expand_i8<E>(&mut self, v: &str) -> Result<Option<i8>, E>

where E: Error,

fn expand_i16<E>(&mut self, v: &str) -> Result<Option<i16>, E>

where E: Error,

fn expand_i32<E>(&mut self, v: &str) -> Result<Option<i32>, E>

where E: Error,

fn expand_i64<E>(&mut self, v: &str) -> Result<Option<i64>, E>

where E: Error,

fn expand_u8<E>(&mut self, v: &str) -> Result<Option<u8>, E>

where E: Error,

fn expand_u16<E>(&mut self, v: &str) -> Result<Option<u16>, E>

where E: Error,

fn expand_u32<E>(&mut self, v: &str) -> Result<Option<u32>, E>

where E: Error,

fn expand_u64<E>(&mut self, v: &str) -> Result<Option<u64>, E>

where E: Error,

fn expand_f32<E>(&mut self, v: &str) -> Result<Option<f32>, E>

where E: Error,

fn expand_f64<E>(&mut self, v: &str) -> Result<Option<f64>, E>

where E: Error,

fn expand_str<'a, E>( &mut self, v: Cow<'a, str>, ) -> Result<Expansion<Cow<'a, str>>, E>

where E: Error,

fn expand_bytes<'a, E>( &mut self, v: Cow<'a, [u8]>, ) -> Result<Expansion<Cow<'a, [u8]>>, E>

where E: Error,

fn expand_any<'a, E>( &mut self, v: Cow<'a, str>, ) -> Result<Expansion<Any<'a>, Cow<'a, str>>, E>

where E: Error,

impl<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Source for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)

where T1: Source, T2: Source, T3: Source, T4: Source, T5: Source, T6: Source, T7: Source, T8: Source, T9: Source, T10: Source, T11: Source,

fn expand_bool<E>(&mut self, v: &str) -> Result<Option<bool>, E>

where E: Error,

fn expand_i8<E>(&mut self, v: &str) -> Result<Option<i8>, E>

where E: Error,

fn expand_i16<E>(&mut self, v: &str) -> Result<Option<i16>, E>

where E: Error,

fn expand_i32<E>(&mut self, v: &str) -> Result<Option<i32>, E>

where E: Error,

fn expand_i64<E>(&mut self, v: &str) -> Result<Option<i64>, E>

where E: Error,

fn expand_u8<E>(&mut self, v: &str) -> Result<Option<u8>, E>

where E: Error,

fn expand_u16<E>(&mut self, v: &str) -> Result<Option<u16>, E>

where E: Error,

fn expand_u32<E>(&mut self, v: &str) -> Result<Option<u32>, E>

where E: Error,

fn expand_u64<E>(&mut self, v: &str) -> Result<Option<u64>, E>

where E: Error,

fn expand_f32<E>(&mut self, v: &str) -> Result<Option<f32>, E>

where E: Error,

fn expand_f64<E>(&mut self, v: &str) -> Result<Option<f64>, E>

where E: Error,

fn expand_str<'a, E>( &mut self, v: Cow<'a, str>, ) -> Result<Expansion<Cow<'a, str>>, E>

where E: Error,

fn expand_bytes<'a, E>( &mut self, v: Cow<'a, [u8]>, ) -> Result<Expansion<Cow<'a, [u8]>>, E>

where E: Error,

fn expand_any<'a, E>( &mut self, v: Cow<'a, str>, ) -> Result<Expansion<Any<'a>, Cow<'a, str>>, E>

where E: Error,

impl<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Source for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)

where T1: Source, T2: Source, T3: Source, T4: Source, T5: Source, T6: Source, T7: Source, T8: Source, T9: Source, T10: Source,

fn expand_bool<E>(&mut self, v: &str) -> Result<Option<bool>, E>

where E: Error,

fn expand_i8<E>(&mut self, v: &str) -> Result<Option<i8>, E>

where E: Error,

fn expand_i16<E>(&mut self, v: &str) -> Result<Option<i16>, E>

where E: Error,

fn expand_i32<E>(&mut self, v: &str) -> Result<Option<i32>, E>

where E: Error,

fn expand_i64<E>(&mut self, v: &str) -> Result<Option<i64>, E>

where E: Error,

fn expand_u8<E>(&mut self, v: &str) -> Result<Option<u8>, E>

where E: Error,

fn expand_u16<E>(&mut self, v: &str) -> Result<Option<u16>, E>

where E: Error,

fn expand_u32<E>(&mut self, v: &str) -> Result<Option<u32>, E>

where E: Error,

fn expand_u64<E>(&mut self, v: &str) -> Result<Option<u64>, E>

where E: Error,

fn expand_f32<E>(&mut self, v: &str) -> Result<Option<f32>, E>

where E: Error,

fn expand_f64<E>(&mut self, v: &str) -> Result<Option<f64>, E>

where E: Error,

fn expand_str<'a, E>( &mut self, v: Cow<'a, str>, ) -> Result<Expansion<Cow<'a, str>>, E>

where E: Error,

fn expand_bytes<'a, E>( &mut self, v: Cow<'a, [u8]>, ) -> Result<Expansion<Cow<'a, [u8]>>, E>

where E: Error,

fn expand_any<'a, E>( &mut self, v: Cow<'a, str>, ) -> Result<Expansion<Any<'a>, Cow<'a, str>>, E>

where E: Error,

impl<T1, T2, T3, T4, T5, T6, T7, T8, T9> Source for (T1, T2, T3, T4, T5, T6, T7, T8, T9)

where T1: Source, T2: Source, T3: Source, T4: Source, T5: Source, T6: Source, T7: Source, T8: Source, T9: Source,

fn expand_bool<E>(&mut self, v: &str) -> Result<Option<bool>, E>

where E: Error,

fn expand_i8<E>(&mut self, v: &str) -> Result<Option<i8>, E>

where E: Error,

fn expand_i16<E>(&mut self, v: &str) -> Result<Option<i16>, E>

where E: Error,

fn expand_i32<E>(&mut self, v: &str) -> Result<Option<i32>, E>

where E: Error,

fn expand_i64<E>(&mut self, v: &str) -> Result<Option<i64>, E>

where E: Error,

fn expand_u8<E>(&mut self, v: &str) -> Result<Option<u8>, E>

where E: Error,

fn expand_u16<E>(&mut self, v: &str) -> Result<Option<u16>, E>

where E: Error,

fn expand_u32<E>(&mut self, v: &str) -> Result<Option<u32>, E>

where E: Error,

fn expand_u64<E>(&mut self, v: &str) -> Result<Option<u64>, E>

where E: Error,

fn expand_f32<E>(&mut self, v: &str) -> Result<Option<f32>, E>

where E: Error,

fn expand_f64<E>(&mut self, v: &str) -> Result<Option<f64>, E>

where E: Error,

fn expand_str<'a, E>( &mut self, v: Cow<'a, str>, ) -> Result<Expansion<Cow<'a, str>>, E>

where E: Error,

fn expand_bytes<'a, E>( &mut self, v: Cow<'a, [u8]>, ) -> Result<Expansion<Cow<'a, [u8]>>, E>

where E: Error,

fn expand_any<'a, E>( &mut self, v: Cow<'a, str>, ) -> Result<Expansion<Any<'a>, Cow<'a, str>>, E>

where E: Error,

impl<T1, T2, T3, T4, T5, T6, T7, T8> Source for (T1, T2, T3, T4, T5, T6, T7, T8)

where T1: Source, T2: Source, T3: Source, T4: Source, T5: Source, T6: Source, T7: Source, T8: Source,

fn expand_bool<E>(&mut self, v: &str) -> Result<Option<bool>, E>

where E: Error,

fn expand_i8<E>(&mut self, v: &str) -> Result<Option<i8>, E>

where E: Error,

fn expand_i16<E>(&mut self, v: &str) -> Result<Option<i16>, E>

where E: Error,

fn expand_i32<E>(&mut self, v: &str) -> Result<Option<i32>, E>

where E: Error,

fn expand_i64<E>(&mut self, v: &str) -> Result<Option<i64>, E>

where E: Error,

fn expand_u8<E>(&mut self, v: &str) -> Result<Option<u8>, E>

where E: Error,

fn expand_u16<E>(&mut self, v: &str) -> Result<Option<u16>, E>

where E: Error,

fn expand_u32<E>(&mut self, v: &str) -> Result<Option<u32>, E>

where E: Error,

fn expand_u64<E>(&mut self, v: &str) -> Result<Option<u64>, E>

where E: Error,

fn expand_f32<E>(&mut self, v: &str) -> Result<Option<f32>, E>

where E: Error,

fn expand_f64<E>(&mut self, v: &str) -> Result<Option<f64>, E>

where E: Error,

fn expand_str<'a, E>( &mut self, v: Cow<'a, str>, ) -> Result<Expansion<Cow<'a, str>>, E>

where E: Error,

fn expand_bytes<'a, E>( &mut self, v: Cow<'a, [u8]>, ) -> Result<Expansion<Cow<'a, [u8]>>, E>

where E: Error,

fn expand_any<'a, E>( &mut self, v: Cow<'a, str>, ) -> Result<Expansion<Any<'a>, Cow<'a, str>>, E>

where E: Error,

impl<T1, T2, T3, T4, T5, T6, T7> Source for (T1, T2, T3, T4, T5, T6, T7)

where T1: Source, T2: Source, T3: Source, T4: Source, T5: Source, T6: Source, T7: Source,

fn expand_bool<E>(&mut self, v: &str) -> Result<Option<bool>, E>

where E: Error,

fn expand_i8<E>(&mut self, v: &str) -> Result<Option<i8>, E>

where E: Error,

fn expand_i16<E>(&mut self, v: &str) -> Result<Option<i16>, E>

where E: Error,

fn expand_i32<E>(&mut self, v: &str) -> Result<Option<i32>, E>

where E: Error,

fn expand_i64<E>(&mut self, v: &str) -> Result<Option<i64>, E>

where E: Error,

fn expand_u8<E>(&mut self, v: &str) -> Result<Option<u8>, E>

where E: Error,

fn expand_u16<E>(&mut self, v: &str) -> Result<Option<u16>, E>

where E: Error,

fn expand_u32<E>(&mut self, v: &str) -> Result<Option<u32>, E>

where E: Error,

fn expand_u64<E>(&mut self, v: &str) -> Result<Option<u64>, E>

where E: Error,

fn expand_f32<E>(&mut self, v: &str) -> Result<Option<f32>, E>

where E: Error,

fn expand_f64<E>(&mut self, v: &str) -> Result<Option<f64>, E>

where E: Error,

fn expand_str<'a, E>( &mut self, v: Cow<'a, str>, ) -> Result<Expansion<Cow<'a, str>>, E>

where E: Error,

fn expand_bytes<'a, E>( &mut self, v: Cow<'a, [u8]>, ) -> Result<Expansion<Cow<'a, [u8]>>, E>

where E: Error,

fn expand_any<'a, E>( &mut self, v: Cow<'a, str>, ) -> Result<Expansion<Any<'a>, Cow<'a, str>>, E>

where E: Error,

impl<T1, T2, T3, T4, T5, T6> Source for (T1, T2, T3, T4, T5, T6)

where T1: Source, T2: Source, T3: Source, T4: Source, T5: Source, T6: Source,

fn expand_bool<E>(&mut self, v: &str) -> Result<Option<bool>, E>

where E: Error,

fn expand_i8<E>(&mut self, v: &str) -> Result<Option<i8>, E>

where E: Error,

fn expand_i16<E>(&mut self, v: &str) -> Result<Option<i16>, E>

where E: Error,

fn expand_i32<E>(&mut self, v: &str) -> Result<Option<i32>, E>

where E: Error,

fn expand_i64<E>(&mut self, v: &str) -> Result<Option<i64>, E>

where E: Error,

fn expand_u8<E>(&mut self, v: &str) -> Result<Option<u8>, E>

where E: Error,

fn expand_u16<E>(&mut self, v: &str) -> Result<Option<u16>, E>

where E: Error,

fn expand_u32<E>(&mut self, v: &str) -> Result<Option<u32>, E>

where E: Error,

fn expand_u64<E>(&mut self, v: &str) -> Result<Option<u64>, E>

where E: Error,

fn expand_f32<E>(&mut self, v: &str) -> Result<Option<f32>, E>

where E: Error,

fn expand_f64<E>(&mut self, v: &str) -> Result<Option<f64>, E>

where E: Error,

fn expand_str<'a, E>( &mut self, v: Cow<'a, str>, ) -> Result<Expansion<Cow<'a, str>>, E>

where E: Error,

fn expand_bytes<'a, E>( &mut self, v: Cow<'a, [u8]>, ) -> Result<Expansion<Cow<'a, [u8]>>, E>

where E: Error,

fn expand_any<'a, E>( &mut self, v: Cow<'a, str>, ) -> Result<Expansion<Any<'a>, Cow<'a, str>>, E>

where E: Error,

impl<T1, T2, T3, T4, T5> Source for (T1, T2, T3, T4, T5)

where T1: Source, T2: Source, T3: Source, T4: Source, T5: Source,

fn expand_bool<E>(&mut self, v: &str) -> Result<Option<bool>, E>

where E: Error,

fn expand_i8<E>(&mut self, v: &str) -> Result<Option<i8>, E>

where E: Error,

fn expand_i16<E>(&mut self, v: &str) -> Result<Option<i16>, E>

where E: Error,

fn expand_i32<E>(&mut self, v: &str) -> Result<Option<i32>, E>

where E: Error,

fn expand_i64<E>(&mut self, v: &str) -> Result<Option<i64>, E>

where E: Error,

fn expand_u8<E>(&mut self, v: &str) -> Result<Option<u8>, E>

where E: Error,

fn expand_u16<E>(&mut self, v: &str) -> Result<Option<u16>, E>

where E: Error,

fn expand_u32<E>(&mut self, v: &str) -> Result<Option<u32>, E>

where E: Error,

fn expand_u64<E>(&mut self, v: &str) -> Result<Option<u64>, E>

where E: Error,

fn expand_f32<E>(&mut self, v: &str) -> Result<Option<f32>, E>

where E: Error,

fn expand_f64<E>(&mut self, v: &str) -> Result<Option<f64>, E>

where E: Error,

fn expand_str<'a, E>( &mut self, v: Cow<'a, str>, ) -> Result<Expansion<Cow<'a, str>>, E>

where E: Error,

fn expand_bytes<'a, E>( &mut self, v: Cow<'a, [u8]>, ) -> Result<Expansion<Cow<'a, [u8]>>, E>

where E: Error,

fn expand_any<'a, E>( &mut self, v: Cow<'a, str>, ) -> Result<Expansion<Any<'a>, Cow<'a, str>>, E>

where E: Error,

impl<T1, T2, T3, T4> Source for (T1, T2, T3, T4)

where T1: Source, T2: Source, T3: Source, T4: Source,

fn expand_bool<E>(&mut self, v: &str) -> Result<Option<bool>, E>

where E: Error,

fn expand_i8<E>(&mut self, v: &str) -> Result<Option<i8>, E>

where E: Error,

fn expand_i16<E>(&mut self, v: &str) -> Result<Option<i16>, E>

where E: Error,

fn expand_i32<E>(&mut self, v: &str) -> Result<Option<i32>, E>

where E: Error,

fn expand_i64<E>(&mut self, v: &str) -> Result<Option<i64>, E>

where E: Error,

fn expand_u8<E>(&mut self, v: &str) -> Result<Option<u8>, E>

where E: Error,

fn expand_u16<E>(&mut self, v: &str) -> Result<Option<u16>, E>

where E: Error,

fn expand_u32<E>(&mut self, v: &str) -> Result<Option<u32>, E>

where E: Error,

fn expand_u64<E>(&mut self, v: &str) -> Result<Option<u64>, E>

where E: Error,

fn expand_f32<E>(&mut self, v: &str) -> Result<Option<f32>, E>

where E: Error,

fn expand_f64<E>(&mut self, v: &str) -> Result<Option<f64>, E>

where E: Error,

fn expand_str<'a, E>( &mut self, v: Cow<'a, str>, ) -> Result<Expansion<Cow<'a, str>>, E>

where E: Error,

fn expand_bytes<'a, E>( &mut self, v: Cow<'a, [u8]>, ) -> Result<Expansion<Cow<'a, [u8]>>, E>

where E: Error,

fn expand_any<'a, E>( &mut self, v: Cow<'a, str>, ) -> Result<Expansion<Any<'a>, Cow<'a, str>>, E>

where E: Error,

impl<T1, T2, T3> Source for (T1, T2, T3)

where T1: Source, T2: Source, T3: Source,

fn expand_bool<E>(&mut self, v: &str) -> Result<Option<bool>, E>

where E: Error,

fn expand_i8<E>(&mut self, v: &str) -> Result<Option<i8>, E>

where E: Error,

fn expand_i16<E>(&mut self, v: &str) -> Result<Option<i16>, E>

where E: Error,

fn expand_i32<E>(&mut self, v: &str) -> Result<Option<i32>, E>

where E: Error,

fn expand_i64<E>(&mut self, v: &str) -> Result<Option<i64>, E>

where E: Error,

fn expand_u8<E>(&mut self, v: &str) -> Result<Option<u8>, E>

where E: Error,

fn expand_u16<E>(&mut self, v: &str) -> Result<Option<u16>, E>

where E: Error,

fn expand_u32<E>(&mut self, v: &str) -> Result<Option<u32>, E>

where E: Error,

fn expand_u64<E>(&mut self, v: &str) -> Result<Option<u64>, E>

where E: Error,

fn expand_f32<E>(&mut self, v: &str) -> Result<Option<f32>, E>

where E: Error,

fn expand_f64<E>(&mut self, v: &str) -> Result<Option<f64>, E>

where E: Error,

fn expand_str<'a, E>( &mut self, v: Cow<'a, str>, ) -> Result<Expansion<Cow<'a, str>>, E>

where E: Error,

fn expand_bytes<'a, E>( &mut self, v: Cow<'a, [u8]>, ) -> Result<Expansion<Cow<'a, [u8]>>, E>

where E: Error,

fn expand_any<'a, E>( &mut self, v: Cow<'a, str>, ) -> Result<Expansion<Any<'a>, Cow<'a, str>>, E>

where E: Error,

impl<T1, T2> Source for (T1, T2)

where T1: Source, T2: Source,

fn expand_bool<E>(&mut self, v: &str) -> Result<Option<bool>, E>

where E: Error,

fn expand_i8<E>(&mut self, v: &str) -> Result<Option<i8>, E>

where E: Error,

fn expand_i16<E>(&mut self, v: &str) -> Result<Option<i16>, E>

where E: Error,

fn expand_i32<E>(&mut self, v: &str) -> Result<Option<i32>, E>

where E: Error,

fn expand_i64<E>(&mut self, v: &str) -> Result<Option<i64>, E>

where E: Error,

fn expand_u8<E>(&mut self, v: &str) -> Result<Option<u8>, E>

where E: Error,

fn expand_u16<E>(&mut self, v: &str) -> Result<Option<u16>, E>

where E: Error,

fn expand_u32<E>(&mut self, v: &str) -> Result<Option<u32>, E>

where E: Error,

fn expand_u64<E>(&mut self, v: &str) -> Result<Option<u64>, E>

where E: Error,

fn expand_f32<E>(&mut self, v: &str) -> Result<Option<f32>, E>

where E: Error,

fn expand_f64<E>(&mut self, v: &str) -> Result<Option<f64>, E>

where E: Error,

fn expand_str<'a, E>( &mut self, v: Cow<'a, str>, ) -> Result<Expansion<Cow<'a, str>>, E>

where E: Error,

fn expand_bytes<'a, E>( &mut self, v: Cow<'a, [u8]>, ) -> Result<Expansion<Cow<'a, [u8]>>, E>

where E: Error,

fn expand_any<'a, E>( &mut self, v: Cow<'a, str>, ) -> Result<Expansion<Any<'a>, Cow<'a, str>>, E>

where E: Error,

impl<T1> Source for (T1,)

where T1: Source,

fn expand_bool<E>(&mut self, v: &str) -> Result<Option<bool>, E>

where E: Error,

fn expand_i8<E>(&mut self, v: &str) -> Result<Option<i8>, E>

where E: Error,

fn expand_i16<E>(&mut self, v: &str) -> Result<Option<i16>, E>

where E: Error,

fn expand_i32<E>(&mut self, v: &str) -> Result<Option<i32>, E>

where E: Error,

fn expand_i64<E>(&mut self, v: &str) -> Result<Option<i64>, E>

where E: Error,

fn expand_u8<E>(&mut self, v: &str) -> Result<Option<u8>, E>

where E: Error,

fn expand_u16<E>(&mut self, v: &str) -> Result<Option<u16>, E>

where E: Error,

fn expand_u32<E>(&mut self, v: &str) -> Result<Option<u32>, E>

where E: Error,

fn expand_u64<E>(&mut self, v: &str) -> Result<Option<u64>, E>

where E: Error,

fn expand_f32<E>(&mut self, v: &str) -> Result<Option<f32>, E>

where E: Error,

fn expand_f64<E>(&mut self, v: &str) -> Result<Option<f64>, E>

where E: Error,

fn expand_str<'a, E>( &mut self, v: Cow<'a, str>, ) -> Result<Expansion<Cow<'a, str>>, E>

where E: Error,

fn expand_bytes<'a, E>( &mut self, v: Cow<'a, [u8]>, ) -> Result<Expansion<Cow<'a, [u8]>>, E>

where E: Error,

fn expand_any<'a, E>( &mut self, v: Cow<'a, str>, ) -> Result<Expansion<Any<'a>, Cow<'a, str>>, E>

where E: Error,

Implementors

impl<F: FileSystem> Source for FileSource<F>

impl<T> Source for StringSource<T>

where T: StringLookup,