Lines Matching defs:end
4104 message: "begin <= end (4 <= 3)";
4111 message: "begin <= end (4 <= 3)";
8836 // This should clone&append one Panic{..} at the end, and then panic while
12932 // we end up with a deque of the correct size
15317 /// // but at the end of a word, it's ς, not σ:
15335 // Σ maps to σ, except at the end of a word where it maps to ς.
16430 /// We end up with a different output:
16979 /// Appends a given string slice onto the end of this `String`.
17233 /// Appends the given [`char`] to the end of this `String`.
17364 None => panic!("cannot remove a char from the end of a string"),
17417 // SAFETY: start and end will be on utf8 byte boundaries per
17420 for (start, end) in matches {
17422 self.vec.as_mut_ptr().add(end - shrunk_by),
17424 len - end,
17426 shrunk_by += end - start;
17713 /// consumed until the end.
17717 /// Panics if the starting point or end point do not lie on a [`char`]
17748 let Range { start, end } = slice::range(range, ..self.len());
17750 assert!(self.is_char_boundary(end));
17756 let chars_iter = unsafe { self.get_unchecked(start..end) }.chars();
17758 Drain { start, end, iter: chars_iter, string: self_ptr }
17767 /// Panics if the starting point or end point do not lie on a [`char`]
17800 let end = range.end_bound();
17801 match end {
17810 unsafe { self.as_mut_vec() }.splice((start, end), replace_with.bytes());
18714 end: usize,
18738 if self.start <= self.end && self.end <= self_vec.len() {
18739 self_vec.drain(self.start..self.end);
19632 //! // At the end of the function, `gadget1` and `gadget2` are destroyed, and
19646 //! place. In order to end up with two values that point at each other, one of
19720 //! // At the end of the function, `gadget_owner`, `gadget1`, and `gadget2`
21958 // Align the unsized value to the end of the RcBox.
22837 // 2. Fills the remaining hole in `v` in the end.
22911 hole = MergeHole { start: buf, end: buf.add(mid), dest: v };
22919 while *left < hole.end && right < v_end {
22935 hole = MergeHole { start: buf, end: buf.add(len - mid), dest: v_mid };
22940 let right = &mut hole.end;
22970 // When dropped, copies the range `start..end` into `dest..`.
22973 end: *mut T,
22980 let len = (self.end as usize - self.start as usize) / mem::size_of::<T>();
23037 let mut end = len;
23038 while end > 0 {
23040 let mut start = end - 1;
23048 v[start..end].reverse();
23060 while start > 0 && end - start < MIN_RUN {
23062 insert_head(&mut v[start..end], &mut is_less);
23066 runs.push(Run { start, len: end - start });
23067 end = start;
23368 /// In the end, this means that you may need to pair `Arc<T>` with some sort of
24637 // dropped. Worst case, we end up allocated a new Arc unnecessarily.
25787 // Align the unsized value to the end of the ArcInner.
25868 //! leverage named parameters. Named parameters are listed at the end of the
26267 //! println!("I have a newline {}", "character at the end");
26947 //! The `LinkedList` allows pushing and popping elements at either end
26975 /// The `LinkedList` allows pushing and popping elements at either end
27340 /// Moves all elements from `other` to the end of the list.
27812 // Below, we iterate towards the `i-1`th node, either from the start or the end,
27824 // better off starting from the end
27863 // the start or the end, depending on which would be faster.
28144 // No current. We're at the start of the list. Yield None and jump to the end.
28241 // No current. We're at the start of the list. Yield None and jump to the end.
28333 /// inserted at the end of the `LinkedList`.
28416 /// inserted at the end of the `LinkedList`.
29199 /// If you want the tree to end up in a strictly ascending order, like for
29215 /// Pushes all key-value pairs to the end of the tree, incrementing a
29620 let (start, end) = (range.start_bound(), range.end_bound());
29621 match (start, end) {
29623 panic!("range start and end are equal and excluded in BTreeMap")
29628 panic!("range start is greater than range end in BTreeMap")
29633 let mut upper_bound = SearchBound::from_range(end);
30811 /// Panics if range `start > end`.
30812 /// Panics if range `start == end` and both bounds are `Excluded`.
30854 /// Panics if range `start > end`.
30855 /// Panics if range `start == end` and both bounds are `Excluded`.
33897 // twice, and never end up with overlapping value references.
33991 /// This method also deallocates any node(s) it reaches the end of. This
34019 /// This method also deallocates any node(s) it reaches the end of. This
37482 // Two leafs where the second one ends up underfull and needs stealing at the end.
38022 /// initialized and valid, except that near the end, while the tree is held
38534 /// Adds a key-value pair to the end of the node.
38549 /// to the end of the node.
38737 /// The goal of the split point is for its key and value to end up in a parent node;
41423 let Range { start, end } = slice::range(range, ..self.len());
41425 let head = self.wrap_add(self.tail, end);
41433 /// Panics if the starting point is greater than the end point or if
41434 /// the end point is greater than the length of the vector.
41468 /// Panics if the starting point is greater than the end point or if
41469 /// the end point is greater than the length of the vector.
41510 /// consumed until the end.
41518 /// Panics if the starting point is greater than the end point or if
41519 /// the end point is greater than the length of the vector.
42048 // move elements from idx to end forward not including ^ element
42092 // move elements from idx-1 to end forward not including ^ element
42123 /// Whichever end is closer to the removal point will be moved to make
42289 // move elements from tail to end forward, excluding the last one
42616 // Sometimes the temp store is reached when the right edge is at the end
42647 /// - Pops the first `mid` items and pushes them to the end.
42918 /// and all elements for which the predicate returns false are at the end.
42920 /// (all odd numbers are at the start, all even at the end).
43750 for end in start..=len {
43758 let range: VecDeque<_> = tester.range(start..end).copied().collect();
43759 let expected: VecDeque<_> = (start..end).collect();
43775 for end in start..=len {
43786 let range: VecDeque<_> = tester.range_mut(start..end).map(|v| *v).collect();
43787 let expected: VecDeque<_> = (start..end).collect();
43969 // Test cases where block at end of buffer is bigger than block at start
43974 // Test cases where block at start of buffer is bigger than block at end
43990 // Test cases where block at end of buffer is bigger than block at start
43995 // Test cases where block at start of buffer is bigger than block at end
44770 let mut end = self.len();
44771 while end > 1 {
44772 end -= 1;
44773 // SAFETY: `end` goes from `self.len() - 1` to 1 (both included),
44776 // 1 <= end < self.len(), which means self.len() >= 2.
44779 ptr::swap(ptr, ptr.add(end));
44781 // SAFETY: `end` goes from `self.len() - 1` to 1 (both included) so:
44782 // 0 < 1 <= end <= self.len() - 1 < self.len()
44783 // Which means 0 < end and end < self.len().
44784 unsafe { self.sift_down_range(0, end) };
44794 // the hole is filled back at the end of its scope, even on panic.
44829 /// The caller must guarantee that `pos < end <= self.len()`.
44830 unsafe fn sift_down_range(&mut self, pos: usize, end: usize) {
44831 // SAFETY: The caller guarantees that pos < end <= self.len().
44836 while child <= end.saturating_sub(2) {
44838 // SAFETY: child < end - 1 < self.len() and
44839 // child + 1 < end <= self.len(), so they're valid indexes.
44859 // second condition it's already true that child == end - 1 < self.len().
44860 if child == end - 1 && hole.element() < unsafe { hole.get(child) } {
44887 let end = self.len();
44895 while child <= end.saturating_sub(2) {
44896 // SAFETY: child < end - 1 < self.len() and
44897 // child + 1 < end <= self.len(), so they're valid indexes.
44909 if child == end - 1 {
44910 // SAFETY: child == end - 1 < self.len(), so it's a valid index
45878 pub(super) end: *const T,
45952 self.end = self.buf.as_ptr();
45978 if self.ptr as *const _ == self.end {
45999 (self.end as usize).wrapping_sub(self.ptr as usize)
46001 unsafe { self.end.offset_from(self.ptr) as usize }
46033 if self.end == self.ptr {
46037 self.end = unsafe { arith_offset(self.end as *const i8, -1) as *mut T };
46042 self.end = unsafe { self.end.offset(-1) };
46044 Some(unsafe { ptr::read(self.end) })
46052 self.ptr == self.end
46199 iterator.ptr = iterator.end;
46713 inner.end as *const T,
46764 /// collected. `end` is the last writable element of the allocation and used for bounds checks.
46765 fn collect_in_place(&mut self, dst: *mut T, end: *const T) -> usize;
46773 default fn collect_in_place(&mut self, dst_buf: *mut T, end: *const T) -> usize {
46777 // - it lets us thread the write pointer through its innards and get it back in the end
46780 self.try_fold::<_, _, Result<_, !>>(sink, write_in_place_with_drop(end)).unwrap();
46791 fn collect_in_place(&mut self, dst_buf: *mut T, end: *const T) -> usize {
46800 debug_assert!(dst as *const _ <= end, "InPlaceIterable contract violation");
46812 //! Vectors have `O(1)` indexing, amortized `O(1)` push (to the end) and
46813 //! `O(1)` pop (from the end).
46835 //! You can [`push`] values onto the end of a vector (which will grow the vector
47886 /// function returns, or else it will end up pointing to garbage.
47923 /// function returns, or else it will end up pointing to garbage.
48447 let end = self.as_mut_ptr().add(self.len);
48448 ptr::write(end, value);
48520 /// Panics if the starting point is greater than the end point or if
48521 /// the end point is greater than the length of the vector.
48551 let Range { start, end } = slice::range(range, ..len);
48558 let range_slice = slice::from_raw_parts_mut(self.as_mut_ptr().add(start), end - start);
48560 tail_start: end,
48561 tail_len: len - end,
48680 /// calling the closure `f`. The return values from `f` will end up
48856 let Range { start: ptr, end: spare_ptr } = self.as_mut_ptr_range();
48930 /// Copies elements from `src` range to the end of the vector.
49222 /// the vector (from start to end). The vector cannot be used after calling
49240 let end = if mem::size_of::<T>() == 0 {
49252 end,
49325 /// `range` is removed even if the iterator is not consumed until the end.
49342 /// Panics if the starting point is greater than the end point or if
49343 /// the end point is greater than the length of the vector.
50155 let end = i.add(layout.size());
50156 while i < end {