rustun 0.1.4

A library for implementing STUN server and client asynchronously
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
51
52
53
54
55
56
57
58
59
60

use std::net::SocketAddr;
use fibers::Spawn;
use fibers::net::TcpStream;
use fibers::net::futures::Connect;
use futures::{Future, Poll};

use {Client, Error};
use transport::TcpClientTransport;
use message::RawMessage;
use super::BaseClient;

/// `Future` that handle a request/response transaction issued by `TcpClient`.
pub type TcpCallRaw =
    <BaseClient<TcpClientTransport> as Client>::CallRaw;

/// `Future` that handle a indication transaction issued by `TcpClient`.
pub type TcpCastRaw =
    <BaseClient<TcpClientTransport> as Client>::CastRaw;

/// A [Client](trait.Client.html) trait implementation which
/// uses [TcpClientTransport](../transport/struct.TcpClientTransport.html) as the transport layer.
pub struct TcpClient(BaseClient<TcpClientTransport>);
impl TcpClient {
    /// Makes a future that results in a `TcpClient` instance which communicates with `server`.
    pub fn new<S: Spawn>(spawner: S, server: SocketAddr) -> InitTcpClient<S> {
        InitTcpClient {
            spawner: spawner,
            server: server,
            connect: TcpStream::connect(server),
        }
    }
}
impl Client for TcpClient {
    type CallRaw = TcpCallRaw;
    type CastRaw = TcpCastRaw;
    fn call_raw(&mut self, message: RawMessage) -> Self::CallRaw {
        self.0.call_raw(message)
    }
    fn cast_raw(&mut self, message: RawMessage) -> Self::CastRaw {
        self.0.cast_raw(message)
    }
}

/// `Future` that results in a `TcpClient` instance.
pub struct InitTcpClient<S> {
    spawner: S,
    server: SocketAddr,
    connect: Connect,
}
impl<S: Spawn> Future for InitTcpClient<S> {
    type Item = TcpClient;
    type Error = Error;
    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
        Ok(track_try!(self.connect.poll()).map(|stream| {
            TcpClient(BaseClient::new(&self.spawner,
                                      self.server,
                                      TcpClientTransport::new(self.server, stream)))
        }))
    }
}