cue_sdk/property/
int32.rs

1use cue_sdk_sys as ffi;
2use num_traits::ToPrimitive;
3
4use super::RefreshValueError;
5use crate::device::DeviceIndex;
6use crate::errors::get_last_error;
7use crate::internal::CuePropertyValueHolder;
8
9/// An `int32` property that can be refreshed to "check" the property at any point.
10#[derive(Debug, Clone, PartialEq)]
11pub struct Int32Property {
12    pub key: Int32PropertyKey,
13    device_index: DeviceIndex,
14    pub last_value: i32,
15}
16
17impl Int32Property {
18    pub(crate) fn new(
19        device_index: DeviceIndex,
20        key: Int32PropertyKey,
21        initial_value: i32,
22    ) -> Self {
23        Int32Property {
24            device_index,
25            key,
26            last_value: initial_value,
27        }
28    }
29
30    pub fn refresh_value(&mut self) -> Result<(), RefreshValueError> {
31        let mut new_value_holder = CuePropertyValueHolder::<i32>::new();
32        let was_successful = unsafe {
33            ffi::CorsairGetInt32PropertyValue(
34                self.device_index as i32,
35                self.key.into(),
36                new_value_holder.mut_ptr(),
37            )
38        };
39        if was_successful {
40            let updated_value = new_value_holder.value();
41            self.last_value = updated_value;
42            Ok(())
43        } else {
44            Err(RefreshValueError(get_last_error()))
45        }
46    }
47}
48
49/// The valid keys that some devices support for `int32` property lookups.
50#[derive(Debug, Clone, Copy, ToPrimitive, FromPrimitive, PartialEq)]
51#[cfg_attr(test, derive(EnumIter))]
52pub enum Int32PropertyKey {
53    HeadsetEqualizerPreset = ffi::CorsairDevicePropertyId_CDPI_Headset_EqualizerPreset as isize,
54}
55
56impl From<Int32PropertyKey> for u32 {
57    fn from(key: Int32PropertyKey) -> Self {
58        //this unwrap is covered for all variants in unit tests
59        key.to_u32().unwrap()
60    }
61}
62
63#[cfg(test)]
64mod tests {
65    #[cfg(test)]
66    use strum::IntoEnumIterator;
67
68    use super::{Int32Property, Int32PropertyKey};
69
70    #[test]
71    fn new() {
72        let prop = Int32Property::new(2, Int32PropertyKey::HeadsetEqualizerPreset, 12);
73        assert_eq!(
74            prop,
75            Int32Property {
76                device_index: 2,
77                key: Int32PropertyKey::HeadsetEqualizerPreset,
78                last_value: 12
79            }
80        )
81    }
82
83    #[test]
84    fn from_boolean_property_key_for_u32() {
85        for key in Int32PropertyKey::iter() {
86            u32::from(key); //ensure this never panics
87        }
88    }
89}