bach 0.1.2

Discrete-event simulation environment for async workflows
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
61
62
63
64
65
66
67
68
69
70
71
72

use crate::net::SocketAddr;
use core::task::{Context, Poll};
use std::io;

pub struct Socket<S, R> {
    inner: S,
    #[allow(dead_code)]
    reservation: R,
}

impl<S, R> Socket<S, R> {
    pub fn new(inner: S, reservation: R) -> Self {
        Self { inner, reservation }
    }
}

impl<S, R> super::Socket for Socket<S, R>
where
    S: super::Socket,
    R: 'static + Send + Sync,
{
    fn poll_connect(&self, cx: &mut Context, peer_addr: SocketAddr) -> Poll<io::Result<()>> {
        self.inner.poll_connect(cx, peer_addr)
    }

    fn peer_addr(&self) -> io::Result<SocketAddr> {
        self.inner.peer_addr()
    }

    fn local_addr(&self) -> io::Result<SocketAddr> {
        self.inner.local_addr()
    }

    fn poll_writable(&self, cx: &mut Context) -> Poll<io::Result<()>> {
        self.inner.poll_writable(cx)
    }

    fn poll_readable(&self, cx: &mut Context) -> Poll<io::Result<()>> {
        self.inner.poll_readable(cx)
    }

    fn set_sockopt(&self, option: super::Sockopt, value: usize) -> io::Result<()> {
        self.inner.set_sockopt(option, value)
    }

    fn get_sockopt(&self, option: super::Sockopt) -> io::Result<usize> {
        self.inner.get_sockopt(option)
    }

    fn sendmsg(
        &self,
        cx: Option<&mut Context>,
        destination: &SocketAddr,
        payload: &[io::IoSlice],
        opts: super::SendOptions,
    ) -> io::Result<usize> {
        self.inner.sendmsg(cx, destination, payload, opts)
    }

    fn recvmsg(
        &self,
        cx: Option<&mut Context>,
        payload: &mut [io::IoSliceMut],
        opts: super::RecvOptions,
    ) -> io::Result<super::RecvResult> {
        self.inner.recvmsg(cx, payload, opts)
    }

    fn shutdown(&self, how: std::net::Shutdown) -> io::Result<()> {
        self.inner.shutdown(how)
    }
}