swamp_app/
system_types.rs

1/*
2 * Copyright (c) Peter Bjorklund. All rights reserved. https://github.com/swamp/swamp
3 * Licensed under the MIT License. See LICENSE in the project root for license information.
4 */
5use std::mem::transmute;
6use std::ops::{Deref, DerefMut};
7use swamp_message::{Message, Messages};
8use swamp_resource::{Resource, ResourceStorage};
9use swamp_system::SystemParam;
10use swamp_system_state::State;
11
12// Mutable resource access
13pub struct ReM<'a, T: 'static> {
14    value: &'a mut T,
15}
16
17impl<'a, T> ReM<'a, T> {
18    pub fn new(value: &'a mut T) -> Self {
19        Self { value }
20    }
21}
22
23impl<'a, T> Deref for ReM<'a, T> {
24    type Target = T;
25
26    fn deref(&self) -> &Self::Target {
27        self.value
28    }
29}
30
31impl<'a, T> DerefMut for ReM<'a, T> {
32    fn deref_mut(&mut self) -> &mut Self::Target {
33        self.value
34    }
35}
36
37// Mutable resource access
38pub struct Re<'a, T: 'static> {
39    value: &'a T,
40}
41
42impl<'a, T> Re<'a, T> {
43    pub fn new(value: &'a T) -> Self {
44        Self { value }
45    }
46}
47
48impl<'a, T> Deref for Re<'a, T> {
49    type Target = T;
50
51    fn deref(&self) -> &Self::Target {
52        self.value
53    }
54}
55
56impl<T: Resource + 'static> SystemParam for ReM<'static, T> {
57    type Item = Self;
58
59    fn fetch(world: &mut State) -> Self::Item {
60        let actual_ref: &mut T = world.resource_mut::<T>();
61        let static_ref: &'static mut T = unsafe { transmute(actual_ref) };
62        ReM::new(static_ref)
63    }
64}
65
66impl<T: Resource + 'static> SystemParam for Re<'static, T> {
67    type Item = Self;
68
69    fn fetch(world: &mut State) -> Self::Item {
70        let actual_ref: &mut T = world.resource_mut::<T>();
71        let static_ref: &'static mut T = unsafe { transmute(actual_ref) };
72        Re::new(static_ref)
73    }
74}
75
76impl<T: 'static + Message> SystemParam for Msg<'static, T> {
77    type Item = Self;
78
79    fn fetch(world: &mut State) -> Self::Item {
80        let actual_ref = world.message::<T>();
81        let static_ref: &'static Messages<T> = unsafe { transmute(actual_ref) };
82        Msg::new(static_ref)
83    }
84}
85
86impl<T: 'static + Message> SystemParam for MsgM<'static, T> {
87    type Item = Self;
88
89    fn fetch(world: &mut State) -> Self::Item {
90        let actual_ref = world.message_mut::<T>();
91        let static_ref: &'static mut Messages<T> = unsafe { transmute(actual_ref) };
92        MsgM::new(static_ref)
93    }
94}
95
96pub struct ReAll<'a> {
97    value: &'a mut ResourceStorage,
98}
99impl<'a> ReAll<'a> {
100    pub fn new(value: &'a mut ResourceStorage) -> Self {
101        Self { value }
102    }
103}
104
105impl<'a> Deref for ReAll<'a> {
106    type Target = ResourceStorage;
107
108    fn deref(&self) -> &Self::Target {
109        self.value
110    }
111}
112
113impl<'a> DerefMut for ReAll<'a> {
114    fn deref_mut(&mut self) -> &mut Self::Target {
115        self.value
116    }
117}
118
119impl SystemParam for ReAll<'static> {
120    type Item = Self;
121
122    fn fetch(world: &mut State) -> Self::Item {
123        let actual_ref: &mut ResourceStorage = world.resources_mut();
124        let static_ref: &'static mut ResourceStorage = unsafe { transmute(actual_ref) };
125        ReAll::new(static_ref)
126    }
127}
128
129// ====================
130
131pub struct Msg<'a, T: 'static + Message> {
132    value: &'a Messages<T>,
133}
134
135impl<'a, T: Message> Msg<'a, T> {
136    #[must_use]
137    pub const fn new(value: &'a Messages<T>) -> Self {
138        Self { value }
139    }
140}
141
142impl<'a, T: Message> Deref for Msg<'a, T> {
143    type Target = Messages<T>;
144
145    fn deref(&self) -> &Self::Target {
146        self.value
147    }
148}
149
150// Mutable message access
151pub struct MsgM<'a, T: 'static + Message> {
152    value: &'a mut Messages<T>,
153}
154
155impl<'a, T: Message> crate::system_types::MsgM<'a, T> {
156    pub fn new(value: &'a mut Messages<T>) -> Self {
157        Self { value }
158    }
159}
160
161impl<'a, T: Message> Deref for crate::system_types::MsgM<'a, T> {
162    type Target = Messages<T>;
163
164    fn deref(&self) -> &Self::Target {
165        self.value
166    }
167}
168
169impl<'a, T: Message> DerefMut for crate::system_types::MsgM<'a, T> {
170    fn deref_mut(&mut self) -> &mut Self::Target {
171        self.value
172    }
173}
swamp_app/system_types.rs

swamp_app/
system_types.rs
