emcyphal 0.1.0

Async Cyphal/CAN network stack for no_std environments
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

/// Array of N1 + N2 elements with uniform access
///
/// This is a workaround for [T; {N1 + N2}] in stable rust
#[repr(C)]
pub struct DuplexArray<T, const N1: usize, const N2: usize>([T; N1], [T; N2]);

impl<T, const N1: usize, const N2: usize> DuplexArray<T, N1, N2> {
    #[allow(clippy::redundant_closure)]
    pub fn from_fn(mut cb: impl FnMut(usize) -> T) -> Self {
        Self(
            core::array::from_fn(|i| cb(i)),
            core::array::from_fn(|i| cb(N1 + i)),
        )
    }
}

impl<T: Clone, const N1: usize, const N2: usize> DuplexArray<T, N1, N2> {
    #[allow(clippy::redundant_closure)]
    pub fn repeat(val: T) -> Self {
        Self(core::array::repeat(val.clone()), core::array::repeat(val))
    }
}

impl<T: Default, const N1: usize, const N2: usize> Default for DuplexArray<T, N1, N2> {
    fn default() -> Self {
        Self(
            core::array::from_fn(|_| Default::default()),
            core::array::from_fn(|_| Default::default()),
        )
    }
}

impl<T, const N1: usize, const N2: usize> core::ops::Deref for DuplexArray<T, N1, N2> {
    type Target = [T];

    fn deref(&self) -> &Self::Target {
        // SAFETY: DuplexArray is #[repr(C)] so the two arrays are laid out contiguously
        unsafe { core::slice::from_raw_parts(self.0.as_ptr(), N1 + N2) }
    }
}

impl<T, const N1: usize, const N2: usize> core::ops::DerefMut for DuplexArray<T, N1, N2> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        // SAFETY: DuplexArray is #[repr(C)] so the two arrays are laid out contiguously
        unsafe { core::slice::from_raw_parts_mut(self.0.as_mut_ptr(), N1 + N2) }
    }
}

/// Array of N1 + N2 + N3 elements with uniform access
///
/// This is a workaround for [T; {N1 + N2 + N3}] in stable rust
#[repr(C)]
pub struct TriplexArray<T, const N1: usize, const N2: usize, const N3: usize>(
    [T; N1],
    [T; N2],
    [T; N3],
);

impl<T, const N1: usize, const N2: usize, const N3: usize> TriplexArray<T, N1, N2, N3> {
    #[allow(clippy::redundant_closure)]
    pub fn from_fn(mut cb: impl FnMut(usize) -> T) -> Self {
        Self(
            core::array::from_fn(|i| cb(i)),
            core::array::from_fn(|i| cb(N1 + i)),
            core::array::from_fn(|i| cb(N1 + N2 + i)),
        )
    }

    pub const fn len(&self) -> usize {
        N1 + N2 + N3
    }
}

impl<T: Default, const N1: usize, const N2: usize, const N3: usize> Default
    for TriplexArray<T, N1, N2, N3>
{
    fn default() -> Self {
        Self(
            core::array::from_fn(|_| Default::default()),
            core::array::from_fn(|_| Default::default()),
            core::array::from_fn(|_| Default::default()),
        )
    }
}

impl<T, const N1: usize, const N2: usize, const N3: usize> core::ops::Deref
    for TriplexArray<T, N1, N2, N3>
{
    type Target = [T];

    fn deref(&self) -> &Self::Target {
        // SAFETY: TriplexArray is #[repr(C)] so the three arrays are laid out contiguously
        unsafe { core::slice::from_raw_parts(self.0.as_ptr(), N1 + N2 + N3) }
    }
}

impl<T, const N1: usize, const N2: usize, const N3: usize> core::ops::DerefMut
    for TriplexArray<T, N1, N2, N3>
{
    fn deref_mut(&mut self) -> &mut Self::Target {
        // SAFETY: TriplexArray is #[repr(C)] so the three arrays are laid out contiguously
        unsafe { core::slice::from_raw_parts_mut(self.0.as_mut_ptr(), N1 + N2 + N3) }
    }
}