sdmmc-core 0.5.0

SD/MMC core data structures and algorithms
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

use crate::result::{Error, Result};
use crate::util::check_ascii;

pub const PRODUCT_NAME_LEN: usize = 5;

/// Represents the product name as a 5-character ASCII string.
#[repr(C)]
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct ProductName {
    name: [u8; PRODUCT_NAME_LEN],
}

impl ProductName {
    /// Creates a new [ProductName].
    pub const fn new() -> Self {
        Self {
            name: [0; PRODUCT_NAME_LEN],
        }
    }

    /// Gets a reference to the name of the [ProductName].
    pub const fn name(&self) -> &[u8] {
        &self.name
    }

    /// Converts a [ProductName] into a byte array.
    pub const fn bytes(self) -> [u8; PRODUCT_NAME_LEN] {
        self.name
    }

    /// Attempts to convert a byte slice into a [ProductName].
    pub const fn try_from_bytes(val: &[u8]) -> Result<Self> {
        match check_ascii(val, PRODUCT_NAME_LEN) {
            Ok(_) => Ok(Self {
                name: [val[0], val[1], val[2], val[3], val[4]],
            }),
            Err(err) => Err(err),
        }
    }
}

impl Default for ProductName {
    fn default() -> Self {
        Self::new()
    }
}

impl From<ProductName> for [u8; PRODUCT_NAME_LEN] {
    fn from(val: ProductName) -> Self {
        val.bytes()
    }
}

impl TryFrom<&[u8]> for ProductName {
    type Error = Error;

    fn try_from(val: &[u8]) -> Result<Self> {
        Self::try_from_bytes(val)
    }
}

impl<const N: usize> TryFrom<[u8; N]> for ProductName {
    type Error = Error;

    fn try_from(val: [u8; N]) -> Result<Self> {
        Self::try_from_bytes(val.as_ref())
    }
}

impl<const N: usize> TryFrom<&[u8; N]> for ProductName {
    type Error = Error;

    fn try_from(val: &[u8; N]) -> Result<Self> {
        Self::try_from_bytes(val.as_ref())
    }
}

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

    #[test]
    fn test_valid() {
        (0..=u8::MAX)
            .filter(|&c| (c as char).is_ascii())
            .for_each(|c| {
                let name = [c; PRODUCT_NAME_LEN];
                let exp_name = ProductName { name };

                assert_eq!(ProductName::try_from_bytes(name.as_ref()), Ok(exp_name));
                assert_eq!(ProductName::try_from(name.as_ref()), Ok(exp_name));
                assert_eq!(ProductName::try_from(name), Ok(exp_name));

                assert_eq!(exp_name.bytes(), name);
                assert_eq!(exp_name.name(), name.as_ref());
            });
    }

    #[test]
    fn test_invalid() {
        (0..=u8::MAX)
            .filter(|&c| !(c as char).is_ascii())
            .for_each(|c| {
                let name = [c; PRODUCT_NAME_LEN];

                assert_eq!(
                    ProductName::try_from_bytes(name.as_ref()),
                    Err(Error::InvalidVariant(c as usize))
                );
                assert_eq!(
                    ProductName::try_from(name.as_ref()),
                    Err(Error::InvalidVariant(c as usize))
                );
                assert_eq!(
                    ProductName::try_from(name),
                    Err(Error::InvalidVariant(c as usize))
                );
            });
    }
}