Type Alias UnalignedView

Source
pub type UnalignedView<B, T> = Ref<B, Unalign<T>>;

Aliased Type§

struct UnalignedView<B, T>(/* private fields */);

Implementations

§

impl<'a, B, T> Ref<B, T>
where B: 'a + IntoByteSlice<'a>, T: FromBytes + KnownLayout + Immutable + ?Sized,

pub fn into_ref(r: Ref<B, T>) -> &'a T

Converts this Ref into a reference.

into_ref consumes the Ref, and returns a reference to T.

Note: this is an associated function, which means that you have to call it as Ref::into_ref(r) instead of r.into_ref(). This is so that there is no conflict with a method on the inner type.

§

impl<'a, B, T> Ref<B, T>
where B: 'a + IntoByteSliceMut<'a>, T: FromBytes + IntoBytes + KnownLayout + ?Sized,

pub fn into_mut(r: Ref<B, T>) -> &'a mut T

Converts this Ref into a mutable reference.

into_mut consumes the Ref, and returns a mutable reference to T.

Note: this is an associated function, which means that you have to call it as Ref::into_mut(r) instead of r.into_mut(). This is so that there is no conflict with a method on the inner type.

§

impl<B, T> Ref<B, T>
where B: ByteSlice, T: ?Sized,

pub fn bytes(r: &Ref<B, T>) -> &[u8]

Gets the underlying bytes.

Note: this is an associated function, which means that you have to call it as Ref::bytes(r) instead of r.bytes(). This is so that there is no conflict with a method on the inner type.

§

impl<B, T> Ref<B, T>
where B: ByteSlice, T: FromBytes,

pub fn read(r: &Ref<B, T>) -> T

Reads a copy of T.

Note: this is an associated function, which means that you have to call it as Ref::read(r) instead of r.read(). This is so that there is no conflict with a method on the inner type.

§

impl<B, T> Ref<B, T>
where B: ByteSlice, T: KnownLayout + Immutable + ?Sized,

pub fn from_bytes( source: B, ) -> Result<Ref<B, T>, ConvertError<AlignmentError<B, T>, SizeError<B, T>, Infallible>>

Constructs a Ref from a byte slice.

If the length of source is not a valid size of T, or if source is not appropriately aligned for T, this returns Err. If T: Unaligned, you can infallibly discard the alignment error.

T may be a sized type, a slice, or a slice DST.

§Compile-Time Assertions

This method cannot yet be used on unsized types whose dynamically-sized component is zero-sized. Attempting to use this method on such types results in a compile-time assertion error; e.g.:

use zerocopy::*;

#[derive(Immutable, KnownLayout)]
#[repr(C)]
struct ZSTy {
    leading_sized: u16,
    trailing_dst: [()],
}

let _ = Ref::<_, ZSTy>::from_bytes(&b"UU"[..]); // ⚠ Compile Error!
§

impl<B, T> Ref<B, T>
where B: ByteSlice, T: KnownLayout<PointerMetadata = usize> + Immutable + ?Sized,

pub fn from_bytes_with_elems( source: B, count: usize, ) -> Result<Ref<B, T>, ConvertError<AlignmentError<B, T>, SizeError<B, T>, Infallible>>

Constructs a Ref from the given bytes with DST length equal to count without copying.

This method attempts to return a Ref to the prefix of source interpreted as a T with count trailing elements, and a reference to the remaining bytes. If the length of source is not equal to the size of Self with count elements, or if source is not appropriately aligned, this returns Err. If T: Unaligned, you can infallibly discard the alignment error.

§Compile-Time Assertions

This method cannot yet be used on unsized types whose dynamically-sized component is zero-sized. Attempting to use this method on such types results in a compile-time assertion error; e.g.:

use zerocopy::*;

#[derive(Immutable, KnownLayout)]
#[repr(C)]
struct ZSTy {
    leading_sized: u16,
    trailing_dst: [()],
}

let _ = Ref::<_, ZSTy>::from_bytes_with_elems(&b"UU"[..], 42); // ⚠ Compile Error!
§

impl<B, T> Ref<B, T>
where B: ByteSliceMut, T: ?Sized,

pub fn bytes_mut(r: &mut Ref<B, T>) -> &mut [u8]

Gets the underlying bytes mutably.

Note: this is an associated function, which means that you have to call it as Ref::bytes_mut(r) instead of r.bytes_mut(). This is so that there is no conflict with a method on the inner type.

§

impl<B, T> Ref<B, T>
where B: ByteSliceMut, T: IntoBytes,

pub fn write(r: &mut Ref<B, T>, t: T)

Writes the bytes of t and then forgets t.

Note: this is an associated function, which means that you have to call it as Ref::write(r, t) instead of r.write(t). This is so that there is no conflict with a method on the inner type.

§

impl<B, T> Ref<B, T>
where B: SplitByteSlice, T: KnownLayout + Immutable + ?Sized,

pub fn from_prefix( source: B, ) -> Result<(Ref<B, T>, B), ConvertError<AlignmentError<B, T>, SizeError<B, T>, Infallible>>

Constructs a Ref from the prefix of a byte slice.

This method computes the largest possible size of T that can fit in the leading bytes of source, then attempts to return both a Ref to those bytes, and a reference to the remaining bytes. If there are insufficient bytes, or if source is not appropriately aligned, this returns Err. If T: Unaligned, you can infallibly discard the alignment error.

T may be a sized type, a slice, or a slice DST.

§Compile-Time Assertions

This method cannot yet be used on unsized types whose dynamically-sized component is zero-sized. Attempting to use this method on such types results in a compile-time assertion error; e.g.:

use zerocopy::*;

#[derive(Immutable, KnownLayout)]
#[repr(C)]
struct ZSTy {
    leading_sized: u16,
    trailing_dst: [()],
}

let _ = Ref::<_, ZSTy>::from_prefix(&b"UU"[..]); // ⚠ Compile Error!

pub fn from_suffix( source: B, ) -> Result<(B, Ref<B, T>), ConvertError<AlignmentError<B, T>, SizeError<B, T>, Infallible>>

Constructs a Ref from the suffix of a byte slice.

This method computes the largest possible size of T that can fit in the trailing bytes of source, then attempts to return both a Ref to those bytes, and a reference to the preceding bytes. If there are insufficient bytes, or if that suffix of source is not appropriately aligned, this returns Err. If T: Unaligned, you can infallibly discard the alignment error.

T may be a sized type, a slice, or a slice DST.

§Compile-Time Assertions

This method cannot yet be used on unsized types whose dynamically-sized component is zero-sized. Attempting to use this method on such types results in a compile-time assertion error; e.g.:

use zerocopy::*;

#[derive(Immutable, KnownLayout)]
#[repr(C)]
struct ZSTy {
    leading_sized: u16,
    trailing_dst: [()],
}

let _ = Ref::<_, ZSTy>::from_suffix(&b"UU"[..]); // ⚠ Compile Error!
§

impl<B, T> Ref<B, T>
where B: SplitByteSlice, T: KnownLayout<PointerMetadata = usize> + Immutable + ?Sized,

pub fn from_prefix_with_elems( source: B, count: usize, ) -> Result<(Ref<B, T>, B), ConvertError<AlignmentError<B, T>, SizeError<B, T>, Infallible>>

Constructs a Ref from the prefix of the given bytes with DST length equal to count without copying.

This method attempts to return a Ref to the prefix of source interpreted as a T with count trailing elements, and a reference to the remaining bytes. If there are insufficient bytes, or if source is not appropriately aligned, this returns Err. If T: Unaligned, you can infallibly discard the alignment error.

§Compile-Time Assertions

This method cannot yet be used on unsized types whose dynamically-sized component is zero-sized. Attempting to use this method on such types results in a compile-time assertion error; e.g.:

use zerocopy::*;

#[derive(Immutable, KnownLayout)]
#[repr(C)]
struct ZSTy {
    leading_sized: u16,
    trailing_dst: [()],
}

let _ = Ref::<_, ZSTy>::from_prefix_with_elems(&b"UU"[..], 42); // ⚠ Compile Error!

pub fn from_suffix_with_elems( source: B, count: usize, ) -> Result<(B, Ref<B, T>), ConvertError<AlignmentError<B, T>, SizeError<B, T>, Infallible>>

Constructs a Ref from the suffix of the given bytes with DST length equal to count without copying.

This method attempts to return a Ref to the suffix of source interpreted as a T with count trailing elements, and a reference to the preceding bytes. If there are insufficient bytes, or if that suffix of source is not appropriately aligned, this returns Err. If T: Unaligned, you can infallibly discard the alignment error.

§Compile-Time Assertions

This method cannot yet be used on unsized types whose dynamically-sized component is zero-sized. Attempting to use this method on such types results in a compile-time assertion error; e.g.:

use zerocopy::*;

#[derive(Immutable, KnownLayout)]
#[repr(C)]
struct ZSTy {
    leading_sized: u16,
    trailing_dst: [()],
}

let _ = Ref::<_, ZSTy>::from_suffix_with_elems(&b"UU"[..], 42); // ⚠ Compile Error!

Trait Implementations

§

impl<B, T> Clone for Ref<B, T>
where B: CloneableByteSlice + Clone, T: ?Sized,

§

fn clone(&self) -> Ref<B, T>

Returns a copy of the value. Read more
1.0.0 · Source§

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more
§

impl<T, B> Debug for Ref<B, T>
where B: ByteSlice, T: FromBytes + Debug + KnownLayout + Immutable + ?Sized,

§

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter. Read more
§

impl<B, T> Deref for Ref<B, T>
where B: ByteSlice, T: FromBytes + KnownLayout + Immutable + ?Sized,

§

type Target = T

The resulting type after dereferencing.
§

fn deref(&self) -> &T

Dereferences the value.
§

impl<B, T> DerefMut for Ref<B, T>
where B: ByteSliceMut, T: FromBytes + IntoBytes + KnownLayout + Immutable + ?Sized,

§

fn deref_mut(&mut self) -> &mut T

Mutably dereferences the value.
§

impl<T, B> Display for Ref<B, T>
where B: ByteSlice, T: FromBytes + Display + KnownLayout + Immutable + ?Sized,

§

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter. Read more
§

impl<T, B> Ord for Ref<B, T>
where B: ByteSlice, T: FromBytes + Ord + KnownLayout + Immutable + ?Sized,

§

fn cmp(&self, other: &Ref<B, T>) -> Ordering

This method returns an Ordering between self and other. Read more
1.21.0 · Source§

fn max(self, other: Self) -> Self
where Self: Sized,

Compares and returns the maximum of two values. Read more
1.21.0 · Source§

fn min(self, other: Self) -> Self
where Self: Sized,

Compares and returns the minimum of two values. Read more
1.50.0 · Source§

fn clamp(self, min: Self, max: Self) -> Self
where Self: Sized,

Restrict a value to a certain interval. Read more
§

impl<T, B> PartialEq for Ref<B, T>
where B: ByteSlice, T: FromBytes + PartialEq + KnownLayout + Immutable + ?Sized,

§

fn eq(&self, other: &Ref<B, T>) -> bool

Tests for self and other values to be equal, and is used by ==.
1.0.0 · Source§

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
§

impl<T, B> PartialOrd for Ref<B, T>
where B: ByteSlice, T: FromBytes + PartialOrd + KnownLayout + Immutable + ?Sized,

§

fn partial_cmp(&self, other: &Ref<B, T>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists. Read more
1.0.0 · Source§

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator. Read more
1.0.0 · Source§

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator. Read more
1.0.0 · Source§

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator. Read more
1.0.0 · Source§

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator. Read more
§

impl<B, T> Copy for Ref<B, T>
where B: CopyableByteSlice + Copy, T: ?Sized,

§

impl<T, B> Eq for Ref<B, T>
where B: ByteSlice, T: FromBytes + Eq + KnownLayout + Immutable + ?Sized,