space-crush/space-crush-common/src/misc/flagged_storage.rs

#![allow(dead_code)]

use std::ops::{Deref, DerefMut};

use hibitset::BitSetLike;
use shrev::{Event, EventChannel, ReaderId};
use specs::{
    storage::{DistinctStorage, MaskedStorage, Storage, TryDefault, UnprotectedStorage},
    world::Index,
    Component, DenseVecStorage,
};

/* FlaggedStorage */

pub struct FlaggedStorage<C, T = DenseVecStorage<C>>
where
    C: Event,
{
    event_emission: bool,
    channel: EventChannel<ComponentEvent<C>>,
    storage: T,
}

pub enum ComponentEvent<C>
where
    C: Event,
{
    Inserted(Index, C),
    Modified(Index, C),
    Removed(Index, C),
}

impl<C, T> Default for FlaggedStorage<C, T>
where
    C: Event,
    T: TryDefault,
{
    fn default() -> Self {
        FlaggedStorage {
            event_emission: true,
            channel: EventChannel::new(),
            storage: T::unwrap_default(),
        }
    }
}

impl<C, T> UnprotectedStorage<C> for FlaggedStorage<C, T>
where
    C: Component + Event + Clone,
    T: UnprotectedStorage<C>,
{
    unsafe fn clean<B>(&mut self, has: B)
    where
        B: BitSetLike,
    {
        self.storage.clean(has);
    }

    unsafe fn get(&self, id: Index) -> &C {
        self.storage.get(id)
    }

    unsafe fn get_mut(&mut self, id: Index) -> &mut C {
        let component = self.storage.get_mut(id);

        if self.event_emission {
            self.channel
                .single_write(ComponentEvent::Modified(id, component.clone()));
        }

        component
    }

    unsafe fn insert(&mut self, id: Index, component: C) {
        self.storage.insert(id, component.clone());

        if self.event_emission {
            self.channel
                .single_write(ComponentEvent::Inserted(id, component));
        }
    }

    unsafe fn remove(&mut self, id: Index) -> C {
        let component = self.storage.remove(id);

        if self.event_emission {
            self.channel
                .single_write(ComponentEvent::Removed(id, component.clone()));
        }

        component
    }
}

unsafe impl<C, T> DistinctStorage for FlaggedStorage<C, T>
where
    C: Component + Event + Clone,
    T: DistinctStorage,
{
}

/* Tracked */

pub trait Tracked<C: Event> {
    fn channel(&self) -> &EventChannel<ComponentEvent<C>>;
    fn channel_mut(&mut self) -> &mut EventChannel<ComponentEvent<C>>;

    fn event_emission(&self) -> bool;
    fn set_event_emission(&mut self, value: bool);
}

impl<C, T> Tracked<C> for FlaggedStorage<C, T>
where
    C: Component + Event,
{
    fn channel(&self) -> &EventChannel<ComponentEvent<C>> {
        &self.channel
    }

    fn channel_mut(&mut self) -> &mut EventChannel<ComponentEvent<C>> {
        &mut self.channel
    }

    fn event_emission(&self) -> bool {
        self.event_emission
    }

    fn set_event_emission(&mut self, value: bool) {
        self.event_emission = value;
    }
}

/* StorageHelper */

pub trait StorageHelper<C: Event> {
    fn event_emission(&self) -> bool;
    fn channel(&self) -> &EventChannel<ComponentEvent<C>>;
}

pub trait StorageHelperMut<C: Event> {
    fn set_event_emission(&mut self, value: bool);
    fn channel_mut(&mut self) -> &mut EventChannel<ComponentEvent<C>>;
    fn register_event_reader(&mut self) -> ReaderId<ComponentEvent<C>>;
}

impl<'e, T, D> StorageHelper<T> for Storage<'e, T, D>
where
    T: Component + Event,
    T::Storage: Tracked<T>,
    D: Deref<Target = MaskedStorage<T>>,
{
    fn event_emission(&self) -> bool {
        self.unprotected_storage().event_emission()
    }

    fn channel(&self) -> &EventChannel<ComponentEvent<T>> {
        self.unprotected_storage().channel()
    }
}

impl<'e, T, D> StorageHelperMut<T> for Storage<'e, T, D>
where
    T: Component + Event,
    T::Storage: Tracked<T>,
    D: DerefMut<Target = MaskedStorage<T>>,
{
    fn set_event_emission(&mut self, value: bool) {
        unsafe { self.unprotected_storage_mut().set_event_emission(value) };
    }

    fn channel_mut(&mut self) -> &mut EventChannel<ComponentEvent<T>> {
        unsafe { self.unprotected_storage_mut().channel_mut() }
    }

    fn register_event_reader(&mut self) -> ReaderId<ComponentEvent<T>> {
        self.channel_mut().register_reader()
    }
}