Lines Matching defs:copy
8616 panic!("extend_from_within must use specialization on copy");
9774 // small rotations in large slice, uses ptr::copy
9809 // small rotations in large slice, uses ptr::copy
13802 let mut copy = vec![Dummy { _data: 84 }; size].into_boxed_slice();
13803 copy.clone_from(&control);
13805 assert_eq!(control, copy);
13818 let mut copy = vec![Dummy { _data: 84 }; size].into_boxed_slice();
13819 let copy_raw = copy.as_ptr() as usize;
13820 copy.clone_from(&control);
13821 assert_eq!(copy.as_ptr() as usize, copy_raw);
14419 // We can always copy in-place, without ever involving a local value.
15147 // copy separator and slices over without bounds checks
15153 // slices for the length calculation and the actual copy.
15473 /// Returns a copy of this string where each character is mapped to its
15503 /// Returns a copy of this string where each character is mapped to its
16608 /// This method will take care to not copy the vector, for efficiency's
16924 /// This consumes the `String`, so we do not need to copy its contents.
17370 ptr::copy(self.vec.as_ptr().add(next), self.vec.as_mut_ptr().add(idx), len - next);
17421 ptr::copy(
17488 ptr::copy(
17544 ptr::copy(self.vec.as_ptr().add(idx), self.vec.as_mut_ptr().add(idx + amt), len - idx);
17545 ptr::copy(bytes.as_ptr(), self.vec.as_mut_ptr().add(idx), amt);
17859 /// consume the error, moving out the bytes, so that a copy of the bytes
20094 let val = ptr::read(&*this); // copy the contained object
21235 /// Allocate a reference-counted string slice and copy `v` into it.
21253 /// Allocate a reference-counted string slice and copy `v` into it.
22607 /// Returns a vector containing a copy of this slice where each byte
22624 /// Returns a vector containing a copy of this slice where each byte
22818 // However, this way we copy data around more than is necessary. If elements are big
22819 // structures (costly to copy), this method will be slow.
22826 // for it is found. As we go along, copy every traversed element into the slot
22827 // preceding it. Finally, copy data from the temporary variable into the remaining
22879 /// to hold a copy of the shorter slice. Also, `T` must not be a zero-sized type.
22893 // consumed first, then we must copy whatever is left of the shorter run into the remaining
23028 // `is_less` panics. When merging two sorted runs, this buffer holds a copy of the shorter run,
25576 /// Allocate a reference-counted `str` and copy `v` into it.
25594 /// Allocate a reference-counted `str` and copy `v` into it.
30578 // See `get` for implementation notes, this is basically a copy-paste with mut's added
34125 /// on any copy of the handles being used to traverse the tree.
34143 /// on any copy of the handles being used to traverse the tree.
39574 ptr::copy(slice_ptr.add(idx), slice_ptr.add(idx + 1), len - idx - 1);
39591 ptr::copy(slice_ptr.add(idx + 1), slice_ptr.add(idx), len - idx - 1);
39603 ptr::copy(slice_ptr.add(distance), slice_ptr, slice.len() - distance);
39614 ptr::copy(slice_ptr, slice_ptr.add(distance), slice.len() - distance);
40580 unsafe fn copy(&self, dst: usize, src: usize, len: usize) {
40598 ptr::copy(self.ptr().add(src), self.ptr().add(dst), len);
40664 self.copy(dst, src, len);
40677 self.copy(dst, src, dst_pre_wrap_len);
40678 self.copy(0, src + dst_pre_wrap_len, len - dst_pre_wrap_len);
40691 self.copy(0, src + dst_pre_wrap_len, len - dst_pre_wrap_len);
40692 self.copy(dst, src, dst_pre_wrap_len);
40705 self.copy(dst, src, src_pre_wrap_len);
40706 self.copy(dst + src_pre_wrap_len, 0, len - src_pre_wrap_len);
40719 self.copy(dst + src_pre_wrap_len, 0, len - src_pre_wrap_len);
40720 self.copy(dst, src, src_pre_wrap_len);
40736 self.copy(dst, src, src_pre_wrap_len);
40737 self.copy(dst + src_pre_wrap_len, 0, delta);
40738 self.copy(0, delta, len - dst_pre_wrap_len);
40754 self.copy(delta, 0, len - src_pre_wrap_len);
40755 self.copy(0, self.cap() - delta, delta);
40756 self.copy(dst, src, dst_pre_wrap_len);
41994 self.copy(new_tail, self.tail, 1);
41995 // Already moved the tail, so we only copy `index - 1` elements.
41996 self.copy(self.tail, self.tail + 1, index - 1);
42012 self.copy(idx + 1, idx, self.head - idx);
42027 self.copy(self.tail - 1, self.tail, index);
42042 // copy elements up to new head
42043 self.copy(1, 0, self.head);
42045 // copy last element into empty spot at bottom of buffer
42046 self.copy(0, self.cap() - 1, 1);
42049 self.copy(idx + 1, idx, self.cap() - 1 - idx);
42066 // copy elements up to new tail
42067 self.copy(self.tail - 1, self.tail, self.cap() - self.tail);
42069 // copy last element into empty spot at bottom of buffer
42070 self.copy(self.cap() - 1, 0, 1);
42086 // copy elements up to new tail
42087 self.copy(self.tail - 1, self.tail, self.cap() - self.tail);
42089 // copy last element into empty spot at bottom of buffer
42090 self.copy(self.cap() - 1, 0, 1);
42093 self.copy(0, 1, idx - 1);
42109 self.copy(idx + 1, idx, self.head - idx);
42188 self.copy(self.tail + 1, self.tail, index);
42203 self.copy(idx, idx + 1, self.head - idx - 1);
42218 self.copy(self.tail + 1, self.tail, index);
42233 self.copy(idx, idx + 1, self.head - idx - 1);
42258 self.copy(idx, idx + 1, self.cap() - idx - 1);
42262 // copy first element into empty spot
42263 self.copy(self.cap() - 1, 0, 1);
42266 self.copy(0, 1, self.head - 1);
42284 self.copy(1, 0, idx);
42286 // copy last element into empty spot
42287 self.copy(0, self.cap() - 1, 1);
42290 self.copy(self.tail + 1, self.tail, self.cap() - self.tail - 1);
42565 // there is enough free space to copy the tail in one go,
42567 // copy the tail to the correct position.
42572 ptr::copy(buf, buf.add(tail_len), self.head);
42587 // there is enough free space to copy the head in one go,
42589 // copy the head to the correct position.
42594 ptr::copy(buf.add(self.tail), buf.add(self.head), tail_len);
43275 ptr::copy(buf.add(other.tail), buf, len);
46405 ptr::copy(src, dst, self.0.tail_len);
46621 ptr::copy(it.ptr, it.buf.as_ptr(), it.len());
48135 ptr::copy(p, p.offset(1), len - index);
48136 // Write it in, overwriting the first copy of the `index`th
48176 // copy it out, unsafely having a copy of the value on
48181 ptr::copy(ptr.offset(1), ptr, len - index - 1);
48245 ptr::copy(
48275 // We use copy for move, and never touch this element again.
48358 * and `len - read` never overflow and that the copy is always
48375 ptr::copy(valid_ptr, dropped_ptr, items_left);
48406 * have to use `copy` or conditional `copy_nonoverlapping`.
48408 ptr::copy(read_ptr, write_ptr, 1);
48656 // the new vector can take over the original buffer and avoid the copy
48666 // Unsafely `set_len` and copy items to `other`.
49107 // - Elements are :Copy so it's OK to to copy them, without doing
50083 ptr::copy(src, dst, self.tail_len);
51252 // this makes a copy of the data
51392 /// and performs a copy of `slice`.
51428 /// and performs a copy of `s`.