Struct State 

pub struct State<T = TypeFormat>(/* private fields */);

Stores the state for writing and reading.

Implementations

impl State

pub fn new() -> State

Creates a new state.

pub fn read<R: Read>(r: &mut R) -> Result<(Option<State<Bytes>>, u16, u16)>

Reads type format and property.

Returns None in first argument if there is no more data.

Examples found in repository

examples/test.rs (line 28)

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 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 matrix() {
    let filename = "assets/test-matrix.pool";

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

    let mut file = File::open(filename).unwrap();
    let mut data: Vec<[[f32; 2]; 2]> = vec![];
    let mut val: [[u8; 2]; 2] = [[0; 2]; 2];

    while let Ok((Some(state), ty, prop)) = State::read(&mut file) {
        match prop {
            ARRAY_PROPERTY => Matrix::read_array(state, ty, &mut data, &mut file).unwrap(),
            SINGLE_PROPERTY => val.read_property(state, ty, &mut file).unwrap(),
            _ => break,
        }
    }

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

pub fn write_type_format<W: Write>( self, type_format: u16, w: &mut W, ) -> Result<State<PropertyId>>

Writes type format.

pub fn read_type_format<R: Read>( self, type_format: &mut u16, r: &mut R, ) -> Result<State<PropertyId>>

Reads type format.

pub fn end_type_formats<W: Write>(self, w: &mut W) -> Result<()>

Ends writing state.

impl State<PropertyId>

pub fn write_property_id<W: Write>( self, property_id: u16, w: &mut W, ) -> Result<State<Bytes>>

Writes property id.

pub fn read_property_id<R: Read>( self, property_id: &mut u16, r: &mut R, ) -> Result<State<Bytes>>

Reads property id.

impl State<Bytes>

pub fn write_bytes<W: Write>( self, bytes: u64, w: &mut W, ) -> Result<State<OffsetInstanceId>>

Writes number of bytes in data.

pub fn read_bytes<R: Read>( self, bytes: &mut u64, r: &mut R, ) -> Result<State<OffsetInstanceId>>

Reads bytes.

pub fn end_bytes<W: Write>(self, w: &mut W) -> Result<State<TypeFormat>>

Ends byte block.

pub fn has_end_bytes<R: Read>(self, r: &mut R) -> Result<State<TypeFormat>>

Checks if this is the end of bytes.

impl State<OffsetInstanceId>

pub fn write_offset_instance_id<W: Write>( self, offset_instance_id: u64, w: &mut W, ) -> Result<State<Data>>

Writes offset instance id.

pub fn read_offset_instance_id<R: Read>( self, offset_instance_id: &mut u64, r: &mut R, ) -> Result<State<Data>>

Reads offset instance id.

impl State<Data>

pub fn write_data<W: Write>(self, data: &[u8], w: &mut W) -> Result<State<Data>>

Writes data.

pub fn end_data(self) -> State<Bytes>

End of data.