mtb_entity_slab/container/

ptrlist.rs

use crate::{EntityAlloc, IEntityAllocID, PtrID, alloc::IEntityAllocatable};
use std::{
    cell::Cell,
    error::Error,
    fmt::{Debug, Display},
    iter::Rev,
};

pub struct EntityListHead<E: IEntityAllocatable>(pub Option<PtrID<E>>, pub Option<PtrID<E>>);

impl<E: IEntityAllocatable> Clone for EntityListHead<E> {
    #[inline]
    fn clone(&self) -> Self {
        Self(self.0, self.1)
    }
}
impl<E: IEntityAllocatable> Copy for EntityListHead<E> {}
impl<E: IEntityAllocatable> EntityListHead<E> {
    #[inline]
    pub fn none() -> Self {
        Self(None, None)
    }

    #[inline]
    pub fn get_prev_id(&self) -> Option<PtrID<E>> {
        self.0
    }
    #[inline]
    pub fn get_next_id(&self) -> Option<PtrID<E>> {
        self.1
    }

    #[inline]
    pub fn prev_id(self, prev: Option<PtrID<E>>) -> Self {
        Self(prev, self.1)
    }
    #[inline]
    pub fn next_id(self, next: Option<PtrID<E>>) -> Self {
        Self(self.0, next)
    }
}

pub enum EntityListError<E: IEntityAllocatable> {
    EmptyList,
    ListBroken,
    NodeIsSentinel,
    RepeatedNode,
    SelfNotAttached(PtrID<E>),
    ItemFalselyAttached(PtrID<E>),
    ItemFalselyDetached(PtrID<E>),
}
impl<E: IEntityAllocatable> Debug for EntityListError<E> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        use EntityListError::*;
        match self {
            EmptyList => write!(f, "EmptyList"),
            ListBroken => write!(f, "ListBroken"),
            NodeIsSentinel => write!(f, "NodeIsSentinel"),
            RepeatedNode => write!(f, "RepeatedNode"),
            SelfNotAttached(id) => {
                write!(f, "SelfNotAttached({id:?})")
            }
            ItemFalselyAttached(id) => {
                write!(f, "ItemFalselyAttached({id:?})")
            }
            ItemFalselyDetached(id) => {
                write!(f, "ItemFalselyDetached({id:?})")
            }
        }
    }
}
impl<E: IEntityAllocatable> Clone for EntityListError<E> {
    fn clone(&self) -> Self {
        match self {
            EntityListError::EmptyList => EntityListError::EmptyList,
            EntityListError::ListBroken => EntityListError::ListBroken,
            EntityListError::NodeIsSentinel => EntityListError::NodeIsSentinel,
            EntityListError::RepeatedNode => EntityListError::RepeatedNode,
            EntityListError::SelfNotAttached(id) => EntityListError::SelfNotAttached(*id),
            EntityListError::ItemFalselyAttached(id) => EntityListError::ItemFalselyAttached(*id),
            EntityListError::ItemFalselyDetached(id) => EntityListError::ItemFalselyDetached(*id),
        }
    }
}
impl<E: IEntityAllocatable> Copy for EntityListError<E> {}
impl<E: IEntityAllocatable> Display for EntityListError<E> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{self:?}")
    }
}
impl<E: IEntityAllocatable> Error for EntityListError<E> {}

pub type PtrListRes<E, T = ()> = Result<T, EntityListError<E>>;

pub trait IEntityListNode: Sized + IEntityAllocatable {
    fn load_head(&self) -> EntityListHead<Self>;
    fn store_head(&self, head: EntityListHead<Self>);
    fn is_sentinel(&self) -> bool;
    fn new_sentinel() -> Self;
    fn on_push_next(
        curr: PtrID<Self>,
        next: PtrID<Self>,
        alloc: &EntityAlloc<Self>,
    ) -> PtrListRes<Self>;
    fn on_push_prev(
        curr: PtrID<Self>,
        prev: PtrID<Self>,
        alloc: &EntityAlloc<Self>,
    ) -> PtrListRes<Self>;
    fn on_unplug(curr: PtrID<Self>, alloc: &EntityAlloc<Self>) -> PtrListRes<Self>;

    #[inline]
    fn get_prev_id(&self) -> Option<PtrID<Self>> {
        self.load_head().get_prev_id()
    }
    #[inline]
    fn get_next_id(&self) -> Option<PtrID<Self>> {
        self.load_head().get_next_id()
    }

    #[inline]
    fn set_prev_id(&self, prev: Option<PtrID<Self>>) {
        let head = self.load_head();
        self.store_head(head.prev_id(prev));
    }
    #[inline]
    fn set_next_id(&self, next: Option<PtrID<Self>>) {
        let head = self.load_head();
        self.store_head(head.next_id(next));
    }

    #[inline]
    fn is_attached(&self) -> bool {
        let EntityListHead(prev, next) = self.load_head();
        assert!(
            self.is_sentinel() || prev.is_some() == next.is_some(),
            "ptrlist node is corrupted"
        );
        prev.is_some() || next.is_some()
    }

    fn comes_before(
        curr: PtrID<Self>,
        other: PtrID<Self>,
        alloc: &EntityAlloc<Self>,
    ) -> PtrListRes<Self> {
        let mut node = curr;
        while let Some(next) = node.deref(alloc).get_next_id() {
            if next == other {
                return Ok(());
            }
            node = next;
        }
        Err(EntityListError::ListBroken)
    }
}

/// A partial-close range of an entity pointer list representing `[start, end)`.
///
/// - if `end is None`, the range is open-ended.
/// - the `start` is non-nullable, meaning any range must have a valid start.
pub struct EntityListRange<E: IEntityListNode> {
    pub start: PtrID<E>,
    pub end: Option<PtrID<E>>,
}

impl<E: IEntityListNode> EntityListRange<E> {
    #[inline]
    pub fn is_empty(&self) -> bool {
        Some(self.start) == self.end
    }

    pub fn iter<'alloc>(&self, alloc: &'alloc EntityAlloc<E>) -> EntityListReadIter<'alloc, E> {
        EntityListReadIter {
            alloc,
            curr: Some(self.start),
            end: self.end,
        }
    }
}

pub struct EntityList<E: IEntityListNode> {
    pub head: PtrID<E>,
    pub tail: PtrID<E>,
    pub len: Cell<usize>,
}

impl<E: IEntityListNode> EntityList<E> {
    pub fn new(alloc: &EntityAlloc<E>) -> Self {
        let head = alloc.allocate(E::new_sentinel());
        let tail = alloc.allocate(E::new_sentinel());
        head.deref(alloc).set_next_id(Some(tail));
        tail.deref(alloc).set_prev_id(Some(head));
        Self {
            head,
            tail,
            len: Cell::new(0),
        }
    }

    #[inline]
    pub fn len(&self) -> usize {
        self.len.get()
    }
    #[inline]
    pub fn is_empty(&self) -> bool {
        self.len.get() == 0
    }

    pub fn get_front_id(&self, alloc: &EntityAlloc<E>) -> Option<PtrID<E>> {
        let head = self.head.deref(alloc);
        let next = head.get_next_id()?;
        if next == self.tail { None } else { Some(next) }
    }
    pub fn get_back_id(&self, alloc: &EntityAlloc<E>) -> Option<PtrID<E>> {
        let tail = self.tail.deref(alloc);
        let prev = tail.get_prev_id()?;
        if prev == self.head { None } else { Some(prev) }
    }

    pub fn node_add_next(
        &self,
        node: PtrID<E>,
        new_node: PtrID<E>,
        alloc: &EntityAlloc<E>,
    ) -> PtrListRes<E> {
        if node == new_node {
            return Err(EntityListError::RepeatedNode);
        }
        E::on_push_next(node, new_node, alloc)?;
        assert!(node.deref(alloc).is_attached());
        assert!(!new_node.deref(alloc).is_attached());
        let node_obj = node.deref(alloc);
        let orig_next = node_obj.get_next_id();
        new_node
            .deref(alloc)
            .store_head(EntityListHead(Some(node), orig_next));
        node_obj.set_next_id(Some(new_node));
        if let Some(orig_next) = orig_next {
            orig_next.deref(alloc).set_prev_id(Some(new_node));
        }
        self.len.set(self.len.get() + 1);
        Ok(())
    }
    pub fn node_add_prev(
        &self,
        node: PtrID<E>,
        new_node: PtrID<E>,
        alloc: &EntityAlloc<E>,
    ) -> PtrListRes<E> {
        if node == new_node {
            return Err(EntityListError::RepeatedNode);
        }
        E::on_push_prev(node, new_node, alloc)?;
        assert!(node.deref(alloc).is_attached());
        assert!(!new_node.deref(alloc).is_attached());
        let node_obj = node.deref(alloc);
        let orig_prev = node_obj.get_prev_id();
        new_node
            .deref(alloc)
            .store_head(EntityListHead(orig_prev, Some(node)));
        node_obj.set_prev_id(Some(new_node));
        if let Some(orig_prev) = orig_prev {
            orig_prev.deref(alloc).set_next_id(Some(new_node));
        }
        self.len.set(self.len.get() + 1);
        Ok(())
    }
    pub fn node_unplug(&self, node: PtrID<E>, alloc: &EntityAlloc<E>) -> PtrListRes<E> {
        if node == self.head || node == self.tail {
            return Err(EntityListError::NodeIsSentinel);
        }
        E::on_unplug(node, alloc)?;
        assert!(node.deref(alloc).is_attached());
        let node_obj = node.deref(alloc);
        let prev = node_obj.get_prev_id().ok_or(EntityListError::ListBroken)?;
        let next = node_obj.get_next_id().ok_or(EntityListError::ListBroken)?;
        prev.deref(alloc).set_next_id(Some(next));
        next.deref(alloc).set_prev_id(Some(prev));
        node_obj.store_head(EntityListHead(None, None));
        self.len.set(self.len.get() - 1);
        Ok(())
    }

    #[inline]
    pub fn push_back_id(&self, new_node: PtrID<E>, alloc: &EntityAlloc<E>) -> PtrListRes<E> {
        self.node_add_prev(self.tail, new_node, alloc)
    }
    #[inline]
    pub fn push_front_id(&self, new_node: PtrID<E>, alloc: &EntityAlloc<E>) -> PtrListRes<E> {
        self.node_add_next(self.head, new_node, alloc)
    }
    #[inline]
    pub fn push_back_val(&self, val: E, alloc: &EntityAlloc<E>) -> PtrListRes<E> {
        self.push_back_id(alloc.allocate(val), alloc)
    }
    #[inline]
    pub fn push_front_val(&self, val: E, alloc: &EntityAlloc<E>) -> PtrListRes<E> {
        self.push_front_id(alloc.allocate(val), alloc)
    }

    pub fn pop_back(&self, alloc: &EntityAlloc<E>) -> PtrListRes<E, PtrID<E>> {
        let back_id = self.get_back_id(alloc).ok_or(EntityListError::EmptyList)?;
        self.node_unplug(back_id, alloc)?;
        Ok(back_id)
    }
    pub fn pop_front(&self, alloc: &EntityAlloc<E>) -> PtrListRes<E, PtrID<E>> {
        let front_id = self.get_front_id(alloc).ok_or(EntityListError::EmptyList)?;
        self.node_unplug(front_id, alloc)?;
        Ok(front_id)
    }

    pub fn foreach(&self, alloc: &EntityAlloc<E>, mut f: impl FnMut(PtrID<E>, &E)) {
        let mut node_opt = self.get_front_id(alloc);
        while let Some(node) = node_opt {
            let node_obj = node.deref(alloc);
            f(node, node_obj);
            node_opt = node_obj.get_next_id();
            if node_opt == Some(self.tail) {
                break;
            }
        }
    }
    pub fn forall_with_sentinel(
        &self,
        alloc: &EntityAlloc<E>,
        mut f: impl FnMut(PtrID<E>, &E) -> bool,
    ) -> bool {
        let mut node_opt = Some(self.head);
        while let Some(node) = node_opt {
            let node_obj = node.deref(alloc);
            if !f(node, node_obj) {
                return false;
            }
            node_opt = node_obj.get_next_id();
        }
        true
    }

    pub fn get_range(&self, alloc: &EntityAlloc<E>) -> EntityListRange<E> {
        let Some(start) = self.head.deref(alloc).get_next_id() else {
            panic!("EntityList corrupted: head has no next");
        };
        EntityListRange {
            start,
            end: Some(self.tail),
        }
    }
    /// Get the range including sentinels.
    pub fn get_range_with_sentinels(&self) -> EntityListRange<E> {
        EntityListRange {
            start: self.head,
            end: None,
        }
    }

    pub fn iter<'alloc>(
        &'alloc self,
        alloc: &'alloc EntityAlloc<E>,
    ) -> EntityListReadIter<'alloc, E> {
        EntityListReadIter {
            alloc,
            curr: self.head.deref(alloc).get_next_id(),
            end: Some(self.tail),
        }
    }
    pub fn iter_with_sentinels<'alloc>(
        &'alloc self,
        alloc: &'alloc EntityAlloc<E>,
    ) -> EntityListReadIter<'alloc, E> {
        EntityListReadIter {
            alloc,
            curr: Some(self.head),
            end: None,
        }
    }
}

pub struct EntityListReadIter<'alloc, E: IEntityListNode> {
    alloc: &'alloc EntityAlloc<E>,
    curr: Option<PtrID<E>>,
    end: Option<PtrID<E>>,
}
impl<'alloc, E: IEntityListNode> Iterator for EntityListReadIter<'alloc, E> {
    type Item = (PtrID<E>, &'alloc E);

    fn next(&mut self) -> Option<Self::Item> {
        let curr_id = self.curr?;
        if Some(curr_id) == self.end {
            return None;
        }
        let curr_obj = curr_id.deref(self.alloc);
        self.curr = curr_obj.get_next_id();
        Some((curr_id, curr_obj))
    }
}

/// An entity pointer list node that supports ring lists.
pub trait IEntityRingListNode: Sized + IEntityAllocatable {
    fn load_head(&self) -> EntityListHead<Self>;
    fn store_head(&self, head: EntityListHead<Self>);
    fn is_sentinel(&self) -> bool;
    fn new_sentinel() -> Self;

    fn ring_list_node_dispose(&self, alloc: &EntityAlloc<Self>) {
        self.detach(alloc)
            .expect("Failed to detach node during disposal");
    }
    fn on_self_unplug(&self, self_id: PtrID<Self>, alloc: &EntityAlloc<Self>);

    #[inline]
    fn get_prev_id(&self) -> Option<PtrID<Self>> {
        self.load_head().get_prev_id()
    }
    #[inline]
    fn get_next_id(&self) -> Option<PtrID<Self>> {
        self.load_head().get_next_id()
    }
    #[inline]
    fn set_prev_id(&self, prev: Option<PtrID<Self>>) {
        let head = self.load_head();
        self.store_head(head.prev_id(prev));
    }
    #[inline]
    fn set_next_id(&self, next: Option<PtrID<Self>>) {
        let head = self.load_head();
        self.store_head(head.next_id(next));
    }

    #[inline]
    fn is_attached(&self) -> bool {
        let EntityListHead(prev, next) = self.load_head();
        assert!(
            prev.is_some() == next.is_some(),
            "ptrlist node is corrupted"
        );
        prev.is_some() || next.is_some()
    }
    fn detach(&self, alloc: &EntityAlloc<Self>) -> PtrListRes<Self> {
        if self.is_sentinel() {
            return Err(EntityListError::NodeIsSentinel);
        }
        let EntityListHead(Some(prev), Some(next)) = self.load_head() else {
            // detach() 在节点未连接时调用是合法的，直接返回 Ok(())
            return Ok(());
        };
        prev.deref(alloc).set_next_id(Some(next));
        next.deref(alloc).set_prev_id(Some(prev));
        self.store_head(EntityListHead(None, None));
        Ok(())
    }
}

impl<E: IEntityRingListNode> PtrID<E> {
    pub fn detach(self, alloc: &EntityAlloc<E>) -> PtrListRes<E> {
        let obj = self.deref(alloc);
        if obj.is_sentinel() {
            return Err(EntityListError::NodeIsSentinel);
        }
        let EntityListHead(Some(prev), Some(next)) = obj.load_head() else {
            // detach() 在节点未连接时调用是合法的，直接返回 Ok(())
            return Ok(());
        };
        prev.deref(alloc).set_next_id(Some(next));
        next.deref(alloc).set_prev_id(Some(prev));
        obj.store_head(EntityListHead(None, None));
        Ok(())
    }
}

/// A doubly-linked ring list of entity pointers.
pub struct EntityRingList<E: IEntityRingListNode> {
    pub sentinel: PtrID<E>,
}

impl<E: IEntityRingListNode> EntityRingList<E> {
    pub fn new(alloc: &EntityAlloc<E>) -> Self {
        let sentinel = alloc.allocate(E::new_sentinel());
        let head = Some(sentinel);
        sentinel.deref(alloc).store_head(EntityListHead(head, head));
        Self { sentinel }
    }

    pub fn is_empty(&self, alloc: &EntityAlloc<E>) -> bool {
        let sentinel_obj = self.sentinel.deref(alloc);
        match sentinel_obj.get_next_id() {
            Some(id) => id.deref(alloc).is_sentinel(),
            None => true,
        }
    }

    pub fn foreach(&self, alloc: &EntityAlloc<E>, mut f: impl FnMut(PtrID<E>, &E)) {
        let mut node_id_opt = self.sentinel.deref(alloc).get_next_id();
        while let Some(node_id) = node_id_opt {
            if node_id.deref(alloc).is_sentinel() {
                break;
            }
            let node_obj = node_id.deref(alloc);
            f(node_id, node_obj);
            node_id_opt = node_obj.get_next_id();
        }
    }
    pub fn forall_with_sentinel(
        &self,
        alloc: &EntityAlloc<E>,
        mut f: impl FnMut(PtrID<E>, &E) -> bool,
    ) -> bool {
        let mut node_id_opt = Some(self.sentinel);
        let mut n = 0;
        while let Some(node_id) = node_id_opt {
            let node_obj = node_id.deref(alloc);
            if !f(node_id, node_obj) {
                return false;
            }
            let next = node_obj.get_next_id();
            if next == Some(self.sentinel) {
                return true;
            }
            node_id_opt = next;
            n += 1;
        }
        panic!("Broken ring list detected after {n} iterations");
    }
    pub fn len(&self, alloc: &EntityAlloc<E>) -> usize {
        let mut count = 0;
        self.foreach(alloc, |_, _| count += 1);
        count
    }
    pub fn front_id(&self, alloc: &EntityAlloc<E>) -> Option<PtrID<E>> {
        let next = self.sentinel.deref(alloc).get_next_id()?;
        if next.deref(alloc).is_sentinel() {
            None
        } else {
            Some(next)
        }
    }
    pub fn back_id(&self, alloc: &EntityAlloc<E>) -> Option<PtrID<E>> {
        let prev = self.sentinel.deref(alloc).get_prev_id()?;
        if prev.deref(alloc).is_sentinel() {
            None
        } else {
            Some(prev)
        }
    }
    pub fn is_single(&self, alloc: &EntityAlloc<E>) -> bool {
        let s = self.sentinel.deref(alloc);
        let next = s.get_next_id().unwrap_or(self.sentinel);
        let prev = s.get_prev_id().unwrap_or(self.sentinel);
        next == prev && !next.deref(alloc).is_sentinel()
    }
    #[inline]
    pub fn is_multiple(&self, alloc: &EntityAlloc<E>) -> bool {
        !self.is_empty(alloc) && !self.is_single(alloc)
    }
    pub fn contains(&self, node: PtrID<E>, alloc: &EntityAlloc<E>) -> bool {
        if !node.deref(alloc).is_attached() {
            return false;
        }
        let mut cur = self.sentinel.deref(alloc).get_next_id();
        while let Some(id) = cur {
            if id == node {
                return true;
            }
            if id.deref(alloc).is_sentinel() {
                break;
            }
            cur = id.deref(alloc).get_next_id();
        }
        false
    }
    /// Clone a view over the same ring list (shares the sentinel)
    #[inline]
    pub fn clone_view(&self) -> Self {
        Self {
            sentinel: self.sentinel,
        }
    }
    pub fn iter<'alloc>(
        &'alloc self,
        alloc: &'alloc EntityAlloc<E>,
    ) -> EntityRingListReadIter<'alloc, E> {
        EntityRingListReadIter {
            alloc,
            curr: self
                .sentinel
                .deref(alloc)
                .get_next_id()
                .unwrap_or(self.sentinel),
        }
    }
    pub fn back_iter<'alloc>(
        &'alloc self,
        alloc: &'alloc EntityAlloc<E>,
    ) -> Rev<EntityRingListReadIter<'alloc, E>> {
        EntityRingListReadIter {
            alloc,
            curr: self
                .sentinel
                .deref(alloc)
                .get_prev_id()
                .unwrap_or(self.sentinel),
        }
        .rev()
    }

    /// Push to back (before sentinel)
    pub fn push_back_id(&self, new_node: PtrID<E>, alloc: &EntityAlloc<E>) -> PtrListRes<E> {
        // Insert immediately before sentinel: prev <-> new_node <-> sentinel
        let sentinel = self.sentinel;
        let s_obj = sentinel.deref(alloc);
        assert!(s_obj.is_sentinel());
        let prev = s_obj
            .get_prev_id()
            .expect("ring broken: sentinel.prev is None");
        // new_node must not already be attached
        assert!(!new_node.deref(alloc).is_attached());
        new_node
            .deref(alloc)
            .store_head(EntityListHead(Some(prev), Some(sentinel)));
        s_obj.set_prev_id(Some(new_node));
        prev.deref(alloc).set_next_id(Some(new_node));
        Ok(())
    }

    // pop_front/pop_back are intentionally omitted for Remusys IR use-cases;
    // detach a known node explicitly when needed.

    /// Move all nodes from `self` into `other`, preserving order; invoke on_move for each moved node.
    pub fn move_all_to(
        &self,
        other: &EntityRingList<E>,
        alloc: &EntityAlloc<E>,
        mut on_move: impl FnMut(PtrID<E>),
    ) -> PtrListRes<E> {
        if self.sentinel == other.sentinel {
            return Ok(());
        }
        let mut cur = self.front_id(alloc);
        while let Some(id) = cur {
            let next = id.deref(alloc).get_next_id();
            id.detach(alloc)?;
            other.push_back_id(id, alloc)?;
            on_move(id);
            cur = match next {
                Some(n) if !n.deref(alloc).is_sentinel() => Some(n),
                _ => None,
            };
        }
        Ok(())
    }
    /// Move nodes that satisfy `predicate` from `self` to `other`, preserving order.
    pub fn move_to_if(
        &self,
        other: &EntityRingList<E>,
        alloc: &EntityAlloc<E>,
        mut predicate: impl FnMut(PtrID<E>, &E) -> bool,
        mut on_move: impl FnMut(PtrID<E>),
    ) -> PtrListRes<E> {
        if self.sentinel == other.sentinel {
            return Ok(());
        }
        let mut cur = self.front_id(alloc);
        while let Some(id) = cur {
            let next = id.deref(alloc).get_next_id();
            let obj = id.deref(alloc);
            if predicate(id, obj) {
                id.detach(alloc)?;
                other.push_back_id(id, alloc)?;
                on_move(id);
            }
            cur = match next {
                Some(n) if !n.deref(alloc).is_sentinel() => Some(n),
                _ => None,
            };
        }
        Ok(())
    }

    /// notifies all nodes in the ring list that the list is being dropped
    pub fn clean(&self, alloc: &EntityAlloc<E>) {
        let mut node = self.sentinel.deref(alloc).get_next_id();
        while let Some(node_id) = node {
            if node_id == self.sentinel {
                break;
            }
            let next_node = node_id.deref(alloc).get_next_id();
            node_id.deref(alloc).store_head(EntityListHead(None, None));
            node_id.deref(alloc).on_self_unplug(node_id, alloc);
            node = next_node;
        }
        self.sentinel
            .deref(alloc)
            .store_head(EntityListHead(Some(self.sentinel), Some(self.sentinel)));
    }

    pub fn pop_back(&self, alloc: &EntityAlloc<E>) -> PtrListRes<E, PtrID<E>> {
        let back_id = self.back_id(alloc).ok_or(EntityListError::EmptyList)?;
        back_id.detach(alloc)?;
        back_id.deref(alloc).on_self_unplug(back_id, alloc);
        Ok(back_id)
    }
    pub fn pop_front(&self, alloc: &EntityAlloc<E>) -> PtrListRes<E, PtrID<E>> {
        let front_id = self.front_id(alloc).ok_or(EntityListError::EmptyList)?;
        front_id.detach(alloc)?;
        front_id.deref(alloc).on_self_unplug(front_id, alloc);
        Ok(front_id)
    }
}

pub struct EntityRingListReadIter<'alloc, E: IEntityRingListNode> {
    alloc: &'alloc EntityAlloc<E>,
    curr: PtrID<E>,
}

impl<'alloc, E: IEntityRingListNode> Iterator for EntityRingListReadIter<'alloc, E> {
    type Item = (PtrID<E>, &'alloc E);

    fn next(&mut self) -> Option<Self::Item> {
        let curr_id = self.curr;
        let curr_obj = curr_id.deref(self.alloc);
        if curr_obj.is_sentinel() {
            return None;
        }
        let next_id = curr_obj.get_next_id()?;
        if next_id == self.curr {
            return None;
        }
        self.curr = next_id;
        Some((curr_id, curr_obj))
    }
}
impl<'alloc, E: IEntityRingListNode> DoubleEndedIterator for EntityRingListReadIter<'alloc, E> {
    fn next_back(&mut self) -> Option<Self::Item> {
        let curr_id = self.curr;
        let curr_obj = curr_id.deref(self.alloc);
        if curr_obj.is_sentinel() {
            return None;
        }
        let prev_id = curr_obj.get_prev_id()?;
        if prev_id == self.curr {
            return None;
        }
        self.curr = prev_id;
        Some((curr_id, curr_obj))
    }
}