Trait RecyclingItemPool 

pub trait RecyclingItemPool<T: PoolItem>: ItemPool<T> {
    // Required method
    fn get_discard_pool(&mut self) -> &mut Vec<T>;

    // Provided methods
    fn discard_one(&mut self, item: T) { ... }
    fn recycle_discarded(&mut self) { ... }
    fn get_set(&mut self, size: usize) -> HashSet<T> { ... }
}

Trait for managing item pools with discard and recycling capabilities.

This trait extends ItemPool to add support for temporarily discarding items and later recycling them back into the main pool. This is useful for scenarios where items need to be temporarily unavailable but should be reused later.

Examples

use itempool::{ItemPool, RecyclingItemPool};
use std::collections::HashSet;

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
struct Card(u32);

struct Deck {
    draw_pile: Vec<Card>,
    discard_pile: Vec<Card>,
}

impl ItemPool<Card> for Deck {
    fn pool(&mut self) -> &mut Vec<Card> {
        &mut self.draw_pile
    }
}

impl RecyclingItemPool<Card> for Deck {
    fn get_discard_pool(&mut self) -> &mut Vec<Card> {
        &mut self.discard_pile
    }
}

Required Methods

fn get_discard_pool(&mut self) -> &mut Vec<T>

Returns a mutable reference to the pool of discarded items.

A temporary storage area for items that have been removed from the main pool but might be needed again later. This allows for recycling of items without needing to re-allocate or re-initialize them.

Provided Methods

fn discard_one(&mut self, item: T)

Adds an item to the discard pool.

Note: This method only adds the item to the discard pool. It does not remove it from the main pool. If you need to move an item from the main pool to the discard pool, you must remove it from the main pool separately.

Arguments

• item - The item to discard

Examples

pool.discard_one(Item(1));

Examples found in repository

examples/enemy_example.rs (line 65)

fn main() {
    let mut enemy_pool = EnemyPool::new(10); // Pool contains EntityId(0) to EntityId(9)
    println!("Initial Pool: {:?}", enemy_pool.pool()); // [EntityId(0), ..., EntityId(9)]
    println!("Initial Discard: {:?}", enemy_pool.get_discard_pool()); // []
    println!("---");

    // Get a single enemy
    let enemy1 = enemy_pool.remove_one();
    println!("Got one enemy: {:?}", enemy1);
    println!("Pool after remove_one: {:?}", enemy_pool.pool());
    println!(
        "Discard after remove_one: {:?}",
        enemy_pool.get_discard_pool()
    );
    println!("---");

    // Get a set of enemies
    let enemy_squad = enemy_pool.remove_set(3);
    println!("Got enemy squad: {:?}", enemy_squad);
    println!("Pool after remove_set: {:?}", enemy_pool.pool());
    println!(
        "Discard after remove_set: {:?}",
        enemy_pool.get_discard_pool()
    );
    println!("---");

    // Manually discard an enemy
    let enemy_to_disable = EntityId(5);
    enemy_pool.discard_one(enemy_to_disable);
    println!("Discarded enemy ID: {:?}", enemy_to_disable);
    println!("Pool after discard_one: {:?}", enemy_pool.pool());
    println!(
        "Discard after discard_one: {:?}",
        enemy_pool.get_discard_pool()
    ); // Contains EntityId(5)
    println!("---");

    // Get another enemy using get_set - this will trigger recycling first
    println!("Calling get_set, which will recycle first...");
    let enemy2 = enemy_pool.get_set(1);
    println!("Got another enemy: {:?}", enemy2);
    println!("Pool after recycle + get_set: {:?}", enemy_pool.pool());
    println!(
        "Discard after recycle + get_set: {:?}",
        enemy_pool.get_discard_pool()
    ); // Empty now
    println!("---");

    // Demonstrate manual recycling
    enemy_pool.discard_one(EntityId(7));
    enemy_pool.discard_one(EntityId(8));
    println!("Discarded 2 more enemies");
    println!("Pool before recycle: {:?}", enemy_pool.pool());
    println!(
        "Discard before recycle: {:?}",
        enemy_pool.get_discard_pool()
    );

    enemy_pool.recycle_discarded();
    println!("Pool after manual recycle: {:?}", enemy_pool.pool());
    println!(
        "Discard after manual recycle: {:?}",
        enemy_pool.get_discard_pool()
    );
}

fn recycle_discarded(&mut self)

Moves all items from the discard pool back into the main pool.

After this operation, the discard pool will be empty and all previously discarded items will be available again in the main pool.

Examples

pool.recycle_discarded();
assert_eq!(pool.pool().len(), 2);
assert_eq!(pool.get_discard_pool().len(), 0);

Examples found in repository

examples/enemy_example.rs (line 95)

fn main() {
    let mut enemy_pool = EnemyPool::new(10); // Pool contains EntityId(0) to EntityId(9)
    println!("Initial Pool: {:?}", enemy_pool.pool()); // [EntityId(0), ..., EntityId(9)]
    println!("Initial Discard: {:?}", enemy_pool.get_discard_pool()); // []
    println!("---");

    // Get a single enemy
    let enemy1 = enemy_pool.remove_one();
    println!("Got one enemy: {:?}", enemy1);
    println!("Pool after remove_one: {:?}", enemy_pool.pool());
    println!(
        "Discard after remove_one: {:?}",
        enemy_pool.get_discard_pool()
    );
    println!("---");

    // Get a set of enemies
    let enemy_squad = enemy_pool.remove_set(3);
    println!("Got enemy squad: {:?}", enemy_squad);
    println!("Pool after remove_set: {:?}", enemy_pool.pool());
    println!(
        "Discard after remove_set: {:?}",
        enemy_pool.get_discard_pool()
    );
    println!("---");

    // Manually discard an enemy
    let enemy_to_disable = EntityId(5);
    enemy_pool.discard_one(enemy_to_disable);
    println!("Discarded enemy ID: {:?}", enemy_to_disable);
    println!("Pool after discard_one: {:?}", enemy_pool.pool());
    println!(
        "Discard after discard_one: {:?}",
        enemy_pool.get_discard_pool()
    ); // Contains EntityId(5)
    println!("---");

    // Get another enemy using get_set - this will trigger recycling first
    println!("Calling get_set, which will recycle first...");
    let enemy2 = enemy_pool.get_set(1);
    println!("Got another enemy: {:?}", enemy2);
    println!("Pool after recycle + get_set: {:?}", enemy_pool.pool());
    println!(
        "Discard after recycle + get_set: {:?}",
        enemy_pool.get_discard_pool()
    ); // Empty now
    println!("---");

    // Demonstrate manual recycling
    enemy_pool.discard_one(EntityId(7));
    enemy_pool.discard_one(EntityId(8));
    println!("Discarded 2 more enemies");
    println!("Pool before recycle: {:?}", enemy_pool.pool());
    println!(
        "Discard before recycle: {:?}",
        enemy_pool.get_discard_pool()
    );

    enemy_pool.recycle_discarded();
    println!("Pool after manual recycle: {:?}", enemy_pool.pool());
    println!(
        "Discard after manual recycle: {:?}",
        enemy_pool.get_discard_pool()
    );
}

fn get_set(&mut self, size: usize) -> HashSet<T>

Retrieves a set of unique items, automatically recycling discarded items first.

This method first calls recycle_discarded to ensure all discarded items are available, then retrieves the requested number of unique items using ItemPool::remove_set.

Arguments

• size - The number of unique items to retrieve

Returns

A HashSet containing the unique items

Panics

Panics in debug mode if:

• The combined pool (main + discarded) is empty after recycling
• size exceeds the total number of available items after recycling

Examples

let items = pool.get_set(7);
assert_eq!(items.len(), 7);

Examples found in repository

examples/enemy_example.rs (line 76)

fn main() {
    let mut enemy_pool = EnemyPool::new(10); // Pool contains EntityId(0) to EntityId(9)
    println!("Initial Pool: {:?}", enemy_pool.pool()); // [EntityId(0), ..., EntityId(9)]
    println!("Initial Discard: {:?}", enemy_pool.get_discard_pool()); // []
    println!("---");

    // Get a single enemy
    let enemy1 = enemy_pool.remove_one();
    println!("Got one enemy: {:?}", enemy1);
    println!("Pool after remove_one: {:?}", enemy_pool.pool());
    println!(
        "Discard after remove_one: {:?}",
        enemy_pool.get_discard_pool()
    );
    println!("---");

    // Get a set of enemies
    let enemy_squad = enemy_pool.remove_set(3);
    println!("Got enemy squad: {:?}", enemy_squad);
    println!("Pool after remove_set: {:?}", enemy_pool.pool());
    println!(
        "Discard after remove_set: {:?}",
        enemy_pool.get_discard_pool()
    );
    println!("---");

    // Manually discard an enemy
    let enemy_to_disable = EntityId(5);
    enemy_pool.discard_one(enemy_to_disable);
    println!("Discarded enemy ID: {:?}", enemy_to_disable);
    println!("Pool after discard_one: {:?}", enemy_pool.pool());
    println!(
        "Discard after discard_one: {:?}",
        enemy_pool.get_discard_pool()
    ); // Contains EntityId(5)
    println!("---");

    // Get another enemy using get_set - this will trigger recycling first
    println!("Calling get_set, which will recycle first...");
    let enemy2 = enemy_pool.get_set(1);
    println!("Got another enemy: {:?}", enemy2);
    println!("Pool after recycle + get_set: {:?}", enemy_pool.pool());
    println!(
        "Discard after recycle + get_set: {:?}",
        enemy_pool.get_discard_pool()
    ); // Empty now
    println!("---");

    // Demonstrate manual recycling
    enemy_pool.discard_one(EntityId(7));
    enemy_pool.discard_one(EntityId(8));
    println!("Discarded 2 more enemies");
    println!("Pool before recycle: {:?}", enemy_pool.pool());
    println!(
        "Discard before recycle: {:?}",
        enemy_pool.get_discard_pool()
    );

    enemy_pool.recycle_discarded();
    println!("Pool after manual recycle: {:?}", enemy_pool.pool());
    println!(
        "Discard after manual recycle: {:?}",
        enemy_pool.get_discard_pool()
    );
}

Implementors