1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109

use crate::{IntoSendStorage, entity::EntitiesStorage, storage::{FastIndexExt, ReadOnlyStorage}, sync::{ReadGuardRef, OrderedIndexGuard}};
use std::{marker, ops::Deref};
use crate::Component;
use crate::Bitmask;
use super::{IterOptionWrapper, OrderedData, SafeIter};
use crate::storage::{HierarchicalStorage, StorageRef, IntoOrderedIter};
use crate::idtree;

pub struct ReadHierarchical<'a, T: Component>{
    _marker: marker::PhantomData<&'a T>,
}

// Sync Hierarchical Read/Write
pub struct HierarchicalStorageRead<'a, S, BS, T>{
    storage: BS,
    marker_t: marker::PhantomData<&'a T>,
    marker_s: marker::PhantomData<S>,
}

impl<'a, S, BS, T> FastIndexExt for HierarchicalStorageRead<'a, S, BS, T>
where
    S: HierarchicalStorage<'a, T> + 'a,
    BS: Deref<Target = S>,
    T: Component
{
    type FastIndex = idtree::NodeId;
    type StaticTypeId = T;

    fn fast_index(&self, guid: usize) -> idtree::NodeId {
        unsafe{ self.storage.ordered_fast_index(guid) }
    }
}

impl<'a, 'r, S, BS, T> StorageRef<'r> for HierarchicalStorageRead<'a, S, BS, T>
where
    S: HierarchicalStorage<'a,T> + 'a,
    BS: Deref<Target = S>,
    T: Component
{
    type Data = ReadHierarchical<'a, T>;
    type Component = idtree::NodeRef<'r, T>;

    unsafe fn get_fast_unchecked(&'r mut self, idx: idtree::NodeId) -> idtree::NodeRef<'r, T>{
        self.storage.fast_get_node(idx)
    }

    unsafe fn get_unchecked(&'r mut self, guid: usize) -> idtree::NodeRef<'r, T>{
        self.storage.get_node(guid)
    }

    fn contains(&self, guid: usize) -> bool{
        self.storage.contains(guid)
    }
}

impl<'a, 'r, S, T> IntoSendStorage<'r> for HierarchicalStorageRead<'a, S, ReadGuardRef<'a, S>, T>
where
    'a: 'r,
    S: HierarchicalStorage<'a,T> + 'a,
    T: Component
{
    type SendStorage = HierarchicalStorageRead<'a, S, &'r S, T>;
    fn into_send_storage(&'r mut self) -> Self::SendStorage {
        HierarchicalStorageRead {
            storage: &self.storage,
            marker_s: marker::PhantomData,
            marker_t: marker::PhantomData,
        }
    }
}

unsafe impl<'a, S, BS, T> ReadOnlyStorage for HierarchicalStorageRead<'a, S, BS, T>{}

unsafe impl<T: Component> SafeIter<'_> for ReadHierarchical<'_, T>{}

impl<'a, T: Component> OrderedData<'a> for ReadHierarchical<'a,T>
    where for<'b> <T as Component>::Storage: HierarchicalStorage<'b,T>,
          for<'b> ReadGuardRef<'b, <T as Component>::Storage>: IntoOrderedIter
{
    type Iter = IterOptionWrapper<<ReadGuardRef<'a, <T as Component>::Storage> as IntoOrderedIter>::OrderedIter>;
    type Components = T;
    type ComponentsRef = idtree::NodeRef<'a, T>;
    type Storage = HierarchicalStorageRead<'a,
        <T as Component>::Storage,
        ReadGuardRef<'a, <T as Component>::Storage>,
        Self::Components
    >;
    fn query_mask<E: EntitiesStorage>(entities: &E) -> Bitmask{
        Bitmask::has(entities.component_mask::<T>())
    }

    fn into_iter<E: EntitiesStorage>(entities: &'a E) -> Self::Iter{
        IterOptionWrapper{
            it: entities.storage::<T>().map(|s| s.into_ordered_iter())
        }
    }

    fn storage<E: EntitiesStorage>(entities: &'a E) -> Option<Self::Storage>{
        Some(HierarchicalStorageRead{
            storage: entities.storage::<T>()?,
            marker_t: marker::PhantomData,
            marker_s: marker::PhantomData,
        })
    }

    fn ordered_ids<S: FastIndexExt, E: EntitiesStorage>(entities: &'a E, query_mask: Bitmask, unordered_storage: &S) -> OrderedIndexGuard<'a>{
        entities.ordered_entities_for::<T,S>(query_mask, unordered_storage)
    }
}