Trait Vector 

pub trait Vector: Sized + Default {
    type Scalar: Scalar;

    // Required methods
    fn dim() -> usize;
    fn get(&self, ind: usize) -> &Self::Scalar;
    fn set(&mut self, ind: usize, val: Self::Scalar);

    // 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 vector types.

Required Associated Types

type Scalar: Scalar

Scalar type.

Required Methods

fn dim() -> usize

Returns the number of dimensions.

fn get(&self, ind: usize) -> &Self::Scalar

Gets value.

fn set(&mut self, ind: usize, val: Self::Scalar)

Sets value.

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 48)

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

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

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

    println!("=== Vector ===");
    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 46)

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

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

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

    println!("=== Vector ===");
    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 57)

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

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

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

    println!("=== Vector ===");
    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 56)

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

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

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

    println!("=== Vector ===");
    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<T: Scalar> Vector for [T; 2]

type Scalar = T

fn dim() -> usize

fn get(&self, ind: usize) -> &T

fn set(&mut self, ind: usize, val: T)

impl<T: Scalar> Vector for [T; 3]

type Scalar = T

fn dim() -> usize

fn get(&self, ind: usize) -> &T

fn set(&mut self, ind: usize, val: T)

impl<T: Scalar> Vector for [T; 4]

type Scalar = T

fn dim() -> usize

fn get(&self, ind: usize) -> &T

fn set(&mut self, ind: usize, val: T)

Implementors