[go: up one dir, main page]

protobuf 3.7.2

Rust implementation of Google protocol buffers
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
141
142
143
144
145
146
147
148
149
150
151
152
153
154

use crate::fixed::ProtobufFixed;
use crate::rt::compute_raw_varint32_size;
use crate::rt::tag_size;
use crate::varint::generic::ProtobufVarint;
use crate::zigzag::ProtobufVarintZigzag;
use crate::Enum;
use crate::EnumOrUnknown;

/// Size of serialized repeated packed field, excluding length and tag.
pub(crate) fn vec_packed_varint_data_size<T: ProtobufVarint>(vec: &[T]) -> u64 {
    vec.iter().map(|v| v.len_varint() as u64).sum()
}

/// Size of serialized repeated packed field, excluding length and tag.
pub(crate) fn vec_packed_varint_zigzag_data_size<T: ProtobufVarintZigzag>(vec: &[T]) -> u64 {
    vec.iter().map(|v| v.len_varint_zigzag()).sum()
}

/// Size of serialized repeated packed enum field, excluding length and tag.
pub(crate) fn vec_packed_enum_or_unknown_data_size<E: Enum>(vec: &[EnumOrUnknown<E>]) -> u64 {
    vec.iter()
        .map(|e| compute_raw_varint32_size(e.value() as u32))
        .sum()
}

/// Size of serialized data with length prefix and tag
#[inline]
fn vec_packed_varint_size<T: ProtobufVarint>(field_number: u32, vec: &[T]) -> u64 {
    if vec.is_empty() {
        0
    } else {
        let data_size = vec_packed_varint_data_size(vec);
        tag_size(field_number) + data_size.len_varint() + data_size
    }
}

/// Size of serialized data with length prefix and tag.
#[inline]
pub fn vec_packed_int32_size(field_number: u32, vec: &[i32]) -> u64 {
    vec_packed_varint_size(field_number, vec)
}

/// Size of serialized data with length prefix and tag.
#[inline]
pub fn vec_packed_int64_size(field_number: u32, vec: &[i64]) -> u64 {
    vec_packed_varint_size(field_number, vec)
}

/// Size of serialized data with length prefix and tag.
#[inline]
pub fn vec_packed_uint32_size(field_number: u32, vec: &[u32]) -> u64 {
    vec_packed_varint_size(field_number, vec)
}

/// Size of serialized data with length prefix and tag.
#[inline]
pub fn vec_packed_uint64_size(field_number: u32, vec: &[u64]) -> u64 {
    vec_packed_varint_size(field_number, vec)
}

/// Size of serialized data with length prefix and tag
#[inline]
fn vec_packed_varint_zigzag_size<T: ProtobufVarintZigzag>(field_number: u32, vec: &[T]) -> u64 {
    if vec.is_empty() {
        0
    } else {
        let data_size = vec_packed_varint_zigzag_data_size(vec);
        tag_size(field_number) + data_size.len_varint() + data_size
    }
}

/// Size of serialized data with length prefix and tag.
#[inline]
pub fn vec_packed_sint32_size(field_number: u32, vec: &[i32]) -> u64 {
    vec_packed_varint_zigzag_size(field_number, vec)
}

/// Size of serialized data with length prefix and tag.
#[inline]
pub fn vec_packed_sint64_size(field_number: u32, vec: &[i64]) -> u64 {
    vec_packed_varint_zigzag_size(field_number, vec)
}

/// Size of serialized data with length prefix and tag
#[inline]
pub fn vec_packed_enum_or_unknown_size<E: Enum>(
    field_number: u32,
    vec: &[EnumOrUnknown<E>],
) -> u64 {
    if vec.is_empty() {
        0
    } else {
        let data_size = vec_packed_enum_or_unknown_data_size(vec);
        tag_size(field_number) + data_size.len_varint() + data_size
    }
}

/// Compute data size of fixed encoding of repeated field data.
pub(crate) fn vec_packed_fixed_data_size<V: ProtobufFixed>(vec: &[V]) -> u64 {
    (vec.len() as u64) * (V::LEN as u64)
}

/// Compute field size (data plus header) of fixed encoding of repeated field.
#[inline]
fn vec_packed_fixed_size<V: ProtobufFixed>(field_number: u32, vec: &[V]) -> u64 {
    if vec.is_empty() {
        0
    } else {
        let data_size = vec_packed_fixed_data_size::<V>(vec);
        tag_size(field_number) + data_size.len_varint() + data_size
    }
}

/// Compute data size of fixed encoding of repeated field data.
#[inline]
pub fn vec_packed_fixed32_size(field_number: u32, vec: &[u32]) -> u64 {
    vec_packed_fixed_size(field_number, vec)
}

/// Compute data size of fixed encoding of repeated field data.
#[inline]
pub fn vec_packed_fixed64_size(field_number: u32, vec: &[u64]) -> u64 {
    vec_packed_fixed_size(field_number, vec)
}

/// Compute data size of fixed encoding of repeated field data.
#[inline]
pub fn vec_packed_sfixed32_size(field_number: u32, vec: &[i32]) -> u64 {
    vec_packed_fixed_size(field_number, vec)
}

/// Compute data size of fixed encoding of repeated field data.
#[inline]
pub fn vec_packed_sfixed64_size(field_number: u32, vec: &[i64]) -> u64 {
    vec_packed_fixed_size(field_number, vec)
}

/// Compute data size of fixed encoding of repeated field data.
#[inline]
pub fn vec_packed_float_size(field_number: u32, vec: &[f32]) -> u64 {
    vec_packed_fixed_size(field_number, vec)
}

/// Compute data size of fixed encoding of repeated field data.
#[inline]
pub fn vec_packed_double_size(field_number: u32, vec: &[f64]) -> u64 {
    vec_packed_fixed_size(field_number, vec)
}

/// Compute data size of fixed encoding of repeated field data.
#[inline]
pub fn vec_packed_bool_size(field_number: u32, vec: &[bool]) -> u64 {
    vec_packed_fixed_size(field_number, vec)
}