/rust/registry/src/index.crates.io-6f17d22bba15001f/protobuf-3.2.0/src/rt/packed.rs

Source (jump to first uncovered line)
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)
}

Line	Count	Source (jump to first uncovered line)
1		use crate::fixed::ProtobufFixed;
2		use crate::rt::compute_raw_varint32_size;
3		use crate::rt::tag_size;
4		use crate::varint::generic::ProtobufVarint;
5		use crate::zigzag::ProtobufVarintZigzag;
6		use crate::Enum;
7		use crate::EnumOrUnknown;
8
9		/// Size of serialized repeated packed field, excluding length and tag.
10	0	pub(crate) fn vec_packed_varint_data_size<T: ProtobufVarint>(vec: &[T]) -> u64 {
11	0	vec.iter().map(\|v\| v.len_varint() as u64).sum() Unexecuted instantiation: protobuf::rt::packed::vec_packed_varint_data_size::<u32>::{closure#0} Unexecuted instantiation: protobuf::rt::packed::vec_packed_varint_data_size::<i64>::{closure#0} Unexecuted instantiation: protobuf::rt::packed::vec_packed_varint_data_size::<u64>::{closure#0} Unexecuted instantiation: protobuf::rt::packed::vec_packed_varint_data_size::<i32>::{closure#0}
12	0	} Unexecuted instantiation: protobuf::rt::packed::vec_packed_varint_data_size::<i64> Unexecuted instantiation: protobuf::rt::packed::vec_packed_varint_data_size::<u32> Unexecuted instantiation: protobuf::rt::packed::vec_packed_varint_data_size::<u64> Unexecuted instantiation: protobuf::rt::packed::vec_packed_varint_data_size::<i32>
13
14		/// Size of serialized repeated packed field, excluding length and tag.
15	0	pub(crate) fn vec_packed_varint_zigzag_data_size<T: ProtobufVarintZigzag>(vec: &[T]) -> u64 {
16	0	vec.iter().map(\|v\| v.len_varint_zigzag()).sum() Unexecuted instantiation: protobuf::rt::packed::vec_packed_varint_zigzag_data_size::<i32>::{closure#0} Unexecuted instantiation: protobuf::rt::packed::vec_packed_varint_zigzag_data_size::<i64>::{closure#0}
17	0	} Unexecuted instantiation: protobuf::rt::packed::vec_packed_varint_zigzag_data_size::<i32> Unexecuted instantiation: protobuf::rt::packed::vec_packed_varint_zigzag_data_size::<i64>
18
19		/// Size of serialized repeated packed enum field, excluding length and tag.
20	0	pub(crate) fn vec_packed_enum_or_unknown_data_size<E: Enum>(vec: &[EnumOrUnknown<E>]) -> u64 {
21	0	vec.iter()
22	0	.map(\|e\| compute_raw_varint32_size(e.value() as u32))
23	0	.sum()
24	0	}
25
26		/// Size of serialized data with length prefix and tag
27		#[inline]
28	0	fn vec_packed_varint_size<T: ProtobufVarint>(field_number: u32, vec: &[T]) -> u64 {
29	0	if vec.is_empty() {
30	0	0
31		} else {
32	0	let data_size = vec_packed_varint_data_size(vec);
33	0	tag_size(field_number) + data_size.len_varint() + data_size
34		}
35	0	} Unexecuted instantiation: protobuf::rt::packed::vec_packed_varint_size::<u32> Unexecuted instantiation: protobuf::rt::packed::vec_packed_varint_size::<i64> Unexecuted instantiation: protobuf::rt::packed::vec_packed_varint_size::<u64> Unexecuted instantiation: protobuf::rt::packed::vec_packed_varint_size::<i32>
36
37		/// Size of serialized data with length prefix and tag.
38		#[inline]
39	0	pub fn vec_packed_int32_size(field_number: u32, vec: &[i32]) -> u64 {
40	0	vec_packed_varint_size(field_number, vec)
41	0	}
42
43		/// Size of serialized data with length prefix and tag.
44		#[inline]
45	0	pub fn vec_packed_int64_size(field_number: u32, vec: &[i64]) -> u64 {
46	0	vec_packed_varint_size(field_number, vec)
47	0	}
48
49		/// Size of serialized data with length prefix and tag.
50		#[inline]
51	0	pub fn vec_packed_uint32_size(field_number: u32, vec: &[u32]) -> u64 {
52	0	vec_packed_varint_size(field_number, vec)
53	0	}
54
55		/// Size of serialized data with length prefix and tag.
56		#[inline]
57	0	pub fn vec_packed_uint64_size(field_number: u32, vec: &[u64]) -> u64 {
58	0	vec_packed_varint_size(field_number, vec)
59	0	}
60
61		/// Size of serialized data with length prefix and tag
62		#[inline]
63	0	fn vec_packed_varint_zigzag_size<T: ProtobufVarintZigzag>(field_number: u32, vec: &[T]) -> u64 {
64	0	if vec.is_empty() {
65	0	0
66		} else {
67	0	let data_size = vec_packed_varint_zigzag_data_size(vec);
68	0	tag_size(field_number) + data_size.len_varint() + data_size
69		}
70	0	} Unexecuted instantiation: protobuf::rt::packed::vec_packed_varint_zigzag_size::<i32> Unexecuted instantiation: protobuf::rt::packed::vec_packed_varint_zigzag_size::<i64>
71
72		/// Size of serialized data with length prefix and tag.
73		#[inline]
74	0	pub fn vec_packed_sint32_size(field_number: u32, vec: &[i32]) -> u64 {
75	0	vec_packed_varint_zigzag_size(field_number, vec)
76	0	}
77
78		/// Size of serialized data with length prefix and tag.
79		#[inline]
80	0	pub fn vec_packed_sint64_size(field_number: u32, vec: &[i64]) -> u64 {
81	0	vec_packed_varint_zigzag_size(field_number, vec)
82	0	}
83
84		/// Size of serialized data with length prefix and tag
85		#[inline]
86	0	pub fn vec_packed_enum_or_unknown_size<E: Enum>(
87	0	field_number: u32,
88	0	vec: &[EnumOrUnknown<E>],
89	0	) -> u64 {
90	0	if vec.is_empty() {
91	0	0
92		} else {
93	0	let data_size = vec_packed_enum_or_unknown_data_size(vec);
94	0	tag_size(field_number) + data_size.len_varint() + data_size
95		}
96	0	}
97
98		/// Compute data size of fixed encoding of repeated field data.
99	0	pub(crate) fn vec_packed_fixed_data_size<V: ProtobufFixed>(vec: &[V]) -> u64 {
100	0	(vec.len() as u64) * (V::LEN as u64)
101	0	} Unexecuted instantiation: protobuf::rt::packed::vec_packed_fixed_data_size::<f32> Unexecuted instantiation: protobuf::rt::packed::vec_packed_fixed_data_size::<f64> Unexecuted instantiation: protobuf::rt::packed::vec_packed_fixed_data_size::<u32> Unexecuted instantiation: protobuf::rt::packed::vec_packed_fixed_data_size::<u64> Unexecuted instantiation: protobuf::rt::packed::vec_packed_fixed_data_size::<i32> Unexecuted instantiation: protobuf::rt::packed::vec_packed_fixed_data_size::<i64> Unexecuted instantiation: protobuf::rt::packed::vec_packed_fixed_data_size::<bool>
102
103		/// Compute field size (data plus header) of fixed encoding of repeated field.
104		#[inline]
105	0	fn vec_packed_fixed_size<V: ProtobufFixed>(field_number: u32, vec: &[V]) -> u64 {
106	0	if vec.is_empty() {
107	0	0
108		} else {
109	0	let data_size = vec_packed_fixed_data_size::<V>(vec);
110	0	tag_size(field_number) + data_size.len_varint() + data_size
111		}
112	0	} Unexecuted instantiation: protobuf::rt::packed::vec_packed_fixed_size::<bool> Unexecuted instantiation: protobuf::rt::packed::vec_packed_fixed_size::<f64> Unexecuted instantiation: protobuf::rt::packed::vec_packed_fixed_size::<f32> Unexecuted instantiation: protobuf::rt::packed::vec_packed_fixed_size::<i32> Unexecuted instantiation: protobuf::rt::packed::vec_packed_fixed_size::<u32> Unexecuted instantiation: protobuf::rt::packed::vec_packed_fixed_size::<i64> Unexecuted instantiation: protobuf::rt::packed::vec_packed_fixed_size::<u64>
113
114		/// Compute data size of fixed encoding of repeated field data.
115		#[inline]
116	0	pub fn vec_packed_fixed32_size(field_number: u32, vec: &[u32]) -> u64 {
117	0	vec_packed_fixed_size(field_number, vec)
118	0	}
119
120		/// Compute data size of fixed encoding of repeated field data.
121		#[inline]
122	0	pub fn vec_packed_fixed64_size(field_number: u32, vec: &[u64]) -> u64 {
123	0	vec_packed_fixed_size(field_number, vec)
124	0	}
125
126		/// Compute data size of fixed encoding of repeated field data.
127		#[inline]
128	0	pub fn vec_packed_sfixed32_size(field_number: u32, vec: &[i32]) -> u64 {
129	0	vec_packed_fixed_size(field_number, vec)
130	0	}
131
132		/// Compute data size of fixed encoding of repeated field data.
133		#[inline]
134	0	pub fn vec_packed_sfixed64_size(field_number: u32, vec: &[i64]) -> u64 {
135	0	vec_packed_fixed_size(field_number, vec)
136	0	}
137
138		/// Compute data size of fixed encoding of repeated field data.
139		#[inline]
140	0	pub fn vec_packed_float_size(field_number: u32, vec: &[f32]) -> u64 {
141	0	vec_packed_fixed_size(field_number, vec)
142	0	}
143
144		/// Compute data size of fixed encoding of repeated field data.
145		#[inline]
146	0	pub fn vec_packed_double_size(field_number: u32, vec: &[f64]) -> u64 {
147	0	vec_packed_fixed_size(field_number, vec)
148	0	}
149
150		/// Compute data size of fixed encoding of repeated field data.
151		#[inline]
152	0	pub fn vec_packed_bool_size(field_number: u32, vec: &[bool]) -> u64 {
153	0	vec_packed_fixed_size(field_number, vec)
154	0	}

Coverage Report

Created: 2025-06-24 06:17