Struct obj_pool::ObjPool [−][src]
pub struct ObjPool<T> { /* fields omitted */ }
An object pool.
ObjPool<T>
holds an array of slots for storing objects.
Every slot is always in one of two states: occupied or vacant.
Essentially, this is equivalent to Vec<Option<T>>
.
Insert and remove
When inserting a new object into object pool, a vacant slot is found and then the object is placed
into the slot. If there are no vacant slots, the array is reallocated with bigger capacity.
The cost of insertion is amortized O(1)
.
When removing an object, the slot containing it is marked as vacant and the object is returned.
The cost of removal is O(1)
.
use obj_pool::ObjPool; let mut obj_pool = ObjPool::new(); let a = obj_pool.insert(10); let b = obj_pool.insert(20); assert_ne!(a, b); // ids are not the same assert_eq!(obj_pool.remove(a), Some(10)); assert_eq!(obj_pool.get(a), None); // there is no object with this `ObjId` anymore assert_eq!(obj_pool.insert(30), a); // slot is reused, got the same `ObjId`
Indexing
You can also access objects in an object pool by ObjId
.
However, accessing an object with invalid ObjId
will result in panic.
use obj_pool::ObjPool; let mut obj_pool = ObjPool::new(); let a = obj_pool.insert(10); let b = obj_pool.insert(20); assert_eq!(obj_pool[a], 10); assert_eq!(obj_pool[b], 20); obj_pool[a] += obj_pool[b]; assert_eq!(obj_pool[a], 30);
To access slots without fear of panicking, use get
and get_mut
, which return Option
s.
Methods
impl<T> ObjPool<T>
[src]
impl<T> ObjPool<T>
pub fn new() -> Self
[src]
pub fn new() -> Self
Constructs a new, empty object pool.
The object pool will not allocate until objects are inserted into it.
Examples
use obj_pool::ObjPool; let mut obj_pool: ObjPool<i32> = ObjPool::new();
pub fn obj_id_from_index(&self, index: u32) -> ObjId
[src]
pub fn obj_id_from_index(&self, index: u32) -> ObjId
pub fn index_from_obj_id(&self, obj_id: ObjId) -> u32
[src]
pub fn index_from_obj_id(&self, obj_id: ObjId) -> u32
pub fn with_capacity(cap: usize) -> Self
[src]
pub fn with_capacity(cap: usize) -> Self
Constructs a new, empty object pool with the specified capacity (number of slots).
The object pool will be able to hold exactly capacity
objects without reallocating.
If capacity
is 0, the object pool will not allocate.
Examples
use obj_pool::ObjPool; let mut obj_pool = ObjPool::with_capacity(10); assert_eq!(obj_pool.len(), 0); assert_eq!(obj_pool.capacity(), 10); // These inserts are done without reallocating... for i in 0..10 { obj_pool.insert(i); } assert_eq!(obj_pool.capacity(), 10); // ... but this one will reallocate. obj_pool.insert(11); assert!(obj_pool.capacity() > 10);
pub fn capacity(&self) -> usize
[src]
pub fn capacity(&self) -> usize
Returns the number of slots in the object pool.
Examples
use obj_pool::ObjPool; let obj_pool: ObjPool<i32> = ObjPool::with_capacity(10); assert_eq!(obj_pool.capacity(), 10);
pub fn len(&self) -> u32
[src]
pub fn len(&self) -> u32
Returns the number of occupied slots in the object pool.
Examples
use obj_pool::ObjPool; let mut obj_pool = ObjPool::new(); assert_eq!(obj_pool.len(), 0); for i in 0..10 { obj_pool.insert(()); assert_eq!(obj_pool.len(), i + 1); }
pub fn is_empty(&self) -> bool
[src]
pub fn is_empty(&self) -> bool
Returns true
if all slots are vacant.
Examples
use obj_pool::ObjPool; let mut obj_pool = ObjPool::new(); assert!(obj_pool.is_empty()); obj_pool.insert(1); assert!(!obj_pool.is_empty());
pub fn next_vacant(&mut self) -> ObjId
[src]
pub fn next_vacant(&mut self) -> ObjId
Returns the ObjId
of the next inserted object if no other
mutating calls take place in between.
Examples
use obj_pool::ObjPool; let mut obj_pool = ObjPool::new(); let a = obj_pool.next_vacant(); let b = obj_pool.insert(1); assert_eq!(a, b); let c = obj_pool.next_vacant(); let d = obj_pool.insert(2); assert_eq!(c, d);
pub fn insert(&mut self, object: T) -> ObjId
[src]
pub fn insert(&mut self, object: T) -> ObjId
Inserts an object into the object pool and returns the ObjId
of this object.
The object pool will reallocate if it's full.
Examples
use obj_pool::ObjPool; let mut obj_pool = ObjPool::new(); let a = obj_pool.insert(1); let b = obj_pool.insert(2); assert!(a != b);
pub fn remove(&mut self, obj_id: ObjId) -> Option<T>
[src]
pub fn remove(&mut self, obj_id: ObjId) -> Option<T>
Removes the object stored by ObjId
from the object pool and returns it.
None
is returned in case the there is no object with such an ObjId
.
Examples
use obj_pool::ObjPool; let mut obj_pool = ObjPool::new(); let a = obj_pool.insert("hello"); assert_eq!(obj_pool.len(), 1); assert_eq!(obj_pool.remove(a), Some("hello")); assert_eq!(obj_pool.len(), 0); assert_eq!(obj_pool.remove(a), None);
pub fn clear(&mut self)
[src]
pub fn clear(&mut self)
Clears the object pool, removing and dropping all objects it holds. Keeps the allocated memory for reuse.
Examples
use obj_pool::ObjPool; let mut obj_pool = ObjPool::new(); for i in 0..10 { obj_pool.insert(i); } assert_eq!(obj_pool.len(), 10); obj_pool.clear(); assert_eq!(obj_pool.len(), 0);
pub fn get(&self, obj_id: ObjId) -> Option<&T>
[src]
pub fn get(&self, obj_id: ObjId) -> Option<&T>
Returns a reference to the object by its ObjId
.
If object is not found with given obj_id
, None
is returned.
Examples
use obj_pool::ObjPool; let mut obj_pool = ObjPool::new(); let obj_id = obj_pool.insert("hello"); assert_eq!(obj_pool.get(obj_id), Some(&"hello")); obj_pool.remove(obj_id); assert_eq!(obj_pool.get(obj_id), None);
pub fn get_mut(&mut self, obj_id: ObjId) -> Option<&mut T>
[src]
pub fn get_mut(&mut self, obj_id: ObjId) -> Option<&mut T>
Returns a mutable reference to the object by its ObjId
.
If object can't be found, None
is returned.
Examples
use obj_pool::ObjPool; let mut obj_pool = ObjPool::new(); let obj_id = obj_pool.insert(7); assert_eq!(obj_pool.get_mut(obj_id), Some(&mut 7)); *obj_pool.get_mut(obj_id).unwrap() *= 10; assert_eq!(obj_pool.get_mut(obj_id), Some(&mut 70));
pub unsafe fn get_unchecked(&self, obj_id: ObjId) -> &T
[src]
pub unsafe fn get_unchecked(&self, obj_id: ObjId) -> &T
Returns a reference to the object by its ObjId
.
Safety
Behavior is undefined if object can't be found.
Examples
use obj_pool::ObjPool; let mut obj_pool = ObjPool::new(); let obj_id = obj_pool.insert("hello"); unsafe { assert_eq!(&*obj_pool.get_unchecked(obj_id), &"hello") }
pub unsafe fn get_unchecked_mut(&mut self, obj_id: ObjId) -> &mut T
[src]
pub unsafe fn get_unchecked_mut(&mut self, obj_id: ObjId) -> &mut T
Returns a mutable reference to the object by its ObjId
.
Safety
Behavior is undefined if object can't be found.
Examples
use obj_pool::ObjPool; let mut obj_pool = ObjPool::new(); let obj_id = obj_pool.insert("hello"); unsafe { assert_eq!(&*obj_pool.get_unchecked_mut(obj_id), &"hello") }
pub fn swap(&mut self, a: ObjId, b: ObjId)
[src]
pub fn swap(&mut self, a: ObjId, b: ObjId)
Swaps two objects in the object pool.
The two ObjId
s are a
and b
.
Panics
Panics if any of the ObjId
s is invalid.
Examples
use obj_pool::ObjPool; let mut obj_pool = ObjPool::new(); let a = obj_pool.insert(7); let b = obj_pool.insert(8); obj_pool.swap(a, b); assert_eq!(obj_pool.get(a), Some(&8)); assert_eq!(obj_pool.get(b), Some(&7));
pub fn reserve(&mut self, additional: u32)
[src]
pub fn reserve(&mut self, additional: u32)
Reserves capacity for at least additional
more objects to be inserted. The object pool may
reserve more space to avoid frequent reallocations.
Panics
Panics if the new capacity overflows u32
.
Examples
use obj_pool::ObjPool; let mut obj_pool = ObjPool::new(); obj_pool.insert("hello"); obj_pool.reserve(10); assert!(obj_pool.capacity() >= 11);
pub fn reserve_exact(&mut self, additional: u32)
[src]
pub fn reserve_exact(&mut self, additional: u32)
Reserves the minimum capacity for exactly additional
more objects to be inserted.
Note that the allocator may give the object pool more space than it requests.
Panics
Panics if the new capacity overflows u32
.
Examples
use obj_pool::ObjPool; let mut obj_pool = ObjPool::new(); obj_pool.insert("hello"); obj_pool.reserve_exact(10); assert!(obj_pool.capacity() >= 11);
pub fn shrink_to_fit(&mut self)
[src]
pub fn shrink_to_fit(&mut self)
Shrinks the capacity of the object pool as much as possible.
It will drop down as close as possible to the length but the allocator may still inform the object pool that there is space for a few more elements.
Examples
use obj_pool::ObjPool; let mut obj_pool = ObjPool::with_capacity(10); obj_pool.insert("first".to_string()); obj_pool.insert("second".to_string()); obj_pool.insert("third".to_string()); assert_eq!(obj_pool.capacity(), 10); obj_pool.shrink_to_fit(); assert!(obj_pool.capacity() >= 3);
Trait Implementations
impl<T> Debug for ObjPool<T>
[src]
impl<T> Debug for ObjPool<T>
fn fmt(&self, f: &mut Formatter) -> Result
[src]
fn fmt(&self, f: &mut Formatter) -> Result
Formats the value using the given formatter. Read more
impl<T> Index<ObjId> for ObjPool<T>
[src]
impl<T> Index<ObjId> for ObjPool<T>
type Output = T
The returned type after indexing.
fn index(&self, obj_id: ObjId) -> &T
[src]
fn index(&self, obj_id: ObjId) -> &T
Performs the indexing (container[index]
) operation.
impl<T> IndexMut<ObjId> for ObjPool<T>
[src]
impl<T> IndexMut<ObjId> for ObjPool<T>
fn index_mut(&mut self, obj_id: ObjId) -> &mut T
[src]
fn index_mut(&mut self, obj_id: ObjId) -> &mut T
Performs the mutable indexing (container[index]
) operation.
impl<T> Default for ObjPool<T>
[src]
impl<T> Default for ObjPool<T>
impl<T: Clone> Clone for ObjPool<T>
[src]
impl<T: Clone> Clone for ObjPool<T>
fn clone(&self) -> Self
[src]
fn clone(&self) -> Self
Returns a copy of the value. Read more
fn clone_from(&mut self, source: &Self)
1.0.0[src]
fn clone_from(&mut self, source: &Self)
Performs copy-assignment from source
. Read more
impl<T> FromIterator<T> for ObjPool<T>
[src]
impl<T> FromIterator<T> for ObjPool<T>
fn from_iter<U: IntoIterator<Item = T>>(iter: U) -> ObjPool<T>
[src]
fn from_iter<U: IntoIterator<Item = T>>(iter: U) -> ObjPool<T>
Creates a value from an iterator. Read more