tsp_sdk 0.8.0

Rust implementation of the Trust Spanning Protocol
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

use super::ReceivedTspMessage;
use bytes::BytesMut;

// Rust, there has to be a better way.
impl<T: AsRef<[u8]>> ReceivedTspMessage<T> {
    /// Turn a ReceivedTspMessage that contains references to borrowed data into a freestanding version;
    /// if it already was a freestanding version, nothing happens.
    // We only offer this version as the 'public' version, since the second can be confusing
    pub fn into_owned(self) -> ReceivedTspMessage
    where
        T: Into<BytesMut>,
    {
        self.map(|x| x.into())
    }

    /// Convert the data representation used by a ReceivedTspMessage; we are careful with the payload data
    /// since it may be very large.
    pub(crate) fn map<U: AsRef<[u8]>>(self, f: impl Fn(T) -> U) -> ReceivedTspMessage<U> {
        use ReceivedTspMessage::*;
        match self {
            GenericMessage {
                sender,
                nonconfidential_data,
                message,
                message_type,
            } => GenericMessage {
                sender,
                nonconfidential_data: nonconfidential_data.map(&f),
                message: f(message),
                message_type,
            },
            RequestRelationship {
                sender,
                route,
                nested_vid,
                thread_id,
            } => RequestRelationship {
                sender,
                route,
                nested_vid,
                thread_id,
            },
            AcceptRelationship { sender, nested_vid } => AcceptRelationship { sender, nested_vid },
            CancelRelationship { sender } => CancelRelationship { sender },
            ForwardRequest {
                sender,
                next_hop,
                route,
                opaque_payload,
            } => ForwardRequest {
                sender,
                next_hop,
                route,
                opaque_payload,
            },
            NewIdentifier { sender, new_vid } => NewIdentifier { sender, new_vid },
            Referral {
                sender,
                referred_vid,
            } => Referral {
                sender,
                referred_vid,
            },
            #[cfg(feature = "async")]
            PendingMessage {
                unknown_vid,
                payload,
            } => PendingMessage {
                unknown_vid,
                payload,
            },
        }
    }
}