mio-example.rs

extern crate mio;

use std::io::Read;

use mio::*;
use mio::tcp::{TcpListener, TcpStream};
use mio::buf::ByteBuf;

struct MyHandler {
    listener: NonBlock<TcpListener>,
    clients: Vec<NonBlock<TcpStream>>
}

impl MyHandler {
    fn new(listener: NonBlock<TcpListener>) -> MyHandler {
        MyHandler {
            listener: listener,
            clients: Vec::new()
        }
    }
}

impl Handler for MyHandler {
    type Timeout = ();
    type Message = ();

    fn readable(&mut self, event_loop: &mut EventLoop<MyHandler>, token: Token, _: ReadHint) {
        match token {
            Token(0) => {
                // accept the client
                let client = self.listener.accept().unwrap().unwrap();
                // this is client's ID
                let i = self.clients.len()+1;
                event_loop.register(&client, Token(i));
                // store it with the others
                self.clients.push(client);

                println!("Client {} connected!", i);
            }
            Token(i) => {
                let client = &mut self.clients[i-1];
                let mut buffer = ByteBuf::mut_with_capacity(1024);
                match client.read(&mut buffer) {
                    Ok(_) => {
                        let mut buf = buffer.flip();
                        let mut text = String::new();
                        buf.read_to_string(&mut text);
                        println!("Received for {}: {}", i, text);
                    },
                    Err(e) => println!("Error: {:?}",e)
                }
            }
        }
    }
}

pub fn main() {
    println!("Running server on 127.0.0.1:13265");
    let addr = "127.0.0.1:13265".parse().unwrap();

    // Setup the server socket
    let server = tcp::listen(&addr).unwrap();

    // Create an event loop
    let mut event_loop = EventLoop::new().unwrap();

    // Start listening for incoming connections
    event_loop.register(&server, Token(0)).unwrap();

    // Start handling events
    event_loop.run(&mut MyHandler::new(server)).unwrap();
}