Struct fj_kernel::storage::Store

pub struct Store<T> { /* private fields */ }

Append-only object storage

Implementations

impl<T> Store<T>

pub fn new() -> Self

Construct a new instance of Store

Equivalent to calling Store::with_block_size with a default block size.

Examples found in repository

src/storage/store.rs (line 103)

    fn default() -> Self {
        Self::new()
    }

src/objects/stores.rs (line 109)

    fn default() -> Self {
        let mut store: Store<Surface> = Store::new();

        let xy_plane = store.reserve();
        store.insert(
            xy_plane.clone(),
            Surface::new(SurfaceGeometry {
                u: GlobalPath::x_axis(),
                v: Vector::unit_y(),
            }),
        );

        let xz_plane = store.reserve();
        store.insert(
            xz_plane.clone(),
            Surface::new(SurfaceGeometry {
                u: GlobalPath::x_axis(),
                v: Vector::unit_z(),
            }),
        );
        let yz_plane = store.reserve();
        store.insert(
            yz_plane.clone(),
            Surface::new(SurfaceGeometry {
                u: GlobalPath::y_axis(),
                v: Vector::unit_z(),
            }),
        );

        Self {
            store,
            xy_plane,
            xz_plane,
            yz_plane,
        }
    }

pub fn with_block_size(block_size: usize) -> Self

Construct a new instance of Store using the provided block size

Examples found in repository

src/storage/store.rs (line 45)

    pub fn new() -> Self {
        Self::with_block_size(16384)
    }

pub fn reserve(&self) -> Handle<T>

Reserve a slot for an object in the store

This method returns a handle to the reserved slot. That handle does not refer to an object yet! Attempting to dereference the handle before it has been used to insert an object into the store, will result in a panic.

Usually, you’d acquire one handle, then immediately use it to insert an object using Store::insert. The methods are separate to support more advanced use cases, like inserting objects that refer to each other.

Examples found in repository

src/objects/stores.rs (line 83)

    pub fn reserve(&self) -> Handle<Surface> {
        self.store.reserve()
    }

    /// Insert a [`Surface`] into the store
    pub fn insert(&mut self, handle: Handle<Surface>, surface: Surface) {
        self.store.insert(handle, surface);
    }

    /// Access the xy-plane
    pub fn xy_plane(&self) -> Handle<Surface> {
        self.xy_plane.clone()
    }

    /// Access the xz-plane
    pub fn xz_plane(&self) -> Handle<Surface> {
        self.xz_plane.clone()
    }

    /// Access the yz-plane
    pub fn yz_plane(&self) -> Handle<Surface> {
        self.yz_plane.clone()
    }
}

impl Default for Surfaces {
    fn default() -> Self {
        let mut store: Store<Surface> = Store::new();

        let xy_plane = store.reserve();
        store.insert(
            xy_plane.clone(),
            Surface::new(SurfaceGeometry {
                u: GlobalPath::x_axis(),
                v: Vector::unit_y(),
            }),
        );

        let xz_plane = store.reserve();
        store.insert(
            xz_plane.clone(),
            Surface::new(SurfaceGeometry {
                u: GlobalPath::x_axis(),
                v: Vector::unit_z(),
            }),
        );
        let yz_plane = store.reserve();
        store.insert(
            yz_plane.clone(),
            Surface::new(SurfaceGeometry {
                u: GlobalPath::y_axis(),
                v: Vector::unit_z(),
            }),
        );

        Self {
            store,
            xy_plane,
            xz_plane,
            yz_plane,
        }
    }

pub fn insert(&mut self, handle: Handle<T>, object: T)

Insert an object into the store

Panics

Panics, if the passed Handle does not refer to a reserved slot. This can only be the case, if the handle has been used to insert an object before.

Examples found in repository

src/objects/stores.rs (line 88)

    pub fn insert(&mut self, handle: Handle<Surface>, surface: Surface) {
        self.store.insert(handle, surface);
    }

    /// Access the xy-plane
    pub fn xy_plane(&self) -> Handle<Surface> {
        self.xy_plane.clone()
    }

    /// Access the xz-plane
    pub fn xz_plane(&self) -> Handle<Surface> {
        self.xz_plane.clone()
    }

    /// Access the yz-plane
    pub fn yz_plane(&self) -> Handle<Surface> {
        self.yz_plane.clone()
    }
}

impl Default for Surfaces {
    fn default() -> Self {
        let mut store: Store<Surface> = Store::new();

        let xy_plane = store.reserve();
        store.insert(
            xy_plane.clone(),
            Surface::new(SurfaceGeometry {
                u: GlobalPath::x_axis(),
                v: Vector::unit_y(),
            }),
        );

        let xz_plane = store.reserve();
        store.insert(
            xz_plane.clone(),
            Surface::new(SurfaceGeometry {
                u: GlobalPath::x_axis(),
                v: Vector::unit_z(),
            }),
        );
        let yz_plane = store.reserve();
        store.insert(
            yz_plane.clone(),
            Surface::new(SurfaceGeometry {
                u: GlobalPath::y_axis(),
                v: Vector::unit_z(),
            }),
        );

        Self {
            store,
            xy_plane,
            xz_plane,
            yz_plane,
        }
    }

pub fn iter(&self) -> Iter<'_, T>

Iterate over all objects in this store

Examples found in repository

src/storage/store.rs (line 112)

    fn into_iter(self) -> Self::IntoIter {
        self.iter()
    }

Trait Implementations

impl<T: Debug> Debug for Store<T>

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

Formats the value using the given formatter.

impl<T> Default for Store<T>

fn default() -> Self

Returns the “default value” for a type.

impl<'a, T> IntoIterator for &'a Store<T>

type Item = Handle<T>

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.