Crate swimming 

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.

Structs

Pool

Enums

FreshOrPooled

FreshOrPooled Enum

Traits

Connection

Connection Management