fire-protobuf 0.1.3

Rust only protobuf implementation
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

use crate::encode::{
	EncodeMessage, MessageEncoder, EncodeError, FieldOpt, SizeBuilder
};
use crate::decode::{DecodeMessage, MessageDecoder, FieldKind, DecodeError};
use crate::bytes::{BytesOwned, BytesRead, BytesWrite};
pub use crate::WireType;

use std::fmt::Debug;


#[derive(Debug, Default, PartialEq, Eq)]
pub struct Wrapper<T>(pub T);

impl<T> EncodeMessage for Wrapper<T>
where T: EncodeMessage {
	const WIRE_TYPE: WireType = WireType::Len;

	fn is_default(&self) -> bool { false }

	fn encoded_size(
		&mut self,
		field: Option<FieldOpt>,
		builder: &mut SizeBuilder
	) -> Result<(), EncodeError> {
		let mut size = SizeBuilder::new();
		self.0.encoded_size(Some(FieldOpt::new(1)), &mut size)?;
		let size = size.finish();

		if let Some(field) = field {
			builder.write_tag(field.num, WireType::Len);
			builder.write_len(size);
		}

		builder.write_bytes(size);

		Ok(())
	}

	fn encode<B>(
		&mut self,
		field: Option<FieldOpt>,
		encoder: &mut MessageEncoder<B>
	) -> Result<(), EncodeError>
	where B: BytesWrite {
		if let Some(field) = field {
			encoder.write_tag(field.num, WireType::Len)?;

			let mut size = SizeBuilder::new();
			self.0.encoded_size(Some(FieldOpt::new(1)), &mut size)?;
			let size = size.finish();

			encoder.write_len(size)?;
		}

		self.0.encode(Some(FieldOpt::new(1)), encoder)
	}
}

impl<'m, T> DecodeMessage<'m> for Wrapper<T>
where T: DecodeMessage<'m> {
	const WIRE_TYPE: WireType = WireType::Len;

	fn decode_default() -> Self {
		Self(T::decode_default())
	}

	fn merge(
		&mut self,
		kind: FieldKind<'m>,
		_is_field: bool
	) -> Result<(), DecodeError> {
		let mut decoder = MessageDecoder::try_from_kind(kind)?;

		while let Some(field) = decoder.next()? {
			if field.number == 1 {
				self.0.merge(field.kind, true)?;
			}
		}

		decoder.finish()
	}
}

pub struct TestWriter {
	inner: MessageEncoder<BytesOwned>
}

impl TestWriter {
	pub fn new() -> Self {
		Self {
			inner: MessageEncoder::new_owned()
		}
	}

	pub fn write_tag(mut self, fieldnum: u64, wtype: WireType) -> Self {
		self.inner.write_tag(fieldnum, wtype).unwrap();
		self
	}

	pub fn write_len(mut self, len: u64) -> Self {
		self.inner.write_len(len).unwrap();
		self
	}

	pub fn write_bytes(mut self, bytes: &[u8]) -> Self {
		self.inner.write_bytes(bytes).unwrap();
		self
	}

	pub fn write_varint(mut self, val: u64) -> Self {
		self.inner.write_varint(val).unwrap();
		self
	}

	#[track_caller]
	pub fn cmp<T>(self, mut other: T) -> Self
	where T: EncodeMessage + for<'a> DecodeMessage<'a> + Debug + Eq {
		let n_bytes = other.write_to_bytes().unwrap();
		assert_eq!(self.inner.inner().as_slice(), n_bytes);

		let n_v = T::parse_from_bytes(self.inner.inner().as_slice())
			.unwrap();
		assert_eq!(other, n_v);

		self
	}
}