Lines Matching defs:cap
6303 // * overflow may trigger when adding `len` to `cap` (in number of elements)
7611 let mut cap = 0;
7616 cap = v.capacity();
7623 drop(Vec::from_raw_parts(to_free, 0, cap));
7982 // * overflow may trigger when adding `len` to `cap` (in number of elements)
12078 let cap = ring.capacity() as i32;
12079 let first = cap / 2;
12080 let last = cap - first;
12099 assert_eq!(ring.len() as i32, cap);
12100 assert_eq!(ring.capacity() as i32, cap);
12106 let cap = ring.capacity() as i32;
12107 let first = cap / 2;
12108 let last = cap - first;
12127 assert_eq!(ring.len() as i32, cap);
12128 assert_eq!(ring.capacity() as i32, cap);
12361 // * overflow may trigger when adding `len` to `cap` (in number of elements)
14473 cap: usize,
14550 // `cap: 0` means "unallocated". zero-sized types are ignored.
14551 Self { ptr: Unique::dangling(), cap: 0, alloc }
14578 /// Note that this will correctly reconstitute any `cap` changes
14627 cap: Self::capacity_from_bytes(ptr.len()),
14645 Self { ptr: unsafe { Unique::new_unchecked(ptr) }, cap: capacity, alloc }
14661 if mem::size_of::<T>() == 0 { usize::MAX } else { self.cap }
14670 if mem::size_of::<T>() == 0 || self.cap == 0 {
14677 let size = mem::size_of::<T>() * self.cap;
14822 self.cap = Self::capacity_from_bytes(ptr.len());
14846 // because `cap <= isize::MAX` and the type of `cap` is `usize`.
14847 let cap = cmp::max(self.cap * 2, required_cap);
14848 let cap = cmp::max(Self::MIN_NON_ZERO_CAP, cap);
14850 let new_layout = Layout::array::<T>(cap);
14868 let cap = len.checked_add(additional).ok_or(CapacityOverflow)?;
14869 let new_layout = Layout::array::<T>(cap);
16567 /// let cap = s.capacity();
16572 /// assert_eq!(s.capacity(), cap);
16827 /// let (ptr, len, cap) = s.into_raw_parts();
16829 /// let rebuilt = unsafe { String::from_raw_parts(ptr, len, cap) };
40168 let tail_len = count(orig_tail, drain_tail, source_deque.cap());
40169 let head_len = count(drain_head, orig_head, source_deque.cap());
40516 fn cap(&self) -> usize {
40528 unsafe { slice::from_raw_parts(self.ptr(), self.cap()) }
40534 unsafe { slice::from_raw_parts_mut(self.ptr(), self.cap()) }
40554 self.cap() - self.len() == 1
40561 wrap_index(idx, self.cap())
40568 wrap_index(idx.wrapping_add(addend), self.cap())
40575 wrap_index(idx.wrapping_sub(subtrahend), self.cap())
40582 dst + len <= self.cap(),
40583 "cpy dst={} src={} len={} cap={}",
40587 self.cap()
40590 src + len <= self.cap(),
40591 "cpy dst={} src={} len={} cap={}",
40595 self.cap()
40606 dst + len <= self.cap(),
40607 "cno dst={} src={} len={} cap={}",
40611 self.cap()
40614 src + len <= self.cap(),
40615 "cno dst={} src={} len={} cap={}",
40619 self.cap()
40627 /// (abs(dst - src) + len) must be no larger than cap() (There must be at
40635 cmp::min(diff(dst, src), self.cap() - diff(dst, src)) + len <= self.cap(),
40636 "wrc dst={} src={} len={} cap={}",
40640 self.cap()
40649 let src_pre_wrap_len = self.cap() - src;
40650 let dst_pre_wrap_len = self.cap() - dst;
40755 self.copy(0, self.cap() - delta, delta);
40766 let new_capacity = self.cap();
40801 debug_assert!(self.head < self.cap());
40802 debug_assert!(self.tail < self.cap());
40803 debug_assert!(self.cap().count_ones() == 1);
40834 let cap = cmp::max(capacity + 1, MINIMUM_CAPACITY + 1).next_power_of_two();
40835 assert!(cap > capacity, "capacity overflow");
40837 VecDeque { tail: 0, head: 0, buf: RawVec::with_capacity(cap) }
40940 self.cap() - 1
40988 let old_cap = self.cap();
41079 let old_cap = self.cap();
41145 if target_cap < self.cap() {
41183 let len = self.cap() - self.tail;
41194 debug_assert!(self.head < self.cap());
41195 debug_assert!(self.tail < self.cap());
41196 debug_assert!(self.cap().count_ones() == 1);
41308 ring: ptr::slice_from_raw_parts_mut(self.ptr(), self.cap()),
41399 count(self.tail, self.head, self.cap())
41501 ring: ptr::slice_from_raw_parts_mut(self.ptr(), self.cap()),
42046 self.copy(0, self.cap() - 1, 1);
42049 self.copy(idx + 1, idx, self.cap() - 1 - idx);
42067 self.copy(self.tail - 1, self.tail, self.cap() - self.tail);
42070 self.copy(self.cap() - 1, 0, 1);
42087 self.copy(self.tail - 1, self.tail, self.cap() - self.tail);
42090 self.copy(self.cap() - 1, 0, 1);
42258 self.copy(idx, idx + 1, self.cap() - idx - 1);
42263 self.copy(self.cap() - 1, 0, 1);
42287 self.copy(0, self.cap() - 1, 1);
42290 self.copy(self.tail + 1, self.tail, self.cap() - self.tail - 1);
42447 let old_cap = self.cap();
42450 assert!(self.cap() == old_cap * 2);
42558 let cap = self.cap();
42562 let tail_len = cap - self.tail;
42621 while left_edge < len && right_edge != cap {
42624 right_offset = (i - left_edge) % (cap - right_edge);
42732 // `wrap_copy` requires that `min(x, cap() - x) + copy_len <= cap()`,
43220 let cap = cmp::max(min_cap, other.capacity()).next_power_of_two();
43221 if other.capacity() != cap {
43222 other.reserve_exact(cap - len);
43272 let cap = other.cap();
43277 Vec::from_raw_parts(buf, len, cap)
43549 assert!(tester.tail < tester.cap());
43550 assert!(tester.head < tester.cap());
43568 let cap = tester.capacity();
43571 let minlen = if cfg!(miri) { cap - 1 } else { 1 }; // Miri is too slow
43572 for len in minlen..cap {
43575 for tail_pos in 0..cap {
43585 assert!(tester.tail < tester.cap());
43586 assert!(tester.head < tester.cap());
43712 let cap = tester.capacity();
43715 let minlen = if cfg!(miri) { cap - 2 } else { 0 }; // Miri is too slow
43716 for len in minlen..cap - 1 {
43719 for tail_pos in 0..cap {
43733 assert!(tester.tail < tester.cap());
43734 assert!(tester.head < tester.cap());
43745 let cap = tester.capacity();
43746 let minlen = if cfg!(miri) { cap - 1 } else { 0 }; // Miri is too slow
43747 for len in minlen..=cap {
43748 for tail in 0..=cap {
43771 let cap = tester.capacity();
43772 for len in 0..=cap {
43773 for tail in 0..=cap {
43792 assert_eq!(tester.capacity(), cap);
43805 let cap = tester.capacity();
43806 for len in 0..=cap {
43807 for tail in 0..=cap {
43823 assert_eq!(tester.capacity(), cap);
43824 assert!(tester.tail < tester.cap());
43825 assert!(tester.head < tester.cap());
43845 let cap = tester.capacity();
43849 for len in 0..=cap {
43860 assert!(tester.capacity() <= cap);
43861 assert!(tester.tail < tester.cap());
43862 assert!(tester.head < tester.cap());
43877 let cap = tester.capacity();
43880 let minlen = if cfg!(miri) { cap - 1 } else { 0 }; // Miri is too slow
43881 for len in minlen..cap {
43889 for tail_pos in 0..cap {
43896 assert!(tester.tail < tester.cap());
43897 assert!(tester.head < tester.cap());
43898 assert!(result.tail < result.cap());
43899 assert!(result.head < result.cap());
43910 for cap in 0..35 {
43911 for len in 0..=cap {
43912 let mut vec = Vec::with_capacity(cap);
43916 assert!(vd.cap().is_power_of_two());
43924 assert!(vd.cap().is_power_of_two());
43934 assert!(vd.cap().is_power_of_two());
43960 let cap = (2i32.pow(cap_pwr) - 1) as usize;
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)
45875 pub(super) cap: usize,
45949 self.cap = 0;
46096 let _ = RawVec::from_raw_parts_in(self.0.buf.as_ptr(), self.0.cap, alloc);
46617 if !has_advanced || iterator.len() >= iterator.cap / 2 {
46623 return Vec::from_raw_parts(it.buf.as_ptr(), it.len(), it.cap);
46707 let (src_buf, src_ptr, dst_buf, dst_end, cap) = unsafe {
46714 inner.cap,
46739 let vec = unsafe { Vec::from_raw_parts(dst_buf, len, cap) };
47302 /// let cap = v.capacity();
47311 /// let rebuilt = Vec::from_raw_parts(p, len, cap);
47447 /// let cap = v.capacity();
47457 /// let rebuilt = Vec::from_raw_parts_in(p, len, cap, alloc.clone());
47488 /// let (ptr, len, cap) = v.into_raw_parts();
47495 /// Vec::from_raw_parts(ptr, len, cap)
47531 /// let (ptr, len, cap, alloc) = v.into_raw_parts_with_alloc();
47538 /// Vec::from_raw_parts_in(ptr, len, cap, alloc)
49245 let cap = me.buf.capacity();
49249 cap,