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;
}

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.

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 Box<CStr>

Available on crate feature alloc only.

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

where R: BitRead, E: Endianness,

impl<Ctx> BitDecode<Ctx> for CString

Available on crate feature alloc only.

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 Box<str>

Available on crate feature alloc only.

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

where R: BitRead, E: Endianness,

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

Available on crate feature alloc only.

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>,

Available on crate feature alloc only.

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,

Available on crate feature std only.

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 Box<[T]>

where T: BitDecode<Ctx>,

Available on crate feature alloc only.

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

where R: BitRead, E: Endianness,

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

where T: BitDecode<Ctx> + Ord,

Available on crate feature alloc only.

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,

Available on crate feature alloc only.

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>,

Available on crate feature alloc only.

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>,

Available on crate feature alloc only.

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>,

Available on crate feature alloc only.

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,

Available on crate feature std only.

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>,

Available on crate feature alloc only.

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>,

Available on crate feature alloc only.

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>,

Available on crate feature alloc only.

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 Box<str>

where Tag: TryInto<usize>,

Available on crate feature alloc only.

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

where R: BitRead, E: Endianness,

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

where Tag: TryInto<usize>,

Available on crate feature alloc only.

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>,

Available on crate feature alloc only.

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,

Available on crate feature std only.

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 Box<[T]>

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

Available on crate feature alloc only.

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>,

Available on crate feature alloc only.

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>,

Available on crate feature alloc only.

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>,

Available on crate feature alloc only.

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>,

Available on crate feature alloc only.

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>,

Available on crate feature alloc only.

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,

Available on crate feature std only.

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

where R: BitRead, E: Endianness,

Implementors