qecs 0.0.7

use qecs_core::{
    Id, Valid, ServiceBase, StoreBase, EntityStore, EntityStoreIter,
    _EntityStoreIter,
};

use std::collections::btree_set::{self, BTreeSet};
use std::iter;

pub struct BTreeSetStore<ID> {
    storage: BTreeSet<ID>,
}

impl<ID> From<BTreeSet<ID>> for BTreeSetStore<ID>
    where ID: Id
{
    fn from(storage: BTreeSet<ID>) -> Self {
        BTreeSetStore{ storage: storage }
    }
}

impl<ID> Default for BTreeSetStore<ID>
    where ID: Id
{
    fn default() -> Self {
        Self::from(BTreeSet::default())
    }
}

impl<ID> ServiceBase for BTreeSetStore<ID>
    where ID: Id
{}

impl<ID> StoreBase for BTreeSetStore<ID>
    where ID: Id
{
    type Id = ID;

    fn len(&self) -> usize { self.storage.len() }

    fn is_assigned<'id>(&self, id: Valid<'id, Self::Id>) -> bool {
        self.storage.contains(&*id)
    }

    /*fn assign_cloned<'id>(
        &mut self, 
        dest: Valid<'id, Self::Id>, 
        src: Valid<'id, Self::Id>,
    ) -> bool {
        match self.get(src).map(|c| c.clone()) {
            Some(com) => { self.assign(dest, com); true },
            None => false,
        }
    }*/

    fn release_drop<'id>(&mut self, id: Valid<'id, Self::Id>) -> bool {
        self.storage.remove(&*id)
    }

    fn clear(&mut self){ self.storage.clear() }
}

impl<ID> EntityStore for BTreeSetStore<ID>
    where ID: Id
{
    fn assign<'id>(&mut self, id: Valid<'id, Self::Id>) -> bool {
        self.storage.insert(*id)
    }
}

pub type Iter<'a, ID> = iter::Map<btree_set::Iter<'a, ID>, fn(&'a ID) -> Valid<'a, ID>>;

impl<'a, ID> _EntityStoreIter<'a> for BTreeSetStore<ID>
    where ID: Id
{
    type Iter = Iter<'a, ID>;
}

impl<ID> EntityStoreIter for BTreeSetStore<ID>
    where ID: Id
{
    fn iter<'a>(&'a self) -> <Self as _EntityStoreIter<'a>>::Iter {
        fn map_fn<'a, ID: Id>(id: &'a ID) -> Valid<'a, ID> {
            unsafe { Valid::new(*id) }
        }

        self.storage.iter().map(map_fn)
    }
}

impl<'id, ID> Extend<Valid<'id, ID>> for BTreeSetStore<ID> 
    where ID: Id
{
    fn extend<I>(&mut self, iterable: I)
        where I: IntoIterator<Item = Valid<'id, ID>>
    {
        for id in iterable {
            self.assign(id);
        }
    }
}

impl<'a, ID> IntoIterator for &'a BTreeSetStore<ID>
    where ID: Id
{
    type Item = <Self::IntoIter as Iterator>::Item;
    type IntoIter = Iter<'a, ID>;
    fn into_iter(self) -> Self::IntoIter { self.iter() }
}