Trait Scalar 

pub trait Scalar: Sized + Default {
    // Required methods
    fn ty() -> Type;
    fn write<W: Write>(&self, w: &mut W) -> Result<usize>;
    fn read<R: Read>(&mut self, r: &mut R) -> Result<usize>;

    // Provided methods
    fn write_property<W: Write>(
        &self,
        property_id: u16,
        w: &mut W,
    ) -> Result<()> { ... }
    fn write_array<W: Write, A: Array<Item = Self>>(
        property_id: u16,
        arr: &A,
        w: &mut W,
    ) -> Result<()> { ... }
    fn read_property<R: Read>(
        &mut self,
        state: State<Bytes>,
        ty: u16,
        r: &mut R,
    ) -> Result<()> { ... }
    fn read_array<R: Read, A: Array<Item = Self>>(
        state: State<Bytes>,
        ty: u16,
        arr: &mut A,
        r: &mut R,
    ) -> Result<()> { ... }
}

Implemented by scalar values.

Required Methods

fn ty() -> Type

Type of scalar.

fn write<W: Write>(&self, w: &mut W) -> Result<usize>

Write to binary.

fn read<R: Read>(&mut self, r: &mut R) -> Result<usize>

Read from binary.

Provided Methods

fn write_property<W: Write>(&self, property_id: u16, w: &mut W) -> Result<()>

Writes property.

Examples found in repository

examples/test.rs (line 21)

fn scalar() {
    let filename = "assets/test-scalar.pool";

    let mut file = File::create(filename).unwrap();
    let data: Vec<f32> = vec![1.0, 2.0, 3.0];
    Scalar::write_array(ARRAY_PROPERTY, &data, &mut file).unwrap();
    (10 as u8).write_property(SINGLE_PROPERTY, &mut file).unwrap();
    drop(file);

    let mut file = File::open(filename).unwrap();

    let mut data: Vec<f32> = vec![];
    let mut val: u8 = 0;
    while let Ok((Some(state), ty, prop)) = State::read(&mut file) {
        match prop {
            ARRAY_PROPERTY => Scalar::read_array(state, ty, &mut data, &mut file).unwrap(),
            SINGLE_PROPERTY => val.read_property(state, ty, &mut file).unwrap(),
            _ => break,
        }
    }

    println!("=== Scalar ===");
    println!("data {:?}", data);
    println!("val {:?}", val);
}

fn write_array<W: Write, A: Array<Item = Self>>( property_id: u16, arr: &A, w: &mut W, ) -> Result<()>

Writes array.

Examples found in repository

examples/test.rs (line 20)

fn scalar() {
    let filename = "assets/test-scalar.pool";

    let mut file = File::create(filename).unwrap();
    let data: Vec<f32> = vec![1.0, 2.0, 3.0];
    Scalar::write_array(ARRAY_PROPERTY, &data, &mut file).unwrap();
    (10 as u8).write_property(SINGLE_PROPERTY, &mut file).unwrap();
    drop(file);

    let mut file = File::open(filename).unwrap();

    let mut data: Vec<f32> = vec![];
    let mut val: u8 = 0;
    while let Ok((Some(state), ty, prop)) = State::read(&mut file) {
        match prop {
            ARRAY_PROPERTY => Scalar::read_array(state, ty, &mut data, &mut file).unwrap(),
            SINGLE_PROPERTY => val.read_property(state, ty, &mut file).unwrap(),
            _ => break,
        }
    }

    println!("=== Scalar ===");
    println!("data {:?}", data);
    println!("val {:?}", val);
}

fn read_property<R: Read>( &mut self, state: State<Bytes>, ty: u16, r: &mut R, ) -> Result<()>

Reads property.

Examples found in repository

examples/test.rs (line 31)

fn scalar() {
    let filename = "assets/test-scalar.pool";

    let mut file = File::create(filename).unwrap();
    let data: Vec<f32> = vec![1.0, 2.0, 3.0];
    Scalar::write_array(ARRAY_PROPERTY, &data, &mut file).unwrap();
    (10 as u8).write_property(SINGLE_PROPERTY, &mut file).unwrap();
    drop(file);

    let mut file = File::open(filename).unwrap();

    let mut data: Vec<f32> = vec![];
    let mut val: u8 = 0;
    while let Ok((Some(state), ty, prop)) = State::read(&mut file) {
        match prop {
            ARRAY_PROPERTY => Scalar::read_array(state, ty, &mut data, &mut file).unwrap(),
            SINGLE_PROPERTY => val.read_property(state, ty, &mut file).unwrap(),
            _ => break,
        }
    }

    println!("=== Scalar ===");
    println!("data {:?}", data);
    println!("val {:?}", val);
}

fn read_array<R: Read, A: Array<Item = Self>>( state: State<Bytes>, ty: u16, arr: &mut A, r: &mut R, ) -> Result<()>

Reads array.

Examples found in repository

examples/test.rs (line 30)

fn scalar() {
    let filename = "assets/test-scalar.pool";

    let mut file = File::create(filename).unwrap();
    let data: Vec<f32> = vec![1.0, 2.0, 3.0];
    Scalar::write_array(ARRAY_PROPERTY, &data, &mut file).unwrap();
    (10 as u8).write_property(SINGLE_PROPERTY, &mut file).unwrap();
    drop(file);

    let mut file = File::open(filename).unwrap();

    let mut data: Vec<f32> = vec![];
    let mut val: u8 = 0;
    while let Ok((Some(state), ty, prop)) = State::read(&mut file) {
        match prop {
            ARRAY_PROPERTY => Scalar::read_array(state, ty, &mut data, &mut file).unwrap(),
            SINGLE_PROPERTY => val.read_property(state, ty, &mut file).unwrap(),
            _ => break,
        }
    }

    println!("=== Scalar ===");
    println!("data {:?}", data);
    println!("val {:?}", val);
}

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 Scalar for f32

fn ty() -> Type

fn write<W: Write>(&self, w: &mut W) -> Result<usize>

fn read<R: Read>(&mut self, r: &mut R) -> Result<usize>

impl Scalar for f64

fn ty() -> Type

fn write<W: Write>(&self, w: &mut W) -> Result<usize>

fn read<R: Read>(&mut self, r: &mut R) -> Result<usize>

impl Scalar for i8

fn ty() -> Type

fn write<W: Write>(&self, w: &mut W) -> Result<usize>

fn read<R: Read>(&mut self, r: &mut R) -> Result<usize>

impl Scalar for i16

fn ty() -> Type

fn write<W: Write>(&self, w: &mut W) -> Result<usize>

fn read<R: Read>(&mut self, r: &mut R) -> Result<usize>

impl Scalar for i32

fn ty() -> Type

fn write<W: Write>(&self, w: &mut W) -> Result<usize>

fn read<R: Read>(&mut self, r: &mut R) -> Result<usize>

impl Scalar for i64

fn ty() -> Type

fn write<W: Write>(&self, w: &mut W) -> Result<usize>

fn read<R: Read>(&mut self, r: &mut R) -> Result<usize>

impl Scalar for u8

fn ty() -> Type

fn write<W: Write>(&self, w: &mut W) -> Result<usize>

fn read<R: Read>(&mut self, r: &mut R) -> Result<usize>

impl Scalar for u16

fn ty() -> Type

fn write<W: Write>(&self, w: &mut W) -> Result<usize>

fn read<R: Read>(&mut self, r: &mut R) -> Result<usize>

impl Scalar for u32

fn ty() -> Type

fn write<W: Write>(&self, w: &mut W) -> Result<usize>

fn read<R: Read>(&mut self, r: &mut R) -> Result<usize>

impl Scalar for u64

fn ty() -> Type

fn write<W: Write>(&self, w: &mut W) -> Result<usize>

fn read<R: Read>(&mut self, r: &mut R) -> Result<usize>

Implementors