jam_types/
fixed_vec.rs

1use super::*;
2use bounded_collections::Get;
3use codec::{decode_vec_with_len, ConstEncodedLen, Error as DecodeError, Output};
4use core::fmt;
5
6/// Trait for vector types which have a bounded length allowing element-wise transformation.
7pub trait BoundedMap<T, N: Get<u32>> {
8	/// Element-wise transformation of items using the given function.
9	///
10	/// - `f`: The transformation function.
11	///
12	/// Returns a new instance with all elements transformed using the function `f`.
13	fn map<U>(self, f: impl FnMut(T) -> U) -> BoundedVec<U, N>;
14	/// Element-wise transformation of item-references using the given function.
15	///
16	/// - `f`: The transformation function.
17	///
18	/// Returns a new instance with all element-references transformed using the function `f`.
19	fn map_ref<U>(&self, f: impl FnMut(&T) -> U) -> BoundedVec<U, N>;
20	/// Fallible element-wise transformation of items using the given function.
21	///
22	/// - `f`: The transformation function.
23	///
24	/// Returns a new instance with all elements transformed using the function `f`, or
25	/// `Err` if any invocation of `f` resulted in error.
26	fn try_map<U, E>(self, f: impl FnMut(T) -> Result<U, E>) -> Result<BoundedVec<U, N>, E>;
27	/// Fallible element-wise transformation of item-references using the given function.
28	///
29	/// - `f`: The transformation function.
30	///
31	/// Returns a new instance with all element-references transformed using the function `f`, or
32	/// `Err` if any invocation of `f` resulted in error.
33	fn try_map_ref<U, E>(&self, f: impl FnMut(&T) -> Result<U, E>) -> Result<BoundedVec<U, N>, E>;
34}
35impl<T, N: Get<u32>> BoundedMap<T, N> for BoundedVec<T, N> {
36	fn map<U>(self, f: impl FnMut(T) -> U) -> BoundedVec<U, N> {
37		BoundedVec::truncate_from(self.into_iter().map(f).collect::<Vec<_>>())
38	}
39	fn map_ref<U>(&self, f: impl FnMut(&T) -> U) -> BoundedVec<U, N> {
40		BoundedVec::truncate_from(self.iter().map(f).collect::<Vec<_>>())
41	}
42	fn try_map<U, E>(self, f: impl FnMut(T) -> Result<U, E>) -> Result<BoundedVec<U, N>, E> {
43		self.into_iter()
44			.map(f)
45			.collect::<Result<Vec<_>, E>>()
46			.map(BoundedVec::truncate_from)
47	}
48	fn try_map_ref<U, E>(&self, f: impl FnMut(&T) -> Result<U, E>) -> Result<BoundedVec<U, N>, E> {
49		self.iter().map(f).collect::<Result<Vec<_>, E>>().map(BoundedVec::truncate_from)
50	}
51}
52
53/// Vector type with a fixed length.
54///
55/// Can be used similarly to an array but which stores its elements on the heap.
56pub struct FixedVec<T, N: Get<u32>>(BoundedVec<T, N>);
57impl<T, N: Get<u32>> FixedVec<T, N> {
58	pub fn new(t: T) -> Self
59	where
60		T: Clone,
61	{
62		Self::from_fn(|_| t.clone())
63	}
64	pub fn padded(t: &[T]) -> Self
65	where
66		T: Default + Clone,
67	{
68		Self::from_fn(|i| t.get(i).cloned().unwrap_or_default())
69	}
70	pub fn from_fn(f: impl FnMut(usize) -> T) -> Self {
71		Self(BoundedVec::truncate_from((0..N::get() as usize).map(f).collect::<Vec<T>>()))
72	}
73	pub fn get(&self, i: usize) -> Option<&T> {
74		if i < N::get() as usize {
75			Some(&self.0[i])
76		} else {
77			None
78		}
79	}
80	pub fn get_mut(&mut self, i: usize) -> Option<&mut T> {
81		if i < N::get() as usize {
82			Some(&mut self.0[i])
83		} else {
84			None
85		}
86	}
87	pub fn len(&self) -> usize {
88		N::get() as usize
89	}
90	pub fn is_empty(&self) -> bool {
91		N::get() == 0
92	}
93	pub fn iter(&self) -> core::slice::Iter<'_, T> {
94		self.0.iter()
95	}
96	pub fn iter_mut(&mut self) -> core::slice::IterMut<'_, T> {
97		self.0.iter_mut()
98	}
99	pub fn map<U>(self, f: impl FnMut(T) -> U) -> FixedVec<U, N> {
100		FixedVec(BoundedVec::truncate_from(self.0.into_iter().map(f).collect::<Vec<_>>()))
101	}
102	pub fn map_ref<U>(&self, f: impl FnMut(&T) -> U) -> FixedVec<U, N> {
103		FixedVec(BoundedVec::truncate_from(self.0.iter().map(f).collect::<Vec<_>>()))
104	}
105	pub fn to_bounded(self) -> BoundedVec<T, N> {
106		self.0
107	}
108	pub fn to_vec(&self) -> Vec<T>
109	where
110		T: Clone,
111	{
112		self.0.to_vec()
113	}
114	pub fn into_vec(self) -> Vec<T> {
115		self.0.into()
116	}
117	pub fn truncate_into_vec(self, len: usize) -> Vec<T> {
118		let mut v = self.into_vec();
119		v.truncate(len);
120		v
121	}
122	pub fn slide(&mut self, index: usize, insert_at: usize) {
123		self.0.slide(index, insert_at);
124	}
125	pub fn force_insert_keep_left(&mut self, index: usize, element: T) -> Result<Option<T>, T> {
126		self.0.force_insert_keep_left(index, element)
127	}
128	pub fn force_insert_keep_right(&mut self, index: usize, element: T) -> Result<Option<T>, T> {
129		self.0.force_insert_keep_right(index, element)
130	}
131	pub fn force_push(&mut self, element: T) {
132		self.0.force_push(element);
133	}
134	pub fn swap(&mut self, a: usize, b: usize) {
135		self.0.as_mut().swap(a, b);
136	}
137	pub fn as_slice(&self) -> &[T] {
138		self.0.as_slice()
139	}
140	pub fn as_mut_slice(&mut self) -> &mut [T] {
141		self.0.as_mut()
142	}
143	pub fn as_ptr(&self) -> *const T {
144		self.0.as_ptr()
145	}
146	pub fn as_mut_ptr(&mut self) -> *mut T {
147		self.0.as_mut().as_mut_ptr()
148	}
149}
150
151impl<T: Encode, N: Get<u32>> Encode for FixedVec<T, N> {
152	fn size_hint(&self) -> usize {
153		self.0.size_hint() - 1
154	}
155	fn encode_to<D: Output + ?Sized>(&self, dest: &mut D) {
156		for t in self.0.iter() {
157			t.encode_to(dest);
158		}
159	}
160}
161
162impl<T: fmt::Debug, N: Get<u32>> fmt::Debug for FixedVec<T, N> {
163	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
164		match self.0.len() {
165			0 => write!(f, "[]"),
166			_ => {
167				write!(f, "[{:?}", self.0[0])?;
168				for i in 1..self.len() {
169					write!(f, ", {:?}", self.0[i])?;
170				}
171				write!(f, "]")
172			},
173		}
174	}
175}
176
177impl<T: ConstEncodedLen, N: Get<u32>> codec::ConstEncodedLen for FixedVec<T, N> {}
178
179impl<N: Get<u32>> fmt::Display for FixedVec<u8, N> {
180	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
181		let suffix = self.iter().rev().take_while(|&&x| x == 0).count();
182		let body = &self.0[..self.len() - suffix];
183		if !body.is_empty() {
184			if body.iter().all(|&x| (32..=127).contains(&x)) {
185				f.write_fmt(format_args!(
186					"\"{}\"",
187					core::str::from_utf8(body).expect("ASCII; qed")
188				))?;
189			}
190			if body.len() > 32 {
191				f.write_fmt(format_args!(
192					"0x{}..{}",
193					hex::hex(&body[..8]),
194					hex::hex(&body[body.len() - 4..])
195				))?;
196			} else {
197				f.write_fmt(format_args!("0x{}", hex::hex(body)))?;
198			}
199		}
200		if suffix != 0 {
201			f.write_fmt(format_args!("{}{suffix}*0", if !body.is_empty() { "+" } else { "" }))?;
202		}
203		Ok(())
204	}
205}
206
207impl<T: Decode, N: Get<u32>> Decode for FixedVec<T, N> {
208	fn decode<I: codec::Input>(input: &mut I) -> Result<Self, DecodeError> {
209		Ok(Self(BoundedVec::truncate_from(decode_vec_with_len(input, N::get() as usize)?)))
210	}
211}
212
213impl<T: MaxEncodedLen, N: Get<u32>> MaxEncodedLen for FixedVec<T, N> {
214	fn max_encoded_len() -> usize {
215		T::max_encoded_len() * N::get() as usize
216	}
217}
218
219impl<T: Clone, N: Get<u32>> Clone for FixedVec<T, N> {
220	fn clone(&self) -> Self {
221		Self(self.0.clone())
222	}
223}
224impl<T: Eq, N: Get<u32>> Eq for FixedVec<T, N> where T: Eq {}
225impl<T: PartialEq, N: Get<u32>> PartialEq for FixedVec<T, N> {
226	fn eq(&self, other: &Self) -> bool {
227		self.0[..] == other.0[..]
228	}
229}
230impl<T: Default, N: Get<u32>> Default for FixedVec<T, N> {
231	fn default() -> Self {
232		Self::from_fn(|_| T::default())
233	}
234}
235impl<T, N: Get<u32>> AsRef<[T]> for FixedVec<T, N> {
236	fn as_ref(&self) -> &[T] {
237		&self.0[..]
238	}
239}
240impl<T, N: Get<u32>> AsMut<[T]> for FixedVec<T, N> {
241	fn as_mut(&mut self) -> &mut [T] {
242		&mut self.0[..]
243	}
244}
245impl<T, N: Get<u32>> core::ops::Index<usize> for FixedVec<T, N> {
246	type Output = T;
247	fn index(&self, i: usize) -> &T {
248		&self.0[i]
249	}
250}
251impl<T, N: Get<u32>> core::ops::IndexMut<usize> for FixedVec<T, N> {
252	fn index_mut(&mut self, i: usize) -> &mut T {
253		&mut self.0[i]
254	}
255}
256impl<T, N: Get<u32>> core::ops::Index<core::ops::Range<usize>> for FixedVec<T, N> {
257	type Output = [T];
258
259	fn index(&self, index: core::ops::Range<usize>) -> &Self::Output {
260		&self.0[index]
261	}
262}
263impl<T, N: Get<u32>> core::ops::IndexMut<core::ops::Range<usize>> for FixedVec<T, N> {
264	fn index_mut(&mut self, index: core::ops::Range<usize>) -> &mut Self::Output {
265		&mut self.0[index]
266	}
267}
268impl<T, N: Get<u32>> core::ops::Index<core::ops::RangeFull> for FixedVec<T, N> {
269	type Output = [T];
270
271	fn index(&self, index: core::ops::RangeFull) -> &Self::Output {
272		&self.0[index]
273	}
274}
275impl<T, N: Get<u32>> core::ops::IndexMut<core::ops::RangeFull> for FixedVec<T, N> {
276	fn index_mut(&mut self, index: core::ops::RangeFull) -> &mut Self::Output {
277		&mut self.0[index]
278	}
279}
280impl<T, N: Get<u32>> From<FixedVec<T, N>> for Vec<T> {
281	fn from(s: FixedVec<T, N>) -> Vec<T> {
282		s.into_vec()
283	}
284}
285impl<T, N: Get<u32>> TryFrom<Vec<T>> for FixedVec<T, N> {
286	type Error = ();
287	fn try_from(v: Vec<T>) -> Result<Self, ()> {
288		if v.len() != N::get() as usize {
289			return Err(())
290		}
291		Ok(Self(BoundedVec::truncate_from(v)))
292	}
293}
294impl<T, N: Get<u32>> From<FixedVec<T, N>> for BoundedVec<T, N> {
295	fn from(s: FixedVec<T, N>) -> BoundedVec<T, N> {
296		s.0
297	}
298}
299impl<T, N: Get<u32>> TryFrom<BoundedVec<T, N>> for FixedVec<T, N> {
300	type Error = ();
301	fn try_from(v: BoundedVec<T, N>) -> Result<Self, ()> {
302		if v.len() != N::get() as usize {
303			return Err(())
304		}
305		Ok(Self(v))
306	}
307}
308impl<'a, T: Clone, N: Get<u32>> TryFrom<&'a [T]> for FixedVec<T, N> {
309	type Error = ();
310	fn try_from(v: &'a [T]) -> Result<Self, ()> {
311		if v.len() != N::get() as usize {
312			return Err(())
313		}
314		Ok(Self(BoundedVec::truncate_from(v.to_vec())))
315	}
316}
317#[cfg(feature = "serde")]
318impl<'de, T, S: Get<u32>> serde::Deserialize<'de> for FixedVec<T, S>
319where
320	T: serde::Deserialize<'de>,
321{
322	fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
323	where
324		D: serde::Deserializer<'de>,
325	{
326		use serde::de::Error;
327		let result = BoundedVec::deserialize(deserializer)?;
328		if result.len() != S::get() as usize {
329			return Err(D::Error::custom("Invalid FixedVec length"))
330		}
331		Ok(Self(result))
332	}
333}
334
335#[cfg(feature = "serde")]
336impl<T, S: Get<u32>> serde::Serialize for FixedVec<T, S>
337where
338	T: serde::Serialize,
339{
340	fn serialize<SR>(&self, serializer: SR) -> Result<SR::Ok, SR::Error>
341	where
342		SR: serde::Serializer,
343	{
344		self.0.serialize(serializer)
345	}
346}
jam_types/fixed_vec.rs

jam_types/
fixed_vec.rs
