krabka_protocol/opt/rustwide/workdir/generated/
RegisterBrokerRecord.owned.rs

1// AUTO-GENERATED by krabka-protocol-codegen against a9ce3221537b8653448750697915607dc7936cf3. Do not edit.
2
3use bytes::{Buf, BufMut};
4
5use crate::{
6    Decode, Encode, ProtocolError, UnknownTaggedFields,
7    codegen_helpers::is_default,
8    primitives::{
9        array::{
10            array_len_prefix_len, get_array_len, get_nullable_array_len,
11            nullable_array_len_prefix_len, put_array_len, put_nullable_array_len,
12        },
13        fixed::{
14            get_bool, get_i16, get_i32, get_i64, get_u16, put_bool, put_i16, put_i32, put_i64,
15            put_u16,
16        },
17        string_bytes::{
18            compact_nullable_string_len, compact_string_len, get_compact_nullable_string_owned,
19            get_compact_string_owned, get_nullable_string_owned, get_string_owned,
20            nullable_string_len, put_compact_nullable_string, put_compact_string,
21            put_nullable_string, put_string, string_len,
22        },
23        uuid::{Uuid, get_uuid, put_uuid},
24    },
25    tagged_fields::{WriteTaggedFields, encode_to_bytes, read_tagged_fields, tagged_fields_len},
26};
27pub const MIN_VERSION: i16 = 0;
28pub const MAX_VERSION: i16 = 4;
29pub const FLEXIBLE_MIN: i16 = 0;
30#[inline]
31#[must_use]
32pub fn is_flexible(version: i16) -> bool {
33    version >= FLEXIBLE_MIN
34}
35#[derive(Debug, Clone, PartialEq, Eq)]
36pub struct RegisterBrokerRecord {
37    pub broker_id: i32,
38    pub is_migrating_zk_broker: bool,
39    pub incarnation_id: Uuid,
40    pub broker_epoch: i64,
41    pub end_points: Vec<BrokerEndpoint>,
42    pub features: Vec<BrokerFeature>,
43    pub rack: Option<String>,
44    pub fenced: bool,
45    pub in_controlled_shutdown: bool,
46    pub log_dirs: Vec<Uuid>,
47    pub cordoned_log_dirs: Option<Vec<Uuid>>,
48    pub unknown_tagged_fields: UnknownTaggedFields,
49}
50impl Default for RegisterBrokerRecord {
51    fn default() -> Self {
52        Self {
53            broker_id: 0i32,
54            is_migrating_zk_broker: false,
55            incarnation_id: Uuid::default(),
56            broker_epoch: 0i64,
57            end_points: Vec::new(),
58            features: Vec::new(),
59            rack: Some(String::new()),
60            fenced: true,
61            in_controlled_shutdown: false,
62            log_dirs: Vec::new(),
63            cordoned_log_dirs: None,
64            unknown_tagged_fields: UnknownTaggedFields::default(),
65        }
66    }
67}
68impl RegisterBrokerRecord {
69    fn encode_field_0<B: BufMut>(&self, buf: &mut B, version: i16, _flex: bool) {
70        if version >= 0 {
71            put_i32(buf, self.broker_id);
72        }
73    }
74    fn encode_field_1<B: BufMut>(&self, buf: &mut B, version: i16, _flex: bool) {
75        if version >= 2 {
76            put_bool(buf, self.is_migrating_zk_broker);
77        }
78    }
79    fn encode_field_2<B: BufMut>(&self, buf: &mut B, version: i16, _flex: bool) {
80        if version >= 0 {
81            put_uuid(buf, self.incarnation_id);
82        }
83    }
84    fn encode_field_3<B: BufMut>(&self, buf: &mut B, version: i16, _flex: bool) {
85        if version >= 0 {
86            put_i64(buf, self.broker_epoch);
87        }
88    }
89    fn encode_field_4<B: BufMut>(
90        &self,
91        buf: &mut B,
92        version: i16,
93        flex: bool,
94    ) -> Result<(), ProtocolError> {
95        if version >= 0 {
96            {
97                put_array_len(buf, (self.end_points).len(), flex)?;
98                for it in &self.end_points {
99                    it.encode(buf, version)?;
100                }
101            }
102        }
103        Ok(())
104    }
105    fn encode_field_5<B: BufMut>(
106        &self,
107        buf: &mut B,
108        version: i16,
109        flex: bool,
110    ) -> Result<(), ProtocolError> {
111        if version >= 0 {
112            {
113                put_array_len(buf, (self.features).len(), flex)?;
114                for it in &self.features {
115                    it.encode(buf, version)?;
116                }
117            }
118        }
119        Ok(())
120    }
121    fn encode_field_6<B: BufMut>(
122        &self,
123        buf: &mut B,
124        version: i16,
125        flex: bool,
126    ) -> Result<(), ProtocolError> {
127        if version >= 0 {
128            if flex {
129                put_compact_nullable_string(buf, self.rack.as_deref())?;
130            } else {
131                put_nullable_string(buf, self.rack.as_deref())?;
132            }
133        }
134        Ok(())
135    }
136    fn encode_field_7<B: BufMut>(&self, buf: &mut B, version: i16, _flex: bool) {
137        if version >= 0 {
138            put_bool(buf, self.fenced);
139        }
140    }
141    fn encode_field_8<B: BufMut>(&self, buf: &mut B, version: i16, _flex: bool) {
142        if version >= 1 {
143            put_bool(buf, self.in_controlled_shutdown);
144        }
145    }
146    fn encode_tagged_fields<B: BufMut>(
147        &self,
148        buf: &mut B,
149        version: i16,
150        flex: bool,
151    ) -> Result<(), ProtocolError> {
152        if flex {
153            let mut tagged = WriteTaggedFields::new();
154            if version >= 3 && !(is_default(&self.log_dirs)) {
155                let payload = encode_to_bytes(
156                    {
157                        let prefix = array_len_prefix_len((self.log_dirs).len(), flex);
158                        let body: usize = (self.log_dirs).iter().map(|_| 16).sum();
159                        prefix + body
160                    },
161                    |b| {
162                        {
163                            put_array_len(b, (self.log_dirs).len(), flex)?;
164                            for it in &self.log_dirs {
165                                put_uuid(b, *it);
166                            }
167                        }
168                        Ok(())
169                    },
170                )?;
171                tagged.add(0, payload);
172            }
173            if version >= 4 && self.cordoned_log_dirs.is_some() {
174                let payload = encode_to_bytes(
175                    {
176                        let opt: Option<&Vec<_>> = (self.cordoned_log_dirs).as_ref();
177                        let prefix = nullable_array_len_prefix_len(opt.map(Vec::len), flex);
178                        let body: usize = opt.map_or(0, |v| v.iter().map(|_| 16).sum());
179                        prefix + body
180                    },
181                    |b| {
182                        {
183                            let len = (self.cordoned_log_dirs).as_ref().map(Vec::len);
184                            put_nullable_array_len(b, len, flex)?;
185                            if let Some(v) = &self.cordoned_log_dirs {
186                                for it in v {
187                                    put_uuid(b, *it);
188                                }
189                            }
190                        }
191                        Ok(())
192                    },
193                )?;
194                tagged.add(1, payload);
195            }
196            tagged.write(buf, &self.unknown_tagged_fields)?;
197        }
198        Ok(())
199    }
200    fn decode_field_0<B: Buf>(
201        out: &mut Self,
202        buf: &mut B,
203        version: i16,
204        _flex: bool,
205    ) -> Result<(), ProtocolError> {
206        if version >= 0 {
207            out.broker_id = get_i32(buf)?;
208        }
209        Ok(())
210    }
211    fn decode_field_1<B: Buf>(
212        out: &mut Self,
213        buf: &mut B,
214        version: i16,
215        _flex: bool,
216    ) -> Result<(), ProtocolError> {
217        if version >= 2 {
218            out.is_migrating_zk_broker = get_bool(buf)?;
219        }
220        Ok(())
221    }
222    fn decode_field_2<B: Buf>(
223        out: &mut Self,
224        buf: &mut B,
225        version: i16,
226        _flex: bool,
227    ) -> Result<(), ProtocolError> {
228        if version >= 0 {
229            out.incarnation_id = get_uuid(buf)?;
230        }
231        Ok(())
232    }
233    fn decode_field_3<B: Buf>(
234        out: &mut Self,
235        buf: &mut B,
236        version: i16,
237        _flex: bool,
238    ) -> Result<(), ProtocolError> {
239        if version >= 0 {
240            out.broker_epoch = get_i64(buf)?;
241        }
242        Ok(())
243    }
244    fn decode_field_4<B: Buf>(
245        out: &mut Self,
246        buf: &mut B,
247        version: i16,
248        flex: bool,
249    ) -> Result<(), ProtocolError> {
250        if version >= 0 {
251            out.end_points = {
252                let n = get_array_len(buf, flex)?;
253                let mut v = Vec::with_capacity(n);
254                for _ in 0..n {
255                    v.push(BrokerEndpoint::decode(buf, version)?);
256                }
257                v
258            };
259        }
260        Ok(())
261    }
262    fn decode_field_5<B: Buf>(
263        out: &mut Self,
264        buf: &mut B,
265        version: i16,
266        flex: bool,
267    ) -> Result<(), ProtocolError> {
268        if version >= 0 {
269            out.features = {
270                let n = get_array_len(buf, flex)?;
271                let mut v = Vec::with_capacity(n);
272                for _ in 0..n {
273                    v.push(BrokerFeature::decode(buf, version)?);
274                }
275                v
276            };
277        }
278        Ok(())
279    }
280    fn decode_field_6<B: Buf>(
281        out: &mut Self,
282        buf: &mut B,
283        version: i16,
284        flex: bool,
285    ) -> Result<(), ProtocolError> {
286        if version >= 0 {
287            out.rack = if flex {
288                get_compact_nullable_string_owned(buf)?
289            } else {
290                get_nullable_string_owned(buf)?
291            };
292        }
293        Ok(())
294    }
295    fn decode_field_7<B: Buf>(
296        out: &mut Self,
297        buf: &mut B,
298        version: i16,
299        _flex: bool,
300    ) -> Result<(), ProtocolError> {
301        if version >= 0 {
302            out.fenced = get_bool(buf)?;
303        }
304        Ok(())
305    }
306    fn decode_field_8<B: Buf>(
307        out: &mut Self,
308        buf: &mut B,
309        version: i16,
310        _flex: bool,
311    ) -> Result<(), ProtocolError> {
312        if version >= 1 {
313            out.in_controlled_shutdown = get_bool(buf)?;
314        }
315        Ok(())
316    }
317    fn decode_tagged_fields<B: Buf>(
318        out: &mut Self,
319        buf: &mut B,
320        version: i16,
321        flex: bool,
322    ) -> Result<(), ProtocolError> {
323        if flex {
324            let mut tag_log_dirs = None;
325            let mut tag_cordoned_log_dirs = None;
326            out.unknown_tagged_fields = read_tagged_fields(buf, |tag, payload| match tag {
327                0 if version >= 3 => {
328                    tag_log_dirs = Some({
329                        let b: &mut &[u8] = payload;
330                        {
331                            let n = get_array_len(b, flex)?;
332                            let mut v = Vec::with_capacity(n);
333                            for _ in 0..n {
334                                v.push(get_uuid(b)?);
335                            }
336                            v
337                        }
338                    });
339                    Ok(true)
340                }
341                0 => Err(ProtocolError::TagNotValidForVersion { tag: 0, version }),
342                1 if version >= 4 => {
343                    tag_cordoned_log_dirs = Some({
344                        let b: &mut &[u8] = payload;
345                        {
346                            let opt = get_nullable_array_len(b, flex)?;
347                            match opt {
348                                None => None,
349                                Some(n) => {
350                                    let mut v = Vec::with_capacity(n);
351                                    for _ in 0..n {
352                                        v.push(get_uuid(b)?);
353                                    }
354                                    Some(v)
355                                }
356                            }
357                        }
358                    });
359                    Ok(true)
360                }
361                1 => Err(ProtocolError::TagNotValidForVersion { tag: 1, version }),
362                _ => Ok(false),
363            })?;
364            if let Some(v) = tag_log_dirs {
365                out.log_dirs = v;
366            }
367            if let Some(v) = tag_cordoned_log_dirs {
368                out.cordoned_log_dirs = v;
369            }
370        }
371        Ok(())
372    }
373}
374impl Encode for RegisterBrokerRecord {
375    fn encode<B: BufMut>(&self, buf: &mut B, version: i16) -> Result<(), ProtocolError> {
376        if !(MIN_VERSION..=MAX_VERSION).contains(&version) {
377            return Err(ProtocolError::SchemaMismatch(
378                "RegisterBrokerRecord version out of range",
379            ));
380        }
381        let flex = is_flexible(version);
382        self.encode_field_0(buf, version, flex);
383        self.encode_field_1(buf, version, flex);
384        self.encode_field_2(buf, version, flex);
385        self.encode_field_3(buf, version, flex);
386        self.encode_field_4(buf, version, flex)?;
387        self.encode_field_5(buf, version, flex)?;
388        self.encode_field_6(buf, version, flex)?;
389        self.encode_field_7(buf, version, flex);
390        self.encode_field_8(buf, version, flex);
391        self.encode_tagged_fields(buf, version, flex)?;
392        Ok(())
393    }
394    fn encoded_len(&self, version: i16) -> usize {
395        let flex = is_flexible(version);
396        let mut n: usize = 0;
397        if version >= 0 {
398            n += 4;
399        }
400        if version >= 2 {
401            n += 1;
402        }
403        if version >= 0 {
404            n += 16;
405        }
406        if version >= 0 {
407            n += 8;
408        }
409        if version >= 0 {
410            n += {
411                let prefix = array_len_prefix_len((self.end_points).len(), flex);
412                let body: usize = (self.end_points)
413                    .iter()
414                    .map(|it| it.encoded_len(version))
415                    .sum();
416                prefix + body
417            };
418        }
419        if version >= 0 {
420            n += {
421                let prefix = array_len_prefix_len((self.features).len(), flex);
422                let body: usize = (self.features)
423                    .iter()
424                    .map(|it| it.encoded_len(version))
425                    .sum();
426                prefix + body
427            };
428        }
429        if version >= 0 {
430            n += if flex {
431                compact_nullable_string_len(self.rack.as_deref())
432            } else {
433                nullable_string_len(self.rack.as_deref())
434            };
435        }
436        if version >= 0 {
437            n += 1;
438        }
439        if version >= 1 {
440            n += 1;
441        }
442        if flex {
443            let mut known_pairs: Vec<(u32, usize)> = Vec::new();
444            if version >= 3 && !(is_default(&self.log_dirs)) {
445                known_pairs.push((0, {
446                    let prefix = array_len_prefix_len((self.log_dirs).len(), flex);
447                    let body: usize = (self.log_dirs).iter().map(|_| 16).sum();
448                    prefix + body
449                }));
450            }
451            if version >= 4 && self.cordoned_log_dirs.is_some() {
452                known_pairs.push((1, {
453                    let opt: Option<&Vec<_>> = (self.cordoned_log_dirs).as_ref();
454                    let prefix = nullable_array_len_prefix_len(opt.map(Vec::len), flex);
455                    let body: usize = opt.map_or(0, |v| v.iter().map(|_| 16).sum());
456                    prefix + body
457                }));
458            }
459            n += tagged_fields_len(&known_pairs, &self.unknown_tagged_fields);
460        }
461        n
462    }
463}
464impl Decode<'_> for RegisterBrokerRecord {
465    fn decode<B: Buf>(buf: &mut B, version: i16) -> Result<Self, ProtocolError> {
466        if !(MIN_VERSION..=MAX_VERSION).contains(&version) {
467            return Err(ProtocolError::SchemaMismatch(
468                "RegisterBrokerRecord version out of range",
469            ));
470        }
471        let flex = is_flexible(version);
472        let mut out = Self::default();
473        Self::decode_field_0(&mut out, buf, version, flex)?;
474        Self::decode_field_1(&mut out, buf, version, flex)?;
475        Self::decode_field_2(&mut out, buf, version, flex)?;
476        Self::decode_field_3(&mut out, buf, version, flex)?;
477        Self::decode_field_4(&mut out, buf, version, flex)?;
478        Self::decode_field_5(&mut out, buf, version, flex)?;
479        Self::decode_field_6(&mut out, buf, version, flex)?;
480        Self::decode_field_7(&mut out, buf, version, flex)?;
481        Self::decode_field_8(&mut out, buf, version, flex)?;
482        Self::decode_tagged_fields(&mut out, buf, version, flex)?;
483        Ok(out)
484    }
485}
486#[cfg(test)]
487impl RegisterBrokerRecord {
488    #[must_use]
489    pub fn populated(version: i16) -> Self {
490        let mut m = Self::default();
491        if version >= 0 {
492            m.broker_id = 1i32;
493        }
494        if version >= 2 {
495            m.is_migrating_zk_broker = true;
496        }
497        if version >= 0 {
498            m.incarnation_id = Uuid([1u8; 16]);
499        }
500        if version >= 0 {
501            m.broker_epoch = 1i64;
502        }
503        if version >= 0 {
504            m.end_points = vec![BrokerEndpoint::populated(version)];
505        }
506        if version >= 0 {
507            m.features = vec![BrokerFeature::populated(version)];
508        }
509        if version >= 0 {
510            m.rack = Some("x".to_owned());
511        }
512        if version >= 0 {
513            m.fenced = true;
514        }
515        if version >= 1 {
516            m.in_controlled_shutdown = true;
517        }
518        if version >= 3 {
519            m.log_dirs = vec![Uuid([1u8; 16])];
520        }
521        if version >= 4 {
522            m.cordoned_log_dirs = Some(vec![Uuid([1u8; 16])]);
523        }
524        m
525    }
526}
527#[derive(Debug, Clone, PartialEq, Eq, Default)]
528pub struct BrokerEndpoint {
529    pub name: String,
530    pub host: String,
531    pub port: u16,
532    pub security_protocol: i16,
533    pub unknown_tagged_fields: UnknownTaggedFields,
534}
535impl Encode for BrokerEndpoint {
536    fn encode<B: BufMut>(&self, buf: &mut B, version: i16) -> Result<(), ProtocolError> {
537        let flex = version >= 0;
538        if version >= 0 {
539            if flex {
540                put_compact_string(buf, &self.name)?;
541            } else {
542                put_string(buf, &self.name)?;
543            }
544        }
545        if version >= 0 {
546            if flex {
547                put_compact_string(buf, &self.host)?;
548            } else {
549                put_string(buf, &self.host)?;
550            }
551        }
552        if version >= 0 {
553            put_u16(buf, self.port);
554        }
555        if version >= 0 {
556            put_i16(buf, self.security_protocol);
557        }
558        if flex {
559            let tagged = WriteTaggedFields::new();
560            tagged.write(buf, &self.unknown_tagged_fields)?;
561        }
562        Ok(())
563    }
564    fn encoded_len(&self, version: i16) -> usize {
565        let flex = version >= 0;
566        let mut n: usize = 0;
567        if version >= 0 {
568            n += if flex {
569                compact_string_len(&self.name)
570            } else {
571                string_len(&self.name)
572            };
573        }
574        if version >= 0 {
575            n += if flex {
576                compact_string_len(&self.host)
577            } else {
578                string_len(&self.host)
579            };
580        }
581        if version >= 0 {
582            n += 2;
583        }
584        if version >= 0 {
585            n += 2;
586        }
587        if flex {
588            let known_pairs: Vec<(u32, usize)> = Vec::new();
589            n += tagged_fields_len(&known_pairs, &self.unknown_tagged_fields);
590        }
591        n
592    }
593}
594impl Decode<'_> for BrokerEndpoint {
595    fn decode<B: Buf>(buf: &mut B, version: i16) -> Result<Self, ProtocolError> {
596        let flex = version >= 0;
597        let mut out = Self::default();
598        if version >= 0 {
599            out.name = if flex {
600                get_compact_string_owned(buf)?
601            } else {
602                get_string_owned(buf)?
603            };
604        }
605        if version >= 0 {
606            out.host = if flex {
607                get_compact_string_owned(buf)?
608            } else {
609                get_string_owned(buf)?
610            };
611        }
612        if version >= 0 {
613            out.port = get_u16(buf)?;
614        }
615        if version >= 0 {
616            out.security_protocol = get_i16(buf)?;
617        }
618        if flex {
619            out.unknown_tagged_fields = read_tagged_fields(buf, |_tag, _payload| Ok(false))?;
620        }
621        Ok(out)
622    }
623}
624#[cfg(test)]
625impl BrokerEndpoint {
626    #[must_use]
627    pub fn populated(version: i16) -> Self {
628        let mut m = Self::default();
629        if version >= 0 {
630            m.name = "x".to_owned();
631        }
632        if version >= 0 {
633            m.host = "x".to_owned();
634        }
635        if version >= 0 {
636            m.port = 1u16;
637        }
638        if version >= 0 {
639            m.security_protocol = 1i16;
640        }
641        m
642    }
643}
644#[derive(Debug, Clone, PartialEq, Eq, Default)]
645pub struct BrokerFeature {
646    pub name: String,
647    pub min_supported_version: i16,
648    pub max_supported_version: i16,
649    pub unknown_tagged_fields: UnknownTaggedFields,
650}
651impl Encode for BrokerFeature {
652    fn encode<B: BufMut>(&self, buf: &mut B, version: i16) -> Result<(), ProtocolError> {
653        let flex = version >= 0;
654        if version >= 0 {
655            if flex {
656                put_compact_string(buf, &self.name)?;
657            } else {
658                put_string(buf, &self.name)?;
659            }
660        }
661        if version >= 0 {
662            put_i16(buf, self.min_supported_version);
663        }
664        if version >= 0 {
665            put_i16(buf, self.max_supported_version);
666        }
667        if flex {
668            let tagged = WriteTaggedFields::new();
669            tagged.write(buf, &self.unknown_tagged_fields)?;
670        }
671        Ok(())
672    }
673    fn encoded_len(&self, version: i16) -> usize {
674        let flex = version >= 0;
675        let mut n: usize = 0;
676        if version >= 0 {
677            n += if flex {
678                compact_string_len(&self.name)
679            } else {
680                string_len(&self.name)
681            };
682        }
683        if version >= 0 {
684            n += 2;
685        }
686        if version >= 0 {
687            n += 2;
688        }
689        if flex {
690            let known_pairs: Vec<(u32, usize)> = Vec::new();
691            n += tagged_fields_len(&known_pairs, &self.unknown_tagged_fields);
692        }
693        n
694    }
695}
696impl Decode<'_> for BrokerFeature {
697    fn decode<B: Buf>(buf: &mut B, version: i16) -> Result<Self, ProtocolError> {
698        let flex = version >= 0;
699        let mut out = Self::default();
700        if version >= 0 {
701            out.name = if flex {
702                get_compact_string_owned(buf)?
703            } else {
704                get_string_owned(buf)?
705            };
706        }
707        if version >= 0 {
708            out.min_supported_version = get_i16(buf)?;
709        }
710        if version >= 0 {
711            out.max_supported_version = get_i16(buf)?;
712        }
713        if flex {
714            out.unknown_tagged_fields = read_tagged_fields(buf, |_tag, _payload| Ok(false))?;
715        }
716        Ok(out)
717    }
718}
719#[cfg(test)]
720impl BrokerFeature {
721    #[must_use]
722    pub fn populated(version: i16) -> Self {
723        let mut m = Self::default();
724        if version >= 0 {
725            m.name = "x".to_owned();
726        }
727        if version >= 0 {
728            m.min_supported_version = 1i16;
729        }
730        if version >= 0 {
731            m.max_supported_version = 1i16;
732        }
733        m
734    }
735}
736/// Default JSON payload matching `Self::default()` for JVM oracle differential testing.
737/// Only includes fields valid for the given version.
738#[must_use]
739#[allow(unused_comparisons)]
740pub fn default_json(version: i16) -> ::serde_json::Value {
741    let mut obj = ::serde_json::Map::new();
742    obj.insert("brokerId".to_owned(), ::serde_json::json!(0));
743    if version >= 2 {
744        obj.insert(
745            "isMigratingZkBroker".to_owned(),
746            ::serde_json::Value::Bool(false),
747        );
748    }
749    obj.insert(
750        "incarnationId".to_owned(),
751        ::serde_json::Value::String("AAAAAAAAAAAAAAAAAAAAAA".to_owned()),
752    );
753    obj.insert("brokerEpoch".to_owned(), ::serde_json::json!(0));
754    obj.insert("endPoints".to_owned(), ::serde_json::Value::Array(vec![]));
755    obj.insert("features".to_owned(), ::serde_json::Value::Array(vec![]));
756    obj.insert(
757        "rack".to_owned(),
758        ::serde_json::Value::String(String::new()),
759    );
760    obj.insert("fenced".to_owned(), ::serde_json::Value::Bool(true));
761    if version >= 1 {
762        obj.insert(
763            "inControlledShutdown".to_owned(),
764            ::serde_json::Value::Bool(false),
765        );
766    }
767    if version >= 3 {
768        obj.insert("logDirs".to_owned(), ::serde_json::Value::Array(vec![]));
769    }
770    if version >= 4 {
771        obj.insert("cordonedLogDirs".to_owned(), ::serde_json::Value::Null);
772    }
773    ::serde_json::Value::Object(obj)
774}
775/// A message with a non-default value in every tagged field, at every depth, for
776/// the JVM oracle differential sweep. The value is the same at every version.
777#[must_use]
778pub fn tagged_fixture() -> RegisterBrokerRecord {
779    RegisterBrokerRecord {
780        log_dirs: vec![Uuid([1u8; 16])],
781        cordoned_log_dirs: Some(vec![Uuid([1u8; 16])]),
782        ..RegisterBrokerRecord::default()
783    }
784}
785/// The JSON form of `tagged_fixture()` that Kafka's JSON converter reads at
786/// `version`. It holds only the fields that the schema declares at that version.
787#[must_use]
788pub fn tagged_fixture_json(version: i16) -> ::serde_json::Value {
789    let mut m = ::serde_json::Map::new();
790    m.insert("brokerId".to_owned(), ::serde_json::json!(0));
791    if version >= 2 {
792        m.insert(
793            "isMigratingZkBroker".to_owned(),
794            ::serde_json::Value::Bool(false),
795        );
796    }
797    m.insert(
798        "incarnationId".to_owned(),
799        ::serde_json::Value::String("AAAAAAAAAAAAAAAAAAAAAA".to_owned()),
800    );
801    m.insert("brokerEpoch".to_owned(), ::serde_json::json!(0));
802    m.insert("endPoints".to_owned(), ::serde_json::Value::Array(vec![]));
803    m.insert("features".to_owned(), ::serde_json::Value::Array(vec![]));
804    m.insert(
805        "rack".to_owned(),
806        ::serde_json::Value::String(String::new()),
807    );
808    m.insert("fenced".to_owned(), ::serde_json::Value::Bool(true));
809    if version >= 1 {
810        m.insert(
811            "inControlledShutdown".to_owned(),
812            ::serde_json::Value::Bool(false),
813        );
814    }
815    if version >= 3 {
816        m.insert(
817            "logDirs".to_owned(),
818            ::serde_json::Value::Array(vec![::serde_json::Value::String(
819                "AQEBAQEBAQEBAQEBAQEBAQ".to_owned(),
820            )]),
821        );
822    }
823    if version == 4 {
824        m.insert(
825            "cordonedLogDirs".to_owned(),
826            ::serde_json::Value::Array(vec![::serde_json::Value::String(
827                "AQEBAQEBAQEBAQEBAQEBAQ".to_owned(),
828            )]),
829        );
830    }
831    ::serde_json::Value::Object(m)
832}
krabka_protocol/opt/rustwide/workdir/generated/RegisterBrokerRecord.owned.rs

krabka_protocol/opt/rustwide/workdir/generated/
RegisterBrokerRecord.owned.rs
