brood 0.9.1

A fast and flexible entity component system library.
Documentation 
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

mod repeat;

pub(crate) use repeat::RepeatNone;

use crate::{
    component::Component,
    entity,
    query::{
        result::ParResults,
        view::{
            Null,
            View,
            Views,
        },
    },
};
use rayon::{
    iter,
    iter::{
        Either,
        IndexedParallelIterator,
    },
    slice,
};

pub trait ParViewSeal<'a>: View<'a> {
    type ParResult: IndexedParallelIterator<Item = Self>;
}

impl<'a, C> ParViewSeal<'a> for &'a C
where
    C: Component + Sync,
{
    type ParResult = slice::Iter<'a, C>;
}

impl<'a, C> ParViewSeal<'a> for &'a mut C
where
    C: Component + Send,
{
    type ParResult = slice::IterMut<'a, C>;
}

impl<'a, C> ParViewSeal<'a> for Option<&'a C>
where
    C: Component + Sync,
{
    type ParResult = Either<
        iter::RepeatN<Option<&'a C>>,
        iter::Map<slice::Iter<'a, C>, fn(&'a C) -> Option<&'a C>>,
    >;
}

impl<'a, C> ParViewSeal<'a> for Option<&'a mut C>
where
    C: Component + Send,
{
    type ParResult = Either<
        RepeatNone<&'a mut C>,
        iter::Map<slice::IterMut<'a, C>, fn(&'a mut C) -> Option<&'a mut C>>,
    >;
}

impl<'a> ParViewSeal<'a> for entity::Identifier {
    type ParResult = iter::Cloned<slice::Iter<'a, Self>>;
}

pub trait ParViewsSeal<'a>: Views<'a> {
    type ParResults: ParResults<View = Self>;
}

impl<'a> ParViewsSeal<'a> for Null {
    type ParResults = iter::RepeatN<Null>;
}

impl<'a, V, W> ParViewsSeal<'a> for (V, W)
where
    V: ParViewSeal<'a> + Send,
    W: ParViewsSeal<'a>,
{
    type ParResults = (V::ParResult, W::ParResults);
}