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
120
121
122
123
124
125

#[cfg(feature = "parallel")]
use fixedbitset::FixedBitSet;

use crate::{Ref, RefMut, ResourceCell, WrappedResources};

pub trait Contains<R0, M0> {
    fn borrow(&self) -> Ref<R0>;

    fn borrow_mut(&self) -> RefMut<R0>;

    fn release(&self, borrowed: Ref<R0>);

    fn release_mut(&self, borrowed: RefMut<R0>);

    #[cfg(feature = "parallel")]
    fn set_resource_bit(bitset: &mut FixedBitSet);
}

impl<R0> Contains<R0, ()> for WrappedResources<'_, (ResourceCell<R0>,)> {
    fn borrow(&self) -> Ref<R0> {
        self.tuple.0.borrow()
    }

    fn borrow_mut(&self) -> RefMut<R0> {
        self.tuple.0.borrow_mut()
    }

    fn release(&self, borrowed: Ref<R0>) {
        self.tuple.0.release(borrowed);
    }

    fn release_mut(&self, borrowed: RefMut<R0>) {
        self.tuple.0.release_mut(borrowed);
    }

    #[cfg(feature = "parallel")]
    fn set_resource_bit(bitset: &mut FixedBitSet) {
        bitset.insert(0);
    }
}

macro_rules! swap_to_unit {
    ($anything:tt) => {
        ()
    };
}

macro_rules! swap_to_markers {
    ($($letter:ident),*) => {
        ($( swap_to_unit!($letter), )*)
    }
}

macro_rules! impl_contains {
    ($($letter:ident),*) => {
        impl_contains!($($letter),* ; $($letter),*);
    };
    ($($all:ident),* ; $letter:ident, $($tail:ident),*) => {
        #[allow(non_snake_case)]
        #[allow(unused_variables)]
        impl<$($all),*> Contains<$letter, ($letter, swap_to_markers!($($tail),*))>
            for WrappedResources<'_, ($(ResourceCell<$all>,)*)>
        {
            fn borrow(&self) -> Ref<$letter> {
                let ($($all,)*) = &self.tuple;
                $letter.borrow()
            }

            fn borrow_mut(&self) -> RefMut<$letter> {
                let ($($all,)*) = &self.tuple;
                $letter.borrow_mut()
            }

            fn release(&self, borrowed: Ref<$letter>) {
                let ($($all,)*) = &self.tuple;
                $letter.release(borrowed);
            }

            fn release_mut(&self, borrowed: RefMut<$letter>) {
                let ($($all,)*) = &self.tuple;
                $letter.release_mut(borrowed);
            }

            #[cfg(feature = "parallel")]
            fn set_resource_bit(bitset: &mut FixedBitSet) {
                bitset.insert(count!($($all)*) - (1usize + count!($($tail)*)));
            }
        }
        impl_contains!($($all),* ; $($tail),*);
    };
    ($($all:ident),* ; $letter:ident ) => {
        #[allow(non_snake_case)]
        #[allow(unused_variables)]
        impl<$($all),*> Contains<$letter, ($letter, )>
            for WrappedResources<'_, ($(ResourceCell<$all>,)*)>
        {
            fn borrow(&self) -> Ref<$letter> {
                let ($($all,)*) = &self.tuple;
                $letter.borrow()
            }

            fn borrow_mut(&self) -> RefMut<$letter> {
                let ($($all,)*) = &self.tuple;
                $letter.borrow_mut()
            }

            fn release(&self, borrowed: Ref<$letter>) {
                let ($($all,)*) = &self.tuple;
                $letter.release(borrowed);
            }

            fn release_mut(&self, borrowed: RefMut<$letter>) {
                let ($($all,)*) = &self.tuple;
                $letter.release_mut(borrowed);
            }

            #[cfg(feature = "parallel")]
            fn set_resource_bit(bitset: &mut FixedBitSet) {
                bitset.insert(count!($($all)*) - 1usize);
            }
        }
    }
}

impl_for_tuples!(impl_contains);