protopuffer/
encode.rs

1use crate::varint::Varint;
2use crate::WireType;
3
4use std::collections::HashMap;
5use std::fmt;
6
7use bytes::{BytesOwned, BytesRead, BytesWrite};
8
9#[derive(Debug, Clone, PartialEq, Eq)]
10#[non_exhaustive]
11pub enum EncodeError {
12	BufferExausted,
13	Other(String),
14}
15
16impl fmt::Display for EncodeError {
17	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
18		match self {
19			Self::BufferExausted => write!(f, "the buffer was to small"),
20			Self::Other(s) => write!(f, "encode error: {s}"),
21		}
22	}
23}
24
25impl std::error::Error for EncodeError {}
26
27#[derive(Debug)]
28pub struct MessageEncoder<B> {
29	inner: B,
30}
31
32impl<B> MessageEncoder<B> {
33	pub fn new(inner: B) -> Self {
34		Self { inner }
35	}
36
37	pub fn inner(&self) -> &B {
38		&self.inner
39	}
40
41	pub fn finish(self) -> B {
42		self.inner
43	}
44}
45
46impl MessageEncoder<BytesOwned> {
47	pub fn new_owned() -> Self {
48		Self {
49			inner: BytesOwned::new(),
50		}
51	}
52}
53
54impl<B> MessageEncoder<B>
55where
56	B: BytesWrite,
57{
58	pub fn write_tag(
59		&mut self,
60		fieldnum: u64,
61		wtype: WireType,
62	) -> Result<(), EncodeError> {
63		let mut tag = Varint(fieldnum << 3);
64		tag.0 |= wtype.as_num() as u64;
65
66		tag.write(&mut self.inner)
67			.map_err(|_| EncodeError::BufferExausted)
68	}
69
70	pub fn write_len(&mut self, len: u64) -> Result<(), EncodeError> {
71		Varint(len)
72			.write(&mut self.inner)
73			.map_err(|_| EncodeError::BufferExausted)
74	}
75
76	pub fn write_bytes(&mut self, bytes: &[u8]) -> Result<(), EncodeError> {
77		self.inner
78			.try_write(bytes)
79			.map_err(|_| EncodeError::BufferExausted)
80	}
81
82	pub fn written_len(&self) -> u64 {
83		self.inner.as_bytes().len() as u64
84	}
85
86	pub fn write_varint(&mut self, val: u64) -> Result<(), EncodeError> {
87		Varint(val)
88			.write(&mut self.inner)
89			.map_err(|_| EncodeError::BufferExausted)
90	}
91
92	pub fn write_i32(&mut self, val: u32) -> Result<(), EncodeError> {
93		self.inner
94			.try_write_le_u32(val)
95			.map_err(|_| EncodeError::BufferExausted)
96	}
97
98	pub fn write_i64(&mut self, val: u64) -> Result<(), EncodeError> {
99		self.inner
100			.try_write_le_u64(val)
101			.map_err(|_| EncodeError::BufferExausted)
102	}
103
104	pub fn write_empty_field(
105		&mut self,
106		fieldnum: u64,
107	) -> Result<(), EncodeError> {
108		self.write_tag(fieldnum, WireType::Len)?;
109		self.write_len(0)
110	}
111}
112
113impl From<MessageEncoder<BytesOwned>> for Vec<u8> {
114	fn from(w: MessageEncoder<BytesOwned>) -> Self {
115		w.inner.into()
116	}
117}
118
119#[derive(Debug)]
120pub struct SizeBuilder {
121	inner: u64,
122}
123
124impl SizeBuilder {
125	pub fn new() -> Self {
126		Self { inner: 0 }
127	}
128
129	pub fn write_tag(&mut self, fieldnum: u64, _wtype: WireType) {
130		self.inner += Varint(fieldnum << 3).size();
131	}
132
133	pub fn write_len(&mut self, len: u64) {
134		// need to get the varint len
135		self.write_varint(len);
136	}
137
138	pub fn write_varint(&mut self, val: u64) {
139		self.inner += Varint(val).size();
140	}
141
142	pub fn write_i32(&mut self, _val: u32) {
143		self.inner += 4;
144	}
145
146	pub fn write_i64(&mut self, _val: u64) {
147		self.inner += 8;
148	}
149
150	pub fn write_bytes(&mut self, len: u64) {
151		self.inner += len;
152	}
153
154	pub fn write_empty_field(&mut self, fieldnum: u64) {
155		self.write_tag(fieldnum, WireType::Len);
156		self.write_len(0);
157	}
158
159	pub fn finish(self) -> u64 {
160		self.inner
161	}
162}
163
164#[derive(Debug, Clone, Copy, PartialEq, Eq)]
165pub struct FieldOpt {
166	pub num: u64,
167	pub is_nested: bool,
168}
169
170impl FieldOpt {
171	pub const fn new(num: u64) -> Self {
172		Self {
173			num,
174			is_nested: false,
175		}
176	}
177}
178
179/// ## Ignoring fields
180/// if your call tells you a field number you need to write it even if you
181/// have the default value
182///
183/// You can only ignore writing fields if you wan't
184pub trait EncodeMessage {
185	fn write_to_bytes(&mut self) -> Result<Vec<u8>, EncodeError> {
186		// we need to call
187		let mut encoder = MessageEncoder::new_owned();
188
189		self.encode(None, &mut encoder)?;
190
191		Ok(encoder.into())
192	}
193
194	/// at the moment only used to check if this message can be packed
195	const WIRE_TYPE: WireType;
196
197	fn is_default(&self) -> bool;
198
199	/// how big will the size be after encoding
200	///
201	/// The that get's returned here needs to be the same as called in write
202	///
203	/// if fieldnum is set this means you *need* to write the tag
204	fn encoded_size(
205		&mut self,
206		field: Option<FieldOpt>,
207		builder: &mut SizeBuilder,
208	) -> Result<(), EncodeError>;
209
210	/// In most cases before this is called encoded_size get's called
211	///
212	/// The size that get's computed in encoded_size must be the same as we get
213	/// here
214	///
215	/// if fieldnum is set this means you *need* to write the tag to
216	fn encode<B>(
217		&mut self,
218		field: Option<FieldOpt>,
219		encoder: &mut MessageEncoder<B>,
220	) -> Result<(), EncodeError>
221	where
222		B: BytesWrite;
223}
224
225impl<V: EncodeMessage> EncodeMessage for &mut V {
226	const WIRE_TYPE: WireType = V::WIRE_TYPE;
227
228	fn is_default(&self) -> bool {
229		(**self).is_default()
230	}
231
232	fn encoded_size(
233		&mut self,
234		field: Option<FieldOpt>,
235		builder: &mut SizeBuilder,
236	) -> Result<(), EncodeError> {
237		(**self).encoded_size(field, builder)
238	}
239
240	fn encode<B>(
241		&mut self,
242		field: Option<FieldOpt>,
243		encoder: &mut MessageEncoder<B>,
244	) -> Result<(), EncodeError>
245	where
246		B: BytesWrite,
247	{
248		(**self).encode(field, encoder)
249	}
250}
251
252macro_rules! impl_from_ref {
253	($ty:ty) => {
254		impl EncodeMessage for $ty {
255			const WIRE_TYPE: WireType = <&$ty>::WIRE_TYPE;
256
257			fn is_default(&self) -> bool {
258				(&&*self).is_default()
259			}
260
261			fn encoded_size(
262				&mut self,
263				field: Option<FieldOpt>,
264				builder: &mut SizeBuilder,
265			) -> Result<(), EncodeError> {
266				(&mut &*self).encoded_size(field, builder)
267			}
268
269			fn encode<B>(
270				&mut self,
271				field: Option<FieldOpt>,
272				encoder: &mut MessageEncoder<B>,
273			) -> Result<(), EncodeError>
274			where
275				B: BytesWrite,
276			{
277				(&mut &*self).encode(field, encoder)
278			}
279		}
280	};
281}
282
283impl<V> EncodeMessage for Vec<V>
284where
285	V: EncodeMessage,
286{
287	const WIRE_TYPE: WireType = WireType::Len;
288
289	fn is_default(&self) -> bool {
290		self.is_empty()
291	}
292
293	/// how big will the size be after writing
294	fn encoded_size(
295		&mut self,
296		field: Option<FieldOpt>,
297		builder: &mut SizeBuilder,
298	) -> Result<(), EncodeError> {
299		self.as_mut_slice().encoded_size(field, builder)
300	}
301
302	fn encode<B>(
303		&mut self,
304		field: Option<FieldOpt>,
305		encoder: &mut MessageEncoder<B>,
306	) -> Result<(), EncodeError>
307	where
308		B: BytesWrite,
309	{
310		self.as_mut_slice().encode(field, encoder)
311	}
312}
313
314impl<V, const S: usize> EncodeMessage for [V; S]
315where
316	V: EncodeMessage,
317{
318	const WIRE_TYPE: WireType = WireType::Len;
319
320	fn is_default(&self) -> bool {
321		self.is_empty()
322	}
323
324	/// how big will the size be after writing
325	fn encoded_size(
326		&mut self,
327		field: Option<FieldOpt>,
328		builder: &mut SizeBuilder,
329	) -> Result<(), EncodeError> {
330		self.as_mut_slice().encoded_size(field, builder)
331	}
332
333	fn encode<B>(
334		&mut self,
335		field: Option<FieldOpt>,
336		encoder: &mut MessageEncoder<B>,
337	) -> Result<(), EncodeError>
338	where
339		B: BytesWrite,
340	{
341		self.as_mut_slice().encode(field, encoder)
342	}
343}
344
345impl<V> EncodeMessage for [V]
346where
347	V: EncodeMessage,
348{
349	const WIRE_TYPE: WireType = WireType::Len;
350
351	fn is_default(&self) -> bool {
352		self.is_empty()
353	}
354
355	/// how big will the size be after writing
356	fn encoded_size(
357		&mut self,
358		field: Option<FieldOpt>,
359		builder: &mut SizeBuilder,
360	) -> Result<(), EncodeError> {
361		// if we don't have a fieldnum we need to simulate a custom field
362		let field = field.unwrap_or(FieldOpt::new(1));
363
364		// if this fieldnumber cannot be repeated we need to simulate another
365		// field
366		if field.is_nested {
367			builder.write_tag(field.num, WireType::Len);
368
369			let mut size = SizeBuilder::new();
370			self.encoded_size(None, &mut size)?;
371			let size = size.finish();
372
373			builder.write_len(size);
374			builder.write_bytes(size);
375			return Ok(());
376		}
377
378		// if we are packed
379		if V::WIRE_TYPE.can_be_packed() && self.len() > 1 {
380			builder.write_tag(field.num, WireType::Len);
381
382			let mut packed_builder = SizeBuilder::new();
383			for v in self.iter_mut() {
384				v.encoded_size(None, &mut packed_builder)?;
385			}
386			// we now know how big a packed field is
387			let packed_size = packed_builder.finish();
388
389			builder.write_len(packed_size);
390			builder.write_bytes(packed_size);
391			return Ok(());
392		}
393
394		// we need to create a field for every entry
395		for v in self.iter_mut() {
396			let field = FieldOpt {
397				num: field.num,
398				is_nested: true,
399			};
400			v.encoded_size(Some(field), builder)?;
401		}
402
403		Ok(())
404	}
405
406	fn encode<B>(
407		&mut self,
408		field: Option<FieldOpt>,
409		encoder: &mut MessageEncoder<B>,
410	) -> Result<(), EncodeError>
411	where
412		B: BytesWrite,
413	{
414		// if we don't have a fieldnum we need to simulate a custom field
415		let field = field.unwrap_or(FieldOpt::new(1));
416
417		// if this fieldnumber cannot be repeated we need to simulate another
418		// field
419		if field.is_nested {
420			encoder.write_tag(field.num, WireType::Len)?;
421
422			let mut size = SizeBuilder::new();
423			self.encoded_size(None, &mut size)?;
424			let size = size.finish();
425
426			encoder.write_len(size)?;
427
428			#[cfg(debug_assertions)]
429			let prev_len = encoder.written_len();
430
431			self.encode(None, encoder)?;
432
433			#[cfg(debug_assertions)]
434			{
435				let added_len = encoder.written_len() - prev_len;
436				assert_eq!(
437					size, added_len as u64,
438					"size does not match real size"
439				);
440			}
441
442			return Ok(());
443		}
444
445		// if we are packed
446		if V::WIRE_TYPE.can_be_packed() && self.len() > 1 {
447			encoder.write_tag(field.num, WireType::Len)?;
448
449			let mut packed_builder = SizeBuilder::new();
450			for v in self.iter_mut() {
451				v.encoded_size(None, &mut packed_builder)?;
452			}
453			// we now know how big a packed field is
454			let packed_size = packed_builder.finish();
455
456			encoder.write_len(packed_size)?;
457
458			#[cfg(debug_assertions)]
459			let prev_len = encoder.written_len();
460
461			for v in self.iter_mut() {
462				v.encode(None, encoder)?;
463			}
464
465			#[cfg(debug_assertions)]
466			{
467				let added_len = encoder.written_len() - prev_len;
468				assert_eq!(
469					packed_size, added_len as u64,
470					"size does not match real size"
471				);
472			}
473
474			return Ok(());
475		}
476
477		// we need to create a field for every entry
478		for v in self.iter_mut() {
479			let field = FieldOpt {
480				num: field.num,
481				is_nested: true,
482			};
483			v.encode(Some(field), encoder)?;
484		}
485
486		Ok(())
487	}
488}
489
490impl<K, V> EncodeMessage for HashMap<K, V>
491where
492	for<'a> &'a K: EncodeMessage,
493	V: EncodeMessage,
494{
495	const WIRE_TYPE: WireType = WireType::Len;
496
497	fn is_default(&self) -> bool {
498		self.is_empty()
499	}
500
501	/// how big will the size be after writing
502	fn encoded_size(
503		&mut self,
504		field: Option<FieldOpt>,
505		builder: &mut SizeBuilder,
506	) -> Result<(), EncodeError> {
507		// if we don't have a fieldnum we need to simulate a custom field
508		let field = field.unwrap_or(FieldOpt::new(1));
509
510		// if this fieldnumber cannot be repeated we need to simulate another
511		// field
512		if field.is_nested {
513			builder.write_tag(field.num, WireType::Len);
514
515			let mut size = SizeBuilder::new();
516			// this works since FieldOpt::new(1) will never be nested
517			self.encoded_size(None, &mut size)?;
518			let size = size.finish();
519
520			builder.write_len(size);
521			builder.write_bytes(size);
522			return Ok(());
523		}
524
525		// we need to create a field for every entry
526		for (k, v) in self.iter_mut() {
527			let field = FieldOpt {
528				num: field.num,
529				is_nested: true,
530			};
531			(k, v).encoded_size(Some(field), builder)?;
532		}
533
534		Ok(())
535	}
536
537	fn encode<B>(
538		&mut self,
539		field: Option<FieldOpt>,
540		encoder: &mut MessageEncoder<B>,
541	) -> Result<(), EncodeError>
542	where
543		B: BytesWrite,
544	{
545		// if we don't have a fieldnum we need to simulate a custom field
546		let field = field.unwrap_or(FieldOpt::new(1));
547
548		// if this fieldnumber cannot be repeated we need to simulate another
549		// field
550		if field.is_nested {
551			encoder.write_tag(field.num, WireType::Len)?;
552
553			let mut size = SizeBuilder::new();
554			self.encoded_size(None, &mut size)?;
555			let size = size.finish();
556
557			encoder.write_len(size)?;
558
559			#[cfg(debug_assertions)]
560			let prev_len = encoder.written_len();
561
562			self.encode(None, encoder)?;
563
564			#[cfg(debug_assertions)]
565			{
566				let added_len = encoder.written_len() - prev_len;
567				assert_eq!(
568					size, added_len as u64,
569					"size does not match real size"
570				);
571			}
572
573			return Ok(());
574		}
575
576		// we need to create a field for every entry
577		for (k, v) in self.iter_mut() {
578			let field = FieldOpt {
579				num: field.num,
580				is_nested: true,
581			};
582			(k, v).encode(Some(field), encoder)?;
583		}
584
585		Ok(())
586	}
587}
588
589impl EncodeMessage for Vec<u8> {
590	const WIRE_TYPE: WireType = WireType::Len;
591
592	fn is_default(&self) -> bool {
593		self.as_slice().is_default()
594	}
595
596	/// how big will the size be after writing
597	fn encoded_size(
598		&mut self,
599		field: Option<FieldOpt>,
600		builder: &mut SizeBuilder,
601	) -> Result<(), EncodeError> {
602		self.as_slice().encoded_size(field, builder)
603	}
604
605	fn encode<B>(
606		&mut self,
607		field: Option<FieldOpt>,
608		encoder: &mut MessageEncoder<B>,
609	) -> Result<(), EncodeError>
610	where
611		B: BytesWrite,
612	{
613		self.as_slice().encode(field, encoder)
614	}
615}
616
617impl<const S: usize> EncodeMessage for [u8; S] {
618	const WIRE_TYPE: WireType = WireType::Len;
619
620	fn is_default(&self) -> bool {
621		self.as_slice().is_default()
622	}
623
624	/// how big will the size be after writing
625	fn encoded_size(
626		&mut self,
627		field: Option<FieldOpt>,
628		builder: &mut SizeBuilder,
629	) -> Result<(), EncodeError> {
630		self.as_slice().encoded_size(field, builder)
631	}
632
633	fn encode<B>(
634		&mut self,
635		field: Option<FieldOpt>,
636		encoder: &mut MessageEncoder<B>,
637	) -> Result<(), EncodeError>
638	where
639		B: BytesWrite,
640	{
641		self.as_slice().encode(field, encoder)
642	}
643}
644
645/// a tuple behaves the same way as a struct
646macro_rules! impl_tuple {
647	($($gen:ident, $idx:tt),*) => (
648		impl<$($gen),*> EncodeMessage for ($($gen),*)
649		where
650			$($gen: EncodeMessage),*
651		{
652			const WIRE_TYPE: WireType = WireType::Len;
653
654			fn is_default(&self) -> bool {
655				false
656			}
657
658			/// how big will the size be after writing
659			fn encoded_size(
660				&mut self,
661				field: Option<FieldOpt>,
662				builder: &mut SizeBuilder
663			) -> Result<(), EncodeError> {
664				let mut size = SizeBuilder::new();
665				$(
666					if !self.$idx.is_default() {
667						self.$idx.encoded_size(
668							Some(FieldOpt::new($idx)),
669							&mut size
670						)?;
671					}
672				)*
673				let fields_size = size.finish();
674
675				if let Some(field) = field {
676					builder.write_tag(field.num, Self::WIRE_TYPE);
677					builder.write_len(fields_size);
678				}
679
680				builder.write_bytes(fields_size);
681
682				Ok(())
683			}
684
685			fn encode<Bytes>(
686				&mut self,
687				field: Option<FieldOpt>,
688				encoder: &mut MessageEncoder<Bytes>
689			) -> Result<(), EncodeError>
690			where Bytes: BytesWrite {
691				#[cfg(debug_assertions)]
692				let mut dbg_fields_size = None;
693
694				// we don't need to get the size if we don't need to write
695				// the size
696				if let Some(field) = field {
697					encoder.write_tag(field.num, Self::WIRE_TYPE)?;
698
699					let mut size = SizeBuilder::new();
700					$(
701						if !self.$idx.is_default() {
702							self.$idx.encoded_size(
703								Some(FieldOpt::new($idx)),
704								&mut size
705							)?;
706						}
707					)*
708					let fields_size = size.finish();
709
710					encoder.write_len(fields_size)?;
711
712					#[cfg(debug_assertions)]
713					{
714						dbg_fields_size = Some(fields_size);
715					}
716				}
717
718				#[cfg(debug_assertions)]
719				let prev_len = encoder.written_len();
720
721				$(
722					if !self.$idx.is_default() {
723						self.$idx.encode(
724							Some(FieldOpt::new($idx)),
725							encoder
726						)?;
727					}
728				)*
729
730				#[cfg(debug_assertions)]
731				if let Some(fields_size) = dbg_fields_size {
732					let added_len = encoder.written_len() - prev_len;
733					assert_eq!(fields_size, added_len as u64,
734						"encoded size does not match actual size");
735				}
736
737				Ok(())
738			}
739		}
740	)
741}
742
743// impl_tuple![
744// 	A, 0
745// ];
746impl_tuple![A, 0, B, 1];
747impl_tuple![A, 0, B, 1, C, 2];
748impl_tuple![A, 0, B, 1, C, 2, D, 3];
749impl_tuple![A, 0, B, 1, C, 2, D, 3, E, 4];
750impl_tuple![A, 0, B, 1, C, 2, D, 3, E, 4, F, 5];
751
752impl_from_ref!([u8]);
753
754impl EncodeMessage for &[u8] {
755	const WIRE_TYPE: WireType = WireType::Len;
756
757	fn is_default(&self) -> bool {
758		self.is_empty()
759	}
760
761	/// how big will the size be after writing
762	fn encoded_size(
763		&mut self,
764		field: Option<FieldOpt>,
765		writer: &mut SizeBuilder,
766	) -> Result<(), EncodeError> {
767		if let Some(field) = field {
768			writer.write_tag(field.num, Self::WIRE_TYPE);
769			writer.write_len(self.len() as u64);
770		}
771
772		writer.write_bytes(self.len() as u64);
773
774		Ok(())
775	}
776
777	fn encode<B>(
778		&mut self,
779		field: Option<FieldOpt>,
780		writer: &mut MessageEncoder<B>,
781	) -> Result<(), EncodeError>
782	where
783		B: BytesWrite,
784	{
785		if let Some(field) = field {
786			writer.write_tag(field.num, Self::WIRE_TYPE)?;
787			writer.write_len(self.len() as u64)?;
788		}
789
790		writer.write_bytes(self)
791	}
792}
793
794impl_from_ref!(String);
795
796impl EncodeMessage for &String {
797	const WIRE_TYPE: WireType = WireType::Len;
798
799	fn is_default(&self) -> bool {
800		self.as_bytes().is_default()
801	}
802
803	/// how big will the size be after writing
804	fn encoded_size(
805		&mut self,
806		field: Option<FieldOpt>,
807		builder: &mut SizeBuilder,
808	) -> Result<(), EncodeError> {
809		self.as_bytes().encoded_size(field, builder)
810	}
811
812	fn encode<B>(
813		&mut self,
814		field: Option<FieldOpt>,
815		encoder: &mut MessageEncoder<B>,
816	) -> Result<(), EncodeError>
817	where
818		B: BytesWrite,
819	{
820		self.as_bytes().encode(field, encoder)
821	}
822}
823
824impl EncodeMessage for &str {
825	const WIRE_TYPE: WireType = WireType::Len;
826
827	fn is_default(&self) -> bool {
828		self.as_bytes().is_default()
829	}
830
831	/// how big will the size be after writing
832	fn encoded_size(
833		&mut self,
834		field: Option<FieldOpt>,
835		builder: &mut SizeBuilder,
836	) -> Result<(), EncodeError> {
837		self.as_bytes().encoded_size(field, builder)
838	}
839
840	fn encode<B>(
841		&mut self,
842		field: Option<FieldOpt>,
843		encoder: &mut MessageEncoder<B>,
844	) -> Result<(), EncodeError>
845	where
846		B: BytesWrite,
847	{
848		self.as_bytes().encode(field, encoder)
849	}
850}
851
852impl<T> EncodeMessage for Option<T>
853where
854	T: EncodeMessage,
855{
856	const WIRE_TYPE: WireType = WireType::Len;
857
858	fn is_default(&self) -> bool {
859		self.is_none()
860	}
861
862	fn encoded_size(
863		&mut self,
864		field: Option<FieldOpt>,
865		builder: &mut SizeBuilder,
866	) -> Result<(), EncodeError> {
867		let field = field.unwrap_or(FieldOpt::new(1));
868
869		if field.is_nested {
870			builder.write_tag(field.num, WireType::Len);
871
872			let mut size = SizeBuilder::new();
873			self.encoded_size(None, &mut size)?;
874			let size = size.finish();
875
876			builder.write_len(size);
877			builder.write_bytes(size);
878
879			return Ok(());
880		}
881
882		match self {
883			Some(v) => v.encoded_size(
884				Some(FieldOpt {
885					num: field.num,
886					is_nested: true,
887				}),
888				builder,
889			),
890			None => Ok(()),
891		}
892	}
893
894	fn encode<B>(
895		&mut self,
896		field: Option<FieldOpt>,
897		encoder: &mut MessageEncoder<B>,
898	) -> Result<(), EncodeError>
899	where
900		B: BytesWrite,
901	{
902		let field = field.unwrap_or(FieldOpt::new(1));
903
904		if field.is_nested {
905			encoder.write_tag(field.num, WireType::Len)?;
906
907			let mut size = SizeBuilder::new();
908			self.encoded_size(None, &mut size)?;
909			let size = size.finish();
910
911			encoder.write_len(size)?;
912
913			#[cfg(debug_assertions)]
914			let prev_len = encoder.written_len();
915
916			self.encode(None, encoder)?;
917
918			#[cfg(debug_assertions)]
919			{
920				let added_len = encoder.written_len() - prev_len;
921				assert_eq!(
922					size, added_len as u64,
923					"size does not match real size"
924				);
925			}
926
927			return Ok(());
928		}
929
930		match self {
931			Some(v) => v.encode(
932				Some(FieldOpt {
933					num: field.num,
934					is_nested: true,
935				}),
936				encoder,
937			),
938			None => Ok(()),
939		}
940	}
941}
942
943impl_from_ref!(bool);
944
945impl EncodeMessage for &bool {
946	const WIRE_TYPE: WireType = WireType::Varint;
947
948	fn is_default(&self) -> bool {
949		**self == false
950	}
951
952	fn encoded_size(
953		&mut self,
954		field: Option<FieldOpt>,
955		builder: &mut SizeBuilder,
956	) -> Result<(), EncodeError> {
957		if let Some(field) = field {
958			builder.write_tag(field.num, Self::WIRE_TYPE);
959		}
960
961		builder.write_varint(**self as u64);
962
963		Ok(())
964	}
965
966	fn encode<B>(
967		&mut self,
968		field: Option<FieldOpt>,
969		encoder: &mut MessageEncoder<B>,
970	) -> Result<(), EncodeError>
971	where
972		B: BytesWrite,
973	{
974		if let Some(field) = field {
975			encoder.write_tag(field.num, Self::WIRE_TYPE)?;
976		}
977
978		encoder.write_varint(**self as u64)
979	}
980}
981
982// impl basic varint
983macro_rules! impl_varint {
984	($($ty:ty),*) => ($(
985		impl_from_ref!($ty);
986
987		impl EncodeMessage for &$ty {
988			const WIRE_TYPE: WireType = WireType::Varint;
989
990			fn is_default(&self) -> bool {
991				**self == 0
992			}
993
994			fn encoded_size(
995				&mut self,
996				field: Option<FieldOpt>,
997				builder: &mut SizeBuilder
998			) -> Result<(), EncodeError> {
999				if let Some(field) = field {
1000					builder.write_tag(field.num, Self::WIRE_TYPE);
1001				}
1002
1003				builder.write_varint(**self as u64);
1004
1005				Ok(())
1006			}
1007
1008			fn encode<B>(
1009				&mut self,
1010				field: Option<FieldOpt>,
1011				encoder: &mut MessageEncoder<B>
1012			) -> Result<(), EncodeError>
1013			where B: BytesWrite {
1014				if let Some(field) = field {
1015					encoder.write_tag(field.num, Self::WIRE_TYPE)?;
1016				}
1017
1018				encoder.write_varint(**self as u64)
1019			}
1020		}
1021	)*)
1022}
1023
1024impl_varint![i32, i64, u32, u64];
1025
1026macro_rules! impl_floats {
1027	($($src:ident, $wty:ident, $wtype:ident as $ty:ty),*) => ($(
1028		impl_from_ref!($ty);
1029
1030		impl EncodeMessage for &$ty {
1031			const WIRE_TYPE: WireType = WireType::$wtype;
1032
1033			fn is_default(&self) -> bool {
1034				**self == 0 as $ty
1035			}
1036
1037			fn encoded_size(
1038				&mut self,
1039				field: Option<FieldOpt>,
1040				builder: &mut SizeBuilder
1041			) -> Result<(), EncodeError> {
1042				if let Some(field) = field {
1043					builder.write_tag(field.num, Self::WIRE_TYPE);
1044				}
1045
1046				builder.$src(**self as $wty);
1047
1048				Ok(())
1049			}
1050
1051			fn encode<B>(
1052				&mut self,
1053				field: Option<FieldOpt>,
1054				encoder: &mut MessageEncoder<B>
1055			) -> Result<(), EncodeError>
1056			where B: BytesWrite {
1057				if let Some(field) = field {
1058					encoder.write_tag(field.num, Self::WIRE_TYPE)?;
1059				}
1060
1061				encoder.$src(**self as $wty)
1062			}
1063		}
1064	)*)
1065}
1066
1067impl_floats![write_i32, u32, I32 as f32, write_i64, u64, I64 as f64];
protopuffer/encode.rs

protopuffer/
encode.rs
