coap-message-implementations 0.2.0

Implementations of coap-message traits, and tools for building them
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

//! Implementations of storage buffers for messages.
#![cfg_attr(feature = "downcast", allow(unsafe_code))]

use super::*;

/// An implementation of [`MessageBuffer`] around a slice of memory.
///
/// As the code is not even pointer sized, it is copied in.
#[derive(Clone, Debug)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
pub struct SliceBuffer<'a> {
    code: u8,
    options_and_payload: &'a [u8],
}

impl<'a> SliceBuffer<'a> {
    /// Constructs a new slice message.
    ///
    /// This constructor is rarely needed, as [`Message::new_from_slice()`] is a short-cut
    /// for it.
    #[must_use]
    pub fn new(code: u8, options_and_payload: &'a [u8]) -> Self {
        Self {
            code,
            options_and_payload,
        }
    }
}

impl MessageBuffer for SliceBuffer<'_> {
    fn code(&self) -> u8 {
        self.code
    }
    fn tail(&self) -> &[u8] {
        self.options_and_payload
    }

    #[cfg(feature = "downcast")]
    fn static_variant() -> Option<LifetimesMatterLittle<impl 'static + MessageBuffer>> {
        // SAFETY: We don't hand out 'a slices, and we don't take any long-lived input.
        Some(unsafe { LifetimesMatterLittle::<SliceBuffer<'static>>::new() })
    }
}

/// The easiest implementation of [`MessageBufferMut`] that is backed by exclusive references.
pub struct SliceBufferMut<'a> {
    code: &'a mut u8,
    tail: &'a mut [u8],
}

impl<'a> SliceBufferMut<'a> {
    /// Marks an area of memory for construction of a message.
    ///
    /// This constructor is rarely needed, as [`MessageMut::new_in_slice()`] is a short-cut for
    /// it.
    pub fn new(code: &'a mut u8, tail: &'a mut [u8]) -> Self {
        Self { code, tail }
    }
}

impl MessageBufferMut for SliceBufferMut<'_> {
    fn code_mut(&mut self) -> &mut u8 {
        self.code
    }

    fn tail_mut(&mut self) -> &mut [u8] {
        self.tail
    }

    #[cfg(feature = "downcast")]
    fn static_mut_variant() -> Option<LifetimesMatterLittle<impl 'static + MessageBufferMut>> {
        // SAFETY: We don't hand out 'a slices, and we don't take any long-lived input.
        Some(unsafe { LifetimesMatterLittle::<SliceBufferMut<'static>>::new() })
    }
}

impl MessageBuffer for SliceBufferMut<'_> {
    fn code(&self) -> u8 {
        *self.code
    }

    fn tail(&self) -> &[u8] {
        self.tail
    }
}

impl MessageBuffer for core::convert::Infallible {
    fn code(&self) -> u8 {
        match *self {}
    }

    fn tail(&self) -> &[u8] {
        match *self {}
    }
}

impl MessageBufferMut for core::convert::Infallible {
    fn code_mut(&mut self) -> &mut u8 {
        match *self {}
    }

    fn tail_mut(&mut self) -> &mut [u8] {
        match *self {}
    }
}