Trait tlbits::de::args::as::BitUnpackAsWithArgs

pub trait BitUnpackAsWithArgs<T> {
    type Args;

    // Required method
    fn unpack_as_with<R>(reader: R, args: Self::Args) -> Result<T, R::Error>
       where R: BitReader;
}

Adapter to deserialize T with args.
See as module-level documentation for more.

For version without arguments, see BitUnpackAs.

Required Associated Types

type Args

Required Methods

fn unpack_as_with<R>(reader: R, args: Self::Args) -> Result<T, R::Error>

where R: BitReader,

Unpacks value with args using an adapter

Object Safety

This trait is not object safe.

Implementations on Foreign Types

impl<Left, Right, AsLeft, AsRight> BitUnpackAsWithArgs<Either<Left, Right>> for Either<AsLeft, AsRight>

where AsLeft: BitUnpackAsWithArgs<Left>, AsRight: BitUnpackAsWithArgs<Right, Args = AsLeft::Args>,

Implementation of Either X Y:

left$0 {X:Type} {Y:Type} value:X = Either X Y;
right$1 {X:Type} {Y:Type} value:Y = Either X Y;

type Args = <AsLeft as BitUnpackAsWithArgs<Left>>::Args

fn unpack_as_with<R>( reader: R, args: Self::Args, ) -> Result<Either<Left, Right>, R::Error>

where R: BitReader,

impl<T0, As0> BitUnpackAsWithArgs<(T0,)> for (As0,)

where As0: BitUnpackAsWithArgs<T0>,

type Args = (<As0 as BitUnpackAsWithArgs<T0>>::Args,)

fn unpack_as_with<R>(reader: R, args: Self::Args) -> Result<(T0,), R::Error>

where R: BitReader,

impl<T0, As0, T1, As1> BitUnpackAsWithArgs<(T0, T1)> for (As0, As1)

where As0: BitUnpackAsWithArgs<T0>, As1: BitUnpackAsWithArgs<T1>,

type Args = (<As0 as BitUnpackAsWithArgs<T0>>::Args, <As1 as BitUnpackAsWithArgs<T1>>::Args)

fn unpack_as_with<R>(reader: R, args: Self::Args) -> Result<(T0, T1), R::Error>

where R: BitReader,

impl<T0, As0, T1, As1, T2, As2> BitUnpackAsWithArgs<(T0, T1, T2)> for (As0, As1, As2)

where As0: BitUnpackAsWithArgs<T0>, As1: BitUnpackAsWithArgs<T1>, As2: BitUnpackAsWithArgs<T2>,

type Args = (<As0 as BitUnpackAsWithArgs<T0>>::Args, <As1 as BitUnpackAsWithArgs<T1>>::Args, <As2 as BitUnpackAsWithArgs<T2>>::Args)

fn unpack_as_with<R>( reader: R, args: Self::Args, ) -> Result<(T0, T1, T2), R::Error>

where R: BitReader,

impl<T0, As0, T1, As1, T2, As2, T3, As3> BitUnpackAsWithArgs<(T0, T1, T2, T3)> for (As0, As1, As2, As3)

where As0: BitUnpackAsWithArgs<T0>, As1: BitUnpackAsWithArgs<T1>, As2: BitUnpackAsWithArgs<T2>, As3: BitUnpackAsWithArgs<T3>,

type Args = (<As0 as BitUnpackAsWithArgs<T0>>::Args, <As1 as BitUnpackAsWithArgs<T1>>::Args, <As2 as BitUnpackAsWithArgs<T2>>::Args, <As3 as BitUnpackAsWithArgs<T3>>::Args)

fn unpack_as_with<R>( reader: R, args: Self::Args, ) -> Result<(T0, T1, T2, T3), R::Error>

where R: BitReader,

impl<T0, As0, T1, As1, T2, As2, T3, As3, T4, As4> BitUnpackAsWithArgs<(T0, T1, T2, T3, T4)> for (As0, As1, As2, As3, As4)

where As0: BitUnpackAsWithArgs<T0>, As1: BitUnpackAsWithArgs<T1>, As2: BitUnpackAsWithArgs<T2>, As3: BitUnpackAsWithArgs<T3>, As4: BitUnpackAsWithArgs<T4>,

type Args = (<As0 as BitUnpackAsWithArgs<T0>>::Args, <As1 as BitUnpackAsWithArgs<T1>>::Args, <As2 as BitUnpackAsWithArgs<T2>>::Args, <As3 as BitUnpackAsWithArgs<T3>>::Args, <As4 as BitUnpackAsWithArgs<T4>>::Args)

fn unpack_as_with<R>( reader: R, args: Self::Args, ) -> Result<(T0, T1, T2, T3, T4), R::Error>

where R: BitReader,

impl<T0, As0, T1, As1, T2, As2, T3, As3, T4, As4, T5, As5> BitUnpackAsWithArgs<(T0, T1, T2, T3, T4, T5)> for (As0, As1, As2, As3, As4, As5)

where As0: BitUnpackAsWithArgs<T0>, As1: BitUnpackAsWithArgs<T1>, As2: BitUnpackAsWithArgs<T2>, As3: BitUnpackAsWithArgs<T3>, As4: BitUnpackAsWithArgs<T4>, As5: BitUnpackAsWithArgs<T5>,

type Args = (<As0 as BitUnpackAsWithArgs<T0>>::Args, <As1 as BitUnpackAsWithArgs<T1>>::Args, <As2 as BitUnpackAsWithArgs<T2>>::Args, <As3 as BitUnpackAsWithArgs<T3>>::Args, <As4 as BitUnpackAsWithArgs<T4>>::Args, <As5 as BitUnpackAsWithArgs<T5>>::Args)

fn unpack_as_with<R>( reader: R, args: Self::Args, ) -> Result<(T0, T1, T2, T3, T4, T5), R::Error>

where R: BitReader,

impl<T0, As0, T1, As1, T2, As2, T3, As3, T4, As4, T5, As5, T6, As6> BitUnpackAsWithArgs<(T0, T1, T2, T3, T4, T5, T6)> for (As0, As1, As2, As3, As4, As5, As6)

where As0: BitUnpackAsWithArgs<T0>, As1: BitUnpackAsWithArgs<T1>, As2: BitUnpackAsWithArgs<T2>, As3: BitUnpackAsWithArgs<T3>, As4: BitUnpackAsWithArgs<T4>, As5: BitUnpackAsWithArgs<T5>, As6: BitUnpackAsWithArgs<T6>,

type Args = (<As0 as BitUnpackAsWithArgs<T0>>::Args, <As1 as BitUnpackAsWithArgs<T1>>::Args, <As2 as BitUnpackAsWithArgs<T2>>::Args, <As3 as BitUnpackAsWithArgs<T3>>::Args, <As4 as BitUnpackAsWithArgs<T4>>::Args, <As5 as BitUnpackAsWithArgs<T5>>::Args, <As6 as BitUnpackAsWithArgs<T6>>::Args)

fn unpack_as_with<R>( reader: R, args: Self::Args, ) -> Result<(T0, T1, T2, T3, T4, T5, T6), R::Error>

where R: BitReader,

impl<T0, As0, T1, As1, T2, As2, T3, As3, T4, As4, T5, As5, T6, As6, T7, As7> BitUnpackAsWithArgs<(T0, T1, T2, T3, T4, T5, T6, T7)> for (As0, As1, As2, As3, As4, As5, As6, As7)

where As0: BitUnpackAsWithArgs<T0>, As1: BitUnpackAsWithArgs<T1>, As2: BitUnpackAsWithArgs<T2>, As3: BitUnpackAsWithArgs<T3>, As4: BitUnpackAsWithArgs<T4>, As5: BitUnpackAsWithArgs<T5>, As6: BitUnpackAsWithArgs<T6>, As7: BitUnpackAsWithArgs<T7>,

type Args = (<As0 as BitUnpackAsWithArgs<T0>>::Args, <As1 as BitUnpackAsWithArgs<T1>>::Args, <As2 as BitUnpackAsWithArgs<T2>>::Args, <As3 as BitUnpackAsWithArgs<T3>>::Args, <As4 as BitUnpackAsWithArgs<T4>>::Args, <As5 as BitUnpackAsWithArgs<T5>>::Args, <As6 as BitUnpackAsWithArgs<T6>>::Args, <As7 as BitUnpackAsWithArgs<T7>>::Args)

fn unpack_as_with<R>( reader: R, args: Self::Args, ) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7), R::Error>

where R: BitReader,

impl<T0, As0, T1, As1, T2, As2, T3, As3, T4, As4, T5, As5, T6, As6, T7, As7, T8, As8> BitUnpackAsWithArgs<(T0, T1, T2, T3, T4, T5, T6, T7, T8)> for (As0, As1, As2, As3, As4, As5, As6, As7, As8)

where As0: BitUnpackAsWithArgs<T0>, As1: BitUnpackAsWithArgs<T1>, As2: BitUnpackAsWithArgs<T2>, As3: BitUnpackAsWithArgs<T3>, As4: BitUnpackAsWithArgs<T4>, As5: BitUnpackAsWithArgs<T5>, As6: BitUnpackAsWithArgs<T6>, As7: BitUnpackAsWithArgs<T7>, As8: BitUnpackAsWithArgs<T8>,

type Args = (<As0 as BitUnpackAsWithArgs<T0>>::Args, <As1 as BitUnpackAsWithArgs<T1>>::Args, <As2 as BitUnpackAsWithArgs<T2>>::Args, <As3 as BitUnpackAsWithArgs<T3>>::Args, <As4 as BitUnpackAsWithArgs<T4>>::Args, <As5 as BitUnpackAsWithArgs<T5>>::Args, <As6 as BitUnpackAsWithArgs<T6>>::Args, <As7 as BitUnpackAsWithArgs<T7>>::Args, <As8 as BitUnpackAsWithArgs<T8>>::Args)

fn unpack_as_with<R>( reader: R, args: Self::Args, ) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8), R::Error>

where R: BitReader,

impl<T0, As0, T1, As1, T2, As2, T3, As3, T4, As4, T5, As5, T6, As6, T7, As7, T8, As8, T9, As9> BitUnpackAsWithArgs<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)> for (As0, As1, As2, As3, As4, As5, As6, As7, As8, As9)

where As0: BitUnpackAsWithArgs<T0>, As1: BitUnpackAsWithArgs<T1>, As2: BitUnpackAsWithArgs<T2>, As3: BitUnpackAsWithArgs<T3>, As4: BitUnpackAsWithArgs<T4>, As5: BitUnpackAsWithArgs<T5>, As6: BitUnpackAsWithArgs<T6>, As7: BitUnpackAsWithArgs<T7>, As8: BitUnpackAsWithArgs<T8>, As9: BitUnpackAsWithArgs<T9>,

type Args = (<As0 as BitUnpackAsWithArgs<T0>>::Args, <As1 as BitUnpackAsWithArgs<T1>>::Args, <As2 as BitUnpackAsWithArgs<T2>>::Args, <As3 as BitUnpackAsWithArgs<T3>>::Args, <As4 as BitUnpackAsWithArgs<T4>>::Args, <As5 as BitUnpackAsWithArgs<T5>>::Args, <As6 as BitUnpackAsWithArgs<T6>>::Args, <As7 as BitUnpackAsWithArgs<T7>>::Args, <As8 as BitUnpackAsWithArgs<T8>>::Args, <As9 as BitUnpackAsWithArgs<T9>>::Args)

fn unpack_as_with<R>( reader: R, args: Self::Args, ) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9), R::Error>

where R: BitReader,

impl<T, As> BitUnpackAsWithArgs<Option<T>> for Option<As>

where As: BitUnpackAsWithArgs<T>,

Implementation of Maybe X:

nothing$0 {X:Type} = Maybe X;
just$1 {X:Type} value:X = Maybe X;

type Args = <As as BitUnpackAsWithArgs<T>>::Args

fn unpack_as_with<R>(reader: R, args: Self::Args) -> Result<Option<T>, R::Error>

where R: BitReader,

impl<T, As> BitUnpackAsWithArgs<Option<T>> for Either<(), As>

where As: BitUnpackAsWithArgs<T>,

type Args = <As as BitUnpackAsWithArgs<T>>::Args

fn unpack_as_with<R>(reader: R, args: Self::Args) -> Result<Option<T>, R::Error>

where R: BitReader,

impl<T, As> BitUnpackAsWithArgs<Box<T>> for Box<As>

where As: BitUnpackAsWithArgs<T> + ?Sized,

type Args = <As as BitUnpackAsWithArgs<T>>::Args

fn unpack_as_with<R>(reader: R, args: Self::Args) -> Result<Box<T>, R::Error>

where R: BitReader,

impl<T, As> BitUnpackAsWithArgs<Rc<T>> for Rc<As>

where As: BitUnpackAsWithArgs<T> + ?Sized,

type Args = <As as BitUnpackAsWithArgs<T>>::Args

fn unpack_as_with<R>(reader: R, args: Self::Args) -> Result<Rc<T>, R::Error>

where R: BitReader,

impl<T, As> BitUnpackAsWithArgs<Arc<T>> for Arc<As>

where As: BitUnpackAsWithArgs<T> + ?Sized,

type Args = <As as BitUnpackAsWithArgs<T>>::Args

fn unpack_as_with<R>(reader: R, args: Self::Args) -> Result<Arc<T>, R::Error>

where R: BitReader,

impl<T, As> BitUnpackAsWithArgs<Vec<T>> for Vec<As>

where As: BitUnpackAsWithArgs<T>, As::Args: Clone,

type Args = (usize, <As as BitUnpackAsWithArgs<T>>::Args)

fn unpack_as_with<R>( reader: R, (len, args): Self::Args, ) -> Result<Vec<T>, R::Error>

where R: BitReader,

impl<T, As, const N: usize> BitUnpackAsWithArgs<[T; N]> for [As; N]

where As: BitUnpackAsWithArgs<T>, As::Args: Clone,

type Args = <As as BitUnpackAsWithArgs<T>>::Args

fn unpack_as_with<R>(reader: R, args: Self::Args) -> Result<[T; N], R::Error>

where R: BitReader,

Implementors

impl<T> BitUnpackAsWithArgs<T> for Same

where T: BitUnpackWithArgs,

type Args = <T as BitUnpackWithArgs>::Args

impl<T> BitUnpackAsWithArgs<T> for VarNBits

where T: PrimInt,

type Args = u32

impl<T> BitUnpackAsWithArgs<T> for VarNBytes

where T: PrimInt,

type Args = u32

impl<T, As> BitUnpackAsWithArgs<T> for FromInto<As>

where As: Into<T> + BitUnpackWithArgs,

type Args = <As as BitUnpackWithArgs>::Args

impl<T, As> BitUnpackAsWithArgs<T> for FromIntoRef<As>

where As: Into<T> + BitUnpackWithArgs,

type Args = <As as BitUnpackWithArgs>::Args

impl<T, As> BitUnpackAsWithArgs<T> for TryFromInto<As>

where As: TryInto<T> + BitUnpackWithArgs, <As as TryInto<T>>::Error: Display,

type Args = <As as BitUnpackWithArgs>::Args

impl<T, As> BitUnpackAsWithArgs<T> for TryFromIntoRef<As>

where As: TryInto<T> + BitUnpackWithArgs, <As as TryInto<T>>::Error: Display,

type Args = <As as BitUnpackWithArgs>::Args

impl<T, As, Args> BitUnpackAsWithArgs<T> for NoArgs<Args, As>

where As: BitUnpackAs<T> + ?Sized,

type Args = Args