Struct flatdata::ExternalVector

pub struct ExternalVector<'a, T> where
    T: Struct,  { /* fields omitted */ }

Vector which flushes its content when growing.

Useful for serialization of data which does not fully fit in memory.

External vector does not provide access to elements previously added to it. Only the last element added to the vector using the result of the method grow can be accessed and written.

An external vector must be closed, after the last element was written to it. After closing, it can not be used anymore.

Examples

struct A {
    x : u32 : 16;
    y : u32 : 16;
}

archive X {
   data : vector< A >;
}

use flatdata::MemoryResourceStorage;
use flatdata::test::{A, X, XBuilder};

let storage = MemoryResourceStorage::new("/root/extvec");
let builder = XBuilder::new(storage.clone()).expect("failed to create builder");
{
    let mut v = builder.start_data().expect("failed to start");
    let mut a = v.grow().expect("grow failed");
    a.set_x(0);
    a.set_y(1);

    let mut a = v.grow().expect("grow failed");
    a.set_x(2);
    a.set_y(3);

    let view = v.close().expect("close failed");

    // data can also be inspected directly after closing
    assert_eq!(view.len(), 2);
    assert_eq!(view[0].x(), 0);
    assert_eq!(view[0].y(), 1);
}

let archive = X::open(storage).expect("failed to open");
let view = archive.data();
assert_eq!(view[1].x(), 2);
assert_eq!(view[1].y(), 3);

Implementations

impl<'a, T> ExternalVector<'a, T> where
    T: Struct, 

pub fn new(resource_handle: ResourceHandle<'a>) -> Self

Creates an empty ExternalVector<T> in the given resource storage.

pub fn len(&self) -> usize

Number of elements that where added to this vector.

pub fn is_empty(&self) -> bool

Returns true if no element were added to this vector yet.

pub fn grow(&mut self) -> Result<&mut T>

Appends an element to the end of this vector and returns a mutable handle to it.

Calling this method may flush data to storage (cf. flush), which may fail due to different IO reasons.

pub fn close(self) -> Result<&'a [T], ResourceStorageError>

Flushes the remaining not yet flushed elements in this vector and finalizes the data inside the storage.

An external vector must be closed

Trait Implementations

impl<'_, T> Debug for ExternalVector<'_, T> where
    T: Struct, 

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

Formats the value using the given formatter.