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 [`Vec`] and
10//! [`VecDeque`](std::collections::VecDeque) of [cloneable](Clone) types.
11//!
12//! The [`Vec`] implementations are available only if the `alloc` feature is
13//! enabled, while the [`VecDeque`](std::collections::VecDeque) implementations
14//! are available only if the `std` feature is enabled.
15
16#![cfg(feature = "alloc")]
17
18#[cfg(all(feature = "alloc", not(feature = "std")))]
19use alloc::vec::Vec;
20
21use core::{
22    iter::{Cloned, Skip},
23    ops::{Range, RangeFrom, RangeFull, RangeInclusive, RangeTo, RangeToInclusive},
24};
25
26use crate::{
27    iter::{
28        Iter, IterFrom, IterateByValue, IterateByValueFrom, IterateByValueFromGat,
29        IterateByValueGat,
30    },
31    slices::{
32        SliceByValue, SliceByValueMut, SliceByValueSubsliceGat, SliceByValueSubsliceGatMut,
33        SliceByValueSubsliceRange, SliceByValueSubsliceRangeMut, Subslice, SubsliceMut,
34    },
35};
36
37impl<T: Clone> SliceByValue for Vec<T> {
38    type Value = T;
39
40    #[inline]
41    fn len(&self) -> usize {
42        <[T]>::len(self)
43    }
44    #[inline]
45    fn get_value(&self, index: usize) -> Option<Self::Value> {
46        (*self).get(index).cloned()
47    }
48
49    #[inline]
50    fn index_value(&self, index: usize) -> Self::Value {
51        self[index].clone()
52    }
53
54    #[inline]
55    unsafe fn get_value_unchecked(&self, index: usize) -> Self::Value {
56        // SAFETY: index is within bounds
57        let val_ref = unsafe { (*self).get_unchecked(index) };
58        val_ref.clone()
59    }
60}
61
62impl<T: Clone> SliceByValueMut for Vec<T> {
63    #[inline]
64    fn set_value(&mut self, index: usize, value: Self::Value) {
65        self[index] = value;
66    }
67
68    #[inline]
69    unsafe fn set_value_unchecked(&mut self, index: usize, value: Self::Value) { unsafe {
70        // SAFETY: index is within bounds
71        let val_mut = { self.get_unchecked_mut(index) };
72        *val_mut = value;
73    }}
74
75    #[inline]
76    fn replace_value(&mut self, index: usize, value: Self::Value) -> Self::Value {
77        core::mem::replace(&mut self[index], value)
78    }
79
80    #[inline]
81    unsafe fn replace_value_unchecked(&mut self, index: usize, value: Self::Value) -> Self::Value {
82        // SAFETY: index is within bounds
83        let val_mut = unsafe { self.get_unchecked_mut(index) };
84        core::mem::replace(val_mut, value)
85    }
86
87    type ChunksMut<'a>
88        = core::slice::ChunksMut<'a, T>
89    where
90        Self: 'a;
91
92    type ChunksMutError = core::convert::Infallible;
93
94    #[inline]
95    fn try_chunks_mut(
96        &mut self,
97        chunk_size: usize,
98    ) -> Result<Self::ChunksMut<'_>, Self::ChunksMutError> {
99        Ok(self.chunks_mut(chunk_size))
100    }
101}
102
103impl<'a, T: Clone> SliceByValueSubsliceGat<'a> for Vec<T> {
104    type Subslice = &'a [T];
105}
106impl<'a, T: Clone> SliceByValueSubsliceGatMut<'a> for Vec<T> {
107    type SubsliceMut = &'a mut [T];
108}
109
110macro_rules! impl_range_vecs {
111    ($range:ty) => {
112        impl<T: Clone> SliceByValueSubsliceRange<$range> for Vec<T> {
113            #[inline]
114            fn get_subslice(&self, index: $range) -> Option<Subslice<'_, Self>> {
115                (*self).get(index)
116            }
117
118            #[inline]
119            fn index_subslice(&self, index: $range) -> Subslice<'_, Self> {
120                &self[index]
121            }
122
123            #[inline]
124            unsafe fn get_subslice_unchecked(&self, index: $range) -> Subslice<'_, Self> {
125                unsafe { (*self).get_unchecked(index) }
126            }
127        }
128        impl<T: Clone> SliceByValueSubsliceRangeMut<$range> for Vec<T> {
129            #[inline]
130            fn get_subslice_mut(&mut self, index: $range) -> Option<SubsliceMut<'_, Self>> {
131                (*self).get_mut(index)
132            }
133
134            #[inline]
135            fn index_subslice_mut(&mut self, index: $range) -> SubsliceMut<'_, Self> {
136                &mut self[index]
137            }
138
139            #[inline]
140            unsafe fn get_subslice_unchecked_mut(
141                &mut self,
142                index: $range,
143            ) -> SubsliceMut<'_, Self> {
144                unsafe { (*self).get_unchecked_mut(index) }
145            }
146        }
147    };
148}
149
150impl_range_vecs!(RangeFull);
151impl_range_vecs!(RangeFrom<usize>);
152impl_range_vecs!(RangeTo<usize>);
153impl_range_vecs!(Range<usize>);
154impl_range_vecs!(RangeInclusive<usize>);
155impl_range_vecs!(RangeToInclusive<usize>);
156
157impl<'a, T: Clone> IterateByValueGat<'a> for Vec<T> {
158    type Item = T;
159    type Iter = Cloned<core::slice::Iter<'a, T>>;
160}
161
162impl<T: Clone> IterateByValue for Vec<T> {
163    fn iter_value(&self) -> Iter<'_, Self> {
164        self.iter().cloned()
165    }
166}
167
168impl<'a, T: Clone> IterateByValueFromGat<'a> for Vec<T> {
169    type Item = T;
170    type IterFrom = Cloned<Skip<core::slice::Iter<'a, T>>>;
171}
172
173impl<T: Clone> IterateByValueFrom for Vec<T> {
174    fn iter_value_from(&self, from: usize) -> IterFrom<'_, Self> {
175        self.iter().skip(from).cloned()
176    }
177}
178
179#[cfg(feature = "std")]
180mod vec_deque {
181    use super::*;
182    use std::collections::VecDeque;
183
184    impl<T: Clone> SliceByValue for VecDeque<T> {
185        type Value = T;
186
187        #[inline]
188        fn len(&self) -> usize {
189            self.len()
190        }
191        #[inline]
192        fn get_value(&self, index: usize) -> Option<Self::Value> {
193            (*self).get(index).cloned()
194        }
195
196        #[inline]
197        fn index_value(&self, index: usize) -> Self::Value {
198            self[index].clone()
199        }
200
201        #[inline]
202        unsafe fn get_value_unchecked(&self, index: usize) -> Self::Value {
203            // SAFETY: index is within bounds
204            let val_ref = unsafe { (*self).get(index).unwrap_unchecked() };
205            val_ref.clone()
206        }
207    }
208
209    impl<T: Clone> SliceByValueMut for VecDeque<T> {
210        #[inline]
211        fn set_value(&mut self, index: usize, value: Self::Value) {
212            self[index] = value;
213        }
214
215        #[inline]
216        unsafe fn set_value_unchecked(&mut self, index: usize, value: Self::Value) { unsafe {
217            // SAFETY: index is within bounds
218            let val_mut = { self.get_mut(index).unwrap_unchecked() };
219            *val_mut = value;
220        }}
221
222        #[inline]
223        fn replace_value(&mut self, index: usize, value: Self::Value) -> Self::Value {
224            core::mem::replace(&mut self[index], value)
225        }
226
227        #[inline]
228        unsafe fn replace_value_unchecked(
229            &mut self,
230            index: usize,
231            value: Self::Value,
232        ) -> Self::Value {
233            // SAFETY: index is within bounds
234            let val_mut = unsafe { self.get_mut(index).unwrap_unchecked() };
235            core::mem::replace(val_mut, value)
236        }
237
238        type ChunksMut<'a>
239            = core::slice::ChunksMut<'a, T>
240        where
241            Self: 'a;
242
243        type ChunksMutError = core::convert::Infallible;
244
245        #[inline]
246        fn try_chunks_mut(
247            &mut self,
248            chunk_size: usize,
249        ) -> Result<Self::ChunksMut<'_>, Self::ChunksMutError> {
250            // Make the VecDeque contiguous so we can use chunks_mut
251            Ok(self.make_contiguous().chunks_mut(chunk_size))
252        }
253    }
254
255    impl<'a, T: Clone> IterateByValueGat<'a> for VecDeque<T> {
256        type Item = T;
257        type Iter = Cloned<std::collections::vec_deque::Iter<'a, T>>;
258    }
259
260    impl<T: Clone> IterateByValue for VecDeque<T> {
261        fn iter_value(&self) -> Iter<'_, Self> {
262            self.iter().cloned()
263        }
264    }
265
266    impl<'a, T: Clone> IterateByValueFromGat<'a> for VecDeque<T> {
267        type Item = T;
268        type IterFrom = Cloned<Skip<std::collections::vec_deque::Iter<'a, T>>>;
269    }
270
271    impl<T: Clone> IterateByValueFrom for VecDeque<T> {
272        fn iter_value_from(&self, from: usize) -> IterFrom<'_, Self> {
273            self.iter().skip(from).cloned()
274        }
275    }
276}
value_traits/impls/vectors.rs

value_traits/impls/
vectors.rs
