use crate::storage::{AccessMut, UnprotectedStorage};
use crate::{
storage::{AccessMutReturn, InsertResult, ReadStorage, WriteStorage},
world::{Component, Entity},
};
pub struct Seal;
pub trait GenericReadStorage {
type Component: Component;
fn get(&self, entity: Entity) -> Option<&Self::Component>;
fn _private() -> Seal;
}
impl<'a, T> GenericReadStorage for ReadStorage<'a, T>
where
T: Component,
{
type Component = T;
fn get(&self, entity: Entity) -> Option<&Self::Component> {
ReadStorage::get(self, entity)
}
fn _private() -> Seal {
Seal
}
}
impl<'a: 'b, 'b, T> GenericReadStorage for &'b ReadStorage<'a, T>
where
T: Component,
{
type Component = T;
fn get(&self, entity: Entity) -> Option<&Self::Component> {
ReadStorage::get(*self, entity)
}
fn _private() -> Seal {
Seal
}
}
impl<'a, T> GenericReadStorage for WriteStorage<'a, T>
where
T: Component,
{
type Component = T;
fn get(&self, entity: Entity) -> Option<&Self::Component> {
WriteStorage::get(self, entity)
}
fn _private() -> Seal {
Seal
}
}
impl<'a: 'b, 'b, T> GenericReadStorage for &'b WriteStorage<'a, T>
where
T: Component,
{
type Component = T;
fn get(&self, entity: Entity) -> Option<&Self::Component> {
WriteStorage::get(*self, entity)
}
fn _private() -> Seal {
Seal
}
}
pub trait GenericWriteStorage {
type Component: Component;
type AccessMut<'a>: AccessMut<Target = Self::Component>
where
Self: 'a;
fn get_mut(&mut self, entity: Entity) -> Option<AccessMutReturn<'_, Self::Component>>;
fn get_mut_or_default(
&mut self,
entity: Entity,
) -> Option<AccessMutReturn<'_, Self::Component>>
where
Self::Component: Default;
fn insert(&mut self, entity: Entity, comp: Self::Component) -> InsertResult<Self::Component>;
fn remove(&mut self, entity: Entity);
fn _private() -> Seal;
}
impl<'a, T> GenericWriteStorage for WriteStorage<'a, T>
where
T: Component,
{
type AccessMut<'b> = <<T as Component>::Storage as UnprotectedStorage<T>>::AccessMut<'b>
where Self: 'b;
type Component = T;
fn get_mut(&mut self, entity: Entity) -> Option<AccessMutReturn<'_, T>> {
WriteStorage::get_mut(self, entity)
}
fn get_mut_or_default(&mut self, entity: Entity) -> Option<AccessMutReturn<'_, T>>
where
Self::Component: Default,
{
if !self.contains(entity) {
self.insert(entity, Default::default())
.ok()
.and_then(move |_| self.get_mut(entity))
} else {
self.get_mut(entity)
}
}
fn insert(&mut self, entity: Entity, comp: Self::Component) -> InsertResult<Self::Component> {
WriteStorage::insert(self, entity, comp)
}
fn remove(&mut self, entity: Entity) {
WriteStorage::remove(self, entity);
}
fn _private() -> Seal {
Seal
}
}
impl<'a: 'b, 'b, T> GenericWriteStorage for &'b mut WriteStorage<'a, T>
where
T: Component,
{
type AccessMut<'c> = <<T as Component>::Storage as UnprotectedStorage<T>>::AccessMut<'c>
where Self: 'c;
type Component = T;
fn get_mut(&mut self, entity: Entity) -> Option<AccessMutReturn<'_, T>> {
WriteStorage::get_mut(*self, entity)
}
fn get_mut_or_default(&mut self, entity: Entity) -> Option<AccessMutReturn<'_, T>>
where
Self::Component: Default,
{
if !self.contains(entity) {
self.insert(entity, Default::default())
.ok()
.and_then(move |_| self.get_mut(entity))
} else {
self.get_mut(entity)
}
}
fn insert(&mut self, entity: Entity, comp: Self::Component) -> InsertResult<Self::Component> {
WriteStorage::insert(*self, entity, comp)
}
fn remove(&mut self, entity: Entity) {
WriteStorage::remove(*self, entity);
}
fn _private() -> Seal {
Seal
}
}