Lines Matching defs:len
131 let len = s.chars().count();
133 b.iter(|| assert_eq!(s.char_indices().count(), len));
139 let len = s.chars().count();
141 b.iter(|| assert_eq!(s.char_indices().rev().count(), len));
154 let len = s.split(' ').count();
156 b.iter(|| assert_eq!(s.split(' ').count(), len));
162 let len = s.split(' ').count();
167 b.iter(|| assert_eq!(s.split(pred).count(), len));
173 let len = s.split(' ').count();
175 b.iter(|| assert_eq!(s.split(|c: char| c == ' ').count(), len));
181 let len = s.split(' ').count();
184 b.iter(|| assert_eq!(s.split(c).count(), len));
193 assert_eq!(v.join(sep).len(), s.len() * 10 + sep.len() * 9);
434 assert_eq!(100, s.len());
443 assert_eq!(100, s.len());
470 let mut r = String::with_capacity(s.len());
472 assert_eq!(r.len(), r.capacity());
474 let mut r = String::with_capacity(s.len());
1127 let mut v = Vec::<u32>::with_capacity(data.len() + 1);
1137 let mut v = Vec::<u32>::with_capacity(data.len() + 1);
1157 let mut v = Vec::<u32>::with_capacity(data.len());
1177 let mut result = Vec::with_capacity(data.len());
1178 for i in 0..data.len() {
1189 let mask = if buf.len() < 8192 {
1191 } else if buf.len() < 200_000 {
1215 let len = {
1217 dedup.len()
1219 vec.truncate(len);
1617 assert_eq!(map.len(), 100 / 2);
1659 assert_eq!(map.len(), 100 / 2);
1688 assert_eq!(map.len(), 10_000 / 2);
1730 assert_eq!(map.len(), 10_000 / 2);
1759 assert_eq!(map.len(), 100 / 2);
1801 assert_eq!(map.len(), 100 / 2);
1813 while set.len() < n {
1816 assert_eq!(set.len(), n);
1822 assert_eq!(set.len(), n);
1828 assert_eq!(set.len(), n);
1839 assert_eq!(sets[0].len(), n1);
1840 assert_eq!(sets[1].len(), n2);
1885 assert_eq!(set.len(), 100 / 2);
1927 assert_eq!(set.len(), 100 / 2);
1956 assert_eq!(set.len(), 10_000 / 2);
1998 assert_eq!(set.len(), 10_000 / 2);
2189 let l = v.len();
2201 let l = v.len();
2207 fn gen_ascending(len: usize) -> Vec<u64> {
2208 (0..len as u64).collect()
2211 fn gen_descending(len: usize) -> Vec<u64> {
2212 (0..len as u64).rev().collect()
2217 fn gen_random(len: usize) -> Vec<u64> {
2219 (&mut rng).sample_iter(&Standard).take(len).collect()
2222 fn gen_random_bytes(len: usize) -> Vec<u8> {
2224 (&mut rng).sample_iter(&Standard).take(len).collect()
2227 fn gen_mostly_ascending(len: usize) -> Vec<u64> {
2229 let mut v = gen_ascending(len);
2230 for _ in (0usize..).take_while(|x| x * x <= len) {
2231 let x = rng.gen::<usize>() % len;
2232 let y = rng.gen::<usize>() % len;
2238 fn gen_mostly_descending(len: usize) -> Vec<u64> {
2240 let mut v = gen_descending(len);
2241 for _ in (0usize..).take_while(|x| x * x <= len) {
2242 let x = rng.gen::<usize>() % len;
2243 let y = rng.gen::<usize>() % len;
2249 fn gen_strings(len: usize) -> Vec<String> {
2252 for _ in 0..len {
2259 fn gen_big_random(len: usize) -> Vec<[u64; 16]> {
2261 (&mut rng).sample_iter(&Standard).map(|x| [x; 16]).take(len).collect()
2265 ($f:ident, $name:ident, $gen:expr, $len:expr) => {
2268 let v = $gen($len);
2270 b.bytes = $len * mem::size_of_val(&$gen(1)[0]) as u64;
2276 ($f:ident, $name:ident, $gen:expr, $len:expr) => {
2279 let v = $gen($len);
2282 b.bytes = $len * mem::size_of::<&str>() as u64;
2288 ($f:ident, $name:ident, $gen:expr, $len:expr) => {
2291 let v = $gen($len);
2304 b.bytes = $len * mem::size_of_val(&$gen(1)[0]) as u64;
2310 ($f:ident, $name:ident, $gen:expr, $len:expr) => {
2313 let v = $gen($len);
2315 b.bytes = $len * mem::size_of_val(&$gen(1)[0]) as u64;
2379 ($name:ident, $gen:expr, $len:expr, $mid:expr) => {
2383 let mut v = $gen($len * 8 / size);
2385 b.bytes = (v.len() * size) as u64;
2585 let l = durations.len();
2605 assert_eq!(m.len(), 2);
2608 assert_eq!(m.len(), 0);
2651 assert_eq!(m.len(), 0);
2652 assert_eq!(p.len(), 1);
2662 assert_eq!(m.len(), 2);
2663 assert_eq!(n.len(), 3);
2676 assert_eq!(m.len(), 4);
2677 assert_eq!(n.len(), 1);
2692 assert_eq!(m.len(), 1);
2693 assert_eq!(p.len(), 0);
2766 let mut len = m.len();
2769 len -= 1;
2771 assert_eq!(len, 0);
2909 assert_eq!(a.len(), 4);
2917 assert_eq!(a.len(), 6);
2927 assert_eq!(a.len(), 4);
2933 assert_eq!(a.len(), 7);
2963 assert_eq!(list.len(), 0);
2970 let initial_len = list.len();
2986 assert_eq!(list.len(), 0);
2994 let initial_len = list.len();
3009 assert_eq!(list.len(), initial_len);
3017 let initial_len = list.len();
3033 assert_eq!(list.len(), 0);
3049 assert_eq!(removed.len(), 10);
3052 assert_eq!(list.len(), 14);
3068 assert_eq!(removed.len(), 10);
3071 assert_eq!(list.len(), 13);
3086 assert_eq!(removed.len(), 10);
3089 assert_eq!(list.len(), 11);
3103 assert_eq!(removed.len(), 10);
3106 assert_eq!(list.len(), 10);
3117 assert_eq!(removed.len(), 10);
3120 assert_eq!(list.len(), 10);
3190 assert_eq!(q.len(), 6);
3577 for j in string[ip..].char_indices().map(|(i, _)| i).chain(Some(string.len() - ip)) {
3647 assert_eq!("～～～～～".len(), 15);
3897 // (such as the input `len..len`, which is just barely valid)
4254 assert!(s.is_char_boundary(s.len()));
4255 assert!(!s.is_char_boundary(s.len() + 1));
4463 let n1 = s1.len();
4464 let n2 = v.len();
4504 assert_eq!(&s[..a.len()], a);
4505 assert_eq!(&s[a.len()..], b);
4507 let (a, b) = s.split_at(s.len());
4602 assert_eq!(pos, v.len());
4603 assert_eq!(s.chars().count(), v.len());
4618 assert_eq!(pos, v.len());
4693 let mut pos = v.len();
4744 assert_eq!(pos, v.len());
4745 assert_eq!(pos, p.len());
4761 assert_eq!(pos, v.len());
4762 assert_eq!(pos, p.len());
4954 v.iter().map(|x| x.len()).sum()
4999 for i in 0..s.len() {
5000 for j in i + 1..=s.len() {
5280 if first_index != haystack.len() {
5575 assert_eq!(s.len(), 10);
5577 assert_eq!(schs.len(), 4);
5878 let empty: String = split.split_off(orig.len());
5887 let _ = split.split_off(orig.len() + 1);
5911 let go = nihon.split_off("日本".len());
5953 assert_eq!(s.len(), 0);
5962 assert_eq!(b.len(), 7);
5970 assert_eq!(s.len(), 33);
6303 // * overflow may trigger when adding `len` to `cap` (in number of elements)
6356 // Same basic idea, but with non-zero len
6376 // Should always overflow in the add-to-len
6707 assert_eq!(v.len(), 5);
6713 assert_eq!(v.len(), 7);
6760 assert!(&left[..left.len()] == &[1, 2]);
6768 assert!(&right[..right.len()] == &[3, 4, 5]);
6948 assert_eq!(v.len(), 0);
6950 assert_eq!(v.len(), 1);
6952 assert_eq!(v.len(), 2);
7242 assert_eq!(v.len(), usize::MAX - 1);
7249 assert_eq!(v.len(), usize::MAX - 1);
7555 assert_eq!(sink.len(), 1);
7698 assert_eq!(vec.len(), 0);
7705 let initial_len = vec.len();
7720 assert_eq!(vec.len(), 0);
7728 let initial_len = vec.len();
7742 assert_eq!(vec.len(), initial_len);
7750 let initial_len = vec.len();
7765 assert_eq!(vec.len(), 0);
7779 assert_eq!(removed.len(), 10);
7782 assert_eq!(vec.len(), 14);
7793 assert_eq!(removed.len(), 10);
7796 assert_eq!(vec.len(), 13);
7806 assert_eq!(removed.len(), 10);
7809 assert_eq!(vec.len(), 11);
7818 assert_eq!(removed.len(), 10);
7821 assert_eq!(vec.len(), 10);
7830 assert_eq!(removed.len(), 10);
7833 assert_eq!(vec.len(), 10);
7883 assert_eq!(check_count, drop_counts.len());
7934 assert_eq!(check_count, drop_counts.len());
7982 // * overflow may trigger when adding `len` to `cap` (in number of elements)
8035 // Same basic idea, but with non-zero len
8055 // Should always overflow in the add-to-len
8222 assert_eq!(v.len(), 2);
8245 v.resize_with(v.len() + 10, || 42);
8571 for len in 0..N {
8572 let mut tester = Vec::with_capacity(len);
8573 assert_eq!(tester.len(), 0);
8574 assert!(tester.capacity() >= len);
8575 for _ in 0..len {
8578 assert_eq!(tester.len(), len);
8579 assert_eq!(tester.iter().count(), len);
9273 assert_eq!(v.len(), 3);
9283 assert_eq!(v.len(), 5);
9298 assert_eq!(v.len(), 2);
9330 assert_eq!(v0.len(), 0);
9331 assert_eq!(v1.len(), 1);
9332 assert_eq!(v2.len(), 2);
9434 let v_a = vec_fixed[1..vec_fixed.len()].to_vec();
9435 assert_eq!(v_a.len(), 3);
9444 assert_eq!(v_b.len(), 2);
9452 assert_eq!(v_d.len(), 5);
9485 assert_eq!(v.len(), 0);
9520 assert_eq!(v.len(), 2);
9522 assert_eq!(v.len(), 1);
9524 assert_eq!(v.len(), 0);
9532 assert_eq!(v.len(), 1);
9537 assert_eq!(v.len(), 2);
9547 assert_eq!(v.len(), 1);
9556 assert_eq!(v.len(), 0);
9641 for len in (2..25).chain(500..510) {
9645 rng.sample_iter::<i32, _>(&Standard).map(|x| x % modulus).take(len).collect();
9675 let a = rng.gen::<usize>() % len;
9676 let b = rng.gen::<usize>() % len;
9692 for i in 0..v.len() {
9697 for i in 0..v.len() {
9717 for len in (2..25).chain(large_range) {
9726 let orig: Vec<_> = (0..len)
9762 v.rotate_left(expected.len());
9797 v.rotate_right(expected.len());
9921 assert_eq!(v.len(), 2);
10026 for i in 0..xs.len() {
10027 for j in i..xs.len() {
10268 assert_eq!(v.chunks(2).len(), 3);
10292 assert_eq!(v.chunks_exact(2).len(), 2);
10316 assert_eq!(v.rchunks(2).len(), 3);
10340 assert_eq!(v.rchunks_exact(2).len(), 2);
10429 assert!(left[..left.len()] == [1, 2]);
10437 assert!(right[..right.len()] == [3, 4, 5]);
10453 assert_eq!(v.len(), 3);
10567 assert_eq!(v.chunks_mut(3).len(), 3);
10599 assert_eq!(v.chunks_exact_mut(3).len(), 2);
10631 assert_eq!(v.rchunks_mut(3).len(), 3);
10663 assert_eq!(v.rchunks_exact_mut(3).len(), 2);
10921 let len = $input.len();
10935 for i in 0..len {
10955 for (i, c) in DROP_COUNTS.iter().enumerate().take(len) {
10957 assert!(count == 1, "found drop count == {} for i == {}, len == {}", count, i, len);
10984 for len in lens {
10987 let mut input = (0..len)
11001 let a = rng.gen::<usize>() % len;
11002 let b = rng.gen::<usize>() % len;
11220 assert_eq!(d.len(), 0);
11224 assert_eq!(d.len(), 3);
11226 assert_eq!(d.len(), 4);
11237 assert_eq!(d.len(), 0);
11239 assert_eq!(d.len(), 1);
11241 assert_eq!(d.len(), 2);
11243 assert_eq!(d.len(), 3);
11245 assert_eq!(d.len(), 4);
11254 assert_eq!(deq.len(), 0);
11258 assert_eq!(deq.len(), 3);
11260 assert_eq!(deq.len(), 4);
11267 assert_eq!(deq.len(), 0);
11269 assert_eq!(deq.len(), 1);
11271 assert_eq!(deq.len(), 2);
11273 assert_eq!(deq.len(), 3);
11275 assert_eq!(deq.len(), 4);
11288 assert_eq!(deq.len(), 66);
11391 assert_eq!(d.len(), 1);
11394 assert_eq!(d.len(), 1);
11485 let mut len = d.len();
11490 len -= 1;
11491 assert_eq!(it.size_hint(), (len, Some(len)))
11713 assert_eq!(deq.len(), 256);
11723 assert_eq!(d.len(), 4);
11725 assert_eq!(e.len(), 4);
11729 assert_eq!(d.len(), 0);
11730 assert_eq!(e.len(), 0);
11794 let len = 28;
11795 let mut ring: VecDeque<i32> = (0..len as i32).collect();
11803 ring.push_back(len - 1);
11813 let len = 28;
11814 let mut ring: VecDeque<i32> = (0..len as i32).collect();
11822 ring.push_back(len - 1);
11831 shifted.push_back(len - 1);
12099 assert_eq!(ring.len() as i32, cap);
12127 assert_eq!(ring.len() as i32, cap);
12268 assert_eq!(v.len(), 4);
12279 assert_eq!(v.len(), 6);
12319 assert_eq!(v.is_empty(), v.len() == 0);
12320 assert_eq!(v.iter().is_empty(), v.iter().len() == 0);
12321 assert_eq!(v.iter_mut().is_empty(), v.iter_mut().len() == 0);
12361 // * overflow may trigger when adding `len` to `cap` (in number of elements)
12411 // Same basic idea, but with non-zero len
12431 // Should always overflow in the add-to-len
12724 assert_eq!(iter.len(), 9);
12862 assert_eq!(v.len(), 3);
12934 for len in 0..N {
12935 let mut tester = VecDeque::with_capacity(len);
12936 assert_eq!(tester.len(), 0);
12937 assert!(tester.capacity() >= len);
12938 for case in 0..(1 << len) {
12939 assert_eq!(tester.len(), 0);
12940 for bit in 0..len {
12947 assert_eq!(tester.len(), len);
12948 assert_eq!(tester.iter().count(), len);
12958 assert_eq!(queue.len(), 100);
13364 fn check_exact_size_iterator<I: ExactSizeIterator>(len: usize, it: I) {
13367 for i in 0..it.len() {
13370 assert_eq!(lower, len - i);
13371 assert_eq!(it.len(), len - i);
13374 assert_eq!(it.len(), 0);
13381 check_exact_size_iterator(heap.len(), heap.iter());
13382 check_exact_size_iterator(heap.len(), heap.clone().into_iter());
13383 check_exact_size_iterator(heap.len(), heap.clone().into_iter_sorted());
13384 check_exact_size_iterator(heap.len(), heap.clone().drain());
13385 check_exact_size_iterator(heap.len(), heap.clone().drain_sorted());
13388 fn check_trusted_len<I: TrustedLen>(len: usize, it: I) {
13390 for i in 0..len {
13394 assert_eq!(lower, len - i);
13403 check_trusted_len(heap.len(), heap.clone().into_iter_sorted());
13404 check_trusted_len(heap.len(), heap.clone().drain_sorted());
13447 assert_eq!(heap.len(), 3);
13450 assert_eq!(heap.len(), 4);
13453 assert_eq!(heap.len(), 5);
13456 assert_eq!(heap.len(), 6);
13459 assert_eq!(heap.len(), 7);
13462 assert_eq!(heap.len(), 8);
13469 assert_eq!(heap.len(), 3);
13472 assert_eq!(heap.len(), 4);
13475 assert_eq!(heap.len(), 5);
13478 assert_eq!(heap.len(), 6);
13481 assert_eq!(heap.len(), 7);
13484 assert_eq!(heap.len(), 8);
13613 assert_eq!(a.len(), 5);
13626 assert_eq!(a.len(), 5);
14572 RawVec::from_raw_parts_in(slice.as_mut_ptr(), slice.len(), alloc)
14576 /// Converts the entire buffer into `Box<[MaybeUninit<T>]>` with the specified `len`.
14583 /// * `len` must be greater than or equal to the most recently requested capacity, and
14584 /// * `len` must be less than or equal to `self.capacity()`.
14588 pub unsafe fn into_box(self, len: usize) -> Box<[MaybeUninit<T>], A> {
14591 len <= self.capacity(),
14592 "`len` must be smaller than or equal to `self.capacity()`"
14597 let slice = slice::from_raw_parts_mut(me.ptr() as *mut MaybeUninit<T>, len);
14627 cap: Self::capacity_from_bytes(ptr.len()),
14684 /// Ensures that the buffer contains at least enough space to hold `len +
14690 /// If `len` exceeds `self.capacity()`, this may fail to actually allocate
14713 /// len: usize,
14718 /// self.buf.reserve(self.len, elems.len());
14719 /// // reserve would have aborted or panicked if the len exceeded
14723 /// ptr::write(self.buf.ptr().add(self.len), x.clone());
14725 /// self.len += 1;
14730 /// # let mut vector = MyVec { buf: RawVec::new(), len: 0 };
14735 pub fn reserve(&mut self, len: usize, additional: usize) {
14743 len: usize,
14746 handle_reserve(slf.grow_amortized(len, additional));
14749 if self.needs_to_grow(len, additional) {
14750 do_reserve_and_handle(self, len, additional);
14755 pub fn try_reserve(&mut self, len: usize, additional: usize) -> Result<(), TryReserveError> {
14756 if self.needs_to_grow(len, additional) {
14757 self.grow_amortized(len, additional)
14763 /// Ensures that the buffer contains at least enough space to hold `len +
14769 /// If `len` exceeds `self.capacity()`, this may fail to actually allocate
14780 pub fn reserve_exact(&mut self, len: usize, additional: usize) {
14781 handle_reserve(self.try_reserve_exact(len, additional));
14787 len: usize,
14790 if self.needs_to_grow(len, additional) { self.grow_exact(len, additional) } else { Ok(()) }
14811 fn needs_to_grow(&self, len: usize, additional: usize) -> bool {
14812 additional > self.capacity().wrapping_sub(len)
14822 self.cap = Self::capacity_from_bytes(ptr.len());
14832 fn grow_amortized(&mut self, len: usize, additional: usize) -> Result<(), TryReserveError> {
14843 let required_cap = len.checked_add(additional).ok_or(CapacityOverflow)?;
14861 fn grow_exact(&mut self, len: usize, additional: usize) -> Result<(), TryReserveError> {
14868 let cap = len.checked_add(additional).ok_or(CapacityOverflow)?;
15069 match $separator.len() {
15096 let len = $bytes.len();
15097 let (head, tail) = { $target }.split_at_mut(len);
15117 let sep_len = sep.len();
15127 // if the `len` calculation overflows, we'll panic
15131 .checked_mul(iter.len())
15133 slice.iter().map(|s| s.borrow().as_ref().len()).try_fold(n, usize::checked_add)
15135 .expect("attempt to join into collection with len > usize::MAX");
15144 let pos = result.len();
15155 let result_len = reserved_len - remain.len();
15246 last_end = start + part.len();
15248 result.push_str(unsafe { self.get_unchecked(last_end..self.len()) });
15285 last_end = start + part.len();
15287 result.push_str(unsafe { self.get_unchecked(last_end..self.len()) });
15332 let mut s = String::with_capacity(self.len());
15411 let mut s = String::with_capacity(self.len());
16357 /// You can look at these with the [`as_ptr`], [`len`], and [`capacity`]
16370 /// let len = story.len();
16374 /// assert_eq!(19, len);
16376 /// // We can re-build a String out of ptr, len, and capacity. This is all
16379 /// let s = unsafe { String::from_raw_parts(ptr, len, capacity) } ;
16385 /// [`len`]: String::len
16564 /// assert_eq!(s.len(), 0);
16715 if valid.len() == v.len() {
16726 let mut res = String::with_capacity(v.len());
16765 let mut ret = String::with_capacity(v.len());
16827 /// let (ptr, len, cap) = s.into_raw_parts();
16829 /// let rebuilt = unsafe { String::from_raw_parts(ptr, len, cap) };
16874 /// let len = s.len();
16877 /// let s = String::from_raw_parts(ptr, len, capacity);
17050 /// assert_eq!(2, s.len());
17097 /// assert_eq!(2, s.len());
17115 /// greater than or equal to `self.len() + additional`. Does nothing if
17133 /// output.try_reserve(data.len())?;
17149 /// capacity will be greater than or equal to `self.len() + additional`.
17171 /// output.try_reserve(data.len())?;
17304 if new_len <= self.len() {
17331 let newlen = self.len() - ch.len_utf8();
17368 let len = self.len();
17370 ptr::copy(self.vec.as_ptr().add(next), self.vec.as_mut_ptr().add(idx), len - next);
17371 self.vec.set_len(len - (next - idx));
17414 let len = self.len();
17424 len - end,
17428 self.vec.set_len(len - shrunk_by);
17472 debug_assert!(new_len <= self.s.len());
17477 let len = self.len();
17480 while guard.idx < len {
17481 let ch = unsafe { guard.s.get_unchecked(guard.idx..len).chars().next().unwrap() };
17539 let len = self.len();
17540 let amt = bytes.len();
17544 ptr::copy(self.vec.as_ptr().add(idx), self.vec.as_mut_ptr().add(idx + amt), len - idx);
17546 self.vec.set_len(len + amt);
17621 /// assert_eq!(a.len(), 3);
17624 /// assert_eq!(fancy_f.len(), 4);
17630 pub fn len(&self) -> usize {
17631 self.vec.len()
17650 self.len() == 0
17656 /// the returned `String` contains bytes `[at, len)`. `at` must be on the
17700 /// assert_eq!(0, s.len());
17726 /// let beta_offset = s.find('β').unwrap_or(s.len());
17748 let Range { start, end } = slice::range(range, ..self.len());
17776 /// let beta_offset = s.find('β').unwrap_or(s.len());
18738 if self.start <= self.end && self.end <= self_vec.len() {
18933 /// for i in 0..input.len() {
19276 let mut s = String::with_capacity(lhs.len() + rhs.len());
19292 let mut s = String::with_capacity(lhs.len() + rhs.len());
20136 pub fn new_uninit_slice(len: usize) -> Rc<[mem::MaybeUninit<T>]> {
20137 unsafe { Rc::from_ptr(Rc::allocate_for_slice(len)) }
20161 pub fn new_zeroed_slice(len: usize) -> Rc<[mem::MaybeUninit<T>]> {
20164 Layout::array::<T>(len).unwrap(),
20167 ptr::slice_from_raw_parts_mut(mem as *mut T, len)
20668 /// println!("String ({}): {}", string.len(), string);
20779 unsafe fn allocate_for_slice(len: usize) -> *mut RcBox<[T]> {
20782 Layout::array::<T>(len).unwrap(),
20784 |mem| ptr::slice_from_raw_parts_mut(mem as *mut T, len) as *mut RcBox<[T]>,
20794 let ptr = Self::allocate_for_slice(v.len());
20795 ptr::copy_nonoverlapping(v.as_ptr(), &mut (*ptr).value as *mut [T] as *mut T, v.len());
20803 unsafe fn from_iter_exact(iter: impl iter::Iterator<Item = T>, len: usize) -> Rc<[T]> {
20826 let ptr = Self::allocate_for_slice(len);
20857 unsafe { Self::from_iter_exact(v.iter().cloned(), v.len()) }
21332 if boxed_slice.len() == N {
22126 let len = b.len();
22128 Vec::from_raw_parts_in(b as *mut T, len, len, alloc)
22160 let mut vec = Vec::with_capacity_in(s.len(), alloc);
22163 // .take(slots.len()) is necessary for LLVM to remove bounds checks
22165 for (i, b) in s.iter().enumerate().take(slots.len()) {
22173 vec.set_len(s.len());
22182 let mut v = Vec::with_capacity_in(s.len(), alloc);
22184 // allocated above with the capacity of `s`, and initialize to `s.len()` in
22187 s.as_ptr().copy_to_nonoverlapping(v.as_mut_ptr(), s.len());
22188 v.set_len(s.len());
22376 for i in 0..$slice.len() {
22392 let len = self.len();
22393 if len < 2 {
22396 if sz_u8 < sz_u16 && len <= (u8::MAX as usize) {
22399 if sz_u16 < sz_u32 && len <= (u16::MAX as usize) {
22402 if sz_u32 < sz_usize && len <= (u32::MAX as usize) {
22506 let capacity = self.len().checked_mul(n).expect("capacity overflow");
22519 (buf.as_mut_ptr() as *mut T).add(buf.len()),
22520 buf.len(),
22522 // `buf` has capacity of `self.len() * n`.
22523 let buf_len = buf.len();
22533 let rem_len = capacity - buf.len(); // `self.len() * rem`
22540 (buf.as_mut_ptr() as *mut T).add(buf.len()),
22543 // `buf.len() + rem_len` equals to `buf.capacity()` (`= self.len() * n`).
22703 let size = slice.iter().map(|slice| slice.borrow().len()).sum();
22722 let size = slice.iter().map(|v| v.borrow().len()).sum::<usize>() + slice.len() - 1;
22745 slice.iter().map(|v| v.borrow().len()).sum::<usize>() + sep.len() * (slice.len() - 1);
22790 target.truncate(self.len());
22792 // target.len <= self.len due to the truncate above, so the
22794 let (init, tail) = self.split_at(target.len());
22813 if v.len() >= 2 && is_less(&v[1], &v[0]) {
22847 for i in 2..v.len() {
22884 let len = v.len();
22886 let (v_mid, v_end) = unsafe { (v.add(mid), v.add(len)) };
22907 if mid <= len - mid {
22934 ptr::copy_nonoverlapping(v_mid, buf, len - mid);
22935 hole = MergeHole { start: buf, end: buf.add(len - mid), dest: v_mid };
22980 let len = (self.end as usize - self.start as usize) / mem::size_of::<T>();
22982 ptr::copy_nonoverlapping(self.start, self.dest, len);
22996 /// 1. for every `i` in `1..runs.len()`: `runs[i - 1].len > runs[i].len`
22997 /// 2. for every `i` in `2..runs.len()`: `runs[i - 2].len > runs[i - 1].len + runs[i].len`
23014 let len = v.len();
23017 if len <= MAX_INSERTION {
23018 if len >= 2 {
23019 for i in (0..len - 1).rev() {
23029 // which will always have length at most `len / 2`.
23030 let mut buf = Vec::with_capacity(len / 2);
23037 let mut end = len;
23066 runs.push(Run { start, len: end - start });
23075 &mut v[left.start..right.start + right.len],
23076 left.len,
23081 runs[r] = Run { start: left.start, len: left.len + right.len };
23087 debug_assert!(runs.len() == 1 && runs[0].start == 0 && runs[0].len == len);
23105 let n = runs.len();
23108 || runs[n - 2].len <= runs[n - 1].len
23109 || (n >= 3 && runs[n - 3].len <= runs[n - 2].len + runs[n - 1].len)
23110 || (n >= 4 && runs[n - 4].len <= runs[n - 3].len + runs[n - 2].len))
23112 if n >= 3 && runs[n - 3].len < runs[n - 1].len { Some(n - 3) } else { Some(n - 2) }
23121 len: usize,
23909 pub fn new_uninit_slice(len: usize) -> Arc<[mem::MaybeUninit<T>]> {
23910 unsafe { Arc::from_ptr(Arc::allocate_for_slice(len)) }
23934 pub fn new_zeroed_slice(len: usize) -> Arc<[mem::MaybeUninit<T>]> {
23937 Layout::array::<T>(len).unwrap(),
23940 ptr::slice_from_raw_parts_mut(mem as *mut T, len)
24429 unsafe fn allocate_for_slice(len: usize) -> *mut ArcInner<[T]> {
24432 Layout::array::<T>(len).unwrap(),
24434 |mem| ptr::slice_from_raw_parts_mut(mem as *mut T, len) as *mut ArcInner<[T]>,
24444 let ptr = Self::allocate_for_slice(v.len());
24446 ptr::copy_nonoverlapping(v.as_ptr(), &mut (*ptr).data as *mut [T] as *mut T, v.len());
24455 unsafe fn from_iter_exact(iter: impl iter::Iterator<Item = T>, len: usize) -> Arc<[T]> {
24478 let ptr = Self::allocate_for_slice(len);
24509 unsafe { Self::from_iter_exact(v.iter().cloned(), v.len()) }
24859 /// println!("String ({}): {}", string.len(), string);
25673 if boxed_slice.len() == N {
26986 len: usize,
27004 len: usize,
27011 f.debug_tuple("Iter").field(&self.len).finish()
27035 len: usize,
27041 f.debug_tuple("IterMut").field(&self.list).field(&self.len).finish()
27093 self.len += 1;
27112 self.len -= 1;
27134 self.len += 1;
27153 self.len -= 1;
27181 self.len -= 1;
27217 self.len += splice_length;
27225 let len = mem::replace(&mut self.len, 0);
27228 Some((head, tail, len))
27259 len: at,
27265 self.len = self.len - at;
27299 len: self.len - at,
27305 self.len = at;
27337 LinkedList { head: None, tail: None, len: 0, marker: PhantomData }
27383 self.len += mem::replace(&mut other.len, 0);
27404 self.len += mem::replace(&mut other.len, 0);
27432 Iter { head: self.head, tail: self.tail, len: self.len, marker: PhantomData }
27461 IterMut { head: self.head, tail: self.tail, len: self.len, list: self }
27488 Cursor { index: self.len.checked_sub(1).unwrap_or(0), current: self.tail, list: self }
27497 CursorMut { index: self.len.checked_sub(1).unwrap_or(0), current: self.tail, list: self }
27533 /// assert_eq!(dl.len(), 1);
27536 /// assert_eq!(dl.len(), 2);
27539 /// assert_eq!(dl.len(), 3);
27544 pub fn len(&self) -> usize {
27545 self.len
27561 /// assert_eq!(dl.len(), 2);
27565 /// assert_eq!(dl.len(), 0);
27784 /// Panics if `at > len`.
27804 let len = self.len();
27805 assert!(at <= len, "Cannot split off at a nonexistent index");
27808 } else if at == len {
27814 let split_node = if at - 1 <= len - 1 - (at - 1) {
27826 for _ in 0..len - 1 - (at - 1) {
27839 /// Panics if at >= len
27859 let len = self.len();
27860 assert!(at < len, "Cannot remove at an index outside of the list bounds");
27864 let offset_from_end = len - at - 1;
27913 let old_len = self.len;
27946 if self.len == 0 {
27952 self.len -= 1;
27961 (self.len, Some(self.len))
27974 if self.len == 0 {
27980 self.len -= 1;
28000 if self.len == 0 {
28006 self.len -= 1;
28015 (self.len, Some(self.len))
28028 if self.len == 0 {
28034 self.len -= 1;
28147 self.index = self.list.len().checked_sub(1).unwrap_or(0);
28152 self.index = self.index.checked_sub(1).unwrap_or_else(|| self.list.len());
28244 self.index = self.list.len().checked_sub(1).unwrap_or(0);
28249 self.index = self.index.checked_sub(1).unwrap_or_else(|| self.list.len());
28325 self.index = self.list.len;
28384 len: 1,
28408 self.index = self.list.len;
28441 let split_off_idx = if self.index == self.list.len { 0 } else { self.index + 1 };
28442 if self.index == self.list.len {
28553 (self.list.len, Some(self.list.len))
28651 self.len() == other.len() && self.iter().eq(other)
28655 self.len() != other.len() || self.iter().ne(other)
28685 if self.len() > other.len() {
28686 self.split_off(other.len());
28707 self.len().hash(state);
28770 let mut len = 0;
28777 assert_eq!(0, list.len);
28795 len += 1;
28798 len += 1;
28807 // check that len matches interior links.
28808 assert_eq!(len, list.len);
28820 assert_eq!(m.len(), 0);
28821 assert_eq!(n.len(), 0);
28830 assert_eq!(m.len(), 1);
28832 assert_eq!(n.len(), 0);
28842 assert_eq!(m.len(), 1);
28856 assert_eq!(sum.len(), m.len());
28860 assert_eq!(n.len(), 0);
28864 assert_eq!(n.len(), 1);
28949 assert_eq!(v1.len(), 3);
28951 assert_eq!(v1.iter().len(), 3);
28952 assert_eq!(v1.iter().collect::<Vec<_>>().len(), 3);
28964 for ix in 0..1 + v1.len() {
29009 assert_eq!(i, v.len());
29226 if cur_node.len() < node::CAPACITY {
29236 if parent.len() < node::CAPACITY {
29727 debug_assert!(start_index <= keys.len());
29735 IndexResult::Edge(keys.len())
29761 AllExcluded => (self.len(), AllExcluded),
29788 AllIncluded => (self.len(), AllIncluded),
29880 /// movie_reviews.len());
30771 /// assert_eq!(a.len(), 5);
30772 /// assert_eq!(b.len(), 0);
30942 /// assert_eq!(a.len(), 2);
30943 /// assert_eq!(b.len(), 3);
30961 let total_num = self.len();
31134 fn len(&self) -> usize {
31200 fn len(&self) -> usize {
31305 fn len(&self) -> usize {
31347 fn len(&self) -> usize {
31348 self.inner.len()
31388 fn len(&self) -> usize {
31389 self.inner.len()
31557 fn len(&self) -> usize {
31558 self.inner.len()
31605 fn len(&self) -> usize {
31606 self.inner.len()
31639 fn len(&self) -> usize {
31640 self.inner.len()
31775 self.len() == other.len() && self.iter().zip(other).all(|(a, b)| a == b)
31973 /// assert_eq!(a.len(), 0);
31975 /// assert_eq!(a.len(), 1);
31980 pub const fn len(&self) -> usize {
32001 self.len() == 0
32217 /// books.len());
32496 _ if self.len() <= other.len() / ITER_PERFORMANCE_TIPPING_SIZE_DIFF => {
32577 _ if self.len() <= other.len() / ITER_PERFORMANCE_TIPPING_SIZE_DIFF => {
32580 _ if other.len() <= self.len() / ITER_PERFORMANCE_TIPPING_SIZE_DIFF => {
32728 if self.len() > other.len() {
32758 if self_iter.len() <= other.len() / ITER_PERFORMANCE_TIPPING_SIZE_DIFF {
32928 /// assert_eq!(set.len(), 1);
33056 /// assert_eq!(a.len(), 5);
33057 /// assert_eq!(b.len(), 0);
33092 /// assert_eq!(a.len(), 2);
33093 /// assert_eq!(b.len(), 3);
33186 /// assert_eq!(v.len(), 0);
33188 /// assert_eq!(v.len(), 1);
33193 pub const fn len(&self) -> usize {
33194 self.map.len()
33212 self.len() == 0
33482 fn len(&self) -> usize {
33483 self.iter.len()
33510 fn len(&self) -> usize {
33511 self.iter.len()
33607 (self_iter.len(), other_iter.len())
33609 DifferenceInner::Search { self_iter, other_set } => (self_iter.len(), other_set.len()),
33610 DifferenceInner::Iterate(iter) => (iter.len(), 0),
33703 IntersectionInner::Stitch { a, b } => (0, Some(min(a.len(), b.len()))),
33704 IntersectionInner::Search { small_iter, .. } => (0, Some(small_iter.len())),
34228 Position::Leaf(node) => result += node.len(),
34229 Position::Internal(node) => result += node.len(),
34308 const LEN: usize = SET.len();
34359 if i < expected.len() {
34365 assert_eq!(i, expected.len());
34619 assert_eq!(set.len(), 3);
34632 assert_eq!(x.len(), 0);
34633 assert_eq!(y.len(), 1);
34674 assert_eq!(set.len(), 2);
34740 assert_eq!(a.len(), 4);
34752 assert_eq!(a.len(), 6);
34788 assert_eq!(s.len(), 1);
34790 assert_eq!(s.len(), 1);
34800 assert_eq!(s.len(), 0);
34907 set.len();
34938 assert_eq!(a.len(), 5);
34939 assert_eq!(b.len(), 0);
34984 fn rand_data(len: usize) -> Vec<u32> {
34986 Vec::from_iter((0..len).map(|_| rng.next()))
35021 let key = data[data.len() / 2];
35686 assert!(self.len() >= min_len, "node len {} < {}", self.len(), min_len);
35688 for idx in 0..=node.len() {
35704 assert_eq!(map.len(), 0);
35717 assert_eq!(map.len(), MIN_INSERTS_HEIGHT_1, "{}", map.dump_keys());
35732 assert_eq!(map.len(), MIN_INSERTS_HEIGHT_2, "{}", map.dump_keys());
35760 assert_eq!(map.len(), 0);
35764 assert_eq!(map.len(), i + 1);
35782 assert_eq!(map.len(), size);
35791 assert_eq!(map.len(), size - i - 1);
35802 assert_eq!(map.len(), size / 2 - i - 1);
35812 assert_eq!(map.len(), 0);
35830 assert_eq!(map.len(), 1);
35838 assert_eq!(map.len(), 1);
35850 assert_eq!(map.len(), 2);
35862 assert_eq!(map.len(), 1);
35876 assert_eq!(map.len(), 0);
36473 assert_eq!(map.len(), 50);
36557 assert_eq!(map.len(), 2);
36597 assert_eq!(map.len(), NODE_CAPACITY - 1);
36626 assert_eq!(map.len(), 8);
36645 assert_eq!(map.len(), MIN_INSERTS_HEIGHT_1 - 1);
36667 assert_eq!(map.len(), MIN_INSERTS_HEIGHT_2 - 1);
36731 assert_eq!(map.len(), 2);
36763 assert_eq!(map.len(), 2);
36858 assert_eq!(map.len(), 6);
36869 assert_eq!(map.len(), 6);
36880 assert_eq!(map.len(), 5);
36891 assert_eq!(map.len(), 6);
36905 assert_eq!(a.len(), 3);
36915 assert_eq!(m.len(), 0);
36918 assert_eq!(m.len(), 1);
36921 assert_eq!(m.len(), 1);
36925 assert_eq!(m.len(), 0);
36931 assert_eq!(m.len(), 1);
36975 for &len in &[MIN_INSERTS_HEIGHT_1, MIN_INSERTS_HEIGHT_2, 0, NODE_CAPACITY] {
36976 for i in 0..len {
36979 assert_eq!(map.len(), len);
37001 assert_eq!(map.len(), 0);
37013 assert_eq!(map.len(), 0);
37017 assert_eq!(map.len(), i + 1);
37024 assert_eq!(map.len(), size);
37031 assert_eq!(map.len(), size - i - 1);
37039 assert_eq!(map.len(), size / 2 - i - 1);
37046 assert_eq!(map.len(), MIN_INSERTS_HEIGHT_2 - 1);
37049 assert_eq!(map.len(), MIN_INSERTS_HEIGHT_2);
37072 assert_eq!(map.len(), 3);
37309 map.len();
37349 const LEN: usize = MAP.len();
37360 assert_eq!(a.len(), 1);
37367 assert_eq!(a.len(), 1);
37386 assert_eq!(a.len(), 1);
37433 assert_eq!(root_node.len(), 1);
37434 assert_eq!(root_node.first_leaf_edge().into_node().len(), NODE_CAPACITY);
37435 assert_eq!(root_node.last_leaf_edge().into_node().len(), NODE_CAPACITY);
37443 ($name:ident, $len:expr) => {
37452 for i in 5..$len {
37458 assert_eq!(a.len(), $len);
37459 assert_eq!(b.len(), 0);
37461 for i in 0..$len {
37470 assert_eq!(a.remove(&($len - 1)), Some(2 * ($len - 1)));
37471 assert_eq!(a.insert($len - 1, 20), None);
37529 assert_eq!(map1.len(), 2);
37530 assert_eq!(map2.len(), 4);
37532 assert_eq!(map1.len(), 5);
37533 assert_eq!(map2.len(), 0);
37538 fn rand_data(len: usize) -> Vec<(u32, u32)> {
37540 Vec::from_iter((0..len).map(|_| (rng.next(), rng.next())))
37580 assert_eq!(left.len(), 1);
37581 assert_eq!(right.len(), MIN_INSERTS_HEIGHT_2 - 1);
37597 assert_eq!(left.len(), MIN_INSERTS_HEIGHT_2 - 1);
37598 assert_eq!(right.len(), 1);
37606 for &len in &[NODE_CAPACITY, 25, 50, 75, 100] {
37607 let mut data = Vec::from_iter((0..len).map(|_| (rng.next(), ())));
37611 let small_keys = data.iter().take(len / 2).map(|kv| kv.0);
37612 let large_keys = data.iter().skip(len / 2).map(|kv| kv.0);
37630 let key = data[data.len() / 2].0;
37686 assert_eq!(keys.len(), 3);
37698 assert_eq!(values.len(), 3);
37758 let len = pos.reborrow().into_node().len();
37759 if len < MIN_LEN {
37916 Some(Peeked::A(_)) => (1 + self.a.len(), self.b.len()),
37917 Some(Peeked::B(_)) => (self.a.len(), 1 + self.b.len()),
37918 _ => (self.a.len(), self.b.len()),
37935 // len: u16,
37981 len: u16,
37983 /// The arrays storing the actual data of the node. Only the first `len` elements of each
37997 ptr::addr_of_mut!((*this).len).write(0);
38021 /// The pointers to the children of this node. `len + 1` of these are considered
38192 /// The number of edges is `len() + 1`.
38195 pub fn len(&self) -> usize {
38196 // Crucially, we only access the `len` field here. If BorrowType is marker::ValMut,
38198 unsafe { usize::from((*Self::as_leaf_ptr(self)).len) }
38258 let len = self.len();
38259 unsafe { Handle::new_edge(self, len) }
38264 let len = self.len();
38265 assert!(len > 0);
38271 let len = self.len();
38272 assert!(len > 0);
38273 unsafe { Handle::new_kv(self, len - 1) }
38302 MaybeUninit::slice_assume_init_ref(leaf.keys.get_unchecked(..usize::from(leaf.len)))
38429 &mut self.as_leaf_mut().len
38438 debug_assert!(i <= self.len());
38444 let len = self.len();
38445 unsafe { self.correct_childrens_parent_links(0..=len) };
38536 let len = self.len_mut();
38537 let idx = usize::from(*len);
38539 *len += 1;
38553 let len = self.len_mut();
38554 let idx = usize::from(*len);
38556 *len += 1;
38655 /// Unsafe because the caller must ensure that `idx < node.len()`.
38657 debug_assert!(idx < node.len());
38706 /// Unsafe because the caller must ensure that `idx <= node.len()`.
38708 debug_assert!(idx <= node.len());
38722 if self.idx < self.node.len() {
38758 debug_assert!(self.node.len() < CAPACITY);
38759 let new_len = self.node.len() + 1;
38777 if self.node.len() < CAPACITY {
38816 debug_assert!(self.node.len() < CAPACITY);
38818 let new_len = self.node.len() + 1;
38841 if self.node.len() < CAPACITY {
38925 debug_assert!(self.idx < self.node.len());
38939 debug_assert!(self.idx < self.node.len());
38953 debug_assert!(self.idx < self.node.len());
38975 debug_assert!(self.idx < self.node.len());
38976 let old_len = self.node.len();
38978 new_node.len = new_len as u16;
39020 let old_len = self.node.len();
39039 let old_len = self.node.len();
39043 let new_len = usize::from(new_node.data.len);
39116 self.left_child.len()
39120 self.right_child.len()
39134 self.left_child.len() + 1 + self.right_child.len() <= CAPACITY
39151 let old_parent_len = parent_node.len();
39153 let old_left_len = left_node.len();
39155 let right_len = right_node.len();
39226 let old_left_len = self.left_child.len();
39227 let right_len = self.right_child.len();
39269 let old_left_len = left_node.len();
39271 let old_right_len = right_node.len();
39332 let old_left_len = left_node.len();
39334 let old_right_len = right_node.len();
39463 let old_left_len = left_node.len();
39468 assert!(right_node.len() == 0);
39570 let len = slice.len();
39571 debug_assert!(len > idx);
39573 if len > idx + 1 {
39574 ptr::copy(slice_ptr.add(idx), slice_ptr.add(idx + 1), len - idx - 1);
39587 let len = slice.len();
39588 debug_assert!(idx < len);
39591 ptr::copy(slice_ptr.add(idx + 1), slice_ptr.add(idx), len - idx - 1);
39603 ptr::copy(slice_ptr.add(distance), slice_ptr, slice.len() - distance);
39614 ptr::copy(slice_ptr, slice_ptr.add(distance), slice.len() - distance);
39622 assert!(src.len() == dst.len());
39624 ptr::copy_nonoverlapping(src.as_ptr(), dst.as_mut_ptr(), src.len());
39639 for idx in 0..=node.len() {
39742 let len = self.len();
39743 if len >= MIN_LEN {
39752 left_parent_kv.bulk_steal_left(MIN_LEN - len);
39761 right_parent_kv.bulk_steal_right(MIN_LEN - len);
39766 if len > 0 {
39799 while self.height() > 0 && self.len() == 0 {
39809 if self.len() > 0 {
39818 if self.len() > 0 {
39849 debug_assert!(self.reborrow().into_node().len() > MIN_LEN);
39856 debug_assert!(self.reborrow().into_node().len() > MIN_LEN);
40040 let len = self.inner.len();
40041 (len, Some(len))
40101 if self.len() != other.len() {
40105 let (oa, ob) = other[..].split_at(sa.len());
40276 assert!(from <= to && to < self.len());
40278 let len = to - from;
40279 ptr::slice_from_raw_parts_mut(self.as_mut_ptr().wrapping_add(from), len)
40283 let len = self.len();
40285 assert!(mid <= len);
40288 ptr::slice_from_raw_parts_mut(ptr.wrapping_add(mid), len - mid),
40339 let part = cmp::min(self.a0.len(), self.b0.len());
40458 self.truncate(other.len());
40554 self.cap() - self.len() == 1
40578 /// Copies a contiguous block of memory len long from src to dst
40580 unsafe fn copy(&self, dst: usize, src: usize, len: usize) {
40582 dst + len <= self.cap(),
40583 "cpy dst={} src={} len={} cap={}",
40586 len,
40590 src + len <= self.cap(),
40591 "cpy dst={} src={} len={} cap={}",
40594 len,
40598 ptr::copy(self.ptr().add(src), self.ptr().add(dst), len);
40602 /// Copies a contiguous block of memory len long from src to dst
40604 unsafe fn copy_nonoverlapping(&self, dst: usize, src: usize, len: usize) {
40606 dst + len <= self.cap(),
40607 "cno dst={} src={} len={} cap={}",
40610 len,
40614 src + len <= self.cap(),
40615 "cno dst={} src={} len={} cap={}",
40618 len,
40622 ptr::copy_nonoverlapping(self.ptr().add(src), self.ptr().add(dst), len);
40626 /// Copies a potentially wrapping block of memory len long from src to dest.
40627 /// (abs(dst - src) + len) must be no larger than cap() (There must be at
40629 unsafe fn wrap_copy(&self, dst: usize, src: usize, len: usize) {
40635 cmp::min(diff(dst, src), self.cap() - diff(dst, src)) + len <= self.cap(),
40636 "wrc dst={} src={} len={} cap={}",
40639 len,
40643 if src == dst || len == 0 {
40647 let dst_after_src = self.wrap_sub(dst, src) < len;
40651 let src_wraps = src_pre_wrap_len < len;
40652 let dst_wraps = dst_pre_wrap_len < len;
40664 self.copy(dst, src, len);
40678 self.copy(0, src + dst_pre_wrap_len, len - dst_pre_wrap_len);
40691 self.copy(0, src + dst_pre_wrap_len, len - dst_pre_wrap_len);
40706 self.copy(dst + src_pre_wrap_len, 0, len - src_pre_wrap_len);
40719 self.copy(dst + src_pre_wrap_len, 0, len - src_pre_wrap_len);
40738 self.copy(0, delta, len - dst_pre_wrap_len);
40754 self.copy(delta, 0, len - src_pre_wrap_len);
40857 if index < self.len() {
40886 if index < self.len() {
40919 assert!(i < self.len());
40920 assert!(j < self.len());
40989 let used_cap = self.len() + 1;
41005 /// capacity will be greater than or equal to `self.len() + additional`.
41028 /// output.try_reserve_exact(data.len())?;
41047 /// greater than or equal to `self.len() + additional`. Does nothing if
41066 /// output.try_reserve(data.len())?;
41080 let used_cap = self.len() + 1;
41140 // We don't have to worry about an overflow as neither `self.len()` nor `self.capacity()`
41142 let target_cap = cmp::max(cmp::max(min_capacity, self.len()) + 1, MINIMUM_CAPACITY + 1)
41162 self.copy_nonoverlapping(0, self.tail, self.len());
41164 self.head = self.len();
41171 let len = self.wrap_sub(self.head, target_cap);
41173 self.copy_nonoverlapping(0, target_cap, len);
41175 self.head = len;
41183 let len = self.cap() - self.tail;
41184 let new_tail = target_cap - len;
41186 self.copy_nonoverlapping(new_tail, self.tail, len);
41200 /// Shortens the `VecDeque`, keeping the first `len` elements and dropping
41203 /// If `len` is greater than the `VecDeque`'s current length, this has no
41220 pub fn truncate(&mut self, len: usize) {
41236 // `len <= front.len()` and returning on `len > self.len()` ensures
41237 // `begin <= back.len()` in the first case
41241 if len > self.len() {
41244 let num_dropped = self.len() - len;
41246 if len > front.len() {
41247 let begin = len - front.len();
41253 let drop_front = front.get_unchecked_mut(len..) as *mut _;
41392 /// assert_eq!(v.len(), 0);
41394 /// assert_eq!(v.len(), 1);
41398 pub fn len(&self) -> usize {
41423 let Range { start, end } = slice::range(range, ..self.len());
41447 /// assert_eq!(all.len(), 3);
41694 self.get(self.len().wrapping_sub(1))
41718 self.get_mut(self.len().wrapping_sub(1))
41854 let length = self.len();
41889 let length = self.len();
41923 assert!(index <= self.len(), "index out of bounds");
41931 // At most len/2 - 1 elements will be moved. O(min(n, n-i))
41953 let distance_to_head = self.len() - index;
42145 if self.is_empty() || self.len() <= index {
42172 let distance_to_head = self.len() - index;
42303 /// and the returned `VecDeque` contains elements `[at, len)`.
42311 /// Panics if `at > len`.
42327 let len = self.len();
42328 assert!(at <= len, "`at` out of bounds");
42330 let other_len = len - at;
42336 let first_len = first_half.len();
42337 let second_len = second_half.len();
42429 let len = self.len();
42431 for i in 0..len {
42439 self.truncate(len - del);
42458 /// Modifies the `VecDeque` in-place so that `len()` is equal to `new_len`,
42485 let len = self.len();
42487 if new_len > len {
42488 self.extend(repeat_with(generator).take(new_len - len))
42545 /// assert_eq!(buf.len(), slice.len());
42559 let len = self.len();
42578 self.head = len;
42600 self.head = self.wrap_add(self.tail, len);
42621 while left_edge < len && right_edge != cap {
42634 self.head = len;
42648 /// - Rotates `len() - mid` places to the right.
42652 /// If `mid` is greater than `len()`. Note that `mid == len()`
42657 /// Takes `*O*(min(mid, len() - mid))` time and no extra space.
42677 assert!(mid <= self.len());
42678 let k = self.len() - mid;
42691 /// - Rotates `len() - k` places to the left.
42695 /// If `k` is greater than `len()`. Note that `k == len()`
42700 /// Takes `*O*(min(k, len() - k))` time and no extra space.
42720 assert!(k <= self.len());
42721 let mid = self.len() - k;
42738 debug_assert!(mid * 2 <= self.len());
42747 debug_assert!(k * 2 <= self.len());
42856 Ok(front.len())
42858 back.binary_search_by(f).map(|idx| idx + front.len()).map_err(|idx| idx + front.len())
42952 back.partition_point(pred) + front.len()
42960 /// Modifies the `VecDeque` in-place so that `len()` is equal to new_len,
43005 if self.len() != other.len() {
43010 if sa.len() == oa.len() {
43012 } else if sa.len() < oa.len() {
43018 let front = sa.len();
43019 let mid = oa.len() - front;
43023 debug_assert_eq!(sa.len(), oa_front.len());
43024 debug_assert_eq!(sb_mid.len(), oa_mid.len());
43025 debug_assert_eq!(sb_back.len(), ob.len());
43028 let front = oa.len();
43029 let mid = sa.len() - front;
43033 debug_assert_eq!(sa_front.len(), oa.len());
43034 debug_assert_eq!(sa_mid.len(), ob_mid.len());
43035 debug_assert_eq!(sb.len(), ob_back.len());
43069 self.len().hash(state);
43151 if self.len() == self.capacity() {
43210 let len = other.len();
43214 assert!(len < MAXIMUM_ZST_CAPACITY, "capacity overflow");
43219 let min_cap = cmp::max(MINIMUM_CAPACITY, len) + 1;
43222 other.reserve_exact(cap - len);
43227 let (other_buf, len, capacity) = other.into_raw_parts();
43229 VecDeque { tail: 0, head: len, buf }
43271 let len = other.len();
43275 ptr::copy(buf.add(other.tail), buf, len);
43277 Vec::from_raw_parts(buf, len, cap)
43326 self.tail = wrap_index(self.tail.wrapping_add(1), self.ring.len());
43332 let len = count(self.tail, self.head, self.ring.len());
43333 (len, Some(len))
43361 let len = self.ring.len();
43362 self.tail = (self.ring.len() - back_iter.len()) & (len - 1);
43366 self.tail = self.head - iter.len();
43371 if n >= count(self.tail, self.head, self.ring.len()) {
43375 self.tail = wrap_index(self.tail.wrapping_add(n), self.ring.len());
43393 let idx = wrap_index(self.tail.wrapping_add(idx), self.ring.len());
43406 self.head = wrap_index(self.head.wrapping_sub(1), self.ring.len());
43435 self.head = front_iter.len();
43439 self.head = self.tail + iter.len();
43527 for len in 0..final_len {
43529 if back { (0..len).collect() } else { (0..len).rev().collect() };
43534 for i in 0..len * 2 {
43537 for i in 0..len {
43538 assert_eq!(tester.swap_remove_back(i), Some(len * 2 - 1 - i));
43541 for i in 0..len * 2 {
43544 for i in 0..len {
43545 let idx = tester.len() - 1 - i;
43546 assert_eq!(tester.swap_remove_front(idx), Some(len * 2 - 1 - i));
43570 // len is the length *after* insertion
43572 for len in minlen..cap {
43573 // 0, 1, 2, .., len - 1
43574 let expected = (0..).take(len).collect::<VecDeque<_>>();
43576 for to_insert in 0..len {
43579 for i in 0..len {
43714 // len is the length *after* removal
43716 for len in minlen..cap - 1 {
43717 // 0, 1, 2, .., len - 1
43718 let expected = (0..).take(len).collect::<VecDeque<_>>();
43720 for to_remove in 0..=len {
43723 for i in 0..len {
43729 if to_remove == len {
43747 for len in minlen..=cap {
43749 for start in 0..=len {
43750 for end in start..=len {
43753 for i in 0..len {
43772 for len in 0..=cap {
43774 for start in 0..=len {
43775 for end in start..=len {
43778 for i in 0..len {
43806 for len in 0..=cap {
43808 for drain_start in 0..=len {
43809 for drain_end in drain_start..=len {
43812 for i in 0..len {
43828 let expected: VecDeque<_> = (0..drain_start).chain(drain_end..len).collect();
43849 for len in 0..=cap {
43850 // 0, 1, 2, .., len - 1
43851 let expected = (0..).take(len).collect::<VecDeque<_>>();
43856 for i in 0..len {
43879 // len is the length *before* splitting
43881 for len in minlen..cap {
43883 for at in 0..=len {
43886 // at, at + 1, .., len - 1 (may be empty)
43887 let expected_other = (at..).take(len - at).collect::<VecDeque<_>>();
43892 for i in 0..len {
43911 for len in 0..=cap {
43913 vec.extend(0..len);
43917 assert_eq!(vd.len(), vec.len());
43925 assert_eq!(vd.len(), vec.len());
43935 assert_eq!(vd.len(), vec.len());
43942 fn create_vec_and_test_convert(capacity: usize, offset: usize, len: usize) {
43948 vd.extend(0..len);
43951 assert_eq!(vec.len(), vd.len());
43963 for len in 0..((cap + 1) / 2) {
43965 for offset in 0..(cap - len) {
43966 create_vec_and_test_convert(cap, offset, len)
43970 for offset in (cap - len)..(cap - (len / 2)) {
43971 create_vec_and_test_convert(cap, offset, len)
43975 for offset in (cap - (len / 2))..cap {
43976 create_vec_and_test_convert(cap, offset, len)
43982 // (cap + 1 - offset) > (cap + 1 - len) && (len - (cap + 1 - offset)) > (cap + 1 - len))
43984 for len in ((cap + 1) / 2)..cap {
43986 for offset in 0..(cap - len) {
43987 create_vec_and_test_convert(cap, offset, len)
43991 for offset in (cap - len)..(cap - (len / 2)) {
43992 create_vec_and_test_convert(cap, offset, len)
43996 for offset in (cap - (len / 2))..cap {
43997 create_vec_and_test_convert(cap, offset, len)
44041 for push_front in 0..=v.len() {
44167 self.tail = wrap_index(self.tail.wrapping_add(1), self.ring.len());
44177 let len = count(self.tail, self.head, self.ring.len());
44178 (len, Some(len))
44194 if n >= count(self.tail, self.head, self.ring.len()) {
44198 self.tail = wrap_index(self.tail.wrapping_add(n), self.ring.len());
44216 let idx = wrap_index(self.tail.wrapping_add(idx), self.ring.len());
44229 self.head = wrap_index(self.head.wrapping_sub(1), self.ring.len());
44330 //! let mut dist: Vec<_> = (0..adj_list.len()).map(|_| usize::MAX).collect();
44458 /// assert_eq!(heap.len(), 3);
44703 // SAFETY: !self.is_empty() means that self.len() > 0
44723 /// assert_eq!(heap.len(), 3);
44744 let old_len = self.len();
44747 // old_len = self.len() - 1 < self.len()
44770 let mut end = self.len();
44773 // SAFETY: `end` goes from `self.len() - 1` to 1 (both included),
44776 // 1 <= end < self.len(), which means self.len() >= 2.
44781 // SAFETY: `end` goes from `self.len() - 1` to 1 (both included) so:
44782 // 0 < 1 <= end <= self.len() - 1 < self.len()
44783 // Which means 0 < end and end < self.len().
44800 /// The caller must guarantee that `pos < self.len()`.
44803 // SAFETY: The caller guarantees that pos < self.len()
44829 /// The caller must guarantee that `pos < end <= self.len()`.
44831 // SAFETY: The caller guarantees that pos < end <= self.len().
44838 // SAFETY: child < end - 1 < self.len() and
44839 // child + 1 < end <= self.len(), so they're valid indexes.
44848 // We already proven that both are < self.len() and != hole.pos()
44859 // second condition it's already true that child == end - 1 < self.len().
44869 /// The caller must guarantee that `pos < self.len()`.
44871 let len = self.len();
44872 // SAFETY: pos < len is guaranteed by the caller and
44873 // obviously len = self.len() <= self.len().
44874 unsafe { self.sift_down_range(pos, len) };
44885 /// The caller must guarantee that `pos < self.len()`.
44887 let end = self.len();
44890 // SAFETY: The caller guarantees that pos < self.len().
44896 // SAFETY: child < end - 1 < self.len() and
44897 // child + 1 < end <= self.len(), so they're valid indexes.
44910 // SAFETY: child == end - 1 < self.len(), so it's a valid index
44924 if start == self.len() {
44928 let tail_len = self.len() - start;
44935 // `rebuild` takes O(self.len()) operations
44936 // and about 2 * self.len() comparisons in the worst case
44943 } else if self.len() <= 2048 {
44944 2 * self.len() < tail_len * log2_fast(start)
44946 2 * self.len() < tail_len * 11
44952 for i in start..self.len() {
44953 // SAFETY: The index `i` is always less than self.len().
44960 let mut n = self.len() / 2;
44963 // SAFETY: n starts from self.len() / 2 and goes down to 0.
44964 // The only case when !(n < self.len()) is if
44965 // self.len() == 0, but it's ruled out by the loop condition.
44992 if self.len() < other.len() {
44996 let start = self.data.len();
45020 /// assert_eq!(heap.len(), 5);
45023 /// assert_eq!(heap.len(), 0);
45055 let mut first_removed = self.len();
45302 /// assert_eq!(heap.len(), 2);
45306 pub fn len(&self) -> usize {
45307 self.data.len()
45330 self.len() == 0
45397 debug_assert!(pos < data.len());
45420 debug_assert!(index < self.data.len());
45430 debug_assert!(index < self.data.len());
45606 let exact = self.inner.len();
45708 let exact = self.inner.len();
45902 unsafe { slice::from_raw_parts(self.ptr, self.len()) }
45931 ptr::slice_from_raw_parts_mut(self.ptr as *mut T, self.len())
46008 self.len()
46174 let mut ptr = self.as_mut_ptr().add(self.len());
46175 let mut local_len = SetLenOnDrop::new(&mut self.len);
46245 return Vec { buf: RawVec::with_capacity_zeroed_in(n, alloc), len: n };
46260 return Vec { buf: RawVec::with_capacity_zeroed_in(n, alloc), len: n };
46275 return Vec { buf: RawVec::with_capacity_zeroed_in(n, alloc), len: n };
46400 let start = source_vec.len();
46617 if !has_advanced || iterator.len() >= iterator.cap / 2 {
46621 ptr::copy(it.ptr, it.buf.as_ptr(), it.len());
46623 return Vec::from_raw_parts(it.buf.as_ptr(), it.len(), it.cap);
46718 let len = SpecInPlaceCollect::collect_in_place(&mut iterator, dst_buf, dst_end);
46729 unsafe { dst_buf.add(len) as *const _ } <= src.ptr,
46739 let vec = unsafe { Vec::from_raw_parts(dst_buf, len, cap) };
46792 let len = self.size();
46794 for i in 0..len {
46806 len
46946 /// assert_eq!(vec.len(), 2);
46950 /// assert_eq!(vec.len(), 1);
47092 /// pointer points to [`len`] initialized, contiguous elements in order (what
47094 /// `[`len`] logically uninitialized, contiguous elements.
47102 /// ptr len capacity
47130 /// and then filling it back up to the same [`len`] should incur no calls to
47136 /// [`len`]` == `[`capacity`]. That is, the reported capacity is completely
47148 /// with exactly the requested capacity. If [`len`]` == `[`capacity`],
47174 /// [`len`]: Vec::len
47184 len: usize,
47206 Vec { buf: RawVec::NEW, len: 0 }
47231 /// assert_eq!(vec.len(), 0);
47238 /// assert_eq!(vec.len(), 10);
47243 /// assert_eq!(vec.len(), 11);
47301 /// let len = v.len();
47306 /// for i in 0..len as isize {
47311 /// let rebuilt = Vec::from_raw_parts(p, len, cap);
47340 Vec { buf: RawVec::new_in(alloc), len: 0 }
47370 /// assert_eq!(vec.len(), 0);
47377 /// assert_eq!(vec.len(), 10);
47382 /// assert_eq!(vec.len(), 11);
47388 Vec { buf: RawVec::with_capacity_in(capacity, alloc), len: 0 }
47446 /// let len = v.len();
47452 /// for i in 0..len as isize {
47457 /// let rebuilt = Vec::from_raw_parts_in(p, len, cap, alloc.clone());
47464 unsafe { Vec { buf: RawVec::from_raw_parts_in(ptr, capacity, alloc), len: length } }
47488 /// let (ptr, len, cap) = v.into_raw_parts();
47495 /// Vec::from_raw_parts(ptr, len, cap)
47502 (me.as_mut_ptr(), me.len(), me.capacity())
47531 /// let (ptr, len, cap, alloc) = v.into_raw_parts_with_alloc();
47538 /// Vec::from_raw_parts_in(ptr, len, cap, alloc)
47546 let len = me.len();
47550 (ptr, len, capacity, alloc)
47571 /// greater than or equal to `self.len() + additional`. Does nothing if
47588 self.buf.reserve(self.len, additional);
47593 /// capacity will be greater than or equal to `self.len() + additional`.
47614 self.buf.reserve_exact(self.len, additional);
47620 /// greater than or equal to `self.len() + additional`. Does nothing if
47638 /// output.try_reserve(data.len())?;
47652 self.buf.try_reserve(self.len, additional)
47658 /// `self.len() + additional` if it returns `Ok(())`.
47680 /// output.try_reserve_exact(data.len())?;
47694 self.buf.try_reserve_exact(self.len, additional)
47717 if self.capacity() > self.len {
47718 self.buf.shrink_to_fit(self.len);
47745 self.buf.shrink_to_fit(cmp::max(self.len, min_capacity));
47779 let len = me.len();
47780 buf.into_box(len).assume_init()
47784 /// Shortens the vector, keeping the first `len` elements and dropping
47787 /// If `len` is greater than the vector's current length, this has no
47806 /// No truncation occurs when `len` is greater than the vector's current
47815 /// Truncating when `len == 0` is equivalent to calling the [`clear`]
47827 pub fn truncate(&mut self, len: usize) {
47830 // * the slice passed to `drop_in_place` is valid; the `len > self.len`
47832 // * the `len` of the vector is shrunk before calling `drop_in_place`,
47839 if len > self.len {
47842 let remaining_len = self.len - len;
47843 let s = ptr::slice_from_raw_parts_mut(self.as_mut_ptr().add(len), remaining_len);
47844 self.len = len;
47901 /// for i in 0..x.len() {
48046 self.len = new_len;
48075 fn assert_failed(index: usize, len: usize) -> ! {
48076 panic!("swap_remove index (is {}) should be < len (is {})", index, len);
48079 let len = self.len();
48080 if index >= len {
48081 assert_failed(index, len);
48087 let last = ptr::read(self.as_ptr().add(len - 1));
48089 self.set_len(len - 1);
48099 /// Panics if `index > len`.
48114 fn assert_failed(index: usize, len: usize) -> ! {
48115 panic!("insertion index (is {}) should be <= len (is {})", index, len);
48118 let len = self.len();
48119 if index > len {
48120 assert_failed(index, len);
48124 if len == self.buf.capacity() {
48135 ptr::copy(p, p.offset(1), len - index);
48140 self.set_len(len + 1);
48162 fn assert_failed(index: usize, len: usize) -> ! {
48163 panic!("removal index (is {}) should be < len (is {})", index, len);
48166 let len = self.len();
48167 if index >= len {
48168 assert_failed(index, len);
48181 ptr::copy(ptr.offset(1), ptr, len - index - 1);
48183 self.set_len(len - 1);
48217 let original_len = self.len();
48223 // |<- processed len ->| ^- next to check
48335 let len = self.len();
48336 if len <= 1 {
48340 /* INVARIANT: vec.len() > read >= write > write-1 >= 0 */
48358 * and `len - read` never overflow and that the copy is always
48362 let len = self.vec.len();
48365 * Basically vec[read..].len() */
48366 let items_left = len.wrapping_sub(self.read);
48378 * Basically vec[read..write].len() */
48381 self.vec.set_len(len - dropped);
48395 while gap.read < len {
48443 if self.len == self.buf.capacity() {
48447 let end = self.as_mut_ptr().add(self.len);
48449 self.len += 1;
48466 if self.len == 0 {
48470 self.len -= 1;
48471 Some(ptr::read(self.as_ptr().add(self.len())))
48503 let count = unsafe { (*other).len() };
48505 let len = self.len();
48506 unsafe { ptr::copy_nonoverlapping(other as *const T, self.as_mut_ptr().add(len), count) };
48507 self.len += count;
48550 let len = self.len();
48551 let Range { start, end } = slice::range(range, ..len);
48561 tail_len: len - end,
48595 /// assert_eq!(a.len(), 3);
48600 pub fn len(&self) -> usize {
48601 self.len
48617 self.len() == 0
48623 /// `[at, len)`. After the call, the original vector will be left containing
48628 /// Panics if `at > len`.
48647 fn assert_failed(at: usize, len: usize) -> ! {
48648 panic!("`at` split index (is {}) should be <= len (is {})", at, len);
48651 if at > self.len() {
48652 assert_failed(at, self.len());
48663 let other_len = self.len - at;
48671 ptr::copy_nonoverlapping(self.as_ptr().add(at), other.as_mut_ptr(), other.len());
48676 /// Resizes the `Vec` in-place so that `len` is equal to `new_len`.
48678 /// If `new_len` is greater than `len`, the `Vec` is extended by the
48683 /// If `new_len` is less than `len`, the `Vec` is simply truncated.
48707 let len = self.len();
48708 if new_len > len {
48709 self.extend_with(new_len - len, ExtendFunc(f));
48784 self.as_mut_ptr().add(self.len) as *mut MaybeUninit<T>,
48785 self.buf.capacity() - self.len,
48835 /// let len = v.len();
48836 /// v.set_len(len + 4);
48845 // - len is ignored and so never changed
48858 let spare_len = self.buf.capacity() - self.len;
48861 // - `ptr` is guaranteed to be valid for `len` elements
48864 let initialized = slice::from_raw_parts_mut(ptr, self.len);
48867 (initialized, spare, &mut self.len)
48873 /// Resizes the `Vec` in-place so that `len` is equal to `new_len`.
48875 /// If `new_len` is greater than `len`, the `Vec` is extended by the
48877 /// If `new_len` is less than `len`, the `Vec` is simply truncated.
48897 let len = self.len();
48899 if new_len > len {
48900 self.extend_with(new_len - len, ExtendElement(value))
48951 let range = slice::range(src, ..self.len());
48952 self.reserve(range.len());
49004 let mut ptr = self.as_mut_ptr().add(self.len());
49008 let mut local_len = SetLenOnDrop::new(&mut self.len);
49024 // len set by scope guard
49071 /// - `self.capacity() - self.len()` must be `>= src.len()`
49078 // - len is increased only after initializing elements
49079 let (this, spare, len) = unsafe { self.split_at_spare_mut_with_len() };
49088 // - Element was just initialized with `MaybeUninit::write`, so it's ok to increase len
49089 // - len is increased after each element to prevent leaks (see issue #82533)
49090 .for_each(|_| *len += 1);
49096 let count = src.len();
49109 // - `count` is equal to the len of `source`, so source is valid for
49111 // - `.reserve(count)` guarantees that `spare.len() >= count` so spare
49118 self.len += count;
49131 unsafe { slice::from_raw_parts(self.as_ptr(), self.len) }
49138 unsafe { slice::from_raw_parts_mut(self.as_mut_ptr(), self.len) }
49162 self.truncate(other.len());
49164 // self.len <= other.len due to the truncate above, so the
49166 let (init, tail) = other.split_at(self.len());
49241 arith_offset(begin as *const i8, me.len() as isize) as *const T
49243 begin.add(me.len()) as *const T
49308 let len = self.len();
49309 if len == self.capacity() {
49314 ptr::write(self.as_mut_ptr().add(len), element);
49316 self.set_len(len + 1);
49376 /// while i < vec.len() {
49413 let old_len = self.len();
49475 ptr::drop_in_place(ptr::slice_from_raw_parts_mut(self.as_mut_ptr(), self.len))
49690 if vec.len() != N {
49712 len: &'a mut usize,
49718 pub(super) fn new(len: &'a mut usize) -> Self {
49719 SetLenOnDrop { local_len: *len, len }
49731 *self.len = self.local_len;
50037 if collected.len() > 0 {
50038 self.drain.move_tail(collected.len());
50041 debug_assert_eq!(collected.len(), 0);
50044 // Let `Drain::drop` move the tail back if necessary and restore `vec.len`.
50050 /// The range from `self.vec.len` to `self.tail_start` contains elements
50056 let range_start = vec.len;
50065 vec.len += 1;
50076 let len = self.tail_start + self.tail_len;
50077 vec.buf.reserve(len, additional);
50099 fn len(&self) -> usize {
50108 ptr::drop_in_place(slice::from_raw_parts_mut(self.inner, self.len()));
50721 pub fn new_uninit_slice(len: usize) -> Box<[mem::MaybeUninit<T>]> {
50722 unsafe { RawVec::with_capacity(len).into_box(len) }
50744 pub fn new_zeroed_slice(len: usize) -> Box<[mem::MaybeUninit<T>]> {
50745 unsafe { RawVec::with_capacity_zeroed(len).into_box(len) }
50774 pub fn new_uninit_slice_in(len: usize, alloc: A) -> Box<[mem::MaybeUninit<T>], A> {
50775 unsafe { RawVec::with_capacity_in(len, alloc).into_box(len) }
50800 pub fn new_zeroed_slice_in(len: usize, alloc: A) -> Box<[mem::MaybeUninit<T>], A> {
50801 unsafe { RawVec::with_capacity_zeroed_in(len, alloc).into_box(len) }
51403 let len = slice.len();
51404 let buf = RawVec::with_capacity(len);
51406 ptr::copy_nonoverlapping(slice.as_ptr(), buf.ptr(), len);
51407 buf.into_box(slice.len()).assume_init()
51498 if boxed_slice.len() == N {
51518 /// println!("String ({}): {}", string.len(), string);
51550 /// println!("String ({}): {}", string.len(), string);
51582 /// println!("String ({}): {}", string.len(), string);
51700 fn len(&self) -> usize {
51701 (**self).len()
51755 if self.len() == other.len() {
52081 assert_eq!(boxed.len(), 100);