[−][src]Trait spool::Pool

pub trait Pool<T> {
    fn new(capacity: usize) -> Self;

    fn capacity(&self) -> usize;

    fn insert(&mut self, value: T) -> PoolKey;

    fn get(&self, key: &PoolKey) -> Option<&T>;

    fn get_mut(&mut self, key: &PoolKey) -> Option<&mut T>;

    fn take(&mut self, key: &PoolKey) -> Option<T>;

    fn delete(&mut self, key: &PoolKey);

    fn clear(&mut self);
}

Required methods

fn new(capacity: usize) -> Self

fn capacity(&self) -> usize

fn insert(&mut self, value: T) -> PoolKey

fn get(&self, key: &PoolKey) -> Option<&T>

fn get_mut(&mut self, key: &PoolKey) -> Option<&mut T>

fn take(&mut self, key: &PoolKey) -> Option<T>

fn delete(&mut self, key: &PoolKey)

fn clear(&mut self)

Loading content...

Implementors

impl<T> Pool<T> for ObjectPool<T>[src]

fn new(capacity: usize) -> Self[src]

Returns a new, empty pool. Preallocated with specified capacity.

Examples

use spool::{ ObjectPool, Pool };

let pool: ObjectPool<i32> = ObjectPool::new(10);
assert_eq!(pool.capacity(), 10);

fn capacity(&self) -> usize[src]

Returns the maximum capacity of the pool.

Examples

use spool::{ ObjectPool, Pool };

let pool: ObjectPool<i32> = ObjectPool::new(10);
assert_eq!(pool.capacity(), 10);

fn insert(&mut self, value: T) -> PoolKey[src]

Returns a PoolKey corresponding to the inserted item.

Panics

This function panics if pool is full.

Examples

use spool::{ ObjectPool, Pool };

let mut pool = ObjectPool::new(10);
let key = pool.insert("Howdy!");

fn get(&self, key: &PoolKey) -> Option<&T>[src]

Retrieves an Option<&T> corresponding to the PoolKey referenced.

Examples

use spool::{ ObjectPool, Pool };

let mut pool = ObjectPool::new(10);

let key1 = pool.insert("I am going to be removed!");
let key2 = pool.insert("I am going to remain!");

pool.delete(&key1);

assert!(pool.get(&key1).is_none());
assert!(pool.get(&key2).is_some());

fn get_mut(&mut self, key: &PoolKey) -> Option<&mut T>[src]

Retrieves an Option<&T> corresponding to the PoolKey referenced.

Examples

use spool::{ ObjectPool, Pool };

let mut pool = ObjectPool::new(10);

let key1 = pool.insert("I am going to be removed!");
let key2 = pool.insert("I am going to remain!");

pool.delete(&key1);

assert!(pool.get_mut(&key1).is_none());
assert!(pool.get_mut(&key2).is_some());

fn take(&mut self, key: &PoolKey) -> Option<T>[src]

Extracts an Option corresponding to the PoolKey referenced. When an entry is been taken it is removed from the pool.

Examples

use spool::{ ObjectPool, Pool };

let mut pool = ObjectPool::new(10);

let key = pool.insert("Take me!");

assert!(pool.take(&key).is_some());
assert!(pool.get(&key).is_none());

fn delete(&mut self, key: &PoolKey)[src]

Deletes an entry corresponding to the PoolKey referenced. When an entry is been deleted it is removed, however it will not be returned.

Examples

use spool::{ ObjectPool, Pool };

let mut pool = ObjectPool::new(10);

let key = pool.insert("Delete me!");

pool.delete(&key);

assert!(pool.get(&key).is_none());

fn clear(&mut self)[src]

Deletes all entries. No entries will be returned.

Examples

use spool::{ ObjectPool, Pool };

let mut pool = ObjectPool::new(10);

let key1 = pool.insert("Delete me!");
let key2 = pool.insert("Delete me too!");
let key3 = pool.insert("Delete me too!");

pool.clear();

assert!(pool.get(&key1).is_none());
assert!(pool.get(&key2).is_none());
assert!(pool.get(&key2).is_none());
Loading content...