nrf-modem 0.10.2

Async modem api for the nRF91xx
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

// Ok, this is gonna be really unsafe...
pub struct WakerNode<T: ?Sized> {
    pub context: Option<*mut T>,
    pub waker: core::task::Waker,
    previous_node: Option<*mut WakerNode<T>>,
    next_node: Option<*mut WakerNode<T>>,
}

impl<T: ?Sized> WakerNode<T> {
    pub fn new(context: Option<*mut T>, waker: core::task::Waker) -> Self {
        Self {
            context,
            waker,
            previous_node: None,
            next_node: None,
        }
    }
}

pub struct WakerNodeList<T: ?Sized> {
    next_node: Option<*mut WakerNode<T>>,
}

unsafe impl<T: ?Sized> Send for WakerNodeList<T> {}
unsafe impl<T: ?Sized> Sync for WakerNodeList<T> {}

impl<T: ?Sized> WakerNodeList<T> {
    pub const fn new() -> Self {
        Self { next_node: None }
    }

    pub unsafe fn append_node(&mut self, node: *mut WakerNode<T>) {
        if node.is_null() {
            panic!("Node cannot be null");
        }

        let mut other = match self.next_node {
            Some(other) if !core::ptr::eq(other, node) => other,
            Some(_) => {
                // Already in the list
                return;
            }
            None => {
                self.next_node = Some(node);
                return;
            }
        };

        // Find the last one in the chain of the others
        loop {
            match (*other).next_node {
                Some(next_node) if !core::ptr::eq(next_node, node) => other = next_node,
                Some(_) => {
                    // Already in the list
                    return;
                }
                None => break,
            }
        }

        (*other).next_node = Some(node);
        (*node).previous_node = Some(other);
        (*node).next_node = None;
    }

    pub unsafe fn remove_node(&mut self, node: *mut WakerNode<T>) {
        if node.is_null() {
            panic!("Node cannot be null");
        }

        let next_node = (*node).next_node;
        let previous_node = (*node).previous_node;

        if let Some(next_node) = next_node {
            (*next_node).previous_node = previous_node
        }

        if let Some(previous_node) = previous_node {
            (*previous_node).next_node = next_node
        }

        if self.next_node == Some(node) {
            self.next_node = next_node;
        }

        (*node).next_node = None;
        (*node).previous_node = None;
    }

    /// Wakes all nodes
    pub fn wake_all(&mut self, mut wake_function: impl FnMut(&mut T)) {
        // Get the first node
        let mut node = match self.next_node {
            Some(node) => node,
            None => return,
        };

        unsafe {
            loop {
                // Run the callback if there is a context
                if let Some(context) = (*node).context {
                    wake_function(&mut *context);
                }

                // Wake the node
                (*node).waker.wake_by_ref();

                // Get the next node if there is one
                match (*node).next_node {
                    Some(next_node) => {
                        node = next_node;
                    }
                    None => {
                        break;
                    }
                }
            }
        }
    }
}