Lines Matching defs:mem
753 let tmp = std::mem::take(&mut data);
1005 let tmp = std::mem::take(&mut data);
1025 let tmp = std::mem::take(&mut data);
1053 input.into_iter().map(|e| unsafe { std::mem::transmute_copy(&e) }).collect()
1061 let v = std::mem::take(&mut vec);
1210 b.bytes = std::mem::size_of_val(template.as_slice()) as u64;
1229 b.bytes = std::mem::size_of_val(template.as_slice()) as u64;
2031 use std::{mem, ptr};
2270 b.bytes = $len * mem::size_of_val(&$gen(1)[0]) as u64;
2282 b.bytes = $len * mem::size_of::<&str>() as u64;
2304 b.bytes = $len * mem::size_of_val(&$gen(1)[0]) as u64;
2315 b.bytes = $len * mem::size_of_val(&$gen(1)[0]) as u64;
2358 let mut v: Vec<_> = (0..1 + (n / mem::size_of::<$ty>() as u64)).map($f).collect();
2382 let size = mem::size_of_val(&$gen(1)[0]);
2510 std::mem::forget(peek_mut);
3301 use std::mem;
3429 assert_eq!(mem::size_of::<Box<u16>>() * SHARED_ITER_MAX as usize, mem::size_of_val(&*rc));
3445 assert_eq!(0, mem::size_of_val(&*rc));
6535 use std::mem::{size_of, swap};
7380 std::mem::forget(v.splice(2..4, a.iter().cloned()));
8305 unsafe { std::mem::transmute::<*mut dyn Fn(), DynRepr>(ptr).vtable }
8309 unsafe { std::mem::transmute::<DynRepr, *mut dyn Fn()>(DynRepr { data, vtable }) }
9058 use std::mem;
9182 assert_eq!(mem::size_of::<Box<u16>>() * SHARED_ITER_MAX as usize, mem::size_of_val(&*rc));
9198 assert_eq!(0, mem::size_of_val(&*rc));
9250 use std::mem;
9329 assert_eq!(mem::size_of::<Z>(), 0);
11208 use std::mem::size_of;
13184 let a: isize = ::std::mem::transmute(3_usize);
13773 use std::mem::MaybeUninit;
14429 use core::mem::{self, ManuallyDrop, MaybeUninit};
14538 const MIN_NON_ZERO_CAP: usize = if mem::size_of::<T>() == 1 {
14540 } else if mem::size_of::<T>() <= 1024 {
14603 if mem::size_of::<T>() == 0 {
14661 if mem::size_of::<T>() == 0 { usize::MAX } else { self.cap }
14670 if mem::size_of::<T>() == 0 || self.cap == 0 {
14676 let align = mem::align_of::<T>();
14677 let size = mem::size_of::<T>() * self.cap;
14816 debug_assert_ne!(mem::size_of::<T>(), 0);
14817 excess / mem::size_of::<T>()
14836 if mem::size_of::<T>() == 0 {
14862 if mem::size_of::<T>() == 0 {
14880 let (ptr, layout) = if let Some(mem) = self.current_memory() { mem } else { return Ok(()) };
14881 let new_size = amount * mem::size_of::<T>();
15001 use core::mem;
15186 let mut b = mem::take(target).into_bytes();
15557 use std::mem::drop;
16361 /// use std::mem;
16367 /// let mut story = mem::ManuallyDrop::new(story);
16864 /// use std::mem;
16871 /// let mut s = mem::ManuallyDrop::new(s);
19755 use core::mem::{self, align_of_val_raw, forget, size_of_val};
19878 value: mem::MaybeUninit::<T>::uninit(),
19907 mem::forget(weak);
19933 pub fn new_uninit() -> Rc<mem::MaybeUninit<T>> {
19938 |mem| mem as *mut RcBox<mem::MaybeUninit<T>>,
19962 /// [zeroed]: mem::MaybeUninit::zeroed
19964 pub fn new_zeroed() -> Rc<mem::MaybeUninit<T>> {
19969 |mem| mem as *mut RcBox<mem::MaybeUninit<T>>,
20021 pub fn try_new_uninit() -> Result<Rc<mem::MaybeUninit<T>>, AllocError> {
20026 |mem| mem as *mut RcBox<mem::MaybeUninit<T>>,
20051 /// [zeroed]: mem::MaybeUninit::zeroed
20054 pub fn try_new_zeroed() -> Result<Rc<mem::MaybeUninit<T>>, AllocError> {
20059 |mem| mem as *mut RcBox<mem::MaybeUninit<T>>,
20136 pub fn new_uninit_slice(len: usize) -> Rc<[mem::MaybeUninit<T>]> {
20159 /// [zeroed]: mem::MaybeUninit::zeroed
20161 pub fn new_zeroed_slice(len: usize) -> Rc<[mem::MaybeUninit<T>]> {
20166 |mem| {
20167 ptr::slice_from_raw_parts_mut(mem as *mut T, len)
20168 as *mut RcBox<[mem::MaybeUninit<T>]>
20175 impl<T> Rc<mem::MaybeUninit<T>> {
20186 /// [`MaybeUninit::assume_init`]: mem::MaybeUninit::assume_init
20210 Rc::from_inner(mem::ManuallyDrop::new(self).ptr.cast())
20214 impl<T> Rc<[mem::MaybeUninit<T>]> {
20225 /// [`MaybeUninit::assume_init`]: mem::MaybeUninit::assume_init
20251 unsafe { Rc::from_ptr(mem::ManuallyDrop::new(self).ptr.as_ptr() as _) }
20275 mem::forget(this);
20312 /// [`mem::transmute`][transmute] for more information on what
20322 /// [transmute]: core::mem::transmute
20436 let rc = unsafe { mem::ManuallyDrop::new(Rc::<T>::from_raw(ptr)) };
20438 let _rc_clone: mem::ManuallyDrop<_> = rc.clone();
20472 unsafe { mem::drop(Rc::from_raw(ptr)) };
20749 |mem| (ptr as *mut RcBox<T>).set_ptr_value(mem),
20784 |mem| ptr::slice_from_raw_parts_mut(mem as *mut T, len) as *mut RcBox<[T]>,
20808 mem: NonNull<u8>,
20820 Global.deallocate(self.mem, self.layout);
20828 let mem = ptr as *mut _ as *mut u8;
20834 let mut guard = Guard { mem: NonNull::new_unchecked(mem), elems, layout, n_elems: 0 };
21568 mem::forget(self);
21847 // NOTE: We checked_add here to deal with mem::forget safely. In particular
21848 // if you mem::forget Rcs (or Weaks), the ref-count can overflow, and then
22058 use core::mem::{self, size_of};
22169 core::mem::forget(guard);
22387 let sz_u8 = mem::size_of::<(K, u8)>();
22388 let sz_u16 = mem::size_of::<(K, u16)>();
22389 let sz_u32 = mem::size_of::<(K, u32)>();
22390 let sz_usize = mem::size_of::<(K, usize)>();
22832 let mut tmp = mem::ManuallyDrop::new(ptr::read(&v[0]));
22980 let len = (self.end as usize - self.start as usize) / mem::size_of::<T>();
23126 use core::mem::ManuallyDrop;
23287 use core::mem::{self, align_of_val_raw, size_of_val};
23638 data: mem::MaybeUninit::<T>::uninit(),
23679 mem::forget(weak);
23705 pub fn new_uninit() -> Arc<mem::MaybeUninit<T>> {
23710 |mem| mem as *mut ArcInner<mem::MaybeUninit<T>>,
23734 /// [zeroed]: ../../std/mem/union.MaybeUninit.html#method.zeroed
23736 pub fn new_zeroed() -> Arc<mem::MaybeUninit<T>> {
23741 |mem| mem as *mut ArcInner<mem::MaybeUninit<T>>,
23802 pub fn try_new_uninit() -> Result<Arc<mem::MaybeUninit<T>>, AllocError> {
23807 |mem| mem as *mut ArcInner<mem::MaybeUninit<T>>,
23832 /// [zeroed]: mem::MaybeUninit::zeroed
23835 pub fn try_new_zeroed() -> Result<Arc<mem::MaybeUninit<T>>, AllocError> {
23840 |mem| mem as *mut ArcInner<mem::MaybeUninit<T>>,
23877 mem::forget(this);
23909 pub fn new_uninit_slice(len: usize) -> Arc<[mem::MaybeUninit<T>]> {
23932 /// [zeroed]: ../../std/mem/union.MaybeUninit.html#method.zeroed
23934 pub fn new_zeroed_slice(len: usize) -> Arc<[mem::MaybeUninit<T>]> {
23939 |mem| {
23940 ptr::slice_from_raw_parts_mut(mem as *mut T, len)
23941 as *mut ArcInner<[mem::MaybeUninit<T>]>
23948 impl<T> Arc<mem::MaybeUninit<T>> {
23959 /// [`MaybeUninit::assume_init`]: ../../std/mem/union.MaybeUninit.html#method.assume_init
23983 Arc::from_inner(mem::ManuallyDrop::new(self).ptr.cast())
23987 impl<T> Arc<[mem::MaybeUninit<T>]> {
23998 /// [`MaybeUninit::assume_init`]: ../../std/mem/union.MaybeUninit.html#method.assume_init
24024 unsafe { Arc::from_ptr(mem::ManuallyDrop::new(self).ptr.as_ptr() as _) }
24046 mem::forget(this);
24083 /// [`mem::transmute`][transmute] for more information on what
24093 /// [transmute]: core::mem::transmute
24253 let arc = unsafe { mem::ManuallyDrop::new(Arc::<T>::from_raw(ptr)) };
24255 let _arc_clone: mem::ManuallyDrop<_> = arc.clone();
24291 unsafe { mem::drop(Arc::from_raw(ptr)) };
24399 |mem| (ptr as *mut ArcInner<T>).set_ptr_value(mem) as *mut ArcInner<T>,
24434 |mem| ptr::slice_from_raw_parts_mut(mem as *mut T, len) as *mut ArcInner<[T]>,
24460 mem: NonNull<u8>,
24472 Global.deallocate(self.mem, self.layout);
24480 let mem = ptr as *mut _ as *mut u8;
24486 let mut guard = Guard { mem: NonNull::new_unchecked(mem), elems, layout, n_elems: 0 };
24494 mem::forget(guard);
24552 // is `mem::forget`ing Arcs. If we don't do this the count can overflow
24873 mem::forget(self);
24980 mem::forget(self);
25025 /// [`forget`]: std::mem::forget
25089 // See comments in `Arc::clone` for why we do this (for `mem::forget`).
25235 // See comments in Arc::clone() for why we do this (for mem::forget).
26390 use std::mem::drop;
26964 use core::mem;
27225 let len = mem::replace(&mut self.len, 0);
27269 mem::replace(self, LinkedList::new())
27309 mem::replace(self, LinkedList::new())
27372 None => mem::swap(self, other),
27383 self.len += mem::replace(&mut other.len, 0);
27393 None => mem::swap(self, other),
27404 self.len += mem::replace(&mut other.len, 0);
27807 return mem::take(self);
27935 mem::forget(guard);
28527 mem::forget(guard);
29799 use core::mem::{self, ManuallyDrop};
30056 Found(mut kv) => Some(mem::replace(kv.key_mut(), key)),
30792 mem::swap(self, other);
30796 let self_iter = mem::take(self).into_iter();
30797 let other_iter = mem::take(other).into_iter();
31259 mem::forget(guard);
32061 use core::mem;
32092 mem::forget(guard);
34064 super::mem::replace(self, |leaf_edge| {
34077 super::mem::replace(self, |leaf_edge| {
34092 let kv = super::mem::replace(self, |leaf_edge| {
34107 let kv = super::mem::replace(self, |leaf_edge| {
34131 super::mem::replace(self, |leaf_edge| unsafe {
34149 super::mem::replace(self, |leaf_edge| unsafe {
34267 mod mem;
35048 use core::mem;
35519 mem::replace(self.get_mut(), value)
35571 use std::mem;
35598 mem::swap(dummy, r);
35601 mem::swap(dummy, r);
35678 let iter = mem::take(self).into_iter();
37956 use core::mem::{self, MaybeUninit};
38478 super::mem::take_mut(self, |old_root| NodeRef::new_internal(old_root).forget_type());
38967 (mem::replace(key, k), mem::replace(val, v))
39726 assert_eq!(core::mem::size_of::<LeafNode<(), ()>>(), 16);
39727 assert_eq!(core::mem::size_of::<LeafNode<i64, i64>>(), 16 + CAPACITY * 2 * 8);
39728 assert_eq!(core::mem::size_of::<InternalNode<(), ()>>(), 16 + (CAPACITY + 1) * 8);
39729 assert_eq!(core::mem::size_of::<InternalNode<i64, i64>>(), 16 + (CAPACITY * 3 + 1) * 8);
40113 use core::{fmt, mem};
40201 mem::forget(guard);
40294 use core::mem::replace;
40372 use core::mem::{self, ManuallyDrop};
40517 if mem::size_of::<T>() == 0 {
41514 /// (e.g., due to `mem::forget`).
43211 if mem::size_of::<T>() == 0 {
44415 use core::mem::{self, swap, ManuallyDrop};
45692 mem::forget(guard);
45853 use core::mem::{self};
45940 /// (&mut into_iter).for_each(core::mem::drop);
45980 } else if mem::size_of::<T>() == 0 {
45987 Some(unsafe { mem::zeroed() })
45998 let exact = if mem::size_of::<T>() == 0 {
46024 if mem::size_of::<T>() == 0 { mem::zeroed() } else { ptr::read(self.ptr.add(i)) }
46035 } else if mem::size_of::<T>() == 0 {
46040 Some(unsafe { mem::zeroed() })
46285 use core::mem::{self};
46417 mem::forget(guard);
46567 use core::mem::ManuallyDrop;
46665 use core::mem::{self, ManuallyDrop};
46697 if mem::size_of::<T>() == 0
46698 || mem::size_of::<T>()
46699 != mem::size_of::<<<I as SourceIter>::Source as AsIntoIter>::Item>()
46700 || mem::align_of::<T>()
46701 != mem::align_of::<<<I as SourceIter>::Source as AsIntoIter>::Item>()
46805 mem::forget(drop_guard);
46871 use core::mem::{self, ManuallyDrop, MaybeUninit};
47084 /// if [`mem::size_of::<T>`]`() * capacity() > 0`. In general, `Vec`'s allocation
47173 /// [`mem::size_of::<T>`]: core::mem::size_of
47178 /// [`MaybeUninit`]: core::mem::MaybeUninit
47290 /// use std::mem;
47297 /// let mut v = mem::ManuallyDrop::new(v);
47432 /// use std::mem;
47442 /// let mut v = mem::ManuallyDrop::new(v);
48421 mem::forget(gap);
48515 /// iterator **is not** dropped (with [`mem::forget`] for example), it is
48657 return mem::replace(
49240 let end = if mem::size_of::<T>() == 0 {
50314 use core::mem;
50378 pub fn new_uninit() -> Box<mem::MaybeUninit<T>> {
50399 /// [zeroed]: mem::MaybeUninit::zeroed
50403 pub fn new_zeroed() -> Box<mem::MaybeUninit<T>> {
50457 pub fn try_new_uninit() -> Result<Box<mem::MaybeUninit<T>>, AllocError> {
50479 /// [zeroed]: mem::MaybeUninit::zeroed
50483 pub fn try_new_zeroed() -> Result<Box<mem::MaybeUninit<T>>, AllocError> {
50559 pub fn new_uninit_in(alloc: A) -> Box<mem::MaybeUninit<T>, A> {
50560 let layout = Layout::new::<mem::MaybeUninit<T>>();
50593 pub fn try_new_uninit_in(alloc: A) -> Result<Box<mem::MaybeUninit<T>, A>, AllocError> {
50594 let layout = Layout::new::<mem::MaybeUninit<T>>();
50618 /// [zeroed]: mem::MaybeUninit::zeroed
50621 pub fn new_zeroed_in(alloc: A) -> Box<mem::MaybeUninit<T>, A> {
50622 let layout = Layout::new::<mem::MaybeUninit<T>>();
50652 /// [zeroed]: mem::MaybeUninit::zeroed
50655 pub fn try_new_zeroed_in(alloc: A) -> Result<Box<mem::MaybeUninit<T>, A>, AllocError> {
50656 let layout = Layout::new::<mem::MaybeUninit<T>>();
50721 pub fn new_uninit_slice(len: usize) -> Box<[mem::MaybeUninit<T>]> {
50742 /// [zeroed]: mem::MaybeUninit::zeroed
50744 pub fn new_zeroed_slice(len: usize) -> Box<[mem::MaybeUninit<T>]> {
50774 pub fn new_uninit_slice_in(len: usize, alloc: A) -> Box<[mem::MaybeUninit<T>], A> {
50797 /// [zeroed]: mem::MaybeUninit::zeroed
50800 pub fn new_zeroed_slice_in(len: usize, alloc: A) -> Box<[mem::MaybeUninit<T>], A> {
50805 impl<T, A: Allocator> Box<mem::MaybeUninit<T>, A> {
50816 /// [`MaybeUninit::assume_init`]: mem::MaybeUninit::assume_init
50842 impl<T, A: Allocator> Box<[mem::MaybeUninit<T>], A> {
50853 /// [`MaybeUninit::assume_init`]: mem::MaybeUninit::assume_init
51151 unsafe { &mut *mem::ManuallyDrop::new(b).0.as_ptr() }