Trait BitDecode

pub trait BitDecode<Ctx = (), Tag = ()>: Sized {
    // Required method
    fn decode<R, E>(read: &mut R, ctx: &mut Ctx, tag: Tag) -> Result<Self>
       where R: BitRead,
             E: Endianness;

    // Provided method
    fn decode_bytes_ctx<E>(
        bytes: &[u8],
        byte_order: E,
        ctx: &mut Ctx,
        tag: Tag,
    ) -> Result<Self>
       where E: Endianness { ... }
}

A trait for bit-level decoding.

Required Methods

fn decode<R, E>(read: &mut R, ctx: &mut Ctx, tag: Tag) -> Result<Self>

where R: BitRead, E: Endianness,

Reads self from a stream.

Provided Methods

fn decode_bytes_ctx<E>( bytes: &[u8], byte_order: E, ctx: &mut Ctx, tag: Tag, ) -> Result<Self>

where E: Endianness,

Parses a new value from its raw byte representation with provided context and tag.

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<Ctx> BitDecode<Ctx> for bool

fn decode<R, E>(read: &mut R, _: &mut Ctx, (): ()) -> Result<Self>

where R: BitRead, E: Endianness,

impl<Ctx> BitDecode<Ctx> for f32

fn decode<R, E>(read: &mut R, _: &mut Ctx, (): ()) -> Result<Self>

where R: BitRead, E: Endianness,

impl<Ctx> BitDecode<Ctx> for f64

fn decode<R, E>(read: &mut R, _: &mut Ctx, (): ()) -> Result<Self>

where R: BitRead, E: Endianness,

impl<Ctx> BitDecode<Ctx> for i8

fn decode<R, E>(read: &mut R, _: &mut Ctx, (): ()) -> Result<Self>

where R: BitRead, E: Endianness,

impl<Ctx> BitDecode<Ctx> for i16

fn decode<R, E>(read: &mut R, _: &mut Ctx, (): ()) -> Result<Self>

where R: BitRead, E: Endianness,

impl<Ctx> BitDecode<Ctx> for i32

fn decode<R, E>(read: &mut R, _: &mut Ctx, (): ()) -> Result<Self>

where R: BitRead, E: Endianness,

impl<Ctx> BitDecode<Ctx> for i64

fn decode<R, E>(read: &mut R, _: &mut Ctx, (): ()) -> Result<Self>

where R: BitRead, E: Endianness,

impl<Ctx> BitDecode<Ctx> for i128

fn decode<R, E>(read: &mut R, _: &mut Ctx, (): ()) -> Result<Self>

where R: BitRead, E: Endianness,

impl<Ctx> BitDecode<Ctx> for isize

fn decode<R, E>(read: &mut R, _: &mut Ctx, (): ()) -> Result<Self>

where R: BitRead, E: Endianness,

impl<Ctx> BitDecode<Ctx> for u8

fn decode<R, E>(read: &mut R, _: &mut Ctx, (): ()) -> Result<Self>

where R: BitRead, E: Endianness,

impl<Ctx> BitDecode<Ctx> for u16

fn decode<R, E>(read: &mut R, _: &mut Ctx, (): ()) -> Result<Self>

where R: BitRead, E: Endianness,

impl<Ctx> BitDecode<Ctx> for u32

fn decode<R, E>(read: &mut R, _: &mut Ctx, (): ()) -> Result<Self>

where R: BitRead, E: Endianness,

impl<Ctx> BitDecode<Ctx> for u64

fn decode<R, E>(read: &mut R, _: &mut Ctx, (): ()) -> Result<Self>

where R: BitRead, E: Endianness,

impl<Ctx> BitDecode<Ctx> for u128

fn decode<R, E>(read: &mut R, _: &mut Ctx, (): ()) -> Result<Self>

where R: BitRead, E: Endianness,

impl<Ctx> BitDecode<Ctx> for ()

fn decode<R, E>(_: &mut R, _: &mut Ctx, (): ()) -> Result<Self>

where R: BitRead, E: Endianness,

impl<Ctx> BitDecode<Ctx> for usize

fn decode<R, E>(read: &mut R, _: &mut Ctx, (): ()) -> Result<Self>

where R: BitRead, E: Endianness,

impl<Ctx> BitDecode<Ctx> for CString

fn decode<R, E>(read: &mut R, ctx: &mut Ctx, tag: ()) -> Result<Self>

where R: BitRead, E: Endianness,

impl<Ctx> BitDecode<Ctx> for PhantomPinned

fn decode<R, E>(_: &mut R, _: &mut Ctx, (): ()) -> Result<Self>

where R: BitRead, E: Endianness,

impl<Ctx> BitDecode<Ctx> for Ipv4Addr

fn decode<R, E>(read: &mut R, ctx: &mut Ctx, tag: ()) -> Result<Self>

where R: BitRead, E: Endianness,

impl<Ctx> BitDecode<Ctx> for Ipv6Addr

fn decode<R, E>(read: &mut R, ctx: &mut Ctx, tag: ()) -> Result<Self>

where R: BitRead, E: Endianness,

impl<Ctx> BitDecode<Ctx> for NonZeroI8

fn decode<R, E>(read: &mut R, _: &mut Ctx, (): ()) -> Result<Self>

where R: BitRead, E: Endianness,

impl<Ctx> BitDecode<Ctx> for NonZeroI16

fn decode<R, E>(read: &mut R, _: &mut Ctx, (): ()) -> Result<Self>

where R: BitRead, E: Endianness,

impl<Ctx> BitDecode<Ctx> for NonZeroI32

fn decode<R, E>(read: &mut R, _: &mut Ctx, (): ()) -> Result<Self>

where R: BitRead, E: Endianness,

impl<Ctx> BitDecode<Ctx> for NonZeroI64

fn decode<R, E>(read: &mut R, _: &mut Ctx, (): ()) -> Result<Self>

where R: BitRead, E: Endianness,

impl<Ctx> BitDecode<Ctx> for NonZeroI128

fn decode<R, E>(read: &mut R, _: &mut Ctx, (): ()) -> Result<Self>

where R: BitRead, E: Endianness,

impl<Ctx> BitDecode<Ctx> for NonZeroIsize

fn decode<R, E>(read: &mut R, _: &mut Ctx, (): ()) -> Result<Self>

where R: BitRead, E: Endianness,

impl<Ctx> BitDecode<Ctx> for NonZeroU8

fn decode<R, E>(read: &mut R, _: &mut Ctx, (): ()) -> Result<Self>

where R: BitRead, E: Endianness,

impl<Ctx> BitDecode<Ctx> for NonZeroU16

fn decode<R, E>(read: &mut R, _: &mut Ctx, (): ()) -> Result<Self>

where R: BitRead, E: Endianness,

impl<Ctx> BitDecode<Ctx> for NonZeroU32

fn decode<R, E>(read: &mut R, _: &mut Ctx, (): ()) -> Result<Self>

where R: BitRead, E: Endianness,

impl<Ctx> BitDecode<Ctx> for NonZeroU64

fn decode<R, E>(read: &mut R, _: &mut Ctx, (): ()) -> Result<Self>

where R: BitRead, E: Endianness,

impl<Ctx> BitDecode<Ctx> for NonZeroU128

fn decode<R, E>(read: &mut R, _: &mut Ctx, (): ()) -> Result<Self>

where R: BitRead, E: Endianness,

impl<Ctx> BitDecode<Ctx> for NonZeroUsize

fn decode<R, E>(read: &mut R, _: &mut Ctx, (): ()) -> Result<Self>

where R: BitRead, E: Endianness,

impl<Ctx> BitDecode<Ctx, Untagged> for String

fn decode<R, E>(read: &mut R, ctx: &mut Ctx, _: Untagged) -> Result<Self>

where R: BitRead, E: Endianness,

impl<Ctx, K, V> BitDecode<Ctx, Untagged> for BTreeMap<K, V>

where K: BitDecode<Ctx> + Ord, V: BitDecode<Ctx>,

fn decode<R, E>(read: &mut R, ctx: &mut Ctx, _: Untagged) -> Result<Self>

where R: BitRead, E: Endianness,

impl<Ctx, K, V, H> BitDecode<Ctx, Untagged> for HashMap<K, V, H>

where K: BitDecode<Ctx> + Eq + Hash, V: BitDecode<Ctx>, H: BuildHasher + Default,

fn decode<R, E>(read: &mut R, ctx: &mut Ctx, _: Untagged) -> Result<Self>

where R: BitRead, E: Endianness,

impl<Ctx, T> BitDecode<Ctx> for PhantomData<T>

fn decode<R, E>(_: &mut R, _: &mut Ctx, (): ()) -> Result<Self>

where R: BitRead, E: Endianness,

impl<Ctx, T> BitDecode<Ctx, Untagged> for BinaryHeap<T>

where T: BitDecode<Ctx> + Ord,

fn decode<R, E>(read: &mut R, ctx: &mut Ctx, _: Untagged) -> Result<Self>

where R: BitRead, E: Endianness,

impl<Ctx, T> BitDecode<Ctx, Untagged> for BTreeSet<T>

where T: BitDecode<Ctx> + Ord,

fn decode<R, E>(read: &mut R, ctx: &mut Ctx, _: Untagged) -> Result<Self>

where R: BitRead, E: Endianness,

impl<Ctx, T> BitDecode<Ctx, Untagged> for LinkedList<T>

where T: BitDecode<Ctx>,

fn decode<R, E>(read: &mut R, ctx: &mut Ctx, _: Untagged) -> Result<Self>

where R: BitRead, E: Endianness,

impl<Ctx, T> BitDecode<Ctx, Untagged> for VecDeque<T>

where T: BitDecode<Ctx>,

fn decode<R, E>(read: &mut R, ctx: &mut Ctx, _: Untagged) -> Result<Self>

where R: BitRead, E: Endianness,

impl<Ctx, T> BitDecode<Ctx, Untagged> for Vec<T>

where T: BitDecode<Ctx>,

fn decode<R, E>(read: &mut R, ctx: &mut Ctx, _: Untagged) -> Result<Self>

where R: BitRead, E: Endianness,

impl<Ctx, T, H> BitDecode<Ctx, Untagged> for HashSet<T, H>

where T: BitDecode<Ctx> + Hash + Eq, H: BuildHasher + Default,

fn decode<R, E>(read: &mut R, ctx: &mut Ctx, _: Untagged) -> Result<Self>

where R: BitRead, E: Endianness,

impl<Ctx, T, const N: usize> BitDecode<Ctx> for [T; N]

where T: BitDecode<Ctx>,

fn decode<R, E>(read: &mut R, ctx: &mut Ctx, (): ()) -> Result<Self>

where R: BitRead, E: Endianness,

impl<Ctx, Tag, T> BitDecode<Ctx, Tag> for (T₁, T₂, …, Tₙ)

where T: BitDecode<Ctx, Tag>,

This trait is implemented for tuples with up to 16 items.

fn decode<R, E>(read: &mut R, ctx: &mut Ctx, tag: Tag) -> Result<Self>

where R: BitRead, E: Endianness,

impl<Ctx, Tag, T> BitDecode<Ctx, Tag> for Box<T>

where T: BitDecode<Ctx, Tag>,

fn decode<R, E>(read: &mut R, ctx: &mut Ctx, tag: Tag) -> Result<Self>

where R: BitRead, E: Endianness,

impl<Ctx, Tag, T> BitDecode<Ctx, Tag> for Rc<T>

where T: BitDecode<Ctx, Tag>,

fn decode<R, E>(read: &mut R, ctx: &mut Ctx, tag: Tag) -> Result<Self>

where R: BitRead, E: Endianness,

impl<Ctx, Tag, T> BitDecode<Ctx, Tag> for Arc<T>

where T: BitDecode<Ctx, Tag>,

fn decode<R, E>(read: &mut R, ctx: &mut Ctx, tag: Tag) -> Result<Self>

where R: BitRead, E: Endianness,

impl<Ctx, Tag, T> BitDecode<Ctx, Tag> for Saturating<T>

where T: BitDecode<Ctx, Tag>,

fn decode<R, E>(read: &mut R, ctx: &mut Ctx, tag: Tag) -> Result<Self>

where R: BitRead, E: Endianness,

impl<Ctx, Tag, T> BitDecode<Ctx, Tag> for Wrapping<T>

where T: BitDecode<Ctx, Tag>,

fn decode<R, E>(read: &mut R, ctx: &mut Ctx, tag: Tag) -> Result<Self>

where R: BitRead, E: Endianness,

impl<Ctx, const C: u32> BitDecode<Ctx, Bits<C>> for bool

fn decode<R, E>(read: &mut R, _: &mut Ctx, _: Bits<C>) -> Result<Self>

where R: BitRead, E: Endianness,

impl<Ctx, const C: u32> BitDecode<Ctx, Bits<C>> for i8

fn decode<R, E>(read: &mut R, _: &mut Ctx, _: Bits<C>) -> Result<Self>

where R: BitRead, E: Endianness,

impl<Ctx, const C: u32> BitDecode<Ctx, Bits<C>> for i16

fn decode<R, E>(read: &mut R, _: &mut Ctx, _: Bits<C>) -> Result<Self>

where R: BitRead, E: Endianness,

impl<Ctx, const C: u32> BitDecode<Ctx, Bits<C>> for i32

fn decode<R, E>(read: &mut R, _: &mut Ctx, _: Bits<C>) -> Result<Self>

where R: BitRead, E: Endianness,

impl<Ctx, const C: u32> BitDecode<Ctx, Bits<C>> for i64

fn decode<R, E>(read: &mut R, _: &mut Ctx, _: Bits<C>) -> Result<Self>

where R: BitRead, E: Endianness,

impl<Ctx, const C: u32> BitDecode<Ctx, Bits<C>> for isize

fn decode<R, E>(read: &mut R, _: &mut Ctx, _: Bits<C>) -> Result<Self>

where R: BitRead, E: Endianness,

impl<Ctx, const C: u32> BitDecode<Ctx, Bits<C>> for u8

fn decode<R, E>(read: &mut R, _: &mut Ctx, _: Bits<C>) -> Result<Self>

where R: BitRead, E: Endianness,

impl<Ctx, const C: u32> BitDecode<Ctx, Bits<C>> for u16

fn decode<R, E>(read: &mut R, _: &mut Ctx, _: Bits<C>) -> Result<Self>

where R: BitRead, E: Endianness,

impl<Ctx, const C: u32> BitDecode<Ctx, Bits<C>> for u32

fn decode<R, E>(read: &mut R, _: &mut Ctx, _: Bits<C>) -> Result<Self>

where R: BitRead, E: Endianness,

impl<Ctx, const C: u32> BitDecode<Ctx, Bits<C>> for u64

fn decode<R, E>(read: &mut R, _: &mut Ctx, _: Bits<C>) -> Result<Self>

where R: BitRead, E: Endianness,

impl<Ctx, const C: u32> BitDecode<Ctx, Bits<C>> for usize

fn decode<R, E>(read: &mut R, _: &mut Ctx, _: Bits<C>) -> Result<Self>

where R: BitRead, E: Endianness,

impl<Ctx, const C: u32> BitDecode<Ctx, Bits<C>> for NonZeroI8

fn decode<R, E>(read: &mut R, _: &mut Ctx, _: Bits<C>) -> Result<Self>

where R: BitRead, E: Endianness,

impl<Ctx, const C: u32> BitDecode<Ctx, Bits<C>> for NonZeroI16

fn decode<R, E>(read: &mut R, _: &mut Ctx, _: Bits<C>) -> Result<Self>

where R: BitRead, E: Endianness,

impl<Ctx, const C: u32> BitDecode<Ctx, Bits<C>> for NonZeroI32

fn decode<R, E>(read: &mut R, _: &mut Ctx, _: Bits<C>) -> Result<Self>

where R: BitRead, E: Endianness,

impl<Ctx, const C: u32> BitDecode<Ctx, Bits<C>> for NonZeroIsize

fn decode<R, E>(read: &mut R, _: &mut Ctx, _: Bits<C>) -> Result<Self>

where R: BitRead, E: Endianness,

impl<Ctx, const C: u32> BitDecode<Ctx, Bits<C>> for NonZeroU8

fn decode<R, E>(read: &mut R, _: &mut Ctx, _: Bits<C>) -> Result<Self>

where R: BitRead, E: Endianness,

impl<Ctx, const C: u32> BitDecode<Ctx, Bits<C>> for NonZeroU16

fn decode<R, E>(read: &mut R, _: &mut Ctx, _: Bits<C>) -> Result<Self>

where R: BitRead, E: Endianness,

impl<Ctx, const C: u32> BitDecode<Ctx, Bits<C>> for NonZeroU32

fn decode<R, E>(read: &mut R, _: &mut Ctx, _: Bits<C>) -> Result<Self>

where R: BitRead, E: Endianness,

impl<Ctx, const C: u32> BitDecode<Ctx, Bits<C>> for NonZeroUsize

fn decode<R, E>(read: &mut R, _: &mut Ctx, _: Bits<C>) -> Result<Self>

where R: BitRead, E: Endianness,

impl<Tag, Ctx> BitDecode<Ctx, Tag<Tag>> for String

where Tag: TryInto<usize>,

fn decode<R, E>(read: &mut R, ctx: &mut Ctx, tag: Tag<Tag>) -> Result<Self>

where R: BitRead, E: Endianness,

impl<Tag, Ctx, K, V> BitDecode<Ctx, Tag<Tag>> for BTreeMap<K, V>

where K: BitDecode<Ctx> + Ord, V: BitDecode<Ctx>, Tag: TryInto<usize>,

fn decode<R, E>(read: &mut R, ctx: &mut Ctx, tag: Tag<Tag>) -> Result<Self>

where R: BitRead, E: Endianness,

impl<Tag, Ctx, K, V, H> BitDecode<Ctx, Tag<Tag>> for HashMap<K, V, H>

where K: BitDecode<Ctx> + Eq + Hash, V: BitDecode<Ctx>, Tag: TryInto<usize>, H: BuildHasher + Default,

fn decode<R, E>(read: &mut R, ctx: &mut Ctx, tag: Tag<Tag>) -> Result<Self>

where R: BitRead, E: Endianness,

impl<Tag, Ctx, T> BitDecode<Ctx, Tag<Tag>> for Option<T>

where T: BitDecode<Ctx>, Tag: TryInto<bool>,

fn decode<R, E>(read: &mut R, ctx: &mut Ctx, tag: Tag<Tag>) -> Result<Self>

where R: BitRead, E: Endianness,

impl<Tag, Ctx, T> BitDecode<Ctx, Tag<Tag>> for BinaryHeap<T>

where T: BitDecode<Ctx> + Ord, Tag: TryInto<usize>,

fn decode<R, E>(read: &mut R, ctx: &mut Ctx, tag: Tag<Tag>) -> Result<Self>

where R: BitRead, E: Endianness,

impl<Tag, Ctx, T> BitDecode<Ctx, Tag<Tag>> for BTreeSet<T>

where T: BitDecode<Ctx> + Ord, Tag: TryInto<usize>,

fn decode<R, E>(read: &mut R, ctx: &mut Ctx, tag: Tag<Tag>) -> Result<Self>

where R: BitRead, E: Endianness,

impl<Tag, Ctx, T> BitDecode<Ctx, Tag<Tag>> for LinkedList<T>

where T: BitDecode<Ctx>, Tag: TryInto<usize>,

fn decode<R, E>(read: &mut R, ctx: &mut Ctx, tag: Tag<Tag>) -> Result<Self>

where R: BitRead, E: Endianness,

impl<Tag, Ctx, T> BitDecode<Ctx, Tag<Tag>> for VecDeque<T>

where T: BitDecode<Ctx>, Tag: TryInto<usize>,

fn decode<R, E>(read: &mut R, ctx: &mut Ctx, tag: Tag<Tag>) -> Result<Self>

where R: BitRead, E: Endianness,

impl<Tag, Ctx, T> BitDecode<Ctx, Tag<Tag>> for Vec<T>

where T: BitDecode<Ctx>, Tag: TryInto<usize>,

fn decode<R, E>(read: &mut R, ctx: &mut Ctx, tag: Tag<Tag>) -> Result<Self>

where R: BitRead, E: Endianness,

impl<Tag, Ctx, T, H> BitDecode<Ctx, Tag<Tag>> for HashSet<T, H>

where T: BitDecode<Ctx> + Hash + Eq, Tag: TryInto<usize>, H: BuildHasher + Default,

fn decode<R, E>(read: &mut R, ctx: &mut Ctx, tag: Tag<Tag>) -> Result<Self>

where R: BitRead, E: Endianness,

Implementors