scalar_types

Enum Endian

Source
pub enum Endian<T> {
    Little(T),
    Big(T),
    Native(T),
}
Expand description

Endian This wraps a scalar value and specializes the value for a specific endianness. In doing so it allows us to tag endian sensitive content, and safely pass it between functions for applications that may require this.

Variants§

§

Little(T)

§

Big(T)

§

Native(T)

Implementations§

Source§

impl<T: Copy + Default> Endian<T>

Source

pub fn new(value: T) -> Endian<T>

All values are read in as “Endian::Native(T)”. It can be converted between to the desired endianness when needed.

use scalar_types::Endian;
fn main() {
    let scalar_types = Endian::new(42u16);
}
Source

pub fn from_stream<StreamT: Read>(stream: &mut StreamT) -> Option<Endian<T>>

UNSAFE

Reads and returns a Endian::Native(T) from any type that implements the std:io::Read trait. Advances the stream by the size of type T bytes.

Marked unsafe as it uses a raw pointer; however, the unsafe code is bounded by the size of the variable and should never reach unowned memory.

use scalar_types::Endian;
use std::io::{BufReader, Result};
 
fn read_some_stuff() -> Result<()> {
    let file = std::fs::File::open("file.bin")?;
    let mut reader = BufReader::new(file);
 
    let endian_value = Endian::<u32>::from_stream(&mut reader);
    let parsed_value = match endian_value {
        Some(value) => value,
        None => panic!("Unable to parse value from stream!")
    };
    Ok(())
 }
Source

pub fn as_big(&self) -> Option<T>

Attempts to cast the value held by Endian to a big endian value. Only fail condition is if get_native_endianness fails somehow

This shouldn’t really be possible; however, it does call unsafe. so, out of abundance of caution we include the fail condition.

use scalar_types::Endian;
fn main() {
    let scalar_types = Endian::new(42u16);
 
    let be_scalar_types = match scalar_types.as_big() {
        Some(value) => value,
        None => panic!("Unable to convert endianness!")
    };
}
Source

pub fn as_little(&self) -> Option<T>

Attempts to cast the value held by Endian to a little endian value. Only fail condition is if get_native_endianness fails somehow

This shouldn’t really be possible; however, it does call unsafe. so, out of abundance of caution we include the fail condition.

use scalar_types::Endian;
fn main() {
    let scalar_types = Endian::new(42u16);
 
    let le_scalar_types = match scalar_types.as_little() {
        Some(value) => value,
        None => panic!("Unable to convert endianness!")
    };
}
Source

pub fn as_native(&self) -> Option<T>

Attempts to cast the value held by Endian to a native endian value. Only fail condition is if get_native_endianness fails somehow

This shouldn’t really be possible; however, it does call unsafe. so, out of abundance of caution we include the fail condition.

use scalar_types::Endian;
fn main() {
    let scalar_types = Endian::new(42u16);
 
    let le_scalar_types = match scalar_types.as_native() {
        Some(value) => value,
        None => panic!("Unable to convert endianness!")
    };
}
Source

pub fn cast(&self, order: Endian<()>) -> Option<T>

Attempts to cast the value held by Endian to a specified endianness Only fail condition is if get_native_endianness fails somehow

This shouldn’t really be possible; however, it does call unsafe. so, out of abundance of caution we include the fail condition.

use scalar_types::Endian;
fn main() {
    let scalar_types = Endian::new(42u16);
 
    let le_scalar_types = scalar_types.cast(Endian::Little(()));
    let be_scalar_types = scalar_types.cast(Endian::Big(()));
    let ne_scalar_types = scalar_types.cast(Endian::Native(()));
}
Source

pub fn is_little(&self) -> bool

use scalar_types::Endian;
fn main() {
    let scalar_types = Endian::Little(42u16);
     
    assert_eq!(scalar_types.is_little(), true)
}
Source

pub fn is_big(&self) -> bool

use scalar_types::Endian;
fn main() {
    let scalar_types = Endian::Big(42u16);
     
    assert_eq!(scalar_types.is_big(), true)
}
Source

pub fn is_native(&self) -> bool

use scalar_types::Endian;
fn main() {
    // new() creates a Endian::Native
    let scalar_types = Endian::new(42u16);
    let ne_scalar_types = Endian::Native(42u16);
 
    assert_eq!(scalar_types.is_native(), true);
    assert_eq!(ne_scalar_types.is_native(), true);
}
Source

pub fn unpack(&self) -> T

Unpack the value as a native endian value. If casting fails, the default value for the type is returned instead Not recommended for production.

use scalar_types::Endian;
fn main() {
    // new() creates a Endian::Native
    let scalar_types = Endian::new(42u16);
     
    println!("the meaning of life the universe and everything: {}", scalar_types.unpack());
}

Output:

    "the meaning of life the universe and everything: 42"

Trait Implementations§

Source§

impl<T: Debug> Debug for Endian<T>

Source§

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

Formats the value using the given formatter. Read more
Source§

impl<T: PartialEq> PartialEq for Endian<T>

Source§

fn eq(&self, other: &Endian<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.
Source§

impl<T> StructuralPartialEq for Endian<T>

Auto Trait Implementations§

§

impl<T> Freeze for Endian<T>
where T: Freeze,

§

impl<T> RefUnwindSafe for Endian<T>
where T: RefUnwindSafe,

§

impl<T> Send for Endian<T>
where T: Send,

§

impl<T> Sync for Endian<T>
where T: Sync,

§

impl<T> Unpin for Endian<T>
where T: Unpin,

§

impl<T> UnwindSafe for Endian<T>
where T: UnwindSafe,

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

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

Mutably borrows from an owned value. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.