Kincir Examples

These examples demonstrate how to use Kincir in different scenarios. Each example includes full source code and explanations.

Basic Examples

Simple Echo Service

This example shows how to create a basic echo service using Kincir. It creates a router that responds to text messages by sending back the same text.

use kincir::{Router, Message, Handle};
use std::sync::Arc;

// Define a message type
#[derive(Debug)]
struct TextMessage(String);

// Define a handler
fn handle_text(msg: TextMessage) {
    println!("Received text: {}", msg.0);
}

fn main() {
    // Create a router
    let mut router = Router::new();
    
    // Register a handler
    router.on::<TextMessage, _>(handle_text);
    
    // Send a message
    router.send(TextMessage(String::from("Hello, Kincir!")));
}

Using Middleware

Middleware allows you to intercept and process messages before and after they reach their handlers.

use kincir::{Router, Message, Handle, middleware::Middleware, Next};

// Define a message type
#[derive(Debug)]
struct TextMessage(String);

// Create a logging middleware
fn logging_middleware<M: Message>(msg: M, next: Next<M>) {
    println!("📥 Before handling message");
    next(msg); // Pass the message to the next middleware or handler
    println!("📤 After handling message");
}

// Define a handler
fn handle_text(msg: TextMessage) {
    println!("Processing message: {}", msg.0);
}

fn main() {
    // Create a router
    let mut router = Router::new();
    
    // Register middleware (applied to all message types)
    router.use_middleware(logging_middleware);
    
    // Register a handler
    router.on::<TextMessage, _>(handle_text);
    
    // Send a message - middleware will be called first
    router.send(TextMessage(String::from("Hello with middleware!")));
}

Advanced Examples

Broadcast Service

This example demonstrates how to create a broadcast service that sends messages to multiple receivers.

use kincir::{Router, Message, Handle};
use std::sync::Arc;

// Define a broadcast message type
#[derive(Debug, Clone)]
struct BroadcastMessage(String);

// Define handlers for different receivers
fn receiver_one(msg: BroadcastMessage) {
    println!("Receiver One got: {}", msg.0);
}

fn receiver_two(msg: BroadcastMessage) {
    println!("Receiver Two got: {}", msg.0);
}

fn main() {
    // Create a router
    let mut router = Router::new();
    
    // Register multiple handlers for the same message type
    router.on::<BroadcastMessage, _>(receiver_one);
    router.on::<BroadcastMessage, _>(receiver_two);
    
    // Send a message - both handlers will be called
    router.send(BroadcastMessage(String::from("This is a broadcast!")));
}