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
115
116
117
118
119
120
121

use std::hash::Hash;

#[macro_export]
macro_rules! define_label_type {
    (
        $(#[$label_attr:meta])*
        $label_name:ident,

        $(#[$id_attr:meta])*
        $id_name:ident $(,)?
    ) => {
        $(#[$id_attr])*
        #[derive(Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
        pub struct $id_name(::core::any::TypeId, &'static str);

        impl ::core::fmt::Debug for $id_name {
            fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                write!(f, "{}", self.1)
            }
        }

        $(#[$label_attr])*
        pub trait $label_name: 'static {
            /// Converts this type into an opaque, strongly-typed label.
            fn as_label(&self) -> $id_name {
                let id = self.type_id();
                let label = self.as_str();
                $id_name(id, label)
            }
            /// Returns the [`TypeId`] used to differentiate labels.
            fn type_id(&self) -> ::core::any::TypeId {
                ::core::any::TypeId::of::<Self>()
            }
            /// Returns the representation of this label as a string literal.
            ///
            /// In cases where you absolutely need a label to be determined at runtime,
            /// you can use [`Box::leak`] to get a `'static` reference.
            fn as_str(&self) -> &'static str;
        }

        impl $label_name for $id_name {
            fn as_label(&self) -> Self {
                *self
            }
            fn type_id(&self) -> ::core::any::TypeId {
                self.0
            }
            fn as_str(&self) -> &'static str {
                self.1
            }
        }

        impl<L: $label_name> $label_name for &'static L {
            #[inline]
            fn as_str(&self) -> &'static str {
                L::as_str(self)
            }
        }

        impl $label_name for &'static str {
            fn as_str(&self) -> Self {
                self
            }
        }
    };
}

#[macro_export]
macro_rules! define_label_enum {
    (
        $(#[$label_attr:meta])*
        $v:vis enum $enum_name:ident : $label_type:path {
            $( $item:ident ),* $(,)?
        }
    ) => {
        $(#[$label_attr])*
        #[non_exhaustive]
        #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
        $v enum $enum_name {
            $( $item ),*
        }

        impl $label_type for $enum_name {
            fn as_str(&self) -> &'static str {
                match self {
                    $(
                        Self::$item => concat!(stringify!($enum_name),"::",stringify!($item)),
                    )*
                }
            }
        }
    };
}

define_label_type!(SystemSet, SystemSetId);

define_label_enum! {
    pub enum CoreSystemSet: SystemSet {
        First,
        Update,
        Last,
    }
}

define_label_enum! {
    pub(crate) enum UndefinedSystemSet: SystemSet {
        Undefined
    }
}

#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, PartialOrd, Ord)]
pub struct SystemLabel(pub(crate) ::core::any::TypeId, pub(crate) &'static str);

impl SystemSet for SystemLabel {
    fn type_id(&self) -> ::core::any::TypeId {
        self.0
    }
    fn as_str(&self) -> &'static str {
        self.1
    }
}