Struct MoveArena 

pub struct MoveArena<M> { /* private fields */ }

Arena allocator for moves with O(1) reset.

Instead of allocating a new Vec each step and letting it drop, the arena maintains a reusable buffer. Calling reset() simply sets the length to 0 without running destructors (moves are Copy-like in practice since they contain only primitives and small inline data).

Performance

Operation	Vec per step	MoveArena
Alloc	O(n) heap	O(1) bump
Cleanup	O(n) drop	O(1) reset
Memory	n * size_of	Reused

Example

use solverforge_solver::heuristic::r#move::MoveArena;

let mut arena: MoveArena<i32> = MoveArena::new();

// Step 1: generate and evaluate moves
arena.push(1);
arena.push(2);
arena.push(3);
assert_eq!(arena.len(), 3);

// Step 2: reset and reuse (O(1)!)
arena.reset();
assert!(arena.is_empty());

arena.push(10);
arena.push(20);
for mov in arena.iter() {
    assert!(*mov >= 10);
}

Implementations

impl<M> MoveArena<M>

pub fn new() -> Self

Creates a new empty arena.

pub fn with_capacity(capacity: usize) -> Self

Creates a new arena with pre-allocated capacity.

pub fn reset(&mut self)

Resets the arena, making it empty.

Drops all moves except the one that was taken (if any).

pub fn push(&mut self, m: M)

Adds a move to the arena.

pub fn len(&self) -> usize

Returns the number of moves in the arena.

pub fn is_empty(&self) -> bool

Returns true if the arena is empty.

pub fn iter(&self) -> impl Iterator<Item = &M>

Returns an iterator over the moves.

pub fn iter_mut(&mut self) -> impl Iterator<Item = &mut M>

Returns a mutable iterator over the moves.

pub fn get(&self, index: usize) -> Option<&M>

Gets a move by index.

pub fn take(&mut self, index: usize) -> M

Takes ownership of a move by index.

Only one move can be taken per step. Call reset() before taking another.

Panics

Panics if index >= len or if a move was already taken.

Example

use solverforge_solver::heuristic::r#move::MoveArena;

let mut arena: MoveArena<String> = MoveArena::new();
arena.push("first".to_string());
arena.push("second".to_string());

// Take ownership of the move at index 1
let taken = arena.take(1);
assert_eq!(taken, "second");

// Reset before next step
arena.reset();

pub fn extend<I: IntoIterator<Item = M>>(&mut self, iter: I)

Extends the arena from an iterator.

pub fn capacity(&self) -> usize

Returns the capacity of the arena.

Trait Implementations

impl<M: Debug> Debug for MoveArena<M>

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

Formats the value using the given formatter.

impl<M> Default for MoveArena<M>

fn default() -> Self

Returns the “default value” for a type.

impl<M> Drop for MoveArena<M>

fn drop(&mut self)

Executes the destructor for this type.