Trait TryFromBytes 

pub trait TryFromBytes: Sized {
    type Bytes: ByteArray;
    type Error;

    const PREFERS_LE: bool = true;

    // Required methods
    fn try_from_le_bytes(bytes: Self::Bytes) -> Result<Self, Self::Error>;
    fn try_from_be_bytes(bytes: Self::Bytes) -> Result<Self, Self::Error>;

    // Provided methods
    fn try_from_bytes(bytes: Self::Bytes) -> Result<Self, Self::Error> { ... }
    fn try_from_ne_bytes(bytes: Self::Bytes) -> Result<Self, Self::Error> { ... }
}

Try to create a value from its representation as a packed stack byte array of a fixed size.

Most times, the method try_from_bytes should be used, as it ensures consistency by respecting the byte order set by the PREFERS_LE associated constant.

Provided Associated Constants

const PREFERS_LE: bool = true

Is it preferred to represent this type as bytes in the little endian order?

Required Associated Types

type Bytes: ByteArray

A byte array which can store a packed representation of this type.

type Error

A type containing the failure of creating a value of the type from bytes.

Required Methods

fn try_from_le_bytes(bytes: Self::Bytes) -> Result<Self, Self::Error>

Try to create a value of this type from its representation as a byte array in little endian.

fn try_from_be_bytes(bytes: Self::Bytes) -> Result<Self, Self::Error>

Try to create a value of this type from its representation as a byte array in big endian.

Provided Methods

fn try_from_bytes(bytes: Self::Bytes) -> Result<Self, Self::Error>

Try to create a value of this type from its representation as a byte array in the preferred byte order, set in the associated constant PREFERS_LE.

fn try_from_ne_bytes(bytes: Self::Bytes) -> Result<Self, Self::Error>

Try to create a value of this type from its representation as a byte array in native endian.

As the target platform’s native endianness is used, portable code likely wants to use try_from_le_bytes or try_from_be_bytes, as appropriate instead.

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 TryFromBytes for bool

type Bytes = [u8; 1]

type Error = InvalidBool

fn try_from_le_bytes(bytes: Self::Bytes) -> Result<Self, InvalidBool>

fn try_from_be_bytes(bytes: Self::Bytes) -> Result<Self, InvalidBool>

impl TryFromBytes for char

type Bytes = [u8; 4]

type Error = InvalidChar

fn try_from_le_bytes(bytes: Self::Bytes) -> Result<Self, InvalidChar>

fn try_from_be_bytes(bytes: Self::Bytes) -> Result<Self, InvalidChar>

Implementors

impl<B: ByteArray, T: FromBytes<Bytes = B>> TryFromBytes for T

type Bytes = B

type Error = Infallible