Struct dynamic_pool::DynamicPoolItem

pub struct DynamicPoolItem<T: DynamicReset> { /* private fields */ }

an object, checked out from a dynamic pool object.

Implementations

impl<T: DynamicReset> DynamicPoolItem<T>

pub fn detach(self) -> T

detaches this instance from the pool, returns T.

Examples found in repository

examples/simple.rs (line 53)

fn main() {
    // Creates a new pool that will hold at most 10 items, starting with 1 item by default.
    let pool = DynamicPool::new(1, 10, Person::default);
    // Assert we have one item in the pool.
    assert_eq!(pool.available(), 1);

    // Take an item from the pool.
    let mut person = pool.take();
    person.name = "jake".into();
    person.age = 99;

    // Assert the pool is empty since we took the person above.
    assert_eq!(pool.available(), 0);
    // Dropping returns the item to the pool.
    drop(person);
    // We now have stuff available in the pool to take.
    assert_eq!(pool.available(), 1);

    // Take person from the pool again, it should be reset.
    let person = pool.take();
    assert_eq!(person.name, "");
    assert_eq!(person.age, 0);

    // Nothing is in the queue.
    assert_eq!(pool.available(), 0);
    // try_take returns an Option. Since the pool is empty, nothing will be created.
    assert!(pool.try_take().is_none());
    // Dropping again returns the person to the pool.
    drop(person);
    // We have stuff in the pool now!
    assert_eq!(pool.available(), 1);

    // try_take would succeed here!
    let person = pool.try_take().unwrap();

    // We can also then detach the `person` from the pool, meaning it won't get
    // recycled.
    let person = person.detach();
    // We can then drop that person, and see that it's not returned to the pool.
    drop(person);
    assert_eq!(pool.available(), 0);
}

Trait Implementations

impl<T: DynamicReset> AsRef<T> for DynamicPoolItem<T>

fn as_ref(&self) -> &T

Converts this type into a shared reference of the (usually inferred) input type.

impl<T: Debug + DynamicReset> Debug for DynamicPoolItem<T>

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

Formats the value using the given formatter.

impl<T: DynamicReset> Deref for DynamicPoolItem<T>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &T

Dereferences the value.

impl<T: DynamicReset> DerefMut for DynamicPoolItem<T>

fn deref_mut(&mut self) -> &mut T

Mutably dereferences the value.

impl<T: DynamicReset> Drop for DynamicPoolItem<T>

fn drop(&mut self)

Executes the destructor for this type.