hexga_utils 0.0.11-beta.56

miscellaneous stuff, when somethings will be too big it will be on a separate crate
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
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170

use super::*;

pub mod prelude
{
    pub use super::traits::*;
    pub use super::{ButtonEvolution, ButtonRepeat, ButtonState, ButtonStateEvolution, ButtonToggle};
}
pub mod traits
{
    pub use super::{ButtonEvolutionExtension, ButtonRepeatExtension, ButtonStateExtension, ButtonToggleExtension};
}

pub type ButtonEvolution = PreviousValue<ButtonState>;

#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, Default)]
pub enum ButtonToggle
{
    /// False
    #[default]
    Hold,
    /// True
    Toggle,
}
pub trait ButtonToggleExtension: Has<ButtonToggle>
{
    fn is_hold(&self) -> bool { self.retrieve().is_hold() }
    fn is_toggle(&self) -> bool { self.retrieve().is_toggle() }
}
impl<T> ButtonToggleExtension for T where T: Has<ButtonToggle> {}

impl ButtonToggle
{
    pub const fn is_hold(self) -> bool { matches!(self, Self::Hold) }
    pub const fn is_toggle(self) -> bool { matches!(self, Self::Toggle) }
}
impl From<bool> for ButtonToggle
{
    fn from(value: bool) -> Self { if value { Self::Toggle } else { Self::Hold } }
}
impl From<ButtonToggle> for bool
{
    fn from(value: ButtonToggle) -> Self { value.is_toggle() }
}

/// Describes the state of a button.
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, Default)]
pub enum ButtonState
{
    /// True
    #[default]
    Down,
    /// False
    Up,
}
pub trait ButtonStateExtension: Has<ButtonState>
{
    fn is_up(&self) -> bool { self.retrieve().is_up() }
    fn is_down(&self) -> bool { self.retrieve().is_down() }
}
impl<T> ButtonStateExtension for T where T: Has<ButtonState> {}

impl ButtonState
{
    pub const fn is_up(self) -> bool { matches!(self, ButtonState::Up) }
    pub const fn is_down(self) -> bool { matches!(self, ButtonState::Down) }
}
impl From<bool> for ButtonState
{
    fn from(value: bool) -> Self { if value { Self::Down } else { Self::Up } }
}
impl From<ButtonState> for bool
{
    fn from(value: ButtonState) -> Self { value.is_down() }
}

#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub enum ButtonRepeat
{
    #[default]
    NotRepeated,
    Repeated,
}
pub trait ButtonRepeatExtension: Has<ButtonRepeat>
{
    fn is_repeated(&self) -> bool { self.retrieve().is_repeated() }
    fn is_not_repeated(&self) -> bool { self.retrieve().is_not_repeated() }
}
impl<T> ButtonRepeatExtension for T where T: Has<ButtonRepeat> {}

impl ButtonRepeat
{
    pub const fn is_repeated(self) -> bool { matches!(self, ButtonRepeat::Repeated) }
    pub const fn is_not_repeated(self) -> bool { matches!(self, ButtonRepeat::NotRepeated) }
}
impl From<bool> for ButtonRepeat
{
    fn from(value: bool) -> Self { if value { Self::Repeated } else { Self::NotRepeated } }
}
impl From<ButtonRepeat> for bool
{
    fn from(value: ButtonRepeat) -> Self { value.is_repeated() }
}

#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
pub enum ButtonStateEvolution
{
    Down,
    Up,
    /// Can be use for toggle
    Pressed,
    /// Can be use for toggle
    Released,
}
impl From<ButtonState> for ButtonStateEvolution
{
    fn from(value: ButtonState) -> Self
    {
        match value
        {
            ButtonState::Down => Self::Down,
            ButtonState::Up => Self::Up,
        }
    }
}
impl Evolution<ButtonState> for ButtonStateEvolution
{
    fn value(&self) -> ButtonState { matches!(self, Self::Down | Self::Pressed).into() }
    fn old_value(&self) -> ButtonState { matches!(self, Self::Down | Self::Released).into() }
}

pub trait ButtonEvolutionExtension: Evolution<ButtonState>
{
    fn is_down(&self) -> bool;
    fn was_down(&self) -> bool;

    fn is_up(&self) -> bool { !self.is_down() }
    fn was_up(&self) -> bool { !self.was_down() }

    /// Pull up, `false` to `true`, `0` to `1`,
    fn is_pressed(&self) -> bool { self.is_down() && (!self.was_down()) }
    /// Pull down, `true` to `false`, `1` to `0`
    fn is_released(&self) -> bool { self.was_down() && (!self.is_down()) }

    fn is_toggled(&self) -> bool { self.is_down() != self.was_down() }
    fn is_constant(&self) -> bool { self.is_down() == self.was_down() }

    fn is_hold(&self) -> bool { self.is_constant() && self.is_down() }

    fn evolution(&self) -> ButtonStateEvolution
    {
        match (self.is_down(), self.was_down())
        {
            (true, true) => ButtonStateEvolution::Down,
            (true, false) => ButtonStateEvolution::Pressed,
            (false, true) => ButtonStateEvolution::Released,
            (false, false) => ButtonStateEvolution::Up,
        }
    }
}

impl<T> ButtonEvolutionExtension for T
where
    T: Evolution<ButtonState>,
{
    fn is_down(&self) -> bool { self.value().is_down() }
    fn was_down(&self) -> bool { self.old_value().is_down() }
}