Enum Endianness 

pub enum Endianness {
    Little,
    Big,
}

Endianness. Either big or little.

Variants

Little

Little endian.

Big

Big endian.

Implementations

impl Endianness

pub fn native() -> Endianness

Returns the native endianness of the CPU.

Examples found in repository

examples/custom_data_type_fixed_size.rs (line 222)

    fn encode<'a>(
        &self,
        bytes: std::borrow::Cow<'a, [u8]>,
        endianness: Option<zarrs_metadata::Endianness>,
    ) -> Result<std::borrow::Cow<'a, [u8]>, BytesCodecEndiannessMissingError> {
        if let Some(endianness) = endianness {
            if endianness != Endianness::native() {
                let mut bytes = bytes.into_owned();
                for bytes in bytes
                    .as_chunks_mut::<{ size_of::<CustomDataTypeFixedSizeBytes>() }>()
                    .0
                {
                    let value = CustomDataTypeFixedSizeElement::from_ne_bytes(bytes);
                    if endianness == Endianness::Little {
                        *bytes = value.to_le_bytes();
                    } else {
                        *bytes = value.to_be_bytes();
                    }
                }
                Ok(Cow::Owned(bytes))
            } else {
                Ok(bytes)
            }
        } else {
            Err(BytesCodecEndiannessMissingError)
        }
    }

    fn decode<'a>(
        &self,
        bytes: std::borrow::Cow<'a, [u8]>,
        endianness: Option<zarrs_metadata::Endianness>,
    ) -> Result<std::borrow::Cow<'a, [u8]>, BytesCodecEndiannessMissingError> {
        if let Some(endianness) = endianness {
            if endianness != Endianness::native() {
                let mut bytes = bytes.into_owned();
                for bytes in bytes
                    .as_chunks_mut::<{ size_of::<u64>() + size_of::<f32>() }>()
                    .0
                {
                    let value = if endianness == Endianness::Little {
                        CustomDataTypeFixedSizeElement::from_le_bytes(bytes)
                    } else {
                        CustomDataTypeFixedSizeElement::from_be_bytes(bytes)
                    };
                    *bytes = value.to_ne_bytes();
                }
                Ok(Cow::Owned(bytes))
            } else {
                Ok(bytes)
            }
        } else {
            Err(BytesCodecEndiannessMissingError)
        }
    }

pub fn is_native(self) -> bool

Return true if the endianness matches the endianness of the CPU.

Trait Implementations

impl Clone for Endianness

fn clone(&self) -> Endianness

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Endianness

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Endianness

fn deserialize<__D>( __deserializer: __D, ) -> Result<Endianness, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Endianness

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

Formats the value using the given formatter.

impl PartialEq for Endianness

fn eq(&self, other: &Endianness) -> bool

Tests for self and other values to be equal, and is used by ==.

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 Serialize for Endianness

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for Endianness

impl Eq for Endianness

impl StructuralPartialEq for Endianness