toml [dependencies] easy-pool = "0.2.5"

An easy way to reuse your objects without reallocating memory every time.

Simple example

```rust, no_run use std::sync::Arc;

use easypool::{Clear, PoolMutex}; use easypoolprocmacro::EasyPoolMutex;

// It will create the pool and create the functions T::createwith & T::create. // This derive is optional but you have to create the pool yourself. // Like this : let pool = Arc::new(PoolMutex::withconfig(1024, 1024));.

[derive(EasyPoolMutex, Default)]

struct Test { pets: Vec, }

impl Clear for Test { fn clear(&mut self) { self.pets.clear(); } }

fn main() { // Easiest way. let mut test = Test::createwith(|| Test { pets: Vec::withcapacity(100), }); asserteq!(test.pets.capacity(), 100); test.pets.push("Cat".tostring()); asserteq!(test.pets.first().unwrap(), "Cat"); test.pets.extend(vec!["Dog".tostring(); 100]); asserteq!(test.pets.len(), 101); asserteq!(test.pets.capacity(), 200); drop(test);

// The function create will reuse the old "test".
let test = Test::create_with(|| Test {
    pets: Vec::with_capacity(100),
});
assert_eq!(test.pets.len(), 0);
assert_eq!(test.pets.capacity(), 200);

// Or more complex.
let pool = Arc::new(PoolMutex::with_config(1024, 1024));
let result = pool.create_with(|| Test {
    pets: Vec::with_capacity(100),
});
assert_eq!(result.pets.capacity(), 100);

} ```