Trait AbstractBits

pub trait AbstractBits {
    const MIN_BITS: usize;
    const MAX_BITS: usize;

    // Required methods
    fn write_abstract_bits(
        &self,
        writer: &mut BitWriter<'_>,
    ) -> Result<(), ToBytesError>;
    fn read_abstract_bits(
        reader: &mut BitReader<'_>,
    ) -> Result<Self, FromBytesError>
       where Self: Sized;

    // Provided methods
    fn to_abstract_bits(&self) -> Result<Vec<u8>, ToBytesError> { ... }
    fn from_abstract_bits(bytes: &[u8]) -> Result<Self, FromBytesError>
       where Self: Sized { ... }
}

Required Associated Constants

const MIN_BITS: usize

const MAX_BITS: usize

Required Methods

fn write_abstract_bits( &self, writer: &mut BitWriter<'_>, ) -> Result<(), ToBytesError>

To get the amount written use BitWriter::bits_written or BitWriter::bytes_written

fn read_abstract_bits( reader: &mut BitReader<'_>, ) -> Result<Self, FromBytesError>

where Self: Sized,

To get the amount read use BitReader::bits_read or BitReader::bytes_read

Provided Methods

fn to_abstract_bits(&self) -> Result<Vec<u8>, ToBytesError>

fn from_abstract_bits(bytes: &[u8]) -> Result<Self, FromBytesError>

where Self: Sized,

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 AbstractBits for bool

const MIN_BITS: usize = 1usize

const MAX_BITS: usize = 1usize

fn write_abstract_bits( &self, writer: &mut BitWriter<'_>, ) -> Result<(), ToBytesError>

fn read_abstract_bits( reader: &mut BitReader<'_>, ) -> Result<Self, FromBytesError>

where Self: Sized,

impl AbstractBits for u8

const MIN_BITS: usize = 8usize

const MAX_BITS: usize = 8usize

fn write_abstract_bits( &self, writer: &mut BitWriter<'_>, ) -> Result<(), ToBytesError>

fn read_abstract_bits( reader: &mut BitReader<'_>, ) -> Result<Self, FromBytesError>

where Self: Sized,

impl AbstractBits for u16

const MIN_BITS: usize = 16usize

const MAX_BITS: usize = 16usize

fn write_abstract_bits( &self, writer: &mut BitWriter<'_>, ) -> Result<(), ToBytesError>

fn read_abstract_bits( reader: &mut BitReader<'_>, ) -> Result<Self, FromBytesError>

where Self: Sized,

impl AbstractBits for u32

const MIN_BITS: usize = 32usize

const MAX_BITS: usize = 32usize

fn write_abstract_bits( &self, writer: &mut BitWriter<'_>, ) -> Result<(), ToBytesError>

fn read_abstract_bits( reader: &mut BitReader<'_>, ) -> Result<Self, FromBytesError>

where Self: Sized,

impl AbstractBits for u64

const MIN_BITS: usize = 64usize

const MAX_BITS: usize = 64usize

fn write_abstract_bits( &self, writer: &mut BitWriter<'_>, ) -> Result<(), ToBytesError>

fn read_abstract_bits( reader: &mut BitReader<'_>, ) -> Result<Self, FromBytesError>

where Self: Sized,

impl<const N: usize> AbstractBits for UInt<u8, N>

const MIN_BITS: usize = Self::BITS

const MAX_BITS: usize = Self::BITS

fn write_abstract_bits( &self, writer: &mut BitWriter<'_>, ) -> Result<(), ToBytesError>

fn read_abstract_bits( reader: &mut BitReader<'_>, ) -> Result<Self, FromBytesError>

where Self: Sized,

impl<const N: usize> AbstractBits for UInt<u16, N>

const MIN_BITS: usize = Self::BITS

const MAX_BITS: usize = Self::BITS

fn write_abstract_bits( &self, writer: &mut BitWriter<'_>, ) -> Result<(), ToBytesError>

fn read_abstract_bits( reader: &mut BitReader<'_>, ) -> Result<Self, FromBytesError>

where Self: Sized,

impl<const N: usize> AbstractBits for UInt<u32, N>

const MIN_BITS: usize = Self::BITS

const MAX_BITS: usize = Self::BITS

fn write_abstract_bits( &self, writer: &mut BitWriter<'_>, ) -> Result<(), ToBytesError>

fn read_abstract_bits( reader: &mut BitReader<'_>, ) -> Result<Self, FromBytesError>

where Self: Sized,

impl<const N: usize> AbstractBits for UInt<u64, N>

const MIN_BITS: usize = Self::BITS

const MAX_BITS: usize = Self::BITS

fn write_abstract_bits( &self, writer: &mut BitWriter<'_>, ) -> Result<(), ToBytesError>

fn read_abstract_bits( reader: &mut BitReader<'_>, ) -> Result<Self, FromBytesError>

where Self: Sized,

impl<const N: usize, T: AbstractBits + Sized> AbstractBits for [T; N]

const MIN_BITS: usize

const MAX_BITS: usize

fn write_abstract_bits( &self, writer: &mut BitWriter<'_>, ) -> Result<(), ToBytesError>

fn read_abstract_bits( reader: &mut BitReader<'_>, ) -> Result<Self, FromBytesError>

where Self: Sized,

Implementors