Struct spool::ObjectPool

pub struct ObjectPool<T> { /* fields omitted */ }

The default ObjectPool implementation.

Allocation of specified capacity happens completely upfront, and the pool cannot be resized.

Items are eagerly dropped when deleted, so destructors run asap.

See Pool implementation for more information.

use spool::{ ObjectPool, Pool };

//Pool allocates _once_ upfront, with given capacity.
let mut pool = ObjectPool::new(3);

let key1 = pool.insert(1);
let key2 = pool.insert(2);
let key3 = pool.insert(3);

//Over capacity! This panics!
//let key4 = pool.insert(404);

pool.delete(&key2);

//All is well.
let key4 = pool.insert(404);

Trait Implementations

impl<T: Clone> Clone for ObjectPool<T>

fn clone(&self) -> ObjectPool<T>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug> Debug for ObjectPool<T>

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

Formats the value using the given formatter.

impl<T: Default> Default for ObjectPool<T>

fn default() -> ObjectPool<T>

Returns the "default value" for a type.

impl<T: Eq> Eq for ObjectPool<T>

impl<T: Hash> Hash for ObjectPool<T>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given [Hasher].

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given [Hasher].

impl<T: PartialEq> PartialEq<ObjectPool<T>> for ObjectPool<T>

fn eq(&self, other: &ObjectPool<T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &ObjectPool<T>) -> bool

This method tests for !=.

impl<T> Pool<T> for ObjectPool<T>

fn new(capacity: usize) -> Self

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

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

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>

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>

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>

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)

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)

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());

impl<T> StructuralEq for ObjectPool<T>

impl<T> StructuralPartialEq for ObjectPool<T>