easy-pool 0.2.7

An easy way to reuse your objects without reallocating memory every time.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

use std::sync::Arc;

use easy_pool::{Clear, EasyPoolMutex, PoolMutex};

// It will create the pool and create the functions T::create_with & T::create.
// This derive is optional but you have to create the pool yourself.
// Like this : let pool = Arc::new(PoolMutex::with_config(1024, 1024));.
#[derive(EasyPoolMutex, Default)]
struct Test {
    pets: Vec<String>,
}

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

fn main() {
    // Easiest way.
    let mut test = Test::create_with(|| Test {
        pets: Vec::with_capacity(100),
    });
    assert_eq!(test.pets.capacity(), 100);
    test.pets.push("Cat".to_string());
    assert_eq!(test.pets.first().unwrap(), "Cat");
    test.pets.extend(vec!["Dog".to_string(); 100]);
    assert_eq!(test.pets.len(), 101);
    assert_eq!(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);
}