Lines Matching defs:ptr
67 use core::ptr::{self, NonNull};
316 /// ptr len capacity
547 /// * `ptr` must have been allocated using the global allocator, such as via
549 /// * `T` needs to have the same alignment as what `ptr` was allocated with.
562 /// These requirements are always upheld by any `ptr` that has been allocated
578 /// The ownership of `ptr` is effectively transferred to the
591 /// use std::ptr;
609 /// ptr::write(p.add(i), 4 + i);
643 pub unsafe fn from_raw_parts(ptr: *mut T, length: usize, capacity: usize) -> Self {
644 unsafe { Self::from_raw_parts_in(ptr, length, capacity, Global) }
799 /// * `ptr` must be [*currently allocated*] via the given allocator `alloc`.
800 /// * `T` needs to have the same alignment as what `ptr` was allocated with.
813 /// These requirements are always upheld by any `ptr` that has been allocated
825 /// The ownership of `ptr` is effectively transferred to the
843 /// use std::ptr;
865 /// ptr::write(p.add(i), 4 + i);
901 pub unsafe fn from_raw_parts_in(ptr: *mut T, length: usize, capacity: usize, alloc: A) -> Self {
902 unsafe { Vec { buf: RawVec::from_raw_parts_in(ptr, capacity, alloc), len: length } }
926 /// let (ptr, len, cap) = v.into_raw_parts();
931 /// let ptr = ptr as *mut u32;
933 /// Vec::from_raw_parts(ptr, len, cap)
969 /// let (ptr, len, cap, alloc) = v.into_raw_parts_with_alloc();
974 /// let ptr = ptr as *mut u32;
976 /// Vec::from_raw_parts_in(ptr, len, cap, alloc)
986 let ptr = me.as_mut_ptr();
987 let alloc = unsafe { ptr::read(me.allocator()) };
988 (ptr, len, capacity, alloc)
1222 let buf = ptr::read(&me.buf);
1287 let s = ptr::slice_from_raw_parts_mut(self.as_mut_ptr().add(len), remaining_len);
1289 ptr::drop_in_place(s);
1358 self.buf.ptr()
1391 self.buf.ptr()
1528 let value = ptr::read(self.as_ptr().add(index));
1530 ptr::copy(base_ptr.add(len - 1), base_ptr.add(index), 1);
1576 ptr::copy(p, p.add(1), len - index);
1584 ptr::write(p, element);
1632 let ptr = self.as_mut_ptr().add(index);
1635 ret = ptr::read(ptr);
1638 ptr::copy(ptr.add(1), ptr, len - index - 1);
1728 ptr::copy(
1759 unsafe { ptr::drop_in_place(cur) };
1772 ptr::copy_nonoverlapping(cur, hole_slot, 1);
1862 let ptr = self.vec.as_mut_ptr();
1870 let dropped_ptr = ptr.add(self.write);
1872 let valid_ptr = ptr.add(self.read);
1876 ptr::copy(valid_ptr, dropped_ptr, items_left);
1888 let ptr = gap.vec.as_mut_ptr();
1897 let read_ptr = ptr.add(gap.read);
1898 let prev_ptr = ptr.add(gap.write.wrapping_sub(1));
1904 ptr::drop_in_place(read_ptr);
1906 let write_ptr = ptr.add(gap.write);
1911 ptr::copy(read_ptr, write_ptr, 1);
1951 ptr::write(end, value);
1973 ptr::write(end, value);
2018 ptr::write(end, value);
2047 Some(ptr::read(self.as_ptr().add(self.len())))
2084 unsafe { ptr::copy_nonoverlapping(other as *const T, self.as_mut_ptr().add(len), count) };
2094 unsafe { ptr::copy_nonoverlapping(other as *const T, self.as_mut_ptr().add(len), count) };
2140 // Drain will ptr::read out the values to remove.
2187 ptr::drop_in_place(elems);
2274 ptr::copy_nonoverlapping(self.as_ptr().add(at), other.as_mut_ptr(), other.len());
2460 let ptr = self.as_mut_ptr();
2462 // - `ptr` is guaranteed to be valid for `self.len` elements
2465 let spare_ptr = unsafe { ptr.add(self.len) };
2470 // - `ptr` is guaranteed to be valid for `self.len` elements
2473 let initialized = slice::from_raw_parts_mut(ptr, self.len);
2667 let (ptr, len, cap, alloc) = self.into_raw_parts_with_alloc();
2679 // - `ptr` was allocated by `self`
2680 // - `ptr` is well-aligned because `[T; N]` has the same alignment as `T`.
2684 unsafe { Vec::<T, A>::from_raw_parts_in(ptr.cast(), new_len, new_cap, alloc) }
2695 let mut ptr = self.as_mut_ptr().add(self.len());
2697 // might not realize the store through `ptr` through self.set_len()
2703 ptr::write(ptr, value.clone());
2704 ptr = ptr.add(1);
2711 ptr::write(ptr, value);
2724 let mut ptr = self.as_mut_ptr().add(self.len());
2726 // might not realize the store through `ptr` through self.set_len()
2732 ptr::write(ptr, value.clone());
2733 ptr = ptr.add(1);
2740 ptr::write(ptr, value);
2836 unsafe { ptr::copy_nonoverlapping(source.as_ptr(), spare.as_mut_ptr() as _, count) };
2970 let alloc = ManuallyDrop::new(ptr::read(me.allocator()));
2983 ptr: begin,
3048 ptr::write(self.as_mut_ptr().add(len), element);
3074 ptr::write(self.as_mut_ptr().add(len), element);
3099 let ptr = self.as_mut_ptr();
3102 ptr::write(ptr.add(local_len.current_len()), element);
3132 let ptr = self.as_mut_ptr();
3135 ptr::write(ptr.add(local_len.current_len()), element);
3315 ptr::drop_in_place(ptr::slice_from_raw_parts_mut(self.as_mut_ptr(), self.len))
3556 let array = unsafe { ptr::read(vec.as_ptr() as *const [T; N]) };