pulz-schedule 0.1.0-alpha2

For scheduling systems and managing their resources
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

use std::marker::PhantomData;

use pulz_functional_utils::{
    func::{FuncMut, FuncOnce},
    tuple::Tuple,
};

use super::{
    SendSystem, System, SystemInit,
    data::{SystemData, SystemDataSend},
};
use crate::{
    resource::{Resources, ResourcesSend},
    system::IntoSystem,
};
pub struct FuncSystem<F, D>
where
    D: SystemData + Tuple,
{
    func: F,
    args_data: Option<D::Data>,
}

impl<F, D> FuncSystem<F, D>
where
    F: FuncMut<D, Output = ()>,
    D: SystemData + Tuple,
{
    pub const fn new(func: F) -> Self {
        Self {
            func,
            args_data: None,
        }
    }
}

#[diagnostic::do_not_recommend]
impl<F, D> SystemInit for FuncSystem<F, D>
where
    F: 'static,
    D: SystemData + Tuple + 'static,
{
    #[inline]
    fn init(&mut self, resources: &mut Resources) {
        self.args_data = Some(D::init(resources));
    }

    #[inline]
    fn system_type_name(&self) -> &'static str {
        std::any::type_name::<F>()
    }

    #[inline]
    fn system_type_id(&self) -> std::any::TypeId {
        std::any::TypeId::of::<F>()
    }
}

#[diagnostic::do_not_recommend]
impl<F, D> System for FuncSystem<F, D>
where
    F: FuncMut<D, Output = ()> + 'static,
    for<'a> &'a mut F: FuncOnce<D::Arg<'a>, Output = ()> + 'a,
    D: SystemData + Tuple + 'static,
    for<'a> D::Arg<'a>: Tuple,
{
    fn run<'a>(&'a mut self, resources: &'a Resources) {
        let data = self.args_data.as_mut().expect("not initialized");
        let args = D::get(resources, data);
        <&mut F>::call_once(&mut self.func, args);
    }

    #[inline]
    fn update_access(&self, res: &Resources, access: &mut crate::resource::ResourceAccess) {
        D::update_access(
            res,
            access,
            self.args_data.as_ref().expect("not initialized"),
        );
    }
}

#[diagnostic::do_not_recommend]
impl<F, D> SendSystem for FuncSystem<F, D>
where
    F: FuncMut<D, Output = ()> + Send + Sync + 'static,
    for<'a> &'a mut F: FuncOnce<D::Arg<'a>, Output = ()> + 'a,
    D: SystemDataSend + Tuple + 'static,
    for<'a> D::Arg<'a>: Tuple,
{
    fn run_send<'a>(&'a mut self, resources: &'a ResourcesSend) {
        let data = self.args_data.as_mut().expect("not initialized");
        let args = D::get_send(resources, data);
        <&mut F>::call_once(&mut self.func, args);
    }
}

#[doc(hidden)]
pub struct NonExclusiveSystemMarker<D>(PhantomData<fn(D)>);

#[diagnostic::do_not_recommend]
impl<F, D> IntoSystem<NonExclusiveSystemMarker<D>> for F
where
    D: SystemData + Tuple,
    F: FuncMut<D, Output = ()>,
    FuncSystem<F, D>: System,
{
    type System = FuncSystem<F, D>;

    #[inline]
    fn into_system(self) -> Self::System {
        FuncSystem::<F, D>::new(self)
    }
}