rustwave 0.1.0

//! RustWave
//!
//! A Lightweight async event-driven WebSocket framework for Rust.
//!
//! Features:
//! - Async event-driven WebSocket server and client.
//! - Rooms.
//! - Broadcasts.
//! - Typed Payloads.
//! - Easy to use.
//! - Async handlers powered by Tokio.
//!
//!
//!
//! Example Server usage:
//! ```no_run
//! use rustwave::{Server, Result};
//!
//! #[tokio::main]
//! async fn main() -> Result<()> {
//!     let server = Server::bind("127.0.0.1:8080");
//!
//!     // Events on the root namespace("/")
//!     server.on("message", |data, ctx| async move {
//!         println!("Client {} say: {}", ctx.get_socket_id(), data);
//!     });
//!
//!     server.run().await?;
//!     Ok(())
//! }
//! ```
//!
//! Example Client usage:
//! ```no_run
//! use rustwave::{Client, Result};
//!
//! #[tokio::main]
//! async fn main() -> Result<()> {
//!     let client = Client::connect("ws://127.0.0.1:8080").await?;
//!     client.on("message", |data| async move {
//!         println!("Client got message: {}", data);
//!     });
//!     client.emit("message", "Hello Server!".to_string()).await?;
//!     client.wait().await;
//!     
//!     Ok(())
//! }
//! ```
//!
//! RustWave provides an event-based API for building real-time applications.
//!
//! # Benchmark
//!
//! ## Test Environment
//! - CPU: Intel(R) Core(TM) i3-3220 CPU @ 3.30GHz
//! - RAM: 4GB
//! - OS: Fedora Linux
//! - Rust Version: 1.94.0
//! - Build: `cargo run --release`
//!
//! ## Echo Benchmark
//!
//! Client: 10,000
//! Messages per client: 100
//! Total Messages: 1,000,000
//! Test Type: Echo
//!
//! ## Test Result
//! Message loss: 0
//! Total time: 8.88s
//! Throughput: **112,587 msgs/sec**
//!
//!

mod client;
mod peer;
mod server;
mod utils;

pub mod error;

pub use client::client::Client;
pub use error::{Result, RustWaveError};
pub use peer::peer_conext::PeerContext;
pub use server::namespace::Namespace;
pub use server::server::Server;
pub use utils::broadcast_builder::BroadcastBuilder;
pub use utils::send_data::Payload;