Lines Matching defs:dropped
3408 // Clone a bit and let these get dropped.
3431 // Clone a bit and let these get dropped.
6572 // doing anything significant when dropped multiple times.
6575 // Here tv goes out of scope, tv.y should be dropped, but not tv.x.
6833 // Everything is dropped when predicate panicked.
6848 // Everything is dropped when predicate panicked.
6876 // Other elements are dropped when `drop` of one element panicked.
6877 // The panicked wrapper also has its Rc dropped.
7552 assert_eq!(Rc::strong_count(&drop_count[0]), 1, "front was dropped");
7554 assert_eq!(Rc::strong_count(&drop_count[2]), 1, "tail was dropped");
7578 "all items were dropped once"
7870 // vec would still be dropped exactly once.
7922 // vec would still be dropped exactly once.
7930 // NOTE: The DrainFilter is dropped without being consumed
9161 // Clone a bit and let these get dropped.
9184 // Clone a bit and let these get dropped.
10759 // When xs is dropped, +5.
10953 // Check that the number of things dropped is exactly
10960 // Check that the most recent versions of values were dropped.
13757 // Assert no elements were dropped
14463 /// This type does not in anyway inspect the memory that it manages. When dropped it *will*
15917 // At this point, the weak points to a dropped DST
19503 //! referred to as "inner value") is also dropped.
19521 //! already been dropped. In other words, `Weak` pointers do not keep the value
19557 //! already been dropped.
19624 //! // of the `Owner` of the `Gadget`s. This is because we've only dropped a
20316 /// dropped once.
20806 // into the new RcBox will be dropped, then the memory freed.
20898 /// println!("dropped!");
20906 /// drop(foo2); // Prints "dropped!"
21427 /// prevent the value stored in the allocation from being dropped, and `Weak` itself makes no
21433 /// managed by [`Rc`] without preventing its inner value from being dropped. It is also used to
21435 /// would never allow either [`Rc`] to be dropped. For example, a tree could
21532 // The payload may be dropped at this point, and we have to maintain provenance,
21623 // SAFETY: data_offset is safe to call, as ptr references a real (potentially dropped) T.
21637 /// Returns [`None`] if the inner value has since been dropped.
21701 // is dropped, the data field will be dropped in-place).
21770 /// println!("dropped!");
21779 /// drop(foo); // Prints "dropped!"
21956 /// valid instance of T, but the T is allowed to be dropped.
22841 // If `is_less` panics at any point during the process, `hole` will get dropped and
22854 // `hole` gets dropped and thus copies `tmp` into the remaining hole in `v`.
22858 // When dropped, copies from `src` into `dest`.
22902 // If `is_less` panics at any point during the process, `hole` will get dropped and fill the
22956 // Finally, `hole` gets dropped. If the shorter run was not fully consumed, whatever remains of
22970 // When dropped, copies the range `start..end` into `dest..`.
23338 /// referred to as "inner value") is also dropped.
23376 /// already been dropped. In other words, `Weak` pointers do not keep the value
23428 /// already been dropped.
23526 /// prevent the value stored in the allocation from being dropped, and `Weak` itself makes no
23532 /// managed by [`Arc`] without preventing its inner value from being dropped. It is also used to
23534 /// would never allow either [`Arc`] to be dropped. For example, a tree could
24087 /// dropped once.
24458 // into the new ArcInner will be dropped, then the memory freed.
24637 // dropped. Worst case, we end up allocated a new Arc unnecessarily.
24756 // weak ref was never dropped, the CAS here will fail so we do not care to synchronize.
24760 // is being dropped.
24791 /// println!("dropped!");
24799 /// drop(foo2); // Prints "dropped!"
24944 // The payload may be dropped at this point, and we have to maintain provenance,
25035 // SAFETY: data_offset is safe to call, as ptr references a real (potentially dropped) T.
25051 /// Returns [`None`] if the inner value has since been dropped.
25153 // is dropped, the data field will be dropped in-place).
25278 /// println!("dropped!");
25287 /// drop(foo); // Prints "dropped!"
25785 /// valid instance of T, but the T is allowed to be dropped.
26714 // At this point, the weak points to a dropped DST
29303 dropped: AtomicUsize,
29313 dropped: AtomicUsize::new(0),
29329 /// Returns how many times instances of the dummy have been dropped.
29330 pub fn dropped(&self) -> usize {
29331 self.dropped.load(SeqCst)
29381 self.origin.dropped.fetch_add(1, SeqCst);
30984 /// dropped.
33117 /// values will still be subjected to the closure and removed and dropped if it returns true.
34651 assert_eq!(a.dropped(), 1);
34652 assert_eq!(b.dropped(), 1);
34653 assert_eq!(c.dropped(), 1);
34671 assert_eq!(a.dropped(), 1);
34672 assert_eq!(b.dropped(), 0);
34673 assert_eq!(c.dropped(), 0);
36707 assert_eq!(a.dropped(), 1);
36708 assert_eq!(b.dropped(), 1);
36709 assert_eq!(c.dropped(), 1);
36728 assert_eq!(a.dropped(), 1);
36729 assert_eq!(b.dropped(), 0);
36730 assert_eq!(c.dropped(), 0);
36760 assert_eq!(a.dropped(), 1);
36761 assert_eq!(b.dropped(), 0);
36762 assert_eq!(c.dropped(), 0);
36998 assert_eq!(a.dropped(), 1);
36999 assert_eq!(b.dropped(), 1);
37000 assert_eq!(c.dropped(), 1);
37004 assert_eq!(a.dropped(), 1);
37005 assert_eq!(b.dropped(), 1);
37006 assert_eq!(c.dropped(), 1);
37069 assert_eq!(a.dropped(), 1);
37070 assert_eq!(b.dropped(), 0);
37071 assert_eq!(c.dropped(), 0);
37078 assert_eq!(a.dropped(), 2);
37079 assert_eq!(b.dropped(), 1);
37080 assert_eq!(c.dropped(), 1);
37506 left.insert(b.spawn(Panic::InDrop), ()); // first duplicate key, dropped during append
37512 assert_eq!(a.dropped(), 1);
37513 assert_eq!(b.dropped(), 1); // should be 2 were it not for Rust issue #47949
37514 assert_eq!(c.dropped(), 2);
37655 assert_eq!(a.dropped(), 1);
37656 assert_eq!(b.dropped(), 1);
37657 assert_eq!(c.dropped(), 1);
37658 assert_eq!(d.dropped(), 1);
37659 assert_eq!(e.dropped(), 1);
37675 assert_eq!(dummies[i].dropped(), 2);
38371 // until the key slice reference is dropped, as we have unique access
38385 // until the value slice reference is dropped, as we have unique access
38401 // until the edge slice reference is dropped, as we have unique access
40476 /// Runs the destructor for all items in the slice when it gets dropped (normally or
41221 /// Runs the destructor for all items in the slice when it gets dropped (normally or
41239 // so no value is dropped twice if `drop_in_place` panics
41256 // Make sure the second half is dropped even when a destructor
41513 /// if the `Drain` value is not dropped, but the borrow it holds expires
46106 // now `guard` will be dropped and do the rest
47163 /// Currently, `Vec` does not guarantee the order in which elements are dropped.
47791 /// elements to be returned instead of dropped.
47833 // such that no value will be dropped twice in case `drop_in_place`
48227 // Hole: Moved or dropped element slot.
48268 // SAFETY: We never touch this element again after dropped.
48377 /* How many items have been already dropped
48379 let dropped = self.read.wrapping_sub(self.write);
48381 self.vec.set_len(len - dropped);
48513 /// When the iterator **is** dropped, all elements in the range are removed
48515 /// iterator **is not** dropped (with [`mem::forget`] for example), it is
49330 /// The input iterator `replace_with` is only consumed when the `Splice` value is dropped.
49775 /// backshifted in the `vec`, but no further items will be dropped or
50092 // i.e. the head. The source slice (the tail) is dropped by IntoIter.
51119 /// then be dropped which will properly destroy `T` and release the