rustwire 0.2.0

A Rust library for efficient manipulation of encoded protocol buffer messages.
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

#![feature(test)]

extern crate test;

use prost::Message;
use rustwire::{create_header, extract_field_by_tag, replace_field_with, Variant};
use test::Bencher;

#[derive(Clone, Message, PartialEq)]
pub struct User {
    #[prost(string, tag = "1")]
    pub name: String,
    #[prost(int32, tag = "2")]
    pub id: i32,
    #[prost(string, tag = "3")]
    pub email: String,
}

#[derive(Clone, PartialEq, Message)]
pub struct ThisMessage {
    #[prost(int32, tag = "1")]
    pub field1: i32,
    #[prost(string, tag = "2")]
    pub field2: String,
    #[prost(uint64, tag = "3")]
    pub field3: u64,
    #[prost(bool, tag = "4")]
    pub field4: bool,

    // user field
    #[prost(message, tag = "5")]
    pub user: Option<User>,
}

#[derive(Clone, PartialEq, Message)]
pub struct OutMessage {
    #[prost(int32, tag = "1")]
    pub field1: i32,
    #[prost(string, tag = "2")]
    pub field2: String,
    #[prost(uint64, tag = "3")]
    pub field3: u64,
    #[prost(bool, tag = "4")]
    pub field4: bool,
    #[prost(int32, tag = "5")]
    pub user_id: i32,
}

pub fn default_message() -> ThisMessage {
    let default_string = "Lorem ipsum dolor sit amet, consectetur adipiscing elit.".repeat(10);
    let mut default_bytes = Vec::new();
    for i in 0..3397 {
        default_bytes.push(i as u8);
    }

    let user = User {
        name: "John Doe".to_string(),
        id: 12345,
        email: "john@doe.com".to_string(),
    };

    ThisMessage {
        field1: 42,
        field2: default_string,
        field3: 1234567890,
        field4: true,
        user: Some(user),
    }
}

fn prost_replace(encoded_message: &[u8]) -> Vec<u8> {
    let mut message = ThisMessage::decode(encoded_message).unwrap();
    let user = message.user.take().unwrap();
    let out_message = OutMessage {
        field1: message.field1,
        field2: message.field2,
        field3: message.field3,
        field4: message.field4,
        user_id: user.id,
    };

    let mut out_bytes = Vec::new();
    out_message.encode(&mut out_bytes).unwrap();
    out_bytes
}

fn rustwire_replace(encoded_message: &[u8], user_id: i32) -> Vec<u8> {
    // first read id from user field
    let user_field = extract_field_by_tag(encoded_message, 5).unwrap();
    let id = extract_field_by_tag(&user_field, 2).unwrap();

    let header = create_header(5, Variant::Varint.into(), &id);
    let replace_with = [header, user_id.to_le_bytes().to_vec()].concat();
    let result = replace_field_with(&mut encoded_message.to_vec(), 5, &replace_with).unwrap();
    result
}

// Benchmark for extracting a field using rustwire
#[bench]
fn bench_rustwire_replace(b: &mut Bencher) {
    let encoded_message = default_message().encode_to_vec();

    b.iter(|| {
        let result = extract_field_by_tag(&encoded_message, 5).unwrap();
        test::black_box(result);
    });
}

// Benchmark for deserializing the message and getting the field manually
#[bench]
fn bench_prost_replace(b: &mut Bencher) {
    let encoded_message = default_message().encode_to_vec();

    b.iter(|| {
        let result = prost_replace(&encoded_message);
        test::black_box(result);
    });
}