corona 0.4.3

Coroutine and Async/Await support for tokio-based futures
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

use std::cell::RefCell;
use std::collections::HashMap;

use context::stack::ProtectedFixedSizeStack;

use errors::StackError;

thread_local! {
    static CACHE: RefCell<HashMap<usize, Vec<ProtectedFixedSizeStack>>> =
        RefCell::new(HashMap::new());
}

/// Get a stack of the given size.
///
/// Retrieve it from the cache or create a new one, if none is available.
///
/// The cache is thread local.
pub(crate) fn get(size: usize) -> Result<ProtectedFixedSizeStack, StackError> {
    CACHE.with(|c| {
        let mut cell = c.borrow_mut();
        cell.get_mut(&size)
            .and_then(|v| v.pop().map(Ok))
            .unwrap_or_else(|| {
                ProtectedFixedSizeStack::new(size)
            })
    })
}

/// Put a stack into the cache, for future reuse.
///
/// The cache is thread local and the stack will be returned in some future
/// [`get`](function.get.html) call.
pub(crate) fn put(stack: ProtectedFixedSizeStack) {
    let len = stack.len();
    CACHE.with(|c| c.borrow_mut().entry(len).or_insert_with(Vec::new).push(stack));
}