Trait BWrite 

pub trait BWrite<'a, W> {
    const WIDTH: u8 = 1u8;

    // Required methods
    fn width(&self) -> u8;
    fn offset(&self) -> u8;
    fn bit(self, value: bool) -> &'a mut W;
    fn variant(self, variant: bool) -> &'a mut W;
    fn set_bit(self) -> &'a mut W;
    fn clear_bit(self) -> &'a mut W;
}

BitWriter methods as a trait.

Provided Associated Constants

const WIDTH: u8 = 1u8

Required Methods

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl<'a> BWrite<'a, W<WpmrSpec>> for BitWriter<'a, WpmrSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<AbsrSpec>> for BitWriter<'a, AbsrSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<AimdrSpec>> for BitWriter<'a, AimdrSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<AimerSpec>> for BitWriter<'a, AimerSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<CodrSpec>> for BitWriter<'a, CodrSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<DifsrSpec>> for BitWriter<'a, DifsrSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<EsrSpec>> for BitWriter<'a, EsrSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<FellsrSpec>> for BitWriter<'a, FellsrSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<IdrSpec>> for BitWriter<'a, IdrSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<IerSpec>> for BitWriter<'a, IerSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<IfdrSpec>> for BitWriter<'a, IfdrSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<IferSpec>> for BitWriter<'a, IferSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<LsrSpec>> for BitWriter<'a, LsrSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<MddrSpec>> for BitWriter<'a, MddrSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<MderSpec>> for BitWriter<'a, MderSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<OdrSpec>> for BitWriter<'a, OdrSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<OdsrSpec>> for BitWriter<'a, OdsrSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<OerSpec>> for BitWriter<'a, OerSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<OwdrSpec>> for BitWriter<'a, OwdrSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<OwerSpec>> for BitWriter<'a, OwerSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<PdrSpec>> for BitWriter<'a, PdrSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<PerSpec>> for BitWriter<'a, PerSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<PudrSpec>> for BitWriter<'a, PudrSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<PuerSpec>> for BitWriter<'a, PuerSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<RehlsrSpec>> for BitWriter<'a, RehlsrSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<ScifsrSpec>> for BitWriter<'a, ScifsrSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<SodrSpec>> for BitWriter<'a, SodrSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<WpmrSpec>> for BitWriter<'a, WpmrSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<AbsrSpec>> for BitWriter<'a, AbsrSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<AimdrSpec>> for BitWriter<'a, AimdrSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<AimerSpec>> for BitWriter<'a, AimerSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<CodrSpec>> for BitWriter<'a, CodrSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<DifsrSpec>> for BitWriter<'a, DifsrSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<EsrSpec>> for BitWriter<'a, EsrSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<FellsrSpec>> for BitWriter<'a, FellsrSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<IdrSpec>> for BitWriter<'a, IdrSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<IerSpec>> for BitWriter<'a, IerSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<IfdrSpec>> for BitWriter<'a, IfdrSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<IferSpec>> for BitWriter<'a, IferSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<LsrSpec>> for BitWriter<'a, LsrSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<MddrSpec>> for BitWriter<'a, MddrSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<MderSpec>> for BitWriter<'a, MderSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<OdrSpec>> for BitWriter<'a, OdrSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<OdsrSpec>> for BitWriter<'a, OdsrSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<OerSpec>> for BitWriter<'a, OerSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<OwdrSpec>> for BitWriter<'a, OwdrSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<OwerSpec>> for BitWriter<'a, OwerSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<PdrSpec>> for BitWriter<'a, PdrSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<PerSpec>> for BitWriter<'a, PerSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<PudrSpec>> for BitWriter<'a, PudrSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<PuerSpec>> for BitWriter<'a, PuerSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<RehlsrSpec>> for BitWriter<'a, RehlsrSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<ScifsrSpec>> for BitWriter<'a, ScifsrSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<SodrSpec>> for BitWriter<'a, SodrSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<WpmrSpec>> for BitWriter<'a, WpmrSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<AbsrSpec>> for BitWriter<'a, AbsrSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<AimdrSpec>> for BitWriter<'a, AimdrSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<AimerSpec>> for BitWriter<'a, AimerSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<CodrSpec>> for BitWriter<'a, CodrSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<DifsrSpec>> for BitWriter<'a, DifsrSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<EsrSpec>> for BitWriter<'a, EsrSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<FellsrSpec>> for BitWriter<'a, FellsrSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<IdrSpec>> for BitWriter<'a, IdrSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<IerSpec>> for BitWriter<'a, IerSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<IfdrSpec>> for BitWriter<'a, IfdrSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<IferSpec>> for BitWriter<'a, IferSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<LsrSpec>> for BitWriter<'a, LsrSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<MddrSpec>> for BitWriter<'a, MddrSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<MderSpec>> for BitWriter<'a, MderSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<OdrSpec>> for BitWriter<'a, OdrSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<OdsrSpec>> for BitWriter<'a, OdsrSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<OerSpec>> for BitWriter<'a, OerSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<OwdrSpec>> for BitWriter<'a, OwdrSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<OwerSpec>> for BitWriter<'a, OwerSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<PdrSpec>> for BitWriter<'a, PdrSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<PerSpec>> for BitWriter<'a, PerSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<PudrSpec>> for BitWriter<'a, PudrSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<PuerSpec>> for BitWriter<'a, PuerSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<RehlsrSpec>> for BitWriter<'a, RehlsrSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<ScifsrSpec>> for BitWriter<'a, ScifsrSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<SodrSpec>> for BitWriter<'a, SodrSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<WpmrSpec>> for BitWriter<'a, WpmrSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<AbsrSpec>> for BitWriter<'a, AbsrSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<AimdrSpec>> for BitWriter<'a, AimdrSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<AimerSpec>> for BitWriter<'a, AimerSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<CodrSpec>> for BitWriter<'a, CodrSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<DifsrSpec>> for BitWriter<'a, DifsrSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<EsrSpec>> for BitWriter<'a, EsrSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<FellsrSpec>> for BitWriter<'a, FellsrSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<IdrSpec>> for BitWriter<'a, IdrSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<IerSpec>> for BitWriter<'a, IerSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<IfdrSpec>> for BitWriter<'a, IfdrSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<IferSpec>> for BitWriter<'a, IferSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<LsrSpec>> for BitWriter<'a, LsrSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<MddrSpec>> for BitWriter<'a, MddrSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<MderSpec>> for BitWriter<'a, MderSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<OdrSpec>> for BitWriter<'a, OdrSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<OdsrSpec>> for BitWriter<'a, OdsrSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<OerSpec>> for BitWriter<'a, OerSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<OwdrSpec>> for BitWriter<'a, OwdrSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<OwerSpec>> for BitWriter<'a, OwerSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<PdrSpec>> for BitWriter<'a, PdrSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<PerSpec>> for BitWriter<'a, PerSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<PudrSpec>> for BitWriter<'a, PudrSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<PuerSpec>> for BitWriter<'a, PuerSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<RehlsrSpec>> for BitWriter<'a, RehlsrSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<ScifsrSpec>> for BitWriter<'a, ScifsrSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<SodrSpec>> for BitWriter<'a, SodrSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

impl<'a> BWrite<'a, W<WpmrSpec>> for BitWriter<'a, WpmrSpec>

const WIDTH: u8 = 1u8

fn width(&self) -> u8

fn offset(&self) -> u8

fn bit(self, value: bool) -> &'a mut W

fn variant(self, variant: bool) -> &'a mut W

fn set_bit(self) -> &'a mut W

fn clear_bit(self) -> &'a mut W

Implementors