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.

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.

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.

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.

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::*;
# use zerocopy_derive::*;

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

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

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::*;
# use zerocopy_derive::*;

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

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

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.

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.

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::*;
# use zerocopy_derive::*;

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

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

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::*;
# use zerocopy_derive::*;

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

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

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::*;
# use zerocopy_derive::*;

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

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

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::*;
# use zerocopy_derive::*;

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

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