value_traits/impls/
vectors.rs

1/*
2 * SPDX-FileCopyrightText: 2025 Tommaso Fontana
3 * SPDX-FileCopyrightText: 2025 Sebastiano Vigna
4 * SPDX-FileCopyrightText: 2025 Inria
5 *
6 * SPDX-License-Identifier: Apache-2.0 OR LGPL-2.1-or-later
7 */
8
9//! Implementations of by-value traits for vectors of [cloneable](Clone) types.
10//!
11//! This module is only available if the `alloc` feature is enabled.
12
13#![cfg(feature = "alloc")]
14
15#[cfg(all(feature = "alloc", not(feature = "std")))]
16use alloc::vec::Vec;
17
18use core::{
19    iter::{Cloned, Skip},
20    ops::{Range, RangeFrom, RangeFull, RangeInclusive, RangeTo, RangeToInclusive},
21};
22use std::collections::VecDeque;
23
24use crate::{
25    iter::{
26        Iter, IterFrom, IterateByValue, IterateByValueFrom, IterateByValueFromGat,
27        IterateByValueGat,
28    },
29    slices::{
30        SliceByValue, SliceByValueGet, SliceByValueRepl, SliceByValueSet, SliceByValueSubsliceGat,
31        SliceByValueSubsliceGatMut, SliceByValueSubsliceRange, SliceByValueSubsliceRangeMut,
32        Subslice, SubsliceMut,
33    },
34};
35
36impl<T> SliceByValue for Vec<T> {
37    type Value = T;
38    #[inline]
39    fn len(&self) -> usize {
40        <[T]>::len(self)
41    }
42}
43
44impl<T: Clone> SliceByValueGet for Vec<T> {
45    #[inline]
46    fn get_value(&self, index: usize) -> Option<Self::Value> {
47        (*self).get(index).cloned()
48    }
49
50    #[inline]
51    fn index_value(&self, index: usize) -> Self::Value {
52        self[index].clone()
53    }
54
55    #[inline]
56    unsafe fn get_value_unchecked(&self, index: usize) -> Self::Value {
57        // SAFETY: index is within bounds
58        let val_ref = unsafe { (*self).get_unchecked(index) };
59        val_ref.clone()
60    }
61}
62
63impl<T: Clone> SliceByValueRepl for Vec<T> {
64    #[inline]
65    fn replace_value(&mut self, index: usize, value: Self::Value) -> Self::Value {
66        core::mem::replace(&mut self[index], value)
67    }
68
69    #[inline]
70    unsafe fn replace_value_unchecked(&mut self, index: usize, value: Self::Value) -> Self::Value {
71        // SAFETY: index is within bounds
72        let val_mut = unsafe { self.get_unchecked_mut(index) };
73        core::mem::replace(val_mut, value)
74    }
75}
76
77impl<T: Clone> SliceByValueSet for Vec<T> {
78    #[inline]
79    fn set_value(&mut self, index: usize, value: Self::Value) {
80        self[index] = value;
81    }
82
83    #[inline]
84    unsafe fn set_value_unchecked(&mut self, index: usize, value: Self::Value) {
85        // SAFETY: index is within bounds
86        let val_mut = { self.get_unchecked_mut(index) };
87        *val_mut = value;
88    }
89}
90
91impl<'a, T: Clone> SliceByValueSubsliceGat<'a> for Vec<T> {
92    type Subslice = &'a [T];
93}
94impl<'a, T: Clone> SliceByValueSubsliceGatMut<'a> for Vec<T> {
95    type SubsliceMut = &'a mut [T];
96}
97
98macro_rules! impl_range_vecs {
99    ($range:ty) => {
100        impl<T: Clone> SliceByValueSubsliceRange<$range> for Vec<T> {
101            #[inline]
102            fn get_subslice(&self, index: $range) -> Option<Subslice<'_, Self>> {
103                (*self).get(index)
104            }
105
106            #[inline]
107            fn index_subslice(&self, index: $range) -> Subslice<'_, Self> {
108                &self[index]
109            }
110
111            #[inline]
112            unsafe fn get_subslice_unchecked(&self, index: $range) -> Subslice<'_, Self> {
113                unsafe { (*self).get_unchecked(index) }
114            }
115        }
116        impl<T: Clone> SliceByValueSubsliceRangeMut<$range> for Vec<T> {
117            #[inline]
118            fn get_subslice_mut(&mut self, index: $range) -> Option<SubsliceMut<'_, Self>> {
119                (*self).get_mut(index)
120            }
121
122            #[inline]
123            fn index_subslice_mut(&mut self, index: $range) -> SubsliceMut<'_, Self> {
124                &mut self[index]
125            }
126
127            #[inline]
128            unsafe fn get_subslice_unchecked_mut(
129                &mut self,
130                index: $range,
131            ) -> SubsliceMut<'_, Self> {
132                unsafe { (*self).get_unchecked_mut(index) }
133            }
134        }
135    };
136}
137
138impl_range_vecs!(RangeFull);
139impl_range_vecs!(RangeFrom<usize>);
140impl_range_vecs!(RangeTo<usize>);
141impl_range_vecs!(Range<usize>);
142impl_range_vecs!(RangeInclusive<usize>);
143impl_range_vecs!(RangeToInclusive<usize>);
144
145impl<'a, T: Clone> IterateByValueGat<'a> for Vec<T> {
146    type Item = T;
147    type Iter = Cloned<core::slice::Iter<'a, T>>;
148}
149
150impl<T: Clone> IterateByValue for Vec<T> {
151    fn iter_value(&self) -> Iter<'_, Self> {
152        self.iter().cloned()
153    }
154}
155
156impl<'a, T: Clone> IterateByValueFromGat<'a> for Vec<T> {
157    type Item = T;
158    type IterFrom = Cloned<Skip<core::slice::Iter<'a, T>>>;
159}
160
161impl<T: Clone> IterateByValueFrom for Vec<T> {
162    fn iter_value_from(&self, from: usize) -> IterFrom<'_, Self> {
163        self.iter().skip(from).cloned()
164    }
165}
166
167impl<T> SliceByValue for VecDeque<T> {
168    type Value = T;
169    #[inline]
170    fn len(&self) -> usize {
171        self.len()
172    }
173}
174
175impl<T: Clone> SliceByValueGet for VecDeque<T> {
176    #[inline]
177    fn get_value(&self, index: usize) -> Option<Self::Value> {
178        (*self).get(index).cloned()
179    }
180
181    #[inline]
182    fn index_value(&self, index: usize) -> Self::Value {
183        self[index].clone()
184    }
185
186    #[inline]
187    unsafe fn get_value_unchecked(&self, index: usize) -> Self::Value {
188        // SAFETY: index is within bounds
189        let val_ref = unsafe { (*self).get(index).unwrap_unchecked() };
190        val_ref.clone()
191    }
192}
193
194impl<T: Clone> SliceByValueRepl for VecDeque<T> {
195    #[inline]
196    fn replace_value(&mut self, index: usize, value: Self::Value) -> Self::Value {
197        core::mem::replace(&mut self[index], value)
198    }
199
200    #[inline]
201    unsafe fn replace_value_unchecked(&mut self, index: usize, value: Self::Value) -> Self::Value {
202        // SAFETY: index is within bounds
203        let val_mut = unsafe { self.get_mut(index).unwrap_unchecked() };
204        core::mem::replace(val_mut, value)
205    }
206}
207
208impl<T: Clone> SliceByValueSet for VecDeque<T> {
209    #[inline]
210    fn set_value(&mut self, index: usize, value: Self::Value) {
211        self[index] = value;
212    }
213
214    #[inline]
215    unsafe fn set_value_unchecked(&mut self, index: usize, value: Self::Value) {
216        // SAFETY: index is within bounds
217        let val_mut = { self.get_mut(index).unwrap_unchecked() };
218        *val_mut = value;
219    }
220}
221
222impl<'a, T: Clone> IterateByValueGat<'a> for VecDeque<T> {
223    type Item = T;
224    type Iter = Cloned<std::collections::vec_deque::Iter<'a, T>>;
225}
226
227impl<T: Clone> IterateByValue for VecDeque<T> {
228    fn iter_value(&self) -> Iter<'_, Self> {
229        self.iter().cloned()
230    }
231}
232
233impl<'a, T: Clone> IterateByValueFromGat<'a> for VecDeque<T> {
234    type Item = T;
235    type IterFrom = Cloned<Skip<std::collections::vec_deque::Iter<'a, T>>>;
236}
237
238impl<T: Clone> IterateByValueFrom for VecDeque<T> {
239    fn iter_value_from(&self, from: usize) -> IterFrom<'_, Self> {
240        self.iter().skip(from).cloned()
241    }
242}
value_traits/impls/vectors.rs

value_traits/impls/
vectors.rs
