bissel 0.2.0

Robotics-focused publish-subscribe/request-reply middleware for embedded Linux
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

use postcard::*;
extern crate alloc;
use alloc::vec::Vec;
use serde::{Deserialize, Serialize};

#[derive(Debug, Serialize, Deserialize)]
struct WrappedU8 {
    val: u8,
}

#[derive(Debug, Serialize, Deserialize)]
struct StringAndU8 {
    a: String,
    val: u8,
}

#[derive(Debug, Serialize, Deserialize)]
struct StringAndIsize {
    a: String,
    val: isize,
}

#[derive(Debug, Serialize, Deserialize)]
struct TwoIsizes {
    a: isize,
    b: isize,
}

#[test]
fn test_postcard_u8() {
    let val = WrappedU8 { val: 1 };
    let bytes: Vec<u8> = to_allocvec(&val).unwrap();
    println!("value: {:?}", bytes);
    let result: WrappedU8 = from_bytes(&bytes).unwrap();
    dbg!(result);
}

#[test]
fn test_postcard_composite_w_u8() {
    let val = StringAndU8 {
        a: "hello".to_string(),
        val: 5,
    };
    let bytes: Vec<u8> = to_allocvec(&val).unwrap();
    println!("value: {:?}", bytes);
    let result: StringAndU8 = from_bytes(&bytes).unwrap();
    dbg!(result);
}

#[test]
fn test_postcard_composite_w_isize() {
    let val = StringAndIsize {
        a: "hello".to_string(),
        val: 0,
    };
    let bytes: Vec<u8> = to_allocvec(&val).unwrap();
    println!("value: {:?}", bytes);
    let result: StringAndIsize = from_bytes(&bytes).unwrap();
    dbg!(result);
}

#[test]
fn test_postcard_two_isizes() {
    let val = TwoIsizes { a: -1, b: 0 };
    let bytes: Vec<u8> = to_allocvec(&val).unwrap();
    println!("value: {:?}", bytes);
    let result: TwoIsizes = from_bytes(&bytes).unwrap();
    dbg!(result);
}

#[derive(Debug, Serialize, Deserialize)]
struct WrappedUsize {
    val: usize,
}

#[test]
fn test_postcard_usize() {
    let val = WrappedUsize { val: 0 };
    let bytes: Vec<u8> = to_allocvec(&val).unwrap();
    println!("value: {:?}", bytes);
    let result: WrappedUsize = from_bytes(&bytes).unwrap();
    dbg!(result);
}