Lines Matching defs:idx
971 .map(|(idx, e)| idx as $type ^ e)
1009 .map(|(idx, e)| idx.wrapping_add(e))
17345 /// Panics if `idx` is larger than or equal to the `String`'s length,
17361 pub fn remove(&mut self, idx: usize) -> char {
17362 let ch = match self[idx..].chars().next() {
17367 let next = idx + ch.len_utf8();
17370 ptr::copy(self.vec.as_ptr().add(next), self.vec.as_mut_ptr().add(idx), len - next);
17371 self.vec.set_len(len - (next - idx));
17465 idx: usize,
17471 let new_len = self.idx - self.del_bytes;
17478 let mut guard = SetLenOnDrop { s: self, idx: 0, del_bytes: 0 };
17480 while guard.idx < len {
17481 let ch = unsafe { guard.s.get_unchecked(guard.idx..len).chars().next().unwrap() };
17489 guard.s.vec.as_ptr().add(guard.idx),
17490 guard.s.vec.as_mut_ptr().add(guard.idx - guard.del_bytes),
17496 // Point idx to the next char
17497 guard.idx += ch_len;
17510 /// Panics if `idx` is larger than the `String`'s length, or if it does not
17528 pub fn insert(&mut self, idx: usize, ch: char) {
17529 assert!(self.is_char_boundary(idx));
17534 self.insert_bytes(idx, bits);
17538 unsafe fn insert_bytes(&mut self, idx: usize, bytes: &[u8]) {
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);
17557 /// Panics if `idx` is larger than the `String`'s length, or if it does not
17573 pub fn insert_str(&mut self, idx: usize, string: &str) {
17574 assert!(self.is_char_boundary(idx));
17577 self.insert_bytes(idx, string.as_bytes());
27915 DrainFilter { list: self, it, pred: filter, idx: 0, old_len }
28472 idx: usize,
28487 self.idx += 1;
28501 (0, Some(self.old_len - self.idx))
29707 IndexResult::KV(idx) => Found(unsafe { Handle::new_kv(self, idx) }),
29708 IndexResult::Edge(idx) => GoDown(unsafe { Handle::new_edge(self, idx) }),
29753 IndexResult::KV(idx) => (idx, AllExcluded),
29754 IndexResult::Edge(idx) => (idx, bound),
29757 IndexResult::KV(idx) => (idx + 1, AllIncluded),
29758 IndexResult::Edge(idx) => (idx, bound),
29781 IndexResult::KV(idx) => (idx + 1, AllExcluded),
29782 IndexResult::Edge(idx) => (idx, bound),
29785 IndexResult::KV(idx) => (idx, AllIncluded),
29786 IndexResult::Edge(idx) => (idx, bound),
35688 for idx in 0..=node.len() {
35689 let edge = unsafe { Handle::new_edge(node, idx) };
37760 let idx = pos.idx();
37767 left_parent_kv.merge_tracking_child_edge(Right(idx))
37770 left_parent_kv.steal_left(idx)
37776 right_parent_kv.merge_tracking_child_edge(Left(idx))
37779 right_parent_kv.steal_right(idx)
37782 Err(pos) => unsafe { Handle::new_edge(pos, idx) },
38247 idx: unsafe { usize::from((*leaf_ptr).parent_idx.assume_init()) },
38409 /// - The node has more than `idx` initialized elements.
38410 unsafe fn into_key_val_mut_at(mut self, idx: usize) -> (&'a K, &'a mut V) {
38420 let key = unsafe { (&*keys.get_unchecked(idx)).assume_init_ref() };
38421 let val = unsafe { (&mut *vals.get_unchecked_mut(idx)).assume_init_mut() };
38537 let idx = usize::from(*len);
38538 assert!(idx < CAPACITY);
38541 self.key_area_mut(idx).write(key);
38542 self.val_area_mut(idx).write(val);
38554 let idx = usize::from(*len);
38555 assert!(idx < CAPACITY);
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);
38561 Handle::new_edge(self.reborrow_mut(), idx + 1).correct_parent_link();
38628 idx: usize,
38648 pub fn idx(&self) -> usize {
38649 self.idx
38655 /// Unsafe because the caller must ensure that `idx < node.len()`.
38656 pub unsafe fn new_kv(node: NodeRef<BorrowType, K, V, NodeType>, idx: usize) -> Self {
38657 debug_assert!(idx < node.len());
38659 Handle { node, idx, _marker: PhantomData }
38663 unsafe { Handle::new_edge(self.node, self.idx) }
38667 unsafe { Handle::new_edge(self.node, self.idx + 1) }
38675 let Self { node, idx, _marker } = self;
38676 node.eq(&other.node) && *idx == other.idx
38686 Handle { node: self.node.reborrow(), idx: self.idx, _marker: PhantomData }
38700 Handle { node: unsafe { self.node.reborrow_mut() }, idx: self.idx, _marker: PhantomData }
38706 /// Unsafe because the caller must ensure that `idx <= node.len()`.
38707 pub unsafe fn new_edge(node: NodeRef<BorrowType, K, V, NodeType>, idx: usize) -> Self {
38708 debug_assert!(idx <= node.len());
38710 Handle { node, idx, _marker: PhantomData }
38714 if self.idx > 0 {
38715 Ok(unsafe { Handle::new_kv(self.node, self.idx - 1) })
38722 if self.idx < self.node.len() {
38723 Ok(unsafe { Handle::new_kv(self.node, self.idx) })
38762 slice_insert(self.node.key_area_mut(..new_len), self.idx, key);
38763 slice_insert(self.node.val_area_mut(..new_len), self.idx, val);
38766 self.node.val_area_mut(self.idx).assume_init_mut()
38779 let kv = unsafe { Handle::new_kv(self.node, self.idx) };
38782 let (middle_kv_idx, insertion) = splitpoint(self.idx);
38805 let idx = self.idx;
38807 child.set_parent_link(ptr, idx);
38821 slice_insert(self.node.key_area_mut(..new_len), self.idx, key);
38822 slice_insert(self.node.val_area_mut(..new_len), self.idx, val);
38823 slice_insert(self.node.edge_area_mut(..new_len + 1), self.idx + 1, edge.node);
38826 self.node.correct_childrens_parent_links(self.idx + 1..new_len + 1);
38843 let kv = unsafe { Handle::new_kv(self.node, self.idx) };
38846 let (middle_kv_idx, insertion) = splitpoint(self.idx);
38918 let node = unsafe { (*parent_ptr).edges.get_unchecked(self.idx).assume_init_read() };
38925 debug_assert!(self.idx < self.node.len());
38927 let k = unsafe { leaf.keys.get_unchecked(self.idx).assume_init_ref() };
38928 let v = unsafe { leaf.vals.get_unchecked(self.idx).assume_init_ref() };
38935 unsafe { self.node.key_area_mut(self.idx).assume_init_mut() }
38939 debug_assert!(self.idx < self.node.len());
38941 unsafe { leaf.vals.get_unchecked_mut(self.idx).assume_init_mut() }
38947 unsafe { self.node.into_key_val_mut_at(self.idx) }
38953 debug_assert!(self.idx < self.node.len());
38958 let key = leaf.keys.get_unchecked_mut(self.idx).assume_init_mut();
38959 let val = leaf.vals.get_unchecked_mut(self.idx).assume_init_mut();
38975 debug_assert!(self.idx < self.node.len());
38977 let new_len = old_len - self.idx - 1;
38980 let k = self.node.key_area_mut(self.idx).assume_init_read();
38981 let v = self.node.val_area_mut(self.idx).assume_init_read();
38984 self.node.key_area_mut(self.idx + 1..old_len),
38988 self.node.val_area_mut(self.idx + 1..old_len),
38992 *self.node.len_mut() = self.idx as u16;
39022 let k = slice_remove(self.node.key_area_mut(..old_len), self.idx);
39023 let v = slice_remove(self.node.val_area_mut(..old_len), self.idx);
39045 self.node.edge_area_mut(self.idx + 1..old_len + 1),
39150 let Handle { node: mut parent_node, idx: parent_idx, _marker } = self.parent;
39229 LeftOrRight::Left(idx) => idx <= old_left_len,
39230 LeftOrRight::Right(idx) => idx <= right_len,
39234 LeftOrRight::Left(idx) => idx,
39235 LeftOrRight::Right(idx) => old_left_len + 1 + idx,
39396 unsafe { Handle::new_edge(self.node.forget_type(), self.idx) }
39404 unsafe { Handle::new_edge(self.node.forget_type(), self.idx) }
39412 unsafe { Handle::new_kv(self.node.forget_type(), self.idx) }
39420 unsafe { Handle::new_kv(self.node.forget_type(), self.idx) }
39434 ForceResult::Leaf(Handle { node, idx: self.idx, _marker: PhantomData })
39437 ForceResult::Internal(Handle { node, idx: self.idx, _marker: PhantomData })
39449 Handle { node, idx: self.idx, _marker: PhantomData }
39461 let new_left_len = self.idx;
39567 /// The slice has more than `idx` elements.
39568 unsafe fn slice_insert<T>(slice: &mut [MaybeUninit<T>], idx: usize, val: T) {
39571 debug_assert!(len > idx);
39573 if len > idx + 1 {
39574 ptr::copy(slice_ptr.add(idx), slice_ptr.add(idx + 1), len - idx - 1);
39576 (*slice_ptr.add(idx)).write(val);
39584 /// The slice has more than `idx` elements.
39585 unsafe fn slice_remove<T>(slice: &mut [MaybeUninit<T>], idx: usize) -> T {
39588 debug_assert!(idx < len);
39590 let ret = (*slice_ptr.add(idx)).assume_init_read();
39591 ptr::copy(slice_ptr.add(idx + 1), slice_ptr.add(idx), len - idx - 1);
39639 for idx in 0..=node.len() {
39640 let edge = unsafe { Handle::new_edge(node, idx) };
39675 for idx in 0..=CAPACITY {
39676 let (middle_kv_idx, insertion) = splitpoint(idx);
40045 unsafe fn __iterator_get_unchecked(&mut self, idx: usize) -> Self::Item
40055 let idx = self.inner.wrap_add(self.inner.tail, idx);
40056 self.inner.buffer_read(idx)
40560 fn wrap_index(&self, idx: usize) -> usize {
40561 wrap_index(idx, self.cap())
40567 fn wrap_add(&self, idx: usize, addend: usize) -> usize {
40568 wrap_index(idx.wrapping_add(addend), self.cap())
40574 fn wrap_sub(&self, idx: usize, subtrahend: usize) -> usize {
40575 wrap_index(idx.wrapping_sub(subtrahend), self.cap())
40858 let idx = self.wrap_add(self.tail, index);
40859 unsafe { Some(&*self.ptr().add(idx)) }
40887 let idx = self.wrap_add(self.tail, index);
40888 unsafe { Some(&mut *self.ptr().add(idx)) }
41950 let idx = self.wrap_add(self.tail, index);
41957 match (contiguous, distance_to_tail <= distance_to_head, idx >= self.tail) {
42012 self.copy(idx + 1, idx, self.head - idx);
42048 // move elements from idx to end forward not including ^ element
42049 self.copy(idx + 1, idx, self.cap() - 1 - idx);
42054 (false, true, false) if idx == 0 => {
42092 // move elements from idx-1 to end forward not including ^ element
42093 self.copy(0, 1, idx - 1);
42109 self.copy(idx + 1, idx, self.head - idx);
42167 let idx = self.wrap_add(self.tail, index);
42169 let elem = unsafe { Some(self.buffer_read(idx)) };
42176 match (contiguous, distance_to_tail <= distance_to_head, idx >= self.tail) {
42203 self.copy(idx, idx + 1, self.head - idx - 1);
42233 self.copy(idx, idx + 1, self.head - idx - 1);
42258 self.copy(idx, idx + 1, self.cap() - idx - 1);
42283 // draw in elements up to idx
42284 self.copy(1, 0, idx);
42797 /// let idx = deque.binary_search(&num).unwrap_or_else(|x| x);
42798 /// deque.insert(idx, num);
42858 back.binary_search_by(f).map(|idx| idx + front.len()).map_err(|idx| idx + front.len())
43386 unsafe fn __iterator_get_unchecked(&mut self, idx: usize) -> Self::Item
43393 let idx = wrap_index(self.tail.wrapping_add(idx), self.ring.len());
43394 self.ring.get_unchecked(idx)
43545 let idx = tester.len() - 1 - i;
43546 assert_eq!(tester.swap_remove_front(idx), Some(len * 2 - 1 - i));
44209 unsafe fn __iterator_get_unchecked(&mut self, idx: usize) -> Self::Item
44216 let idx = wrap_index(self.tail.wrapping_add(idx), self.ring.len());
44217 &mut *self.ring.get_unchecked_mut(idx)
49420 DrainFilter { vec: self, idx: 0, del: 0, old_len, pred: filter, panic_flag: false }
49765 pub(super) idx: usize,
49801 while self.idx < self.old_len {
49802 let i = self.idx;
49810 self.idx += 1;
49826 (0, Some(self.old_len - self.idx))
49849 if self.drain.idx < self.drain.old_len && self.drain.del > 0 {
49857 let src = ptr.add(self.drain.idx);
49859 let tail_len = self.drain.old_len - self.drain.idx;