fawkes_crypto/core/
sizedvec.rs

1use std::{
2    iter::*,
3    ops::{Index, IndexMut},
4    slice::SliceIndex,
5    slice::{Iter, IterMut},
6    mem::MaybeUninit,
7    self
8};
9
10
11
12#[cfg(feature = "borsh_support")]
13use crate::borsh::{BorshSerialize, BorshDeserialize};
14
15#[cfg(feature = "serde_support")]
16use crate::serde::{Deserialize, Deserializer, Serialize, Serializer};
17
18#[derive(Debug, Clone)]
19pub struct SizedVec<T: Sized, const L: usize>([T; L]);
20
21impl<T, const L: usize> SizedVec<T, L> {
22    pub fn as_slice(&self) -> &[T] {
23        &self.0
24    }
25
26    pub fn as_mut_slice(&mut self) -> &mut [T] {
27        &mut self.0
28    }
29
30    pub fn iter(&self) -> Iter<'_, T> {
31        self.0.iter()
32    }
33
34    pub fn iter_mut(&mut self) -> IterMut<'_, T> {
35        self.0.iter_mut()
36    }
37}
38
39#[cfg(feature = "serde_support")]
40impl<T: Serialize, const L: usize> Serialize for SizedVec<T, L> {
41    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
42        self.0.serialize(serializer)
43    }
44}
45
46#[cfg(feature = "serde_support")]
47impl<'de, T: Deserialize<'de>, const L: usize> Deserialize<'de> for SizedVec<T, L> {
48    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<SizedVec<T, L>, D::Error> {
49        Vec::<T>::deserialize(deserializer).map(|v| SizedVec::<T, L>::from_iter(v))
50    }
51}
52
53
54#[cfg(feature = "borsh_support")]
55impl<T: BorshSerialize, const L: usize> BorshSerialize for SizedVec<T, L> {
56    fn serialize<W: std::io::Write>(&self, writer: &mut W) -> Result<(), std::io::Error> {
57        for i in 0..L {
58            self.0[i].serialize(writer)?;
59        }
60        Ok(())
61    }
62}
63
64#[cfg(feature = "borsh_support")]
65impl<T: BorshDeserialize, const L: usize> BorshDeserialize for SizedVec<T, L> {
66    fn deserialize(buf: &mut &[u8]) -> Result<Self, std::io::Error> {
67        (0..L).map(|_| T::deserialize(buf)).collect()
68    }
69}
70
71
72impl<T, const L: usize> FromIterator<T> for SizedVec<T, L> {
73    #[inline]
74    fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
75        let mut iter = iter.into_iter();
76        let mut data: [MaybeUninit<T>; L] = unsafe { MaybeUninit::uninit().assume_init()};
77
78        for i in 0..L {
79            data[i] = MaybeUninit::new(iter.next().expect("iterator is shorter than expected"));
80        }
81
82        assert!(iter.next().is_none(), "iterator is longer than expected");
83
84        SizedVec(unsafe { (&*(&MaybeUninit::new(data) as *const _ as *const MaybeUninit<_>)).assume_init_read() })
85    }
86}
87
88impl<T, I: SliceIndex<[T]>, const L: usize> Index<I> for SizedVec<T, L> {
89    type Output = I::Output;
90
91    #[inline]
92    fn index(&self, index: I) -> &Self::Output {
93        Index::index(&self.0, index)
94    }
95}
96
97impl<T, I: SliceIndex<[T]>, const L: usize> IndexMut<I> for SizedVec<T, L> {
98    #[inline]
99    fn index_mut(&mut self, index: I) -> &mut Self::Output {
100        IndexMut::index_mut(&mut self.0, index)
101    }
102}
fawkes_crypto/core/sizedvec.rs

fawkes_crypto/core/
sizedvec.rs
