Struct R11Store

pub struct R11Store<T, U>
where
    T: Storable,
    U: Storable,
{
    pub left: XvcStore<T>,
    pub right: XvcStore<U>,
}

Associates two XvcStores with two different type of components with a single XvcEntity. It’s like using the same primary key in two database tables.

Fields

left: XvcStore<T>

The first XvcStore to be associated

right: XvcStore<U>

The second XvcStore to be associated

Implementations

impl<T, U> R11Store<T, U>

where T: Storable, U: Storable,

pub fn new() -> R11Store<T, U>

Creates an empty R11Store

The following creates two new stores: XvcStore<String> and XvcStore<i32> that can be used in parallel with the same XvcEntity keys.

use xvc_ecs::R11Store;
let rs = R11Store::<String, i32>::new();

pub fn insert( &mut self, entity: &XvcEntity, left_component: T, right_component: U, )

inserts an element to both left and right

Having a R11Store<String, String>, the following code inserts “left component” and “right component” with the same XvcEntity(100).

let entity: XvcEntity = 100.into();
rs.insert(&entity, "left component".into(), "right component".into());

pub fn left_to_right(&self, entity: &XvcEntity) -> Option<(&XvcEntity, &U)>

returns the right element in L-R pair

let entity: XvcEntity = (100u64, 200u64).into();
rs.insert(&entity, "left component".into(), "right component".to_string());

pub fn right_to_left(&self, entity: &XvcEntity) -> Option<(&XvcEntity, &T)>

returns the left element in L-R pair

let entity: XvcEntity = (100, 200).into();
rs.insert(&entity, "left component".into(), "right component".into());

pub fn tuple(&self, entity: &XvcEntity) -> (Option<&T>, Option<&U>)

Returns L-R as a tuple

let entity: XvcEntity = (100, 200).into();
rs.insert(&entity, "left component".into(), "right component".into());
let t = rs.tuple(&entity);

pub fn entity_by_left(&self, left_element: &T) -> Option<XvcEntity>

Finds the entity from the left value

pub fn entity_by_right(&self, right_element: &U) -> Option<XvcEntity>

Finds the first entity from the right value

pub fn remove(&mut self, entity: XvcEntity)

removes the components from both right and left

pub fn lookup_by_left(&self, left_element: &T) -> Option<&U>

Search the right value by left

pub fn lookup_by_right(&self, right_element: &U) -> Option<&T>

Search the left value by right

pub fn filter(&self, predicate: impl Fn(&T, &U) -> bool) -> R11Store<T, U>

Run a filter on the store and return elements selected by the predicate

impl<T, U> R11Store<T, U>

where T: Storable, U: Storable,

pub fn load_r11store(store_root: &Path) -> Result<R11Store<T, U>, Error>

Creates a 1-1 store by loading member stores with XvcStore::load_store

pub fn save_r11store(&self, store_root: &Path) -> Result<(), Error>

Records a store by recording the member stores with XvcStore::save.

Trait Implementations

impl<T, U> Clone for R11Store<T, U>

where T: Clone + Storable, U: Clone + Storable,

fn clone(&self) -> R11Store<T, U>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T, U> Debug for R11Store<T, U>

where T: Debug + Storable, U: Debug + Storable,

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

Formats the value using the given formatter.

impl<T, U> Default for R11Store<T, U>

where T: Storable, U: Storable,

fn default() -> R11Store<T, U>

Returns the “default value” for a type.