Lines Matching refs:vec
19 //! ...or by using the [`vec!`] macro:
22 //! let v: Vec<i32> = vec![];
24 //! let v = vec![1, 2, 3, 4, 5];
26 //! let v = vec![0; 10]; // ten zeroes
33 //! let mut v = vec![1, 2];
41 //! let mut v = vec![1, 2];
49 //! let mut v = vec![1, 2, 3];
155 /// let mut vec = Vec::new();
156 /// vec.push(1);
157 /// vec.push(2);
159 /// assert_eq!(vec.len(), 2);
160 /// assert_eq!(vec[0], 1);
162 /// assert_eq!(vec.pop(), Some(2));
163 /// assert_eq!(vec.len(), 1);
165 /// vec[0] = 7;
166 /// assert_eq!(vec[0], 7);
168 /// vec.extend([1, 2, 3]);
170 /// for x in &vec {
173 /// assert_eq!(vec, [7, 1, 2, 3]);
176 /// The [`vec!`] macro is provided for convenient initialization:
179 /// let mut vec1 = vec![1, 2, 3];
190 /// let vec = vec![0; 5];
191 /// assert_eq!(vec, [0, 0, 0, 0, 0]);
194 /// let mut vec = Vec::with_capacity(5);
195 /// vec.resize(5, 0);
196 /// assert_eq!(vec, [0, 0, 0, 0, 0]);
223 /// let v = vec![0, 2, 4, 6];
231 /// let v = vec![0, 2, 4, 6];
248 /// let v = vec![0, 1];
293 /// if you construct a `Vec` with capacity 0 via [`Vec::new`], [`vec![]`][`vec!`],
360 /// `vec![x; n]`, `vec![a, b, c, d]`, and
363 /// (as is the case for the [`vec!`] macro), then a `Vec<T>` can be converted to
417 /// let mut vec: Vec<i32> = Vec::new();
454 /// let mut vec = Vec::with_capacity(10);
457 /// assert_eq!(vec.len(), 0);
458 /// assert!(vec.capacity() >= 10);
462 /// vec.push(i);
464 /// assert_eq!(vec.len(), 10);
465 /// assert!(vec.capacity() >= 10);
468 /// vec.push(11);
469 /// assert_eq!(vec.len(), 11);
470 /// assert!(vec.capacity() >= 11);
508 /// let mut vec = Vec::try_with_capacity(10).unwrap();
511 /// assert_eq!(vec.len(), 0);
512 /// assert!(vec.capacity() >= 10);
516 /// vec.push(i);
518 /// assert_eq!(vec.len(), 10);
519 /// assert!(vec.capacity() >= 10);
522 /// vec.push(11);
523 /// assert_eq!(vec.len(), 11);
524 /// assert!(vec.capacity() >= 11);
594 /// let v = vec![1, 2, 3];
626 /// let vec = unsafe {
637 /// assert_eq!(vec, &[1_000_000]);
638 /// assert_eq!(vec.capacity(), 16);
661 /// let mut vec: Vec<i32, _> = Vec::new_in(System);
701 /// let mut vec = Vec::with_capacity_in(10, System);
704 /// assert_eq!(vec.len(), 0);
705 /// assert!(vec.capacity() >= 10);
709 /// vec.push(i);
711 /// assert_eq!(vec.len(), 10);
712 /// assert!(vec.capacity() >= 10);
715 /// vec.push(11);
716 /// assert_eq!(vec.len(), 11);
717 /// assert!(vec.capacity() >= 11);
759 /// let mut vec = Vec::try_with_capacity_in(10, System).unwrap();
762 /// assert_eq!(vec.len(), 0);
763 /// assert!(vec.capacity() >= 10);
767 /// vec.push(i);
769 /// assert_eq!(vec.len(), 10);
770 /// assert!(vec.capacity() >= 10);
773 /// vec.push(11);
774 /// assert_eq!(vec.len(), 11);
775 /// assert!(vec.capacity() >= 11);
884 /// let vec = unsafe {
895 /// assert_eq!(vec, &[1_000_000]);
896 /// assert_eq!(vec.capacity(), 16);
924 /// let v: Vec<i32> = vec![-1, 0, 1];
997 /// let mut vec: Vec<i32> = Vec::with_capacity(10);
998 /// vec.push(42);
999 /// assert!(vec.capacity() >= 10);
1020 /// let mut vec = vec![1];
1021 /// vec.reserve(10);
1022 /// assert!(vec.capacity() >= 11);
1050 /// let mut vec = vec![1];
1051 /// vec.reserve_exact(10);
1052 /// assert!(vec.capacity() >= 11);
1148 /// let mut vec = Vec::with_capacity(10);
1149 /// vec.extend([1, 2, 3]);
1150 /// assert!(vec.capacity() >= 10);
1151 /// vec.shrink_to_fit();
1152 /// assert!(vec.capacity() >= 3);
1175 /// let mut vec = Vec::with_capacity(10);
1176 /// vec.extend([1, 2, 3]);
1177 /// assert!(vec.capacity() >= 10);
1178 /// vec.shrink_to(4);
1179 /// assert!(vec.capacity() >= 4);
1180 /// vec.shrink_to(0);
1181 /// assert!(vec.capacity() >= 3);
1201 /// let v = vec![1, 2, 3];
1209 /// let mut vec = Vec::with_capacity(10);
1210 /// vec.extend([1, 2, 3]);
1212 /// assert!(vec.capacity() >= 10);
1213 /// let slice = vec.into_boxed_slice();
1245 /// let mut vec = vec![1, 2, 3, 4, 5];
1246 /// vec.truncate(2);
1247 /// assert_eq!(vec, [1, 2]);
1254 /// let mut vec = vec![1, 2, 3];
1255 /// vec.truncate(8);
1256 /// assert_eq!(vec, [1, 2, 3]);
1263 /// let mut vec = vec![1, 2, 3];
1264 /// vec.truncate(0);
1265 /// assert_eq!(vec, []);
1301 /// let buffer = vec![1, 2, 3, 5, 8];
1318 /// let mut buffer = vec![0; 3];
1342 /// let x = vec![1, 2, 4];
1466 /// let mut vec = vec![vec![1, 0, 0],
1467 /// vec![0, 1, 0],
1468 /// vec![0, 0, 1]];
1473 /// vec.set_len(0);
1503 /// let mut v = vec!["foo", "bar", "baz", "qux"];
1546 /// let mut vec = vec![1, 2, 3];
1547 /// vec.insert(1, 4);
1548 /// assert_eq!(vec, [1, 4, 2, 3]);
1549 /// vec.insert(4, 5);
1550 /// assert_eq!(vec, [1, 4, 2, 3, 5]);
1609 /// let mut v = vec![1, 2, 3];
1654 /// let mut vec = vec![1, 2, 3, 4];
1655 /// vec.retain(|&x| x % 2 == 0);
1656 /// assert_eq!(vec, [2, 4]);
1663 /// let mut vec = vec![1, 2, 3, 4, 5];
1666 /// vec.retain(|_| *iter.next().unwrap());
1667 /// assert_eq!(vec, [2, 3, 5]);
1686 /// let mut vec = vec![1, 2, 3, 4];
1687 /// vec.retain_mut(|x| if *x <= 3 {
1693 /// assert_eq!(vec, [2, 3, 4]);
1797 /// let mut vec = vec![10, 20, 21, 30, 20];
1799 /// vec.dedup_by_key(|i| *i / 10);
1801 /// assert_eq!(vec, [10, 20, 30, 20]);
1825 /// let mut vec = vec!["foo", "bar", "Bar", "baz", "bar"];
1827 /// vec.dedup_by(|a, b| a.eq_ignore_ascii_case(b));
1829 /// assert_eq!(vec, ["foo", "bar", "baz", "bar"]);
1841 /* INVARIANT: vec.len() > read >= write > write-1 >= 0 */
1851 vec: &'a mut Vec<T, A>,
1862 let ptr = self.vec.as_mut_ptr();
1863 let len = self.vec.len();
1866 * Basically vec[read..].len() */
1869 /* Pointer to first item in vec[write..write+items_left] slice */
1871 /* Pointer to first item in vec[read..] slice */
1874 /* Copy `vec[read..]` to `vec[write..write+items_left]`.
1879 * Basically vec[read..write].len() */
1882 self.vec.set_len(len - dropped);
1887 let mut gap = FillGapOnDrop { read: 1, write: 1, vec: self };
1888 let ptr = gap.vec.as_mut_ptr();
1922 gap.vec.set_len(gap.write);
1936 /// let mut vec = vec![1, 2];
1937 /// vec.push(3);
1938 /// assert_eq!(vec, [1, 2, 3]);
1961 /// let mut vec = vec![1, 2];
1962 /// vec.try_push(3).unwrap();
1963 /// assert_eq!(vec, [1, 2, 3]);
1998 /// let mut vec = Vec::new();
2000 /// if let Err(value) = vec.push_within_capacity(value) {
2001 /// vec.try_reserve(1)?;
2003 /// let _ = vec.push_within_capacity(value);
2006 /// Ok(vec)
2035 /// let mut vec = vec![1, 2, 3];
2036 /// assert_eq!(vec.pop(), Some(3));
2037 /// assert_eq!(vec, [1, 2]);
2061 /// let mut vec = vec![1, 2, 3];
2062 /// let mut vec2 = vec![4, 5, 6];
2063 /// vec.append(&mut vec2);
2064 /// assert_eq!(vec, [1, 2, 3, 4, 5, 6]);
2120 /// let mut v = vec![1, 2, 3];
2141 // When finished, remaining tail of the vec is copied back to cover
2148 // set self.vec length's to start, to be safe in case Drain is leaked
2155 vec: NonNull::from(self),
2168 /// let mut v = vec![1, 2, 3];
2197 /// let a = vec![1, 2, 3];
2235 /// let mut vec = vec![1, 2, 3];
2236 /// let vec2 = vec.split_off(1);
2237 /// assert_eq!(vec, [1]);
2296 /// let mut vec = vec![1, 2, 3];
2297 /// vec.resize_with(5, Default::default);
2298 /// assert_eq!(vec, [1, 2, 3, 0, 0]);
2300 /// let mut vec = vec![];
2302 /// vec.resize_with(4, || { p *= 2; p });
2303 /// assert_eq!(vec, [2, 4, 8, 16]);
2337 /// let x = vec![1, 2, 3];
2423 /// let mut v = vec![1, 1, 2];
2456 /// This method provides unique access to all vec parts at once in `extend_from_within`.
2497 /// let mut vec = vec!["hello"];
2498 /// vec.resize(3, "world");
2499 /// assert_eq!(vec, ["hello", "world", "world"]);
2501 /// let mut vec = vec![1, 2, 3, 4];
2502 /// vec.resize(2, 0);
2503 /// assert_eq!(vec, [1, 2]);
2532 /// let mut vec = vec!["hello"];
2533 /// vec.try_resize(3, "world").unwrap();
2534 /// assert_eq!(vec, ["hello", "world", "world"]);
2536 /// let mut vec = vec![1, 2, 3, 4];
2537 /// vec.try_resize(2, 0).unwrap();
2538 /// assert_eq!(vec, [1, 2]);
2540 /// let mut vec = vec![42];
2541 /// let result = vec.try_resize(usize::MAX, 0);
2569 /// let mut vec = vec![1];
2570 /// vec.extend_from_slice(&[2, 3, 4]);
2571 /// assert_eq!(vec, [1, 2, 3, 4]);
2594 /// let mut vec = vec![1];
2595 /// vec.try_extend_from_slice(&[2, 3, 4]).unwrap();
2596 /// assert_eq!(vec, [1, 2, 3, 4]);
2615 /// let mut vec = vec![0, 1, 2, 3, 4];
2617 /// vec.extend_from_within(2..);
2618 /// assert_eq!(vec, [0, 1, 2, 3, 4, 2, 3, 4]);
2620 /// vec.extend_from_within(..2);
2621 /// assert_eq!(vec, [0, 1, 2, 3, 4, 2, 3, 4, 0, 1]);
2623 /// vec.extend_from_within(4..8);
2624 /// assert_eq!(vec, [0, 1, 2, 3, 4, 2, 3, 4, 0, 1, 4, 2, 3, 4]);
2659 /// let mut vec = vec![[1, 2, 3], [4, 5, 6], [7, 8, 9]];
2660 /// assert_eq!(vec.pop(), Some([7, 8, 9]));
2662 /// let mut flattened = vec.into_flattened();
2669 (len.checked_mul(N).expect("vec len overflow"), usize::MAX)
2759 /// let mut vec = vec![1, 2, 2, 3, 2];
2761 /// vec.dedup();
2763 /// assert_eq!(vec, [1, 2, 3, 2]);
2898 /// let v: Vec<u8> = vec![0xa8, 0x3c, 0x09];
2957 /// let v = vec!["a".to_string(), "b".to_string()];
3175 /// let mut v = vec![1, 2, 3, 4];
3208 /// # let mut vec = vec![1, 2, 3, 4, 5, 6];
3210 /// while i < vec.len() {
3211 /// if some_predicate(&mut vec[i]) {
3212 /// let val = vec.remove(i);
3219 /// # assert_eq!(vec, vec![1, 4, 5]);
3234 /// let mut numbers = vec![1, 2, 3, 4, 5, 6, 8, 9, 11, 13, 14, 15];
3239 /// assert_eq!(evens, vec![2, 4, 6, 8, 14]);
3240 /// assert_eq!(odds, vec![1, 3, 5, 9, 11, 13, 15]);
3254 ExtractIf { vec: self, idx: 0, del: 0, old_len, pred: filter }
3374 /// assert_eq!(Vec::from(&[1, 2, 3][..]), vec![1, 2, 3]);
3394 /// assert_eq!(Vec::from(&mut [1, 2, 3][..]), vec![1, 2, 3]);
3414 /// assert_eq!(Vec::from([1, 2, 3]), vec![1, 2, 3]);
3443 /// let o: Cow<'_, [i32]> = Cow::Owned(vec![1, 2, 3]);
3462 /// let b: Box<[i32]> = vec![1, 2, 3].into_boxed_slice();
3463 /// assert_eq!(Vec::from(b), vec![1, 2, 3]);
3483 /// assert_eq!(Box::from(vec![1, 2, 3]), vec![1, 2, 3].into_boxed_slice());
3488 /// let mut vec = Vec::with_capacity(10);
3489 /// vec.extend([1, 2, 3]);
3491 /// assert_eq!(Box::from(vec), vec![1, 2, 3].into_boxed_slice());
3506 /// assert_eq!(Vec::from("123"), vec![b'1', b'2', b'3']);
3523 /// assert_eq!(vec![1, 2, 3].try_into(), Ok([1, 2, 3]));
3530 /// assert_eq!(r, Err(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9]));
3543 fn try_from(mut vec: Vec<T, A>) -> Result<[T; N], Vec<T, A>> {
3544 if vec.len() != N {
3545 return Err(vec);
3549 unsafe { vec.set_len(0) };
3556 let array = unsafe { ptr::read(vec.as_ptr() as *const [T; N]) };