limnus_system_params/
lib.rs

1/*
2 * Copyright (c) Peter Bjorklund. All rights reserved. https://github.com/swamp/limnus
3 * Licensed under the MIT License. See LICENSE in the project root for license information.
4 */
5pub mod prelude;
6
7use limnus_local_resource::{LocalResource, LocalResourceStorage};
8use limnus_message::{Message, MessageStorage, Messages};
9use limnus_resource::{Resource, ResourceStorage};
10use limnus_system::SystemParam;
11use limnus_system_state::State;
12use std::mem::transmute;
13use std::ops::{Deref, DerefMut};
14
15// Mutable resource access
16pub struct ReM<'a, T: 'static> {
17    value: &'a mut T,
18}
19
20impl<'a, T> ReM<'a, T> {
21    pub const fn new(value: &'a mut T) -> Self {
22        Self { value }
23    }
24}
25
26impl<T> Deref for ReM<'_, T> {
27    type Target = T;
28
29    fn deref(&self) -> &Self::Target {
30        self.value
31    }
32}
33
34impl<T> DerefMut for ReM<'_, T> {
35    fn deref_mut(&mut self) -> &mut Self::Target {
36        self.value
37    }
38}
39
40// Mutable resource access
41pub struct Re<'a, T: 'static> {
42    value: &'a T,
43}
44
45impl<'a, T> Re<'a, T> {
46    pub const fn new(value: &'a T) -> Self {
47        Self { value }
48    }
49}
50
51impl<T> Deref for Re<'_, T> {
52    type Target = T;
53
54    fn deref(&self) -> &Self::Target {
55        self.value
56    }
57}
58
59impl<T: Resource + 'static> SystemParam for ReM<'static, T> {
60    type Item = Self;
61
62    fn get(world: &mut State) -> Option<Self::Item> {
63        let actual_ref = world.resource_mut::<T>()?;
64        let static_ref: &'static mut T = unsafe { transmute(actual_ref) };
65        Some(ReM::new(static_ref))
66    }
67}
68
69impl<T: Resource + 'static> SystemParam for Re<'static, T> {
70    type Item = Self;
71
72    fn get(world: &mut State) -> Option<Self::Item> {
73        let actual_ref = world.resource_mut::<T>()?;
74        let static_ref: &'static mut T = unsafe { transmute(actual_ref) };
75        Some(Re::new(static_ref))
76    }
77}
78
79impl<T: 'static + Message> SystemParam for Msg<'static, T> {
80    type Item = Self;
81
82    fn get(world: &mut State) -> Option<Self::Item> {
83        let actual_ref = world.message::<T>()?;
84        let static_ref: &'static Messages<T> = unsafe { transmute(actual_ref) };
85        Some(Msg::new(static_ref))
86    }
87}
88
89impl<T: 'static + Message> SystemParam for MsgM<'static, T> {
90    type Item = Self;
91
92    fn get(world: &mut State) -> Option<Self::Item> {
93        let actual_ref = world.message_mut::<T>()?;
94        let static_ref: &'static mut Messages<T> = unsafe { transmute(actual_ref) };
95        Some(MsgM::new(static_ref))
96    }
97}
98
99pub struct ReAll<'a> {
100    value: &'a mut ResourceStorage,
101}
102impl<'a> ReAll<'a> {
103    pub const fn new(value: &'a mut ResourceStorage) -> Self {
104        Self { value }
105    }
106}
107
108impl Deref for ReAll<'_> {
109    type Target = ResourceStorage;
110
111    fn deref(&self) -> &Self::Target {
112        self.value
113    }
114}
115
116impl DerefMut for ReAll<'_> {
117    fn deref_mut(&mut self) -> &mut Self::Target {
118        self.value
119    }
120}
121
122impl SystemParam for ReAll<'static> {
123    type Item = Self;
124
125    fn get(world: &mut State) -> Option<Self::Item> {
126        let actual_ref: &mut ResourceStorage = world.resources_mut();
127        let static_ref: &'static mut ResourceStorage = unsafe { transmute(actual_ref) };
128        Some(ReAll::new(static_ref))
129    }
130}
131
132// ====================
133
134pub struct Msg<'a, T: 'static + Message> {
135    value: &'a Messages<T>,
136}
137
138impl<'a, T: Message> Msg<'a, T> {
139    #[must_use]
140    pub const fn new(value: &'a Messages<T>) -> Self {
141        Self { value }
142    }
143}
144
145impl<T: Message> Deref for Msg<'_, T> {
146    type Target = Messages<T>;
147
148    fn deref(&self) -> &Self::Target {
149        self.value
150    }
151}
152
153// Mutable message access
154pub struct MsgM<'a, T: 'static + Message> {
155    value: &'a mut Messages<T>,
156}
157
158impl<'a, T: Message> MsgM<'a, T> {
159    pub const fn new(value: &'a mut Messages<T>) -> Self {
160        Self { value }
161    }
162}
163
164impl<T: Message> Deref for MsgM<'_, T> {
165    type Target = Messages<T>;
166
167    fn deref(&self) -> &Self::Target {
168        self.value
169    }
170}
171
172impl<T: Message> DerefMut for MsgM<'_, T> {
173    fn deref_mut(&mut self) -> &mut Self::Target {
174        self.value
175    }
176}
177
178pub struct MsgAll<'a> {
179    value: &'a mut MessageStorage,
180}
181impl<'a> MsgAll<'a> {
182    pub const fn new(value: &'a mut MessageStorage) -> Self {
183        Self { value }
184    }
185}
186
187impl Deref for MsgAll<'_> {
188    type Target = MessageStorage;
189
190    fn deref(&self) -> &Self::Target {
191        self.value
192    }
193}
194
195impl DerefMut for MsgAll<'_> {
196    fn deref_mut(&mut self) -> &mut Self::Target {
197        self.value
198    }
199}
200
201impl SystemParam for MsgAll<'static> {
202    type Item = Self;
203
204    fn get(world: &mut State) -> Option<Self::Item> {
205        let actual_ref: &mut MessageStorage = world.messages_mut();
206        let static_ref: &'static mut MessageStorage = unsafe { transmute(actual_ref) };
207        Some(MsgAll::new(static_ref))
208    }
209}
210
211// ==========  Local resources
212
213pub struct LoReAll<'a> {
214    value: &'a mut LocalResourceStorage,
215}
216impl<'a> LoReAll<'a> {
217    pub const fn new(value: &'a mut LocalResourceStorage) -> Self {
218        Self { value }
219    }
220}
221
222impl Deref for LoReAll<'_> {
223    type Target = LocalResourceStorage;
224
225    fn deref(&self) -> &Self::Target {
226        self.value
227    }
228}
229
230impl DerefMut for LoReAll<'_> {
231    fn deref_mut(&mut self) -> &mut Self::Target {
232        self.value
233    }
234}
235
236impl SystemParam for LoReAll<'static> {
237    type Item = Self;
238
239    fn get(world: &mut State) -> Option<Self::Item> {
240        let actual_ref: &mut LocalResourceStorage = world.local_resources_mut();
241        let static_ref: &'static mut LocalResourceStorage = unsafe { transmute(actual_ref) };
242        Some(LoReAll::new(static_ref))
243    }
244}
245
246// === Local Resources
247
248// Mutable local resource access
249pub struct LoReM<'a, T: 'static> {
250    value: &'a mut T,
251}
252
253impl<'a, T> LoReM<'a, T> {
254    pub const fn new(value: &'a mut T) -> Self {
255        Self { value }
256    }
257}
258
259impl<T> Deref for LoReM<'_, T> {
260    type Target = T;
261
262    fn deref(&self) -> &Self::Target {
263        self.value
264    }
265}
266
267impl<T> DerefMut for LoReM<'_, T> {
268    fn deref_mut(&mut self) -> &mut Self::Target {
269        self.value
270    }
271}
272
273impl<T: LocalResource + 'static> SystemParam for LoReM<'static, T> {
274    type Item = Self;
275
276    fn get(world: &mut State) -> Option<Self::Item> {
277        let actual_ref = world.local_resource_mut::<T>()?;
278        let static_ref: &'static mut T = unsafe { transmute(actual_ref) };
279        Some(LoReM::new(static_ref))
280    }
281}
282
283// Mutable local resource access
284pub struct LoRe<'a, T: 'static> {
285    value: &'a T,
286}
287
288impl<'a, T> LoRe<'a, T> {
289    pub const fn new(value: &'a T) -> Self {
290        Self { value }
291    }
292}
293
294impl<T> Deref for LoRe<'_, T> {
295    type Target = T;
296
297    fn deref(&self) -> &Self::Target {
298        self.value
299    }
300}
301
302impl<T: LocalResource + 'static> SystemParam for LoRe<'static, T> {
303    type Item = Self;
304
305    fn get(world: &mut State) -> Option<Self::Item> {
306        let actual_ref = world.local_resource_mut::<T>()?;
307        let static_ref: &'static mut T = unsafe { transmute(actual_ref) };
308        Some(LoRe::new(static_ref))
309    }
310}
limnus_system_params/lib.rs

limnus_system_params/
lib.rs
