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

value_traits/impls/
vectors.rs
