1 #![rustfmt::skip]
2 /// @generated rust packets from test.
3 use bytes::{Buf, BufMut, Bytes, BytesMut};
4 use std::convert::{TryFrom, TryInto};
5 use std::cell::Cell;
6 use std::fmt;
7 use std::result::Result;
8 use pdl_runtime::{DecodeError, EncodeError, Packet};
9 /// Private prevents users from creating arbitrary scalar values
10 /// in situations where the value needs to be validated.
11 /// Users can freely deref the value, but only the backend
12 /// may create it.
13 #[derive(Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)]
14 pub struct Private<T>(T);
15 impl<T> std::ops::Deref for Private<T> {
16     type Target = T;
deref(&self) -> &Self::Target17     fn deref(&self) -> &Self::Target {
18         &self.0
19     }
20 }
21 impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result22     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
23         T::fmt(&self.0, f)
24     }
25 }
26 #[repr(u64)]
27 #[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
28 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
29 #[cfg_attr(feature = "serde", serde(try_from = "u16", into = "u16"))]
30 pub enum Enum16 {
31     A = 0x1,
32     B = 0x2,
33 }
34 impl TryFrom<u16> for Enum16 {
35     type Error = u16;
try_from(value: u16) -> Result<Self, Self::Error>36     fn try_from(value: u16) -> Result<Self, Self::Error> {
37         match value {
38             0x1 => Ok(Enum16::A),
39             0x2 => Ok(Enum16::B),
40             _ => Err(value),
41         }
42     }
43 }
44 impl From<&Enum16> for u16 {
from(value: &Enum16) -> Self45     fn from(value: &Enum16) -> Self {
46         match value {
47             Enum16::A => 0x1,
48             Enum16::B => 0x2,
49         }
50     }
51 }
52 impl From<Enum16> for u16 {
from(value: Enum16) -> Self53     fn from(value: Enum16) -> Self {
54         (&value).into()
55     }
56 }
57 impl From<Enum16> for i32 {
from(value: Enum16) -> Self58     fn from(value: Enum16) -> Self {
59         u16::from(value) as Self
60     }
61 }
62 impl From<Enum16> for i64 {
from(value: Enum16) -> Self63     fn from(value: Enum16) -> Self {
64         u16::from(value) as Self
65     }
66 }
67 impl From<Enum16> for u32 {
from(value: Enum16) -> Self68     fn from(value: Enum16) -> Self {
69         u16::from(value) as Self
70     }
71 }
72 impl From<Enum16> for u64 {
from(value: Enum16) -> Self73     fn from(value: Enum16) -> Self {
74         u16::from(value) as Self
75     }
76 }
77 #[derive(Debug, Clone, PartialEq, Eq)]
78 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
79 pub enum FooDataChild {
80     Bar(BarData),
81     Baz(BazData),
82     Payload(Bytes),
83     None,
84 }
85 impl FooDataChild {
get_total_size(&self) -> usize86     fn get_total_size(&self) -> usize {
87         match self {
88             FooDataChild::Bar(value) => value.get_total_size(),
89             FooDataChild::Baz(value) => value.get_total_size(),
90             FooDataChild::Payload(bytes) => bytes.len(),
91             FooDataChild::None => 0,
92         }
93     }
94 }
95 #[derive(Debug, Clone, PartialEq, Eq)]
96 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
97 pub enum FooChild {
98     Bar(Bar),
99     Baz(Baz),
100     Payload(Bytes),
101     None,
102 }
103 #[derive(Debug, Clone, PartialEq, Eq)]
104 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
105 pub struct FooData {
106     a: u8,
107     b: Enum16,
108     child: FooDataChild,
109 }
110 #[derive(Debug, Clone, PartialEq, Eq)]
111 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
112 pub struct Foo {
113     #[cfg_attr(feature = "serde", serde(flatten))]
114     foo: FooData,
115 }
116 #[derive(Debug)]
117 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
118 pub struct FooBuilder {
119     pub a: u8,
120     pub b: Enum16,
121     pub payload: Option<Bytes>,
122 }
123 impl FooData {
conforms(bytes: &[u8]) -> bool124     fn conforms(bytes: &[u8]) -> bool {
125         bytes.len() >= 4
126     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>127     fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
128         let mut cell = Cell::new(bytes);
129         let packet = Self::parse_inner(&mut cell)?;
130         Ok(packet)
131     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>132     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
133         if bytes.get().remaining() < 1 {
134             return Err(DecodeError::InvalidLengthError {
135                 obj: "Foo",
136                 wanted: 1,
137                 got: bytes.get().remaining(),
138             });
139         }
140         let a = bytes.get_mut().get_u8();
141         if bytes.get().remaining() < 2 {
142             return Err(DecodeError::InvalidLengthError {
143                 obj: "Foo",
144                 wanted: 2,
145                 got: bytes.get().remaining(),
146             });
147         }
148         let b = Enum16::try_from(bytes.get_mut().get_u16())
149             .map_err(|unknown_val| DecodeError::InvalidEnumValueError {
150                 obj: "Foo",
151                 field: "b",
152                 value: unknown_val as u64,
153                 type_: "Enum16",
154             })?;
155         if bytes.get().remaining() < 1 {
156             return Err(DecodeError::InvalidLengthError {
157                 obj: "Foo",
158                 wanted: 1,
159                 got: bytes.get().remaining(),
160             });
161         }
162         let payload_size = bytes.get_mut().get_u8() as usize;
163         if bytes.get().remaining() < payload_size {
164             return Err(DecodeError::InvalidLengthError {
165                 obj: "Foo",
166                 wanted: payload_size,
167                 got: bytes.get().remaining(),
168             });
169         }
170         let payload = &bytes.get()[..payload_size];
171         bytes.get_mut().advance(payload_size);
172         let child = match (a, b) {
173             (100, _) if BarData::conforms(&payload) => {
174                 let mut cell = Cell::new(payload);
175                 let child_data = BarData::parse_inner(&mut cell)?;
176                 FooDataChild::Bar(child_data)
177             }
178             (_, Enum16::B) if BazData::conforms(&payload) => {
179                 let mut cell = Cell::new(payload);
180                 let child_data = BazData::parse_inner(&mut cell)?;
181                 FooDataChild::Baz(child_data)
182             }
183             _ if !payload.is_empty() => {
184                 FooDataChild::Payload(Bytes::copy_from_slice(payload))
185             }
186             _ => FooDataChild::None,
187         };
188         Ok(Self { a, b, child })
189     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>190     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
191         buffer.put_u8(self.a);
192         buffer.put_u16(u16::from(self.b));
193         if self.child.get_total_size() > 0xff {
194             return Err(EncodeError::SizeOverflow {
195                 packet: "Foo",
196                 field: "_payload_",
197                 size: self.child.get_total_size(),
198                 maximum_size: 0xff,
199             });
200         }
201         buffer.put_u8(self.child.get_total_size() as u8);
202         match &self.child {
203             FooDataChild::Bar(child) => child.write_to(buffer)?,
204             FooDataChild::Baz(child) => child.write_to(buffer)?,
205             FooDataChild::Payload(payload) => buffer.put_slice(payload),
206             FooDataChild::None => {}
207         }
208         Ok(())
209     }
get_total_size(&self) -> usize210     fn get_total_size(&self) -> usize {
211         self.get_size()
212     }
get_size(&self) -> usize213     fn get_size(&self) -> usize {
214         4 + self.child.get_total_size()
215     }
216 }
217 impl Packet for Foo {
encoded_len(&self) -> usize218     fn encoded_len(&self) -> usize {
219         self.get_size()
220     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>221     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
222         self.foo.write_to(buf)
223     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>224     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
225         unimplemented!("Rust legacy does not implement full packet trait")
226     }
227 }
228 impl TryFrom<Foo> for Bytes {
229     type Error = EncodeError;
try_from(packet: Foo) -> Result<Self, Self::Error>230     fn try_from(packet: Foo) -> Result<Self, Self::Error> {
231         packet.encode_to_bytes()
232     }
233 }
234 impl TryFrom<Foo> for Vec<u8> {
235     type Error = EncodeError;
try_from(packet: Foo) -> Result<Self, Self::Error>236     fn try_from(packet: Foo) -> Result<Self, Self::Error> {
237         packet.encode_to_vec()
238     }
239 }
240 impl Foo {
parse(bytes: &[u8]) -> Result<Self, DecodeError>241     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
242         let mut cell = Cell::new(bytes);
243         let packet = Self::parse_inner(&mut cell)?;
244         Ok(packet)
245     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>246     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
247         let data = FooData::parse_inner(&mut bytes)?;
248         Self::new(data)
249     }
specialize(&self) -> FooChild250     pub fn specialize(&self) -> FooChild {
251         match &self.foo.child {
252             FooDataChild::Bar(_) => FooChild::Bar(Bar::new(self.foo.clone()).unwrap()),
253             FooDataChild::Baz(_) => FooChild::Baz(Baz::new(self.foo.clone()).unwrap()),
254             FooDataChild::Payload(payload) => FooChild::Payload(payload.clone()),
255             FooDataChild::None => FooChild::None,
256         }
257     }
new(foo: FooData) -> Result<Self, DecodeError>258     fn new(foo: FooData) -> Result<Self, DecodeError> {
259         Ok(Self { foo })
260     }
get_a(&self) -> u8261     pub fn get_a(&self) -> u8 {
262         self.foo.a
263     }
get_b(&self) -> Enum16264     pub fn get_b(&self) -> Enum16 {
265         self.foo.b
266     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>267     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
268         self.foo.write_to(buffer)
269     }
get_size(&self) -> usize270     pub fn get_size(&self) -> usize {
271         self.foo.get_size()
272     }
273 }
274 impl FooBuilder {
build(self) -> Foo275     pub fn build(self) -> Foo {
276         let foo = FooData {
277             a: self.a,
278             b: self.b,
279             child: match self.payload {
280                 None => FooDataChild::None,
281                 Some(bytes) => FooDataChild::Payload(bytes),
282             },
283         };
284         Foo::new(foo).unwrap()
285     }
286 }
287 impl From<FooBuilder> for Foo {
from(builder: FooBuilder) -> Foo288     fn from(builder: FooBuilder) -> Foo {
289         builder.build().into()
290     }
291 }
292 #[derive(Debug, Clone, PartialEq, Eq)]
293 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
294 pub struct BarData {
295     x: u8,
296 }
297 #[derive(Debug, Clone, PartialEq, Eq)]
298 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
299 pub struct Bar {
300     #[cfg_attr(feature = "serde", serde(flatten))]
301     foo: FooData,
302     #[cfg_attr(feature = "serde", serde(flatten))]
303     bar: BarData,
304 }
305 #[derive(Debug)]
306 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
307 pub struct BarBuilder {
308     pub b: Enum16,
309     pub x: u8,
310 }
311 impl BarData {
conforms(bytes: &[u8]) -> bool312     fn conforms(bytes: &[u8]) -> bool {
313         bytes.len() >= 1
314     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>315     fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
316         let mut cell = Cell::new(bytes);
317         let packet = Self::parse_inner(&mut cell)?;
318         Ok(packet)
319     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>320     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
321         if bytes.get().remaining() < 1 {
322             return Err(DecodeError::InvalidLengthError {
323                 obj: "Bar",
324                 wanted: 1,
325                 got: bytes.get().remaining(),
326             });
327         }
328         let x = bytes.get_mut().get_u8();
329         Ok(Self { x })
330     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>331     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
332         buffer.put_u8(self.x);
333         Ok(())
334     }
get_total_size(&self) -> usize335     fn get_total_size(&self) -> usize {
336         self.get_size()
337     }
get_size(&self) -> usize338     fn get_size(&self) -> usize {
339         1
340     }
341 }
342 impl Packet for Bar {
encoded_len(&self) -> usize343     fn encoded_len(&self) -> usize {
344         self.get_size()
345     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>346     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
347         self.foo.write_to(buf)
348     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>349     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
350         unimplemented!("Rust legacy does not implement full packet trait")
351     }
352 }
353 impl TryFrom<Bar> for Bytes {
354     type Error = EncodeError;
try_from(packet: Bar) -> Result<Self, Self::Error>355     fn try_from(packet: Bar) -> Result<Self, Self::Error> {
356         packet.encode_to_bytes()
357     }
358 }
359 impl TryFrom<Bar> for Vec<u8> {
360     type Error = EncodeError;
try_from(packet: Bar) -> Result<Self, Self::Error>361     fn try_from(packet: Bar) -> Result<Self, Self::Error> {
362         packet.encode_to_vec()
363     }
364 }
365 impl From<Bar> for Foo {
from(packet: Bar) -> Foo366     fn from(packet: Bar) -> Foo {
367         Foo::new(packet.foo).unwrap()
368     }
369 }
370 impl TryFrom<Foo> for Bar {
371     type Error = DecodeError;
try_from(packet: Foo) -> Result<Bar, Self::Error>372     fn try_from(packet: Foo) -> Result<Bar, Self::Error> {
373         Bar::new(packet.foo)
374     }
375 }
376 impl Bar {
parse(bytes: &[u8]) -> Result<Self, DecodeError>377     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
378         let mut cell = Cell::new(bytes);
379         let packet = Self::parse_inner(&mut cell)?;
380         Ok(packet)
381     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>382     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
383         let data = FooData::parse_inner(&mut bytes)?;
384         Self::new(data)
385     }
new(foo: FooData) -> Result<Self, DecodeError>386     fn new(foo: FooData) -> Result<Self, DecodeError> {
387         let bar = match &foo.child {
388             FooDataChild::Bar(value) => value.clone(),
389             _ => {
390                 return Err(DecodeError::InvalidChildError {
391                     expected: stringify!(FooDataChild::Bar),
392                     actual: format!("{:?}", & foo.child),
393                 });
394             }
395         };
396         Ok(Self { foo, bar })
397     }
get_a(&self) -> u8398     pub fn get_a(&self) -> u8 {
399         self.foo.a
400     }
get_b(&self) -> Enum16401     pub fn get_b(&self) -> Enum16 {
402         self.foo.b
403     }
get_x(&self) -> u8404     pub fn get_x(&self) -> u8 {
405         self.bar.x
406     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>407     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
408         self.bar.write_to(buffer)
409     }
get_size(&self) -> usize410     pub fn get_size(&self) -> usize {
411         self.foo.get_size()
412     }
413 }
414 impl BarBuilder {
build(self) -> Bar415     pub fn build(self) -> Bar {
416         let bar = BarData { x: self.x };
417         let foo = FooData {
418             a: 100,
419             b: self.b,
420             child: FooDataChild::Bar(bar),
421         };
422         Bar::new(foo).unwrap()
423     }
424 }
425 impl From<BarBuilder> for Foo {
from(builder: BarBuilder) -> Foo426     fn from(builder: BarBuilder) -> Foo {
427         builder.build().into()
428     }
429 }
430 impl From<BarBuilder> for Bar {
from(builder: BarBuilder) -> Bar431     fn from(builder: BarBuilder) -> Bar {
432         builder.build().into()
433     }
434 }
435 #[derive(Debug, Clone, PartialEq, Eq)]
436 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
437 pub struct BazData {
438     y: u16,
439 }
440 #[derive(Debug, Clone, PartialEq, Eq)]
441 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
442 pub struct Baz {
443     #[cfg_attr(feature = "serde", serde(flatten))]
444     foo: FooData,
445     #[cfg_attr(feature = "serde", serde(flatten))]
446     baz: BazData,
447 }
448 #[derive(Debug)]
449 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
450 pub struct BazBuilder {
451     pub a: u8,
452     pub y: u16,
453 }
454 impl BazData {
conforms(bytes: &[u8]) -> bool455     fn conforms(bytes: &[u8]) -> bool {
456         bytes.len() >= 2
457     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>458     fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
459         let mut cell = Cell::new(bytes);
460         let packet = Self::parse_inner(&mut cell)?;
461         Ok(packet)
462     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>463     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
464         if bytes.get().remaining() < 2 {
465             return Err(DecodeError::InvalidLengthError {
466                 obj: "Baz",
467                 wanted: 2,
468                 got: bytes.get().remaining(),
469             });
470         }
471         let y = bytes.get_mut().get_u16();
472         Ok(Self { y })
473     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>474     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
475         buffer.put_u16(self.y);
476         Ok(())
477     }
get_total_size(&self) -> usize478     fn get_total_size(&self) -> usize {
479         self.get_size()
480     }
get_size(&self) -> usize481     fn get_size(&self) -> usize {
482         2
483     }
484 }
485 impl Packet for Baz {
encoded_len(&self) -> usize486     fn encoded_len(&self) -> usize {
487         self.get_size()
488     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>489     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
490         self.foo.write_to(buf)
491     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>492     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
493         unimplemented!("Rust legacy does not implement full packet trait")
494     }
495 }
496 impl TryFrom<Baz> for Bytes {
497     type Error = EncodeError;
try_from(packet: Baz) -> Result<Self, Self::Error>498     fn try_from(packet: Baz) -> Result<Self, Self::Error> {
499         packet.encode_to_bytes()
500     }
501 }
502 impl TryFrom<Baz> for Vec<u8> {
503     type Error = EncodeError;
try_from(packet: Baz) -> Result<Self, Self::Error>504     fn try_from(packet: Baz) -> Result<Self, Self::Error> {
505         packet.encode_to_vec()
506     }
507 }
508 impl From<Baz> for Foo {
from(packet: Baz) -> Foo509     fn from(packet: Baz) -> Foo {
510         Foo::new(packet.foo).unwrap()
511     }
512 }
513 impl TryFrom<Foo> for Baz {
514     type Error = DecodeError;
try_from(packet: Foo) -> Result<Baz, Self::Error>515     fn try_from(packet: Foo) -> Result<Baz, Self::Error> {
516         Baz::new(packet.foo)
517     }
518 }
519 impl Baz {
parse(bytes: &[u8]) -> Result<Self, DecodeError>520     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
521         let mut cell = Cell::new(bytes);
522         let packet = Self::parse_inner(&mut cell)?;
523         Ok(packet)
524     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>525     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
526         let data = FooData::parse_inner(&mut bytes)?;
527         Self::new(data)
528     }
new(foo: FooData) -> Result<Self, DecodeError>529     fn new(foo: FooData) -> Result<Self, DecodeError> {
530         let baz = match &foo.child {
531             FooDataChild::Baz(value) => value.clone(),
532             _ => {
533                 return Err(DecodeError::InvalidChildError {
534                     expected: stringify!(FooDataChild::Baz),
535                     actual: format!("{:?}", & foo.child),
536                 });
537             }
538         };
539         Ok(Self { foo, baz })
540     }
get_a(&self) -> u8541     pub fn get_a(&self) -> u8 {
542         self.foo.a
543     }
get_b(&self) -> Enum16544     pub fn get_b(&self) -> Enum16 {
545         self.foo.b
546     }
get_y(&self) -> u16547     pub fn get_y(&self) -> u16 {
548         self.baz.y
549     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>550     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
551         self.baz.write_to(buffer)
552     }
get_size(&self) -> usize553     pub fn get_size(&self) -> usize {
554         self.foo.get_size()
555     }
556 }
557 impl BazBuilder {
build(self) -> Baz558     pub fn build(self) -> Baz {
559         let baz = BazData { y: self.y };
560         let foo = FooData {
561             a: self.a,
562             b: Enum16::B,
563             child: FooDataChild::Baz(baz),
564         };
565         Baz::new(foo).unwrap()
566     }
567 }
568 impl From<BazBuilder> for Foo {
from(builder: BazBuilder) -> Foo569     fn from(builder: BazBuilder) -> Foo {
570         builder.build().into()
571     }
572 }
573 impl From<BazBuilder> for Baz {
from(builder: BazBuilder) -> Baz574     fn from(builder: BazBuilder) -> Baz {
575         builder.build().into()
576     }
577 }
578