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
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120

use crate::utils::DuplexArray;
use crate::utils::multi_class_queue::MultiClassQueue;

const QUEUE_CLASS: u8 = 0;
const FREE_CLASS: u8 = QUEUE_CLASS + 1;
const CLASS_COUNT: usize = FREE_CLASS as usize + 1;

pub const MAX_CAPACITY: usize = u8::MAX as usize + 1 - CLASS_COUNT;

#[derive(Debug)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
pub struct NoKey;

const NO_ENTRY: u8 = u8::MAX;

pub struct IndexQueue<K, V, const K_MAX: usize, const N: usize> {
    keys: [Option<K>; N],
    values: [Option<V>; N],
    index: DuplexArray<u8, 1, K_MAX>,
    queue: MultiClassQueue<CLASS_COUNT, N>,
}

impl<K: Copy + Into<usize>, V, const K_MAX: usize, const N: usize> IndexQueue<K, V, K_MAX, N> {
    const _ASSERT: usize = MAX_CAPACITY - N;

    pub fn new() -> Self {
        let mut queue = MultiClassQueue::new();
        for i in 0..N {
            let entry = unwrap!(u8::try_from(i));
            queue.move_back(FREE_CLASS, entry);
        }

        Self {
            keys: core::array::from_fn(|_| None),
            values: core::array::from_fn(|_| None),
            index: DuplexArray::repeat(NO_ENTRY),
            queue,
        }
    }

    pub fn contains(&self, key: K) -> bool {
        self.get_index(key).is_ok()
    }

    pub fn get(&self, key: K) -> Option<&V> {
        let idx = self.get_index(key).ok()?;
        Some(unwrap!(self.values[usize::from(idx)].as_ref()))
    }

    pub fn get_mut(&mut self, key: K) -> Option<&mut V> {
        let idx = self.get_index(key).ok()?;
        Some(unwrap!(self.values[usize::from(idx)].as_mut()))
    }

    pub fn insert(&mut self, key: K, value: V) -> Result<Option<V>, (K, V)> {
        if key.into() > K_MAX {
            return Err((key, value));
        }

        if let Ok(idx) = self.get_index(key) {
            let value = unwrap!(self.values[usize::from(idx)].take());
            return Ok(Some(value));
        }

        let idx = match self.queue.front(FREE_CLASS) {
            Some(idx) => idx,
            None => return Err((key, value)),
        };
        self.queue.remove(idx);

        self.keys[usize::from(idx)] = Some(key);
        self.values[usize::from(idx)] = Some(value);
        self.index[key.into()] = idx;
        Ok(None)
    }

    pub fn remove(&mut self, key: K) -> Option<V> {
        let idx = self.get_index(key).ok()?;
        self.index[key.into()] = NO_ENTRY;
        self.queue.move_back(FREE_CLASS, idx);
        self.keys[usize::from(idx)] = None;
        Some(unwrap!(self.values[usize::from(idx)].take()))
    }

    pub fn front(&self) -> Option<K> {
        let idx = self.queue.front(QUEUE_CLASS)?;
        self.keys[usize::from(idx)]
    }

    pub fn back(&self) -> Option<K> {
        let idx = self.queue.back(QUEUE_CLASS)?;
        self.keys[usize::from(idx)]
    }

    pub fn enqueue_front(&mut self, key: K) -> Result<(), NoKey> {
        let idx = self.get_index(key)?;
        self.queue.move_front(QUEUE_CLASS, idx);
        Ok(())
    }

    pub fn enqueue_back(&mut self, key: K) -> Result<(), NoKey> {
        let idx = self.get_index(key)?;
        self.queue.move_back(QUEUE_CLASS, idx);
        Ok(())
    }

    pub fn dequeue(&mut self, key: K) -> Result<(), NoKey> {
        let idx = self.get_index(key)?;
        self.queue.remove(idx);
        Ok(())
    }

    fn get_index(&self, key: K) -> Result<u8, NoKey> {
        if key.into() > K_MAX {
            return Err(NoKey);
        }
        let idx = self.index[key.into()];
        if idx != NO_ENTRY { Ok(idx) } else { Err(NoKey) }
    }
}