rust_asio 0.3.1

Asynchronous I/O library
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

use std::io;
use std::sync::Arc;
use std::marker::PhantomData;
use {IoService, Handler};

/// The binding Arc<T> handler.
pub struct ArcHandler<T, F, R> {
    owner: Arc<T>,
    handler: F,
    marker: PhantomData<R>,
}

impl<T, F, R> Handler<R> for ArcHandler<T, F, R>
    where T: Send + Sync + 'static,
          F: FnOnce(Arc<T>, io::Result<R>, &IoService) + Send + 'static,
          R: Send + 'static,
{
    fn callback(self, io: &IoService, res: io::Result<R>) {
        let ArcHandler { owner, handler, marker:_ } = self;
        handler(owner, res, io)
    }
}

/// Provides a primitive handler to asynchronous operation.
///
/// # Examples.
///
/// ```
/// use std::sync::Arc;
/// use asio::{IoService, ArcHandler, bind};
/// use asio::ip::{Tcp, TcpSocket, TcpListener};
///
/// let io = &IoService::new();
/// let soc = Arc::new(TcpListener::new(io, Tcp::v4()).unwrap());
/// soc.async_accept(bind(|soc, res, _: &IoService| {
///   let _: Arc<TcpListener> = soc;
///
///   if let Ok((acc, ep)) = res {
///     let _: TcpSocket = acc;
///     println!("accepted {}", ep)
///   }
/// }, &soc));
/// ```
pub fn bind<T, F, R>(handler: F, owner: &Arc<T>) -> ArcHandler<T, F, R> {
    ArcHandler {
        owner: owner.clone(),
        handler: handler,
        marker: PhantomData,
    }
}