fire_protobuf/
encode.rs

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

fire_protobuf/
encode.rs
