npsd 0.2.0

Network payload serializer / deserializer framework
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

#[cfg(feature = "sync")]
use npsd::{Payload, IntoPayload, FromPayload, Middleware, PayloadInfo, Error};

#[cfg(feature = "sync")]
#[derive(Clone, PartialEq, Debug)]
enum ContextUnwrap {
    Void,
    Usize(usize),
}

#[cfg(feature = "sync")]
#[derive(Clone, PartialEq, Debug)]
struct CheckContext {
    sender: Option<ContextUnwrap>,
    receiver: Option<ContextUnwrap>,
} 

#[cfg(feature = "sync")]
impl IntoPayload<usize> for ContextUnwrap {
    fn into_payload<'a, M: Middleware<'a>>(&self, ctx: &mut usize, next: &mut M) -> Result<(), Error> {
        match self {
            ContextUnwrap::Void => next.into_payload(&0u8, ctx),
            ContextUnwrap::Usize(value) => {
                next.into_payload(&1u8, ctx)?;
                next.into_payload(&(value + *ctx), ctx)
            }
        }
    }
}

#[cfg(feature = "sync")]
impl<'a> FromPayload<'a, usize> for ContextUnwrap {
    fn from_payload<M: Middleware<'a>>(ctx: &mut usize, next: &mut M) -> Result<Self, Error> {
        match next.from_payload::<usize, u8>(ctx)? {
            0 => {
                Ok(ContextUnwrap::Void)
            },
            1 => {
                Ok(ContextUnwrap::Usize(next.from_payload::<usize, usize>(ctx)? + *ctx))
            },
            _ => {
                panic!("Unknown type!!!");
            }
        }
    }
}

#[cfg(feature = "sync")]
impl<'a> Payload<'a, usize> for ContextUnwrap {}

#[cfg(feature = "sync")]
impl PayloadInfo for ContextUnwrap {
    const TYPE: &'static str = "ContextUnwrap";
}

#[cfg(feature = "sync")]
impl IntoPayload<usize> for CheckContext {
    fn into_payload<'a, M: Middleware<'a>>(&self, ctx: &mut usize, next: &mut M) -> Result<(), Error> {
        let mut this = self.clone();

        this.sender = Some(ContextUnwrap::Usize(*ctx));

        next.into_payload(&this.sender, ctx)?;
        next.into_payload(&this.receiver, ctx)
    }
}

#[cfg(feature = "sync")]
impl<'a> FromPayload<'a, usize> for CheckContext {
    fn from_payload<M: Middleware<'a>>(ctx: &mut usize, next: &mut M) -> Result<Self, Error> {
        Ok(CheckContext {
            sender: next.from_payload(ctx)?,
            receiver: Some(ContextUnwrap::Usize(*ctx))
        })
    }
}

#[cfg(feature = "sync")]
impl<'a> Payload<'a, usize> for CheckContext {}

#[cfg(feature = "sync")]
impl PayloadInfo for CheckContext {
    const TYPE: &'static str = "ContextUnwrap";
}

#[cfg(feature = "sync")]
#[test]
fn test_context_unwrap() -> Result<(), Error> {
    use pretty_hex::PrettyHex;

    #[cfg(feature = "info")]
    use npsd::NextTrace;

    #[cfg(not(feature = "info"))]
    use npsd::Next;

    // Create Middleware
    #[cfg(not(feature = "info"))]
    let mut next = Next::default();

    #[cfg(feature = "info")]
    let mut next = NextTrace::default();

    let mut sender_ctx = 1337usize;

    CheckContext {
        sender: None,
        receiver: None,
    }.into_packet(&mut sender_ctx, &mut next)?;

    println!("Encoded: {:?}", next.serialized().hex_dump());

    let mut receiver_ctx = 42usize;
    let deserialized = CheckContext::from_packet(&mut receiver_ctx, &mut next)?;    

    assert_eq!(deserialized, CheckContext {
        sender: Some(ContextUnwrap::Usize(sender_ctx * 2 + receiver_ctx)),
        receiver: Some(ContextUnwrap::Usize(receiver_ctx)),
    });

    dbg!(deserialized);

    Ok(())
}