zmodem2 0.7.3

ZMODEM file transfer protocol
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
121
122
123
124
125
126

// SPDX-License-Identifier: MIT OR Apache-2.0
// Copyright (c) 2023-2025 Jarkko Sakkinen

//! A simple stack-allocated buffer with a fixed capacity for staging data coming
//! from the serial link.

use core::fmt;
use core::ops::{Deref, DerefMut};

/// An error indicating a buffer's capacity was exceeded.
#[derive(Debug, PartialEq)]
pub struct CapacityError;

/// A buffer type for incoming and outgoing and other flyaway data.
pub struct Buffer<const CAP: usize> {
    bytes: [u8; CAP],
    len: usize,
}

impl<const CAP: usize> Default for Buffer<CAP> {
    fn default() -> Self {
        Self::new()
    }
}

impl<const CAP: usize> Buffer<CAP> {
    /// Creates a new instance.
    #[must_use]
    pub const fn new() -> Self {
        Self {
            bytes: [0; CAP],
            len: 0,
        }
    }

    /// Returns the number of bytes stored in the buffer.
    #[must_use]
    pub const fn len(&self) -> usize {
        self.len
    }

    /// Returns the capacity of the buffer in bytes.
    #[must_use]
    #[allow(clippy::unused_self)]
    pub const fn capacity(&self) -> usize {
        CAP
    }

    /// Returns `true` if the buffer is empty.
    #[must_use]
    pub const fn is_empty(&self) -> bool {
        self.len() == 0
    }

    /// Resets buffer length back to zero.
    pub fn clear(&mut self) {
        self.len = 0;
    }

    /// Appends a byte to the buffer.
    ///
    /// # Errors
    ///
    /// Returns `Err(CapacityError)`, if the capacity would be exceeded.
    pub fn push(&mut self, value: u8) -> Result<(), CapacityError> {
        if self.len < CAP {
            self.bytes[self.len] = value;
            self.len += 1;
            Ok(())
        } else {
            Err(CapacityError)
        }
    }

    /// Copies bytes from a slice to the end of the buffer.
    ///
    /// # Errors
    ///
    /// Returns `Err(CapacityError)`, if the capacity would be exceeded.
    pub fn extend_from_slice(&mut self, slice: &[u8]) -> Result<(), CapacityError> {
        if self.len + slice.len() > CAP {
            return Err(CapacityError);
        }
        let end = self.len + slice.len();
        self.bytes[self.len..end].copy_from_slice(slice);
        self.len = end;
        Ok(())
    }
}

impl<const CAP: usize> fmt::Write for Buffer<CAP> {
    fn write_str(&mut self, s: &str) -> fmt::Result {
        self.extend_from_slice(s.as_bytes()).map_err(|_| fmt::Error)
    }
}

impl<const CAP: usize> Deref for Buffer<CAP> {
    type Target = [u8];

    fn deref(&self) -> &Self::Target {
        &self.bytes[0..self.len]
    }
}

impl<const CAP: usize> DerefMut for Buffer<CAP> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.bytes[0..self.len]
    }
}

impl<const CAP: usize> AsRef<[u8]> for Buffer<CAP> {
    fn as_ref(&self) -> &[u8] {
        &self.bytes[0..self.len]
    }
}

impl<const CAP: usize, T: ?Sized> PartialEq<T> for Buffer<CAP>
where
    T: AsRef<[u8]>,
{
    fn eq(&self, other: &T) -> bool {
        self.as_ref() == other.as_ref()
    }
}

impl<const CAP: usize> Eq for Buffer<CAP> {}