Method remove

crates/common/src/linked_list.rs:235–277

Removes the specified node from the list # Safety The caller **must** ensure that `node` is currently contained by `self` or not contained by any other list.

(&mut self, node: NonNull<L::Target>)

    /// The caller **must** ensure that `node` is currently contained by
    /// `self` or not contained by any other list.
    pub unsafe fn remove(&mut self, node: NonNull<L::Target>) -> Option<L::Handle> {
        unsafe {
            if let Some(prev) = L::pointers(node).as_ref().get_prev() {
                debug_assert_eq!(
                    L::pointers(prev).as_ref().get_next(),
                    Some(node),
                    "linked list corruption: prev->next != node (prev={prev:p}, node={node:p})"
                );
                L::pointers(prev)
                    .as_mut()
                    .set_next(L::pointers(node).as_ref().get_next());
            } else {
                if self.head != Some(node) {
                    return None;
                }

                self.head = L::pointers(node).as_ref().get_next();
            }

            if let Some(next) = L::pointers(node).as_ref().get_next() {
                debug_assert_eq!(
                    L::pointers(next).as_ref().get_prev(),
                    Some(node),
                    "linked list corruption: next->prev != node (next={next:p}, node={node:p})"
                );
                L::pointers(next)
                    .as_mut()
                    .set_prev(L::pointers(node).as_ref().get_prev());
            } else {
                // // This might be the last item in the list
                // if self.tail != Some(node) {
                //     return None;
                // }

                // self.tail = L::pointers(node).as_ref().get_prev();
            }

            L::pointers(node).as_mut().set_next(None);
            L::pointers(node).as_mut().set_prev(None);

            Some(L::from_raw(node))
        }
    }

    // pub fn last(&self) -> Option<&L::Target> {
    //     let tail = self.tail.as_ref()?;