Lines Matching defs:write
13193 // Basic test to make sure that we can invoke the `write!` macro with an
13198 let _ = write!(&mut buf, "{}", 3);
13201 let _ = write!(w, "{foo}", foo = 4);
13202 let _ = write!(w, "{}", "hello");
13230 let _ = write!(w, "{}", format_args!("{}", 1));
13231 let _ = write!(w, "{}", format_args!("test"));
13232 let _ = write!(w, "{}", format_args!("{test}", test = 3));
13957 /// The same convention is used with [`print!`] and [`write!`] macros,
13965 /// [`write!`]: core::write
14412 unsafe { target.write(self.clone()) };
14692 /// code *you* write that relies on the behavior of this function may break.
14723 /// ptr::write(self.buf.ptr().add(self.len), x.clone());
14771 /// *you* write that relies on the behavior of this function may break.
18910 /// A clone-on-write smart pointer.
18912 /// The type `Cow` is a smart pointer providing clone-on-write functionality: it
18924 /// [`Arc::make_mut`][crate::sync::Arc::make_mut] can provide clone-on-write
19896 ptr::write(ptr::addr_of_mut!((*inner).value), data);
19925 /// Rc::get_mut_unchecked(&mut five).as_mut_ptr().write(5);
20011 /// Rc::get_mut_unchecked(&mut five).as_mut_ptr().write(5);
20126 /// Rc::get_mut_unchecked(&mut values)[0].as_mut_ptr().write(1);
20127 /// Rc::get_mut_unchecked(&mut values)[1].as_mut_ptr().write(2);
20128 /// Rc::get_mut_unchecked(&mut values)[2].as_mut_ptr().write(3);
20200 /// Rc::get_mut_unchecked(&mut five).as_mut_ptr().write(5);
20239 /// Rc::get_mut_unchecked(&mut values)[0].as_mut_ptr().write(1);
20240 /// Rc::get_mut_unchecked(&mut values)[1].as_mut_ptr().write(2);
20241 /// Rc::get_mut_unchecked(&mut values)[2].as_mut_ptr().write(3);
20301 // write through the pointer after the Rc is recovered through `from_raw`.
20576 /// referred to as clone-on-write.
20643 ptr::write(this, rc.assume_init());
20735 ptr::write(&mut (*inner).strong, Cell::new(1));
20736 ptr::write(&mut (*inner).weak, Cell::new(1));
20837 ptr::write(elems.add(i), item);
21822 write!(f, "(Weak)")
22167 slots[i].write(b.clone());
23565 write!(f, "(Weak)")
23657 ptr::write(ptr::addr_of_mut!((*inner).data), data);
23659 // The above write to the data field must be visible to any threads which
23697 /// Arc::get_mut_unchecked(&mut five).as_mut_ptr().write(5);
23792 /// Arc::get_mut_unchecked(&mut five).as_mut_ptr().write(5);
23899 /// Arc::get_mut_unchecked(&mut values)[0].as_mut_ptr().write(1);
23900 /// Arc::get_mut_unchecked(&mut values)[1].as_mut_ptr().write(2);
23901 /// Arc::get_mut_unchecked(&mut values)[2].as_mut_ptr().write(3);
23973 /// Arc::get_mut_unchecked(&mut five).as_mut_ptr().write(5);
24012 /// Arc::get_mut_unchecked(&mut values)[0].as_mut_ptr().write(1);
24013 /// Arc::get_mut_unchecked(&mut values)[1].as_mut_ptr().write(2);
24014 /// Arc::get_mut_unchecked(&mut values)[2].as_mut_ptr().write(3);
24072 // write through the pointer after the Rc is recovered through `from_raw`.
24155 // synchronize with the write coming from `is_unique`, so that the
24156 // events prior to that write happen before this read.
24385 ptr::write(&mut (*inner).strong, atomic::AtomicUsize::new(1));
24386 ptr::write(&mut (*inner).weak, atomic::AtomicUsize::new(1));
24489 ptr::write(elems.add(i), item);
24586 /// to ensure unique ownership. This is also referred to as clone-on-write.
24656 ptr::write(this, arc.assume_init());
24763 // The release write here synchronizes with a read in `downgrade`,
24765 // after the write.
25078 // Relaxed load because any write of 0 that we can observe
26139 //! # write!(f, "testing, testing")
26153 //! calling [`write!`]). However, they should never return errors spuriously. That
26176 //! // write! macro is expecting. Note that this formatting ignores the
26178 //! write!(f, "({}, {})", self.x, self.y)
26235 //! write! // first argument is a &mut io::Write, the destination
26236 //! writeln! // same as write but appends a newline
26244 //! ### `write!`
26248 //! format strings and instead directly write the output. Under the hood, this
26256 //! write!(&mut w, "Hello {}!", "world");
26261 //! This and [`println!`] emit their output to stdout. Similarly to the [`write!`]
26290 //! write!(&mut some_writer, "{}", format_args!("print with a {}", "macro"));
26293 //! write!(&mut io::stdout(), "{}", args);
26299 //! This structure can then be passed to the [`write`] and [`format`] functions
26311 //! [`write!`]: core::write
26312 //! [`write`]: core::write
26335 pub use core::fmt::{write, ArgumentV1, Arguments};
32090 ptr::write(v, new_value);
35144 write!(
37996 ptr::addr_of_mut!((*this).parent).write(None);
37997 ptr::addr_of_mut!((*this).len).write(0);
38149 new_node.edges[0].write(child.node);
38455 unsafe { (*leaf).parent_idx.write(parent_idx as u16) };
38541 self.key_area_mut(idx).write(key);
38542 self.val_area_mut(idx).write(val);
38558 self.key_area_mut(idx).write(key);
38559 self.val_area_mut(idx).write(val);
38560 self.edge_area_mut(idx + 1).write(edge.node);
39164 left_node.key_area_mut(old_left_len).write(parent_key);
39171 left_node.val_area_mut(old_left_len).write(parent_val);
39304 right_node.key_area_mut(count - 1).write(k);
39305 right_node.val_area_mut(count - 1).write(v);
39353 left_node.key_area_mut(old_left_len).write(k);
39354 left_node.val_area_mut(old_left_len).write(v);
39576 (*slice_ptr.add(idx)).write(val);
40547 ptr::write(self.ptr().add(off), value);
41583 // it. We do not write to `self` nor reborrow to a mutable reference.
44092 fn write(&mut self, bytes: &[u8]) {
45263 /// io::sink().write(heap.as_slice()).unwrap();
45941 /// unsafe { core::ptr::write(&mut into_iter, Vec::new().into_iter()); }
46177 ptr::write(ptr, element);
46465 ptr::write(vector.as_mut_ptr(), element);
46730 "InPlaceIterable contract violation, write pointer advanced beyond read pointer"
46754 ptr::write(sink.dst, item);
46777 // - it lets us thread the write pointer through its innards and get it back in the end
46797 // write back the result.
46801 ptr::write(dst, self.__iterator_get_unchecked(i));
47160 /// not break, however: using `unsafe` code to write to the excess capacity,
47307 /// ptr::write(p.offset(i), 4 + i);
47453 /// ptr::write(p.offset(i), 4 + i);
47858 /// io::sink().write(buffer.as_slice()).unwrap();
48138 ptr::write(p, element);
48340 /* INVARIANT: vec.len() > read >= write > write-1 >= 0 */
48347 write: usize,
48357 /* SAFETY: invariant guarantees that `read - write`
48368 /* Pointer to first item in vec[write..write+items_left] slice */
48369 let dropped_ptr = ptr.add(self.write);
48373 /* Copy `vec[read..]` to `vec[write..write+items_left]`.
48378 * Basically vec[read..write].len() */
48379 let dropped = self.read.wrapping_sub(self.write);
48386 let mut gap = FillGapOnDrop { read: 1, write: 1, vec: self };
48397 let prev_ptr = ptr.add(gap.write.wrapping_sub(1));
48403 let write_ptr = ptr.add(gap.write);
48411 gap.write += 1;
48420 gap.vec.set_len(gap.write);
48448 ptr::write(end, value);
48765 /// uninit[0].write(0);
48766 /// uninit[1].write(1);
48767 /// uninit[2].write(2);
48828 /// uninit[0].write(sum);
48829 /// uninit[1].write(sum * 2);
48830 /// uninit[2].write(sum * 3);
48831 /// uninit[3].write(sum * 4);
49012 ptr::write(ptr, value.next());
49019 // We can write the last element directly without cloning needlessly
49020 ptr::write(ptr, value.last());
49086 .map(|(src, dst)| dst.write(src.clone()))
49088 // - Element was just initialized with `MaybeUninit::write`, so it's ok to increase len
49314 ptr::write(self.as_mut_ptr().add(len), element);
49586 /// Convert a clone-on-write slice into a vector.
50064 unsafe { ptr::write(place, new_item) };
50369 /// five.as_mut_ptr().write(5);
50446 /// five.as_mut_ptr().write(5);
50507 boxed.as_mut_ptr().write(x);
50532 boxed.as_mut_ptr().write(x);
50550 /// five.as_mut_ptr().write(5);
50583 /// five.as_mut_ptr().write(5);
50711 /// values[0].as_mut_ptr().write(1);
50712 /// values[1].as_mut_ptr().write(2);
50713 /// values[2].as_mut_ptr().write(3);
50763 /// values[0].as_mut_ptr().write(1);
50764 /// values[1].as_mut_ptr().write(2);
50765 /// values[2].as_mut_ptr().write(3);
50827 /// five.as_mut_ptr().write(5);
50864 /// values[0].as_mut_ptr().write(1);
50865 /// values[1].as_mut_ptr().write(2);
50866 /// values[2].as_mut_ptr().write(3);
50913 /// // In general .write is required to avoid attempting to destruct
50916 /// ptr.write(5);
50967 /// // In general .write is required to avoid attempting to destruct
50970 /// ptr.write(5);
51314 fn write(&mut self, bytes: &[u8]) {
51315 (**self).write(bytes)