yaks 0.1.0

Minimalistic framework for automatic multithreading of hecs via rayon
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
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
110
111
112
113
114
115
116
117
118
119

use crate::{Contains, DerefTuple, Ref, RefMut};

#[cfg(feature = "parallel")]
use crate::ResourceSet;

pub trait Fetch<'a, T, M0>: Sized {
    type Fetched: DerefTuple<'a, Output = Self>;

    fn fetch(resources: &T) -> Self::Fetched;

    fn release(resources: &T, fetched: Self::Fetched);

    #[cfg(feature = "parallel")]
    fn set_resource_bits(resource_set: &mut ResourceSet);
}

impl<'a, T, M0, R0> Fetch<'a, T, M0> for &'a R0
where
    T: Contains<R0, M0>,
    R0: 'a,
{
    type Fetched = Ref<R0>;

    fn fetch(resources: &T) -> Self::Fetched {
        T::borrow(resources)
    }

    fn release(resources: &T, fetched: Self::Fetched) {
        T::release(resources, fetched);
    }

    #[cfg(feature = "parallel")]
    fn set_resource_bits(resource_set: &mut ResourceSet) {
        T::set_resource_bit(&mut resource_set.immutable);
    }
}

impl<'a, T, M0, R0> Fetch<'a, T, M0> for &'a mut R0
where
    T: Contains<R0, M0>,
    R0: 'a,
{
    type Fetched = RefMut<R0>;

    fn fetch(resources: &T) -> Self::Fetched {
        T::borrow_mut(resources)
    }

    fn release(resources: &T, fetched: Self::Fetched) {
        T::release_mut(resources, fetched);
    }

    #[cfg(feature = "parallel")]
    fn set_resource_bits(resource_set: &mut ResourceSet) {
        T::set_resource_bit(&mut resource_set.mutable);
    }
}

impl<'a, T> Fetch<'a, T, ()> for () {
    type Fetched = ();

    fn fetch(_: &T) -> Self::Fetched {}

    fn release(_: &T, _: Self::Fetched) {}

    #[cfg(feature = "parallel")]
    fn set_resource_bits(_: &mut ResourceSet) {}
}

impl<'a, T, M0, F0> Fetch<'a, T, (M0,)> for (F0,)
where
    F0: Fetch<'a, T, M0>,
{
    type Fetched = (F0::Fetched,);

    fn fetch(resources: &T) -> Self::Fetched {
        (F0::fetch(resources),)
    }

    fn release(resources: &T, fetched: Self::Fetched) {
        F0::release(resources, fetched.0);
    }

    #[cfg(feature = "parallel")]
    fn set_resource_bits(resource_set: &mut ResourceSet) {
        F0::set_resource_bits(resource_set);
    }
}

macro_rules! impl_fetch {
    ($($letter:ident),*) => {
        paste::item! {
            impl<'a, T, $([<M $letter>],)* $([<F $letter>],)*> Fetch<'a, T, ($([<M $letter>],)*)>
                for ($([<F $letter>]),*)
            where
                $([<F $letter>]: Fetch<'a, T, [<M $letter>]>,)*
            {
                type Fetched = ($([<F $letter>]::Fetched,)*);

                fn fetch(resources: &T) -> Self::Fetched {
                    ($([<F $letter>]::fetch(resources)),*)
                }

                #[allow(non_snake_case)]
                fn release(resources: &T, fetched: Self::Fetched) {
                    let ($($letter,)*) = fetched;
                    $([<F $letter>]::release(resources, $letter);)*
                }

                #[cfg(feature = "parallel")]
                fn set_resource_bits(resource_set: &mut ResourceSet) {
                    $([<F $letter>]::set_resource_bits(resource_set);)*
                }
            }
        }
    }
}

impl_for_tuples!(impl_fetch);