maudio 0.1.5

Rust bindings to the miniaudio library
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

//! Resource Manager data source flags
use maudio_sys::ffi as sys;

type RmSourceFlagsRaw = sys::ma_resource_manager_data_source_flags;

/// For specific behaviour see documentation on functions where these flags are used
#[repr(transparent)]
#[derive(Debug, PartialEq, Clone, Copy, Hash, Eq)]
pub struct RmSourceFlags(RmSourceFlagsRaw);

impl RmSourceFlags {
    pub const NONE: Self = Self(0);

    pub const STREAM: Self = Self(
        sys::ma_resource_manager_data_source_flags_MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_STREAM,
    );

    pub const DECODE: Self = Self(
        sys::ma_resource_manager_data_source_flags_MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_DECODE,
    );

    pub const ASYNC: Self =
        Self(sys::ma_resource_manager_data_source_flags_MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_ASYNC);

    pub const WAIT_INIT: Self = Self(
        sys::ma_resource_manager_data_source_flags_MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_WAIT_INIT,
    );

    pub const UNKOWN_LENGTH: Self = Self(sys::ma_resource_manager_data_source_flags_MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_UNKNOWN_LENGTH);

    pub const LOOPING: Self = Self(
        sys::ma_resource_manager_data_source_flags_MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_LOOPING,
    );

    #[inline]
    #[allow(clippy::cast_sign_loss)]
    #[allow(clippy::useless_conversion)]
    #[allow(clippy::unnecessary_cast)]
    pub fn bits(self) -> u32 {
        self.0 as u32
    }

    /// Set or clear bits
    #[inline]
    pub const fn set(&mut self, other: Self, enabled: bool) {
        if enabled {
            self.0 |= other.0;
        } else {
            self.0 &= !other.0;
        }
    }

    /// Create RmSoourceFlags from a u32 bitmask
    #[inline]
    pub const fn from_bits(bits: u32) -> Self {
        Self(bits as RmSourceFlagsRaw)
    }

    /// Check if all the bits in other are set
    #[inline]
    pub const fn contains(self, other: Self) -> bool {
        (self.0 & other.0) == other.0
    }

    /// Check if any of the bits in other are set
    #[inline]
    pub const fn intersects(self, other: Self) -> bool {
        (self.0 & other.0) != 0
    }

    #[inline]
    pub const fn is_none(self) -> bool {
        self.0 == 0
    }

    #[inline]
    pub const fn insert(&mut self, other: Self) {
        self.0 |= other.0
    }

    #[inline]
    pub const fn remove(&mut self, other: Self) {
        self.0 &= !other.0
    }
}

impl core::ops::BitOr for RmSourceFlags {
    type Output = Self;
    #[inline]
    fn bitor(self, rhs: Self) -> Self {
        Self(self.0 | rhs.0)
    }
}

impl core::ops::BitOrAssign for RmSourceFlags {
    #[inline]
    fn bitor_assign(&mut self, rhs: Self) {
        self.0 |= rhs.0;
    }
}

impl core::ops::BitAnd for RmSourceFlags {
    type Output = Self;
    #[inline]
    fn bitand(self, rhs: Self) -> Self {
        Self(self.0 & rhs.0)
    }
}

impl core::ops::BitAndAssign for RmSourceFlags {
    #[inline]
    fn bitand_assign(&mut self, rhs: Self) {
        self.0 &= rhs.0;
    }
}

impl core::ops::BitXor for RmSourceFlags {
    type Output = Self;
    #[inline]
    fn bitxor(self, rhs: Self) -> Self {
        Self(self.0 ^ rhs.0)
    }
}

impl core::ops::Not for RmSourceFlags {
    type Output = Self;
    #[inline]
    fn not(self) -> Self {
        Self(!self.0)
    }
}

impl From<RmSourceFlags> for u32 {
    #[inline]
    #[allow(clippy::cast_sign_loss)]
    #[allow(clippy::useless_conversion)]
    #[allow(clippy::unnecessary_cast)]
    fn from(v: RmSourceFlags) -> u32 {
        v.0 as u32
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn build_resouce_man_data_source_flags() {
        let mut flag = RmSourceFlags::NONE;
        flag.insert(RmSourceFlags::ASYNC);
        assert!(flag == RmSourceFlags::ASYNC);
        flag.remove(RmSourceFlags::ASYNC);
        assert!(flag == RmSourceFlags::NONE);

        flag.insert(RmSourceFlags::ASYNC);
        flag.insert(RmSourceFlags::LOOPING);
        assert!(flag == (RmSourceFlags::ASYNC | RmSourceFlags::LOOPING));
        assert!(flag.contains(RmSourceFlags::ASYNC));
        assert!(flag.contains(RmSourceFlags::LOOPING));
        assert!(!flag.contains(RmSourceFlags::DECODE));

        flag.remove(RmSourceFlags::ASYNC);
        assert!(flag == RmSourceFlags::LOOPING);
    }
}