cecs 0.1.11

Entity database for the game 'Cao-Lo'
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

use std::sync::atomic::{AtomicBool, Ordering};

use crate::query::WorldQuery;

/// Gives unique access to the world
///
/// Systems that take `WorldAccess` can not have other queries and will run in their own schedule
/// group.
///
///
/// ```
/// use cecs::prelude::*;
///
/// fn sys(mut access: WorldAccess) {
///     let w = access.world_mut();
///     // you can use the world as you would normally
///     w.run_system(||{}).unwrap();
/// }
///
/// let mut world = World::new(0);
/// ```
///
/// ## Limitation
///
/// You must not stack WorldAccess queries! Do not run a system that needs WorldAccess inside
/// another system with WorldAccess as they might violate Rust's borrow rules.
///
/// WorldAccess is unstable and the author would recommend avoiding using it for now
pub struct WorldAccess<'a> {
    world: std::ptr::NonNull<crate::World>,
    _guard: WorldLockGuard<'a>,
}

// this has nothing World specific in it, I just suck at naming
//
// this lock's job is to panic if users try to stack WorldAccesses
pub(crate) struct WorldLock {
    locked: AtomicBool,
}

pub(crate) struct WorldLockGuard<'a> {
    lock: &'a WorldLock,
}

impl<'a> Drop for WorldLockGuard<'a> {
    fn drop(&mut self) {
        self.lock.unlock();
    }
}

impl WorldLock {
    pub fn new() -> Self {
        Self {
            locked: AtomicBool::new(false),
        }
    }

    pub fn lock(&self) -> WorldLockGuard<'_> {
        self.locked
            .compare_exchange(false, true, Ordering::AcqRel, Ordering::Relaxed)
            .expect("Can not be locked twice");
        WorldLockGuard { lock: self }
    }

    pub fn unlock(&self) {
        self.locked.store(false, Ordering::Release);
    }
}

impl WorldAccess<'_> {
    pub fn world(&self) -> &crate::World {
        unsafe { self.world.as_ref() }
    }

    pub fn world_mut(&mut self) -> &mut crate::World {
        unsafe { self.world.as_mut() }
    }
}

unsafe impl Send for WorldAccess<'_> {}
unsafe impl Sync for WorldAccess<'_> {}

unsafe impl<'a> WorldQuery<'a> for WorldAccess<'a> {
    fn new(db: &'a crate::World, _system_idx: usize) -> Self {
        let _guard = db.this_lock.lock();
        WorldAccess {
            world: db.into(),
            _guard,
        }
    }

    fn exclusive() -> bool {
        true
    }

    fn read_only() -> bool {
        false
    }
}