Struct SlidingRing 

pub struct SlidingRing<T: Copy, const DEPTH: u8> { /* private fields */ }

Ring that slides over signed coordinates while keeping slot access O(1).

Implementations

impl<T: Copy, const DEPTH: u8> SlidingRing<T, DEPTH>

pub const DEPTH: u8 = DEPTH

Compile-time depth parameter exposed for downstream consumers.

pub fn new(zero: T) -> Self

Create a new ring seeded with zero. The anchor index starts at 0.

pub fn borrow_anchor(&self) -> &T

Borrow the slot at the anchor.

pub fn borrow_anchor_mut(&mut self) -> &mut T

Borrow the slot at the anchor mutably.

pub fn slot(&self, offset: RingIndex) -> &T

Immutable access to the slot for offset (measured from the anchor).

pub fn slot_mut(&mut self, offset: RingIndex) -> &mut T

Mutable access to the slot for offset (measured from the anchor).

pub fn shift_by(&mut self, delta: i128)

Shift the anchor by delta, clearing only the slots that newly enter the window.

pub fn shift_by_keep_anchor(&mut self, delta: i128)

Shift by delta while preserving the new anchor slot on backward moves.

pub fn slot_by_index(&self, index: RingIndex) -> &T

Immutable access by raw ring index (0-255).

pub fn slot_by_index_mut(&mut self, index: RingIndex) -> &mut T

Mutable access by raw ring index (0-255).

pub fn clear_all(&mut self)

Clear every slot and reset the anchor index to zero.

pub fn as_slice(&self) -> &[T; 256]

Expose immutable slice reference for advanced use-cases.

pub fn as_mut_slice(&mut self) -> &mut [T; 256]

Expose mutable slice reference for advanced use-cases.

pub fn slices_from_anchor(&self) -> (&[T], &[T])

Returns the contiguous slices that cover the ring starting at the anchor.

The first slice begins at the anchor slot; the second slice wraps around to index 0 (and may be empty). This is ideal for SIMD scans.

const DEPTH: u8 = 16;
let mut ring = SlidingRing::<u64, DEPTH>::new(0);
*ring.slot_mut(0) = 42;
let (tail, head) = ring.slices_from_anchor();
assert_eq!(tail.first(), Some(&42));
assert!(head.is_empty());

pub fn slices_from_anchor_mut(&mut self) -> (&mut [T], &mut [T])

Mutable variant of SlidingRing::slices_from_anchor.

const DEPTH: u8 = 16;
let mut ring = SlidingRing::<u64, DEPTH>::new(0);
{
    let (tail, head) = ring.slices_from_anchor_mut();
    tail[0] = 7;
    assert!(head.is_empty());
}
assert_eq!(*ring.slot(0), 7);

pub fn iter(&self) -> Slots<'_, T>

Iterate over slots in storage order using raw pointers.

pub fn iter_mut(&mut self) -> SlotsMut<'_, T>

Mutable iterator over slots in storage order using raw pointers.

pub fn iter_from_anchor(&self, direction: Direction) -> AnchorIter<'_, T, DEPTH>

Iterate starting at the anchor in the desired direction (wrapping once).

const DEPTH: u8 = 16;
let mut ring = SlidingRing::<u64, DEPTH>::new(0);
*ring.slot_mut(0) = 1;
*ring.slot_mut(1) = 2;
let mut iter = ring.iter_from_anchor(Direction::Forward);
assert_eq!(iter.next().unwrap().1, &1);
assert_eq!(iter.next().unwrap().0, 1);

pub fn iter_from_anchor_mut( &mut self, direction: Direction, ) -> AnchorIterMut<'_, T, DEPTH>

Mutable iteration starting at the anchor in the desired direction.

const DEPTH: u8 = 16;
let mut ring = SlidingRing::<u64, DEPTH>::new(0);
for (_, slot) in ring.iter_from_anchor_mut(Direction::Forward).take(2) {
    *slot = 5;
}
assert_eq!(*ring.slot(0), 5);
assert_eq!(*ring.slot(1), 5);

Trait Implementations

impl<T: Copy, const DEPTH: u8> Debug for SlidingRing<T, DEPTH>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.