Lines Matching refs:item
1197 for item in buf.iter_mut() {
1202 *item = seed & mask;
3185 drop(q.drain_filter(|item| if item.0 >= 2 { panic!() } else { true }))
8840 // Previously just appended item was leaked, making drop_count = 3, instead of 4.
9722 // where the first item of each tuple is random, but
9723 // the second item represents which occurrence of that
9739 // This comparison includes the count (the second item
13748 // push the panicking item to the heap and catch the panic
17993 // one allocation by getting the first item and appending to it all the
20836 for (i, item) in iter.enumerate() {
20837 ptr::write(elems.add(i), item);
24488 for (i, item) in iter.enumerate() {
24489 ptr::write(elems.add(i), item);
28315 pub fn insert_after(&mut self, item: T) {
28317 let spliced_node = Box::leak(Box::new(Node::new(item))).into();
28335 pub fn insert_before(&mut self, item: T) {
28337 let spliced_node = Box::leak(Box::new(Node::new(item))).into();
28524 while let Some(item) = self.next() {
28526 drop(item);
32188 /// It is a logic error for an item to be modified in such a way that the item's ordering relative
32189 /// to any other item, as determined by the [`Ord`] trait, changes while it is in the set. This is
38435 /// Every item returned by `range` is a valid edge index for the node.
40198 while let Some(item) = self.next() {
40200 drop(item);
42646 /// - Rotates item `mid` into the first position.
42689 /// - Rotates the first item into position `k`.
42788 /// If you want to insert an item to a sorted `VecDeque`, while maintaining
43146 // for item in iter.into_iter() {
43147 // self.push_back(item);
44428 /// It is a logic error for an item to be modified in such a way that the
44429 /// item's ordering relative to any other item, as determined by the `Ord`
44445 /// // We can use peek to look at the next item in the heap. In this case,
44454 /// // Now peek shows the most important item in the heap.
44522 /// Structure wrapping a mutable reference to the greatest item on a
44645 /// Returns a mutable reference to the greatest item in the binary heap, or
44672 /// If the item is modified then the worst case time complexity is *O*(log(*n*)),
44679 /// Removes the greatest item from the binary heap and returns it, or `None` if it
44700 self.data.pop().map(|mut item| {
44702 swap(&mut item, &mut self.data[0]);
44706 item
44710 /// Pushes an item onto the binary heap.
44743 pub fn push(&mut self, item: T) {
44745 self.data.push(item);
44746 // SAFETY: Since we pushed a new item it means that
45111 /// Returns the greatest item in the binary heap, or `None` if it is empty.
45689 while let Some(item) = self.inner.pop() {
45691 drop(item);
45798 fn extend_one(&mut self, item: T) {
45799 self.push(item);
45838 fn extend_one(&mut self, &item: &'a T) {
45839 self.push(item);
46414 while let Some(item) = self.next() {
46416 drop(item);
46748 move |mut sink, item| {
46754 ptr::write(sink.dst, item);
48284 // All item are processed. This can be optimized to `set_len` by LLVM.
48368 /* Pointer to first item in vec[write..write+items_left] slice */
48370 /* Pointer to first item in vec[read..] slice */
49286 fn extend_one(&mut self, item: T) {
49287 self.push(item);
49304 // for item in iterator {
49305 // self.push(item);
49437 fn extend_one(&mut self, &item: &'a T) {
49438 self.push(item);
49764 /// The index of the item that will be inspected by the next call to `next`.
49855 // drained item prior to a panic in the predicate.