Trait ssh_packet::BinWrite

source ·
pub trait BinWrite {
    type Args<'a>;

    // Required method
    fn write_options<W>(
        &self,
        writer: &mut W,
        endian: Endian,
        args: Self::Args<'_>
    ) -> Result<(), Error>
       where W: Write + Seek;

    // Provided methods
    fn write<W>(&self, writer: &mut W) -> Result<(), Error>
       where W: Write + Seek,
             Self: WriteEndian,
             Self::Args<'a>: for<'a> Required { ... }
    fn write_be<W>(&self, writer: &mut W) -> Result<(), Error>
       where W: Write + Seek,
             Self::Args<'a>: for<'a> Required { ... }
    fn write_le<W>(&self, writer: &mut W) -> Result<(), Error>
       where W: Write + Seek,
             Self::Args<'a>: for<'a> Required { ... }
    fn write_args<W>(
        &self,
        writer: &mut W,
        args: Self::Args<'_>
    ) -> Result<(), Error>
       where W: Write + Seek,
             Self: WriteEndian { ... }
    fn write_be_args<W>(
        &self,
        writer: &mut W,
        args: Self::Args<'_>
    ) -> Result<(), Error>
       where W: Write + Seek { ... }
    fn write_le_args<W>(
        &self,
        writer: &mut W,
        args: Self::Args<'_>
    ) -> Result<(), Error>
       where W: Write + Seek { ... }
}
Expand description

The BinWrite trait serialises objects and writes them to streams.

This trait is usually derived, but can also be manually implemented by writing an appropriate Args type and write_options() function.

Derivable

This trait can be used with #[derive] or #[binwrite]. Each field of a derived type must either implement BinWrite or be annotated with an attribute containing a map, try_map, or write_with directive.

Using #[binwrite] instead of #[derive] is required when using temporary fields.

Required Associated Types§

source

type Args<'a>

The type used for the args parameter of write_args() and write_options().

When the given type implements Default, convenience functions like write() are enabled. BinWrite implementations that don’t receive any arguments should use the () type.

When BinWrite is derived, the import and import_tuple directives define this type.

Required Methods§

source

fn write_options<W>( &self, writer: &mut W, endian: Endian, args: Self::Args<'_> ) -> Result<(), Error>where W: Write + Seek,

Write Self to the writer using the given Endian and arguments.

Errors

If writing fails, an Error variant will be returned.

Provided Methods§

source

fn write<W>(&self, writer: &mut W) -> Result<(), Error>where W: Write + Seek, Self: WriteEndian, Self::Args<'a>: for<'a> Required,

Write Self to the writer using default arguments.

Errors

If writing fails, an Error variant will be returned.

source

fn write_be<W>(&self, writer: &mut W) -> Result<(), Error>where W: Write + Seek, Self::Args<'a>: for<'a> Required,

Write Self to the writer assuming big-endian byte order.

Errors

If writing fails, an Error variant will be returned.

source

fn write_le<W>(&self, writer: &mut W) -> Result<(), Error>where W: Write + Seek, Self::Args<'a>: for<'a> Required,

Write Self to the writer assuming little-endian byte order.

Errors

If writing fails, an Error variant will be returned.

source

fn write_args<W>( &self, writer: &mut W, args: Self::Args<'_> ) -> Result<(), Error>where W: Write + Seek, Self: WriteEndian,

Write Self to the writer using the given arguments.

Errors

If writing fails, an Error variant will be returned.

source

fn write_be_args<W>( &self, writer: &mut W, args: Self::Args<'_> ) -> Result<(), Error>where W: Write + Seek,

Write Self to the writer, assuming big-endian byte order, using the given arguments.

Errors

If reading fails, an Error variant will be returned.

source

fn write_le_args<W>( &self, writer: &mut W, args: Self::Args<'_> ) -> Result<(), Error>where W: Write + Seek,

Write Self to the writer, assuming little-endian byte order, using the given arguments.

Errors

If reading fails, an Error variant will be returned.

Object Safety§

This trait is not object safe.

Implementations on Foreign Types§

source§

impl BinWrite for f32

§

type Args<'a> = ()

source§

fn write_options<W>( &self, writer: &mut W, endian: Endian, _: <f32 as BinWrite>::Args<'_> ) -> Result<(), Error>where W: Write + Seek,

source§

impl BinWrite for f64

§

type Args<'a> = ()

source§

fn write_options<W>( &self, writer: &mut W, endian: Endian, _: <f64 as BinWrite>::Args<'_> ) -> Result<(), Error>where W: Write + Seek,

source§

impl BinWrite for i8

§

type Args<'a> = ()

source§

fn write_options<W>( &self, writer: &mut W, endian: Endian, _: <i8 as BinWrite>::Args<'_> ) -> Result<(), Error>where W: Write + Seek,

source§

impl BinWrite for i16

§

type Args<'a> = ()

source§

fn write_options<W>( &self, writer: &mut W, endian: Endian, _: <i16 as BinWrite>::Args<'_> ) -> Result<(), Error>where W: Write + Seek,

source§

impl BinWrite for i32

§

type Args<'a> = ()

source§

fn write_options<W>( &self, writer: &mut W, endian: Endian, _: <i32 as BinWrite>::Args<'_> ) -> Result<(), Error>where W: Write + Seek,

source§

impl BinWrite for i64

§

type Args<'a> = ()

source§

fn write_options<W>( &self, writer: &mut W, endian: Endian, _: <i64 as BinWrite>::Args<'_> ) -> Result<(), Error>where W: Write + Seek,

source§

impl BinWrite for i128

§

type Args<'a> = ()

source§

fn write_options<W>( &self, writer: &mut W, endian: Endian, _: <i128 as BinWrite>::Args<'_> ) -> Result<(), Error>where W: Write + Seek,

source§

impl BinWrite for u8

§

type Args<'a> = ()

source§

fn write_options<W>( &self, writer: &mut W, endian: Endian, _: <u8 as BinWrite>::Args<'_> ) -> Result<(), Error>where W: Write + Seek,

source§

impl BinWrite for u16

§

type Args<'a> = ()

source§

fn write_options<W>( &self, writer: &mut W, endian: Endian, _: <u16 as BinWrite>::Args<'_> ) -> Result<(), Error>where W: Write + Seek,

source§

impl BinWrite for u32

§

type Args<'a> = ()

source§

fn write_options<W>( &self, writer: &mut W, endian: Endian, _: <u32 as BinWrite>::Args<'_> ) -> Result<(), Error>where W: Write + Seek,

source§

impl BinWrite for u64

§

type Args<'a> = ()

source§

fn write_options<W>( &self, writer: &mut W, endian: Endian, _: <u64 as BinWrite>::Args<'_> ) -> Result<(), Error>where W: Write + Seek,

source§

impl BinWrite for u128

§

type Args<'a> = ()

source§

fn write_options<W>( &self, writer: &mut W, endian: Endian, _: <u128 as BinWrite>::Args<'_> ) -> Result<(), Error>where W: Write + Seek,

source§

impl BinWrite for ()

§

type Args<'a> = ()

source§

fn write_options<W>( &self, _: &mut W, _: Endian, _: <() as BinWrite>::Args<'_> ) -> Result<(), Error>where W: Write + Seek,

source§

impl BinWrite for NonZeroI8

§

type Args<'a> = ()

source§

fn write_options<W>( &self, writer: &mut W, endian: Endian, _: <NonZeroI8 as BinWrite>::Args<'_> ) -> Result<(), Error>where W: Write + Seek,

source§

impl BinWrite for NonZeroI16

§

type Args<'a> = ()

source§

fn write_options<W>( &self, writer: &mut W, endian: Endian, _: <NonZeroI16 as BinWrite>::Args<'_> ) -> Result<(), Error>where W: Write + Seek,

source§

impl BinWrite for NonZeroI32

§

type Args<'a> = ()

source§

fn write_options<W>( &self, writer: &mut W, endian: Endian, _: <NonZeroI32 as BinWrite>::Args<'_> ) -> Result<(), Error>where W: Write + Seek,

source§

impl BinWrite for NonZeroI64

§

type Args<'a> = ()

source§

fn write_options<W>( &self, writer: &mut W, endian: Endian, _: <NonZeroI64 as BinWrite>::Args<'_> ) -> Result<(), Error>where W: Write + Seek,

source§

impl BinWrite for NonZeroI128

§

type Args<'a> = ()

source§

fn write_options<W>( &self, writer: &mut W, endian: Endian, _: <NonZeroI128 as BinWrite>::Args<'_> ) -> Result<(), Error>where W: Write + Seek,

source§

impl BinWrite for NonZeroU8

§

type Args<'a> = ()

source§

fn write_options<W>( &self, writer: &mut W, endian: Endian, _: <NonZeroU8 as BinWrite>::Args<'_> ) -> Result<(), Error>where W: Write + Seek,

source§

impl BinWrite for NonZeroU16

§

type Args<'a> = ()

source§

fn write_options<W>( &self, writer: &mut W, endian: Endian, _: <NonZeroU16 as BinWrite>::Args<'_> ) -> Result<(), Error>where W: Write + Seek,

source§

impl BinWrite for NonZeroU32

§

type Args<'a> = ()

source§

fn write_options<W>( &self, writer: &mut W, endian: Endian, _: <NonZeroU32 as BinWrite>::Args<'_> ) -> Result<(), Error>where W: Write + Seek,

source§

impl BinWrite for NonZeroU64

§

type Args<'a> = ()

source§

fn write_options<W>( &self, writer: &mut W, endian: Endian, _: <NonZeroU64 as BinWrite>::Args<'_> ) -> Result<(), Error>where W: Write + Seek,

source§

impl BinWrite for NonZeroU128

§

type Args<'a> = ()

source§

fn write_options<W>( &self, writer: &mut W, endian: Endian, _: <NonZeroU128 as BinWrite>::Args<'_> ) -> Result<(), Error>where W: Write + Seek,

source§

impl<Args, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32> BinWrite for (b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32)where Args: Clone, b1: for<'a> BinWrite<Args<'a> = Args>, b2: for<'a> BinWrite<Args<'a> = Args>, b3: for<'a> BinWrite<Args<'a> = Args>, b4: for<'a> BinWrite<Args<'a> = Args>, b5: for<'a> BinWrite<Args<'a> = Args>, b6: for<'a> BinWrite<Args<'a> = Args>, b7: for<'a> BinWrite<Args<'a> = Args>, b8: for<'a> BinWrite<Args<'a> = Args>, b9: for<'a> BinWrite<Args<'a> = Args>, b10: for<'a> BinWrite<Args<'a> = Args>, b11: for<'a> BinWrite<Args<'a> = Args>, b12: for<'a> BinWrite<Args<'a> = Args>, b13: for<'a> BinWrite<Args<'a> = Args>, b14: for<'a> BinWrite<Args<'a> = Args>, b15: for<'a> BinWrite<Args<'a> = Args>, b16: for<'a> BinWrite<Args<'a> = Args>, b17: for<'a> BinWrite<Args<'a> = Args>, b18: for<'a> BinWrite<Args<'a> = Args>, b19: for<'a> BinWrite<Args<'a> = Args>, b20: for<'a> BinWrite<Args<'a> = Args>, b21: for<'a> BinWrite<Args<'a> = Args>, b22: for<'a> BinWrite<Args<'a> = Args>, b23: for<'a> BinWrite<Args<'a> = Args>, b24: for<'a> BinWrite<Args<'a> = Args>, b25: for<'a> BinWrite<Args<'a> = Args>, b26: for<'a> BinWrite<Args<'a> = Args>, b27: for<'a> BinWrite<Args<'a> = Args>, b28: for<'a> BinWrite<Args<'a> = Args>, b29: for<'a> BinWrite<Args<'a> = Args>, b30: for<'a> BinWrite<Args<'a> = Args>, b31: for<'a> BinWrite<Args<'a> = Args>, b32: for<'a> BinWrite<Args<'a> = Args>,

source§

impl<Args, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32> BinWrite for (b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32)where Args: Clone, b2: for<'a> BinWrite<Args<'a> = Args>, b3: for<'a> BinWrite<Args<'a> = Args>, b4: for<'a> BinWrite<Args<'a> = Args>, b5: for<'a> BinWrite<Args<'a> = Args>, b6: for<'a> BinWrite<Args<'a> = Args>, b7: for<'a> BinWrite<Args<'a> = Args>, b8: for<'a> BinWrite<Args<'a> = Args>, b9: for<'a> BinWrite<Args<'a> = Args>, b10: for<'a> BinWrite<Args<'a> = Args>, b11: for<'a> BinWrite<Args<'a> = Args>, b12: for<'a> BinWrite<Args<'a> = Args>, b13: for<'a> BinWrite<Args<'a> = Args>, b14: for<'a> BinWrite<Args<'a> = Args>, b15: for<'a> BinWrite<Args<'a> = Args>, b16: for<'a> BinWrite<Args<'a> = Args>, b17: for<'a> BinWrite<Args<'a> = Args>, b18: for<'a> BinWrite<Args<'a> = Args>, b19: for<'a> BinWrite<Args<'a> = Args>, b20: for<'a> BinWrite<Args<'a> = Args>, b21: for<'a> BinWrite<Args<'a> = Args>, b22: for<'a> BinWrite<Args<'a> = Args>, b23: for<'a> BinWrite<Args<'a> = Args>, b24: for<'a> BinWrite<Args<'a> = Args>, b25: for<'a> BinWrite<Args<'a> = Args>, b26: for<'a> BinWrite<Args<'a> = Args>, b27: for<'a> BinWrite<Args<'a> = Args>, b28: for<'a> BinWrite<Args<'a> = Args>, b29: for<'a> BinWrite<Args<'a> = Args>, b30: for<'a> BinWrite<Args<'a> = Args>, b31: for<'a> BinWrite<Args<'a> = Args>, b32: for<'a> BinWrite<Args<'a> = Args>,

source§

impl<Args, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32> BinWrite for (b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32)where Args: Clone, b3: for<'a> BinWrite<Args<'a> = Args>, b4: for<'a> BinWrite<Args<'a> = Args>, b5: for<'a> BinWrite<Args<'a> = Args>, b6: for<'a> BinWrite<Args<'a> = Args>, b7: for<'a> BinWrite<Args<'a> = Args>, b8: for<'a> BinWrite<Args<'a> = Args>, b9: for<'a> BinWrite<Args<'a> = Args>, b10: for<'a> BinWrite<Args<'a> = Args>, b11: for<'a> BinWrite<Args<'a> = Args>, b12: for<'a> BinWrite<Args<'a> = Args>, b13: for<'a> BinWrite<Args<'a> = Args>, b14: for<'a> BinWrite<Args<'a> = Args>, b15: for<'a> BinWrite<Args<'a> = Args>, b16: for<'a> BinWrite<Args<'a> = Args>, b17: for<'a> BinWrite<Args<'a> = Args>, b18: for<'a> BinWrite<Args<'a> = Args>, b19: for<'a> BinWrite<Args<'a> = Args>, b20: for<'a> BinWrite<Args<'a> = Args>, b21: for<'a> BinWrite<Args<'a> = Args>, b22: for<'a> BinWrite<Args<'a> = Args>, b23: for<'a> BinWrite<Args<'a> = Args>, b24: for<'a> BinWrite<Args<'a> = Args>, b25: for<'a> BinWrite<Args<'a> = Args>, b26: for<'a> BinWrite<Args<'a> = Args>, b27: for<'a> BinWrite<Args<'a> = Args>, b28: for<'a> BinWrite<Args<'a> = Args>, b29: for<'a> BinWrite<Args<'a> = Args>, b30: for<'a> BinWrite<Args<'a> = Args>, b31: for<'a> BinWrite<Args<'a> = Args>, b32: for<'a> BinWrite<Args<'a> = Args>,

source§

impl<Args, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32> BinWrite for (b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32)where Args: Clone, b4: for<'a> BinWrite<Args<'a> = Args>, b5: for<'a> BinWrite<Args<'a> = Args>, b6: for<'a> BinWrite<Args<'a> = Args>, b7: for<'a> BinWrite<Args<'a> = Args>, b8: for<'a> BinWrite<Args<'a> = Args>, b9: for<'a> BinWrite<Args<'a> = Args>, b10: for<'a> BinWrite<Args<'a> = Args>, b11: for<'a> BinWrite<Args<'a> = Args>, b12: for<'a> BinWrite<Args<'a> = Args>, b13: for<'a> BinWrite<Args<'a> = Args>, b14: for<'a> BinWrite<Args<'a> = Args>, b15: for<'a> BinWrite<Args<'a> = Args>, b16: for<'a> BinWrite<Args<'a> = Args>, b17: for<'a> BinWrite<Args<'a> = Args>, b18: for<'a> BinWrite<Args<'a> = Args>, b19: for<'a> BinWrite<Args<'a> = Args>, b20: for<'a> BinWrite<Args<'a> = Args>, b21: for<'a> BinWrite<Args<'a> = Args>, b22: for<'a> BinWrite<Args<'a> = Args>, b23: for<'a> BinWrite<Args<'a> = Args>, b24: for<'a> BinWrite<Args<'a> = Args>, b25: for<'a> BinWrite<Args<'a> = Args>, b26: for<'a> BinWrite<Args<'a> = Args>, b27: for<'a> BinWrite<Args<'a> = Args>, b28: for<'a> BinWrite<Args<'a> = Args>, b29: for<'a> BinWrite<Args<'a> = Args>, b30: for<'a> BinWrite<Args<'a> = Args>, b31: for<'a> BinWrite<Args<'a> = Args>, b32: for<'a> BinWrite<Args<'a> = Args>,

source§

impl<Args, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32> BinWrite for (b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32)where Args: Clone, b5: for<'a> BinWrite<Args<'a> = Args>, b6: for<'a> BinWrite<Args<'a> = Args>, b7: for<'a> BinWrite<Args<'a> = Args>, b8: for<'a> BinWrite<Args<'a> = Args>, b9: for<'a> BinWrite<Args<'a> = Args>, b10: for<'a> BinWrite<Args<'a> = Args>, b11: for<'a> BinWrite<Args<'a> = Args>, b12: for<'a> BinWrite<Args<'a> = Args>, b13: for<'a> BinWrite<Args<'a> = Args>, b14: for<'a> BinWrite<Args<'a> = Args>, b15: for<'a> BinWrite<Args<'a> = Args>, b16: for<'a> BinWrite<Args<'a> = Args>, b17: for<'a> BinWrite<Args<'a> = Args>, b18: for<'a> BinWrite<Args<'a> = Args>, b19: for<'a> BinWrite<Args<'a> = Args>, b20: for<'a> BinWrite<Args<'a> = Args>, b21: for<'a> BinWrite<Args<'a> = Args>, b22: for<'a> BinWrite<Args<'a> = Args>, b23: for<'a> BinWrite<Args<'a> = Args>, b24: for<'a> BinWrite<Args<'a> = Args>, b25: for<'a> BinWrite<Args<'a> = Args>, b26: for<'a> BinWrite<Args<'a> = Args>, b27: for<'a> BinWrite<Args<'a> = Args>, b28: for<'a> BinWrite<Args<'a> = Args>, b29: for<'a> BinWrite<Args<'a> = Args>, b30: for<'a> BinWrite<Args<'a> = Args>, b31: for<'a> BinWrite<Args<'a> = Args>, b32: for<'a> BinWrite<Args<'a> = Args>,

source§

impl<Args, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32> BinWrite for (b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32)where Args: Clone, b6: for<'a> BinWrite<Args<'a> = Args>, b7: for<'a> BinWrite<Args<'a> = Args>, b8: for<'a> BinWrite<Args<'a> = Args>, b9: for<'a> BinWrite<Args<'a> = Args>, b10: for<'a> BinWrite<Args<'a> = Args>, b11: for<'a> BinWrite<Args<'a> = Args>, b12: for<'a> BinWrite<Args<'a> = Args>, b13: for<'a> BinWrite<Args<'a> = Args>, b14: for<'a> BinWrite<Args<'a> = Args>, b15: for<'a> BinWrite<Args<'a> = Args>, b16: for<'a> BinWrite<Args<'a> = Args>, b17: for<'a> BinWrite<Args<'a> = Args>, b18: for<'a> BinWrite<Args<'a> = Args>, b19: for<'a> BinWrite<Args<'a> = Args>, b20: for<'a> BinWrite<Args<'a> = Args>, b21: for<'a> BinWrite<Args<'a> = Args>, b22: for<'a> BinWrite<Args<'a> = Args>, b23: for<'a> BinWrite<Args<'a> = Args>, b24: for<'a> BinWrite<Args<'a> = Args>, b25: for<'a> BinWrite<Args<'a> = Args>, b26: for<'a> BinWrite<Args<'a> = Args>, b27: for<'a> BinWrite<Args<'a> = Args>, b28: for<'a> BinWrite<Args<'a> = Args>, b29: for<'a> BinWrite<Args<'a> = Args>, b30: for<'a> BinWrite<Args<'a> = Args>, b31: for<'a> BinWrite<Args<'a> = Args>, b32: for<'a> BinWrite<Args<'a> = Args>,

source§

impl<Args, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32> BinWrite for (b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32)where Args: Clone, b7: for<'a> BinWrite<Args<'a> = Args>, b8: for<'a> BinWrite<Args<'a> = Args>, b9: for<'a> BinWrite<Args<'a> = Args>, b10: for<'a> BinWrite<Args<'a> = Args>, b11: for<'a> BinWrite<Args<'a> = Args>, b12: for<'a> BinWrite<Args<'a> = Args>, b13: for<'a> BinWrite<Args<'a> = Args>, b14: for<'a> BinWrite<Args<'a> = Args>, b15: for<'a> BinWrite<Args<'a> = Args>, b16: for<'a> BinWrite<Args<'a> = Args>, b17: for<'a> BinWrite<Args<'a> = Args>, b18: for<'a> BinWrite<Args<'a> = Args>, b19: for<'a> BinWrite<Args<'a> = Args>, b20: for<'a> BinWrite<Args<'a> = Args>, b21: for<'a> BinWrite<Args<'a> = Args>, b22: for<'a> BinWrite<Args<'a> = Args>, b23: for<'a> BinWrite<Args<'a> = Args>, b24: for<'a> BinWrite<Args<'a> = Args>, b25: for<'a> BinWrite<Args<'a> = Args>, b26: for<'a> BinWrite<Args<'a> = Args>, b27: for<'a> BinWrite<Args<'a> = Args>, b28: for<'a> BinWrite<Args<'a> = Args>, b29: for<'a> BinWrite<Args<'a> = Args>, b30: for<'a> BinWrite<Args<'a> = Args>, b31: for<'a> BinWrite<Args<'a> = Args>, b32: for<'a> BinWrite<Args<'a> = Args>,

source§

impl<Args, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32> BinWrite for (b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32)where Args: Clone, b8: for<'a> BinWrite<Args<'a> = Args>, b9: for<'a> BinWrite<Args<'a> = Args>, b10: for<'a> BinWrite<Args<'a> = Args>, b11: for<'a> BinWrite<Args<'a> = Args>, b12: for<'a> BinWrite<Args<'a> = Args>, b13: for<'a> BinWrite<Args<'a> = Args>, b14: for<'a> BinWrite<Args<'a> = Args>, b15: for<'a> BinWrite<Args<'a> = Args>, b16: for<'a> BinWrite<Args<'a> = Args>, b17: for<'a> BinWrite<Args<'a> = Args>, b18: for<'a> BinWrite<Args<'a> = Args>, b19: for<'a> BinWrite<Args<'a> = Args>, b20: for<'a> BinWrite<Args<'a> = Args>, b21: for<'a> BinWrite<Args<'a> = Args>, b22: for<'a> BinWrite<Args<'a> = Args>, b23: for<'a> BinWrite<Args<'a> = Args>, b24: for<'a> BinWrite<Args<'a> = Args>, b25: for<'a> BinWrite<Args<'a> = Args>, b26: for<'a> BinWrite<Args<'a> = Args>, b27: for<'a> BinWrite<Args<'a> = Args>, b28: for<'a> BinWrite<Args<'a> = Args>, b29: for<'a> BinWrite<Args<'a> = Args>, b30: for<'a> BinWrite<Args<'a> = Args>, b31: for<'a> BinWrite<Args<'a> = Args>, b32: for<'a> BinWrite<Args<'a> = Args>,

source§

impl<Args, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32> BinWrite for (b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32)where Args: Clone, b9: for<'a> BinWrite<Args<'a> = Args>, b10: for<'a> BinWrite<Args<'a> = Args>, b11: for<'a> BinWrite<Args<'a> = Args>, b12: for<'a> BinWrite<Args<'a> = Args>, b13: for<'a> BinWrite<Args<'a> = Args>, b14: for<'a> BinWrite<Args<'a> = Args>, b15: for<'a> BinWrite<Args<'a> = Args>, b16: for<'a> BinWrite<Args<'a> = Args>, b17: for<'a> BinWrite<Args<'a> = Args>, b18: for<'a> BinWrite<Args<'a> = Args>, b19: for<'a> BinWrite<Args<'a> = Args>, b20: for<'a> BinWrite<Args<'a> = Args>, b21: for<'a> BinWrite<Args<'a> = Args>, b22: for<'a> BinWrite<Args<'a> = Args>, b23: for<'a> BinWrite<Args<'a> = Args>, b24: for<'a> BinWrite<Args<'a> = Args>, b25: for<'a> BinWrite<Args<'a> = Args>, b26: for<'a> BinWrite<Args<'a> = Args>, b27: for<'a> BinWrite<Args<'a> = Args>, b28: for<'a> BinWrite<Args<'a> = Args>, b29: for<'a> BinWrite<Args<'a> = Args>, b30: for<'a> BinWrite<Args<'a> = Args>, b31: for<'a> BinWrite<Args<'a> = Args>, b32: for<'a> BinWrite<Args<'a> = Args>,

source§

impl<Args, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32> BinWrite for (b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32)where Args: Clone, b10: for<'a> BinWrite<Args<'a> = Args>, b11: for<'a> BinWrite<Args<'a> = Args>, b12: for<'a> BinWrite<Args<'a> = Args>, b13: for<'a> BinWrite<Args<'a> = Args>, b14: for<'a> BinWrite<Args<'a> = Args>, b15: for<'a> BinWrite<Args<'a> = Args>, b16: for<'a> BinWrite<Args<'a> = Args>, b17: for<'a> BinWrite<Args<'a> = Args>, b18: for<'a> BinWrite<Args<'a> = Args>, b19: for<'a> BinWrite<Args<'a> = Args>, b20: for<'a> BinWrite<Args<'a> = Args>, b21: for<'a> BinWrite<Args<'a> = Args>, b22: for<'a> BinWrite<Args<'a> = Args>, b23: for<'a> BinWrite<Args<'a> = Args>, b24: for<'a> BinWrite<Args<'a> = Args>, b25: for<'a> BinWrite<Args<'a> = Args>, b26: for<'a> BinWrite<Args<'a> = Args>, b27: for<'a> BinWrite<Args<'a> = Args>, b28: for<'a> BinWrite<Args<'a> = Args>, b29: for<'a> BinWrite<Args<'a> = Args>, b30: for<'a> BinWrite<Args<'a> = Args>, b31: for<'a> BinWrite<Args<'a> = Args>, b32: for<'a> BinWrite<Args<'a> = Args>,

source§

impl<Args, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32> BinWrite for (b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32)where Args: Clone, b11: for<'a> BinWrite<Args<'a> = Args>, b12: for<'a> BinWrite<Args<'a> = Args>, b13: for<'a> BinWrite<Args<'a> = Args>, b14: for<'a> BinWrite<Args<'a> = Args>, b15: for<'a> BinWrite<Args<'a> = Args>, b16: for<'a> BinWrite<Args<'a> = Args>, b17: for<'a> BinWrite<Args<'a> = Args>, b18: for<'a> BinWrite<Args<'a> = Args>, b19: for<'a> BinWrite<Args<'a> = Args>, b20: for<'a> BinWrite<Args<'a> = Args>, b21: for<'a> BinWrite<Args<'a> = Args>, b22: for<'a> BinWrite<Args<'a> = Args>, b23: for<'a> BinWrite<Args<'a> = Args>, b24: for<'a> BinWrite<Args<'a> = Args>, b25: for<'a> BinWrite<Args<'a> = Args>, b26: for<'a> BinWrite<Args<'a> = Args>, b27: for<'a> BinWrite<Args<'a> = Args>, b28: for<'a> BinWrite<Args<'a> = Args>, b29: for<'a> BinWrite<Args<'a> = Args>, b30: for<'a> BinWrite<Args<'a> = Args>, b31: for<'a> BinWrite<Args<'a> = Args>, b32: for<'a> BinWrite<Args<'a> = Args>,

source§

impl<Args, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32> BinWrite for (b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32)where Args: Clone, b12: for<'a> BinWrite<Args<'a> = Args>, b13: for<'a> BinWrite<Args<'a> = Args>, b14: for<'a> BinWrite<Args<'a> = Args>, b15: for<'a> BinWrite<Args<'a> = Args>, b16: for<'a> BinWrite<Args<'a> = Args>, b17: for<'a> BinWrite<Args<'a> = Args>, b18: for<'a> BinWrite<Args<'a> = Args>, b19: for<'a> BinWrite<Args<'a> = Args>, b20: for<'a> BinWrite<Args<'a> = Args>, b21: for<'a> BinWrite<Args<'a> = Args>, b22: for<'a> BinWrite<Args<'a> = Args>, b23: for<'a> BinWrite<Args<'a> = Args>, b24: for<'a> BinWrite<Args<'a> = Args>, b25: for<'a> BinWrite<Args<'a> = Args>, b26: for<'a> BinWrite<Args<'a> = Args>, b27: for<'a> BinWrite<Args<'a> = Args>, b28: for<'a> BinWrite<Args<'a> = Args>, b29: for<'a> BinWrite<Args<'a> = Args>, b30: for<'a> BinWrite<Args<'a> = Args>, b31: for<'a> BinWrite<Args<'a> = Args>, b32: for<'a> BinWrite<Args<'a> = Args>,

source§

impl<Args, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32> BinWrite for (b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32)where Args: Clone, b13: for<'a> BinWrite<Args<'a> = Args>, b14: for<'a> BinWrite<Args<'a> = Args>, b15: for<'a> BinWrite<Args<'a> = Args>, b16: for<'a> BinWrite<Args<'a> = Args>, b17: for<'a> BinWrite<Args<'a> = Args>, b18: for<'a> BinWrite<Args<'a> = Args>, b19: for<'a> BinWrite<Args<'a> = Args>, b20: for<'a> BinWrite<Args<'a> = Args>, b21: for<'a> BinWrite<Args<'a> = Args>, b22: for<'a> BinWrite<Args<'a> = Args>, b23: for<'a> BinWrite<Args<'a> = Args>, b24: for<'a> BinWrite<Args<'a> = Args>, b25: for<'a> BinWrite<Args<'a> = Args>, b26: for<'a> BinWrite<Args<'a> = Args>, b27: for<'a> BinWrite<Args<'a> = Args>, b28: for<'a> BinWrite<Args<'a> = Args>, b29: for<'a> BinWrite<Args<'a> = Args>, b30: for<'a> BinWrite<Args<'a> = Args>, b31: for<'a> BinWrite<Args<'a> = Args>, b32: for<'a> BinWrite<Args<'a> = Args>,

source§

impl<Args, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32> BinWrite for (b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32)where Args: Clone, b14: for<'a> BinWrite<Args<'a> = Args>, b15: for<'a> BinWrite<Args<'a> = Args>, b16: for<'a> BinWrite<Args<'a> = Args>, b17: for<'a> BinWrite<Args<'a> = Args>, b18: for<'a> BinWrite<Args<'a> = Args>, b19: for<'a> BinWrite<Args<'a> = Args>, b20: for<'a> BinWrite<Args<'a> = Args>, b21: for<'a> BinWrite<Args<'a> = Args>, b22: for<'a> BinWrite<Args<'a> = Args>, b23: for<'a> BinWrite<Args<'a> = Args>, b24: for<'a> BinWrite<Args<'a> = Args>, b25: for<'a> BinWrite<Args<'a> = Args>, b26: for<'a> BinWrite<Args<'a> = Args>, b27: for<'a> BinWrite<Args<'a> = Args>, b28: for<'a> BinWrite<Args<'a> = Args>, b29: for<'a> BinWrite<Args<'a> = Args>, b30: for<'a> BinWrite<Args<'a> = Args>, b31: for<'a> BinWrite<Args<'a> = Args>, b32: for<'a> BinWrite<Args<'a> = Args>,

source§

impl<Args, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32> BinWrite for (b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32)where Args: Clone, b15: for<'a> BinWrite<Args<'a> = Args>, b16: for<'a> BinWrite<Args<'a> = Args>, b17: for<'a> BinWrite<Args<'a> = Args>, b18: for<'a> BinWrite<Args<'a> = Args>, b19: for<'a> BinWrite<Args<'a> = Args>, b20: for<'a> BinWrite<Args<'a> = Args>, b21: for<'a> BinWrite<Args<'a> = Args>, b22: for<'a> BinWrite<Args<'a> = Args>, b23: for<'a> BinWrite<Args<'a> = Args>, b24: for<'a> BinWrite<Args<'a> = Args>, b25: for<'a> BinWrite<Args<'a> = Args>, b26: for<'a> BinWrite<Args<'a> = Args>, b27: for<'a> BinWrite<Args<'a> = Args>, b28: for<'a> BinWrite<Args<'a> = Args>, b29: for<'a> BinWrite<Args<'a> = Args>, b30: for<'a> BinWrite<Args<'a> = Args>, b31: for<'a> BinWrite<Args<'a> = Args>, b32: for<'a> BinWrite<Args<'a> = Args>,

source§

impl<Args, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32> BinWrite for (b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32)where Args: Clone, b16: for<'a> BinWrite<Args<'a> = Args>, b17: for<'a> BinWrite<Args<'a> = Args>, b18: for<'a> BinWrite<Args<'a> = Args>, b19: for<'a> BinWrite<Args<'a> = Args>, b20: for<'a> BinWrite<Args<'a> = Args>, b21: for<'a> BinWrite<Args<'a> = Args>, b22: for<'a> BinWrite<Args<'a> = Args>, b23: for<'a> BinWrite<Args<'a> = Args>, b24: for<'a> BinWrite<Args<'a> = Args>, b25: for<'a> BinWrite<Args<'a> = Args>, b26: for<'a> BinWrite<Args<'a> = Args>, b27: for<'a> BinWrite<Args<'a> = Args>, b28: for<'a> BinWrite<Args<'a> = Args>, b29: for<'a> BinWrite<Args<'a> = Args>, b30: for<'a> BinWrite<Args<'a> = Args>, b31: for<'a> BinWrite<Args<'a> = Args>, b32: for<'a> BinWrite<Args<'a> = Args>,

source§

impl<Args, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32> BinWrite for (b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32)where Args: Clone, b17: for<'a> BinWrite<Args<'a> = Args>, b18: for<'a> BinWrite<Args<'a> = Args>, b19: for<'a> BinWrite<Args<'a> = Args>, b20: for<'a> BinWrite<Args<'a> = Args>, b21: for<'a> BinWrite<Args<'a> = Args>, b22: for<'a> BinWrite<Args<'a> = Args>, b23: for<'a> BinWrite<Args<'a> = Args>, b24: for<'a> BinWrite<Args<'a> = Args>, b25: for<'a> BinWrite<Args<'a> = Args>, b26: for<'a> BinWrite<Args<'a> = Args>, b27: for<'a> BinWrite<Args<'a> = Args>, b28: for<'a> BinWrite<Args<'a> = Args>, b29: for<'a> BinWrite<Args<'a> = Args>, b30: for<'a> BinWrite<Args<'a> = Args>, b31: for<'a> BinWrite<Args<'a> = Args>, b32: for<'a> BinWrite<Args<'a> = Args>,

source§

impl<Args, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32> BinWrite for (b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32)where Args: Clone, b18: for<'a> BinWrite<Args<'a> = Args>, b19: for<'a> BinWrite<Args<'a> = Args>, b20: for<'a> BinWrite<Args<'a> = Args>, b21: for<'a> BinWrite<Args<'a> = Args>, b22: for<'a> BinWrite<Args<'a> = Args>, b23: for<'a> BinWrite<Args<'a> = Args>, b24: for<'a> BinWrite<Args<'a> = Args>, b25: for<'a> BinWrite<Args<'a> = Args>, b26: for<'a> BinWrite<Args<'a> = Args>, b27: for<'a> BinWrite<Args<'a> = Args>, b28: for<'a> BinWrite<Args<'a> = Args>, b29: for<'a> BinWrite<Args<'a> = Args>, b30: for<'a> BinWrite<Args<'a> = Args>, b31: for<'a> BinWrite<Args<'a> = Args>, b32: for<'a> BinWrite<Args<'a> = Args>,

source§

impl<Args, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32> BinWrite for (b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32)where Args: Clone, b19: for<'a> BinWrite<Args<'a> = Args>, b20: for<'a> BinWrite<Args<'a> = Args>, b21: for<'a> BinWrite<Args<'a> = Args>, b22: for<'a> BinWrite<Args<'a> = Args>, b23: for<'a> BinWrite<Args<'a> = Args>, b24: for<'a> BinWrite<Args<'a> = Args>, b25: for<'a> BinWrite<Args<'a> = Args>, b26: for<'a> BinWrite<Args<'a> = Args>, b27: for<'a> BinWrite<Args<'a> = Args>, b28: for<'a> BinWrite<Args<'a> = Args>, b29: for<'a> BinWrite<Args<'a> = Args>, b30: for<'a> BinWrite<Args<'a> = Args>, b31: for<'a> BinWrite<Args<'a> = Args>, b32: for<'a> BinWrite<Args<'a> = Args>,

source§

impl<Args, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32> BinWrite for (b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32)where Args: Clone, b20: for<'a> BinWrite<Args<'a> = Args>, b21: for<'a> BinWrite<Args<'a> = Args>, b22: for<'a> BinWrite<Args<'a> = Args>, b23: for<'a> BinWrite<Args<'a> = Args>, b24: for<'a> BinWrite<Args<'a> = Args>, b25: for<'a> BinWrite<Args<'a> = Args>, b26: for<'a> BinWrite<Args<'a> = Args>, b27: for<'a> BinWrite<Args<'a> = Args>, b28: for<'a> BinWrite<Args<'a> = Args>, b29: for<'a> BinWrite<Args<'a> = Args>, b30: for<'a> BinWrite<Args<'a> = Args>, b31: for<'a> BinWrite<Args<'a> = Args>, b32: for<'a> BinWrite<Args<'a> = Args>,

§

type Args<'a> = Args

source§

fn write_options<W>( &self, writer: &mut W, endian: Endian, args: <(b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32) as BinWrite>::Args<'_> ) -> Result<(), Error>where W: Write + Seek,

source§

impl<Args, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32> BinWrite for (b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32)where Args: Clone, b21: for<'a> BinWrite<Args<'a> = Args>, b22: for<'a> BinWrite<Args<'a> = Args>, b23: for<'a> BinWrite<Args<'a> = Args>, b24: for<'a> BinWrite<Args<'a> = Args>, b25: for<'a> BinWrite<Args<'a> = Args>, b26: for<'a> BinWrite<Args<'a> = Args>, b27: for<'a> BinWrite<Args<'a> = Args>, b28: for<'a> BinWrite<Args<'a> = Args>, b29: for<'a> BinWrite<Args<'a> = Args>, b30: for<'a> BinWrite<Args<'a> = Args>, b31: for<'a> BinWrite<Args<'a> = Args>, b32: for<'a> BinWrite<Args<'a> = Args>,

§

type Args<'a> = Args

source§

fn write_options<W>( &self, writer: &mut W, endian: Endian, args: <(b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32) as BinWrite>::Args<'_> ) -> Result<(), Error>where W: Write + Seek,

source§

impl<Args, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32> BinWrite for (b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32)where Args: Clone, b22: for<'a> BinWrite<Args<'a> = Args>, b23: for<'a> BinWrite<Args<'a> = Args>, b24: for<'a> BinWrite<Args<'a> = Args>, b25: for<'a> BinWrite<Args<'a> = Args>, b26: for<'a> BinWrite<Args<'a> = Args>, b27: for<'a> BinWrite<Args<'a> = Args>, b28: for<'a> BinWrite<Args<'a> = Args>, b29: for<'a> BinWrite<Args<'a> = Args>, b30: for<'a> BinWrite<Args<'a> = Args>, b31: for<'a> BinWrite<Args<'a> = Args>, b32: for<'a> BinWrite<Args<'a> = Args>,

§

type Args<'a> = Args

source§

fn write_options<W>( &self, writer: &mut W, endian: Endian, args: <(b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32) as BinWrite>::Args<'_> ) -> Result<(), Error>where W: Write + Seek,

source§

impl<Args, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32> BinWrite for (b23, b24, b25, b26, b27, b28, b29, b30, b31, b32)where Args: Clone, b23: for<'a> BinWrite<Args<'a> = Args>, b24: for<'a> BinWrite<Args<'a> = Args>, b25: for<'a> BinWrite<Args<'a> = Args>, b26: for<'a> BinWrite<Args<'a> = Args>, b27: for<'a> BinWrite<Args<'a> = Args>, b28: for<'a> BinWrite<Args<'a> = Args>, b29: for<'a> BinWrite<Args<'a> = Args>, b30: for<'a> BinWrite<Args<'a> = Args>, b31: for<'a> BinWrite<Args<'a> = Args>, b32: for<'a> BinWrite<Args<'a> = Args>,

§

type Args<'a> = Args

source§

fn write_options<W>( &self, writer: &mut W, endian: Endian, args: <(b23, b24, b25, b26, b27, b28, b29, b30, b31, b32) as BinWrite>::Args<'_> ) -> Result<(), Error>where W: Write + Seek,

source§

impl<Args, b24, b25, b26, b27, b28, b29, b30, b31, b32> BinWrite for (b24, b25, b26, b27, b28, b29, b30, b31, b32)where Args: Clone, b24: for<'a> BinWrite<Args<'a> = Args>, b25: for<'a> BinWrite<Args<'a> = Args>, b26: for<'a> BinWrite<Args<'a> = Args>, b27: for<'a> BinWrite<Args<'a> = Args>, b28: for<'a> BinWrite<Args<'a> = Args>, b29: for<'a> BinWrite<Args<'a> = Args>, b30: for<'a> BinWrite<Args<'a> = Args>, b31: for<'a> BinWrite<Args<'a> = Args>, b32: for<'a> BinWrite<Args<'a> = Args>,

§

type Args<'a> = Args

source§

fn write_options<W>( &self, writer: &mut W, endian: Endian, args: <(b24, b25, b26, b27, b28, b29, b30, b31, b32) as BinWrite>::Args<'_> ) -> Result<(), Error>where W: Write + Seek,

source§

impl<Args, b25, b26, b27, b28, b29, b30, b31, b32> BinWrite for (b25, b26, b27, b28, b29, b30, b31, b32)where Args: Clone, b25: for<'a> BinWrite<Args<'a> = Args>, b26: for<'a> BinWrite<Args<'a> = Args>, b27: for<'a> BinWrite<Args<'a> = Args>, b28: for<'a> BinWrite<Args<'a> = Args>, b29: for<'a> BinWrite<Args<'a> = Args>, b30: for<'a> BinWrite<Args<'a> = Args>, b31: for<'a> BinWrite<Args<'a> = Args>, b32: for<'a> BinWrite<Args<'a> = Args>,

§

type Args<'a> = Args

source§

fn write_options<W>( &self, writer: &mut W, endian: Endian, args: <(b25, b26, b27, b28, b29, b30, b31, b32) as BinWrite>::Args<'_> ) -> Result<(), Error>where W: Write + Seek,

source§

impl<Args, b26, b27, b28, b29, b30, b31, b32> BinWrite for (b26, b27, b28, b29, b30, b31, b32)where Args: Clone, b26: for<'a> BinWrite<Args<'a> = Args>, b27: for<'a> BinWrite<Args<'a> = Args>, b28: for<'a> BinWrite<Args<'a> = Args>, b29: for<'a> BinWrite<Args<'a> = Args>, b30: for<'a> BinWrite<Args<'a> = Args>, b31: for<'a> BinWrite<Args<'a> = Args>, b32: for<'a> BinWrite<Args<'a> = Args>,

§

type Args<'a> = Args

source§

fn write_options<W>( &self, writer: &mut W, endian: Endian, args: <(b26, b27, b28, b29, b30, b31, b32) as BinWrite>::Args<'_> ) -> Result<(), Error>where W: Write + Seek,

source§

impl<Args, b27, b28, b29, b30, b31, b32> BinWrite for (b27, b28, b29, b30, b31, b32)where Args: Clone, b27: for<'a> BinWrite<Args<'a> = Args>, b28: for<'a> BinWrite<Args<'a> = Args>, b29: for<'a> BinWrite<Args<'a> = Args>, b30: for<'a> BinWrite<Args<'a> = Args>, b31: for<'a> BinWrite<Args<'a> = Args>, b32: for<'a> BinWrite<Args<'a> = Args>,

§

type Args<'a> = Args

source§

fn write_options<W>( &self, writer: &mut W, endian: Endian, args: <(b27, b28, b29, b30, b31, b32) as BinWrite>::Args<'_> ) -> Result<(), Error>where W: Write + Seek,

source§

impl<Args, b28, b29, b30, b31, b32> BinWrite for (b28, b29, b30, b31, b32)where Args: Clone, b28: for<'a> BinWrite<Args<'a> = Args>, b29: for<'a> BinWrite<Args<'a> = Args>, b30: for<'a> BinWrite<Args<'a> = Args>, b31: for<'a> BinWrite<Args<'a> = Args>, b32: for<'a> BinWrite<Args<'a> = Args>,

§

type Args<'a> = Args

source§

fn write_options<W>( &self, writer: &mut W, endian: Endian, args: <(b28, b29, b30, b31, b32) as BinWrite>::Args<'_> ) -> Result<(), Error>where W: Write + Seek,

source§

impl<Args, b29, b30, b31, b32> BinWrite for (b29, b30, b31, b32)where Args: Clone, b29: for<'a> BinWrite<Args<'a> = Args>, b30: for<'a> BinWrite<Args<'a> = Args>, b31: for<'a> BinWrite<Args<'a> = Args>, b32: for<'a> BinWrite<Args<'a> = Args>,

§

type Args<'a> = Args

source§

fn write_options<W>( &self, writer: &mut W, endian: Endian, args: <(b29, b30, b31, b32) as BinWrite>::Args<'_> ) -> Result<(), Error>where W: Write + Seek,

source§

impl<Args, b30, b31, b32> BinWrite for (b30, b31, b32)where Args: Clone, b30: for<'a> BinWrite<Args<'a> = Args>, b31: for<'a> BinWrite<Args<'a> = Args>, b32: for<'a> BinWrite<Args<'a> = Args>,

§

type Args<'a> = Args

source§

fn write_options<W>( &self, writer: &mut W, endian: Endian, args: <(b30, b31, b32) as BinWrite>::Args<'_> ) -> Result<(), Error>where W: Write + Seek,

source§

impl<Args, b31, b32> BinWrite for (b31, b32)where Args: Clone, b31: for<'a> BinWrite<Args<'a> = Args>, b32: for<'a> BinWrite<Args<'a> = Args>,

§

type Args<'a> = Args

source§

fn write_options<W>( &self, writer: &mut W, endian: Endian, args: <(b31, b32) as BinWrite>::Args<'_> ) -> Result<(), Error>where W: Write + Seek,

source§

impl<Args, b32> BinWrite for (b32,)where Args: Clone, b32: for<'a> BinWrite<Args<'a> = Args>,

§

type Args<'a> = Args

source§

fn write_options<W>( &self, writer: &mut W, endian: Endian, args: <(b32,) as BinWrite>::Args<'_> ) -> Result<(), Error>where W: Write + Seek,

source§

impl<T> BinWrite for Option<T>where T: BinWrite,

§

type Args<'a> = <T as BinWrite>::Args<'a>

source§

fn write_options<W>( &self, writer: &mut W, endian: Endian, args: <Option<T> as BinWrite>::Args<'_> ) -> Result<(), Error>where W: Write + Seek,

source§

impl<T> BinWrite for &Twhere T: BinWrite + ?Sized,

§

type Args<'a> = <T as BinWrite>::Args<'a>

source§

fn write_options<W>( &self, writer: &mut W, endian: Endian, args: <&T as BinWrite>::Args<'_> ) -> Result<(), Error>where W: Write + Seek,

source§

impl<T> BinWrite for [T]where T: BinWrite, <T as BinWrite>::Args<'a>: for<'a> Clone,

§

type Args<'a> = <T as BinWrite>::Args<'a>

source§

fn write_options<W>( &self, writer: &mut W, endian: Endian, args: <[T] as BinWrite>::Args<'_> ) -> Result<(), Error>where W: Write + Seek,

source§

impl<T> BinWrite for Box<T>where T: BinWrite + 'static + ?Sized,

§

type Args<'a> = <T as BinWrite>::Args<'a>

source§

fn write_options<W>( &self, writer: &mut W, endian: Endian, args: <Box<T> as BinWrite>::Args<'_> ) -> Result<(), Error>where W: Write + Seek,

source§

impl<T> BinWrite for Vec<T>where T: BinWrite + 'static, <T as BinWrite>::Args<'a>: for<'a> Clone,

§

type Args<'a> = <T as BinWrite>::Args<'a>

source§

fn write_options<W>( &self, writer: &mut W, endian: Endian, args: <Vec<T> as BinWrite>::Args<'_> ) -> Result<(), Error>where W: Write + Seek,

source§

impl<T> BinWrite for PhantomData<T>where T: BinWrite,

§

type Args<'a> = <T as BinWrite>::Args<'a>

source§

fn write_options<W>( &self, _: &mut W, _: Endian, _: <PhantomData<T> as BinWrite>::Args<'_> ) -> Result<(), Error>where W: Write + Seek,

source§

impl<T, const N: usize> BinWrite for [T; N]where T: BinWrite + 'static, <T as BinWrite>::Args<'a>: for<'a> Clone,

§

type Args<'a> = <T as BinWrite>::Args<'a>

source§

fn write_options<W>( &self, writer: &mut W, endian: Endian, args: <[T; N] as BinWrite>::Args<'_> ) -> Result<(), Error>where W: Write + Seek,

Implementors§

source§

impl BinWrite for ChannelExtendedDataType

§

type Args<'__binrw_generated_args_lifetime> = ()

source§

impl BinWrite for ChannelOpenFailureReason

§

type Args<'__binrw_generated_args_lifetime> = ()

source§

impl BinWrite for DisconnectReason

§

type Args<'__binrw_generated_args_lifetime> = ()

source§

impl BinWrite for UserauthMethod

§

type Args<'__binrw_generated_args_lifetime> = ()

source§

impl BinWrite for Bool

§

type Args<'__binrw_generated_args_lifetime> = ()

source§

impl BinWrite for NameList

§

type Args<'__binrw_generated_args_lifetime> = ()

source§

impl BinWrite for String

§

type Args<'__binrw_generated_args_lifetime> = ()

source§

impl BinWrite for StringAscii

§

type Args<'__binrw_generated_args_lifetime> = ()

source§

impl BinWrite for StringUtf8

§

type Args<'__binrw_generated_args_lifetime> = ()

source§

impl BinWrite for ChannelClose

§

type Args<'__binrw_generated_args_lifetime> = ()

source§

impl BinWrite for ChannelData

§

type Args<'__binrw_generated_args_lifetime> = ()

source§

impl BinWrite for ChannelEof

§

type Args<'__binrw_generated_args_lifetime> = ()

source§

impl BinWrite for ChannelExtendedData

§

type Args<'__binrw_generated_args_lifetime> = ()

source§

impl BinWrite for ChannelFailure

§

type Args<'__binrw_generated_args_lifetime> = ()

source§

impl BinWrite for ChannelOpen

§

type Args<'__binrw_generated_args_lifetime> = ()

source§

impl BinWrite for ChannelOpenConfirmation

§

type Args<'__binrw_generated_args_lifetime> = ()

source§

impl BinWrite for ChannelOpenFailure

§

type Args<'__binrw_generated_args_lifetime> = ()

source§

impl BinWrite for ChannelRequest

§

type Args<'__binrw_generated_args_lifetime> = ()

source§

impl BinWrite for ChannelSuccess

§

type Args<'__binrw_generated_args_lifetime> = ()

source§

impl BinWrite for ChannelWindowAdjust

§

type Args<'__binrw_generated_args_lifetime> = ()

source§

impl BinWrite for GlobalRequest

§

type Args<'__binrw_generated_args_lifetime> = ()

source§

impl BinWrite for RequestFailure

§

type Args<'__binrw_generated_args_lifetime> = ()

source§

impl BinWrite for RequestSuccess

§

type Args<'__binrw_generated_args_lifetime> = ()

source§

impl BinWrite for NullString

§

type Args<'a> = ()

source§

impl BinWrite for NullWideString

§

type Args<'a> = ()

source§

impl BinWrite for Packet

§

type Args<'__binrw_generated_args_lifetime> = ()

source§

impl BinWrite for Debug

§

type Args<'__binrw_generated_args_lifetime> = ()

source§

impl BinWrite for Disconnect

§

type Args<'__binrw_generated_args_lifetime> = ()

source§

impl BinWrite for Ignore

§

type Args<'__binrw_generated_args_lifetime> = ()

source§

impl BinWrite for KexInit

§

type Args<'__binrw_generated_args_lifetime> = ()

source§

impl BinWrite for NewKeys

§

type Args<'__binrw_generated_args_lifetime> = ()

source§

impl BinWrite for ServiceAccept

§

type Args<'__binrw_generated_args_lifetime> = ()

source§

impl BinWrite for ServiceRequest

§

type Args<'__binrw_generated_args_lifetime> = ()

source§

impl BinWrite for Unimplemented

§

type Args<'__binrw_generated_args_lifetime> = ()

source§

impl BinWrite for UserauthBanner

§

type Args<'__binrw_generated_args_lifetime> = ()

source§

impl BinWrite for UserauthFailure

§

type Args<'__binrw_generated_args_lifetime> = ()

source§

impl BinWrite for UserauthInfoRequest

§

type Args<'__binrw_generated_args_lifetime> = ()

source§

impl BinWrite for UserauthInfoRequestPrompt

§

type Args<'__binrw_generated_args_lifetime> = ()

source§

impl BinWrite for UserauthInfoResponse

§

type Args<'__binrw_generated_args_lifetime> = ()

source§

impl BinWrite for UserauthPasswdChangereq

§

type Args<'__binrw_generated_args_lifetime> = ()

source§

impl BinWrite for UserauthPkOk

§

type Args<'__binrw_generated_args_lifetime> = ()

source§

impl BinWrite for UserauthRequest

§

type Args<'__binrw_generated_args_lifetime> = ()

source§

impl BinWrite for UserauthSuccess

§

type Args<'__binrw_generated_args_lifetime> = ()