Lines Matching defs:src
629 let src: Vec<_> = FromIterator::from_iter(0..src_len);
633 b.iter(|| src.as_slice().to_vec());
657 let src: Vec<_> = FromIterator::from_iter(0..src_len);
662 let dst: Vec<_> = FromIterator::from_iter(src.iter().cloned());
689 let src: Vec<_> = FromIterator::from_iter(dst_len..dst_len + src_len);
695 dst.extend(src.clone());
737 let src: Vec<_> = FromIterator::from_iter(dst_len..dst_len + src_len);
743 dst.extend_from_slice(&src);
798 let src: Vec<usize> = FromIterator::from_iter(0..src_len);
802 b.iter(|| src.clone());
827 let src: Vec<_> = FromIterator::from_iter(dst_len..dst_len + src_len);
835 dst.clone_from(&src);
968 let src: Vec<$type> = black_box(vec![$init; $count]);
969 src.into_iter()
1595 let src = slim_map(100);
1596 b.iter(|| src.clone())
1601 let src = slim_map(100);
1602 b.iter(|| src.clone().clear())
1607 let src = slim_map(100);
1608 b.iter(|| src.clone().drain_filter(|_, _| true).count())
1613 let src = slim_map(100);
1615 let mut map = src.clone();
1623 let src = slim_map(100);
1624 b.iter(|| src.clone().into_iter().count())
1629 let src = slim_map(100);
1631 let mut map = src.clone();
1639 let src = slim_map(100);
1641 let mut map = src.clone();
1652 let src = slim_map(100);
1654 let mut map = src.clone();
1666 let src = slim_map(10_000);
1667 b.iter(|| src.clone())
1672 let src = slim_map(10_000);
1673 b.iter(|| src.clone().clear())
1678 let src = slim_map(10_000);
1679 b.iter(|| src.clone().drain_filter(|_, _| true).count())
1684 let src = slim_map(10_000);
1686 let mut map = src.clone();
1694 let src = slim_map(10_000);
1695 b.iter(|| src.clone().into_iter().count())
1700 let src = slim_map(10_000);
1702 let mut map = src.clone();
1710 let src = slim_map(10_000);
1712 let mut map = src.clone();
1723 let src = slim_map(10_000);
1725 let mut map = src.clone();
1737 let src = fat_val_map(100);
1738 b.iter(|| src.clone())
1743 let src = fat_val_map(100);
1744 b.iter(|| src.clone().clear())
1749 let src = fat_val_map(100);
1750 b.iter(|| src.clone().drain_filter(|_, _| true).count())
1755 let src = fat_val_map(100);
1757 let mut map = src.clone();
1765 let src = fat_val_map(100);
1766 b.iter(|| src.clone().into_iter().count())
1771 let src = fat_val_map(100);
1773 let mut map = src.clone();
1781 let src = fat_val_map(100);
1783 let mut map = src.clone();
1794 let src = fat_val_map(100);
1796 let mut map = src.clone();
1863 let src = slim_set(100);
1864 b.iter(|| src.clone())
1869 let src = slim_set(100);
1870 b.iter(|| src.clone().clear())
1875 let src = slim_set(100);
1876 b.iter(|| src.clone().drain_filter(|_| true).count())
1881 let src = slim_set(100);
1883 let mut set = src.clone();
1891 let src = slim_set(100);
1892 b.iter(|| src.clone().into_iter().count())
1897 let src = slim_set(100);
1899 let mut set = src.clone();
1907 let src = slim_set(100);
1909 let mut set = src.clone();
1920 let src = slim_set(100);
1922 let mut set = src.clone();
1934 let src = slim_set(10_000);
1935 b.iter(|| src.clone())
1940 let src = slim_set(10_000);
1941 b.iter(|| src.clone().clear())
1946 let src = slim_set(10_000);
1947 b.iter(|| src.clone().drain_filter(|_| true).count())
1952 let src = slim_set(10_000);
1954 let mut set = src.clone();
1962 let src = slim_set(10_000);
1963 b.iter(|| src.clone().into_iter().count())
1968 let src = slim_set(10_000);
1970 let mut set = src.clone();
1978 let src = slim_set(10_000);
1980 let mut set = src.clone();
1991 let src = slim_set(10_000);
1993 let mut set = src.clone();
7503 let src: Vec<usize> = vec![0usize; 1];
7504 let srcptr = src.as_ptr();
7505 let sink = src.into_iter().collect::<Vec<_>>();
7512 let src: Vec<usize> = vec![0usize; 10];
7513 let srcptr = src.as_ptr();
7514 let mut iter = src.into_iter();
7525 let src: Vec<usize> = vec![0usize; 256];
7526 let srcptr = src.as_ptr();
7527 let iter = src
7546 let src: Vec<_> = drop_count.iter().cloned().collect();
7547 let srcptr = src.as_ptr();
7548 let iter = src.into_iter();
7561 let src: Vec<_> = drop_count.iter().cloned().collect();
7562 let iter = src.into_iter();
10711 let src: Box<[usize]> = box [1, 2, 3];
10712 let src_ptr = src.as_ptr();
10713 let sink: Box<_> = src.into_vec().into_iter().map(std::convert::identity).collect();
10774 let src = [0, 1, 2, 3, 4, 5];
10776 dst.copy_from_slice(&src);
10777 assert_eq!(src, dst)
10783 let src = [0, 1, 2, 3];
10785 dst.copy_from_slice(&src);
10791 let src = [0, 1, 2, 3];
10793 dst.copy_from_slice(&src);
12187 let src = construct_vec_deque(
12206 let mut src = src.clone();
12208 // Assert that appending `src` to `dst` gives the same order
12212 .chain(src.iter())
12215 dst.append(&mut src);
12217 assert!(src.is_empty());
13517 let src: Vec<usize> = vec![1, 2, 3];
13518 let src_ptr = src.as_ptr();
13519 let heap: BinaryHeap<_> = src.into_iter().map(std::convert::identity).collect();
14024 // the default implementations in libstd (`__rdl_alloc` etc. in `library/std/src/alloc.rs`)
22654 /// --> src/liballoc/slice.rs:608:6
22844 let mut hole = InsertionHole { src: &mut *tmp, dest: &mut v[1] };
22858 // When dropped, copies from `src` into `dest`.
22860 src: *mut T,
22867 ptr::copy_nonoverlapping(self.src, self.dest, 1);
39619 /// of uninitialized elements, leaving behind `src` as all uninitialized.
39620 /// Works like `dst.copy_from_slice(src)` but does not require `T` to be `Copy`.
39621 fn move_to_slice<T>(src: &mut [MaybeUninit<T>], dst: &mut [MaybeUninit<T>]) {
39622 assert!(src.len() == dst.len());
39624 ptr::copy_nonoverlapping(src.as_ptr(), dst.as_mut_ptr(), src.len());
40461 while let Some((dst, src)) = iter.next() {
40462 dst.clone_from_slice(&src);
40578 /// Copies a contiguous block of memory len long from src to dst
40580 unsafe fn copy(&self, dst: usize, src: usize, len: usize) {
40583 "cpy dst={} src={} len={} cap={}",
40585 src,
40590 src + len <= self.cap(),
40591 "cpy dst={} src={} len={} cap={}",
40593 src,
40598 ptr::copy(self.ptr().add(src), self.ptr().add(dst), len);
40602 /// Copies a contiguous block of memory len long from src to dst
40604 unsafe fn copy_nonoverlapping(&self, dst: usize, src: usize, len: usize) {
40607 "cno dst={} src={} len={} cap={}",
40609 src,
40614 src + len <= self.cap(),
40615 "cno dst={} src={} len={} cap={}",
40617 src,
40622 ptr::copy_nonoverlapping(self.ptr().add(src), self.ptr().add(dst), len);
40626 /// Copies a potentially wrapping block of memory len long from src to dest.
40627 /// (abs(dst - src) + len) must be no larger than cap() (There must be at
40628 /// most one continuous overlapping region between src and dest).
40629 unsafe fn wrap_copy(&self, dst: usize, src: usize, len: usize) {
40635 cmp::min(diff(dst, src), self.cap() - diff(dst, src)) + len <= self.cap(),
40636 "wrc dst={} src={} len={} cap={}",
40638 src,
40643 if src == dst || len == 0 {
40647 let dst_after_src = self.wrap_sub(dst, src) < len;
40649 let src_pre_wrap_len = self.cap() - src;
40656 // src doesn't wrap, dst doesn't wrap
40664 self.copy(dst, src, len);
40668 // dst before src, src doesn't wrap, dst wraps
40677 self.copy(dst, src, dst_pre_wrap_len);
40678 self.copy(0, src + dst_pre_wrap_len, len - dst_pre_wrap_len);
40682 // src before dst, src doesn't wrap, dst wraps
40691 self.copy(0, src + dst_pre_wrap_len, len - dst_pre_wrap_len);
40692 self.copy(dst, src, dst_pre_wrap_len);
40696 // dst before src, src wraps, dst doesn't wrap
40705 self.copy(dst, src, src_pre_wrap_len);
40710 // src before dst, src wraps, dst doesn't wrap
40720 self.copy(dst, src, src_pre_wrap_len);
40724 // dst before src, src wraps, dst wraps
40736 self.copy(dst, src, src_pre_wrap_len);
40742 // src before dst, src wraps, dst wraps
40756 self.copy(dst, src, dst_pre_wrap_len);
42625 let src: isize = (right_edge + right_offset) as isize;
42626 ptr::swap(buf.add(i), buf.offset(src));
44071 let mut src = VecDeque::new();
44072 src.push_front(Box::new(2));
44073 dst.append(&mut src);
46403 let src = source_vec.as_ptr().add(tail);
46405 ptr::copy(src, dst, self.0.tail_len);
46720 let src = unsafe { iterator.as_inner().as_into_iter() };
46723 debug_assert_eq!(src_buf, src.buf.as_ptr());
46727 if src.ptr != src_ptr {
46729 unsafe { dst_buf.add(len) as *const _ } <= src.ptr,
46737 src.forget_allocation_drop_remaining();
48930 /// Copies elements from `src` range to the end of the vector.
48947 pub fn extend_from_within<R>(&mut self, src: R)
48951 let range = slice::range(src, ..self.len());
49070 /// - `src` needs to be valid index
49071 /// - `self.capacity() - self.len()` must be `>= src.len()`
49072 unsafe fn spec_extend_from_within(&mut self, src: Range<usize>);
49076 default unsafe fn spec_extend_from_within(&mut self, src: Range<usize>) {
49082 // - caller guaratees that src is a valid index
49083 let to_clone = unsafe { this.get_unchecked(src) };
49086 .map(|(src, dst)| dst.write(src.clone()))
49095 unsafe fn spec_extend_from_within(&mut self, src: Range<usize>) {
49096 let count = src.len();
49101 // - caller guaratees that `src` is a valid index
49102 let source = unsafe { init.get_unchecked(src) };
49816 let src: *const T = &v[i];
49818 ptr::copy_nonoverlapping(src, dst, 1);
49857 let src = ptr.add(self.drain.idx);
49858 let dst = src.sub(self.drain.del);
49860 src.copy_to(dst, tail_len);
50081 let src = vec.as_ptr().add(self.tail_start);
50083 ptr::copy(src, dst, self.tail_len);