swimming

swimming is a no_std, no_alloc, high-performance, asynchronous, thread-safe, and fair connection pooling crate for Rust. It provides a simple and efficient way to manage and reuse connections in your applications.

Features

• no_std and no_alloc compatibility
• High performance with lazy and eager connection initialization
• Asynchronous and thread-safe operations
• Fair connection retrieval mechanism
• Flexible and extensible design
• Robust error handling
• Environment agnostic

Installation

To use swimming in your Rust project, add the following to your Cargo.toml file:

[dependencies]
swimming = "0.1.3"

Usage

Here's a simple example of how to use swimming:

use swimming::{Pool, Connection};
use std::net::SocketAddr;

struct MyConnection;

impl Connection for MyConnection {
    type Context = SocketAddr;
    type Error = ();

    async fn create(_ctx: &SocketAddr) -> Result<Self, Self::Error> {
        Ok(MyConnection)
    }

    fn needs_health_check(&mut self, _ctx: &SocketAddr) -> bool {
        false
    }

    async fn health_check(&mut self, _ctx: &SocketAddr) -> Result<(), ()> {
        Ok(())
    }
}

async fn example() {
    // create the pool providing the context, in general usage this would be details primarily pertinent to creating
    // the connection. 
    let pool = Pool::<MyConnection, 10>::new("127.0.0.1:8080".parse().unwrap());

    let conn = pool.get().await.unwrap();
    // Use the connection...
}

For more detailed usage examples and API documentation, please refer to the Pool's documentation.

License

This crate is licensed under the MIT or Apache 2.0 license at your preference.