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

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