rs-matter-stack 0.1.0

Utility for configuring and running rs-matter
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
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140

/// Re-export the `edge-nal` crate
pub use edge_nal::*;

/// The network stack used by `rs-matter-stack`
///
/// Depending on the platform and features enabled, the stack
/// might or might not support certain protocols.
pub trait NetStack {
    type UdpBind<'a>: UdpBind
    where
        Self: 'a;
    type UdpConnect<'a>: UdpConnect
    where
        Self: 'a;

    type TcpBind<'a>: TcpBind
    where
        Self: 'a;
    type TcpConnect<'a>: TcpConnect
    where
        Self: 'a;

    type Dns<'a>: Dns
    where
        Self: 'a;

    /// Return a UDP Bind implementation, if supported by the network stack
    fn udp_bind(&self) -> Option<Self::UdpBind<'_>>;

    /// Return a UDP Connect implementation, if supported by the network stack
    fn udp_connect(&self) -> Option<Self::UdpConnect<'_>>;

    /// Return a TCP Bind implementation, if supported by the network stack
    fn tcp_bind(&self) -> Option<Self::TcpBind<'_>>;

    /// Return a TCP Connect implementation, if supported by the network stack
    fn tcp_connect(&self) -> Option<Self::TcpConnect<'_>>;

    /// Return a DNS implementation, if supported by the network stack
    fn dns(&self) -> Option<Self::Dns<'_>>;
}

impl<T> NetStack for &T
where
    T: NetStack,
{
    type UdpBind<'a>
        = T::UdpBind<'a>
    where
        Self: 'a;
    type UdpConnect<'a>
        = T::UdpConnect<'a>
    where
        Self: 'a;

    type TcpBind<'a>
        = T::TcpBind<'a>
    where
        Self: 'a;
    type TcpConnect<'a>
        = T::TcpConnect<'a>
    where
        Self: 'a;

    type Dns<'a>
        = T::Dns<'a>
    where
        Self: 'a;

    fn udp_bind(&self) -> Option<Self::UdpBind<'_>> {
        (*self).udp_bind()
    }

    fn udp_connect(&self) -> Option<Self::UdpConnect<'_>> {
        (*self).udp_connect()
    }

    fn tcp_bind(&self) -> Option<Self::TcpBind<'_>> {
        (*self).tcp_bind()
    }

    fn tcp_connect(&self) -> Option<Self::TcpConnect<'_>> {
        (*self).tcp_connect()
    }

    fn dns(&self) -> Option<Self::Dns<'_>> {
        (*self).dns()
    }
}

/// Re-export the `edge-nal-std` crate
#[cfg(feature = "std")]
pub mod std {
    pub use edge_nal_std::*;

    impl super::NetStack for Stack {
        type UdpBind<'a>
            = &'a Stack
        where
            Self: 'a;
        type UdpConnect<'a>
            = &'a Stack
        where
            Self: 'a;

        type TcpBind<'a>
            = &'a Stack
        where
            Self: 'a;
        type TcpConnect<'a>
            = &'a Stack
        where
            Self: 'a;

        type Dns<'a>
            = &'a Stack
        where
            Self: 'a;

        fn udp_bind(&self) -> Option<Self::UdpBind<'_>> {
            Some(self)
        }

        fn udp_connect(&self) -> Option<Self::UdpConnect<'_>> {
            Some(self)
        }

        fn tcp_bind(&self) -> Option<Self::TcpBind<'_>> {
            Some(self)
        }

        fn tcp_connect(&self) -> Option<Self::TcpConnect<'_>> {
            Some(self)
        }

        fn dns(&self) -> Option<Self::Dns<'_>> {
            Some(self)
        }
    }
}