Struct tokio_utils::Pool

pub struct Pool<T> { /* private fields */ }

A shared resource pool

Values are acquired using Pool::acquire and returned when the Guard is dropped.

Examples

use tub::Pool;
use std::net::UdpSocket;
#[tokio::main]
async fn main() {
 // Create a pool of UDP sockets
 let pool: Pool<UdpSocket> = (0..10)
      .map(|_| UdpSocket::bind("127.0.0.1:0").unwrap())
      .into();
  
  // Get a socket from the pool
  let mut socket = pool.acquire().await;
}

Implementations

impl<T> Pool<T>

pub async fn acquire(&self) -> impl Future<Output = Guard<T>>

Acquire a value from the pool.

The value is protected by a Guard

Examples

use tub::Pool;

#[tokio::main]
async fn main() {
   let pool: Pool<u32> = Pool::from_default(10);
   let mut box1 = pool.acquire().await;
   assert_eq!(pool.remaining_capacity(), 9);
   assert_eq!(*box1, u32::default());
}

pub fn remaining_capacity(&self) -> usize

Get the number of available values in the pool

Examples

use tub::Pool;
let pool = Pool::from_iter(0..10);
assert_eq!(pool.remaining_capacity(), 10);

pub fn from_vec(vec: Vec<T, Global>) -> Pool<T>

Create a new pool from a vector of values

Examples

use tub::Pool;
let pool = Pool::from_vec(vec![1, 2, 3]);

pub fn from_initializer<F>(capacity: usize, init: F) -> Pool<T>where F: Fn() -> T,

Create a new pool from an initializer.

The initializer is called once for each value in the pool.

Examples

use std::sync::atomic::AtomicUsize;
use std::sync::atomic::Ordering::SeqCst;
use tub::Pool;
let pool = Pool::from_initializer(10, || {
    static COUNTER: AtomicUsize = AtomicUsize::new(0);
    COUNTER.fetch_add(1, SeqCst);
});

pub fn from_iter<I>(iterable: I) -> Pool<T>where I: IntoIterator<Item = T>,

Create a new pool from an iterator

Examples

use tub::Pool;
let pool = Pool::from_iter(0..10);

impl<T> Pool<T>where T: Default,

pub fn from_default(capacity: usize) -> Pool<T>where T: Default,

Create a new pool with a default value

Examples

use tub::Pool;
let pool: Pool<u32> = Pool::from_default(10);

impl<T> Pool<T>where T: Copy,

pub fn from_copy(capacity: usize, value: T) -> Pool<T>where T: Copy,

Create a new pool with a copy of a value

Examples

use tub::Pool;
let pool = Pool::from_copy(10, 123);

impl<T> Pool<T>where T: Clone,

pub fn from_clone(capacity: usize, value: &T) -> Pool<T>where T: Clone,

Create a new pool with a clone of a value

Examples

use tub::Pool;
let pool = Pool::from_clone(10, &123);

Trait Implementations

impl<T> Clone for Pool<T>where T: Clone,

fn clone(&self) -> Pool<T>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T, I> From<I> for Pool<T>where T: Send + Sync + 'static, I: IntoIterator<Item = T>,

fn from(iter: I) -> Pool<T>

Examples

use tub::Pool;

#[tokio::main]
async fn main() {
  let pool: Pool<u32> = (0..10).into();
}