Trait zerovec::ule::ULE[−][src]

pub unsafe trait ULE where
    Self: Sized,
    Self: Copy + 'static, {
    type Error: Display;
    fn validate_byte_slice(bytes: &[u8]) -> Result<(), Self::Error>;

    fn parse_byte_slice(bytes: &[u8]) -> Result<&[Self], Self::Error> { ... }

    unsafe fn from_byte_slice_unchecked(bytes: &[u8]) -> &[Self]ⓘ
Notable traits for &'_ mut [u8]
impl<'_> Write for &'_ mut [u8]impl<'_> Read for &'_ [u8]
 { ... }

    fn as_byte_slice(slice: &[Self]) -> &[u8]ⓘ
Notable traits for &'_ mut [u8]
impl<'_> Write for &'_ mut [u8]impl<'_> Read for &'_ [u8]
 { ... }
}
Expand description

Fixed-width, byte-aligned data that can be cast to and from a little-endian byte slice.

Types that are not fixed-width can implement VarULE instead.

“ULE” stands for “Unaligned little-endian”

Safety

Safety checklist for ULE:

  1. The type must not include any uninitialized or padding bytes.
  2. The impl of ULE::validate_byte_slice() must return an error if the given byte slice would not represent a valid slice of this type.
  3. The impl of ULE::validate_byte_slice() must return an error if the given byte slice cannot be used in its entirety (if its length is not a multiple of size_of::<Self>()).
  4. All other methods must be left with their default impl, or else implemented according to their respective safety guidelines.
  5. Acknowledge the following note about the equality invariant.

Equality invariant

A non-safety invariant is that if Self implements PartialEq, the it must be logically equivalent to byte equality on Self::as_byte_slice().

It may be necessary to introduce a “canonical form” of the ULE if logical equality does not equal byte equality. In such a case, Self::validate_byte_slice() should return an error for any values that are not in canonical form. For example, the decimal strings “1.23e4” and “12.3e3” are logically equal, but not byte-for-byte equal, so we could define a canonical form where only a single digit is allowed before ..

Failure to follow this invariant will cause surprising behavior in PartialEq, which may result in unpredictable operations on ZeroVec, VarZeroVec, and ZeroMap.

Associated Types

The error that occurs if a byte array is not valid for this ULE.

Required methods

Validates a byte slice, &[u8].

If Self is not well-defined for all possible bit values, the bytes should be validated. If the bytes can be transmuted, in their entirety, to a valid slice of Self, then Ok should be returned; otherwise, Self::Error should be returned.

Provided methods

Parses a byte slice, &[u8], and return it as &[Self] with the same lifetime.

If Self is not well-defined for all possible bit values, the bytes should be validated, and an error should be returned in the same cases as Self::validate_byte_slice().

The default implementation executes Self::validate_byte_slice() followed by Self::from_byte_slice_unchecked.

Note: The following equality should hold: bytes.len() % size_of::<Self>() == 0. This means that the returned slice can span the entire byte slice.

Takes a byte slice, &[u8], and return it as &[Self] with the same lifetime, assuming that this byte slice has previously been run through Self::parse_byte_slice() with success.

The default implementation performs a pointer cast to the same region of memory.

Safety
Callers

Callers of this method must take care to ensure that bytes was previously passed through Self::validate_byte_slice() with success (and was not changed since then).

Implementors

Implementations of this method may call unsafe functions to cast the pointer to the correct type, assuming the “Callers” invariant above.

Keep in mind that &[Self] and &[u8] may have different lengths.

Safety checklist:

  1. This method must return the same result as Self::parse_byte_slice().
  2. This method must return a slice to the same region of memory as the argument.

Given &[Self], returns a &[u8] with the same lifetime.

The default implementation performs a pointer cast to the same region of memory.

Safety

Implementations of this method should call potentially unsafe functions to cast the pointer to the correct type.

Keep in mind that &[Self] and &[u8] may have different lengths.

Implementations on Foreign Types

Implementors