irox-tools 0.10.3

Stuff that should have been in the Rust STL, but aren't
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

// SPDX-License-Identifier: MIT
// Copyright 2025 IROX Contributors
//

//!
//! Stack Buffers

pub use round::*;

mod round;
pub use fixed::*;

mod fixed;
pub use fixed_u8::*;
mod fixed_u8;
pub use round_u8::*;
mod round_u8;

use crate::cfg_feature_alloc;
cfg_feature_alloc! {
    extern crate alloc;

    pub use unlimited::*;
    mod unlimited;
}

///
/// Standard buffer functions
pub trait Buffer<T> {
    fn get(&self, index: usize) -> Option<&T>;
    fn get_mut(&mut self, index: usize) -> Option<&mut T>;
    fn capacity(&self) -> usize;
    fn len(&self) -> usize;
    fn clear(&mut self);

    fn front(&self) -> Option<&T>;
    fn front_mut(&mut self) -> Option<&mut T>;
    fn back(&self) -> Option<&T>;
    fn back_mut(&mut self) -> Option<&mut T>;
    fn pop_front(&mut self) -> Option<T>;
    fn pop_back(&mut self) -> Option<T>;
    fn push_front(&mut self, value: T) -> Result<(), T>;
    fn push_back(&mut self, value: T) -> Result<(), T>;
    fn push(&mut self, value: T) -> Result<(), T> {
        self.push_back(value)
    }

    fn is_empty(&self) -> bool {
        self.len() == 0
    }
    fn is_full(&self) -> bool {
        self.capacity() == self.len()
    }

    cfg_feature_alloc! {
        fn into_boxed_slice(mut self) -> alloc::boxed::Box<[T]> where Self: Sized {
            let mut vec = alloc::vec::Vec::<T>::with_capacity(self.len());
            while let Some(elem) = self.pop_front() {
                vec.push(elem);
            }
            vec.into_boxed_slice()
        }
    }
}

///
/// Trait used for things like [`Vec`] and [`VecDeq`] to pre-allocate and fill
/// with zeros.
pub trait ZeroedBuffer {
    type Output;
    fn new_zeroed(capacity: usize) -> Self::Output;
}