ble_data_struct/windows/descriptors/
windows_server_characteristic_configuration.rs

1//! Server Characteristic Configuration (Attribute Type: 0x2903) module for windows.
2
3#[cfg(target_os = "windows")]
4use windows::Storage::Streams::IBuffer;
5
6#[cfg(target_os = "windows")]
7use crate::{
8    descriptors::server_characteristic_configuration::ServerCharacteristicConfiguration,
9    windows::buffer::{i_buffer_to_vec, vec_to_i_buffer},
10};
11
12#[cfg(target_os = "windows")]
13impl TryFrom<IBuffer> for ServerCharacteristicConfiguration {
14    type Error = String;
15    /// Create [`ServerCharacteristicConfiguration`] from [`IBuffer`].
16    ///
17    /// # Examples
18    ///
19    /// ```
20    /// use windows::Storage::Streams::{DataWriter, IBuffer};
21    ///
22    /// use ble_data_struct::descriptors::server_characteristic_configuration::{
23    ///     ServerCharacteristicConfiguration, BROADCAST,
24    /// };
25    ///
26    /// let client_characteristic_configuration = ServerCharacteristicConfiguration::new(BROADCAST);
27    /// let data_writer = DataWriter::new().unwrap();
28    /// let ble_packet: Vec<u8> = client_characteristic_configuration.into();
29    /// data_writer.WriteBytes(&ble_packet).unwrap();
30    /// let buffer = data_writer.DetachBuffer().unwrap();
31    ///
32    /// let result = ServerCharacteristicConfiguration::try_from(buffer);
33    /// assert!(result.is_ok());
34    /// let value = result.unwrap();
35    /// assert!(value.is_broadcast());
36    /// ```
37    fn try_from(value: IBuffer) -> Result<Self, String> {
38        let vec = i_buffer_to_vec(value).unwrap();
39        let configuration = u16::from_le_bytes(vec.try_into().unwrap());
40        Ok(Self {
41            configuration: configuration,
42        })
43    }
44}
45
46#[cfg(target_os = "windows")]
47impl Into<IBuffer> for ServerCharacteristicConfiguration {
48    /// Create [`IBuffer`] from [`ServerCharacteristicConfiguration`].
49    ///
50    /// # Examples
51    ///
52    /// ```
53    /// use windows::Storage::Streams::{DataWriter, IBuffer};
54    ///
55    /// use ble_data_struct::{
56    ///     descriptors::server_characteristic_configuration::{
57    ///         ServerCharacteristicConfiguration, BROADCAST,
58    ///     },
59    ///     windows::buffer::i_buffer_to_vec,
60    /// };
61    ///
62    /// let value = ServerCharacteristicConfiguration::new(0);
63    /// let buffer: IBuffer = value.clone().into();
64    /// let vec: Vec<u8> = value.into();
65    /// assert_eq!(vec, i_buffer_to_vec(buffer).unwrap());
66    ///
67    /// let value = ServerCharacteristicConfiguration::new(BROADCAST);
68    /// let buffer: IBuffer = value.clone().into();
69    /// let vec: Vec<u8> = value.into();
70    /// assert_eq!(vec, i_buffer_to_vec(buffer).unwrap());
71    /// ```
72    fn into(self) -> IBuffer {
73        let vec: Vec<u8> = self.into();
74        vec_to_i_buffer(&vec).unwrap()
75    }
76}
77
78#[cfg(test)]
79mod tests {
80    use windows::Storage::Streams::{DataWriter, IBuffer};
81
82    use crate::{
83        descriptors::server_characteristic_configuration::{
84            ServerCharacteristicConfiguration, BROADCAST,
85        },
86        windows::buffer::i_buffer_to_vec,
87    };
88
89    #[test]
90    fn test_try_from_i_buffer() {
91        let client_characteristic_configuration = ServerCharacteristicConfiguration::new(BROADCAST);
92        let data_writer = DataWriter::new().unwrap();
93        let ble_packet: Vec<u8> = client_characteristic_configuration.into();
94        data_writer.WriteBytes(&ble_packet).unwrap();
95        let buffer = data_writer.DetachBuffer().unwrap();
96
97        let result = ServerCharacteristicConfiguration::try_from(buffer);
98        assert!(result.is_ok());
99        let value = result.unwrap();
100        assert!(value.is_broadcast());
101    }
102
103    #[test]
104    fn test_into_i_buffer() {
105        let value = ServerCharacteristicConfiguration::new(0);
106        let buffer: IBuffer = value.clone().into();
107        let vec: Vec<u8> = value.into();
108        assert_eq!(vec, i_buffer_to_vec(buffer).unwrap());
109
110        let value = ServerCharacteristicConfiguration::new(BROADCAST);
111        let buffer: IBuffer = value.clone().into();
112        let vec: Vec<u8> = value.into();
113        assert_eq!(vec, i_buffer_to_vec(buffer).unwrap());
114    }
115}