1#![allow(dead_code)]
3#![allow(unused_imports)]
4#![allow(non_upper_case_globals)]
5#![allow(non_snake_case)]
6#![allow(unused_variables)]
7#![allow(unreachable_patterns)]
8
9use std::collections::BTreeMap;
10use std::ffi::c_void;
11
12pub mod DDS {
13 pub mod XTypes {
14 pub type EquivalenceKind = u8;
15 pub const EK_MINIMAL: u8 = 0xF1;
16 pub const EK_COMPLETE: u8 = 0xF2;
17 pub const EK_BOTH: u8 = 0xF3;
18 pub type TypeKind = u8;
19 pub const TK_NONE: u8 = 0x00;
20 pub const TK_BOOLEAN: u8 = 0x01;
21 pub const TK_BYTE: u8 = 0x02;
22 pub const TK_INT16: u8 = 0x03;
23 pub const TK_INT32: u8 = 0x04;
24 pub const TK_INT64: u8 = 0x05;
25 pub const TK_UINT16: u8 = 0x06;
26 pub const TK_UINT32: u8 = 0x07;
27 pub const TK_UINT64: u8 = 0x08;
28 pub const TK_FLOAT32: u8 = 0x09;
29 pub const TK_FLOAT64: u8 = 0x0A;
30 pub const TK_FLOAT128: u8 = 0x0B;
31 pub const TK_CHAR8: u8 = 0x10;
32 pub const TK_CHAR16: u8 = 0x11;
33 pub const TK_STRING8: u8 = 0x20;
34 pub const TK_STRING16: u8 = 0x21;
35 pub const TK_ALIAS: u8 = 0x30;
36 pub const TK_ENUM: u8 = 0x40;
37 pub const TK_BITMASK: u8 = 0x41;
38 pub const TK_ANNOTATION: u8 = 0x50;
39 pub const TK_STRUCTURE: u8 = 0x51;
40 pub const TK_UNION: u8 = 0x52;
41 pub const TK_BITSET: u8 = 0x53;
42 pub const TK_SEQUENCE: u8 = 0x60;
43 pub const TK_ARRAY: u8 = 0x61;
44 pub const TK_MAP: u8 = 0x62;
45 pub type TypeIdentiferKind = u8;
46 pub const TI_STRING8_SMALL: u8 = 0x70;
47 pub const TI_STRING8_LARGE: u8 = 0x71;
48 pub const TI_STRING16_SMALL: u8 = 0x72;
49 pub const TI_STRING16_LARGE: u8 = 0x73;
50 pub const TI_PLAIN_SEQUENCE_SMALL: u8 = 0x80;
51 pub const TI_PLAIN_SEQUENCE_LARGE: u8 = 0x81;
52 pub const TI_PLAIN_ARRAY_SMALL: u8 = 0x90;
53 pub const TI_PLAIN_ARRAY_LARGE: u8 = 0x91;
54 pub const TI_PLAIN_MAP_SMALL: u8 = 0xA0;
55 pub const TI_PLAIN_MAP_LARGE: u8 = 0xA1;
56 pub const TI_STRONGLY_CONNECTED_COMPONENT: u8 = 0xB0;
57 pub const MEMBER_NAME_MAX_LENGTH: i32 = 256;
58 pub type MemberName = String;
59 pub const TYPE_NAME_MAX_LENGTH: i32 = 256;
60 pub type QualifiedTypeName = String;
61 pub type PrimitiveTypeId = u8;
62 pub type EquivalenceHash = [u8; 14];
63 pub type NameHash = [u8; 4];
64 pub type LBound = u32;
65 pub type LBoundSeq = Vec<LBound>;
66 pub const INVALID_LBOUND: LBound = 0;
67 pub type SBound = u8;
68 pub type SBoundSeq = Vec<SBound>;
69 pub const INVALID_SBOUND: SBound = 0;
70 pub struct TypeObjectHashId {
71 pub _d: u8,
72
73 pub hash: Option<Box<EquivalenceHash>>,
74 }
75
76 impl TypeObjectHashId {
77 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
78
79 pub fn new_hash(value: Box<EquivalenceHash>) -> Self {
80 Self {
81 _d: EK_COMPLETE | EK_MINIMAL,
82 hash: Some(value),
83 }
84 }
85
86 pub fn is_hash(&self) -> bool {
87 matches!(self._d, EK_COMPLETE | EK_MINIMAL)
88 }
89
90 pub fn tag(&self) -> &u8 {
91 &self._d
92 }
93 }
94
95 impl xidl_xcdr::XcdrSerialize for TypeObjectHashId {
96 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
97 Self::SERIALIZE_KIND
98 }
99
100 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
101 &self,
102 serializer: &mut S,
103 ) -> xidl_xcdr::error::XcdrResult<()> {
104 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
105 serializer.begin_field(xidl_xcdr::FieldId(0), false, 0)?;
106 xidl_xcdr::XcdrSerialize::serialize_with(&self._d, serializer)?;
107 serializer.end_field()?;
108 match self._d {
109 EK_COMPLETE | EK_MINIMAL => {
110 let value = self.hash.as_ref().ok_or_else(|| {
111 xidl_xcdr::error::XcdrError::Message(
112 "union member is not set for discriminator".to_string(),
113 )
114 })?;
115 serializer.begin_field(xidl_xcdr::FieldId(1u32), false, 0)?;
116 xidl_xcdr::XcdrSerialize::serialize_with(value, serializer)?;
117 serializer.end_field()?;
118 }
119
120 _ => {}
121 }
122 serializer.end_struct()?;
123 Ok(())
124 }
125 }
126
127 impl xidl_xcdr::XcdrDeserialize for TypeObjectHashId {
128 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
129 deserializer: &mut D,
130 ) -> xidl_xcdr::error::XcdrResult<Self> {
131 let _d = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
132 let mut out = Self { _d, hash: None };
133 match out._d {
134 EK_COMPLETE | EK_MINIMAL => {
135 out.hash = Some(xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?);
136 }
137
138 _ => {}
139 }
140 Ok(out)
141 }
142 }
143
144 impl xidl_typeobject::XidlTypeObject for TypeObjectHashId {
145 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
146 xidl_typeobject::runtime::build_minimal_union(
147 0u32,
148 xidl_typeobject::runtime::type_identifier_primitive(
149 xidl_typeobject::DDS::XTypes::TK_BYTE,
150 ),
151 vec![xidl_typeobject::runtime::UnionMemberDesc {
152 member_id: 1u32,
153 member_flags: 0u32,
154 type_id: xidl_typeobject::runtime::type_identifier_for::<EquivalenceHash>(
155 xidl_typeobject::runtime::TypeEquivalence::Minimal,
156 ),
157 name: "hash",
158 labels: vec![0i32, 0i32],
159 }],
160 )
161 }
162
163 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
164 xidl_typeobject::runtime::build_complete_union(
165 "DDS::XTypes::TypeObjectHashId",
166 0u32,
167 xidl_typeobject::runtime::type_identifier_primitive(
168 xidl_typeobject::DDS::XTypes::TK_BYTE,
169 ),
170 vec![xidl_typeobject::runtime::UnionMemberDesc {
171 member_id: 1u32,
172 member_flags: 0u32,
173 type_id: xidl_typeobject::runtime::type_identifier_for::<EquivalenceHash>(
174 xidl_typeobject::runtime::TypeEquivalence::Complete,
175 ),
176 name: "hash",
177 labels: vec![0i32, 0i32],
178 }],
179 )
180 }
181 }
182 pub struct MemberFlag {
183 pub value: u32,
184 }
185
186 impl MemberFlag {
187 pub const TRY_CONSTRUCT1: u32 = 1u32 << 0;
188
189 pub const TRY_CONSTRUCT2: u32 = 1u32 << 1;
190
191 pub const IS_EXTERNAL: u32 = 1u32 << 2;
192
193 pub const IS_OPTIONAL: u32 = 1u32 << 3;
194
195 pub const IS_MUST_UNDERSTAND: u32 = 1u32 << 4;
196
197 pub const IS_KEY: u32 = 1u32 << 5;
198
199 pub const IS_DEFAULT: u32 = 1u32 << 6;
200 }
201
202 impl xidl_xcdr::XcdrSerialize for MemberFlag {
203 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
204 &self,
205 serializer: &mut S,
206 ) -> xidl_xcdr::error::XcdrResult<()> {
207 xidl_xcdr::XcdrSerialize::serialize_with(&self.value, serializer)
208 }
209 }
210
211 impl xidl_xcdr::XcdrDeserialize for MemberFlag {
212 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
213 deserializer: &mut D,
214 ) -> xidl_xcdr::error::XcdrResult<Self> {
215 let value = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
216 Ok(Self { value })
217 }
218 }
219
220 impl xidl_typeobject::XidlTypeObject for MemberFlag {
221 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
222 xidl_typeobject::runtime::build_minimal_bitmask(
223 0u32,
224 32u16,
225 vec![
226 xidl_typeobject::runtime::BitflagDesc {
227 position: 0u16,
228 flags: 0u32,
229 name: "TRY_CONSTRUCT1",
230 },
231 xidl_typeobject::runtime::BitflagDesc {
232 position: 1u16,
233 flags: 0u32,
234 name: "TRY_CONSTRUCT2",
235 },
236 xidl_typeobject::runtime::BitflagDesc {
237 position: 2u16,
238 flags: 0u32,
239 name: "IS_EXTERNAL",
240 },
241 xidl_typeobject::runtime::BitflagDesc {
242 position: 3u16,
243 flags: 0u32,
244 name: "IS_OPTIONAL",
245 },
246 xidl_typeobject::runtime::BitflagDesc {
247 position: 4u16,
248 flags: 0u32,
249 name: "IS_MUST_UNDERSTAND",
250 },
251 xidl_typeobject::runtime::BitflagDesc {
252 position: 5u16,
253 flags: 0u32,
254 name: "IS_KEY",
255 },
256 xidl_typeobject::runtime::BitflagDesc {
257 position: 6u16,
258 flags: 0u32,
259 name: "IS_DEFAULT",
260 },
261 ],
262 )
263 }
264
265 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
266 xidl_typeobject::runtime::build_complete_bitmask(
267 "DDS::XTypes::MemberFlag",
268 0u32,
269 32u16,
270 vec![
271 xidl_typeobject::runtime::BitflagDesc {
272 position: 0u16,
273 flags: 0u32,
274 name: "TRY_CONSTRUCT1",
275 },
276 xidl_typeobject::runtime::BitflagDesc {
277 position: 1u16,
278 flags: 0u32,
279 name: "TRY_CONSTRUCT2",
280 },
281 xidl_typeobject::runtime::BitflagDesc {
282 position: 2u16,
283 flags: 0u32,
284 name: "IS_EXTERNAL",
285 },
286 xidl_typeobject::runtime::BitflagDesc {
287 position: 3u16,
288 flags: 0u32,
289 name: "IS_OPTIONAL",
290 },
291 xidl_typeobject::runtime::BitflagDesc {
292 position: 4u16,
293 flags: 0u32,
294 name: "IS_MUST_UNDERSTAND",
295 },
296 xidl_typeobject::runtime::BitflagDesc {
297 position: 5u16,
298 flags: 0u32,
299 name: "IS_KEY",
300 },
301 xidl_typeobject::runtime::BitflagDesc {
302 position: 6u16,
303 flags: 0u32,
304 name: "IS_DEFAULT",
305 },
306 ],
307 )
308 }
309 }
310 pub type CollectionElementFlag = MemberFlag;
311 pub type StructMemberFlag = MemberFlag;
312 pub type UnionMemberFlag = MemberFlag;
313 pub type UnionDiscriminatorFlag = MemberFlag;
314 pub type EnumeratedLiteralFlag = MemberFlag;
315 pub type AnnotationParameterFlag = MemberFlag;
316 pub type AliasMemberFlag = MemberFlag;
317 pub type BitflagFlag = MemberFlag;
318 pub type BitsetMemberFlag = MemberFlag;
319 pub const MemberFlagMinimalMask: u16 = 0x003f;
320 pub struct TypeFlag {
321 pub value: u32,
322 }
323
324 impl TypeFlag {
325 pub const IS_FINAL: u32 = 1u32 << 0;
326
327 pub const IS_APPENDABLE: u32 = 1u32 << 1;
328
329 pub const IS_MUTABLE: u32 = 1u32 << 2;
330
331 pub const IS_NESTED: u32 = 1u32 << 3;
332
333 pub const IS_AUTOID_HASH: u32 = 1u32 << 4;
334 }
335
336 impl xidl_xcdr::XcdrSerialize for TypeFlag {
337 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
338 &self,
339 serializer: &mut S,
340 ) -> xidl_xcdr::error::XcdrResult<()> {
341 xidl_xcdr::XcdrSerialize::serialize_with(&self.value, serializer)
342 }
343 }
344
345 impl xidl_xcdr::XcdrDeserialize for TypeFlag {
346 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
347 deserializer: &mut D,
348 ) -> xidl_xcdr::error::XcdrResult<Self> {
349 let value = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
350 Ok(Self { value })
351 }
352 }
353
354 impl xidl_typeobject::XidlTypeObject for TypeFlag {
355 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
356 xidl_typeobject::runtime::build_minimal_bitmask(
357 0u32,
358 32u16,
359 vec![
360 xidl_typeobject::runtime::BitflagDesc {
361 position: 0u16,
362 flags: 0u32,
363 name: "IS_FINAL",
364 },
365 xidl_typeobject::runtime::BitflagDesc {
366 position: 1u16,
367 flags: 0u32,
368 name: "IS_APPENDABLE",
369 },
370 xidl_typeobject::runtime::BitflagDesc {
371 position: 2u16,
372 flags: 0u32,
373 name: "IS_MUTABLE",
374 },
375 xidl_typeobject::runtime::BitflagDesc {
376 position: 3u16,
377 flags: 0u32,
378 name: "IS_NESTED",
379 },
380 xidl_typeobject::runtime::BitflagDesc {
381 position: 4u16,
382 flags: 0u32,
383 name: "IS_AUTOID_HASH",
384 },
385 ],
386 )
387 }
388
389 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
390 xidl_typeobject::runtime::build_complete_bitmask(
391 "DDS::XTypes::TypeFlag",
392 0u32,
393 32u16,
394 vec![
395 xidl_typeobject::runtime::BitflagDesc {
396 position: 0u16,
397 flags: 0u32,
398 name: "IS_FINAL",
399 },
400 xidl_typeobject::runtime::BitflagDesc {
401 position: 1u16,
402 flags: 0u32,
403 name: "IS_APPENDABLE",
404 },
405 xidl_typeobject::runtime::BitflagDesc {
406 position: 2u16,
407 flags: 0u32,
408 name: "IS_MUTABLE",
409 },
410 xidl_typeobject::runtime::BitflagDesc {
411 position: 3u16,
412 flags: 0u32,
413 name: "IS_NESTED",
414 },
415 xidl_typeobject::runtime::BitflagDesc {
416 position: 4u16,
417 flags: 0u32,
418 name: "IS_AUTOID_HASH",
419 },
420 ],
421 )
422 }
423 }
424 pub type StructTypeFlag = TypeFlag;
425 pub type UnionTypeFlag = TypeFlag;
426 pub type CollectionTypeFlag = TypeFlag;
427 pub type AnnotationTypeFlag = TypeFlag;
428 pub type AliasTypeFlag = TypeFlag;
429 pub type EnumTypeFlag = TypeFlag;
430 pub type BitmaskTypeFlag = TypeFlag;
431 pub type BitsetTypeFlag = TypeFlag;
432 pub const TypeFlagMinimalMask: u16 = 0x0007;
433 pub struct StringSTypeDefn {
434 pub bound: Box<SBound>,
435 }
436
437 impl StringSTypeDefn {
438 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
439 }
440
441 impl xidl_xcdr::XcdrSerialize for StringSTypeDefn {
442 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
443 Self::SERIALIZE_KIND
444 }
445
446 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
447 &self,
448 serializer: &mut S,
449 ) -> xidl_xcdr::error::XcdrResult<()> {
450 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
451
452 serializer.begin_field(xidl_xcdr::FieldId(1u32), false, 0)?;
453
454 xidl_xcdr::XcdrSerialize::serialize_with(&self.bound, serializer)?;
455 serializer.end_field()?;
456
457 serializer.end_struct()?;
458 Ok(())
459 }
460 }
461
462 impl xidl_xcdr::XcdrDeserialize for StringSTypeDefn {
463 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
464 deserializer: &mut D,
465 ) -> xidl_xcdr::error::XcdrResult<Self> {
466 let bound = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
467
468 Ok(Self { bound })
469 }
470 }
471
472 impl xidl_typeobject::XidlTypeObject for StringSTypeDefn {
473 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
474 xidl_typeobject::runtime::build_minimal_struct(
475 0u32,
476 xidl_typeobject::runtime::type_identifier_none(),
477 vec![xidl_typeobject::runtime::StructMemberDesc {
478 member_id: 1u32,
479 member_flags: 0u32,
480 type_id: xidl_typeobject::runtime::type_identifier_for::<SBound>(
481 xidl_typeobject::runtime::TypeEquivalence::Minimal,
482 ),
483 name: "bound",
484 }],
485 )
486 }
487
488 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
489 xidl_typeobject::runtime::build_complete_struct(
490 "DDS::XTypes::StringSTypeDefn",
491 0u32,
492 xidl_typeobject::runtime::type_identifier_none(),
493 vec![xidl_typeobject::runtime::StructMemberDesc {
494 member_id: 1u32,
495 member_flags: 0u32,
496 type_id: xidl_typeobject::runtime::type_identifier_for::<SBound>(
497 xidl_typeobject::runtime::TypeEquivalence::Complete,
498 ),
499 name: "bound",
500 }],
501 )
502 }
503 }
504 pub struct StringLTypeDefn {
505 pub bound: Box<LBound>,
506 }
507
508 impl StringLTypeDefn {
509 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
510 }
511
512 impl xidl_xcdr::XcdrSerialize for StringLTypeDefn {
513 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
514 Self::SERIALIZE_KIND
515 }
516
517 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
518 &self,
519 serializer: &mut S,
520 ) -> xidl_xcdr::error::XcdrResult<()> {
521 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
522
523 serializer.begin_field(xidl_xcdr::FieldId(1u32), false, 0)?;
524
525 xidl_xcdr::XcdrSerialize::serialize_with(&self.bound, serializer)?;
526 serializer.end_field()?;
527
528 serializer.end_struct()?;
529 Ok(())
530 }
531 }
532
533 impl xidl_xcdr::XcdrDeserialize for StringLTypeDefn {
534 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
535 deserializer: &mut D,
536 ) -> xidl_xcdr::error::XcdrResult<Self> {
537 let bound = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
538
539 Ok(Self { bound })
540 }
541 }
542
543 impl xidl_typeobject::XidlTypeObject for StringLTypeDefn {
544 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
545 xidl_typeobject::runtime::build_minimal_struct(
546 0u32,
547 xidl_typeobject::runtime::type_identifier_none(),
548 vec![xidl_typeobject::runtime::StructMemberDesc {
549 member_id: 1u32,
550 member_flags: 0u32,
551 type_id: xidl_typeobject::runtime::type_identifier_for::<LBound>(
552 xidl_typeobject::runtime::TypeEquivalence::Minimal,
553 ),
554 name: "bound",
555 }],
556 )
557 }
558
559 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
560 xidl_typeobject::runtime::build_complete_struct(
561 "DDS::XTypes::StringLTypeDefn",
562 0u32,
563 xidl_typeobject::runtime::type_identifier_none(),
564 vec![xidl_typeobject::runtime::StructMemberDesc {
565 member_id: 1u32,
566 member_flags: 0u32,
567 type_id: xidl_typeobject::runtime::type_identifier_for::<LBound>(
568 xidl_typeobject::runtime::TypeEquivalence::Complete,
569 ),
570 name: "bound",
571 }],
572 )
573 }
574 }
575 pub struct PlainCollectionHeader {
576 pub equiv_kind: Box<EquivalenceKind>,
577
578 pub element_flags: Box<CollectionElementFlag>,
579 }
580
581 impl PlainCollectionHeader {
582 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
583 }
584
585 impl xidl_xcdr::XcdrSerialize for PlainCollectionHeader {
586 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
587 Self::SERIALIZE_KIND
588 }
589
590 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
591 &self,
592 serializer: &mut S,
593 ) -> xidl_xcdr::error::XcdrResult<()> {
594 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
595
596 serializer.begin_field(xidl_xcdr::FieldId(1u32), false, 0)?;
597
598 xidl_xcdr::XcdrSerialize::serialize_with(&self.equiv_kind, serializer)?;
599 serializer.end_field()?;
600
601 serializer.begin_field(xidl_xcdr::FieldId(2u32), false, 0)?;
602
603 xidl_xcdr::XcdrSerialize::serialize_with(&self.element_flags, serializer)?;
604 serializer.end_field()?;
605
606 serializer.end_struct()?;
607 Ok(())
608 }
609 }
610
611 impl xidl_xcdr::XcdrDeserialize for PlainCollectionHeader {
612 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
613 deserializer: &mut D,
614 ) -> xidl_xcdr::error::XcdrResult<Self> {
615 let equiv_kind = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
616
617 let element_flags = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
618
619 Ok(Self {
620 equiv_kind,
621
622 element_flags,
623 })
624 }
625 }
626
627 impl xidl_typeobject::XidlTypeObject for PlainCollectionHeader {
628 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
629 xidl_typeobject::runtime::build_minimal_struct(
630 0u32,
631 xidl_typeobject::runtime::type_identifier_none(),
632 vec![
633 xidl_typeobject::runtime::StructMemberDesc {
634 member_id: 1u32,
635 member_flags: 0u32,
636 type_id: xidl_typeobject::runtime::type_identifier_for::<EquivalenceKind>(
637 xidl_typeobject::runtime::TypeEquivalence::Minimal,
638 ),
639 name: "equiv_kind",
640 },
641 xidl_typeobject::runtime::StructMemberDesc {
642 member_id: 2u32,
643 member_flags: 0u32,
644 type_id: xidl_typeobject::runtime::type_identifier_for::<
645 CollectionElementFlag,
646 >(
647 xidl_typeobject::runtime::TypeEquivalence::Minimal
648 ),
649 name: "element_flags",
650 },
651 ],
652 )
653 }
654
655 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
656 xidl_typeobject::runtime::build_complete_struct(
657 "DDS::XTypes::PlainCollectionHeader",
658 0u32,
659 xidl_typeobject::runtime::type_identifier_none(),
660 vec![
661 xidl_typeobject::runtime::StructMemberDesc {
662 member_id: 1u32,
663 member_flags: 0u32,
664 type_id: xidl_typeobject::runtime::type_identifier_for::<EquivalenceKind>(
665 xidl_typeobject::runtime::TypeEquivalence::Complete,
666 ),
667 name: "equiv_kind",
668 },
669 xidl_typeobject::runtime::StructMemberDesc {
670 member_id: 2u32,
671 member_flags: 0u32,
672 type_id: xidl_typeobject::runtime::type_identifier_for::<
673 CollectionElementFlag,
674 >(
675 xidl_typeobject::runtime::TypeEquivalence::Complete
676 ),
677 name: "element_flags",
678 },
679 ],
680 )
681 }
682 }
683 pub struct PlainSequenceSElemDefn {
684 pub header: Box<PlainCollectionHeader>,
685
686 pub bound: Box<SBound>,
687
688 pub element_identifier: Box<TypeIdentifier>,
689 }
690
691 impl PlainSequenceSElemDefn {
692 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
693 }
694
695 impl xidl_xcdr::XcdrSerialize for PlainSequenceSElemDefn {
696 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
697 Self::SERIALIZE_KIND
698 }
699
700 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
701 &self,
702 serializer: &mut S,
703 ) -> xidl_xcdr::error::XcdrResult<()> {
704 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
705
706 serializer.begin_field(xidl_xcdr::FieldId(1u32), false, 0)?;
707
708 xidl_xcdr::XcdrSerialize::serialize_with(&self.header, serializer)?;
709 serializer.end_field()?;
710
711 serializer.begin_field(xidl_xcdr::FieldId(2u32), false, 0)?;
712
713 xidl_xcdr::XcdrSerialize::serialize_with(&self.bound, serializer)?;
714 serializer.end_field()?;
715
716 serializer.begin_field(xidl_xcdr::FieldId(3u32), false, 0)?;
717
718 xidl_xcdr::XcdrSerialize::serialize_with(&self.element_identifier, serializer)?;
719 serializer.end_field()?;
720
721 serializer.end_struct()?;
722 Ok(())
723 }
724 }
725
726 impl xidl_xcdr::XcdrDeserialize for PlainSequenceSElemDefn {
727 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
728 deserializer: &mut D,
729 ) -> xidl_xcdr::error::XcdrResult<Self> {
730 let header = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
731
732 let bound = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
733
734 let element_identifier = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
735
736 Ok(Self {
737 header,
738
739 bound,
740
741 element_identifier,
742 })
743 }
744 }
745
746 impl xidl_typeobject::XidlTypeObject for PlainSequenceSElemDefn {
747 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
748 xidl_typeobject::runtime::build_minimal_struct(
749 0u32,
750 xidl_typeobject::runtime::type_identifier_none(),
751 vec![
752 xidl_typeobject::runtime::StructMemberDesc {
753 member_id: 1u32,
754 member_flags: 0u32,
755 type_id: xidl_typeobject::runtime::type_identifier_for::<
756 PlainCollectionHeader,
757 >(
758 xidl_typeobject::runtime::TypeEquivalence::Minimal
759 ),
760 name: "header",
761 },
762 xidl_typeobject::runtime::StructMemberDesc {
763 member_id: 2u32,
764 member_flags: 0u32,
765 type_id: xidl_typeobject::runtime::type_identifier_for::<SBound>(
766 xidl_typeobject::runtime::TypeEquivalence::Minimal,
767 ),
768 name: "bound",
769 },
770 xidl_typeobject::runtime::StructMemberDesc {
771 member_id: 3u32,
772 member_flags: 4u32,
773 type_id: xidl_typeobject::runtime::type_identifier_for::<TypeIdentifier>(
774 xidl_typeobject::runtime::TypeEquivalence::Minimal,
775 ),
776 name: "element_identifier",
777 },
778 ],
779 )
780 }
781
782 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
783 xidl_typeobject::runtime::build_complete_struct(
784 "DDS::XTypes::PlainSequenceSElemDefn",
785 0u32,
786 xidl_typeobject::runtime::type_identifier_none(),
787 vec![
788 xidl_typeobject::runtime::StructMemberDesc {
789 member_id: 1u32,
790 member_flags: 0u32,
791 type_id: xidl_typeobject::runtime::type_identifier_for::<
792 PlainCollectionHeader,
793 >(
794 xidl_typeobject::runtime::TypeEquivalence::Complete
795 ),
796 name: "header",
797 },
798 xidl_typeobject::runtime::StructMemberDesc {
799 member_id: 2u32,
800 member_flags: 0u32,
801 type_id: xidl_typeobject::runtime::type_identifier_for::<SBound>(
802 xidl_typeobject::runtime::TypeEquivalence::Complete,
803 ),
804 name: "bound",
805 },
806 xidl_typeobject::runtime::StructMemberDesc {
807 member_id: 3u32,
808 member_flags: 4u32,
809 type_id: xidl_typeobject::runtime::type_identifier_for::<TypeIdentifier>(
810 xidl_typeobject::runtime::TypeEquivalence::Complete,
811 ),
812 name: "element_identifier",
813 },
814 ],
815 )
816 }
817 }
818 pub struct PlainSequenceLElemDefn {
819 pub header: Box<PlainCollectionHeader>,
820
821 pub bound: Box<LBound>,
822
823 pub element_identifier: Box<TypeIdentifier>,
824 }
825
826 impl PlainSequenceLElemDefn {
827 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
828 }
829
830 impl xidl_xcdr::XcdrSerialize for PlainSequenceLElemDefn {
831 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
832 Self::SERIALIZE_KIND
833 }
834
835 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
836 &self,
837 serializer: &mut S,
838 ) -> xidl_xcdr::error::XcdrResult<()> {
839 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
840
841 serializer.begin_field(xidl_xcdr::FieldId(1u32), false, 0)?;
842
843 xidl_xcdr::XcdrSerialize::serialize_with(&self.header, serializer)?;
844 serializer.end_field()?;
845
846 serializer.begin_field(xidl_xcdr::FieldId(2u32), false, 0)?;
847
848 xidl_xcdr::XcdrSerialize::serialize_with(&self.bound, serializer)?;
849 serializer.end_field()?;
850
851 serializer.begin_field(xidl_xcdr::FieldId(3u32), false, 0)?;
852
853 xidl_xcdr::XcdrSerialize::serialize_with(&self.element_identifier, serializer)?;
854 serializer.end_field()?;
855
856 serializer.end_struct()?;
857 Ok(())
858 }
859 }
860
861 impl xidl_xcdr::XcdrDeserialize for PlainSequenceLElemDefn {
862 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
863 deserializer: &mut D,
864 ) -> xidl_xcdr::error::XcdrResult<Self> {
865 let header = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
866
867 let bound = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
868
869 let element_identifier = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
870
871 Ok(Self {
872 header,
873
874 bound,
875
876 element_identifier,
877 })
878 }
879 }
880
881 impl xidl_typeobject::XidlTypeObject for PlainSequenceLElemDefn {
882 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
883 xidl_typeobject::runtime::build_minimal_struct(
884 0u32,
885 xidl_typeobject::runtime::type_identifier_none(),
886 vec![
887 xidl_typeobject::runtime::StructMemberDesc {
888 member_id: 1u32,
889 member_flags: 0u32,
890 type_id: xidl_typeobject::runtime::type_identifier_for::<
891 PlainCollectionHeader,
892 >(
893 xidl_typeobject::runtime::TypeEquivalence::Minimal
894 ),
895 name: "header",
896 },
897 xidl_typeobject::runtime::StructMemberDesc {
898 member_id: 2u32,
899 member_flags: 0u32,
900 type_id: xidl_typeobject::runtime::type_identifier_for::<LBound>(
901 xidl_typeobject::runtime::TypeEquivalence::Minimal,
902 ),
903 name: "bound",
904 },
905 xidl_typeobject::runtime::StructMemberDesc {
906 member_id: 3u32,
907 member_flags: 4u32,
908 type_id: xidl_typeobject::runtime::type_identifier_for::<TypeIdentifier>(
909 xidl_typeobject::runtime::TypeEquivalence::Minimal,
910 ),
911 name: "element_identifier",
912 },
913 ],
914 )
915 }
916
917 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
918 xidl_typeobject::runtime::build_complete_struct(
919 "DDS::XTypes::PlainSequenceLElemDefn",
920 0u32,
921 xidl_typeobject::runtime::type_identifier_none(),
922 vec![
923 xidl_typeobject::runtime::StructMemberDesc {
924 member_id: 1u32,
925 member_flags: 0u32,
926 type_id: xidl_typeobject::runtime::type_identifier_for::<
927 PlainCollectionHeader,
928 >(
929 xidl_typeobject::runtime::TypeEquivalence::Complete
930 ),
931 name: "header",
932 },
933 xidl_typeobject::runtime::StructMemberDesc {
934 member_id: 2u32,
935 member_flags: 0u32,
936 type_id: xidl_typeobject::runtime::type_identifier_for::<LBound>(
937 xidl_typeobject::runtime::TypeEquivalence::Complete,
938 ),
939 name: "bound",
940 },
941 xidl_typeobject::runtime::StructMemberDesc {
942 member_id: 3u32,
943 member_flags: 4u32,
944 type_id: xidl_typeobject::runtime::type_identifier_for::<TypeIdentifier>(
945 xidl_typeobject::runtime::TypeEquivalence::Complete,
946 ),
947 name: "element_identifier",
948 },
949 ],
950 )
951 }
952 }
953 pub struct PlainArraySElemDefn {
954 pub header: Box<PlainCollectionHeader>,
955
956 pub array_bound_seq: Box<SBoundSeq>,
957
958 pub element_identifier: Box<TypeIdentifier>,
959 }
960
961 impl PlainArraySElemDefn {
962 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
963 }
964
965 impl xidl_xcdr::XcdrSerialize for PlainArraySElemDefn {
966 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
967 Self::SERIALIZE_KIND
968 }
969
970 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
971 &self,
972 serializer: &mut S,
973 ) -> xidl_xcdr::error::XcdrResult<()> {
974 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
975
976 serializer.begin_field(xidl_xcdr::FieldId(1u32), false, 0)?;
977
978 xidl_xcdr::XcdrSerialize::serialize_with(&self.header, serializer)?;
979 serializer.end_field()?;
980
981 serializer.begin_field(xidl_xcdr::FieldId(2u32), false, 0)?;
982
983 xidl_xcdr::XcdrSerialize::serialize_with(&self.array_bound_seq, serializer)?;
984 serializer.end_field()?;
985
986 serializer.begin_field(xidl_xcdr::FieldId(3u32), false, 0)?;
987
988 xidl_xcdr::XcdrSerialize::serialize_with(&self.element_identifier, serializer)?;
989 serializer.end_field()?;
990
991 serializer.end_struct()?;
992 Ok(())
993 }
994 }
995
996 impl xidl_xcdr::XcdrDeserialize for PlainArraySElemDefn {
997 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
998 deserializer: &mut D,
999 ) -> xidl_xcdr::error::XcdrResult<Self> {
1000 let header = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
1001
1002 let array_bound_seq = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
1003
1004 let element_identifier = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
1005
1006 Ok(Self {
1007 header,
1008
1009 array_bound_seq,
1010
1011 element_identifier,
1012 })
1013 }
1014 }
1015
1016 impl xidl_typeobject::XidlTypeObject for PlainArraySElemDefn {
1017 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
1018 xidl_typeobject::runtime::build_minimal_struct(
1019 0u32,
1020 xidl_typeobject::runtime::type_identifier_none(),
1021 vec![
1022 xidl_typeobject::runtime::StructMemberDesc {
1023 member_id: 1u32,
1024 member_flags: 0u32,
1025 type_id: xidl_typeobject::runtime::type_identifier_for::<
1026 PlainCollectionHeader,
1027 >(
1028 xidl_typeobject::runtime::TypeEquivalence::Minimal
1029 ),
1030 name: "header",
1031 },
1032 xidl_typeobject::runtime::StructMemberDesc {
1033 member_id: 2u32,
1034 member_flags: 0u32,
1035 type_id: xidl_typeobject::runtime::type_identifier_for::<SBoundSeq>(
1036 xidl_typeobject::runtime::TypeEquivalence::Minimal,
1037 ),
1038 name: "array_bound_seq",
1039 },
1040 xidl_typeobject::runtime::StructMemberDesc {
1041 member_id: 3u32,
1042 member_flags: 4u32,
1043 type_id: xidl_typeobject::runtime::type_identifier_for::<TypeIdentifier>(
1044 xidl_typeobject::runtime::TypeEquivalence::Minimal,
1045 ),
1046 name: "element_identifier",
1047 },
1048 ],
1049 )
1050 }
1051
1052 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
1053 xidl_typeobject::runtime::build_complete_struct(
1054 "DDS::XTypes::PlainArraySElemDefn",
1055 0u32,
1056 xidl_typeobject::runtime::type_identifier_none(),
1057 vec![
1058 xidl_typeobject::runtime::StructMemberDesc {
1059 member_id: 1u32,
1060 member_flags: 0u32,
1061 type_id: xidl_typeobject::runtime::type_identifier_for::<
1062 PlainCollectionHeader,
1063 >(
1064 xidl_typeobject::runtime::TypeEquivalence::Complete
1065 ),
1066 name: "header",
1067 },
1068 xidl_typeobject::runtime::StructMemberDesc {
1069 member_id: 2u32,
1070 member_flags: 0u32,
1071 type_id: xidl_typeobject::runtime::type_identifier_for::<SBoundSeq>(
1072 xidl_typeobject::runtime::TypeEquivalence::Complete,
1073 ),
1074 name: "array_bound_seq",
1075 },
1076 xidl_typeobject::runtime::StructMemberDesc {
1077 member_id: 3u32,
1078 member_flags: 4u32,
1079 type_id: xidl_typeobject::runtime::type_identifier_for::<TypeIdentifier>(
1080 xidl_typeobject::runtime::TypeEquivalence::Complete,
1081 ),
1082 name: "element_identifier",
1083 },
1084 ],
1085 )
1086 }
1087 }
1088 pub struct PlainArrayLElemDefn {
1089 pub header: Box<PlainCollectionHeader>,
1090
1091 pub array_bound_seq: Box<LBoundSeq>,
1092
1093 pub element_identifier: Box<TypeIdentifier>,
1094 }
1095
1096 impl PlainArrayLElemDefn {
1097 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
1098 }
1099
1100 impl xidl_xcdr::XcdrSerialize for PlainArrayLElemDefn {
1101 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
1102 Self::SERIALIZE_KIND
1103 }
1104
1105 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
1106 &self,
1107 serializer: &mut S,
1108 ) -> xidl_xcdr::error::XcdrResult<()> {
1109 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
1110
1111 serializer.begin_field(xidl_xcdr::FieldId(1u32), false, 0)?;
1112
1113 xidl_xcdr::XcdrSerialize::serialize_with(&self.header, serializer)?;
1114 serializer.end_field()?;
1115
1116 serializer.begin_field(xidl_xcdr::FieldId(2u32), false, 0)?;
1117
1118 xidl_xcdr::XcdrSerialize::serialize_with(&self.array_bound_seq, serializer)?;
1119 serializer.end_field()?;
1120
1121 serializer.begin_field(xidl_xcdr::FieldId(3u32), false, 0)?;
1122
1123 xidl_xcdr::XcdrSerialize::serialize_with(&self.element_identifier, serializer)?;
1124 serializer.end_field()?;
1125
1126 serializer.end_struct()?;
1127 Ok(())
1128 }
1129 }
1130
1131 impl xidl_xcdr::XcdrDeserialize for PlainArrayLElemDefn {
1132 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
1133 deserializer: &mut D,
1134 ) -> xidl_xcdr::error::XcdrResult<Self> {
1135 let header = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
1136
1137 let array_bound_seq = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
1138
1139 let element_identifier = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
1140
1141 Ok(Self {
1142 header,
1143
1144 array_bound_seq,
1145
1146 element_identifier,
1147 })
1148 }
1149 }
1150
1151 impl xidl_typeobject::XidlTypeObject for PlainArrayLElemDefn {
1152 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
1153 xidl_typeobject::runtime::build_minimal_struct(
1154 0u32,
1155 xidl_typeobject::runtime::type_identifier_none(),
1156 vec![
1157 xidl_typeobject::runtime::StructMemberDesc {
1158 member_id: 1u32,
1159 member_flags: 0u32,
1160 type_id: xidl_typeobject::runtime::type_identifier_for::<
1161 PlainCollectionHeader,
1162 >(
1163 xidl_typeobject::runtime::TypeEquivalence::Minimal
1164 ),
1165 name: "header",
1166 },
1167 xidl_typeobject::runtime::StructMemberDesc {
1168 member_id: 2u32,
1169 member_flags: 0u32,
1170 type_id: xidl_typeobject::runtime::type_identifier_for::<LBoundSeq>(
1171 xidl_typeobject::runtime::TypeEquivalence::Minimal,
1172 ),
1173 name: "array_bound_seq",
1174 },
1175 xidl_typeobject::runtime::StructMemberDesc {
1176 member_id: 3u32,
1177 member_flags: 4u32,
1178 type_id: xidl_typeobject::runtime::type_identifier_for::<TypeIdentifier>(
1179 xidl_typeobject::runtime::TypeEquivalence::Minimal,
1180 ),
1181 name: "element_identifier",
1182 },
1183 ],
1184 )
1185 }
1186
1187 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
1188 xidl_typeobject::runtime::build_complete_struct(
1189 "DDS::XTypes::PlainArrayLElemDefn",
1190 0u32,
1191 xidl_typeobject::runtime::type_identifier_none(),
1192 vec![
1193 xidl_typeobject::runtime::StructMemberDesc {
1194 member_id: 1u32,
1195 member_flags: 0u32,
1196 type_id: xidl_typeobject::runtime::type_identifier_for::<
1197 PlainCollectionHeader,
1198 >(
1199 xidl_typeobject::runtime::TypeEquivalence::Complete
1200 ),
1201 name: "header",
1202 },
1203 xidl_typeobject::runtime::StructMemberDesc {
1204 member_id: 2u32,
1205 member_flags: 0u32,
1206 type_id: xidl_typeobject::runtime::type_identifier_for::<LBoundSeq>(
1207 xidl_typeobject::runtime::TypeEquivalence::Complete,
1208 ),
1209 name: "array_bound_seq",
1210 },
1211 xidl_typeobject::runtime::StructMemberDesc {
1212 member_id: 3u32,
1213 member_flags: 4u32,
1214 type_id: xidl_typeobject::runtime::type_identifier_for::<TypeIdentifier>(
1215 xidl_typeobject::runtime::TypeEquivalence::Complete,
1216 ),
1217 name: "element_identifier",
1218 },
1219 ],
1220 )
1221 }
1222 }
1223 pub struct PlainMapSTypeDefn {
1224 pub header: Box<PlainCollectionHeader>,
1225
1226 pub bound: Box<SBound>,
1227
1228 pub element_identifier: Box<TypeIdentifier>,
1229
1230 pub key_flags: Box<CollectionElementFlag>,
1231
1232 pub key_identifier: Box<TypeIdentifier>,
1233 }
1234
1235 impl PlainMapSTypeDefn {
1236 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
1237 }
1238
1239 impl xidl_xcdr::XcdrSerialize for PlainMapSTypeDefn {
1240 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
1241 Self::SERIALIZE_KIND
1242 }
1243
1244 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
1245 &self,
1246 serializer: &mut S,
1247 ) -> xidl_xcdr::error::XcdrResult<()> {
1248 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
1249
1250 serializer.begin_field(xidl_xcdr::FieldId(1u32), false, 0)?;
1251
1252 xidl_xcdr::XcdrSerialize::serialize_with(&self.header, serializer)?;
1253 serializer.end_field()?;
1254
1255 serializer.begin_field(xidl_xcdr::FieldId(2u32), false, 0)?;
1256
1257 xidl_xcdr::XcdrSerialize::serialize_with(&self.bound, serializer)?;
1258 serializer.end_field()?;
1259
1260 serializer.begin_field(xidl_xcdr::FieldId(3u32), false, 0)?;
1261
1262 xidl_xcdr::XcdrSerialize::serialize_with(&self.element_identifier, serializer)?;
1263 serializer.end_field()?;
1264
1265 serializer.begin_field(xidl_xcdr::FieldId(4u32), false, 0)?;
1266
1267 xidl_xcdr::XcdrSerialize::serialize_with(&self.key_flags, serializer)?;
1268 serializer.end_field()?;
1269
1270 serializer.begin_field(xidl_xcdr::FieldId(5u32), false, 0)?;
1271
1272 xidl_xcdr::XcdrSerialize::serialize_with(&self.key_identifier, serializer)?;
1273 serializer.end_field()?;
1274
1275 serializer.end_struct()?;
1276 Ok(())
1277 }
1278 }
1279
1280 impl xidl_xcdr::XcdrDeserialize for PlainMapSTypeDefn {
1281 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
1282 deserializer: &mut D,
1283 ) -> xidl_xcdr::error::XcdrResult<Self> {
1284 let header = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
1285
1286 let bound = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
1287
1288 let element_identifier = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
1289
1290 let key_flags = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
1291
1292 let key_identifier = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
1293
1294 Ok(Self {
1295 header,
1296
1297 bound,
1298
1299 element_identifier,
1300
1301 key_flags,
1302
1303 key_identifier,
1304 })
1305 }
1306 }
1307
1308 impl xidl_typeobject::XidlTypeObject for PlainMapSTypeDefn {
1309 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
1310 xidl_typeobject::runtime::build_minimal_struct(
1311 0u32,
1312 xidl_typeobject::runtime::type_identifier_none(),
1313 vec![
1314 xidl_typeobject::runtime::StructMemberDesc {
1315 member_id: 1u32,
1316 member_flags: 0u32,
1317 type_id: xidl_typeobject::runtime::type_identifier_for::<
1318 PlainCollectionHeader,
1319 >(
1320 xidl_typeobject::runtime::TypeEquivalence::Minimal
1321 ),
1322 name: "header",
1323 },
1324 xidl_typeobject::runtime::StructMemberDesc {
1325 member_id: 2u32,
1326 member_flags: 0u32,
1327 type_id: xidl_typeobject::runtime::type_identifier_for::<SBound>(
1328 xidl_typeobject::runtime::TypeEquivalence::Minimal,
1329 ),
1330 name: "bound",
1331 },
1332 xidl_typeobject::runtime::StructMemberDesc {
1333 member_id: 3u32,
1334 member_flags: 4u32,
1335 type_id: xidl_typeobject::runtime::type_identifier_for::<TypeIdentifier>(
1336 xidl_typeobject::runtime::TypeEquivalence::Minimal,
1337 ),
1338 name: "element_identifier",
1339 },
1340 xidl_typeobject::runtime::StructMemberDesc {
1341 member_id: 4u32,
1342 member_flags: 0u32,
1343 type_id: xidl_typeobject::runtime::type_identifier_for::<
1344 CollectionElementFlag,
1345 >(
1346 xidl_typeobject::runtime::TypeEquivalence::Minimal
1347 ),
1348 name: "key_flags",
1349 },
1350 xidl_typeobject::runtime::StructMemberDesc {
1351 member_id: 5u32,
1352 member_flags: 4u32,
1353 type_id: xidl_typeobject::runtime::type_identifier_for::<TypeIdentifier>(
1354 xidl_typeobject::runtime::TypeEquivalence::Minimal,
1355 ),
1356 name: "key_identifier",
1357 },
1358 ],
1359 )
1360 }
1361
1362 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
1363 xidl_typeobject::runtime::build_complete_struct(
1364 "DDS::XTypes::PlainMapSTypeDefn",
1365 0u32,
1366 xidl_typeobject::runtime::type_identifier_none(),
1367 vec![
1368 xidl_typeobject::runtime::StructMemberDesc {
1369 member_id: 1u32,
1370 member_flags: 0u32,
1371 type_id: xidl_typeobject::runtime::type_identifier_for::<
1372 PlainCollectionHeader,
1373 >(
1374 xidl_typeobject::runtime::TypeEquivalence::Complete
1375 ),
1376 name: "header",
1377 },
1378 xidl_typeobject::runtime::StructMemberDesc {
1379 member_id: 2u32,
1380 member_flags: 0u32,
1381 type_id: xidl_typeobject::runtime::type_identifier_for::<SBound>(
1382 xidl_typeobject::runtime::TypeEquivalence::Complete,
1383 ),
1384 name: "bound",
1385 },
1386 xidl_typeobject::runtime::StructMemberDesc {
1387 member_id: 3u32,
1388 member_flags: 4u32,
1389 type_id: xidl_typeobject::runtime::type_identifier_for::<TypeIdentifier>(
1390 xidl_typeobject::runtime::TypeEquivalence::Complete,
1391 ),
1392 name: "element_identifier",
1393 },
1394 xidl_typeobject::runtime::StructMemberDesc {
1395 member_id: 4u32,
1396 member_flags: 0u32,
1397 type_id: xidl_typeobject::runtime::type_identifier_for::<
1398 CollectionElementFlag,
1399 >(
1400 xidl_typeobject::runtime::TypeEquivalence::Complete
1401 ),
1402 name: "key_flags",
1403 },
1404 xidl_typeobject::runtime::StructMemberDesc {
1405 member_id: 5u32,
1406 member_flags: 4u32,
1407 type_id: xidl_typeobject::runtime::type_identifier_for::<TypeIdentifier>(
1408 xidl_typeobject::runtime::TypeEquivalence::Complete,
1409 ),
1410 name: "key_identifier",
1411 },
1412 ],
1413 )
1414 }
1415 }
1416 pub struct PlainMapLTypeDefn {
1417 pub header: Box<PlainCollectionHeader>,
1418
1419 pub bound: Box<LBound>,
1420
1421 pub element_identifier: Box<TypeIdentifier>,
1422
1423 pub key_flags: Box<CollectionElementFlag>,
1424
1425 pub key_identifier: Box<TypeIdentifier>,
1426 }
1427
1428 impl PlainMapLTypeDefn {
1429 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
1430 }
1431
1432 impl xidl_xcdr::XcdrSerialize for PlainMapLTypeDefn {
1433 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
1434 Self::SERIALIZE_KIND
1435 }
1436
1437 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
1438 &self,
1439 serializer: &mut S,
1440 ) -> xidl_xcdr::error::XcdrResult<()> {
1441 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
1442
1443 serializer.begin_field(xidl_xcdr::FieldId(1u32), false, 0)?;
1444
1445 xidl_xcdr::XcdrSerialize::serialize_with(&self.header, serializer)?;
1446 serializer.end_field()?;
1447
1448 serializer.begin_field(xidl_xcdr::FieldId(2u32), false, 0)?;
1449
1450 xidl_xcdr::XcdrSerialize::serialize_with(&self.bound, serializer)?;
1451 serializer.end_field()?;
1452
1453 serializer.begin_field(xidl_xcdr::FieldId(3u32), false, 0)?;
1454
1455 xidl_xcdr::XcdrSerialize::serialize_with(&self.element_identifier, serializer)?;
1456 serializer.end_field()?;
1457
1458 serializer.begin_field(xidl_xcdr::FieldId(4u32), false, 0)?;
1459
1460 xidl_xcdr::XcdrSerialize::serialize_with(&self.key_flags, serializer)?;
1461 serializer.end_field()?;
1462
1463 serializer.begin_field(xidl_xcdr::FieldId(5u32), false, 0)?;
1464
1465 xidl_xcdr::XcdrSerialize::serialize_with(&self.key_identifier, serializer)?;
1466 serializer.end_field()?;
1467
1468 serializer.end_struct()?;
1469 Ok(())
1470 }
1471 }
1472
1473 impl xidl_xcdr::XcdrDeserialize for PlainMapLTypeDefn {
1474 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
1475 deserializer: &mut D,
1476 ) -> xidl_xcdr::error::XcdrResult<Self> {
1477 let header = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
1478
1479 let bound = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
1480
1481 let element_identifier = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
1482
1483 let key_flags = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
1484
1485 let key_identifier = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
1486
1487 Ok(Self {
1488 header,
1489
1490 bound,
1491
1492 element_identifier,
1493
1494 key_flags,
1495
1496 key_identifier,
1497 })
1498 }
1499 }
1500
1501 impl xidl_typeobject::XidlTypeObject for PlainMapLTypeDefn {
1502 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
1503 xidl_typeobject::runtime::build_minimal_struct(
1504 0u32,
1505 xidl_typeobject::runtime::type_identifier_none(),
1506 vec![
1507 xidl_typeobject::runtime::StructMemberDesc {
1508 member_id: 1u32,
1509 member_flags: 0u32,
1510 type_id: xidl_typeobject::runtime::type_identifier_for::<
1511 PlainCollectionHeader,
1512 >(
1513 xidl_typeobject::runtime::TypeEquivalence::Minimal
1514 ),
1515 name: "header",
1516 },
1517 xidl_typeobject::runtime::StructMemberDesc {
1518 member_id: 2u32,
1519 member_flags: 0u32,
1520 type_id: xidl_typeobject::runtime::type_identifier_for::<LBound>(
1521 xidl_typeobject::runtime::TypeEquivalence::Minimal,
1522 ),
1523 name: "bound",
1524 },
1525 xidl_typeobject::runtime::StructMemberDesc {
1526 member_id: 3u32,
1527 member_flags: 4u32,
1528 type_id: xidl_typeobject::runtime::type_identifier_for::<TypeIdentifier>(
1529 xidl_typeobject::runtime::TypeEquivalence::Minimal,
1530 ),
1531 name: "element_identifier",
1532 },
1533 xidl_typeobject::runtime::StructMemberDesc {
1534 member_id: 4u32,
1535 member_flags: 0u32,
1536 type_id: xidl_typeobject::runtime::type_identifier_for::<
1537 CollectionElementFlag,
1538 >(
1539 xidl_typeobject::runtime::TypeEquivalence::Minimal
1540 ),
1541 name: "key_flags",
1542 },
1543 xidl_typeobject::runtime::StructMemberDesc {
1544 member_id: 5u32,
1545 member_flags: 4u32,
1546 type_id: xidl_typeobject::runtime::type_identifier_for::<TypeIdentifier>(
1547 xidl_typeobject::runtime::TypeEquivalence::Minimal,
1548 ),
1549 name: "key_identifier",
1550 },
1551 ],
1552 )
1553 }
1554
1555 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
1556 xidl_typeobject::runtime::build_complete_struct(
1557 "DDS::XTypes::PlainMapLTypeDefn",
1558 0u32,
1559 xidl_typeobject::runtime::type_identifier_none(),
1560 vec![
1561 xidl_typeobject::runtime::StructMemberDesc {
1562 member_id: 1u32,
1563 member_flags: 0u32,
1564 type_id: xidl_typeobject::runtime::type_identifier_for::<
1565 PlainCollectionHeader,
1566 >(
1567 xidl_typeobject::runtime::TypeEquivalence::Complete
1568 ),
1569 name: "header",
1570 },
1571 xidl_typeobject::runtime::StructMemberDesc {
1572 member_id: 2u32,
1573 member_flags: 0u32,
1574 type_id: xidl_typeobject::runtime::type_identifier_for::<LBound>(
1575 xidl_typeobject::runtime::TypeEquivalence::Complete,
1576 ),
1577 name: "bound",
1578 },
1579 xidl_typeobject::runtime::StructMemberDesc {
1580 member_id: 3u32,
1581 member_flags: 4u32,
1582 type_id: xidl_typeobject::runtime::type_identifier_for::<TypeIdentifier>(
1583 xidl_typeobject::runtime::TypeEquivalence::Complete,
1584 ),
1585 name: "element_identifier",
1586 },
1587 xidl_typeobject::runtime::StructMemberDesc {
1588 member_id: 4u32,
1589 member_flags: 0u32,
1590 type_id: xidl_typeobject::runtime::type_identifier_for::<
1591 CollectionElementFlag,
1592 >(
1593 xidl_typeobject::runtime::TypeEquivalence::Complete
1594 ),
1595 name: "key_flags",
1596 },
1597 xidl_typeobject::runtime::StructMemberDesc {
1598 member_id: 5u32,
1599 member_flags: 4u32,
1600 type_id: xidl_typeobject::runtime::type_identifier_for::<TypeIdentifier>(
1601 xidl_typeobject::runtime::TypeEquivalence::Complete,
1602 ),
1603 name: "key_identifier",
1604 },
1605 ],
1606 )
1607 }
1608 }
1609 pub struct StronglyConnectedComponentId {
1610 pub sc_component_id: Box<TypeObjectHashId>,
1611
1612 pub scc_length: i32,
1613
1614 pub scc_index: i32,
1615 }
1616
1617 impl StronglyConnectedComponentId {
1618 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
1619 }
1620
1621 impl xidl_xcdr::XcdrSerialize for StronglyConnectedComponentId {
1622 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
1623 Self::SERIALIZE_KIND
1624 }
1625
1626 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
1627 &self,
1628 serializer: &mut S,
1629 ) -> xidl_xcdr::error::XcdrResult<()> {
1630 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
1631
1632 serializer.begin_field(xidl_xcdr::FieldId(1u32), false, 0)?;
1633
1634 xidl_xcdr::XcdrSerialize::serialize_with(&self.sc_component_id, serializer)?;
1635 serializer.end_field()?;
1636
1637 serializer.begin_field(xidl_xcdr::FieldId(2u32), false, 0)?;
1638
1639 xidl_xcdr::XcdrSerialize::serialize_with(&self.scc_length, serializer)?;
1640 serializer.end_field()?;
1641
1642 serializer.begin_field(xidl_xcdr::FieldId(3u32), false, 0)?;
1643
1644 xidl_xcdr::XcdrSerialize::serialize_with(&self.scc_index, serializer)?;
1645 serializer.end_field()?;
1646
1647 serializer.end_struct()?;
1648 Ok(())
1649 }
1650 }
1651
1652 impl xidl_xcdr::XcdrDeserialize for StronglyConnectedComponentId {
1653 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
1654 deserializer: &mut D,
1655 ) -> xidl_xcdr::error::XcdrResult<Self> {
1656 let sc_component_id = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
1657
1658 let scc_length = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
1659
1660 let scc_index = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
1661
1662 Ok(Self {
1663 sc_component_id,
1664
1665 scc_length,
1666
1667 scc_index,
1668 })
1669 }
1670 }
1671
1672 impl xidl_typeobject::XidlTypeObject for StronglyConnectedComponentId {
1673 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
1674 xidl_typeobject::runtime::build_minimal_struct(
1675 0u32,
1676 xidl_typeobject::runtime::type_identifier_none(),
1677 vec![
1678 xidl_typeobject::runtime::StructMemberDesc {
1679 member_id: 1u32,
1680 member_flags: 0u32,
1681 type_id: xidl_typeobject::runtime::type_identifier_for::<
1682 TypeObjectHashId,
1683 >(
1684 xidl_typeobject::runtime::TypeEquivalence::Minimal
1685 ),
1686 name: "sc_component_id",
1687 },
1688 xidl_typeobject::runtime::StructMemberDesc {
1689 member_id: 2u32,
1690 member_flags: 0u32,
1691 type_id: xidl_typeobject::runtime::type_identifier_primitive(
1692 xidl_typeobject::DDS::XTypes::TK_INT32,
1693 ),
1694 name: "scc_length",
1695 },
1696 xidl_typeobject::runtime::StructMemberDesc {
1697 member_id: 3u32,
1698 member_flags: 0u32,
1699 type_id: xidl_typeobject::runtime::type_identifier_primitive(
1700 xidl_typeobject::DDS::XTypes::TK_INT32,
1701 ),
1702 name: "scc_index",
1703 },
1704 ],
1705 )
1706 }
1707
1708 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
1709 xidl_typeobject::runtime::build_complete_struct(
1710 "DDS::XTypes::StronglyConnectedComponentId",
1711 0u32,
1712 xidl_typeobject::runtime::type_identifier_none(),
1713 vec![
1714 xidl_typeobject::runtime::StructMemberDesc {
1715 member_id: 1u32,
1716 member_flags: 0u32,
1717 type_id: xidl_typeobject::runtime::type_identifier_for::<
1718 TypeObjectHashId,
1719 >(
1720 xidl_typeobject::runtime::TypeEquivalence::Complete
1721 ),
1722 name: "sc_component_id",
1723 },
1724 xidl_typeobject::runtime::StructMemberDesc {
1725 member_id: 2u32,
1726 member_flags: 0u32,
1727 type_id: xidl_typeobject::runtime::type_identifier_primitive(
1728 xidl_typeobject::DDS::XTypes::TK_INT32,
1729 ),
1730 name: "scc_length",
1731 },
1732 xidl_typeobject::runtime::StructMemberDesc {
1733 member_id: 3u32,
1734 member_flags: 0u32,
1735 type_id: xidl_typeobject::runtime::type_identifier_primitive(
1736 xidl_typeobject::DDS::XTypes::TK_INT32,
1737 ),
1738 name: "scc_index",
1739 },
1740 ],
1741 )
1742 }
1743 }
1744 pub struct ExtendedTypeDefn {}
1745
1746 impl ExtendedTypeDefn {
1747 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
1748 }
1749
1750 impl xidl_xcdr::XcdrSerialize for ExtendedTypeDefn {
1751 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
1752 Self::SERIALIZE_KIND
1753 }
1754
1755 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
1756 &self,
1757 serializer: &mut S,
1758 ) -> xidl_xcdr::error::XcdrResult<()> {
1759 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
1760
1761 serializer.end_struct()?;
1762 Ok(())
1763 }
1764 }
1765
1766 impl xidl_xcdr::XcdrDeserialize for ExtendedTypeDefn {
1767 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
1768 deserializer: &mut D,
1769 ) -> xidl_xcdr::error::XcdrResult<Self> {
1770 Ok(Self {})
1771 }
1772 }
1773
1774 impl xidl_typeobject::XidlTypeObject for ExtendedTypeDefn {
1775 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
1776 xidl_typeobject::runtime::build_minimal_struct(
1777 0u32,
1778 xidl_typeobject::runtime::type_identifier_none(),
1779 vec![],
1780 )
1781 }
1782
1783 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
1784 xidl_typeobject::runtime::build_complete_struct(
1785 "DDS::XTypes::ExtendedTypeDefn",
1786 0u32,
1787 xidl_typeobject::runtime::type_identifier_none(),
1788 vec![],
1789 )
1790 }
1791 }
1792 pub struct TypeIdentifier {
1793 pub _d: u8,
1794
1795 pub string_sdefn: Option<Box<StringSTypeDefn>>,
1796
1797 pub string_ldefn: Option<Box<StringLTypeDefn>>,
1798
1799 pub seq_sdefn: Option<Box<PlainSequenceSElemDefn>>,
1800
1801 pub seq_ldefn: Option<Box<PlainSequenceLElemDefn>>,
1802
1803 pub array_sdefn: Option<Box<PlainArraySElemDefn>>,
1804
1805 pub array_ldefn: Option<Box<PlainArrayLElemDefn>>,
1806
1807 pub map_sdefn: Option<Box<PlainMapSTypeDefn>>,
1808
1809 pub map_ldefn: Option<Box<PlainMapLTypeDefn>>,
1810
1811 pub sc_component_id: Option<Box<StronglyConnectedComponentId>>,
1812
1813 pub equivalence_hash: Option<Box<EquivalenceHash>>,
1814
1815 pub extended_defn: Option<Box<ExtendedTypeDefn>>,
1816 }
1817
1818 impl TypeIdentifier {
1819 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
1820
1821 pub fn new_string_sdefn(value: Box<StringSTypeDefn>) -> Self {
1822 Self {
1823 _d: TI_STRING8_SMALL | TI_STRING16_SMALL,
1824 string_sdefn: Some(value),
1825
1826 string_ldefn: None,
1827
1828 seq_sdefn: None,
1829
1830 seq_ldefn: None,
1831
1832 array_sdefn: None,
1833
1834 array_ldefn: None,
1835
1836 map_sdefn: None,
1837
1838 map_ldefn: None,
1839
1840 sc_component_id: None,
1841
1842 equivalence_hash: None,
1843
1844 extended_defn: None,
1845 }
1846 }
1847
1848 pub fn is_string_sdefn(&self) -> bool {
1849 matches!(self._d, TI_STRING8_SMALL | TI_STRING16_SMALL)
1850 }
1851
1852 pub fn new_string_ldefn(value: Box<StringLTypeDefn>) -> Self {
1853 Self {
1854 _d: TI_STRING8_LARGE | TI_STRING16_LARGE,
1855 string_ldefn: Some(value),
1856
1857 string_sdefn: None,
1858
1859 seq_sdefn: None,
1860
1861 seq_ldefn: None,
1862
1863 array_sdefn: None,
1864
1865 array_ldefn: None,
1866
1867 map_sdefn: None,
1868
1869 map_ldefn: None,
1870
1871 sc_component_id: None,
1872
1873 equivalence_hash: None,
1874
1875 extended_defn: None,
1876 }
1877 }
1878
1879 pub fn is_string_ldefn(&self) -> bool {
1880 matches!(self._d, TI_STRING8_LARGE | TI_STRING16_LARGE)
1881 }
1882
1883 pub fn new_seq_sdefn(value: Box<PlainSequenceSElemDefn>) -> Self {
1884 Self {
1885 _d: TI_PLAIN_SEQUENCE_SMALL,
1886 seq_sdefn: Some(value),
1887
1888 string_sdefn: None,
1889
1890 string_ldefn: None,
1891
1892 seq_ldefn: None,
1893
1894 array_sdefn: None,
1895
1896 array_ldefn: None,
1897
1898 map_sdefn: None,
1899
1900 map_ldefn: None,
1901
1902 sc_component_id: None,
1903
1904 equivalence_hash: None,
1905
1906 extended_defn: None,
1907 }
1908 }
1909
1910 pub fn is_seq_sdefn(&self) -> bool {
1911 matches!(self._d, TI_PLAIN_SEQUENCE_SMALL)
1912 }
1913
1914 pub fn new_seq_ldefn(value: Box<PlainSequenceLElemDefn>) -> Self {
1915 Self {
1916 _d: TI_PLAIN_SEQUENCE_LARGE,
1917 seq_ldefn: Some(value),
1918
1919 string_sdefn: None,
1920
1921 string_ldefn: None,
1922
1923 seq_sdefn: None,
1924
1925 array_sdefn: None,
1926
1927 array_ldefn: None,
1928
1929 map_sdefn: None,
1930
1931 map_ldefn: None,
1932
1933 sc_component_id: None,
1934
1935 equivalence_hash: None,
1936
1937 extended_defn: None,
1938 }
1939 }
1940
1941 pub fn is_seq_ldefn(&self) -> bool {
1942 matches!(self._d, TI_PLAIN_SEQUENCE_LARGE)
1943 }
1944
1945 pub fn new_array_sdefn(value: Box<PlainArraySElemDefn>) -> Self {
1946 Self {
1947 _d: TI_PLAIN_ARRAY_SMALL,
1948 array_sdefn: Some(value),
1949
1950 string_sdefn: None,
1951
1952 string_ldefn: None,
1953
1954 seq_sdefn: None,
1955
1956 seq_ldefn: None,
1957
1958 array_ldefn: None,
1959
1960 map_sdefn: None,
1961
1962 map_ldefn: None,
1963
1964 sc_component_id: None,
1965
1966 equivalence_hash: None,
1967
1968 extended_defn: None,
1969 }
1970 }
1971
1972 pub fn is_array_sdefn(&self) -> bool {
1973 matches!(self._d, TI_PLAIN_ARRAY_SMALL)
1974 }
1975
1976 pub fn new_array_ldefn(value: Box<PlainArrayLElemDefn>) -> Self {
1977 Self {
1978 _d: TI_PLAIN_ARRAY_LARGE,
1979 array_ldefn: Some(value),
1980
1981 string_sdefn: None,
1982
1983 string_ldefn: None,
1984
1985 seq_sdefn: None,
1986
1987 seq_ldefn: None,
1988
1989 array_sdefn: None,
1990
1991 map_sdefn: None,
1992
1993 map_ldefn: None,
1994
1995 sc_component_id: None,
1996
1997 equivalence_hash: None,
1998
1999 extended_defn: None,
2000 }
2001 }
2002
2003 pub fn is_array_ldefn(&self) -> bool {
2004 matches!(self._d, TI_PLAIN_ARRAY_LARGE)
2005 }
2006
2007 pub fn new_map_sdefn(value: Box<PlainMapSTypeDefn>) -> Self {
2008 Self {
2009 _d: TI_PLAIN_MAP_SMALL,
2010 map_sdefn: Some(value),
2011
2012 string_sdefn: None,
2013
2014 string_ldefn: None,
2015
2016 seq_sdefn: None,
2017
2018 seq_ldefn: None,
2019
2020 array_sdefn: None,
2021
2022 array_ldefn: None,
2023
2024 map_ldefn: None,
2025
2026 sc_component_id: None,
2027
2028 equivalence_hash: None,
2029
2030 extended_defn: None,
2031 }
2032 }
2033
2034 pub fn is_map_sdefn(&self) -> bool {
2035 matches!(self._d, TI_PLAIN_MAP_SMALL)
2036 }
2037
2038 pub fn new_map_ldefn(value: Box<PlainMapLTypeDefn>) -> Self {
2039 Self {
2040 _d: TI_PLAIN_MAP_LARGE,
2041 map_ldefn: Some(value),
2042
2043 string_sdefn: None,
2044
2045 string_ldefn: None,
2046
2047 seq_sdefn: None,
2048
2049 seq_ldefn: None,
2050
2051 array_sdefn: None,
2052
2053 array_ldefn: None,
2054
2055 map_sdefn: None,
2056
2057 sc_component_id: None,
2058
2059 equivalence_hash: None,
2060
2061 extended_defn: None,
2062 }
2063 }
2064
2065 pub fn is_map_ldefn(&self) -> bool {
2066 matches!(self._d, TI_PLAIN_MAP_LARGE)
2067 }
2068
2069 pub fn new_sc_component_id(value: Box<StronglyConnectedComponentId>) -> Self {
2070 Self {
2071 _d: TI_STRONGLY_CONNECTED_COMPONENT,
2072 sc_component_id: Some(value),
2073
2074 string_sdefn: None,
2075
2076 string_ldefn: None,
2077
2078 seq_sdefn: None,
2079
2080 seq_ldefn: None,
2081
2082 array_sdefn: None,
2083
2084 array_ldefn: None,
2085
2086 map_sdefn: None,
2087
2088 map_ldefn: None,
2089
2090 equivalence_hash: None,
2091
2092 extended_defn: None,
2093 }
2094 }
2095
2096 pub fn is_sc_component_id(&self) -> bool {
2097 matches!(self._d, TI_STRONGLY_CONNECTED_COMPONENT)
2098 }
2099
2100 pub fn new_equivalence_hash(value: Box<EquivalenceHash>) -> Self {
2101 Self {
2102 _d: EK_COMPLETE | EK_MINIMAL,
2103 equivalence_hash: Some(value),
2104
2105 string_sdefn: None,
2106
2107 string_ldefn: None,
2108
2109 seq_sdefn: None,
2110
2111 seq_ldefn: None,
2112
2113 array_sdefn: None,
2114
2115 array_ldefn: None,
2116
2117 map_sdefn: None,
2118
2119 map_ldefn: None,
2120
2121 sc_component_id: None,
2122
2123 extended_defn: None,
2124 }
2125 }
2126
2127 pub fn is_equivalence_hash(&self) -> bool {
2128 matches!(self._d, EK_COMPLETE | EK_MINIMAL)
2129 }
2130
2131 pub fn new_extended_defn(value: Box<ExtendedTypeDefn>) -> Self {
2132 Self {
2133 _d: u8::default(),
2134 extended_defn: Some(value),
2135
2136 string_sdefn: None,
2137
2138 string_ldefn: None,
2139
2140 seq_sdefn: None,
2141
2142 seq_ldefn: None,
2143
2144 array_sdefn: None,
2145
2146 array_ldefn: None,
2147
2148 map_sdefn: None,
2149
2150 map_ldefn: None,
2151
2152 sc_component_id: None,
2153
2154 equivalence_hash: None,
2155 }
2156 }
2157
2158 pub fn is_extended_defn(&self) -> bool {
2159 matches!(self._d, _)
2160 }
2161
2162 pub fn tag(&self) -> &u8 {
2163 &self._d
2164 }
2165 }
2166
2167 impl xidl_xcdr::XcdrSerialize for TypeIdentifier {
2168 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
2169 Self::SERIALIZE_KIND
2170 }
2171
2172 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
2173 &self,
2174 serializer: &mut S,
2175 ) -> xidl_xcdr::error::XcdrResult<()> {
2176 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
2177 serializer.begin_field(xidl_xcdr::FieldId(0), false, 0)?;
2178 xidl_xcdr::XcdrSerialize::serialize_with(&self._d, serializer)?;
2179 serializer.end_field()?;
2180 match self._d {
2181 TI_STRING8_SMALL | TI_STRING16_SMALL => {
2182 let value = self.string_sdefn.as_ref().ok_or_else(|| {
2183 xidl_xcdr::error::XcdrError::Message(
2184 "union member is not set for discriminator".to_string(),
2185 )
2186 })?;
2187 serializer.begin_field(xidl_xcdr::FieldId(1u32), false, 0)?;
2188 xidl_xcdr::XcdrSerialize::serialize_with(value, serializer)?;
2189 serializer.end_field()?;
2190 }
2191
2192 TI_STRING8_LARGE | TI_STRING16_LARGE => {
2193 let value = self.string_ldefn.as_ref().ok_or_else(|| {
2194 xidl_xcdr::error::XcdrError::Message(
2195 "union member is not set for discriminator".to_string(),
2196 )
2197 })?;
2198 serializer.begin_field(xidl_xcdr::FieldId(2u32), false, 0)?;
2199 xidl_xcdr::XcdrSerialize::serialize_with(value, serializer)?;
2200 serializer.end_field()?;
2201 }
2202
2203 TI_PLAIN_SEQUENCE_SMALL => {
2204 let value = self.seq_sdefn.as_ref().ok_or_else(|| {
2205 xidl_xcdr::error::XcdrError::Message(
2206 "union member is not set for discriminator".to_string(),
2207 )
2208 })?;
2209 serializer.begin_field(xidl_xcdr::FieldId(3u32), false, 0)?;
2210 xidl_xcdr::XcdrSerialize::serialize_with(value, serializer)?;
2211 serializer.end_field()?;
2212 }
2213
2214 TI_PLAIN_SEQUENCE_LARGE => {
2215 let value = self.seq_ldefn.as_ref().ok_or_else(|| {
2216 xidl_xcdr::error::XcdrError::Message(
2217 "union member is not set for discriminator".to_string(),
2218 )
2219 })?;
2220 serializer.begin_field(xidl_xcdr::FieldId(4u32), false, 0)?;
2221 xidl_xcdr::XcdrSerialize::serialize_with(value, serializer)?;
2222 serializer.end_field()?;
2223 }
2224
2225 TI_PLAIN_ARRAY_SMALL => {
2226 let value = self.array_sdefn.as_ref().ok_or_else(|| {
2227 xidl_xcdr::error::XcdrError::Message(
2228 "union member is not set for discriminator".to_string(),
2229 )
2230 })?;
2231 serializer.begin_field(xidl_xcdr::FieldId(5u32), false, 0)?;
2232 xidl_xcdr::XcdrSerialize::serialize_with(value, serializer)?;
2233 serializer.end_field()?;
2234 }
2235
2236 TI_PLAIN_ARRAY_LARGE => {
2237 let value = self.array_ldefn.as_ref().ok_or_else(|| {
2238 xidl_xcdr::error::XcdrError::Message(
2239 "union member is not set for discriminator".to_string(),
2240 )
2241 })?;
2242 serializer.begin_field(xidl_xcdr::FieldId(6u32), false, 0)?;
2243 xidl_xcdr::XcdrSerialize::serialize_with(value, serializer)?;
2244 serializer.end_field()?;
2245 }
2246
2247 TI_PLAIN_MAP_SMALL => {
2248 let value = self.map_sdefn.as_ref().ok_or_else(|| {
2249 xidl_xcdr::error::XcdrError::Message(
2250 "union member is not set for discriminator".to_string(),
2251 )
2252 })?;
2253 serializer.begin_field(xidl_xcdr::FieldId(7u32), false, 0)?;
2254 xidl_xcdr::XcdrSerialize::serialize_with(value, serializer)?;
2255 serializer.end_field()?;
2256 }
2257
2258 TI_PLAIN_MAP_LARGE => {
2259 let value = self.map_ldefn.as_ref().ok_or_else(|| {
2260 xidl_xcdr::error::XcdrError::Message(
2261 "union member is not set for discriminator".to_string(),
2262 )
2263 })?;
2264 serializer.begin_field(xidl_xcdr::FieldId(8u32), false, 0)?;
2265 xidl_xcdr::XcdrSerialize::serialize_with(value, serializer)?;
2266 serializer.end_field()?;
2267 }
2268
2269 TI_STRONGLY_CONNECTED_COMPONENT => {
2270 let value = self.sc_component_id.as_ref().ok_or_else(|| {
2271 xidl_xcdr::error::XcdrError::Message(
2272 "union member is not set for discriminator".to_string(),
2273 )
2274 })?;
2275 serializer.begin_field(xidl_xcdr::FieldId(9u32), false, 0)?;
2276 xidl_xcdr::XcdrSerialize::serialize_with(value, serializer)?;
2277 serializer.end_field()?;
2278 }
2279
2280 EK_COMPLETE | EK_MINIMAL => {
2281 let value = self.equivalence_hash.as_ref().ok_or_else(|| {
2282 xidl_xcdr::error::XcdrError::Message(
2283 "union member is not set for discriminator".to_string(),
2284 )
2285 })?;
2286 serializer.begin_field(xidl_xcdr::FieldId(10u32), false, 0)?;
2287 xidl_xcdr::XcdrSerialize::serialize_with(value, serializer)?;
2288 serializer.end_field()?;
2289 }
2290
2291 _ => {
2292 let value = self.extended_defn.as_ref().ok_or_else(|| {
2293 xidl_xcdr::error::XcdrError::Message(
2294 "union member is not set for discriminator".to_string(),
2295 )
2296 })?;
2297 serializer.begin_field(xidl_xcdr::FieldId(11u32), false, 0)?;
2298 xidl_xcdr::XcdrSerialize::serialize_with(value, serializer)?;
2299 serializer.end_field()?;
2300 }
2301 }
2302 serializer.end_struct()?;
2303 Ok(())
2304 }
2305 }
2306
2307 impl xidl_xcdr::XcdrDeserialize for TypeIdentifier {
2308 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
2309 deserializer: &mut D,
2310 ) -> xidl_xcdr::error::XcdrResult<Self> {
2311 let _d = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
2312 let mut out = Self {
2313 _d,
2314
2315 string_sdefn: None,
2316
2317 string_ldefn: None,
2318
2319 seq_sdefn: None,
2320
2321 seq_ldefn: None,
2322
2323 array_sdefn: None,
2324
2325 array_ldefn: None,
2326
2327 map_sdefn: None,
2328
2329 map_ldefn: None,
2330
2331 sc_component_id: None,
2332
2333 equivalence_hash: None,
2334
2335 extended_defn: None,
2336 };
2337 match out._d {
2338 TI_STRING8_SMALL | TI_STRING16_SMALL => {
2339 out.string_sdefn =
2340 Some(xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?);
2341 }
2342
2343 TI_STRING8_LARGE | TI_STRING16_LARGE => {
2344 out.string_ldefn =
2345 Some(xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?);
2346 }
2347
2348 TI_PLAIN_SEQUENCE_SMALL => {
2349 out.seq_sdefn =
2350 Some(xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?);
2351 }
2352
2353 TI_PLAIN_SEQUENCE_LARGE => {
2354 out.seq_ldefn =
2355 Some(xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?);
2356 }
2357
2358 TI_PLAIN_ARRAY_SMALL => {
2359 out.array_sdefn =
2360 Some(xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?);
2361 }
2362
2363 TI_PLAIN_ARRAY_LARGE => {
2364 out.array_ldefn =
2365 Some(xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?);
2366 }
2367
2368 TI_PLAIN_MAP_SMALL => {
2369 out.map_sdefn =
2370 Some(xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?);
2371 }
2372
2373 TI_PLAIN_MAP_LARGE => {
2374 out.map_ldefn =
2375 Some(xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?);
2376 }
2377
2378 TI_STRONGLY_CONNECTED_COMPONENT => {
2379 out.sc_component_id =
2380 Some(xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?);
2381 }
2382
2383 EK_COMPLETE | EK_MINIMAL => {
2384 out.equivalence_hash =
2385 Some(xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?);
2386 }
2387
2388 _ => {
2389 out.extended_defn =
2390 Some(xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?);
2391 }
2392 }
2393 Ok(out)
2394 }
2395 }
2396
2397 impl xidl_typeobject::XidlTypeObject for TypeIdentifier {
2398 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
2399 xidl_typeobject::runtime::build_minimal_union(
2400 0u32,
2401 xidl_typeobject::runtime::type_identifier_primitive(
2402 xidl_typeobject::DDS::XTypes::TK_BYTE,
2403 ),
2404 vec![
2405 xidl_typeobject::runtime::UnionMemberDesc {
2406 member_id: 1u32,
2407 member_flags: 0u32,
2408 type_id: xidl_typeobject::runtime::type_identifier_for::<StringSTypeDefn>(
2409 xidl_typeobject::runtime::TypeEquivalence::Minimal,
2410 ),
2411 name: "string_sdefn",
2412 labels: vec![0i32, 0i32],
2413 },
2414 xidl_typeobject::runtime::UnionMemberDesc {
2415 member_id: 3u32,
2416 member_flags: 0u32,
2417 type_id: xidl_typeobject::runtime::type_identifier_for::<
2418 PlainSequenceSElemDefn,
2419 >(
2420 xidl_typeobject::runtime::TypeEquivalence::Minimal
2421 ),
2422 name: "seq_sdefn",
2423 labels: vec![0i32],
2424 },
2425 xidl_typeobject::runtime::UnionMemberDesc {
2426 member_id: 9u32,
2427 member_flags: 0u32,
2428 type_id: xidl_typeobject::runtime::type_identifier_for::<
2429 StronglyConnectedComponentId,
2430 >(
2431 xidl_typeobject::runtime::TypeEquivalence::Minimal
2432 ),
2433 name: "sc_component_id",
2434 labels: vec![0i32],
2435 },
2436 xidl_typeobject::runtime::UnionMemberDesc {
2437 member_id: 11u32,
2438 member_flags: 64u32,
2439 type_id: xidl_typeobject::runtime::type_identifier_for::<
2440 ExtendedTypeDefn,
2441 >(
2442 xidl_typeobject::runtime::TypeEquivalence::Minimal
2443 ),
2444 name: "extended_defn",
2445 labels: vec![],
2446 },
2447 xidl_typeobject::runtime::UnionMemberDesc {
2448 member_id: 5u32,
2449 member_flags: 0u32,
2450 type_id: xidl_typeobject::runtime::type_identifier_for::<
2451 PlainArraySElemDefn,
2452 >(
2453 xidl_typeobject::runtime::TypeEquivalence::Minimal
2454 ),
2455 name: "array_sdefn",
2456 labels: vec![0i32],
2457 },
2458 xidl_typeobject::runtime::UnionMemberDesc {
2459 member_id: 10u32,
2460 member_flags: 0u32,
2461 type_id: xidl_typeobject::runtime::type_identifier_for::<EquivalenceHash>(
2462 xidl_typeobject::runtime::TypeEquivalence::Minimal,
2463 ),
2464 name: "equivalence_hash",
2465 labels: vec![0i32, 0i32],
2466 },
2467 xidl_typeobject::runtime::UnionMemberDesc {
2468 member_id: 4u32,
2469 member_flags: 0u32,
2470 type_id: xidl_typeobject::runtime::type_identifier_for::<
2471 PlainSequenceLElemDefn,
2472 >(
2473 xidl_typeobject::runtime::TypeEquivalence::Minimal
2474 ),
2475 name: "seq_ldefn",
2476 labels: vec![0i32],
2477 },
2478 xidl_typeobject::runtime::UnionMemberDesc {
2479 member_id: 6u32,
2480 member_flags: 0u32,
2481 type_id: xidl_typeobject::runtime::type_identifier_for::<
2482 PlainArrayLElemDefn,
2483 >(
2484 xidl_typeobject::runtime::TypeEquivalence::Minimal
2485 ),
2486 name: "array_ldefn",
2487 labels: vec![0i32],
2488 },
2489 xidl_typeobject::runtime::UnionMemberDesc {
2490 member_id: 7u32,
2491 member_flags: 0u32,
2492 type_id: xidl_typeobject::runtime::type_identifier_for::<
2493 PlainMapSTypeDefn,
2494 >(
2495 xidl_typeobject::runtime::TypeEquivalence::Minimal
2496 ),
2497 name: "map_sdefn",
2498 labels: vec![0i32],
2499 },
2500 xidl_typeobject::runtime::UnionMemberDesc {
2501 member_id: 2u32,
2502 member_flags: 0u32,
2503 type_id: xidl_typeobject::runtime::type_identifier_for::<StringLTypeDefn>(
2504 xidl_typeobject::runtime::TypeEquivalence::Minimal,
2505 ),
2506 name: "string_ldefn",
2507 labels: vec![0i32, 0i32],
2508 },
2509 xidl_typeobject::runtime::UnionMemberDesc {
2510 member_id: 8u32,
2511 member_flags: 0u32,
2512 type_id: xidl_typeobject::runtime::type_identifier_for::<
2513 PlainMapLTypeDefn,
2514 >(
2515 xidl_typeobject::runtime::TypeEquivalence::Minimal
2516 ),
2517 name: "map_ldefn",
2518 labels: vec![0i32],
2519 },
2520 ],
2521 )
2522 }
2523
2524 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
2525 xidl_typeobject::runtime::build_complete_union(
2526 "DDS::XTypes::TypeIdentifier",
2527 0u32,
2528 xidl_typeobject::runtime::type_identifier_primitive(
2529 xidl_typeobject::DDS::XTypes::TK_BYTE,
2530 ),
2531 vec![
2532 xidl_typeobject::runtime::UnionMemberDesc {
2533 member_id: 1u32,
2534 member_flags: 0u32,
2535 type_id: xidl_typeobject::runtime::type_identifier_for::<StringSTypeDefn>(
2536 xidl_typeobject::runtime::TypeEquivalence::Complete,
2537 ),
2538 name: "string_sdefn",
2539 labels: vec![0i32, 0i32],
2540 },
2541 xidl_typeobject::runtime::UnionMemberDesc {
2542 member_id: 3u32,
2543 member_flags: 0u32,
2544 type_id: xidl_typeobject::runtime::type_identifier_for::<
2545 PlainSequenceSElemDefn,
2546 >(
2547 xidl_typeobject::runtime::TypeEquivalence::Complete
2548 ),
2549 name: "seq_sdefn",
2550 labels: vec![0i32],
2551 },
2552 xidl_typeobject::runtime::UnionMemberDesc {
2553 member_id: 9u32,
2554 member_flags: 0u32,
2555 type_id: xidl_typeobject::runtime::type_identifier_for::<
2556 StronglyConnectedComponentId,
2557 >(
2558 xidl_typeobject::runtime::TypeEquivalence::Complete
2559 ),
2560 name: "sc_component_id",
2561 labels: vec![0i32],
2562 },
2563 xidl_typeobject::runtime::UnionMemberDesc {
2564 member_id: 11u32,
2565 member_flags: 64u32,
2566 type_id: xidl_typeobject::runtime::type_identifier_for::<
2567 ExtendedTypeDefn,
2568 >(
2569 xidl_typeobject::runtime::TypeEquivalence::Complete
2570 ),
2571 name: "extended_defn",
2572 labels: vec![],
2573 },
2574 xidl_typeobject::runtime::UnionMemberDesc {
2575 member_id: 5u32,
2576 member_flags: 0u32,
2577 type_id: xidl_typeobject::runtime::type_identifier_for::<
2578 PlainArraySElemDefn,
2579 >(
2580 xidl_typeobject::runtime::TypeEquivalence::Complete
2581 ),
2582 name: "array_sdefn",
2583 labels: vec![0i32],
2584 },
2585 xidl_typeobject::runtime::UnionMemberDesc {
2586 member_id: 10u32,
2587 member_flags: 0u32,
2588 type_id: xidl_typeobject::runtime::type_identifier_for::<EquivalenceHash>(
2589 xidl_typeobject::runtime::TypeEquivalence::Complete,
2590 ),
2591 name: "equivalence_hash",
2592 labels: vec![0i32, 0i32],
2593 },
2594 xidl_typeobject::runtime::UnionMemberDesc {
2595 member_id: 4u32,
2596 member_flags: 0u32,
2597 type_id: xidl_typeobject::runtime::type_identifier_for::<
2598 PlainSequenceLElemDefn,
2599 >(
2600 xidl_typeobject::runtime::TypeEquivalence::Complete
2601 ),
2602 name: "seq_ldefn",
2603 labels: vec![0i32],
2604 },
2605 xidl_typeobject::runtime::UnionMemberDesc {
2606 member_id: 6u32,
2607 member_flags: 0u32,
2608 type_id: xidl_typeobject::runtime::type_identifier_for::<
2609 PlainArrayLElemDefn,
2610 >(
2611 xidl_typeobject::runtime::TypeEquivalence::Complete
2612 ),
2613 name: "array_ldefn",
2614 labels: vec![0i32],
2615 },
2616 xidl_typeobject::runtime::UnionMemberDesc {
2617 member_id: 7u32,
2618 member_flags: 0u32,
2619 type_id: xidl_typeobject::runtime::type_identifier_for::<
2620 PlainMapSTypeDefn,
2621 >(
2622 xidl_typeobject::runtime::TypeEquivalence::Complete
2623 ),
2624 name: "map_sdefn",
2625 labels: vec![0i32],
2626 },
2627 xidl_typeobject::runtime::UnionMemberDesc {
2628 member_id: 2u32,
2629 member_flags: 0u32,
2630 type_id: xidl_typeobject::runtime::type_identifier_for::<StringLTypeDefn>(
2631 xidl_typeobject::runtime::TypeEquivalence::Complete,
2632 ),
2633 name: "string_ldefn",
2634 labels: vec![0i32, 0i32],
2635 },
2636 xidl_typeobject::runtime::UnionMemberDesc {
2637 member_id: 8u32,
2638 member_flags: 0u32,
2639 type_id: xidl_typeobject::runtime::type_identifier_for::<
2640 PlainMapLTypeDefn,
2641 >(
2642 xidl_typeobject::runtime::TypeEquivalence::Complete
2643 ),
2644 name: "map_ldefn",
2645 labels: vec![0i32],
2646 },
2647 ],
2648 )
2649 }
2650 }
2651 pub type TypeIdentifierSeq = Vec<TypeIdentifier>;
2652 pub type MemberId = u32;
2653 pub const ANNOTATION_STR_VALUE_MAX_LEN: u32 = 128;
2654 pub const ANNOTATION_OCTETSEC_VALUE_MAX_LEN: u32 = 128;
2655 pub struct ExtendedAnnotationParameterValue {}
2656
2657 impl ExtendedAnnotationParameterValue {
2658 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
2659 }
2660
2661 impl xidl_xcdr::XcdrSerialize for ExtendedAnnotationParameterValue {
2662 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
2663 Self::SERIALIZE_KIND
2664 }
2665
2666 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
2667 &self,
2668 serializer: &mut S,
2669 ) -> xidl_xcdr::error::XcdrResult<()> {
2670 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
2671
2672 serializer.end_struct()?;
2673 Ok(())
2674 }
2675 }
2676
2677 impl xidl_xcdr::XcdrDeserialize for ExtendedAnnotationParameterValue {
2678 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
2679 deserializer: &mut D,
2680 ) -> xidl_xcdr::error::XcdrResult<Self> {
2681 Ok(Self {})
2682 }
2683 }
2684
2685 impl xidl_typeobject::XidlTypeObject for ExtendedAnnotationParameterValue {
2686 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
2687 xidl_typeobject::runtime::build_minimal_struct(
2688 0u32,
2689 xidl_typeobject::runtime::type_identifier_none(),
2690 vec![],
2691 )
2692 }
2693
2694 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
2695 xidl_typeobject::runtime::build_complete_struct(
2696 "DDS::XTypes::ExtendedAnnotationParameterValue",
2697 0u32,
2698 xidl_typeobject::runtime::type_identifier_none(),
2699 vec![],
2700 )
2701 }
2702 }
2703 pub struct AnnotationParameterValue {
2704 pub _d: u8,
2705
2706 pub boolean_value: Option<bool>,
2707
2708 pub byte_value: Option<u8>,
2709
2710 pub int16_value: Option<i16>,
2711
2712 pub uint_16_value: Option<u16>,
2713
2714 pub int32_value: Option<i32>,
2715
2716 pub uint32_value: Option<u32>,
2717
2718 pub int64_value: Option<i64>,
2719
2720 pub uint64_value: Option<u64>,
2721
2722 pub float32_value: Option<f64>,
2723
2724 pub float64_value: Option<f64>,
2725
2726 pub float128_value: Option<f64>,
2727
2728 pub char_value: Option<char>,
2729
2730 pub wchar_value: Option<char>,
2731
2732 pub enumerated_value: Option<i32>,
2733
2734 pub string8_value: Option<String>,
2735
2736 pub string16_value: Option<String>,
2737
2738 pub extended_value: Option<Box<ExtendedAnnotationParameterValue>>,
2739 }
2740
2741 impl AnnotationParameterValue {
2742 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
2743
2744 pub fn new_boolean_value(value: bool) -> Self {
2745 Self {
2746 _d: TK_BOOLEAN,
2747 boolean_value: Some(value),
2748
2749 byte_value: None,
2750
2751 int16_value: None,
2752
2753 uint_16_value: None,
2754
2755 int32_value: None,
2756
2757 uint32_value: None,
2758
2759 int64_value: None,
2760
2761 uint64_value: None,
2762
2763 float32_value: None,
2764
2765 float64_value: None,
2766
2767 float128_value: None,
2768
2769 char_value: None,
2770
2771 wchar_value: None,
2772
2773 enumerated_value: None,
2774
2775 string8_value: None,
2776
2777 string16_value: None,
2778
2779 extended_value: None,
2780 }
2781 }
2782
2783 pub fn is_boolean_value(&self) -> bool {
2784 matches!(self._d, TK_BOOLEAN)
2785 }
2786
2787 pub fn new_byte_value(value: u8) -> Self {
2788 Self {
2789 _d: TK_BYTE,
2790 byte_value: Some(value),
2791
2792 boolean_value: None,
2793
2794 int16_value: None,
2795
2796 uint_16_value: None,
2797
2798 int32_value: None,
2799
2800 uint32_value: None,
2801
2802 int64_value: None,
2803
2804 uint64_value: None,
2805
2806 float32_value: None,
2807
2808 float64_value: None,
2809
2810 float128_value: None,
2811
2812 char_value: None,
2813
2814 wchar_value: None,
2815
2816 enumerated_value: None,
2817
2818 string8_value: None,
2819
2820 string16_value: None,
2821
2822 extended_value: None,
2823 }
2824 }
2825
2826 pub fn is_byte_value(&self) -> bool {
2827 matches!(self._d, TK_BYTE)
2828 }
2829
2830 pub fn new_int16_value(value: i16) -> Self {
2831 Self {
2832 _d: TK_INT16,
2833 int16_value: Some(value),
2834
2835 boolean_value: None,
2836
2837 byte_value: None,
2838
2839 uint_16_value: None,
2840
2841 int32_value: None,
2842
2843 uint32_value: None,
2844
2845 int64_value: None,
2846
2847 uint64_value: None,
2848
2849 float32_value: None,
2850
2851 float64_value: None,
2852
2853 float128_value: None,
2854
2855 char_value: None,
2856
2857 wchar_value: None,
2858
2859 enumerated_value: None,
2860
2861 string8_value: None,
2862
2863 string16_value: None,
2864
2865 extended_value: None,
2866 }
2867 }
2868
2869 pub fn is_int16_value(&self) -> bool {
2870 matches!(self._d, TK_INT16)
2871 }
2872
2873 pub fn new_uint_16_value(value: u16) -> Self {
2874 Self {
2875 _d: TK_UINT16,
2876 uint_16_value: Some(value),
2877
2878 boolean_value: None,
2879
2880 byte_value: None,
2881
2882 int16_value: None,
2883
2884 int32_value: None,
2885
2886 uint32_value: None,
2887
2888 int64_value: None,
2889
2890 uint64_value: None,
2891
2892 float32_value: None,
2893
2894 float64_value: None,
2895
2896 float128_value: None,
2897
2898 char_value: None,
2899
2900 wchar_value: None,
2901
2902 enumerated_value: None,
2903
2904 string8_value: None,
2905
2906 string16_value: None,
2907
2908 extended_value: None,
2909 }
2910 }
2911
2912 pub fn is_uint_16_value(&self) -> bool {
2913 matches!(self._d, TK_UINT16)
2914 }
2915
2916 pub fn new_int32_value(value: i32) -> Self {
2917 Self {
2918 _d: TK_INT32,
2919 int32_value: Some(value),
2920
2921 boolean_value: None,
2922
2923 byte_value: None,
2924
2925 int16_value: None,
2926
2927 uint_16_value: None,
2928
2929 uint32_value: None,
2930
2931 int64_value: None,
2932
2933 uint64_value: None,
2934
2935 float32_value: None,
2936
2937 float64_value: None,
2938
2939 float128_value: None,
2940
2941 char_value: None,
2942
2943 wchar_value: None,
2944
2945 enumerated_value: None,
2946
2947 string8_value: None,
2948
2949 string16_value: None,
2950
2951 extended_value: None,
2952 }
2953 }
2954
2955 pub fn is_int32_value(&self) -> bool {
2956 matches!(self._d, TK_INT32)
2957 }
2958
2959 pub fn new_uint32_value(value: u32) -> Self {
2960 Self {
2961 _d: TK_UINT32,
2962 uint32_value: Some(value),
2963
2964 boolean_value: None,
2965
2966 byte_value: None,
2967
2968 int16_value: None,
2969
2970 uint_16_value: None,
2971
2972 int32_value: None,
2973
2974 int64_value: None,
2975
2976 uint64_value: None,
2977
2978 float32_value: None,
2979
2980 float64_value: None,
2981
2982 float128_value: None,
2983
2984 char_value: None,
2985
2986 wchar_value: None,
2987
2988 enumerated_value: None,
2989
2990 string8_value: None,
2991
2992 string16_value: None,
2993
2994 extended_value: None,
2995 }
2996 }
2997
2998 pub fn is_uint32_value(&self) -> bool {
2999 matches!(self._d, TK_UINT32)
3000 }
3001
3002 pub fn new_int64_value(value: i64) -> Self {
3003 Self {
3004 _d: TK_INT64,
3005 int64_value: Some(value),
3006
3007 boolean_value: None,
3008
3009 byte_value: None,
3010
3011 int16_value: None,
3012
3013 uint_16_value: None,
3014
3015 int32_value: None,
3016
3017 uint32_value: None,
3018
3019 uint64_value: None,
3020
3021 float32_value: None,
3022
3023 float64_value: None,
3024
3025 float128_value: None,
3026
3027 char_value: None,
3028
3029 wchar_value: None,
3030
3031 enumerated_value: None,
3032
3033 string8_value: None,
3034
3035 string16_value: None,
3036
3037 extended_value: None,
3038 }
3039 }
3040
3041 pub fn is_int64_value(&self) -> bool {
3042 matches!(self._d, TK_INT64)
3043 }
3044
3045 pub fn new_uint64_value(value: u64) -> Self {
3046 Self {
3047 _d: TK_UINT64,
3048 uint64_value: Some(value),
3049
3050 boolean_value: None,
3051
3052 byte_value: None,
3053
3054 int16_value: None,
3055
3056 uint_16_value: None,
3057
3058 int32_value: None,
3059
3060 uint32_value: None,
3061
3062 int64_value: None,
3063
3064 float32_value: None,
3065
3066 float64_value: None,
3067
3068 float128_value: None,
3069
3070 char_value: None,
3071
3072 wchar_value: None,
3073
3074 enumerated_value: None,
3075
3076 string8_value: None,
3077
3078 string16_value: None,
3079
3080 extended_value: None,
3081 }
3082 }
3083
3084 pub fn is_uint64_value(&self) -> bool {
3085 matches!(self._d, TK_UINT64)
3086 }
3087
3088 pub fn new_float32_value(value: f64) -> Self {
3089 Self {
3090 _d: TK_FLOAT32,
3091 float32_value: Some(value),
3092
3093 boolean_value: None,
3094
3095 byte_value: None,
3096
3097 int16_value: None,
3098
3099 uint_16_value: None,
3100
3101 int32_value: None,
3102
3103 uint32_value: None,
3104
3105 int64_value: None,
3106
3107 uint64_value: None,
3108
3109 float64_value: None,
3110
3111 float128_value: None,
3112
3113 char_value: None,
3114
3115 wchar_value: None,
3116
3117 enumerated_value: None,
3118
3119 string8_value: None,
3120
3121 string16_value: None,
3122
3123 extended_value: None,
3124 }
3125 }
3126
3127 pub fn is_float32_value(&self) -> bool {
3128 matches!(self._d, TK_FLOAT32)
3129 }
3130
3131 pub fn new_float64_value(value: f64) -> Self {
3132 Self {
3133 _d: TK_FLOAT64,
3134 float64_value: Some(value),
3135
3136 boolean_value: None,
3137
3138 byte_value: None,
3139
3140 int16_value: None,
3141
3142 uint_16_value: None,
3143
3144 int32_value: None,
3145
3146 uint32_value: None,
3147
3148 int64_value: None,
3149
3150 uint64_value: None,
3151
3152 float32_value: None,
3153
3154 float128_value: None,
3155
3156 char_value: None,
3157
3158 wchar_value: None,
3159
3160 enumerated_value: None,
3161
3162 string8_value: None,
3163
3164 string16_value: None,
3165
3166 extended_value: None,
3167 }
3168 }
3169
3170 pub fn is_float64_value(&self) -> bool {
3171 matches!(self._d, TK_FLOAT64)
3172 }
3173
3174 pub fn new_float128_value(value: f64) -> Self {
3175 Self {
3176 _d: TK_FLOAT128,
3177 float128_value: Some(value),
3178
3179 boolean_value: None,
3180
3181 byte_value: None,
3182
3183 int16_value: None,
3184
3185 uint_16_value: None,
3186
3187 int32_value: None,
3188
3189 uint32_value: None,
3190
3191 int64_value: None,
3192
3193 uint64_value: None,
3194
3195 float32_value: None,
3196
3197 float64_value: None,
3198
3199 char_value: None,
3200
3201 wchar_value: None,
3202
3203 enumerated_value: None,
3204
3205 string8_value: None,
3206
3207 string16_value: None,
3208
3209 extended_value: None,
3210 }
3211 }
3212
3213 pub fn is_float128_value(&self) -> bool {
3214 matches!(self._d, TK_FLOAT128)
3215 }
3216
3217 pub fn new_char_value(value: char) -> Self {
3218 Self {
3219 _d: TK_CHAR8,
3220 char_value: Some(value),
3221
3222 boolean_value: None,
3223
3224 byte_value: None,
3225
3226 int16_value: None,
3227
3228 uint_16_value: None,
3229
3230 int32_value: None,
3231
3232 uint32_value: None,
3233
3234 int64_value: None,
3235
3236 uint64_value: None,
3237
3238 float32_value: None,
3239
3240 float64_value: None,
3241
3242 float128_value: None,
3243
3244 wchar_value: None,
3245
3246 enumerated_value: None,
3247
3248 string8_value: None,
3249
3250 string16_value: None,
3251
3252 extended_value: None,
3253 }
3254 }
3255
3256 pub fn is_char_value(&self) -> bool {
3257 matches!(self._d, TK_CHAR8)
3258 }
3259
3260 pub fn new_wchar_value(value: char) -> Self {
3261 Self {
3262 _d: TK_CHAR16,
3263 wchar_value: Some(value),
3264
3265 boolean_value: None,
3266
3267 byte_value: None,
3268
3269 int16_value: None,
3270
3271 uint_16_value: None,
3272
3273 int32_value: None,
3274
3275 uint32_value: None,
3276
3277 int64_value: None,
3278
3279 uint64_value: None,
3280
3281 float32_value: None,
3282
3283 float64_value: None,
3284
3285 float128_value: None,
3286
3287 char_value: None,
3288
3289 enumerated_value: None,
3290
3291 string8_value: None,
3292
3293 string16_value: None,
3294
3295 extended_value: None,
3296 }
3297 }
3298
3299 pub fn is_wchar_value(&self) -> bool {
3300 matches!(self._d, TK_CHAR16)
3301 }
3302
3303 pub fn new_enumerated_value(value: i32) -> Self {
3304 Self {
3305 _d: TK_ENUM,
3306 enumerated_value: Some(value),
3307
3308 boolean_value: None,
3309
3310 byte_value: None,
3311
3312 int16_value: None,
3313
3314 uint_16_value: None,
3315
3316 int32_value: None,
3317
3318 uint32_value: None,
3319
3320 int64_value: None,
3321
3322 uint64_value: None,
3323
3324 float32_value: None,
3325
3326 float64_value: None,
3327
3328 float128_value: None,
3329
3330 char_value: None,
3331
3332 wchar_value: None,
3333
3334 string8_value: None,
3335
3336 string16_value: None,
3337
3338 extended_value: None,
3339 }
3340 }
3341
3342 pub fn is_enumerated_value(&self) -> bool {
3343 matches!(self._d, TK_ENUM)
3344 }
3345
3346 pub fn new_string8_value(value: String) -> Self {
3347 Self {
3348 _d: TK_STRING8,
3349 string8_value: Some(value),
3350
3351 boolean_value: None,
3352
3353 byte_value: None,
3354
3355 int16_value: None,
3356
3357 uint_16_value: None,
3358
3359 int32_value: None,
3360
3361 uint32_value: None,
3362
3363 int64_value: None,
3364
3365 uint64_value: None,
3366
3367 float32_value: None,
3368
3369 float64_value: None,
3370
3371 float128_value: None,
3372
3373 char_value: None,
3374
3375 wchar_value: None,
3376
3377 enumerated_value: None,
3378
3379 string16_value: None,
3380
3381 extended_value: None,
3382 }
3383 }
3384
3385 pub fn is_string8_value(&self) -> bool {
3386 matches!(self._d, TK_STRING8)
3387 }
3388
3389 pub fn new_string16_value(value: String) -> Self {
3390 Self {
3391 _d: TK_STRING16,
3392 string16_value: Some(value),
3393
3394 boolean_value: None,
3395
3396 byte_value: None,
3397
3398 int16_value: None,
3399
3400 uint_16_value: None,
3401
3402 int32_value: None,
3403
3404 uint32_value: None,
3405
3406 int64_value: None,
3407
3408 uint64_value: None,
3409
3410 float32_value: None,
3411
3412 float64_value: None,
3413
3414 float128_value: None,
3415
3416 char_value: None,
3417
3418 wchar_value: None,
3419
3420 enumerated_value: None,
3421
3422 string8_value: None,
3423
3424 extended_value: None,
3425 }
3426 }
3427
3428 pub fn is_string16_value(&self) -> bool {
3429 matches!(self._d, TK_STRING16)
3430 }
3431
3432 pub fn new_extended_value(value: Box<ExtendedAnnotationParameterValue>) -> Self {
3433 Self {
3434 _d: u8::default(),
3435 extended_value: Some(value),
3436
3437 boolean_value: None,
3438
3439 byte_value: None,
3440
3441 int16_value: None,
3442
3443 uint_16_value: None,
3444
3445 int32_value: None,
3446
3447 uint32_value: None,
3448
3449 int64_value: None,
3450
3451 uint64_value: None,
3452
3453 float32_value: None,
3454
3455 float64_value: None,
3456
3457 float128_value: None,
3458
3459 char_value: None,
3460
3461 wchar_value: None,
3462
3463 enumerated_value: None,
3464
3465 string8_value: None,
3466
3467 string16_value: None,
3468 }
3469 }
3470
3471 pub fn is_extended_value(&self) -> bool {
3472 matches!(self._d, _)
3473 }
3474
3475 pub fn tag(&self) -> &u8 {
3476 &self._d
3477 }
3478 }
3479
3480 impl xidl_xcdr::XcdrSerialize for AnnotationParameterValue {
3481 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
3482 Self::SERIALIZE_KIND
3483 }
3484
3485 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
3486 &self,
3487 serializer: &mut S,
3488 ) -> xidl_xcdr::error::XcdrResult<()> {
3489 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
3490 serializer.begin_field(xidl_xcdr::FieldId(0), false, 0)?;
3491 xidl_xcdr::XcdrSerialize::serialize_with(&self._d, serializer)?;
3492 serializer.end_field()?;
3493 match self._d {
3494 TK_BOOLEAN => {
3495 let value = self.boolean_value.as_ref().ok_or_else(|| {
3496 xidl_xcdr::error::XcdrError::Message(
3497 "union member is not set for discriminator".to_string(),
3498 )
3499 })?;
3500 serializer.begin_field(xidl_xcdr::FieldId(1u32), false, 0)?;
3501 xidl_xcdr::XcdrSerialize::serialize_with(value, serializer)?;
3502 serializer.end_field()?;
3503 }
3504
3505 TK_BYTE => {
3506 let value = self.byte_value.as_ref().ok_or_else(|| {
3507 xidl_xcdr::error::XcdrError::Message(
3508 "union member is not set for discriminator".to_string(),
3509 )
3510 })?;
3511 serializer.begin_field(xidl_xcdr::FieldId(2u32), false, 0)?;
3512 xidl_xcdr::XcdrSerialize::serialize_with(value, serializer)?;
3513 serializer.end_field()?;
3514 }
3515
3516 TK_INT16 => {
3517 let value = self.int16_value.as_ref().ok_or_else(|| {
3518 xidl_xcdr::error::XcdrError::Message(
3519 "union member is not set for discriminator".to_string(),
3520 )
3521 })?;
3522 serializer.begin_field(xidl_xcdr::FieldId(3u32), false, 0)?;
3523 xidl_xcdr::XcdrSerialize::serialize_with(value, serializer)?;
3524 serializer.end_field()?;
3525 }
3526
3527 TK_UINT16 => {
3528 let value = self.uint_16_value.as_ref().ok_or_else(|| {
3529 xidl_xcdr::error::XcdrError::Message(
3530 "union member is not set for discriminator".to_string(),
3531 )
3532 })?;
3533 serializer.begin_field(xidl_xcdr::FieldId(4u32), false, 0)?;
3534 xidl_xcdr::XcdrSerialize::serialize_with(value, serializer)?;
3535 serializer.end_field()?;
3536 }
3537
3538 TK_INT32 => {
3539 let value = self.int32_value.as_ref().ok_or_else(|| {
3540 xidl_xcdr::error::XcdrError::Message(
3541 "union member is not set for discriminator".to_string(),
3542 )
3543 })?;
3544 serializer.begin_field(xidl_xcdr::FieldId(5u32), false, 0)?;
3545 xidl_xcdr::XcdrSerialize::serialize_with(value, serializer)?;
3546 serializer.end_field()?;
3547 }
3548
3549 TK_UINT32 => {
3550 let value = self.uint32_value.as_ref().ok_or_else(|| {
3551 xidl_xcdr::error::XcdrError::Message(
3552 "union member is not set for discriminator".to_string(),
3553 )
3554 })?;
3555 serializer.begin_field(xidl_xcdr::FieldId(6u32), false, 0)?;
3556 xidl_xcdr::XcdrSerialize::serialize_with(value, serializer)?;
3557 serializer.end_field()?;
3558 }
3559
3560 TK_INT64 => {
3561 let value = self.int64_value.as_ref().ok_or_else(|| {
3562 xidl_xcdr::error::XcdrError::Message(
3563 "union member is not set for discriminator".to_string(),
3564 )
3565 })?;
3566 serializer.begin_field(xidl_xcdr::FieldId(7u32), false, 0)?;
3567 xidl_xcdr::XcdrSerialize::serialize_with(value, serializer)?;
3568 serializer.end_field()?;
3569 }
3570
3571 TK_UINT64 => {
3572 let value = self.uint64_value.as_ref().ok_or_else(|| {
3573 xidl_xcdr::error::XcdrError::Message(
3574 "union member is not set for discriminator".to_string(),
3575 )
3576 })?;
3577 serializer.begin_field(xidl_xcdr::FieldId(8u32), false, 0)?;
3578 xidl_xcdr::XcdrSerialize::serialize_with(value, serializer)?;
3579 serializer.end_field()?;
3580 }
3581
3582 TK_FLOAT32 => {
3583 let value = self.float32_value.as_ref().ok_or_else(|| {
3584 xidl_xcdr::error::XcdrError::Message(
3585 "union member is not set for discriminator".to_string(),
3586 )
3587 })?;
3588 serializer.begin_field(xidl_xcdr::FieldId(9u32), false, 0)?;
3589 xidl_xcdr::XcdrSerialize::serialize_with(value, serializer)?;
3590 serializer.end_field()?;
3591 }
3592
3593 TK_FLOAT64 => {
3594 let value = self.float64_value.as_ref().ok_or_else(|| {
3595 xidl_xcdr::error::XcdrError::Message(
3596 "union member is not set for discriminator".to_string(),
3597 )
3598 })?;
3599 serializer.begin_field(xidl_xcdr::FieldId(10u32), false, 0)?;
3600 xidl_xcdr::XcdrSerialize::serialize_with(value, serializer)?;
3601 serializer.end_field()?;
3602 }
3603
3604 TK_FLOAT128 => {
3605 let value = self.float128_value.as_ref().ok_or_else(|| {
3606 xidl_xcdr::error::XcdrError::Message(
3607 "union member is not set for discriminator".to_string(),
3608 )
3609 })?;
3610 serializer.begin_field(xidl_xcdr::FieldId(11u32), false, 0)?;
3611 xidl_xcdr::XcdrSerialize::serialize_with(value, serializer)?;
3612 serializer.end_field()?;
3613 }
3614
3615 TK_CHAR8 => {
3616 let value = self.char_value.as_ref().ok_or_else(|| {
3617 xidl_xcdr::error::XcdrError::Message(
3618 "union member is not set for discriminator".to_string(),
3619 )
3620 })?;
3621 serializer.begin_field(xidl_xcdr::FieldId(12u32), false, 0)?;
3622 xidl_xcdr::XcdrSerialize::serialize_with(value, serializer)?;
3623 serializer.end_field()?;
3624 }
3625
3626 TK_CHAR16 => {
3627 let value = self.wchar_value.as_ref().ok_or_else(|| {
3628 xidl_xcdr::error::XcdrError::Message(
3629 "union member is not set for discriminator".to_string(),
3630 )
3631 })?;
3632 serializer.begin_field(xidl_xcdr::FieldId(13u32), false, 0)?;
3633 xidl_xcdr::XcdrSerialize::serialize_with(value, serializer)?;
3634 serializer.end_field()?;
3635 }
3636
3637 TK_ENUM => {
3638 let value = self.enumerated_value.as_ref().ok_or_else(|| {
3639 xidl_xcdr::error::XcdrError::Message(
3640 "union member is not set for discriminator".to_string(),
3641 )
3642 })?;
3643 serializer.begin_field(xidl_xcdr::FieldId(14u32), false, 0)?;
3644 xidl_xcdr::XcdrSerialize::serialize_with(value, serializer)?;
3645 serializer.end_field()?;
3646 }
3647
3648 TK_STRING8 => {
3649 let value = self.string8_value.as_ref().ok_or_else(|| {
3650 xidl_xcdr::error::XcdrError::Message(
3651 "union member is not set for discriminator".to_string(),
3652 )
3653 })?;
3654 serializer.begin_field(xidl_xcdr::FieldId(15u32), false, 0)?;
3655 xidl_xcdr::XcdrSerialize::serialize_with(value, serializer)?;
3656 serializer.end_field()?;
3657 }
3658
3659 TK_STRING16 => {
3660 let value = self.string16_value.as_ref().ok_or_else(|| {
3661 xidl_xcdr::error::XcdrError::Message(
3662 "union member is not set for discriminator".to_string(),
3663 )
3664 })?;
3665 serializer.begin_field(xidl_xcdr::FieldId(16u32), false, 0)?;
3666 xidl_xcdr::XcdrSerialize::serialize_with(value, serializer)?;
3667 serializer.end_field()?;
3668 }
3669
3670 _ => {
3671 let value = self.extended_value.as_ref().ok_or_else(|| {
3672 xidl_xcdr::error::XcdrError::Message(
3673 "union member is not set for discriminator".to_string(),
3674 )
3675 })?;
3676 serializer.begin_field(xidl_xcdr::FieldId(17u32), false, 0)?;
3677 xidl_xcdr::XcdrSerialize::serialize_with(value, serializer)?;
3678 serializer.end_field()?;
3679 }
3680 }
3681 serializer.end_struct()?;
3682 Ok(())
3683 }
3684 }
3685
3686 impl xidl_xcdr::XcdrDeserialize for AnnotationParameterValue {
3687 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
3688 deserializer: &mut D,
3689 ) -> xidl_xcdr::error::XcdrResult<Self> {
3690 let _d = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
3691 let mut out = Self {
3692 _d,
3693
3694 boolean_value: None,
3695
3696 byte_value: None,
3697
3698 int16_value: None,
3699
3700 uint_16_value: None,
3701
3702 int32_value: None,
3703
3704 uint32_value: None,
3705
3706 int64_value: None,
3707
3708 uint64_value: None,
3709
3710 float32_value: None,
3711
3712 float64_value: None,
3713
3714 float128_value: None,
3715
3716 char_value: None,
3717
3718 wchar_value: None,
3719
3720 enumerated_value: None,
3721
3722 string8_value: None,
3723
3724 string16_value: None,
3725
3726 extended_value: None,
3727 };
3728 match out._d {
3729 TK_BOOLEAN => {
3730 out.boolean_value =
3731 Some(xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?);
3732 }
3733
3734 TK_BYTE => {
3735 out.byte_value =
3736 Some(xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?);
3737 }
3738
3739 TK_INT16 => {
3740 out.int16_value =
3741 Some(xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?);
3742 }
3743
3744 TK_UINT16 => {
3745 out.uint_16_value =
3746 Some(xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?);
3747 }
3748
3749 TK_INT32 => {
3750 out.int32_value =
3751 Some(xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?);
3752 }
3753
3754 TK_UINT32 => {
3755 out.uint32_value =
3756 Some(xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?);
3757 }
3758
3759 TK_INT64 => {
3760 out.int64_value =
3761 Some(xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?);
3762 }
3763
3764 TK_UINT64 => {
3765 out.uint64_value =
3766 Some(xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?);
3767 }
3768
3769 TK_FLOAT32 => {
3770 out.float32_value =
3771 Some(xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?);
3772 }
3773
3774 TK_FLOAT64 => {
3775 out.float64_value =
3776 Some(xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?);
3777 }
3778
3779 TK_FLOAT128 => {
3780 out.float128_value =
3781 Some(xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?);
3782 }
3783
3784 TK_CHAR8 => {
3785 out.char_value =
3786 Some(xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?);
3787 }
3788
3789 TK_CHAR16 => {
3790 out.wchar_value =
3791 Some(xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?);
3792 }
3793
3794 TK_ENUM => {
3795 out.enumerated_value =
3796 Some(xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?);
3797 }
3798
3799 TK_STRING8 => {
3800 out.string8_value =
3801 Some(xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?);
3802 }
3803
3804 TK_STRING16 => {
3805 out.string16_value =
3806 Some(xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?);
3807 }
3808
3809 _ => {
3810 out.extended_value =
3811 Some(xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?);
3812 }
3813 }
3814 Ok(out)
3815 }
3816 }
3817
3818 impl xidl_typeobject::XidlTypeObject for AnnotationParameterValue {
3819 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
3820 xidl_typeobject::runtime::build_minimal_union(
3821 0u32,
3822 xidl_typeobject::runtime::type_identifier_primitive(
3823 xidl_typeobject::DDS::XTypes::TK_BYTE,
3824 ),
3825 vec![
3826 xidl_typeobject::runtime::UnionMemberDesc {
3827 member_id: 12u32,
3828 member_flags: 0u32,
3829 type_id: xidl_typeobject::runtime::type_identifier_primitive(
3830 xidl_typeobject::DDS::XTypes::TK_CHAR8,
3831 ),
3832 name: "char_value",
3833 labels: vec![0i32],
3834 },
3835 xidl_typeobject::runtime::UnionMemberDesc {
3836 member_id: 6u32,
3837 member_flags: 0u32,
3838 type_id: xidl_typeobject::runtime::type_identifier_primitive(
3839 xidl_typeobject::DDS::XTypes::TK_UINT32,
3840 ),
3841 name: "uint32_value",
3842 labels: vec![0i32],
3843 },
3844 xidl_typeobject::runtime::UnionMemberDesc {
3845 member_id: 2u32,
3846 member_flags: 0u32,
3847 type_id: xidl_typeobject::runtime::type_identifier_primitive(
3848 xidl_typeobject::DDS::XTypes::TK_BYTE,
3849 ),
3850 name: "byte_value",
3851 labels: vec![0i32],
3852 },
3853 xidl_typeobject::runtime::UnionMemberDesc {
3854 member_id: 7u32,
3855 member_flags: 0u32,
3856 type_id: xidl_typeobject::runtime::type_identifier_primitive(
3857 xidl_typeobject::DDS::XTypes::TK_INT64,
3858 ),
3859 name: "int64_value",
3860 labels: vec![0i32],
3861 },
3862 xidl_typeobject::runtime::UnionMemberDesc {
3863 member_id: 8u32,
3864 member_flags: 0u32,
3865 type_id: xidl_typeobject::runtime::type_identifier_primitive(
3866 xidl_typeobject::DDS::XTypes::TK_UINT64,
3867 ),
3868 name: "uint64_value",
3869 labels: vec![0i32],
3870 },
3871 xidl_typeobject::runtime::UnionMemberDesc {
3872 member_id: 4u32,
3873 member_flags: 0u32,
3874 type_id: xidl_typeobject::runtime::type_identifier_primitive(
3875 xidl_typeobject::DDS::XTypes::TK_UINT16,
3876 ),
3877 name: "uint_16_value",
3878 labels: vec![0i32],
3879 },
3880 xidl_typeobject::runtime::UnionMemberDesc {
3881 member_id: 1u32,
3882 member_flags: 0u32,
3883 type_id: xidl_typeobject::runtime::type_identifier_primitive(
3884 xidl_typeobject::DDS::XTypes::TK_BOOLEAN,
3885 ),
3886 name: "boolean_value",
3887 labels: vec![0i32],
3888 },
3889 xidl_typeobject::runtime::UnionMemberDesc {
3890 member_id: 5u32,
3891 member_flags: 0u32,
3892 type_id: xidl_typeobject::runtime::type_identifier_primitive(
3893 xidl_typeobject::DDS::XTypes::TK_INT32,
3894 ),
3895 name: "int32_value",
3896 labels: vec![0i32],
3897 },
3898 xidl_typeobject::runtime::UnionMemberDesc {
3899 member_id: 13u32,
3900 member_flags: 0u32,
3901 type_id: xidl_typeobject::runtime::type_identifier_primitive(
3902 xidl_typeobject::DDS::XTypes::TK_CHAR16,
3903 ),
3904 name: "wchar_value",
3905 labels: vec![0i32],
3906 },
3907 xidl_typeobject::runtime::UnionMemberDesc {
3908 member_id: 17u32,
3909 member_flags: 64u32,
3910 type_id: xidl_typeobject::runtime::type_identifier_for::<
3911 ExtendedAnnotationParameterValue,
3912 >(
3913 xidl_typeobject::runtime::TypeEquivalence::Minimal
3914 ),
3915 name: "extended_value",
3916 labels: vec![],
3917 },
3918 xidl_typeobject::runtime::UnionMemberDesc {
3919 member_id: 16u32,
3920 member_flags: 0u32,
3921 type_id: xidl_typeobject::runtime::type_identifier_string(None, true),
3922 name: "string16_value",
3923 labels: vec![0i32],
3924 },
3925 xidl_typeobject::runtime::UnionMemberDesc {
3926 member_id: 11u32,
3927 member_flags: 0u32,
3928 type_id: xidl_typeobject::runtime::type_identifier_primitive(
3929 xidl_typeobject::DDS::XTypes::TK_FLOAT64,
3930 ),
3931 name: "float128_value",
3932 labels: vec![0i32],
3933 },
3934 xidl_typeobject::runtime::UnionMemberDesc {
3935 member_id: 9u32,
3936 member_flags: 0u32,
3937 type_id: xidl_typeobject::runtime::type_identifier_primitive(
3938 xidl_typeobject::DDS::XTypes::TK_FLOAT64,
3939 ),
3940 name: "float32_value",
3941 labels: vec![0i32],
3942 },
3943 xidl_typeobject::runtime::UnionMemberDesc {
3944 member_id: 14u32,
3945 member_flags: 0u32,
3946 type_id: xidl_typeobject::runtime::type_identifier_primitive(
3947 xidl_typeobject::DDS::XTypes::TK_INT32,
3948 ),
3949 name: "enumerated_value",
3950 labels: vec![0i32],
3951 },
3952 xidl_typeobject::runtime::UnionMemberDesc {
3953 member_id: 10u32,
3954 member_flags: 0u32,
3955 type_id: xidl_typeobject::runtime::type_identifier_primitive(
3956 xidl_typeobject::DDS::XTypes::TK_FLOAT64,
3957 ),
3958 name: "float64_value",
3959 labels: vec![0i32],
3960 },
3961 xidl_typeobject::runtime::UnionMemberDesc {
3962 member_id: 15u32,
3963 member_flags: 0u32,
3964 type_id: xidl_typeobject::runtime::type_identifier_string(None, false),
3965 name: "string8_value",
3966 labels: vec![0i32],
3967 },
3968 xidl_typeobject::runtime::UnionMemberDesc {
3969 member_id: 3u32,
3970 member_flags: 0u32,
3971 type_id: xidl_typeobject::runtime::type_identifier_primitive(
3972 xidl_typeobject::DDS::XTypes::TK_INT16,
3973 ),
3974 name: "int16_value",
3975 labels: vec![0i32],
3976 },
3977 ],
3978 )
3979 }
3980
3981 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
3982 xidl_typeobject::runtime::build_complete_union(
3983 "DDS::XTypes::AnnotationParameterValue",
3984 0u32,
3985 xidl_typeobject::runtime::type_identifier_primitive(
3986 xidl_typeobject::DDS::XTypes::TK_BYTE,
3987 ),
3988 vec![
3989 xidl_typeobject::runtime::UnionMemberDesc {
3990 member_id: 12u32,
3991 member_flags: 0u32,
3992 type_id: xidl_typeobject::runtime::type_identifier_primitive(
3993 xidl_typeobject::DDS::XTypes::TK_CHAR8,
3994 ),
3995 name: "char_value",
3996 labels: vec![0i32],
3997 },
3998 xidl_typeobject::runtime::UnionMemberDesc {
3999 member_id: 6u32,
4000 member_flags: 0u32,
4001 type_id: xidl_typeobject::runtime::type_identifier_primitive(
4002 xidl_typeobject::DDS::XTypes::TK_UINT32,
4003 ),
4004 name: "uint32_value",
4005 labels: vec![0i32],
4006 },
4007 xidl_typeobject::runtime::UnionMemberDesc {
4008 member_id: 2u32,
4009 member_flags: 0u32,
4010 type_id: xidl_typeobject::runtime::type_identifier_primitive(
4011 xidl_typeobject::DDS::XTypes::TK_BYTE,
4012 ),
4013 name: "byte_value",
4014 labels: vec![0i32],
4015 },
4016 xidl_typeobject::runtime::UnionMemberDesc {
4017 member_id: 7u32,
4018 member_flags: 0u32,
4019 type_id: xidl_typeobject::runtime::type_identifier_primitive(
4020 xidl_typeobject::DDS::XTypes::TK_INT64,
4021 ),
4022 name: "int64_value",
4023 labels: vec![0i32],
4024 },
4025 xidl_typeobject::runtime::UnionMemberDesc {
4026 member_id: 8u32,
4027 member_flags: 0u32,
4028 type_id: xidl_typeobject::runtime::type_identifier_primitive(
4029 xidl_typeobject::DDS::XTypes::TK_UINT64,
4030 ),
4031 name: "uint64_value",
4032 labels: vec![0i32],
4033 },
4034 xidl_typeobject::runtime::UnionMemberDesc {
4035 member_id: 4u32,
4036 member_flags: 0u32,
4037 type_id: xidl_typeobject::runtime::type_identifier_primitive(
4038 xidl_typeobject::DDS::XTypes::TK_UINT16,
4039 ),
4040 name: "uint_16_value",
4041 labels: vec![0i32],
4042 },
4043 xidl_typeobject::runtime::UnionMemberDesc {
4044 member_id: 1u32,
4045 member_flags: 0u32,
4046 type_id: xidl_typeobject::runtime::type_identifier_primitive(
4047 xidl_typeobject::DDS::XTypes::TK_BOOLEAN,
4048 ),
4049 name: "boolean_value",
4050 labels: vec![0i32],
4051 },
4052 xidl_typeobject::runtime::UnionMemberDesc {
4053 member_id: 5u32,
4054 member_flags: 0u32,
4055 type_id: xidl_typeobject::runtime::type_identifier_primitive(
4056 xidl_typeobject::DDS::XTypes::TK_INT32,
4057 ),
4058 name: "int32_value",
4059 labels: vec![0i32],
4060 },
4061 xidl_typeobject::runtime::UnionMemberDesc {
4062 member_id: 13u32,
4063 member_flags: 0u32,
4064 type_id: xidl_typeobject::runtime::type_identifier_primitive(
4065 xidl_typeobject::DDS::XTypes::TK_CHAR16,
4066 ),
4067 name: "wchar_value",
4068 labels: vec![0i32],
4069 },
4070 xidl_typeobject::runtime::UnionMemberDesc {
4071 member_id: 17u32,
4072 member_flags: 64u32,
4073 type_id: xidl_typeobject::runtime::type_identifier_for::<
4074 ExtendedAnnotationParameterValue,
4075 >(
4076 xidl_typeobject::runtime::TypeEquivalence::Complete
4077 ),
4078 name: "extended_value",
4079 labels: vec![],
4080 },
4081 xidl_typeobject::runtime::UnionMemberDesc {
4082 member_id: 16u32,
4083 member_flags: 0u32,
4084 type_id: xidl_typeobject::runtime::type_identifier_string(None, true),
4085 name: "string16_value",
4086 labels: vec![0i32],
4087 },
4088 xidl_typeobject::runtime::UnionMemberDesc {
4089 member_id: 11u32,
4090 member_flags: 0u32,
4091 type_id: xidl_typeobject::runtime::type_identifier_primitive(
4092 xidl_typeobject::DDS::XTypes::TK_FLOAT64,
4093 ),
4094 name: "float128_value",
4095 labels: vec![0i32],
4096 },
4097 xidl_typeobject::runtime::UnionMemberDesc {
4098 member_id: 9u32,
4099 member_flags: 0u32,
4100 type_id: xidl_typeobject::runtime::type_identifier_primitive(
4101 xidl_typeobject::DDS::XTypes::TK_FLOAT64,
4102 ),
4103 name: "float32_value",
4104 labels: vec![0i32],
4105 },
4106 xidl_typeobject::runtime::UnionMemberDesc {
4107 member_id: 14u32,
4108 member_flags: 0u32,
4109 type_id: xidl_typeobject::runtime::type_identifier_primitive(
4110 xidl_typeobject::DDS::XTypes::TK_INT32,
4111 ),
4112 name: "enumerated_value",
4113 labels: vec![0i32],
4114 },
4115 xidl_typeobject::runtime::UnionMemberDesc {
4116 member_id: 10u32,
4117 member_flags: 0u32,
4118 type_id: xidl_typeobject::runtime::type_identifier_primitive(
4119 xidl_typeobject::DDS::XTypes::TK_FLOAT64,
4120 ),
4121 name: "float64_value",
4122 labels: vec![0i32],
4123 },
4124 xidl_typeobject::runtime::UnionMemberDesc {
4125 member_id: 15u32,
4126 member_flags: 0u32,
4127 type_id: xidl_typeobject::runtime::type_identifier_string(None, false),
4128 name: "string8_value",
4129 labels: vec![0i32],
4130 },
4131 xidl_typeobject::runtime::UnionMemberDesc {
4132 member_id: 3u32,
4133 member_flags: 0u32,
4134 type_id: xidl_typeobject::runtime::type_identifier_primitive(
4135 xidl_typeobject::DDS::XTypes::TK_INT16,
4136 ),
4137 name: "int16_value",
4138 labels: vec![0i32],
4139 },
4140 ],
4141 )
4142 }
4143 }
4144 pub struct AppliedAnnotationParameter {
4145 pub paramname_hash: Box<NameHash>,
4146
4147 pub value: Box<AnnotationParameterValue>,
4148 }
4149
4150 impl AppliedAnnotationParameter {
4151 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
4152 }
4153
4154 impl xidl_xcdr::XcdrSerialize for AppliedAnnotationParameter {
4155 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
4156 Self::SERIALIZE_KIND
4157 }
4158
4159 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
4160 &self,
4161 serializer: &mut S,
4162 ) -> xidl_xcdr::error::XcdrResult<()> {
4163 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
4164
4165 serializer.begin_field(xidl_xcdr::FieldId(1u32), false, 0)?;
4166
4167 xidl_xcdr::XcdrSerialize::serialize_with(&self.paramname_hash, serializer)?;
4168 serializer.end_field()?;
4169
4170 serializer.begin_field(xidl_xcdr::FieldId(2u32), false, 0)?;
4171
4172 xidl_xcdr::XcdrSerialize::serialize_with(&self.value, serializer)?;
4173 serializer.end_field()?;
4174
4175 serializer.end_struct()?;
4176 Ok(())
4177 }
4178 }
4179
4180 impl xidl_xcdr::XcdrDeserialize for AppliedAnnotationParameter {
4181 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
4182 deserializer: &mut D,
4183 ) -> xidl_xcdr::error::XcdrResult<Self> {
4184 let paramname_hash = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
4185
4186 let value = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
4187
4188 Ok(Self {
4189 paramname_hash,
4190
4191 value,
4192 })
4193 }
4194 }
4195
4196 impl xidl_typeobject::XidlTypeObject for AppliedAnnotationParameter {
4197 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
4198 xidl_typeobject::runtime::build_minimal_struct(
4199 0u32,
4200 xidl_typeobject::runtime::type_identifier_none(),
4201 vec![
4202 xidl_typeobject::runtime::StructMemberDesc {
4203 member_id: 1u32,
4204 member_flags: 0u32,
4205 type_id: xidl_typeobject::runtime::type_identifier_for::<NameHash>(
4206 xidl_typeobject::runtime::TypeEquivalence::Minimal,
4207 ),
4208 name: "paramname_hash",
4209 },
4210 xidl_typeobject::runtime::StructMemberDesc {
4211 member_id: 2u32,
4212 member_flags: 0u32,
4213 type_id: xidl_typeobject::runtime::type_identifier_for::<
4214 AnnotationParameterValue,
4215 >(
4216 xidl_typeobject::runtime::TypeEquivalence::Minimal
4217 ),
4218 name: "value",
4219 },
4220 ],
4221 )
4222 }
4223
4224 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
4225 xidl_typeobject::runtime::build_complete_struct(
4226 "DDS::XTypes::AppliedAnnotationParameter",
4227 0u32,
4228 xidl_typeobject::runtime::type_identifier_none(),
4229 vec![
4230 xidl_typeobject::runtime::StructMemberDesc {
4231 member_id: 1u32,
4232 member_flags: 0u32,
4233 type_id: xidl_typeobject::runtime::type_identifier_for::<NameHash>(
4234 xidl_typeobject::runtime::TypeEquivalence::Complete,
4235 ),
4236 name: "paramname_hash",
4237 },
4238 xidl_typeobject::runtime::StructMemberDesc {
4239 member_id: 2u32,
4240 member_flags: 0u32,
4241 type_id: xidl_typeobject::runtime::type_identifier_for::<
4242 AnnotationParameterValue,
4243 >(
4244 xidl_typeobject::runtime::TypeEquivalence::Complete
4245 ),
4246 name: "value",
4247 },
4248 ],
4249 )
4250 }
4251 }
4252 pub type AppliedAnnotationParameterSeq = Vec<AppliedAnnotationParameter>;
4253 pub struct AppliedAnnotation {
4254 pub annotation_typeid: Box<TypeIdentifier>,
4255
4256 pub param_seq: Box<AppliedAnnotationParameterSeq>,
4257 }
4258
4259 impl AppliedAnnotation {
4260 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
4261 }
4262
4263 impl xidl_xcdr::XcdrSerialize for AppliedAnnotation {
4264 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
4265 Self::SERIALIZE_KIND
4266 }
4267
4268 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
4269 &self,
4270 serializer: &mut S,
4271 ) -> xidl_xcdr::error::XcdrResult<()> {
4272 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
4273
4274 serializer.begin_field(xidl_xcdr::FieldId(1u32), false, 0)?;
4275
4276 xidl_xcdr::XcdrSerialize::serialize_with(&self.annotation_typeid, serializer)?;
4277 serializer.end_field()?;
4278
4279 serializer.begin_field(xidl_xcdr::FieldId(2u32), false, 0)?;
4280
4281 xidl_xcdr::XcdrSerialize::serialize_with(&self.param_seq, serializer)?;
4282 serializer.end_field()?;
4283
4284 serializer.end_struct()?;
4285 Ok(())
4286 }
4287 }
4288
4289 impl xidl_xcdr::XcdrDeserialize for AppliedAnnotation {
4290 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
4291 deserializer: &mut D,
4292 ) -> xidl_xcdr::error::XcdrResult<Self> {
4293 let annotation_typeid = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
4294
4295 let param_seq = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
4296
4297 Ok(Self {
4298 annotation_typeid,
4299
4300 param_seq,
4301 })
4302 }
4303 }
4304
4305 impl xidl_typeobject::XidlTypeObject for AppliedAnnotation {
4306 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
4307 xidl_typeobject::runtime::build_minimal_struct(
4308 0u32,
4309 xidl_typeobject::runtime::type_identifier_none(),
4310 vec![
4311 xidl_typeobject::runtime::StructMemberDesc {
4312 member_id: 1u32,
4313 member_flags: 0u32,
4314 type_id: xidl_typeobject::runtime::type_identifier_for::<TypeIdentifier>(
4315 xidl_typeobject::runtime::TypeEquivalence::Minimal,
4316 ),
4317 name: "annotation_typeid",
4318 },
4319 xidl_typeobject::runtime::StructMemberDesc {
4320 member_id: 2u32,
4321 member_flags: 0u32,
4322 type_id: xidl_typeobject::runtime::type_identifier_for::<
4323 AppliedAnnotationParameterSeq,
4324 >(
4325 xidl_typeobject::runtime::TypeEquivalence::Minimal
4326 ),
4327 name: "param_seq",
4328 },
4329 ],
4330 )
4331 }
4332
4333 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
4334 xidl_typeobject::runtime::build_complete_struct(
4335 "DDS::XTypes::AppliedAnnotation",
4336 0u32,
4337 xidl_typeobject::runtime::type_identifier_none(),
4338 vec![
4339 xidl_typeobject::runtime::StructMemberDesc {
4340 member_id: 1u32,
4341 member_flags: 0u32,
4342 type_id: xidl_typeobject::runtime::type_identifier_for::<TypeIdentifier>(
4343 xidl_typeobject::runtime::TypeEquivalence::Complete,
4344 ),
4345 name: "annotation_typeid",
4346 },
4347 xidl_typeobject::runtime::StructMemberDesc {
4348 member_id: 2u32,
4349 member_flags: 0u32,
4350 type_id: xidl_typeobject::runtime::type_identifier_for::<
4351 AppliedAnnotationParameterSeq,
4352 >(
4353 xidl_typeobject::runtime::TypeEquivalence::Complete
4354 ),
4355 name: "param_seq",
4356 },
4357 ],
4358 )
4359 }
4360 }
4361 pub type AppliedAnnotationSeq = Vec<AppliedAnnotation>;
4362 pub struct AppliedVerbatimAnnotation {
4363 pub placement: String,
4364
4365 pub language: String,
4366
4367 pub text: String,
4368 }
4369
4370 impl AppliedVerbatimAnnotation {
4371 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
4372 }
4373
4374 impl xidl_xcdr::XcdrSerialize for AppliedVerbatimAnnotation {
4375 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
4376 Self::SERIALIZE_KIND
4377 }
4378
4379 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
4380 &self,
4381 serializer: &mut S,
4382 ) -> xidl_xcdr::error::XcdrResult<()> {
4383 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
4384
4385 serializer.begin_field(xidl_xcdr::FieldId(1u32), false, 0)?;
4386
4387 xidl_xcdr::XcdrSerialize::serialize_with(&self.placement, serializer)?;
4388 serializer.end_field()?;
4389
4390 serializer.begin_field(xidl_xcdr::FieldId(2u32), false, 0)?;
4391
4392 xidl_xcdr::XcdrSerialize::serialize_with(&self.language, serializer)?;
4393 serializer.end_field()?;
4394
4395 serializer.begin_field(xidl_xcdr::FieldId(3u32), false, 0)?;
4396
4397 xidl_xcdr::XcdrSerialize::serialize_with(&self.text, serializer)?;
4398 serializer.end_field()?;
4399
4400 serializer.end_struct()?;
4401 Ok(())
4402 }
4403 }
4404
4405 impl xidl_xcdr::XcdrDeserialize for AppliedVerbatimAnnotation {
4406 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
4407 deserializer: &mut D,
4408 ) -> xidl_xcdr::error::XcdrResult<Self> {
4409 let placement = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
4410
4411 let language = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
4412
4413 let text = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
4414
4415 Ok(Self {
4416 placement,
4417
4418 language,
4419
4420 text,
4421 })
4422 }
4423 }
4424
4425 impl xidl_typeobject::XidlTypeObject for AppliedVerbatimAnnotation {
4426 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
4427 xidl_typeobject::runtime::build_minimal_struct(
4428 0u32,
4429 xidl_typeobject::runtime::type_identifier_none(),
4430 vec![
4431 xidl_typeobject::runtime::StructMemberDesc {
4432 member_id: 1u32,
4433 member_flags: 0u32,
4434 type_id: xidl_typeobject::runtime::type_identifier_string(
4435 Some(32u32),
4436 false,
4437 ),
4438 name: "placement",
4439 },
4440 xidl_typeobject::runtime::StructMemberDesc {
4441 member_id: 2u32,
4442 member_flags: 0u32,
4443 type_id: xidl_typeobject::runtime::type_identifier_string(
4444 Some(32u32),
4445 false,
4446 ),
4447 name: "language",
4448 },
4449 xidl_typeobject::runtime::StructMemberDesc {
4450 member_id: 3u32,
4451 member_flags: 0u32,
4452 type_id: xidl_typeobject::runtime::type_identifier_string(None, false),
4453 name: "text",
4454 },
4455 ],
4456 )
4457 }
4458
4459 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
4460 xidl_typeobject::runtime::build_complete_struct(
4461 "DDS::XTypes::AppliedVerbatimAnnotation",
4462 0u32,
4463 xidl_typeobject::runtime::type_identifier_none(),
4464 vec![
4465 xidl_typeobject::runtime::StructMemberDesc {
4466 member_id: 1u32,
4467 member_flags: 0u32,
4468 type_id: xidl_typeobject::runtime::type_identifier_string(
4469 Some(32u32),
4470 false,
4471 ),
4472 name: "placement",
4473 },
4474 xidl_typeobject::runtime::StructMemberDesc {
4475 member_id: 2u32,
4476 member_flags: 0u32,
4477 type_id: xidl_typeobject::runtime::type_identifier_string(
4478 Some(32u32),
4479 false,
4480 ),
4481 name: "language",
4482 },
4483 xidl_typeobject::runtime::StructMemberDesc {
4484 member_id: 3u32,
4485 member_flags: 0u32,
4486 type_id: xidl_typeobject::runtime::type_identifier_string(None, false),
4487 name: "text",
4488 },
4489 ],
4490 )
4491 }
4492 }
4493 pub struct AppliedBuiltinMemberAnnotations {
4494 pub unit: String,
4495
4496 pub min: Box<AnnotationParameterValue>,
4497
4498 pub max: Box<AnnotationParameterValue>,
4499
4500 pub hash_id: String,
4501 }
4502
4503 impl AppliedBuiltinMemberAnnotations {
4504 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
4505 }
4506
4507 impl xidl_xcdr::XcdrSerialize for AppliedBuiltinMemberAnnotations {
4508 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
4509 Self::SERIALIZE_KIND
4510 }
4511
4512 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
4513 &self,
4514 serializer: &mut S,
4515 ) -> xidl_xcdr::error::XcdrResult<()> {
4516 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
4517
4518 serializer.begin_field(xidl_xcdr::FieldId(1u32), false, 0)?;
4519
4520 xidl_xcdr::XcdrSerialize::serialize_with(&self.unit, serializer)?;
4521 serializer.end_field()?;
4522
4523 serializer.begin_field(xidl_xcdr::FieldId(2u32), false, 0)?;
4524
4525 xidl_xcdr::XcdrSerialize::serialize_with(&self.min, serializer)?;
4526 serializer.end_field()?;
4527
4528 serializer.begin_field(xidl_xcdr::FieldId(3u32), false, 0)?;
4529
4530 xidl_xcdr::XcdrSerialize::serialize_with(&self.max, serializer)?;
4531 serializer.end_field()?;
4532
4533 serializer.begin_field(xidl_xcdr::FieldId(4u32), false, 0)?;
4534
4535 xidl_xcdr::XcdrSerialize::serialize_with(&self.hash_id, serializer)?;
4536 serializer.end_field()?;
4537
4538 serializer.end_struct()?;
4539 Ok(())
4540 }
4541 }
4542
4543 impl xidl_xcdr::XcdrDeserialize for AppliedBuiltinMemberAnnotations {
4544 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
4545 deserializer: &mut D,
4546 ) -> xidl_xcdr::error::XcdrResult<Self> {
4547 let unit = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
4548
4549 let min = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
4550
4551 let max = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
4552
4553 let hash_id = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
4554
4555 Ok(Self {
4556 unit,
4557
4558 min,
4559
4560 max,
4561
4562 hash_id,
4563 })
4564 }
4565 }
4566
4567 impl xidl_typeobject::XidlTypeObject for AppliedBuiltinMemberAnnotations {
4568 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
4569 xidl_typeobject::runtime::build_minimal_struct(
4570 0u32,
4571 xidl_typeobject::runtime::type_identifier_none(),
4572 vec![
4573 xidl_typeobject::runtime::StructMemberDesc {
4574 member_id: 1u32,
4575 member_flags: 0u32,
4576 type_id: xidl_typeobject::runtime::type_identifier_string(None, false),
4577 name: "unit",
4578 },
4579 xidl_typeobject::runtime::StructMemberDesc {
4580 member_id: 2u32,
4581 member_flags: 0u32,
4582 type_id: xidl_typeobject::runtime::type_identifier_for::<
4583 AnnotationParameterValue,
4584 >(
4585 xidl_typeobject::runtime::TypeEquivalence::Minimal
4586 ),
4587 name: "min",
4588 },
4589 xidl_typeobject::runtime::StructMemberDesc {
4590 member_id: 3u32,
4591 member_flags: 0u32,
4592 type_id: xidl_typeobject::runtime::type_identifier_for::<
4593 AnnotationParameterValue,
4594 >(
4595 xidl_typeobject::runtime::TypeEquivalence::Minimal
4596 ),
4597 name: "max",
4598 },
4599 xidl_typeobject::runtime::StructMemberDesc {
4600 member_id: 4u32,
4601 member_flags: 0u32,
4602 type_id: xidl_typeobject::runtime::type_identifier_string(None, false),
4603 name: "hash_id",
4604 },
4605 ],
4606 )
4607 }
4608
4609 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
4610 xidl_typeobject::runtime::build_complete_struct(
4611 "DDS::XTypes::AppliedBuiltinMemberAnnotations",
4612 0u32,
4613 xidl_typeobject::runtime::type_identifier_none(),
4614 vec![
4615 xidl_typeobject::runtime::StructMemberDesc {
4616 member_id: 1u32,
4617 member_flags: 0u32,
4618 type_id: xidl_typeobject::runtime::type_identifier_string(None, false),
4619 name: "unit",
4620 },
4621 xidl_typeobject::runtime::StructMemberDesc {
4622 member_id: 2u32,
4623 member_flags: 0u32,
4624 type_id: xidl_typeobject::runtime::type_identifier_for::<
4625 AnnotationParameterValue,
4626 >(
4627 xidl_typeobject::runtime::TypeEquivalence::Complete
4628 ),
4629 name: "min",
4630 },
4631 xidl_typeobject::runtime::StructMemberDesc {
4632 member_id: 3u32,
4633 member_flags: 0u32,
4634 type_id: xidl_typeobject::runtime::type_identifier_for::<
4635 AnnotationParameterValue,
4636 >(
4637 xidl_typeobject::runtime::TypeEquivalence::Complete
4638 ),
4639 name: "max",
4640 },
4641 xidl_typeobject::runtime::StructMemberDesc {
4642 member_id: 4u32,
4643 member_flags: 0u32,
4644 type_id: xidl_typeobject::runtime::type_identifier_string(None, false),
4645 name: "hash_id",
4646 },
4647 ],
4648 )
4649 }
4650 }
4651 pub struct CommonStructMember {
4652 pub member_id: Box<MemberId>,
4653
4654 pub member_flags: Box<StructMemberFlag>,
4655
4656 pub member_type_id: Box<TypeIdentifier>,
4657 }
4658
4659 impl CommonStructMember {
4660 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
4661 }
4662
4663 impl xidl_xcdr::XcdrSerialize for CommonStructMember {
4664 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
4665 Self::SERIALIZE_KIND
4666 }
4667
4668 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
4669 &self,
4670 serializer: &mut S,
4671 ) -> xidl_xcdr::error::XcdrResult<()> {
4672 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
4673
4674 serializer.begin_field(xidl_xcdr::FieldId(1u32), false, 0)?;
4675
4676 xidl_xcdr::XcdrSerialize::serialize_with(&self.member_id, serializer)?;
4677 serializer.end_field()?;
4678
4679 serializer.begin_field(xidl_xcdr::FieldId(2u32), false, 0)?;
4680
4681 xidl_xcdr::XcdrSerialize::serialize_with(&self.member_flags, serializer)?;
4682 serializer.end_field()?;
4683
4684 serializer.begin_field(xidl_xcdr::FieldId(3u32), false, 0)?;
4685
4686 xidl_xcdr::XcdrSerialize::serialize_with(&self.member_type_id, serializer)?;
4687 serializer.end_field()?;
4688
4689 serializer.end_struct()?;
4690 Ok(())
4691 }
4692 }
4693
4694 impl xidl_xcdr::XcdrDeserialize for CommonStructMember {
4695 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
4696 deserializer: &mut D,
4697 ) -> xidl_xcdr::error::XcdrResult<Self> {
4698 let member_id = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
4699
4700 let member_flags = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
4701
4702 let member_type_id = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
4703
4704 Ok(Self {
4705 member_id,
4706
4707 member_flags,
4708
4709 member_type_id,
4710 })
4711 }
4712 }
4713
4714 impl xidl_typeobject::XidlTypeObject for CommonStructMember {
4715 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
4716 xidl_typeobject::runtime::build_minimal_struct(
4717 0u32,
4718 xidl_typeobject::runtime::type_identifier_none(),
4719 vec![
4720 xidl_typeobject::runtime::StructMemberDesc {
4721 member_id: 1u32,
4722 member_flags: 0u32,
4723 type_id: xidl_typeobject::runtime::type_identifier_for::<MemberId>(
4724 xidl_typeobject::runtime::TypeEquivalence::Minimal,
4725 ),
4726 name: "member_id",
4727 },
4728 xidl_typeobject::runtime::StructMemberDesc {
4729 member_id: 2u32,
4730 member_flags: 0u32,
4731 type_id: xidl_typeobject::runtime::type_identifier_for::<
4732 StructMemberFlag,
4733 >(
4734 xidl_typeobject::runtime::TypeEquivalence::Minimal
4735 ),
4736 name: "member_flags",
4737 },
4738 xidl_typeobject::runtime::StructMemberDesc {
4739 member_id: 3u32,
4740 member_flags: 0u32,
4741 type_id: xidl_typeobject::runtime::type_identifier_for::<TypeIdentifier>(
4742 xidl_typeobject::runtime::TypeEquivalence::Minimal,
4743 ),
4744 name: "member_type_id",
4745 },
4746 ],
4747 )
4748 }
4749
4750 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
4751 xidl_typeobject::runtime::build_complete_struct(
4752 "DDS::XTypes::CommonStructMember",
4753 0u32,
4754 xidl_typeobject::runtime::type_identifier_none(),
4755 vec![
4756 xidl_typeobject::runtime::StructMemberDesc {
4757 member_id: 1u32,
4758 member_flags: 0u32,
4759 type_id: xidl_typeobject::runtime::type_identifier_for::<MemberId>(
4760 xidl_typeobject::runtime::TypeEquivalence::Complete,
4761 ),
4762 name: "member_id",
4763 },
4764 xidl_typeobject::runtime::StructMemberDesc {
4765 member_id: 2u32,
4766 member_flags: 0u32,
4767 type_id: xidl_typeobject::runtime::type_identifier_for::<
4768 StructMemberFlag,
4769 >(
4770 xidl_typeobject::runtime::TypeEquivalence::Complete
4771 ),
4772 name: "member_flags",
4773 },
4774 xidl_typeobject::runtime::StructMemberDesc {
4775 member_id: 3u32,
4776 member_flags: 0u32,
4777 type_id: xidl_typeobject::runtime::type_identifier_for::<TypeIdentifier>(
4778 xidl_typeobject::runtime::TypeEquivalence::Complete,
4779 ),
4780 name: "member_type_id",
4781 },
4782 ],
4783 )
4784 }
4785 }
4786 pub struct CompleteMemberDetail {
4787 pub name: Box<MemberName>,
4788
4789 pub ann_builtin: Box<AppliedBuiltinMemberAnnotations>,
4790
4791 pub ann_custom: Box<AppliedAnnotationSeq>,
4792 }
4793
4794 impl CompleteMemberDetail {
4795 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
4796 }
4797
4798 impl xidl_xcdr::XcdrSerialize for CompleteMemberDetail {
4799 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
4800 Self::SERIALIZE_KIND
4801 }
4802
4803 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
4804 &self,
4805 serializer: &mut S,
4806 ) -> xidl_xcdr::error::XcdrResult<()> {
4807 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
4808
4809 serializer.begin_field(xidl_xcdr::FieldId(1u32), false, 0)?;
4810
4811 xidl_xcdr::XcdrSerialize::serialize_with(&self.name, serializer)?;
4812 serializer.end_field()?;
4813
4814 serializer.begin_field(xidl_xcdr::FieldId(2u32), false, 0)?;
4815
4816 xidl_xcdr::XcdrSerialize::serialize_with(&self.ann_builtin, serializer)?;
4817 serializer.end_field()?;
4818
4819 serializer.begin_field(xidl_xcdr::FieldId(3u32), false, 0)?;
4820
4821 xidl_xcdr::XcdrSerialize::serialize_with(&self.ann_custom, serializer)?;
4822 serializer.end_field()?;
4823
4824 serializer.end_struct()?;
4825 Ok(())
4826 }
4827 }
4828
4829 impl xidl_xcdr::XcdrDeserialize for CompleteMemberDetail {
4830 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
4831 deserializer: &mut D,
4832 ) -> xidl_xcdr::error::XcdrResult<Self> {
4833 let name = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
4834
4835 let ann_builtin = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
4836
4837 let ann_custom = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
4838
4839 Ok(Self {
4840 name,
4841
4842 ann_builtin,
4843
4844 ann_custom,
4845 })
4846 }
4847 }
4848
4849 impl xidl_typeobject::XidlTypeObject for CompleteMemberDetail {
4850 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
4851 xidl_typeobject::runtime::build_minimal_struct(
4852 0u32,
4853 xidl_typeobject::runtime::type_identifier_none(),
4854 vec![
4855 xidl_typeobject::runtime::StructMemberDesc {
4856 member_id: 1u32,
4857 member_flags: 0u32,
4858 type_id: xidl_typeobject::runtime::type_identifier_for::<MemberName>(
4859 xidl_typeobject::runtime::TypeEquivalence::Minimal,
4860 ),
4861 name: "name",
4862 },
4863 xidl_typeobject::runtime::StructMemberDesc {
4864 member_id: 2u32,
4865 member_flags: 0u32,
4866 type_id: xidl_typeobject::runtime::type_identifier_for::<
4867 AppliedBuiltinMemberAnnotations,
4868 >(
4869 xidl_typeobject::runtime::TypeEquivalence::Minimal
4870 ),
4871 name: "ann_builtin",
4872 },
4873 xidl_typeobject::runtime::StructMemberDesc {
4874 member_id: 3u32,
4875 member_flags: 0u32,
4876 type_id: xidl_typeobject::runtime::type_identifier_for::<
4877 AppliedAnnotationSeq,
4878 >(
4879 xidl_typeobject::runtime::TypeEquivalence::Minimal
4880 ),
4881 name: "ann_custom",
4882 },
4883 ],
4884 )
4885 }
4886
4887 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
4888 xidl_typeobject::runtime::build_complete_struct(
4889 "DDS::XTypes::CompleteMemberDetail",
4890 0u32,
4891 xidl_typeobject::runtime::type_identifier_none(),
4892 vec![
4893 xidl_typeobject::runtime::StructMemberDesc {
4894 member_id: 1u32,
4895 member_flags: 0u32,
4896 type_id: xidl_typeobject::runtime::type_identifier_for::<MemberName>(
4897 xidl_typeobject::runtime::TypeEquivalence::Complete,
4898 ),
4899 name: "name",
4900 },
4901 xidl_typeobject::runtime::StructMemberDesc {
4902 member_id: 2u32,
4903 member_flags: 0u32,
4904 type_id: xidl_typeobject::runtime::type_identifier_for::<
4905 AppliedBuiltinMemberAnnotations,
4906 >(
4907 xidl_typeobject::runtime::TypeEquivalence::Complete
4908 ),
4909 name: "ann_builtin",
4910 },
4911 xidl_typeobject::runtime::StructMemberDesc {
4912 member_id: 3u32,
4913 member_flags: 0u32,
4914 type_id: xidl_typeobject::runtime::type_identifier_for::<
4915 AppliedAnnotationSeq,
4916 >(
4917 xidl_typeobject::runtime::TypeEquivalence::Complete
4918 ),
4919 name: "ann_custom",
4920 },
4921 ],
4922 )
4923 }
4924 }
4925 pub struct MinimalMemberDetail {
4926 pub name_hash: Box<NameHash>,
4927 }
4928
4929 impl MinimalMemberDetail {
4930 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
4931 }
4932
4933 impl xidl_xcdr::XcdrSerialize for MinimalMemberDetail {
4934 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
4935 Self::SERIALIZE_KIND
4936 }
4937
4938 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
4939 &self,
4940 serializer: &mut S,
4941 ) -> xidl_xcdr::error::XcdrResult<()> {
4942 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
4943
4944 serializer.begin_field(xidl_xcdr::FieldId(1u32), false, 0)?;
4945
4946 xidl_xcdr::XcdrSerialize::serialize_with(&self.name_hash, serializer)?;
4947 serializer.end_field()?;
4948
4949 serializer.end_struct()?;
4950 Ok(())
4951 }
4952 }
4953
4954 impl xidl_xcdr::XcdrDeserialize for MinimalMemberDetail {
4955 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
4956 deserializer: &mut D,
4957 ) -> xidl_xcdr::error::XcdrResult<Self> {
4958 let name_hash = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
4959
4960 Ok(Self { name_hash })
4961 }
4962 }
4963
4964 impl xidl_typeobject::XidlTypeObject for MinimalMemberDetail {
4965 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
4966 xidl_typeobject::runtime::build_minimal_struct(
4967 0u32,
4968 xidl_typeobject::runtime::type_identifier_none(),
4969 vec![xidl_typeobject::runtime::StructMemberDesc {
4970 member_id: 1u32,
4971 member_flags: 0u32,
4972 type_id: xidl_typeobject::runtime::type_identifier_for::<NameHash>(
4973 xidl_typeobject::runtime::TypeEquivalence::Minimal,
4974 ),
4975 name: "name_hash",
4976 }],
4977 )
4978 }
4979
4980 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
4981 xidl_typeobject::runtime::build_complete_struct(
4982 "DDS::XTypes::MinimalMemberDetail",
4983 0u32,
4984 xidl_typeobject::runtime::type_identifier_none(),
4985 vec![xidl_typeobject::runtime::StructMemberDesc {
4986 member_id: 1u32,
4987 member_flags: 0u32,
4988 type_id: xidl_typeobject::runtime::type_identifier_for::<NameHash>(
4989 xidl_typeobject::runtime::TypeEquivalence::Complete,
4990 ),
4991 name: "name_hash",
4992 }],
4993 )
4994 }
4995 }
4996 pub struct CompleteStructMember {
4997 pub common: Box<CommonStructMember>,
4998
4999 pub detail: Box<CompleteMemberDetail>,
5000 }
5001
5002 impl CompleteStructMember {
5003 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
5004 }
5005
5006 impl xidl_xcdr::XcdrSerialize for CompleteStructMember {
5007 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
5008 Self::SERIALIZE_KIND
5009 }
5010
5011 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
5012 &self,
5013 serializer: &mut S,
5014 ) -> xidl_xcdr::error::XcdrResult<()> {
5015 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
5016
5017 serializer.begin_field(xidl_xcdr::FieldId(1u32), false, 0)?;
5018
5019 xidl_xcdr::XcdrSerialize::serialize_with(&self.common, serializer)?;
5020 serializer.end_field()?;
5021
5022 serializer.begin_field(xidl_xcdr::FieldId(2u32), false, 0)?;
5023
5024 xidl_xcdr::XcdrSerialize::serialize_with(&self.detail, serializer)?;
5025 serializer.end_field()?;
5026
5027 serializer.end_struct()?;
5028 Ok(())
5029 }
5030 }
5031
5032 impl xidl_xcdr::XcdrDeserialize for CompleteStructMember {
5033 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
5034 deserializer: &mut D,
5035 ) -> xidl_xcdr::error::XcdrResult<Self> {
5036 let common = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
5037
5038 let detail = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
5039
5040 Ok(Self { common, detail })
5041 }
5042 }
5043
5044 impl xidl_typeobject::XidlTypeObject for CompleteStructMember {
5045 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
5046 xidl_typeobject::runtime::build_minimal_struct(
5047 0u32,
5048 xidl_typeobject::runtime::type_identifier_none(),
5049 vec![
5050 xidl_typeobject::runtime::StructMemberDesc {
5051 member_id: 1u32,
5052 member_flags: 0u32,
5053 type_id: xidl_typeobject::runtime::type_identifier_for::<
5054 CommonStructMember,
5055 >(
5056 xidl_typeobject::runtime::TypeEquivalence::Minimal
5057 ),
5058 name: "common",
5059 },
5060 xidl_typeobject::runtime::StructMemberDesc {
5061 member_id: 2u32,
5062 member_flags: 0u32,
5063 type_id: xidl_typeobject::runtime::type_identifier_for::<
5064 CompleteMemberDetail,
5065 >(
5066 xidl_typeobject::runtime::TypeEquivalence::Minimal
5067 ),
5068 name: "detail",
5069 },
5070 ],
5071 )
5072 }
5073
5074 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
5075 xidl_typeobject::runtime::build_complete_struct(
5076 "DDS::XTypes::CompleteStructMember",
5077 0u32,
5078 xidl_typeobject::runtime::type_identifier_none(),
5079 vec![
5080 xidl_typeobject::runtime::StructMemberDesc {
5081 member_id: 1u32,
5082 member_flags: 0u32,
5083 type_id: xidl_typeobject::runtime::type_identifier_for::<
5084 CommonStructMember,
5085 >(
5086 xidl_typeobject::runtime::TypeEquivalence::Complete
5087 ),
5088 name: "common",
5089 },
5090 xidl_typeobject::runtime::StructMemberDesc {
5091 member_id: 2u32,
5092 member_flags: 0u32,
5093 type_id: xidl_typeobject::runtime::type_identifier_for::<
5094 CompleteMemberDetail,
5095 >(
5096 xidl_typeobject::runtime::TypeEquivalence::Complete
5097 ),
5098 name: "detail",
5099 },
5100 ],
5101 )
5102 }
5103 }
5104 pub type CompleteStructMemberSeq = Vec<CompleteStructMember>;
5105 pub struct MinimalStructMember {
5106 pub common: Box<CommonStructMember>,
5107
5108 pub detail: Box<MinimalMemberDetail>,
5109 }
5110
5111 impl MinimalStructMember {
5112 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
5113 }
5114
5115 impl xidl_xcdr::XcdrSerialize for MinimalStructMember {
5116 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
5117 Self::SERIALIZE_KIND
5118 }
5119
5120 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
5121 &self,
5122 serializer: &mut S,
5123 ) -> xidl_xcdr::error::XcdrResult<()> {
5124 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
5125
5126 serializer.begin_field(xidl_xcdr::FieldId(1u32), false, 0)?;
5127
5128 xidl_xcdr::XcdrSerialize::serialize_with(&self.common, serializer)?;
5129 serializer.end_field()?;
5130
5131 serializer.begin_field(xidl_xcdr::FieldId(2u32), false, 0)?;
5132
5133 xidl_xcdr::XcdrSerialize::serialize_with(&self.detail, serializer)?;
5134 serializer.end_field()?;
5135
5136 serializer.end_struct()?;
5137 Ok(())
5138 }
5139 }
5140
5141 impl xidl_xcdr::XcdrDeserialize for MinimalStructMember {
5142 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
5143 deserializer: &mut D,
5144 ) -> xidl_xcdr::error::XcdrResult<Self> {
5145 let common = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
5146
5147 let detail = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
5148
5149 Ok(Self { common, detail })
5150 }
5151 }
5152
5153 impl xidl_typeobject::XidlTypeObject for MinimalStructMember {
5154 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
5155 xidl_typeobject::runtime::build_minimal_struct(
5156 0u32,
5157 xidl_typeobject::runtime::type_identifier_none(),
5158 vec![
5159 xidl_typeobject::runtime::StructMemberDesc {
5160 member_id: 1u32,
5161 member_flags: 0u32,
5162 type_id: xidl_typeobject::runtime::type_identifier_for::<
5163 CommonStructMember,
5164 >(
5165 xidl_typeobject::runtime::TypeEquivalence::Minimal
5166 ),
5167 name: "common",
5168 },
5169 xidl_typeobject::runtime::StructMemberDesc {
5170 member_id: 2u32,
5171 member_flags: 0u32,
5172 type_id: xidl_typeobject::runtime::type_identifier_for::<
5173 MinimalMemberDetail,
5174 >(
5175 xidl_typeobject::runtime::TypeEquivalence::Minimal
5176 ),
5177 name: "detail",
5178 },
5179 ],
5180 )
5181 }
5182
5183 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
5184 xidl_typeobject::runtime::build_complete_struct(
5185 "DDS::XTypes::MinimalStructMember",
5186 0u32,
5187 xidl_typeobject::runtime::type_identifier_none(),
5188 vec![
5189 xidl_typeobject::runtime::StructMemberDesc {
5190 member_id: 1u32,
5191 member_flags: 0u32,
5192 type_id: xidl_typeobject::runtime::type_identifier_for::<
5193 CommonStructMember,
5194 >(
5195 xidl_typeobject::runtime::TypeEquivalence::Complete
5196 ),
5197 name: "common",
5198 },
5199 xidl_typeobject::runtime::StructMemberDesc {
5200 member_id: 2u32,
5201 member_flags: 0u32,
5202 type_id: xidl_typeobject::runtime::type_identifier_for::<
5203 MinimalMemberDetail,
5204 >(
5205 xidl_typeobject::runtime::TypeEquivalence::Complete
5206 ),
5207 name: "detail",
5208 },
5209 ],
5210 )
5211 }
5212 }
5213 pub type MinimalStructMemberSeq = Vec<MinimalStructMember>;
5214 pub struct AppliedBuiltinTypeAnnotations {
5215 pub verbatim: Box<AppliedVerbatimAnnotation>,
5216 }
5217
5218 impl AppliedBuiltinTypeAnnotations {
5219 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
5220 }
5221
5222 impl xidl_xcdr::XcdrSerialize for AppliedBuiltinTypeAnnotations {
5223 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
5224 Self::SERIALIZE_KIND
5225 }
5226
5227 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
5228 &self,
5229 serializer: &mut S,
5230 ) -> xidl_xcdr::error::XcdrResult<()> {
5231 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
5232
5233 serializer.begin_field(xidl_xcdr::FieldId(1u32), false, 0)?;
5234
5235 xidl_xcdr::XcdrSerialize::serialize_with(&self.verbatim, serializer)?;
5236 serializer.end_field()?;
5237
5238 serializer.end_struct()?;
5239 Ok(())
5240 }
5241 }
5242
5243 impl xidl_xcdr::XcdrDeserialize for AppliedBuiltinTypeAnnotations {
5244 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
5245 deserializer: &mut D,
5246 ) -> xidl_xcdr::error::XcdrResult<Self> {
5247 let verbatim = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
5248
5249 Ok(Self { verbatim })
5250 }
5251 }
5252
5253 impl xidl_typeobject::XidlTypeObject for AppliedBuiltinTypeAnnotations {
5254 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
5255 xidl_typeobject::runtime::build_minimal_struct(
5256 0u32,
5257 xidl_typeobject::runtime::type_identifier_none(),
5258 vec![xidl_typeobject::runtime::StructMemberDesc {
5259 member_id: 1u32,
5260 member_flags: 0u32,
5261 type_id: xidl_typeobject::runtime::type_identifier_for::<
5262 AppliedVerbatimAnnotation,
5263 >(
5264 xidl_typeobject::runtime::TypeEquivalence::Minimal
5265 ),
5266 name: "verbatim",
5267 }],
5268 )
5269 }
5270
5271 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
5272 xidl_typeobject::runtime::build_complete_struct(
5273 "DDS::XTypes::AppliedBuiltinTypeAnnotations",
5274 0u32,
5275 xidl_typeobject::runtime::type_identifier_none(),
5276 vec![xidl_typeobject::runtime::StructMemberDesc {
5277 member_id: 1u32,
5278 member_flags: 0u32,
5279 type_id: xidl_typeobject::runtime::type_identifier_for::<
5280 AppliedVerbatimAnnotation,
5281 >(
5282 xidl_typeobject::runtime::TypeEquivalence::Complete
5283 ),
5284 name: "verbatim",
5285 }],
5286 )
5287 }
5288 }
5289 pub struct MinimalTypeDetail {}
5290
5291 impl MinimalTypeDetail {
5292 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
5293 }
5294
5295 impl xidl_xcdr::XcdrSerialize for MinimalTypeDetail {
5296 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
5297 Self::SERIALIZE_KIND
5298 }
5299
5300 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
5301 &self,
5302 serializer: &mut S,
5303 ) -> xidl_xcdr::error::XcdrResult<()> {
5304 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
5305
5306 serializer.end_struct()?;
5307 Ok(())
5308 }
5309 }
5310
5311 impl xidl_xcdr::XcdrDeserialize for MinimalTypeDetail {
5312 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
5313 deserializer: &mut D,
5314 ) -> xidl_xcdr::error::XcdrResult<Self> {
5315 Ok(Self {})
5316 }
5317 }
5318
5319 impl xidl_typeobject::XidlTypeObject for MinimalTypeDetail {
5320 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
5321 xidl_typeobject::runtime::build_minimal_struct(
5322 0u32,
5323 xidl_typeobject::runtime::type_identifier_none(),
5324 vec![],
5325 )
5326 }
5327
5328 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
5329 xidl_typeobject::runtime::build_complete_struct(
5330 "DDS::XTypes::MinimalTypeDetail",
5331 0u32,
5332 xidl_typeobject::runtime::type_identifier_none(),
5333 vec![],
5334 )
5335 }
5336 }
5337 pub struct CompleteTypeDetail {
5338 pub ann_builtin: Box<AppliedBuiltinTypeAnnotations>,
5339
5340 pub ann_custom: Box<AppliedAnnotationSeq>,
5341
5342 pub type_name: Box<QualifiedTypeName>,
5343 }
5344
5345 impl CompleteTypeDetail {
5346 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
5347 }
5348
5349 impl xidl_xcdr::XcdrSerialize for CompleteTypeDetail {
5350 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
5351 Self::SERIALIZE_KIND
5352 }
5353
5354 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
5355 &self,
5356 serializer: &mut S,
5357 ) -> xidl_xcdr::error::XcdrResult<()> {
5358 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
5359
5360 serializer.begin_field(xidl_xcdr::FieldId(1u32), false, 0)?;
5361
5362 xidl_xcdr::XcdrSerialize::serialize_with(&self.ann_builtin, serializer)?;
5363 serializer.end_field()?;
5364
5365 serializer.begin_field(xidl_xcdr::FieldId(2u32), false, 0)?;
5366
5367 xidl_xcdr::XcdrSerialize::serialize_with(&self.ann_custom, serializer)?;
5368 serializer.end_field()?;
5369
5370 serializer.begin_field(xidl_xcdr::FieldId(3u32), false, 0)?;
5371
5372 xidl_xcdr::XcdrSerialize::serialize_with(&self.type_name, serializer)?;
5373 serializer.end_field()?;
5374
5375 serializer.end_struct()?;
5376 Ok(())
5377 }
5378 }
5379
5380 impl xidl_xcdr::XcdrDeserialize for CompleteTypeDetail {
5381 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
5382 deserializer: &mut D,
5383 ) -> xidl_xcdr::error::XcdrResult<Self> {
5384 let ann_builtin = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
5385
5386 let ann_custom = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
5387
5388 let type_name = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
5389
5390 Ok(Self {
5391 ann_builtin,
5392
5393 ann_custom,
5394
5395 type_name,
5396 })
5397 }
5398 }
5399
5400 impl xidl_typeobject::XidlTypeObject for CompleteTypeDetail {
5401 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
5402 xidl_typeobject::runtime::build_minimal_struct(
5403 0u32,
5404 xidl_typeobject::runtime::type_identifier_none(),
5405 vec![
5406 xidl_typeobject::runtime::StructMemberDesc {
5407 member_id: 1u32,
5408 member_flags: 0u32,
5409 type_id: xidl_typeobject::runtime::type_identifier_for::<
5410 AppliedBuiltinTypeAnnotations,
5411 >(
5412 xidl_typeobject::runtime::TypeEquivalence::Minimal
5413 ),
5414 name: "ann_builtin",
5415 },
5416 xidl_typeobject::runtime::StructMemberDesc {
5417 member_id: 2u32,
5418 member_flags: 0u32,
5419 type_id: xidl_typeobject::runtime::type_identifier_for::<
5420 AppliedAnnotationSeq,
5421 >(
5422 xidl_typeobject::runtime::TypeEquivalence::Minimal
5423 ),
5424 name: "ann_custom",
5425 },
5426 xidl_typeobject::runtime::StructMemberDesc {
5427 member_id: 3u32,
5428 member_flags: 0u32,
5429 type_id: xidl_typeobject::runtime::type_identifier_for::<
5430 QualifiedTypeName,
5431 >(
5432 xidl_typeobject::runtime::TypeEquivalence::Minimal
5433 ),
5434 name: "type_name",
5435 },
5436 ],
5437 )
5438 }
5439
5440 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
5441 xidl_typeobject::runtime::build_complete_struct(
5442 "DDS::XTypes::CompleteTypeDetail",
5443 0u32,
5444 xidl_typeobject::runtime::type_identifier_none(),
5445 vec![
5446 xidl_typeobject::runtime::StructMemberDesc {
5447 member_id: 1u32,
5448 member_flags: 0u32,
5449 type_id: xidl_typeobject::runtime::type_identifier_for::<
5450 AppliedBuiltinTypeAnnotations,
5451 >(
5452 xidl_typeobject::runtime::TypeEquivalence::Complete
5453 ),
5454 name: "ann_builtin",
5455 },
5456 xidl_typeobject::runtime::StructMemberDesc {
5457 member_id: 2u32,
5458 member_flags: 0u32,
5459 type_id: xidl_typeobject::runtime::type_identifier_for::<
5460 AppliedAnnotationSeq,
5461 >(
5462 xidl_typeobject::runtime::TypeEquivalence::Complete
5463 ),
5464 name: "ann_custom",
5465 },
5466 xidl_typeobject::runtime::StructMemberDesc {
5467 member_id: 3u32,
5468 member_flags: 0u32,
5469 type_id: xidl_typeobject::runtime::type_identifier_for::<
5470 QualifiedTypeName,
5471 >(
5472 xidl_typeobject::runtime::TypeEquivalence::Complete
5473 ),
5474 name: "type_name",
5475 },
5476 ],
5477 )
5478 }
5479 }
5480 pub struct CompleteStructHeader {
5481 pub base_type: Box<TypeIdentifier>,
5482
5483 pub detail: Box<CompleteTypeDetail>,
5484 }
5485
5486 impl CompleteStructHeader {
5487 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
5488 }
5489
5490 impl xidl_xcdr::XcdrSerialize for CompleteStructHeader {
5491 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
5492 Self::SERIALIZE_KIND
5493 }
5494
5495 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
5496 &self,
5497 serializer: &mut S,
5498 ) -> xidl_xcdr::error::XcdrResult<()> {
5499 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
5500
5501 serializer.begin_field(xidl_xcdr::FieldId(1u32), false, 0)?;
5502
5503 xidl_xcdr::XcdrSerialize::serialize_with(&self.base_type, serializer)?;
5504 serializer.end_field()?;
5505
5506 serializer.begin_field(xidl_xcdr::FieldId(2u32), false, 0)?;
5507
5508 xidl_xcdr::XcdrSerialize::serialize_with(&self.detail, serializer)?;
5509 serializer.end_field()?;
5510
5511 serializer.end_struct()?;
5512 Ok(())
5513 }
5514 }
5515
5516 impl xidl_xcdr::XcdrDeserialize for CompleteStructHeader {
5517 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
5518 deserializer: &mut D,
5519 ) -> xidl_xcdr::error::XcdrResult<Self> {
5520 let base_type = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
5521
5522 let detail = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
5523
5524 Ok(Self { base_type, detail })
5525 }
5526 }
5527
5528 impl xidl_typeobject::XidlTypeObject for CompleteStructHeader {
5529 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
5530 xidl_typeobject::runtime::build_minimal_struct(
5531 0u32,
5532 xidl_typeobject::runtime::type_identifier_none(),
5533 vec![
5534 xidl_typeobject::runtime::StructMemberDesc {
5535 member_id: 1u32,
5536 member_flags: 0u32,
5537 type_id: xidl_typeobject::runtime::type_identifier_for::<TypeIdentifier>(
5538 xidl_typeobject::runtime::TypeEquivalence::Minimal,
5539 ),
5540 name: "base_type",
5541 },
5542 xidl_typeobject::runtime::StructMemberDesc {
5543 member_id: 2u32,
5544 member_flags: 0u32,
5545 type_id: xidl_typeobject::runtime::type_identifier_for::<
5546 CompleteTypeDetail,
5547 >(
5548 xidl_typeobject::runtime::TypeEquivalence::Minimal
5549 ),
5550 name: "detail",
5551 },
5552 ],
5553 )
5554 }
5555
5556 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
5557 xidl_typeobject::runtime::build_complete_struct(
5558 "DDS::XTypes::CompleteStructHeader",
5559 0u32,
5560 xidl_typeobject::runtime::type_identifier_none(),
5561 vec![
5562 xidl_typeobject::runtime::StructMemberDesc {
5563 member_id: 1u32,
5564 member_flags: 0u32,
5565 type_id: xidl_typeobject::runtime::type_identifier_for::<TypeIdentifier>(
5566 xidl_typeobject::runtime::TypeEquivalence::Complete,
5567 ),
5568 name: "base_type",
5569 },
5570 xidl_typeobject::runtime::StructMemberDesc {
5571 member_id: 2u32,
5572 member_flags: 0u32,
5573 type_id: xidl_typeobject::runtime::type_identifier_for::<
5574 CompleteTypeDetail,
5575 >(
5576 xidl_typeobject::runtime::TypeEquivalence::Complete
5577 ),
5578 name: "detail",
5579 },
5580 ],
5581 )
5582 }
5583 }
5584 pub struct MinimalStructHeader {
5585 pub base_type: Box<TypeIdentifier>,
5586
5587 pub detail: Box<MinimalTypeDetail>,
5588 }
5589
5590 impl MinimalStructHeader {
5591 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
5592 }
5593
5594 impl xidl_xcdr::XcdrSerialize for MinimalStructHeader {
5595 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
5596 Self::SERIALIZE_KIND
5597 }
5598
5599 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
5600 &self,
5601 serializer: &mut S,
5602 ) -> xidl_xcdr::error::XcdrResult<()> {
5603 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
5604
5605 serializer.begin_field(xidl_xcdr::FieldId(1u32), false, 0)?;
5606
5607 xidl_xcdr::XcdrSerialize::serialize_with(&self.base_type, serializer)?;
5608 serializer.end_field()?;
5609
5610 serializer.begin_field(xidl_xcdr::FieldId(2u32), false, 0)?;
5611
5612 xidl_xcdr::XcdrSerialize::serialize_with(&self.detail, serializer)?;
5613 serializer.end_field()?;
5614
5615 serializer.end_struct()?;
5616 Ok(())
5617 }
5618 }
5619
5620 impl xidl_xcdr::XcdrDeserialize for MinimalStructHeader {
5621 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
5622 deserializer: &mut D,
5623 ) -> xidl_xcdr::error::XcdrResult<Self> {
5624 let base_type = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
5625
5626 let detail = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
5627
5628 Ok(Self { base_type, detail })
5629 }
5630 }
5631
5632 impl xidl_typeobject::XidlTypeObject for MinimalStructHeader {
5633 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
5634 xidl_typeobject::runtime::build_minimal_struct(
5635 0u32,
5636 xidl_typeobject::runtime::type_identifier_none(),
5637 vec![
5638 xidl_typeobject::runtime::StructMemberDesc {
5639 member_id: 1u32,
5640 member_flags: 0u32,
5641 type_id: xidl_typeobject::runtime::type_identifier_for::<TypeIdentifier>(
5642 xidl_typeobject::runtime::TypeEquivalence::Minimal,
5643 ),
5644 name: "base_type",
5645 },
5646 xidl_typeobject::runtime::StructMemberDesc {
5647 member_id: 2u32,
5648 member_flags: 0u32,
5649 type_id: xidl_typeobject::runtime::type_identifier_for::<
5650 MinimalTypeDetail,
5651 >(
5652 xidl_typeobject::runtime::TypeEquivalence::Minimal
5653 ),
5654 name: "detail",
5655 },
5656 ],
5657 )
5658 }
5659
5660 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
5661 xidl_typeobject::runtime::build_complete_struct(
5662 "DDS::XTypes::MinimalStructHeader",
5663 0u32,
5664 xidl_typeobject::runtime::type_identifier_none(),
5665 vec![
5666 xidl_typeobject::runtime::StructMemberDesc {
5667 member_id: 1u32,
5668 member_flags: 0u32,
5669 type_id: xidl_typeobject::runtime::type_identifier_for::<TypeIdentifier>(
5670 xidl_typeobject::runtime::TypeEquivalence::Complete,
5671 ),
5672 name: "base_type",
5673 },
5674 xidl_typeobject::runtime::StructMemberDesc {
5675 member_id: 2u32,
5676 member_flags: 0u32,
5677 type_id: xidl_typeobject::runtime::type_identifier_for::<
5678 MinimalTypeDetail,
5679 >(
5680 xidl_typeobject::runtime::TypeEquivalence::Complete
5681 ),
5682 name: "detail",
5683 },
5684 ],
5685 )
5686 }
5687 }
5688 pub struct CompleteStructType {
5689 pub struct_flags: Box<StructTypeFlag>,
5690
5691 pub header: Box<CompleteStructHeader>,
5692
5693 pub member_seq: Box<CompleteStructMemberSeq>,
5694 }
5695
5696 impl CompleteStructType {
5697 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
5698 }
5699
5700 impl xidl_xcdr::XcdrSerialize for CompleteStructType {
5701 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
5702 Self::SERIALIZE_KIND
5703 }
5704
5705 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
5706 &self,
5707 serializer: &mut S,
5708 ) -> xidl_xcdr::error::XcdrResult<()> {
5709 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
5710
5711 serializer.begin_field(xidl_xcdr::FieldId(1u32), false, 0)?;
5712
5713 xidl_xcdr::XcdrSerialize::serialize_with(&self.struct_flags, serializer)?;
5714 serializer.end_field()?;
5715
5716 serializer.begin_field(xidl_xcdr::FieldId(2u32), false, 0)?;
5717
5718 xidl_xcdr::XcdrSerialize::serialize_with(&self.header, serializer)?;
5719 serializer.end_field()?;
5720
5721 serializer.begin_field(xidl_xcdr::FieldId(3u32), false, 0)?;
5722
5723 xidl_xcdr::XcdrSerialize::serialize_with(&self.member_seq, serializer)?;
5724 serializer.end_field()?;
5725
5726 serializer.end_struct()?;
5727 Ok(())
5728 }
5729 }
5730
5731 impl xidl_xcdr::XcdrDeserialize for CompleteStructType {
5732 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
5733 deserializer: &mut D,
5734 ) -> xidl_xcdr::error::XcdrResult<Self> {
5735 let struct_flags = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
5736
5737 let header = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
5738
5739 let member_seq = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
5740
5741 Ok(Self {
5742 struct_flags,
5743
5744 header,
5745
5746 member_seq,
5747 })
5748 }
5749 }
5750
5751 impl xidl_typeobject::XidlTypeObject for CompleteStructType {
5752 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
5753 xidl_typeobject::runtime::build_minimal_struct(
5754 0u32,
5755 xidl_typeobject::runtime::type_identifier_none(),
5756 vec![
5757 xidl_typeobject::runtime::StructMemberDesc {
5758 member_id: 1u32,
5759 member_flags: 0u32,
5760 type_id: xidl_typeobject::runtime::type_identifier_for::<StructTypeFlag>(
5761 xidl_typeobject::runtime::TypeEquivalence::Minimal,
5762 ),
5763 name: "struct_flags",
5764 },
5765 xidl_typeobject::runtime::StructMemberDesc {
5766 member_id: 2u32,
5767 member_flags: 0u32,
5768 type_id: xidl_typeobject::runtime::type_identifier_for::<
5769 CompleteStructHeader,
5770 >(
5771 xidl_typeobject::runtime::TypeEquivalence::Minimal
5772 ),
5773 name: "header",
5774 },
5775 xidl_typeobject::runtime::StructMemberDesc {
5776 member_id: 3u32,
5777 member_flags: 0u32,
5778 type_id: xidl_typeobject::runtime::type_identifier_for::<
5779 CompleteStructMemberSeq,
5780 >(
5781 xidl_typeobject::runtime::TypeEquivalence::Minimal
5782 ),
5783 name: "member_seq",
5784 },
5785 ],
5786 )
5787 }
5788
5789 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
5790 xidl_typeobject::runtime::build_complete_struct(
5791 "DDS::XTypes::CompleteStructType",
5792 0u32,
5793 xidl_typeobject::runtime::type_identifier_none(),
5794 vec![
5795 xidl_typeobject::runtime::StructMemberDesc {
5796 member_id: 1u32,
5797 member_flags: 0u32,
5798 type_id: xidl_typeobject::runtime::type_identifier_for::<StructTypeFlag>(
5799 xidl_typeobject::runtime::TypeEquivalence::Complete,
5800 ),
5801 name: "struct_flags",
5802 },
5803 xidl_typeobject::runtime::StructMemberDesc {
5804 member_id: 2u32,
5805 member_flags: 0u32,
5806 type_id: xidl_typeobject::runtime::type_identifier_for::<
5807 CompleteStructHeader,
5808 >(
5809 xidl_typeobject::runtime::TypeEquivalence::Complete
5810 ),
5811 name: "header",
5812 },
5813 xidl_typeobject::runtime::StructMemberDesc {
5814 member_id: 3u32,
5815 member_flags: 0u32,
5816 type_id: xidl_typeobject::runtime::type_identifier_for::<
5817 CompleteStructMemberSeq,
5818 >(
5819 xidl_typeobject::runtime::TypeEquivalence::Complete
5820 ),
5821 name: "member_seq",
5822 },
5823 ],
5824 )
5825 }
5826 }
5827 pub struct MinimalStructType {
5828 pub struct_flags: Box<StructTypeFlag>,
5829
5830 pub header: Box<MinimalStructHeader>,
5831
5832 pub member_seq: Box<MinimalStructMemberSeq>,
5833 }
5834
5835 impl MinimalStructType {
5836 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
5837 }
5838
5839 impl xidl_xcdr::XcdrSerialize for MinimalStructType {
5840 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
5841 Self::SERIALIZE_KIND
5842 }
5843
5844 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
5845 &self,
5846 serializer: &mut S,
5847 ) -> xidl_xcdr::error::XcdrResult<()> {
5848 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
5849
5850 serializer.begin_field(xidl_xcdr::FieldId(1u32), false, 0)?;
5851
5852 xidl_xcdr::XcdrSerialize::serialize_with(&self.struct_flags, serializer)?;
5853 serializer.end_field()?;
5854
5855 serializer.begin_field(xidl_xcdr::FieldId(2u32), false, 0)?;
5856
5857 xidl_xcdr::XcdrSerialize::serialize_with(&self.header, serializer)?;
5858 serializer.end_field()?;
5859
5860 serializer.begin_field(xidl_xcdr::FieldId(3u32), false, 0)?;
5861
5862 xidl_xcdr::XcdrSerialize::serialize_with(&self.member_seq, serializer)?;
5863 serializer.end_field()?;
5864
5865 serializer.end_struct()?;
5866 Ok(())
5867 }
5868 }
5869
5870 impl xidl_xcdr::XcdrDeserialize for MinimalStructType {
5871 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
5872 deserializer: &mut D,
5873 ) -> xidl_xcdr::error::XcdrResult<Self> {
5874 let struct_flags = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
5875
5876 let header = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
5877
5878 let member_seq = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
5879
5880 Ok(Self {
5881 struct_flags,
5882
5883 header,
5884
5885 member_seq,
5886 })
5887 }
5888 }
5889
5890 impl xidl_typeobject::XidlTypeObject for MinimalStructType {
5891 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
5892 xidl_typeobject::runtime::build_minimal_struct(
5893 0u32,
5894 xidl_typeobject::runtime::type_identifier_none(),
5895 vec![
5896 xidl_typeobject::runtime::StructMemberDesc {
5897 member_id: 1u32,
5898 member_flags: 0u32,
5899 type_id: xidl_typeobject::runtime::type_identifier_for::<StructTypeFlag>(
5900 xidl_typeobject::runtime::TypeEquivalence::Minimal,
5901 ),
5902 name: "struct_flags",
5903 },
5904 xidl_typeobject::runtime::StructMemberDesc {
5905 member_id: 2u32,
5906 member_flags: 0u32,
5907 type_id: xidl_typeobject::runtime::type_identifier_for::<
5908 MinimalStructHeader,
5909 >(
5910 xidl_typeobject::runtime::TypeEquivalence::Minimal
5911 ),
5912 name: "header",
5913 },
5914 xidl_typeobject::runtime::StructMemberDesc {
5915 member_id: 3u32,
5916 member_flags: 0u32,
5917 type_id: xidl_typeobject::runtime::type_identifier_for::<
5918 MinimalStructMemberSeq,
5919 >(
5920 xidl_typeobject::runtime::TypeEquivalence::Minimal
5921 ),
5922 name: "member_seq",
5923 },
5924 ],
5925 )
5926 }
5927
5928 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
5929 xidl_typeobject::runtime::build_complete_struct(
5930 "DDS::XTypes::MinimalStructType",
5931 0u32,
5932 xidl_typeobject::runtime::type_identifier_none(),
5933 vec![
5934 xidl_typeobject::runtime::StructMemberDesc {
5935 member_id: 1u32,
5936 member_flags: 0u32,
5937 type_id: xidl_typeobject::runtime::type_identifier_for::<StructTypeFlag>(
5938 xidl_typeobject::runtime::TypeEquivalence::Complete,
5939 ),
5940 name: "struct_flags",
5941 },
5942 xidl_typeobject::runtime::StructMemberDesc {
5943 member_id: 2u32,
5944 member_flags: 0u32,
5945 type_id: xidl_typeobject::runtime::type_identifier_for::<
5946 MinimalStructHeader,
5947 >(
5948 xidl_typeobject::runtime::TypeEquivalence::Complete
5949 ),
5950 name: "header",
5951 },
5952 xidl_typeobject::runtime::StructMemberDesc {
5953 member_id: 3u32,
5954 member_flags: 0u32,
5955 type_id: xidl_typeobject::runtime::type_identifier_for::<
5956 MinimalStructMemberSeq,
5957 >(
5958 xidl_typeobject::runtime::TypeEquivalence::Complete
5959 ),
5960 name: "member_seq",
5961 },
5962 ],
5963 )
5964 }
5965 }
5966 pub type UnionCaseLabelSeq = Vec<i32>;
5967 pub struct CommonUnionMember {
5968 pub member_id: Box<MemberId>,
5969
5970 pub member_flags: Box<UnionMemberFlag>,
5971
5972 pub type_id: Box<TypeIdentifier>,
5973
5974 pub label_seq: Box<UnionCaseLabelSeq>,
5975 }
5976
5977 impl CommonUnionMember {
5978 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
5979 }
5980
5981 impl xidl_xcdr::XcdrSerialize for CommonUnionMember {
5982 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
5983 Self::SERIALIZE_KIND
5984 }
5985
5986 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
5987 &self,
5988 serializer: &mut S,
5989 ) -> xidl_xcdr::error::XcdrResult<()> {
5990 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
5991
5992 serializer.begin_field(xidl_xcdr::FieldId(1u32), false, 0)?;
5993
5994 xidl_xcdr::XcdrSerialize::serialize_with(&self.member_id, serializer)?;
5995 serializer.end_field()?;
5996
5997 serializer.begin_field(xidl_xcdr::FieldId(2u32), false, 0)?;
5998
5999 xidl_xcdr::XcdrSerialize::serialize_with(&self.member_flags, serializer)?;
6000 serializer.end_field()?;
6001
6002 serializer.begin_field(xidl_xcdr::FieldId(3u32), false, 0)?;
6003
6004 xidl_xcdr::XcdrSerialize::serialize_with(&self.type_id, serializer)?;
6005 serializer.end_field()?;
6006
6007 serializer.begin_field(xidl_xcdr::FieldId(4u32), false, 0)?;
6008
6009 xidl_xcdr::XcdrSerialize::serialize_with(&self.label_seq, serializer)?;
6010 serializer.end_field()?;
6011
6012 serializer.end_struct()?;
6013 Ok(())
6014 }
6015 }
6016
6017 impl xidl_xcdr::XcdrDeserialize for CommonUnionMember {
6018 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
6019 deserializer: &mut D,
6020 ) -> xidl_xcdr::error::XcdrResult<Self> {
6021 let member_id = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
6022
6023 let member_flags = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
6024
6025 let type_id = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
6026
6027 let label_seq = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
6028
6029 Ok(Self {
6030 member_id,
6031
6032 member_flags,
6033
6034 type_id,
6035
6036 label_seq,
6037 })
6038 }
6039 }
6040
6041 impl xidl_typeobject::XidlTypeObject for CommonUnionMember {
6042 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
6043 xidl_typeobject::runtime::build_minimal_struct(
6044 0u32,
6045 xidl_typeobject::runtime::type_identifier_none(),
6046 vec![
6047 xidl_typeobject::runtime::StructMemberDesc {
6048 member_id: 1u32,
6049 member_flags: 0u32,
6050 type_id: xidl_typeobject::runtime::type_identifier_for::<MemberId>(
6051 xidl_typeobject::runtime::TypeEquivalence::Minimal,
6052 ),
6053 name: "member_id",
6054 },
6055 xidl_typeobject::runtime::StructMemberDesc {
6056 member_id: 2u32,
6057 member_flags: 0u32,
6058 type_id: xidl_typeobject::runtime::type_identifier_for::<UnionMemberFlag>(
6059 xidl_typeobject::runtime::TypeEquivalence::Minimal,
6060 ),
6061 name: "member_flags",
6062 },
6063 xidl_typeobject::runtime::StructMemberDesc {
6064 member_id: 3u32,
6065 member_flags: 0u32,
6066 type_id: xidl_typeobject::runtime::type_identifier_for::<TypeIdentifier>(
6067 xidl_typeobject::runtime::TypeEquivalence::Minimal,
6068 ),
6069 name: "type_id",
6070 },
6071 xidl_typeobject::runtime::StructMemberDesc {
6072 member_id: 4u32,
6073 member_flags: 0u32,
6074 type_id: xidl_typeobject::runtime::type_identifier_for::<
6075 UnionCaseLabelSeq,
6076 >(
6077 xidl_typeobject::runtime::TypeEquivalence::Minimal
6078 ),
6079 name: "label_seq",
6080 },
6081 ],
6082 )
6083 }
6084
6085 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
6086 xidl_typeobject::runtime::build_complete_struct(
6087 "DDS::XTypes::CommonUnionMember",
6088 0u32,
6089 xidl_typeobject::runtime::type_identifier_none(),
6090 vec![
6091 xidl_typeobject::runtime::StructMemberDesc {
6092 member_id: 1u32,
6093 member_flags: 0u32,
6094 type_id: xidl_typeobject::runtime::type_identifier_for::<MemberId>(
6095 xidl_typeobject::runtime::TypeEquivalence::Complete,
6096 ),
6097 name: "member_id",
6098 },
6099 xidl_typeobject::runtime::StructMemberDesc {
6100 member_id: 2u32,
6101 member_flags: 0u32,
6102 type_id: xidl_typeobject::runtime::type_identifier_for::<UnionMemberFlag>(
6103 xidl_typeobject::runtime::TypeEquivalence::Complete,
6104 ),
6105 name: "member_flags",
6106 },
6107 xidl_typeobject::runtime::StructMemberDesc {
6108 member_id: 3u32,
6109 member_flags: 0u32,
6110 type_id: xidl_typeobject::runtime::type_identifier_for::<TypeIdentifier>(
6111 xidl_typeobject::runtime::TypeEquivalence::Complete,
6112 ),
6113 name: "type_id",
6114 },
6115 xidl_typeobject::runtime::StructMemberDesc {
6116 member_id: 4u32,
6117 member_flags: 0u32,
6118 type_id: xidl_typeobject::runtime::type_identifier_for::<
6119 UnionCaseLabelSeq,
6120 >(
6121 xidl_typeobject::runtime::TypeEquivalence::Complete
6122 ),
6123 name: "label_seq",
6124 },
6125 ],
6126 )
6127 }
6128 }
6129 pub struct CompleteUnionMember {
6130 pub common: Box<CommonUnionMember>,
6131
6132 pub detail: Box<CompleteMemberDetail>,
6133 }
6134
6135 impl CompleteUnionMember {
6136 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
6137 }
6138
6139 impl xidl_xcdr::XcdrSerialize for CompleteUnionMember {
6140 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
6141 Self::SERIALIZE_KIND
6142 }
6143
6144 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
6145 &self,
6146 serializer: &mut S,
6147 ) -> xidl_xcdr::error::XcdrResult<()> {
6148 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
6149
6150 serializer.begin_field(xidl_xcdr::FieldId(1u32), false, 0)?;
6151
6152 xidl_xcdr::XcdrSerialize::serialize_with(&self.common, serializer)?;
6153 serializer.end_field()?;
6154
6155 serializer.begin_field(xidl_xcdr::FieldId(2u32), false, 0)?;
6156
6157 xidl_xcdr::XcdrSerialize::serialize_with(&self.detail, serializer)?;
6158 serializer.end_field()?;
6159
6160 serializer.end_struct()?;
6161 Ok(())
6162 }
6163 }
6164
6165 impl xidl_xcdr::XcdrDeserialize for CompleteUnionMember {
6166 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
6167 deserializer: &mut D,
6168 ) -> xidl_xcdr::error::XcdrResult<Self> {
6169 let common = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
6170
6171 let detail = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
6172
6173 Ok(Self { common, detail })
6174 }
6175 }
6176
6177 impl xidl_typeobject::XidlTypeObject for CompleteUnionMember {
6178 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
6179 xidl_typeobject::runtime::build_minimal_struct(
6180 0u32,
6181 xidl_typeobject::runtime::type_identifier_none(),
6182 vec![
6183 xidl_typeobject::runtime::StructMemberDesc {
6184 member_id: 1u32,
6185 member_flags: 0u32,
6186 type_id: xidl_typeobject::runtime::type_identifier_for::<
6187 CommonUnionMember,
6188 >(
6189 xidl_typeobject::runtime::TypeEquivalence::Minimal
6190 ),
6191 name: "common",
6192 },
6193 xidl_typeobject::runtime::StructMemberDesc {
6194 member_id: 2u32,
6195 member_flags: 0u32,
6196 type_id: xidl_typeobject::runtime::type_identifier_for::<
6197 CompleteMemberDetail,
6198 >(
6199 xidl_typeobject::runtime::TypeEquivalence::Minimal
6200 ),
6201 name: "detail",
6202 },
6203 ],
6204 )
6205 }
6206
6207 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
6208 xidl_typeobject::runtime::build_complete_struct(
6209 "DDS::XTypes::CompleteUnionMember",
6210 0u32,
6211 xidl_typeobject::runtime::type_identifier_none(),
6212 vec![
6213 xidl_typeobject::runtime::StructMemberDesc {
6214 member_id: 1u32,
6215 member_flags: 0u32,
6216 type_id: xidl_typeobject::runtime::type_identifier_for::<
6217 CommonUnionMember,
6218 >(
6219 xidl_typeobject::runtime::TypeEquivalence::Complete
6220 ),
6221 name: "common",
6222 },
6223 xidl_typeobject::runtime::StructMemberDesc {
6224 member_id: 2u32,
6225 member_flags: 0u32,
6226 type_id: xidl_typeobject::runtime::type_identifier_for::<
6227 CompleteMemberDetail,
6228 >(
6229 xidl_typeobject::runtime::TypeEquivalence::Complete
6230 ),
6231 name: "detail",
6232 },
6233 ],
6234 )
6235 }
6236 }
6237 pub type CompleteUnionMemberSeq = Vec<CompleteUnionMember>;
6238 pub struct MinimalUnionMember {
6239 pub common: Box<CommonUnionMember>,
6240
6241 pub detail: Box<MinimalMemberDetail>,
6242 }
6243
6244 impl MinimalUnionMember {
6245 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
6246 }
6247
6248 impl xidl_xcdr::XcdrSerialize for MinimalUnionMember {
6249 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
6250 Self::SERIALIZE_KIND
6251 }
6252
6253 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
6254 &self,
6255 serializer: &mut S,
6256 ) -> xidl_xcdr::error::XcdrResult<()> {
6257 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
6258
6259 serializer.begin_field(xidl_xcdr::FieldId(1u32), false, 0)?;
6260
6261 xidl_xcdr::XcdrSerialize::serialize_with(&self.common, serializer)?;
6262 serializer.end_field()?;
6263
6264 serializer.begin_field(xidl_xcdr::FieldId(2u32), false, 0)?;
6265
6266 xidl_xcdr::XcdrSerialize::serialize_with(&self.detail, serializer)?;
6267 serializer.end_field()?;
6268
6269 serializer.end_struct()?;
6270 Ok(())
6271 }
6272 }
6273
6274 impl xidl_xcdr::XcdrDeserialize for MinimalUnionMember {
6275 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
6276 deserializer: &mut D,
6277 ) -> xidl_xcdr::error::XcdrResult<Self> {
6278 let common = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
6279
6280 let detail = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
6281
6282 Ok(Self { common, detail })
6283 }
6284 }
6285
6286 impl xidl_typeobject::XidlTypeObject for MinimalUnionMember {
6287 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
6288 xidl_typeobject::runtime::build_minimal_struct(
6289 0u32,
6290 xidl_typeobject::runtime::type_identifier_none(),
6291 vec![
6292 xidl_typeobject::runtime::StructMemberDesc {
6293 member_id: 1u32,
6294 member_flags: 0u32,
6295 type_id: xidl_typeobject::runtime::type_identifier_for::<
6296 CommonUnionMember,
6297 >(
6298 xidl_typeobject::runtime::TypeEquivalence::Minimal
6299 ),
6300 name: "common",
6301 },
6302 xidl_typeobject::runtime::StructMemberDesc {
6303 member_id: 2u32,
6304 member_flags: 0u32,
6305 type_id: xidl_typeobject::runtime::type_identifier_for::<
6306 MinimalMemberDetail,
6307 >(
6308 xidl_typeobject::runtime::TypeEquivalence::Minimal
6309 ),
6310 name: "detail",
6311 },
6312 ],
6313 )
6314 }
6315
6316 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
6317 xidl_typeobject::runtime::build_complete_struct(
6318 "DDS::XTypes::MinimalUnionMember",
6319 0u32,
6320 xidl_typeobject::runtime::type_identifier_none(),
6321 vec![
6322 xidl_typeobject::runtime::StructMemberDesc {
6323 member_id: 1u32,
6324 member_flags: 0u32,
6325 type_id: xidl_typeobject::runtime::type_identifier_for::<
6326 CommonUnionMember,
6327 >(
6328 xidl_typeobject::runtime::TypeEquivalence::Complete
6329 ),
6330 name: "common",
6331 },
6332 xidl_typeobject::runtime::StructMemberDesc {
6333 member_id: 2u32,
6334 member_flags: 0u32,
6335 type_id: xidl_typeobject::runtime::type_identifier_for::<
6336 MinimalMemberDetail,
6337 >(
6338 xidl_typeobject::runtime::TypeEquivalence::Complete
6339 ),
6340 name: "detail",
6341 },
6342 ],
6343 )
6344 }
6345 }
6346 pub type MinimalUnionMemberSeq = Vec<MinimalUnionMember>;
6347 pub struct CommonDiscriminatorMember {
6348 pub member_flags: Box<UnionDiscriminatorFlag>,
6349
6350 pub type_id: Box<TypeIdentifier>,
6351 }
6352
6353 impl CommonDiscriminatorMember {
6354 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
6355 }
6356
6357 impl xidl_xcdr::XcdrSerialize for CommonDiscriminatorMember {
6358 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
6359 Self::SERIALIZE_KIND
6360 }
6361
6362 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
6363 &self,
6364 serializer: &mut S,
6365 ) -> xidl_xcdr::error::XcdrResult<()> {
6366 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
6367
6368 serializer.begin_field(xidl_xcdr::FieldId(1u32), false, 0)?;
6369
6370 xidl_xcdr::XcdrSerialize::serialize_with(&self.member_flags, serializer)?;
6371 serializer.end_field()?;
6372
6373 serializer.begin_field(xidl_xcdr::FieldId(2u32), false, 0)?;
6374
6375 xidl_xcdr::XcdrSerialize::serialize_with(&self.type_id, serializer)?;
6376 serializer.end_field()?;
6377
6378 serializer.end_struct()?;
6379 Ok(())
6380 }
6381 }
6382
6383 impl xidl_xcdr::XcdrDeserialize for CommonDiscriminatorMember {
6384 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
6385 deserializer: &mut D,
6386 ) -> xidl_xcdr::error::XcdrResult<Self> {
6387 let member_flags = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
6388
6389 let type_id = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
6390
6391 Ok(Self {
6392 member_flags,
6393
6394 type_id,
6395 })
6396 }
6397 }
6398
6399 impl xidl_typeobject::XidlTypeObject for CommonDiscriminatorMember {
6400 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
6401 xidl_typeobject::runtime::build_minimal_struct(
6402 0u32,
6403 xidl_typeobject::runtime::type_identifier_none(),
6404 vec![
6405 xidl_typeobject::runtime::StructMemberDesc {
6406 member_id: 1u32,
6407 member_flags: 0u32,
6408 type_id: xidl_typeobject::runtime::type_identifier_for::<
6409 UnionDiscriminatorFlag,
6410 >(
6411 xidl_typeobject::runtime::TypeEquivalence::Minimal
6412 ),
6413 name: "member_flags",
6414 },
6415 xidl_typeobject::runtime::StructMemberDesc {
6416 member_id: 2u32,
6417 member_flags: 0u32,
6418 type_id: xidl_typeobject::runtime::type_identifier_for::<TypeIdentifier>(
6419 xidl_typeobject::runtime::TypeEquivalence::Minimal,
6420 ),
6421 name: "type_id",
6422 },
6423 ],
6424 )
6425 }
6426
6427 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
6428 xidl_typeobject::runtime::build_complete_struct(
6429 "DDS::XTypes::CommonDiscriminatorMember",
6430 0u32,
6431 xidl_typeobject::runtime::type_identifier_none(),
6432 vec![
6433 xidl_typeobject::runtime::StructMemberDesc {
6434 member_id: 1u32,
6435 member_flags: 0u32,
6436 type_id: xidl_typeobject::runtime::type_identifier_for::<
6437 UnionDiscriminatorFlag,
6438 >(
6439 xidl_typeobject::runtime::TypeEquivalence::Complete
6440 ),
6441 name: "member_flags",
6442 },
6443 xidl_typeobject::runtime::StructMemberDesc {
6444 member_id: 2u32,
6445 member_flags: 0u32,
6446 type_id: xidl_typeobject::runtime::type_identifier_for::<TypeIdentifier>(
6447 xidl_typeobject::runtime::TypeEquivalence::Complete,
6448 ),
6449 name: "type_id",
6450 },
6451 ],
6452 )
6453 }
6454 }
6455 pub struct CompleteDiscriminatorMember {
6456 pub common: Box<CommonDiscriminatorMember>,
6457
6458 pub ann_builtin: Box<AppliedBuiltinTypeAnnotations>,
6459
6460 pub ann_custom: Box<AppliedAnnotationSeq>,
6461 }
6462
6463 impl CompleteDiscriminatorMember {
6464 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
6465 }
6466
6467 impl xidl_xcdr::XcdrSerialize for CompleteDiscriminatorMember {
6468 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
6469 Self::SERIALIZE_KIND
6470 }
6471
6472 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
6473 &self,
6474 serializer: &mut S,
6475 ) -> xidl_xcdr::error::XcdrResult<()> {
6476 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
6477
6478 serializer.begin_field(xidl_xcdr::FieldId(1u32), false, 0)?;
6479
6480 xidl_xcdr::XcdrSerialize::serialize_with(&self.common, serializer)?;
6481 serializer.end_field()?;
6482
6483 serializer.begin_field(xidl_xcdr::FieldId(2u32), false, 0)?;
6484
6485 xidl_xcdr::XcdrSerialize::serialize_with(&self.ann_builtin, serializer)?;
6486 serializer.end_field()?;
6487
6488 serializer.begin_field(xidl_xcdr::FieldId(3u32), false, 0)?;
6489
6490 xidl_xcdr::XcdrSerialize::serialize_with(&self.ann_custom, serializer)?;
6491 serializer.end_field()?;
6492
6493 serializer.end_struct()?;
6494 Ok(())
6495 }
6496 }
6497
6498 impl xidl_xcdr::XcdrDeserialize for CompleteDiscriminatorMember {
6499 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
6500 deserializer: &mut D,
6501 ) -> xidl_xcdr::error::XcdrResult<Self> {
6502 let common = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
6503
6504 let ann_builtin = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
6505
6506 let ann_custom = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
6507
6508 Ok(Self {
6509 common,
6510
6511 ann_builtin,
6512
6513 ann_custom,
6514 })
6515 }
6516 }
6517
6518 impl xidl_typeobject::XidlTypeObject for CompleteDiscriminatorMember {
6519 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
6520 xidl_typeobject::runtime::build_minimal_struct(
6521 0u32,
6522 xidl_typeobject::runtime::type_identifier_none(),
6523 vec![
6524 xidl_typeobject::runtime::StructMemberDesc {
6525 member_id: 1u32,
6526 member_flags: 0u32,
6527 type_id: xidl_typeobject::runtime::type_identifier_for::<
6528 CommonDiscriminatorMember,
6529 >(
6530 xidl_typeobject::runtime::TypeEquivalence::Minimal
6531 ),
6532 name: "common",
6533 },
6534 xidl_typeobject::runtime::StructMemberDesc {
6535 member_id: 2u32,
6536 member_flags: 0u32,
6537 type_id: xidl_typeobject::runtime::type_identifier_for::<
6538 AppliedBuiltinTypeAnnotations,
6539 >(
6540 xidl_typeobject::runtime::TypeEquivalence::Minimal
6541 ),
6542 name: "ann_builtin",
6543 },
6544 xidl_typeobject::runtime::StructMemberDesc {
6545 member_id: 3u32,
6546 member_flags: 0u32,
6547 type_id: xidl_typeobject::runtime::type_identifier_for::<
6548 AppliedAnnotationSeq,
6549 >(
6550 xidl_typeobject::runtime::TypeEquivalence::Minimal
6551 ),
6552 name: "ann_custom",
6553 },
6554 ],
6555 )
6556 }
6557
6558 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
6559 xidl_typeobject::runtime::build_complete_struct(
6560 "DDS::XTypes::CompleteDiscriminatorMember",
6561 0u32,
6562 xidl_typeobject::runtime::type_identifier_none(),
6563 vec![
6564 xidl_typeobject::runtime::StructMemberDesc {
6565 member_id: 1u32,
6566 member_flags: 0u32,
6567 type_id: xidl_typeobject::runtime::type_identifier_for::<
6568 CommonDiscriminatorMember,
6569 >(
6570 xidl_typeobject::runtime::TypeEquivalence::Complete
6571 ),
6572 name: "common",
6573 },
6574 xidl_typeobject::runtime::StructMemberDesc {
6575 member_id: 2u32,
6576 member_flags: 0u32,
6577 type_id: xidl_typeobject::runtime::type_identifier_for::<
6578 AppliedBuiltinTypeAnnotations,
6579 >(
6580 xidl_typeobject::runtime::TypeEquivalence::Complete
6581 ),
6582 name: "ann_builtin",
6583 },
6584 xidl_typeobject::runtime::StructMemberDesc {
6585 member_id: 3u32,
6586 member_flags: 0u32,
6587 type_id: xidl_typeobject::runtime::type_identifier_for::<
6588 AppliedAnnotationSeq,
6589 >(
6590 xidl_typeobject::runtime::TypeEquivalence::Complete
6591 ),
6592 name: "ann_custom",
6593 },
6594 ],
6595 )
6596 }
6597 }
6598 pub struct MinimalDiscriminatorMember {
6599 pub common: Box<CommonDiscriminatorMember>,
6600 }
6601
6602 impl MinimalDiscriminatorMember {
6603 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
6604 }
6605
6606 impl xidl_xcdr::XcdrSerialize for MinimalDiscriminatorMember {
6607 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
6608 Self::SERIALIZE_KIND
6609 }
6610
6611 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
6612 &self,
6613 serializer: &mut S,
6614 ) -> xidl_xcdr::error::XcdrResult<()> {
6615 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
6616
6617 serializer.begin_field(xidl_xcdr::FieldId(1u32), false, 0)?;
6618
6619 xidl_xcdr::XcdrSerialize::serialize_with(&self.common, serializer)?;
6620 serializer.end_field()?;
6621
6622 serializer.end_struct()?;
6623 Ok(())
6624 }
6625 }
6626
6627 impl xidl_xcdr::XcdrDeserialize for MinimalDiscriminatorMember {
6628 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
6629 deserializer: &mut D,
6630 ) -> xidl_xcdr::error::XcdrResult<Self> {
6631 let common = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
6632
6633 Ok(Self { common })
6634 }
6635 }
6636
6637 impl xidl_typeobject::XidlTypeObject for MinimalDiscriminatorMember {
6638 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
6639 xidl_typeobject::runtime::build_minimal_struct(
6640 0u32,
6641 xidl_typeobject::runtime::type_identifier_none(),
6642 vec![xidl_typeobject::runtime::StructMemberDesc {
6643 member_id: 1u32,
6644 member_flags: 0u32,
6645 type_id: xidl_typeobject::runtime::type_identifier_for::<
6646 CommonDiscriminatorMember,
6647 >(
6648 xidl_typeobject::runtime::TypeEquivalence::Minimal
6649 ),
6650 name: "common",
6651 }],
6652 )
6653 }
6654
6655 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
6656 xidl_typeobject::runtime::build_complete_struct(
6657 "DDS::XTypes::MinimalDiscriminatorMember",
6658 0u32,
6659 xidl_typeobject::runtime::type_identifier_none(),
6660 vec![xidl_typeobject::runtime::StructMemberDesc {
6661 member_id: 1u32,
6662 member_flags: 0u32,
6663 type_id: xidl_typeobject::runtime::type_identifier_for::<
6664 CommonDiscriminatorMember,
6665 >(
6666 xidl_typeobject::runtime::TypeEquivalence::Complete
6667 ),
6668 name: "common",
6669 }],
6670 )
6671 }
6672 }
6673 pub struct CompleteUnionHeader {
6674 pub detail: Box<CompleteTypeDetail>,
6675 }
6676
6677 impl CompleteUnionHeader {
6678 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
6679 }
6680
6681 impl xidl_xcdr::XcdrSerialize for CompleteUnionHeader {
6682 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
6683 Self::SERIALIZE_KIND
6684 }
6685
6686 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
6687 &self,
6688 serializer: &mut S,
6689 ) -> xidl_xcdr::error::XcdrResult<()> {
6690 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
6691
6692 serializer.begin_field(xidl_xcdr::FieldId(1u32), false, 0)?;
6693
6694 xidl_xcdr::XcdrSerialize::serialize_with(&self.detail, serializer)?;
6695 serializer.end_field()?;
6696
6697 serializer.end_struct()?;
6698 Ok(())
6699 }
6700 }
6701
6702 impl xidl_xcdr::XcdrDeserialize for CompleteUnionHeader {
6703 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
6704 deserializer: &mut D,
6705 ) -> xidl_xcdr::error::XcdrResult<Self> {
6706 let detail = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
6707
6708 Ok(Self { detail })
6709 }
6710 }
6711
6712 impl xidl_typeobject::XidlTypeObject for CompleteUnionHeader {
6713 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
6714 xidl_typeobject::runtime::build_minimal_struct(
6715 0u32,
6716 xidl_typeobject::runtime::type_identifier_none(),
6717 vec![xidl_typeobject::runtime::StructMemberDesc {
6718 member_id: 1u32,
6719 member_flags: 0u32,
6720 type_id: xidl_typeobject::runtime::type_identifier_for::<CompleteTypeDetail>(
6721 xidl_typeobject::runtime::TypeEquivalence::Minimal,
6722 ),
6723 name: "detail",
6724 }],
6725 )
6726 }
6727
6728 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
6729 xidl_typeobject::runtime::build_complete_struct(
6730 "DDS::XTypes::CompleteUnionHeader",
6731 0u32,
6732 xidl_typeobject::runtime::type_identifier_none(),
6733 vec![xidl_typeobject::runtime::StructMemberDesc {
6734 member_id: 1u32,
6735 member_flags: 0u32,
6736 type_id: xidl_typeobject::runtime::type_identifier_for::<CompleteTypeDetail>(
6737 xidl_typeobject::runtime::TypeEquivalence::Complete,
6738 ),
6739 name: "detail",
6740 }],
6741 )
6742 }
6743 }
6744 pub struct MinimalUnionHeader {
6745 pub detail: Box<MinimalTypeDetail>,
6746 }
6747
6748 impl MinimalUnionHeader {
6749 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
6750 }
6751
6752 impl xidl_xcdr::XcdrSerialize for MinimalUnionHeader {
6753 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
6754 Self::SERIALIZE_KIND
6755 }
6756
6757 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
6758 &self,
6759 serializer: &mut S,
6760 ) -> xidl_xcdr::error::XcdrResult<()> {
6761 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
6762
6763 serializer.begin_field(xidl_xcdr::FieldId(1u32), false, 0)?;
6764
6765 xidl_xcdr::XcdrSerialize::serialize_with(&self.detail, serializer)?;
6766 serializer.end_field()?;
6767
6768 serializer.end_struct()?;
6769 Ok(())
6770 }
6771 }
6772
6773 impl xidl_xcdr::XcdrDeserialize for MinimalUnionHeader {
6774 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
6775 deserializer: &mut D,
6776 ) -> xidl_xcdr::error::XcdrResult<Self> {
6777 let detail = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
6778
6779 Ok(Self { detail })
6780 }
6781 }
6782
6783 impl xidl_typeobject::XidlTypeObject for MinimalUnionHeader {
6784 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
6785 xidl_typeobject::runtime::build_minimal_struct(
6786 0u32,
6787 xidl_typeobject::runtime::type_identifier_none(),
6788 vec![xidl_typeobject::runtime::StructMemberDesc {
6789 member_id: 1u32,
6790 member_flags: 0u32,
6791 type_id: xidl_typeobject::runtime::type_identifier_for::<MinimalTypeDetail>(
6792 xidl_typeobject::runtime::TypeEquivalence::Minimal,
6793 ),
6794 name: "detail",
6795 }],
6796 )
6797 }
6798
6799 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
6800 xidl_typeobject::runtime::build_complete_struct(
6801 "DDS::XTypes::MinimalUnionHeader",
6802 0u32,
6803 xidl_typeobject::runtime::type_identifier_none(),
6804 vec![xidl_typeobject::runtime::StructMemberDesc {
6805 member_id: 1u32,
6806 member_flags: 0u32,
6807 type_id: xidl_typeobject::runtime::type_identifier_for::<MinimalTypeDetail>(
6808 xidl_typeobject::runtime::TypeEquivalence::Complete,
6809 ),
6810 name: "detail",
6811 }],
6812 )
6813 }
6814 }
6815 pub struct CompleteUnionType {
6816 pub union_flags: Box<UnionTypeFlag>,
6817
6818 pub header: Box<CompleteUnionHeader>,
6819
6820 pub discriminator: Box<CompleteDiscriminatorMember>,
6821
6822 pub member_seq: Box<CompleteUnionMemberSeq>,
6823 }
6824
6825 impl CompleteUnionType {
6826 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
6827 }
6828
6829 impl xidl_xcdr::XcdrSerialize for CompleteUnionType {
6830 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
6831 Self::SERIALIZE_KIND
6832 }
6833
6834 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
6835 &self,
6836 serializer: &mut S,
6837 ) -> xidl_xcdr::error::XcdrResult<()> {
6838 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
6839
6840 serializer.begin_field(xidl_xcdr::FieldId(1u32), false, 0)?;
6841
6842 xidl_xcdr::XcdrSerialize::serialize_with(&self.union_flags, serializer)?;
6843 serializer.end_field()?;
6844
6845 serializer.begin_field(xidl_xcdr::FieldId(2u32), false, 0)?;
6846
6847 xidl_xcdr::XcdrSerialize::serialize_with(&self.header, serializer)?;
6848 serializer.end_field()?;
6849
6850 serializer.begin_field(xidl_xcdr::FieldId(3u32), false, 0)?;
6851
6852 xidl_xcdr::XcdrSerialize::serialize_with(&self.discriminator, serializer)?;
6853 serializer.end_field()?;
6854
6855 serializer.begin_field(xidl_xcdr::FieldId(4u32), false, 0)?;
6856
6857 xidl_xcdr::XcdrSerialize::serialize_with(&self.member_seq, serializer)?;
6858 serializer.end_field()?;
6859
6860 serializer.end_struct()?;
6861 Ok(())
6862 }
6863 }
6864
6865 impl xidl_xcdr::XcdrDeserialize for CompleteUnionType {
6866 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
6867 deserializer: &mut D,
6868 ) -> xidl_xcdr::error::XcdrResult<Self> {
6869 let union_flags = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
6870
6871 let header = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
6872
6873 let discriminator = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
6874
6875 let member_seq = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
6876
6877 Ok(Self {
6878 union_flags,
6879
6880 header,
6881
6882 discriminator,
6883
6884 member_seq,
6885 })
6886 }
6887 }
6888
6889 impl xidl_typeobject::XidlTypeObject for CompleteUnionType {
6890 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
6891 xidl_typeobject::runtime::build_minimal_struct(
6892 0u32,
6893 xidl_typeobject::runtime::type_identifier_none(),
6894 vec![
6895 xidl_typeobject::runtime::StructMemberDesc {
6896 member_id: 1u32,
6897 member_flags: 0u32,
6898 type_id: xidl_typeobject::runtime::type_identifier_for::<UnionTypeFlag>(
6899 xidl_typeobject::runtime::TypeEquivalence::Minimal,
6900 ),
6901 name: "union_flags",
6902 },
6903 xidl_typeobject::runtime::StructMemberDesc {
6904 member_id: 2u32,
6905 member_flags: 0u32,
6906 type_id: xidl_typeobject::runtime::type_identifier_for::<
6907 CompleteUnionHeader,
6908 >(
6909 xidl_typeobject::runtime::TypeEquivalence::Minimal
6910 ),
6911 name: "header",
6912 },
6913 xidl_typeobject::runtime::StructMemberDesc {
6914 member_id: 3u32,
6915 member_flags: 0u32,
6916 type_id: xidl_typeobject::runtime::type_identifier_for::<
6917 CompleteDiscriminatorMember,
6918 >(
6919 xidl_typeobject::runtime::TypeEquivalence::Minimal
6920 ),
6921 name: "discriminator",
6922 },
6923 xidl_typeobject::runtime::StructMemberDesc {
6924 member_id: 4u32,
6925 member_flags: 0u32,
6926 type_id: xidl_typeobject::runtime::type_identifier_for::<
6927 CompleteUnionMemberSeq,
6928 >(
6929 xidl_typeobject::runtime::TypeEquivalence::Minimal
6930 ),
6931 name: "member_seq",
6932 },
6933 ],
6934 )
6935 }
6936
6937 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
6938 xidl_typeobject::runtime::build_complete_struct(
6939 "DDS::XTypes::CompleteUnionType",
6940 0u32,
6941 xidl_typeobject::runtime::type_identifier_none(),
6942 vec![
6943 xidl_typeobject::runtime::StructMemberDesc {
6944 member_id: 1u32,
6945 member_flags: 0u32,
6946 type_id: xidl_typeobject::runtime::type_identifier_for::<UnionTypeFlag>(
6947 xidl_typeobject::runtime::TypeEquivalence::Complete,
6948 ),
6949 name: "union_flags",
6950 },
6951 xidl_typeobject::runtime::StructMemberDesc {
6952 member_id: 2u32,
6953 member_flags: 0u32,
6954 type_id: xidl_typeobject::runtime::type_identifier_for::<
6955 CompleteUnionHeader,
6956 >(
6957 xidl_typeobject::runtime::TypeEquivalence::Complete
6958 ),
6959 name: "header",
6960 },
6961 xidl_typeobject::runtime::StructMemberDesc {
6962 member_id: 3u32,
6963 member_flags: 0u32,
6964 type_id: xidl_typeobject::runtime::type_identifier_for::<
6965 CompleteDiscriminatorMember,
6966 >(
6967 xidl_typeobject::runtime::TypeEquivalence::Complete
6968 ),
6969 name: "discriminator",
6970 },
6971 xidl_typeobject::runtime::StructMemberDesc {
6972 member_id: 4u32,
6973 member_flags: 0u32,
6974 type_id: xidl_typeobject::runtime::type_identifier_for::<
6975 CompleteUnionMemberSeq,
6976 >(
6977 xidl_typeobject::runtime::TypeEquivalence::Complete
6978 ),
6979 name: "member_seq",
6980 },
6981 ],
6982 )
6983 }
6984 }
6985 pub struct MinimalUnionType {
6986 pub union_flags: Box<UnionTypeFlag>,
6987
6988 pub header: Box<MinimalUnionHeader>,
6989
6990 pub discriminator: Box<MinimalDiscriminatorMember>,
6991
6992 pub member_seq: Box<MinimalUnionMemberSeq>,
6993 }
6994
6995 impl MinimalUnionType {
6996 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
6997 }
6998
6999 impl xidl_xcdr::XcdrSerialize for MinimalUnionType {
7000 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
7001 Self::SERIALIZE_KIND
7002 }
7003
7004 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
7005 &self,
7006 serializer: &mut S,
7007 ) -> xidl_xcdr::error::XcdrResult<()> {
7008 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
7009
7010 serializer.begin_field(xidl_xcdr::FieldId(1u32), false, 0)?;
7011
7012 xidl_xcdr::XcdrSerialize::serialize_with(&self.union_flags, serializer)?;
7013 serializer.end_field()?;
7014
7015 serializer.begin_field(xidl_xcdr::FieldId(2u32), false, 0)?;
7016
7017 xidl_xcdr::XcdrSerialize::serialize_with(&self.header, serializer)?;
7018 serializer.end_field()?;
7019
7020 serializer.begin_field(xidl_xcdr::FieldId(3u32), false, 0)?;
7021
7022 xidl_xcdr::XcdrSerialize::serialize_with(&self.discriminator, serializer)?;
7023 serializer.end_field()?;
7024
7025 serializer.begin_field(xidl_xcdr::FieldId(4u32), false, 0)?;
7026
7027 xidl_xcdr::XcdrSerialize::serialize_with(&self.member_seq, serializer)?;
7028 serializer.end_field()?;
7029
7030 serializer.end_struct()?;
7031 Ok(())
7032 }
7033 }
7034
7035 impl xidl_xcdr::XcdrDeserialize for MinimalUnionType {
7036 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
7037 deserializer: &mut D,
7038 ) -> xidl_xcdr::error::XcdrResult<Self> {
7039 let union_flags = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
7040
7041 let header = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
7042
7043 let discriminator = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
7044
7045 let member_seq = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
7046
7047 Ok(Self {
7048 union_flags,
7049
7050 header,
7051
7052 discriminator,
7053
7054 member_seq,
7055 })
7056 }
7057 }
7058
7059 impl xidl_typeobject::XidlTypeObject for MinimalUnionType {
7060 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
7061 xidl_typeobject::runtime::build_minimal_struct(
7062 0u32,
7063 xidl_typeobject::runtime::type_identifier_none(),
7064 vec![
7065 xidl_typeobject::runtime::StructMemberDesc {
7066 member_id: 1u32,
7067 member_flags: 0u32,
7068 type_id: xidl_typeobject::runtime::type_identifier_for::<UnionTypeFlag>(
7069 xidl_typeobject::runtime::TypeEquivalence::Minimal,
7070 ),
7071 name: "union_flags",
7072 },
7073 xidl_typeobject::runtime::StructMemberDesc {
7074 member_id: 2u32,
7075 member_flags: 0u32,
7076 type_id: xidl_typeobject::runtime::type_identifier_for::<
7077 MinimalUnionHeader,
7078 >(
7079 xidl_typeobject::runtime::TypeEquivalence::Minimal
7080 ),
7081 name: "header",
7082 },
7083 xidl_typeobject::runtime::StructMemberDesc {
7084 member_id: 3u32,
7085 member_flags: 0u32,
7086 type_id: xidl_typeobject::runtime::type_identifier_for::<
7087 MinimalDiscriminatorMember,
7088 >(
7089 xidl_typeobject::runtime::TypeEquivalence::Minimal
7090 ),
7091 name: "discriminator",
7092 },
7093 xidl_typeobject::runtime::StructMemberDesc {
7094 member_id: 4u32,
7095 member_flags: 0u32,
7096 type_id: xidl_typeobject::runtime::type_identifier_for::<
7097 MinimalUnionMemberSeq,
7098 >(
7099 xidl_typeobject::runtime::TypeEquivalence::Minimal
7100 ),
7101 name: "member_seq",
7102 },
7103 ],
7104 )
7105 }
7106
7107 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
7108 xidl_typeobject::runtime::build_complete_struct(
7109 "DDS::XTypes::MinimalUnionType",
7110 0u32,
7111 xidl_typeobject::runtime::type_identifier_none(),
7112 vec![
7113 xidl_typeobject::runtime::StructMemberDesc {
7114 member_id: 1u32,
7115 member_flags: 0u32,
7116 type_id: xidl_typeobject::runtime::type_identifier_for::<UnionTypeFlag>(
7117 xidl_typeobject::runtime::TypeEquivalence::Complete,
7118 ),
7119 name: "union_flags",
7120 },
7121 xidl_typeobject::runtime::StructMemberDesc {
7122 member_id: 2u32,
7123 member_flags: 0u32,
7124 type_id: xidl_typeobject::runtime::type_identifier_for::<
7125 MinimalUnionHeader,
7126 >(
7127 xidl_typeobject::runtime::TypeEquivalence::Complete
7128 ),
7129 name: "header",
7130 },
7131 xidl_typeobject::runtime::StructMemberDesc {
7132 member_id: 3u32,
7133 member_flags: 0u32,
7134 type_id: xidl_typeobject::runtime::type_identifier_for::<
7135 MinimalDiscriminatorMember,
7136 >(
7137 xidl_typeobject::runtime::TypeEquivalence::Complete
7138 ),
7139 name: "discriminator",
7140 },
7141 xidl_typeobject::runtime::StructMemberDesc {
7142 member_id: 4u32,
7143 member_flags: 0u32,
7144 type_id: xidl_typeobject::runtime::type_identifier_for::<
7145 MinimalUnionMemberSeq,
7146 >(
7147 xidl_typeobject::runtime::TypeEquivalence::Complete
7148 ),
7149 name: "member_seq",
7150 },
7151 ],
7152 )
7153 }
7154 }
7155 pub struct CommonAnnotationParameter {
7156 pub member_flags: Box<AnnotationParameterFlag>,
7157
7158 pub member_type_id: Box<TypeIdentifier>,
7159 }
7160
7161 impl CommonAnnotationParameter {
7162 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
7163 }
7164
7165 impl xidl_xcdr::XcdrSerialize for CommonAnnotationParameter {
7166 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
7167 Self::SERIALIZE_KIND
7168 }
7169
7170 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
7171 &self,
7172 serializer: &mut S,
7173 ) -> xidl_xcdr::error::XcdrResult<()> {
7174 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
7175
7176 serializer.begin_field(xidl_xcdr::FieldId(1u32), false, 0)?;
7177
7178 xidl_xcdr::XcdrSerialize::serialize_with(&self.member_flags, serializer)?;
7179 serializer.end_field()?;
7180
7181 serializer.begin_field(xidl_xcdr::FieldId(2u32), false, 0)?;
7182
7183 xidl_xcdr::XcdrSerialize::serialize_with(&self.member_type_id, serializer)?;
7184 serializer.end_field()?;
7185
7186 serializer.end_struct()?;
7187 Ok(())
7188 }
7189 }
7190
7191 impl xidl_xcdr::XcdrDeserialize for CommonAnnotationParameter {
7192 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
7193 deserializer: &mut D,
7194 ) -> xidl_xcdr::error::XcdrResult<Self> {
7195 let member_flags = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
7196
7197 let member_type_id = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
7198
7199 Ok(Self {
7200 member_flags,
7201
7202 member_type_id,
7203 })
7204 }
7205 }
7206
7207 impl xidl_typeobject::XidlTypeObject for CommonAnnotationParameter {
7208 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
7209 xidl_typeobject::runtime::build_minimal_struct(
7210 0u32,
7211 xidl_typeobject::runtime::type_identifier_none(),
7212 vec![
7213 xidl_typeobject::runtime::StructMemberDesc {
7214 member_id: 1u32,
7215 member_flags: 0u32,
7216 type_id: xidl_typeobject::runtime::type_identifier_for::<
7217 AnnotationParameterFlag,
7218 >(
7219 xidl_typeobject::runtime::TypeEquivalence::Minimal
7220 ),
7221 name: "member_flags",
7222 },
7223 xidl_typeobject::runtime::StructMemberDesc {
7224 member_id: 2u32,
7225 member_flags: 0u32,
7226 type_id: xidl_typeobject::runtime::type_identifier_for::<TypeIdentifier>(
7227 xidl_typeobject::runtime::TypeEquivalence::Minimal,
7228 ),
7229 name: "member_type_id",
7230 },
7231 ],
7232 )
7233 }
7234
7235 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
7236 xidl_typeobject::runtime::build_complete_struct(
7237 "DDS::XTypes::CommonAnnotationParameter",
7238 0u32,
7239 xidl_typeobject::runtime::type_identifier_none(),
7240 vec![
7241 xidl_typeobject::runtime::StructMemberDesc {
7242 member_id: 1u32,
7243 member_flags: 0u32,
7244 type_id: xidl_typeobject::runtime::type_identifier_for::<
7245 AnnotationParameterFlag,
7246 >(
7247 xidl_typeobject::runtime::TypeEquivalence::Complete
7248 ),
7249 name: "member_flags",
7250 },
7251 xidl_typeobject::runtime::StructMemberDesc {
7252 member_id: 2u32,
7253 member_flags: 0u32,
7254 type_id: xidl_typeobject::runtime::type_identifier_for::<TypeIdentifier>(
7255 xidl_typeobject::runtime::TypeEquivalence::Complete,
7256 ),
7257 name: "member_type_id",
7258 },
7259 ],
7260 )
7261 }
7262 }
7263 pub struct CompleteAnnotationParameter {
7264 pub common: Box<CommonAnnotationParameter>,
7265
7266 pub name: Box<MemberName>,
7267
7268 pub default_value: Box<AnnotationParameterValue>,
7269 }
7270
7271 impl CompleteAnnotationParameter {
7272 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
7273 }
7274
7275 impl xidl_xcdr::XcdrSerialize for CompleteAnnotationParameter {
7276 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
7277 Self::SERIALIZE_KIND
7278 }
7279
7280 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
7281 &self,
7282 serializer: &mut S,
7283 ) -> xidl_xcdr::error::XcdrResult<()> {
7284 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
7285
7286 serializer.begin_field(xidl_xcdr::FieldId(1u32), false, 0)?;
7287
7288 xidl_xcdr::XcdrSerialize::serialize_with(&self.common, serializer)?;
7289 serializer.end_field()?;
7290
7291 serializer.begin_field(xidl_xcdr::FieldId(2u32), false, 0)?;
7292
7293 xidl_xcdr::XcdrSerialize::serialize_with(&self.name, serializer)?;
7294 serializer.end_field()?;
7295
7296 serializer.begin_field(xidl_xcdr::FieldId(3u32), false, 0)?;
7297
7298 xidl_xcdr::XcdrSerialize::serialize_with(&self.default_value, serializer)?;
7299 serializer.end_field()?;
7300
7301 serializer.end_struct()?;
7302 Ok(())
7303 }
7304 }
7305
7306 impl xidl_xcdr::XcdrDeserialize for CompleteAnnotationParameter {
7307 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
7308 deserializer: &mut D,
7309 ) -> xidl_xcdr::error::XcdrResult<Self> {
7310 let common = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
7311
7312 let name = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
7313
7314 let default_value = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
7315
7316 Ok(Self {
7317 common,
7318
7319 name,
7320
7321 default_value,
7322 })
7323 }
7324 }
7325
7326 impl xidl_typeobject::XidlTypeObject for CompleteAnnotationParameter {
7327 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
7328 xidl_typeobject::runtime::build_minimal_struct(
7329 0u32,
7330 xidl_typeobject::runtime::type_identifier_none(),
7331 vec![
7332 xidl_typeobject::runtime::StructMemberDesc {
7333 member_id: 1u32,
7334 member_flags: 0u32,
7335 type_id: xidl_typeobject::runtime::type_identifier_for::<
7336 CommonAnnotationParameter,
7337 >(
7338 xidl_typeobject::runtime::TypeEquivalence::Minimal
7339 ),
7340 name: "common",
7341 },
7342 xidl_typeobject::runtime::StructMemberDesc {
7343 member_id: 2u32,
7344 member_flags: 0u32,
7345 type_id: xidl_typeobject::runtime::type_identifier_for::<MemberName>(
7346 xidl_typeobject::runtime::TypeEquivalence::Minimal,
7347 ),
7348 name: "name",
7349 },
7350 xidl_typeobject::runtime::StructMemberDesc {
7351 member_id: 3u32,
7352 member_flags: 0u32,
7353 type_id: xidl_typeobject::runtime::type_identifier_for::<
7354 AnnotationParameterValue,
7355 >(
7356 xidl_typeobject::runtime::TypeEquivalence::Minimal
7357 ),
7358 name: "default_value",
7359 },
7360 ],
7361 )
7362 }
7363
7364 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
7365 xidl_typeobject::runtime::build_complete_struct(
7366 "DDS::XTypes::CompleteAnnotationParameter",
7367 0u32,
7368 xidl_typeobject::runtime::type_identifier_none(),
7369 vec![
7370 xidl_typeobject::runtime::StructMemberDesc {
7371 member_id: 1u32,
7372 member_flags: 0u32,
7373 type_id: xidl_typeobject::runtime::type_identifier_for::<
7374 CommonAnnotationParameter,
7375 >(
7376 xidl_typeobject::runtime::TypeEquivalence::Complete
7377 ),
7378 name: "common",
7379 },
7380 xidl_typeobject::runtime::StructMemberDesc {
7381 member_id: 2u32,
7382 member_flags: 0u32,
7383 type_id: xidl_typeobject::runtime::type_identifier_for::<MemberName>(
7384 xidl_typeobject::runtime::TypeEquivalence::Complete,
7385 ),
7386 name: "name",
7387 },
7388 xidl_typeobject::runtime::StructMemberDesc {
7389 member_id: 3u32,
7390 member_flags: 0u32,
7391 type_id: xidl_typeobject::runtime::type_identifier_for::<
7392 AnnotationParameterValue,
7393 >(
7394 xidl_typeobject::runtime::TypeEquivalence::Complete
7395 ),
7396 name: "default_value",
7397 },
7398 ],
7399 )
7400 }
7401 }
7402 pub type CompleteAnnotationParameterSeq = Vec<CompleteAnnotationParameter>;
7403 pub struct MinimalAnnotationParameter {
7404 pub common: Box<CommonAnnotationParameter>,
7405
7406 pub name_hash: Box<NameHash>,
7407
7408 pub default_value: Box<AnnotationParameterValue>,
7409 }
7410
7411 impl MinimalAnnotationParameter {
7412 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
7413 }
7414
7415 impl xidl_xcdr::XcdrSerialize for MinimalAnnotationParameter {
7416 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
7417 Self::SERIALIZE_KIND
7418 }
7419
7420 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
7421 &self,
7422 serializer: &mut S,
7423 ) -> xidl_xcdr::error::XcdrResult<()> {
7424 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
7425
7426 serializer.begin_field(xidl_xcdr::FieldId(1u32), false, 0)?;
7427
7428 xidl_xcdr::XcdrSerialize::serialize_with(&self.common, serializer)?;
7429 serializer.end_field()?;
7430
7431 serializer.begin_field(xidl_xcdr::FieldId(2u32), false, 0)?;
7432
7433 xidl_xcdr::XcdrSerialize::serialize_with(&self.name_hash, serializer)?;
7434 serializer.end_field()?;
7435
7436 serializer.begin_field(xidl_xcdr::FieldId(3u32), false, 0)?;
7437
7438 xidl_xcdr::XcdrSerialize::serialize_with(&self.default_value, serializer)?;
7439 serializer.end_field()?;
7440
7441 serializer.end_struct()?;
7442 Ok(())
7443 }
7444 }
7445
7446 impl xidl_xcdr::XcdrDeserialize for MinimalAnnotationParameter {
7447 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
7448 deserializer: &mut D,
7449 ) -> xidl_xcdr::error::XcdrResult<Self> {
7450 let common = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
7451
7452 let name_hash = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
7453
7454 let default_value = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
7455
7456 Ok(Self {
7457 common,
7458
7459 name_hash,
7460
7461 default_value,
7462 })
7463 }
7464 }
7465
7466 impl xidl_typeobject::XidlTypeObject for MinimalAnnotationParameter {
7467 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
7468 xidl_typeobject::runtime::build_minimal_struct(
7469 0u32,
7470 xidl_typeobject::runtime::type_identifier_none(),
7471 vec![
7472 xidl_typeobject::runtime::StructMemberDesc {
7473 member_id: 1u32,
7474 member_flags: 0u32,
7475 type_id: xidl_typeobject::runtime::type_identifier_for::<
7476 CommonAnnotationParameter,
7477 >(
7478 xidl_typeobject::runtime::TypeEquivalence::Minimal
7479 ),
7480 name: "common",
7481 },
7482 xidl_typeobject::runtime::StructMemberDesc {
7483 member_id: 2u32,
7484 member_flags: 0u32,
7485 type_id: xidl_typeobject::runtime::type_identifier_for::<NameHash>(
7486 xidl_typeobject::runtime::TypeEquivalence::Minimal,
7487 ),
7488 name: "name_hash",
7489 },
7490 xidl_typeobject::runtime::StructMemberDesc {
7491 member_id: 3u32,
7492 member_flags: 0u32,
7493 type_id: xidl_typeobject::runtime::type_identifier_for::<
7494 AnnotationParameterValue,
7495 >(
7496 xidl_typeobject::runtime::TypeEquivalence::Minimal
7497 ),
7498 name: "default_value",
7499 },
7500 ],
7501 )
7502 }
7503
7504 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
7505 xidl_typeobject::runtime::build_complete_struct(
7506 "DDS::XTypes::MinimalAnnotationParameter",
7507 0u32,
7508 xidl_typeobject::runtime::type_identifier_none(),
7509 vec![
7510 xidl_typeobject::runtime::StructMemberDesc {
7511 member_id: 1u32,
7512 member_flags: 0u32,
7513 type_id: xidl_typeobject::runtime::type_identifier_for::<
7514 CommonAnnotationParameter,
7515 >(
7516 xidl_typeobject::runtime::TypeEquivalence::Complete
7517 ),
7518 name: "common",
7519 },
7520 xidl_typeobject::runtime::StructMemberDesc {
7521 member_id: 2u32,
7522 member_flags: 0u32,
7523 type_id: xidl_typeobject::runtime::type_identifier_for::<NameHash>(
7524 xidl_typeobject::runtime::TypeEquivalence::Complete,
7525 ),
7526 name: "name_hash",
7527 },
7528 xidl_typeobject::runtime::StructMemberDesc {
7529 member_id: 3u32,
7530 member_flags: 0u32,
7531 type_id: xidl_typeobject::runtime::type_identifier_for::<
7532 AnnotationParameterValue,
7533 >(
7534 xidl_typeobject::runtime::TypeEquivalence::Complete
7535 ),
7536 name: "default_value",
7537 },
7538 ],
7539 )
7540 }
7541 }
7542 pub type MinimalAnnotationParameterSeq = Vec<MinimalAnnotationParameter>;
7543 pub struct CompleteAnnotationHeader {
7544 pub annotation_name: Box<QualifiedTypeName>,
7545 }
7546
7547 impl CompleteAnnotationHeader {
7548 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
7549 }
7550
7551 impl xidl_xcdr::XcdrSerialize for CompleteAnnotationHeader {
7552 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
7553 Self::SERIALIZE_KIND
7554 }
7555
7556 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
7557 &self,
7558 serializer: &mut S,
7559 ) -> xidl_xcdr::error::XcdrResult<()> {
7560 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
7561
7562 serializer.begin_field(xidl_xcdr::FieldId(1u32), false, 0)?;
7563
7564 xidl_xcdr::XcdrSerialize::serialize_with(&self.annotation_name, serializer)?;
7565 serializer.end_field()?;
7566
7567 serializer.end_struct()?;
7568 Ok(())
7569 }
7570 }
7571
7572 impl xidl_xcdr::XcdrDeserialize for CompleteAnnotationHeader {
7573 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
7574 deserializer: &mut D,
7575 ) -> xidl_xcdr::error::XcdrResult<Self> {
7576 let annotation_name = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
7577
7578 Ok(Self { annotation_name })
7579 }
7580 }
7581
7582 impl xidl_typeobject::XidlTypeObject for CompleteAnnotationHeader {
7583 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
7584 xidl_typeobject::runtime::build_minimal_struct(
7585 0u32,
7586 xidl_typeobject::runtime::type_identifier_none(),
7587 vec![xidl_typeobject::runtime::StructMemberDesc {
7588 member_id: 1u32,
7589 member_flags: 0u32,
7590 type_id: xidl_typeobject::runtime::type_identifier_for::<QualifiedTypeName>(
7591 xidl_typeobject::runtime::TypeEquivalence::Minimal,
7592 ),
7593 name: "annotation_name",
7594 }],
7595 )
7596 }
7597
7598 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
7599 xidl_typeobject::runtime::build_complete_struct(
7600 "DDS::XTypes::CompleteAnnotationHeader",
7601 0u32,
7602 xidl_typeobject::runtime::type_identifier_none(),
7603 vec![xidl_typeobject::runtime::StructMemberDesc {
7604 member_id: 1u32,
7605 member_flags: 0u32,
7606 type_id: xidl_typeobject::runtime::type_identifier_for::<QualifiedTypeName>(
7607 xidl_typeobject::runtime::TypeEquivalence::Complete,
7608 ),
7609 name: "annotation_name",
7610 }],
7611 )
7612 }
7613 }
7614 pub struct MinimalAnnotationHeader {}
7615
7616 impl MinimalAnnotationHeader {
7617 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
7618 }
7619
7620 impl xidl_xcdr::XcdrSerialize for MinimalAnnotationHeader {
7621 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
7622 Self::SERIALIZE_KIND
7623 }
7624
7625 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
7626 &self,
7627 serializer: &mut S,
7628 ) -> xidl_xcdr::error::XcdrResult<()> {
7629 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
7630
7631 serializer.end_struct()?;
7632 Ok(())
7633 }
7634 }
7635
7636 impl xidl_xcdr::XcdrDeserialize for MinimalAnnotationHeader {
7637 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
7638 deserializer: &mut D,
7639 ) -> xidl_xcdr::error::XcdrResult<Self> {
7640 Ok(Self {})
7641 }
7642 }
7643
7644 impl xidl_typeobject::XidlTypeObject for MinimalAnnotationHeader {
7645 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
7646 xidl_typeobject::runtime::build_minimal_struct(
7647 0u32,
7648 xidl_typeobject::runtime::type_identifier_none(),
7649 vec![],
7650 )
7651 }
7652
7653 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
7654 xidl_typeobject::runtime::build_complete_struct(
7655 "DDS::XTypes::MinimalAnnotationHeader",
7656 0u32,
7657 xidl_typeobject::runtime::type_identifier_none(),
7658 vec![],
7659 )
7660 }
7661 }
7662 pub struct CompleteAnnotationType {
7663 pub annotation_flag: Box<AnnotationTypeFlag>,
7664
7665 pub header: Box<CompleteAnnotationHeader>,
7666
7667 pub member_seq: Box<CompleteAnnotationParameterSeq>,
7668 }
7669
7670 impl CompleteAnnotationType {
7671 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
7672 }
7673
7674 impl xidl_xcdr::XcdrSerialize for CompleteAnnotationType {
7675 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
7676 Self::SERIALIZE_KIND
7677 }
7678
7679 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
7680 &self,
7681 serializer: &mut S,
7682 ) -> xidl_xcdr::error::XcdrResult<()> {
7683 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
7684
7685 serializer.begin_field(xidl_xcdr::FieldId(1u32), false, 0)?;
7686
7687 xidl_xcdr::XcdrSerialize::serialize_with(&self.annotation_flag, serializer)?;
7688 serializer.end_field()?;
7689
7690 serializer.begin_field(xidl_xcdr::FieldId(2u32), false, 0)?;
7691
7692 xidl_xcdr::XcdrSerialize::serialize_with(&self.header, serializer)?;
7693 serializer.end_field()?;
7694
7695 serializer.begin_field(xidl_xcdr::FieldId(3u32), false, 0)?;
7696
7697 xidl_xcdr::XcdrSerialize::serialize_with(&self.member_seq, serializer)?;
7698 serializer.end_field()?;
7699
7700 serializer.end_struct()?;
7701 Ok(())
7702 }
7703 }
7704
7705 impl xidl_xcdr::XcdrDeserialize for CompleteAnnotationType {
7706 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
7707 deserializer: &mut D,
7708 ) -> xidl_xcdr::error::XcdrResult<Self> {
7709 let annotation_flag = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
7710
7711 let header = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
7712
7713 let member_seq = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
7714
7715 Ok(Self {
7716 annotation_flag,
7717
7718 header,
7719
7720 member_seq,
7721 })
7722 }
7723 }
7724
7725 impl xidl_typeobject::XidlTypeObject for CompleteAnnotationType {
7726 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
7727 xidl_typeobject::runtime::build_minimal_struct(
7728 0u32,
7729 xidl_typeobject::runtime::type_identifier_none(),
7730 vec![
7731 xidl_typeobject::runtime::StructMemberDesc {
7732 member_id: 1u32,
7733 member_flags: 0u32,
7734 type_id: xidl_typeobject::runtime::type_identifier_for::<
7735 AnnotationTypeFlag,
7736 >(
7737 xidl_typeobject::runtime::TypeEquivalence::Minimal
7738 ),
7739 name: "annotation_flag",
7740 },
7741 xidl_typeobject::runtime::StructMemberDesc {
7742 member_id: 2u32,
7743 member_flags: 0u32,
7744 type_id: xidl_typeobject::runtime::type_identifier_for::<
7745 CompleteAnnotationHeader,
7746 >(
7747 xidl_typeobject::runtime::TypeEquivalence::Minimal
7748 ),
7749 name: "header",
7750 },
7751 xidl_typeobject::runtime::StructMemberDesc {
7752 member_id: 3u32,
7753 member_flags: 0u32,
7754 type_id: xidl_typeobject::runtime::type_identifier_for::<
7755 CompleteAnnotationParameterSeq,
7756 >(
7757 xidl_typeobject::runtime::TypeEquivalence::Minimal
7758 ),
7759 name: "member_seq",
7760 },
7761 ],
7762 )
7763 }
7764
7765 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
7766 xidl_typeobject::runtime::build_complete_struct(
7767 "DDS::XTypes::CompleteAnnotationType",
7768 0u32,
7769 xidl_typeobject::runtime::type_identifier_none(),
7770 vec![
7771 xidl_typeobject::runtime::StructMemberDesc {
7772 member_id: 1u32,
7773 member_flags: 0u32,
7774 type_id: xidl_typeobject::runtime::type_identifier_for::<
7775 AnnotationTypeFlag,
7776 >(
7777 xidl_typeobject::runtime::TypeEquivalence::Complete
7778 ),
7779 name: "annotation_flag",
7780 },
7781 xidl_typeobject::runtime::StructMemberDesc {
7782 member_id: 2u32,
7783 member_flags: 0u32,
7784 type_id: xidl_typeobject::runtime::type_identifier_for::<
7785 CompleteAnnotationHeader,
7786 >(
7787 xidl_typeobject::runtime::TypeEquivalence::Complete
7788 ),
7789 name: "header",
7790 },
7791 xidl_typeobject::runtime::StructMemberDesc {
7792 member_id: 3u32,
7793 member_flags: 0u32,
7794 type_id: xidl_typeobject::runtime::type_identifier_for::<
7795 CompleteAnnotationParameterSeq,
7796 >(
7797 xidl_typeobject::runtime::TypeEquivalence::Complete
7798 ),
7799 name: "member_seq",
7800 },
7801 ],
7802 )
7803 }
7804 }
7805 pub struct MinimalAnnotationType {
7806 pub annotation_flag: Box<AnnotationTypeFlag>,
7807
7808 pub header: Box<MinimalAnnotationHeader>,
7809
7810 pub member_seq: Box<MinimalAnnotationParameterSeq>,
7811 }
7812
7813 impl MinimalAnnotationType {
7814 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
7815 }
7816
7817 impl xidl_xcdr::XcdrSerialize for MinimalAnnotationType {
7818 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
7819 Self::SERIALIZE_KIND
7820 }
7821
7822 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
7823 &self,
7824 serializer: &mut S,
7825 ) -> xidl_xcdr::error::XcdrResult<()> {
7826 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
7827
7828 serializer.begin_field(xidl_xcdr::FieldId(1u32), false, 0)?;
7829
7830 xidl_xcdr::XcdrSerialize::serialize_with(&self.annotation_flag, serializer)?;
7831 serializer.end_field()?;
7832
7833 serializer.begin_field(xidl_xcdr::FieldId(2u32), false, 0)?;
7834
7835 xidl_xcdr::XcdrSerialize::serialize_with(&self.header, serializer)?;
7836 serializer.end_field()?;
7837
7838 serializer.begin_field(xidl_xcdr::FieldId(3u32), false, 0)?;
7839
7840 xidl_xcdr::XcdrSerialize::serialize_with(&self.member_seq, serializer)?;
7841 serializer.end_field()?;
7842
7843 serializer.end_struct()?;
7844 Ok(())
7845 }
7846 }
7847
7848 impl xidl_xcdr::XcdrDeserialize for MinimalAnnotationType {
7849 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
7850 deserializer: &mut D,
7851 ) -> xidl_xcdr::error::XcdrResult<Self> {
7852 let annotation_flag = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
7853
7854 let header = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
7855
7856 let member_seq = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
7857
7858 Ok(Self {
7859 annotation_flag,
7860
7861 header,
7862
7863 member_seq,
7864 })
7865 }
7866 }
7867
7868 impl xidl_typeobject::XidlTypeObject for MinimalAnnotationType {
7869 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
7870 xidl_typeobject::runtime::build_minimal_struct(
7871 0u32,
7872 xidl_typeobject::runtime::type_identifier_none(),
7873 vec![
7874 xidl_typeobject::runtime::StructMemberDesc {
7875 member_id: 1u32,
7876 member_flags: 0u32,
7877 type_id: xidl_typeobject::runtime::type_identifier_for::<
7878 AnnotationTypeFlag,
7879 >(
7880 xidl_typeobject::runtime::TypeEquivalence::Minimal
7881 ),
7882 name: "annotation_flag",
7883 },
7884 xidl_typeobject::runtime::StructMemberDesc {
7885 member_id: 2u32,
7886 member_flags: 0u32,
7887 type_id: xidl_typeobject::runtime::type_identifier_for::<
7888 MinimalAnnotationHeader,
7889 >(
7890 xidl_typeobject::runtime::TypeEquivalence::Minimal
7891 ),
7892 name: "header",
7893 },
7894 xidl_typeobject::runtime::StructMemberDesc {
7895 member_id: 3u32,
7896 member_flags: 0u32,
7897 type_id: xidl_typeobject::runtime::type_identifier_for::<
7898 MinimalAnnotationParameterSeq,
7899 >(
7900 xidl_typeobject::runtime::TypeEquivalence::Minimal
7901 ),
7902 name: "member_seq",
7903 },
7904 ],
7905 )
7906 }
7907
7908 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
7909 xidl_typeobject::runtime::build_complete_struct(
7910 "DDS::XTypes::MinimalAnnotationType",
7911 0u32,
7912 xidl_typeobject::runtime::type_identifier_none(),
7913 vec![
7914 xidl_typeobject::runtime::StructMemberDesc {
7915 member_id: 1u32,
7916 member_flags: 0u32,
7917 type_id: xidl_typeobject::runtime::type_identifier_for::<
7918 AnnotationTypeFlag,
7919 >(
7920 xidl_typeobject::runtime::TypeEquivalence::Complete
7921 ),
7922 name: "annotation_flag",
7923 },
7924 xidl_typeobject::runtime::StructMemberDesc {
7925 member_id: 2u32,
7926 member_flags: 0u32,
7927 type_id: xidl_typeobject::runtime::type_identifier_for::<
7928 MinimalAnnotationHeader,
7929 >(
7930 xidl_typeobject::runtime::TypeEquivalence::Complete
7931 ),
7932 name: "header",
7933 },
7934 xidl_typeobject::runtime::StructMemberDesc {
7935 member_id: 3u32,
7936 member_flags: 0u32,
7937 type_id: xidl_typeobject::runtime::type_identifier_for::<
7938 MinimalAnnotationParameterSeq,
7939 >(
7940 xidl_typeobject::runtime::TypeEquivalence::Complete
7941 ),
7942 name: "member_seq",
7943 },
7944 ],
7945 )
7946 }
7947 }
7948 pub struct CommonAliasBody {
7949 pub related_flags: Box<AliasMemberFlag>,
7950
7951 pub related_type: Box<TypeIdentifier>,
7952 }
7953
7954 impl CommonAliasBody {
7955 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
7956 }
7957
7958 impl xidl_xcdr::XcdrSerialize for CommonAliasBody {
7959 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
7960 Self::SERIALIZE_KIND
7961 }
7962
7963 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
7964 &self,
7965 serializer: &mut S,
7966 ) -> xidl_xcdr::error::XcdrResult<()> {
7967 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
7968
7969 serializer.begin_field(xidl_xcdr::FieldId(1u32), false, 0)?;
7970
7971 xidl_xcdr::XcdrSerialize::serialize_with(&self.related_flags, serializer)?;
7972 serializer.end_field()?;
7973
7974 serializer.begin_field(xidl_xcdr::FieldId(2u32), false, 0)?;
7975
7976 xidl_xcdr::XcdrSerialize::serialize_with(&self.related_type, serializer)?;
7977 serializer.end_field()?;
7978
7979 serializer.end_struct()?;
7980 Ok(())
7981 }
7982 }
7983
7984 impl xidl_xcdr::XcdrDeserialize for CommonAliasBody {
7985 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
7986 deserializer: &mut D,
7987 ) -> xidl_xcdr::error::XcdrResult<Self> {
7988 let related_flags = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
7989
7990 let related_type = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
7991
7992 Ok(Self {
7993 related_flags,
7994
7995 related_type,
7996 })
7997 }
7998 }
7999
8000 impl xidl_typeobject::XidlTypeObject for CommonAliasBody {
8001 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
8002 xidl_typeobject::runtime::build_minimal_struct(
8003 0u32,
8004 xidl_typeobject::runtime::type_identifier_none(),
8005 vec![
8006 xidl_typeobject::runtime::StructMemberDesc {
8007 member_id: 1u32,
8008 member_flags: 0u32,
8009 type_id: xidl_typeobject::runtime::type_identifier_for::<AliasMemberFlag>(
8010 xidl_typeobject::runtime::TypeEquivalence::Minimal,
8011 ),
8012 name: "related_flags",
8013 },
8014 xidl_typeobject::runtime::StructMemberDesc {
8015 member_id: 2u32,
8016 member_flags: 0u32,
8017 type_id: xidl_typeobject::runtime::type_identifier_for::<TypeIdentifier>(
8018 xidl_typeobject::runtime::TypeEquivalence::Minimal,
8019 ),
8020 name: "related_type",
8021 },
8022 ],
8023 )
8024 }
8025
8026 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
8027 xidl_typeobject::runtime::build_complete_struct(
8028 "DDS::XTypes::CommonAliasBody",
8029 0u32,
8030 xidl_typeobject::runtime::type_identifier_none(),
8031 vec![
8032 xidl_typeobject::runtime::StructMemberDesc {
8033 member_id: 1u32,
8034 member_flags: 0u32,
8035 type_id: xidl_typeobject::runtime::type_identifier_for::<AliasMemberFlag>(
8036 xidl_typeobject::runtime::TypeEquivalence::Complete,
8037 ),
8038 name: "related_flags",
8039 },
8040 xidl_typeobject::runtime::StructMemberDesc {
8041 member_id: 2u32,
8042 member_flags: 0u32,
8043 type_id: xidl_typeobject::runtime::type_identifier_for::<TypeIdentifier>(
8044 xidl_typeobject::runtime::TypeEquivalence::Complete,
8045 ),
8046 name: "related_type",
8047 },
8048 ],
8049 )
8050 }
8051 }
8052 pub struct CompleteAliasBody {
8053 pub common: Box<CommonAliasBody>,
8054
8055 pub ann_builtin: Box<AppliedBuiltinMemberAnnotations>,
8056
8057 pub ann_custom: Box<AppliedAnnotationSeq>,
8058 }
8059
8060 impl CompleteAliasBody {
8061 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
8062 }
8063
8064 impl xidl_xcdr::XcdrSerialize for CompleteAliasBody {
8065 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
8066 Self::SERIALIZE_KIND
8067 }
8068
8069 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
8070 &self,
8071 serializer: &mut S,
8072 ) -> xidl_xcdr::error::XcdrResult<()> {
8073 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
8074
8075 serializer.begin_field(xidl_xcdr::FieldId(1u32), false, 0)?;
8076
8077 xidl_xcdr::XcdrSerialize::serialize_with(&self.common, serializer)?;
8078 serializer.end_field()?;
8079
8080 serializer.begin_field(xidl_xcdr::FieldId(2u32), false, 0)?;
8081
8082 xidl_xcdr::XcdrSerialize::serialize_with(&self.ann_builtin, serializer)?;
8083 serializer.end_field()?;
8084
8085 serializer.begin_field(xidl_xcdr::FieldId(3u32), false, 0)?;
8086
8087 xidl_xcdr::XcdrSerialize::serialize_with(&self.ann_custom, serializer)?;
8088 serializer.end_field()?;
8089
8090 serializer.end_struct()?;
8091 Ok(())
8092 }
8093 }
8094
8095 impl xidl_xcdr::XcdrDeserialize for CompleteAliasBody {
8096 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
8097 deserializer: &mut D,
8098 ) -> xidl_xcdr::error::XcdrResult<Self> {
8099 let common = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
8100
8101 let ann_builtin = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
8102
8103 let ann_custom = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
8104
8105 Ok(Self {
8106 common,
8107
8108 ann_builtin,
8109
8110 ann_custom,
8111 })
8112 }
8113 }
8114
8115 impl xidl_typeobject::XidlTypeObject for CompleteAliasBody {
8116 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
8117 xidl_typeobject::runtime::build_minimal_struct(
8118 0u32,
8119 xidl_typeobject::runtime::type_identifier_none(),
8120 vec![
8121 xidl_typeobject::runtime::StructMemberDesc {
8122 member_id: 1u32,
8123 member_flags: 0u32,
8124 type_id: xidl_typeobject::runtime::type_identifier_for::<CommonAliasBody>(
8125 xidl_typeobject::runtime::TypeEquivalence::Minimal,
8126 ),
8127 name: "common",
8128 },
8129 xidl_typeobject::runtime::StructMemberDesc {
8130 member_id: 2u32,
8131 member_flags: 0u32,
8132 type_id: xidl_typeobject::runtime::type_identifier_for::<
8133 AppliedBuiltinMemberAnnotations,
8134 >(
8135 xidl_typeobject::runtime::TypeEquivalence::Minimal
8136 ),
8137 name: "ann_builtin",
8138 },
8139 xidl_typeobject::runtime::StructMemberDesc {
8140 member_id: 3u32,
8141 member_flags: 0u32,
8142 type_id: xidl_typeobject::runtime::type_identifier_for::<
8143 AppliedAnnotationSeq,
8144 >(
8145 xidl_typeobject::runtime::TypeEquivalence::Minimal
8146 ),
8147 name: "ann_custom",
8148 },
8149 ],
8150 )
8151 }
8152
8153 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
8154 xidl_typeobject::runtime::build_complete_struct(
8155 "DDS::XTypes::CompleteAliasBody",
8156 0u32,
8157 xidl_typeobject::runtime::type_identifier_none(),
8158 vec![
8159 xidl_typeobject::runtime::StructMemberDesc {
8160 member_id: 1u32,
8161 member_flags: 0u32,
8162 type_id: xidl_typeobject::runtime::type_identifier_for::<CommonAliasBody>(
8163 xidl_typeobject::runtime::TypeEquivalence::Complete,
8164 ),
8165 name: "common",
8166 },
8167 xidl_typeobject::runtime::StructMemberDesc {
8168 member_id: 2u32,
8169 member_flags: 0u32,
8170 type_id: xidl_typeobject::runtime::type_identifier_for::<
8171 AppliedBuiltinMemberAnnotations,
8172 >(
8173 xidl_typeobject::runtime::TypeEquivalence::Complete
8174 ),
8175 name: "ann_builtin",
8176 },
8177 xidl_typeobject::runtime::StructMemberDesc {
8178 member_id: 3u32,
8179 member_flags: 0u32,
8180 type_id: xidl_typeobject::runtime::type_identifier_for::<
8181 AppliedAnnotationSeq,
8182 >(
8183 xidl_typeobject::runtime::TypeEquivalence::Complete
8184 ),
8185 name: "ann_custom",
8186 },
8187 ],
8188 )
8189 }
8190 }
8191 pub struct MinimalAliasBody {
8192 pub common: Box<CommonAliasBody>,
8193 }
8194
8195 impl MinimalAliasBody {
8196 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
8197 }
8198
8199 impl xidl_xcdr::XcdrSerialize for MinimalAliasBody {
8200 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
8201 Self::SERIALIZE_KIND
8202 }
8203
8204 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
8205 &self,
8206 serializer: &mut S,
8207 ) -> xidl_xcdr::error::XcdrResult<()> {
8208 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
8209
8210 serializer.begin_field(xidl_xcdr::FieldId(1u32), false, 0)?;
8211
8212 xidl_xcdr::XcdrSerialize::serialize_with(&self.common, serializer)?;
8213 serializer.end_field()?;
8214
8215 serializer.end_struct()?;
8216 Ok(())
8217 }
8218 }
8219
8220 impl xidl_xcdr::XcdrDeserialize for MinimalAliasBody {
8221 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
8222 deserializer: &mut D,
8223 ) -> xidl_xcdr::error::XcdrResult<Self> {
8224 let common = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
8225
8226 Ok(Self { common })
8227 }
8228 }
8229
8230 impl xidl_typeobject::XidlTypeObject for MinimalAliasBody {
8231 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
8232 xidl_typeobject::runtime::build_minimal_struct(
8233 0u32,
8234 xidl_typeobject::runtime::type_identifier_none(),
8235 vec![xidl_typeobject::runtime::StructMemberDesc {
8236 member_id: 1u32,
8237 member_flags: 0u32,
8238 type_id: xidl_typeobject::runtime::type_identifier_for::<CommonAliasBody>(
8239 xidl_typeobject::runtime::TypeEquivalence::Minimal,
8240 ),
8241 name: "common",
8242 }],
8243 )
8244 }
8245
8246 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
8247 xidl_typeobject::runtime::build_complete_struct(
8248 "DDS::XTypes::MinimalAliasBody",
8249 0u32,
8250 xidl_typeobject::runtime::type_identifier_none(),
8251 vec![xidl_typeobject::runtime::StructMemberDesc {
8252 member_id: 1u32,
8253 member_flags: 0u32,
8254 type_id: xidl_typeobject::runtime::type_identifier_for::<CommonAliasBody>(
8255 xidl_typeobject::runtime::TypeEquivalence::Complete,
8256 ),
8257 name: "common",
8258 }],
8259 )
8260 }
8261 }
8262 pub struct CompleteAliasHeader {
8263 pub detail: Box<CompleteTypeDetail>,
8264 }
8265
8266 impl CompleteAliasHeader {
8267 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
8268 }
8269
8270 impl xidl_xcdr::XcdrSerialize for CompleteAliasHeader {
8271 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
8272 Self::SERIALIZE_KIND
8273 }
8274
8275 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
8276 &self,
8277 serializer: &mut S,
8278 ) -> xidl_xcdr::error::XcdrResult<()> {
8279 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
8280
8281 serializer.begin_field(xidl_xcdr::FieldId(1u32), false, 0)?;
8282
8283 xidl_xcdr::XcdrSerialize::serialize_with(&self.detail, serializer)?;
8284 serializer.end_field()?;
8285
8286 serializer.end_struct()?;
8287 Ok(())
8288 }
8289 }
8290
8291 impl xidl_xcdr::XcdrDeserialize for CompleteAliasHeader {
8292 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
8293 deserializer: &mut D,
8294 ) -> xidl_xcdr::error::XcdrResult<Self> {
8295 let detail = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
8296
8297 Ok(Self { detail })
8298 }
8299 }
8300
8301 impl xidl_typeobject::XidlTypeObject for CompleteAliasHeader {
8302 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
8303 xidl_typeobject::runtime::build_minimal_struct(
8304 0u32,
8305 xidl_typeobject::runtime::type_identifier_none(),
8306 vec![xidl_typeobject::runtime::StructMemberDesc {
8307 member_id: 1u32,
8308 member_flags: 0u32,
8309 type_id: xidl_typeobject::runtime::type_identifier_for::<CompleteTypeDetail>(
8310 xidl_typeobject::runtime::TypeEquivalence::Minimal,
8311 ),
8312 name: "detail",
8313 }],
8314 )
8315 }
8316
8317 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
8318 xidl_typeobject::runtime::build_complete_struct(
8319 "DDS::XTypes::CompleteAliasHeader",
8320 0u32,
8321 xidl_typeobject::runtime::type_identifier_none(),
8322 vec![xidl_typeobject::runtime::StructMemberDesc {
8323 member_id: 1u32,
8324 member_flags: 0u32,
8325 type_id: xidl_typeobject::runtime::type_identifier_for::<CompleteTypeDetail>(
8326 xidl_typeobject::runtime::TypeEquivalence::Complete,
8327 ),
8328 name: "detail",
8329 }],
8330 )
8331 }
8332 }
8333 pub struct MinimalAliasHeader {}
8334
8335 impl MinimalAliasHeader {
8336 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
8337 }
8338
8339 impl xidl_xcdr::XcdrSerialize for MinimalAliasHeader {
8340 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
8341 Self::SERIALIZE_KIND
8342 }
8343
8344 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
8345 &self,
8346 serializer: &mut S,
8347 ) -> xidl_xcdr::error::XcdrResult<()> {
8348 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
8349
8350 serializer.end_struct()?;
8351 Ok(())
8352 }
8353 }
8354
8355 impl xidl_xcdr::XcdrDeserialize for MinimalAliasHeader {
8356 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
8357 deserializer: &mut D,
8358 ) -> xidl_xcdr::error::XcdrResult<Self> {
8359 Ok(Self {})
8360 }
8361 }
8362
8363 impl xidl_typeobject::XidlTypeObject for MinimalAliasHeader {
8364 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
8365 xidl_typeobject::runtime::build_minimal_struct(
8366 0u32,
8367 xidl_typeobject::runtime::type_identifier_none(),
8368 vec![],
8369 )
8370 }
8371
8372 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
8373 xidl_typeobject::runtime::build_complete_struct(
8374 "DDS::XTypes::MinimalAliasHeader",
8375 0u32,
8376 xidl_typeobject::runtime::type_identifier_none(),
8377 vec![],
8378 )
8379 }
8380 }
8381 pub struct CompleteAliasType {
8382 pub alias_flags: Box<AliasTypeFlag>,
8383
8384 pub header: Box<CompleteAliasHeader>,
8385
8386 pub body: Box<CompleteAliasBody>,
8387 }
8388
8389 impl CompleteAliasType {
8390 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
8391 }
8392
8393 impl xidl_xcdr::XcdrSerialize for CompleteAliasType {
8394 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
8395 Self::SERIALIZE_KIND
8396 }
8397
8398 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
8399 &self,
8400 serializer: &mut S,
8401 ) -> xidl_xcdr::error::XcdrResult<()> {
8402 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
8403
8404 serializer.begin_field(xidl_xcdr::FieldId(1u32), false, 0)?;
8405
8406 xidl_xcdr::XcdrSerialize::serialize_with(&self.alias_flags, serializer)?;
8407 serializer.end_field()?;
8408
8409 serializer.begin_field(xidl_xcdr::FieldId(2u32), false, 0)?;
8410
8411 xidl_xcdr::XcdrSerialize::serialize_with(&self.header, serializer)?;
8412 serializer.end_field()?;
8413
8414 serializer.begin_field(xidl_xcdr::FieldId(3u32), false, 0)?;
8415
8416 xidl_xcdr::XcdrSerialize::serialize_with(&self.body, serializer)?;
8417 serializer.end_field()?;
8418
8419 serializer.end_struct()?;
8420 Ok(())
8421 }
8422 }
8423
8424 impl xidl_xcdr::XcdrDeserialize for CompleteAliasType {
8425 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
8426 deserializer: &mut D,
8427 ) -> xidl_xcdr::error::XcdrResult<Self> {
8428 let alias_flags = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
8429
8430 let header = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
8431
8432 let body = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
8433
8434 Ok(Self {
8435 alias_flags,
8436
8437 header,
8438
8439 body,
8440 })
8441 }
8442 }
8443
8444 impl xidl_typeobject::XidlTypeObject for CompleteAliasType {
8445 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
8446 xidl_typeobject::runtime::build_minimal_struct(
8447 0u32,
8448 xidl_typeobject::runtime::type_identifier_none(),
8449 vec![
8450 xidl_typeobject::runtime::StructMemberDesc {
8451 member_id: 1u32,
8452 member_flags: 0u32,
8453 type_id: xidl_typeobject::runtime::type_identifier_for::<AliasTypeFlag>(
8454 xidl_typeobject::runtime::TypeEquivalence::Minimal,
8455 ),
8456 name: "alias_flags",
8457 },
8458 xidl_typeobject::runtime::StructMemberDesc {
8459 member_id: 2u32,
8460 member_flags: 0u32,
8461 type_id: xidl_typeobject::runtime::type_identifier_for::<
8462 CompleteAliasHeader,
8463 >(
8464 xidl_typeobject::runtime::TypeEquivalence::Minimal
8465 ),
8466 name: "header",
8467 },
8468 xidl_typeobject::runtime::StructMemberDesc {
8469 member_id: 3u32,
8470 member_flags: 0u32,
8471 type_id: xidl_typeobject::runtime::type_identifier_for::<
8472 CompleteAliasBody,
8473 >(
8474 xidl_typeobject::runtime::TypeEquivalence::Minimal
8475 ),
8476 name: "body",
8477 },
8478 ],
8479 )
8480 }
8481
8482 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
8483 xidl_typeobject::runtime::build_complete_struct(
8484 "DDS::XTypes::CompleteAliasType",
8485 0u32,
8486 xidl_typeobject::runtime::type_identifier_none(),
8487 vec![
8488 xidl_typeobject::runtime::StructMemberDesc {
8489 member_id: 1u32,
8490 member_flags: 0u32,
8491 type_id: xidl_typeobject::runtime::type_identifier_for::<AliasTypeFlag>(
8492 xidl_typeobject::runtime::TypeEquivalence::Complete,
8493 ),
8494 name: "alias_flags",
8495 },
8496 xidl_typeobject::runtime::StructMemberDesc {
8497 member_id: 2u32,
8498 member_flags: 0u32,
8499 type_id: xidl_typeobject::runtime::type_identifier_for::<
8500 CompleteAliasHeader,
8501 >(
8502 xidl_typeobject::runtime::TypeEquivalence::Complete
8503 ),
8504 name: "header",
8505 },
8506 xidl_typeobject::runtime::StructMemberDesc {
8507 member_id: 3u32,
8508 member_flags: 0u32,
8509 type_id: xidl_typeobject::runtime::type_identifier_for::<
8510 CompleteAliasBody,
8511 >(
8512 xidl_typeobject::runtime::TypeEquivalence::Complete
8513 ),
8514 name: "body",
8515 },
8516 ],
8517 )
8518 }
8519 }
8520 pub struct MinimalAliasType {
8521 pub alias_flags: Box<AliasTypeFlag>,
8522
8523 pub header: Box<MinimalAliasHeader>,
8524
8525 pub body: Box<MinimalAliasBody>,
8526 }
8527
8528 impl MinimalAliasType {
8529 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
8530 }
8531
8532 impl xidl_xcdr::XcdrSerialize for MinimalAliasType {
8533 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
8534 Self::SERIALIZE_KIND
8535 }
8536
8537 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
8538 &self,
8539 serializer: &mut S,
8540 ) -> xidl_xcdr::error::XcdrResult<()> {
8541 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
8542
8543 serializer.begin_field(xidl_xcdr::FieldId(1u32), false, 0)?;
8544
8545 xidl_xcdr::XcdrSerialize::serialize_with(&self.alias_flags, serializer)?;
8546 serializer.end_field()?;
8547
8548 serializer.begin_field(xidl_xcdr::FieldId(2u32), false, 0)?;
8549
8550 xidl_xcdr::XcdrSerialize::serialize_with(&self.header, serializer)?;
8551 serializer.end_field()?;
8552
8553 serializer.begin_field(xidl_xcdr::FieldId(3u32), false, 0)?;
8554
8555 xidl_xcdr::XcdrSerialize::serialize_with(&self.body, serializer)?;
8556 serializer.end_field()?;
8557
8558 serializer.end_struct()?;
8559 Ok(())
8560 }
8561 }
8562
8563 impl xidl_xcdr::XcdrDeserialize for MinimalAliasType {
8564 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
8565 deserializer: &mut D,
8566 ) -> xidl_xcdr::error::XcdrResult<Self> {
8567 let alias_flags = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
8568
8569 let header = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
8570
8571 let body = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
8572
8573 Ok(Self {
8574 alias_flags,
8575
8576 header,
8577
8578 body,
8579 })
8580 }
8581 }
8582
8583 impl xidl_typeobject::XidlTypeObject for MinimalAliasType {
8584 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
8585 xidl_typeobject::runtime::build_minimal_struct(
8586 0u32,
8587 xidl_typeobject::runtime::type_identifier_none(),
8588 vec![
8589 xidl_typeobject::runtime::StructMemberDesc {
8590 member_id: 1u32,
8591 member_flags: 0u32,
8592 type_id: xidl_typeobject::runtime::type_identifier_for::<AliasTypeFlag>(
8593 xidl_typeobject::runtime::TypeEquivalence::Minimal,
8594 ),
8595 name: "alias_flags",
8596 },
8597 xidl_typeobject::runtime::StructMemberDesc {
8598 member_id: 2u32,
8599 member_flags: 0u32,
8600 type_id: xidl_typeobject::runtime::type_identifier_for::<
8601 MinimalAliasHeader,
8602 >(
8603 xidl_typeobject::runtime::TypeEquivalence::Minimal
8604 ),
8605 name: "header",
8606 },
8607 xidl_typeobject::runtime::StructMemberDesc {
8608 member_id: 3u32,
8609 member_flags: 0u32,
8610 type_id: xidl_typeobject::runtime::type_identifier_for::<
8611 MinimalAliasBody,
8612 >(
8613 xidl_typeobject::runtime::TypeEquivalence::Minimal
8614 ),
8615 name: "body",
8616 },
8617 ],
8618 )
8619 }
8620
8621 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
8622 xidl_typeobject::runtime::build_complete_struct(
8623 "DDS::XTypes::MinimalAliasType",
8624 0u32,
8625 xidl_typeobject::runtime::type_identifier_none(),
8626 vec![
8627 xidl_typeobject::runtime::StructMemberDesc {
8628 member_id: 1u32,
8629 member_flags: 0u32,
8630 type_id: xidl_typeobject::runtime::type_identifier_for::<AliasTypeFlag>(
8631 xidl_typeobject::runtime::TypeEquivalence::Complete,
8632 ),
8633 name: "alias_flags",
8634 },
8635 xidl_typeobject::runtime::StructMemberDesc {
8636 member_id: 2u32,
8637 member_flags: 0u32,
8638 type_id: xidl_typeobject::runtime::type_identifier_for::<
8639 MinimalAliasHeader,
8640 >(
8641 xidl_typeobject::runtime::TypeEquivalence::Complete
8642 ),
8643 name: "header",
8644 },
8645 xidl_typeobject::runtime::StructMemberDesc {
8646 member_id: 3u32,
8647 member_flags: 0u32,
8648 type_id: xidl_typeobject::runtime::type_identifier_for::<
8649 MinimalAliasBody,
8650 >(
8651 xidl_typeobject::runtime::TypeEquivalence::Complete
8652 ),
8653 name: "body",
8654 },
8655 ],
8656 )
8657 }
8658 }
8659 pub struct CompleteElementDetail {
8660 pub ann_builtin: Box<AppliedBuiltinMemberAnnotations>,
8661
8662 pub ann_custom: Box<AppliedAnnotationSeq>,
8663 }
8664
8665 impl CompleteElementDetail {
8666 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
8667 }
8668
8669 impl xidl_xcdr::XcdrSerialize for CompleteElementDetail {
8670 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
8671 Self::SERIALIZE_KIND
8672 }
8673
8674 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
8675 &self,
8676 serializer: &mut S,
8677 ) -> xidl_xcdr::error::XcdrResult<()> {
8678 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
8679
8680 serializer.begin_field(xidl_xcdr::FieldId(1u32), false, 0)?;
8681
8682 xidl_xcdr::XcdrSerialize::serialize_with(&self.ann_builtin, serializer)?;
8683 serializer.end_field()?;
8684
8685 serializer.begin_field(xidl_xcdr::FieldId(2u32), false, 0)?;
8686
8687 xidl_xcdr::XcdrSerialize::serialize_with(&self.ann_custom, serializer)?;
8688 serializer.end_field()?;
8689
8690 serializer.end_struct()?;
8691 Ok(())
8692 }
8693 }
8694
8695 impl xidl_xcdr::XcdrDeserialize for CompleteElementDetail {
8696 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
8697 deserializer: &mut D,
8698 ) -> xidl_xcdr::error::XcdrResult<Self> {
8699 let ann_builtin = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
8700
8701 let ann_custom = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
8702
8703 Ok(Self {
8704 ann_builtin,
8705
8706 ann_custom,
8707 })
8708 }
8709 }
8710
8711 impl xidl_typeobject::XidlTypeObject for CompleteElementDetail {
8712 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
8713 xidl_typeobject::runtime::build_minimal_struct(
8714 0u32,
8715 xidl_typeobject::runtime::type_identifier_none(),
8716 vec![
8717 xidl_typeobject::runtime::StructMemberDesc {
8718 member_id: 1u32,
8719 member_flags: 0u32,
8720 type_id: xidl_typeobject::runtime::type_identifier_for::<
8721 AppliedBuiltinMemberAnnotations,
8722 >(
8723 xidl_typeobject::runtime::TypeEquivalence::Minimal
8724 ),
8725 name: "ann_builtin",
8726 },
8727 xidl_typeobject::runtime::StructMemberDesc {
8728 member_id: 2u32,
8729 member_flags: 0u32,
8730 type_id: xidl_typeobject::runtime::type_identifier_for::<
8731 AppliedAnnotationSeq,
8732 >(
8733 xidl_typeobject::runtime::TypeEquivalence::Minimal
8734 ),
8735 name: "ann_custom",
8736 },
8737 ],
8738 )
8739 }
8740
8741 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
8742 xidl_typeobject::runtime::build_complete_struct(
8743 "DDS::XTypes::CompleteElementDetail",
8744 0u32,
8745 xidl_typeobject::runtime::type_identifier_none(),
8746 vec![
8747 xidl_typeobject::runtime::StructMemberDesc {
8748 member_id: 1u32,
8749 member_flags: 0u32,
8750 type_id: xidl_typeobject::runtime::type_identifier_for::<
8751 AppliedBuiltinMemberAnnotations,
8752 >(
8753 xidl_typeobject::runtime::TypeEquivalence::Complete
8754 ),
8755 name: "ann_builtin",
8756 },
8757 xidl_typeobject::runtime::StructMemberDesc {
8758 member_id: 2u32,
8759 member_flags: 0u32,
8760 type_id: xidl_typeobject::runtime::type_identifier_for::<
8761 AppliedAnnotationSeq,
8762 >(
8763 xidl_typeobject::runtime::TypeEquivalence::Complete
8764 ),
8765 name: "ann_custom",
8766 },
8767 ],
8768 )
8769 }
8770 }
8771 pub struct CommonCollectionElement {
8772 pub element_flags: Box<CollectionElementFlag>,
8773
8774 pub r#type: Box<TypeIdentifier>,
8775 }
8776
8777 impl CommonCollectionElement {
8778 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
8779 }
8780
8781 impl xidl_xcdr::XcdrSerialize for CommonCollectionElement {
8782 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
8783 Self::SERIALIZE_KIND
8784 }
8785
8786 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
8787 &self,
8788 serializer: &mut S,
8789 ) -> xidl_xcdr::error::XcdrResult<()> {
8790 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
8791
8792 serializer.begin_field(xidl_xcdr::FieldId(1u32), false, 0)?;
8793
8794 xidl_xcdr::XcdrSerialize::serialize_with(&self.element_flags, serializer)?;
8795 serializer.end_field()?;
8796
8797 serializer.begin_field(xidl_xcdr::FieldId(2u32), false, 0)?;
8798
8799 xidl_xcdr::XcdrSerialize::serialize_with(&self.r#type, serializer)?;
8800 serializer.end_field()?;
8801
8802 serializer.end_struct()?;
8803 Ok(())
8804 }
8805 }
8806
8807 impl xidl_xcdr::XcdrDeserialize for CommonCollectionElement {
8808 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
8809 deserializer: &mut D,
8810 ) -> xidl_xcdr::error::XcdrResult<Self> {
8811 let element_flags = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
8812
8813 let r#type = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
8814
8815 Ok(Self {
8816 element_flags,
8817
8818 r#type,
8819 })
8820 }
8821 }
8822
8823 impl xidl_typeobject::XidlTypeObject for CommonCollectionElement {
8824 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
8825 xidl_typeobject::runtime::build_minimal_struct(
8826 0u32,
8827 xidl_typeobject::runtime::type_identifier_none(),
8828 vec![
8829 xidl_typeobject::runtime::StructMemberDesc {
8830 member_id: 1u32,
8831 member_flags: 0u32,
8832 type_id: xidl_typeobject::runtime::type_identifier_for::<
8833 CollectionElementFlag,
8834 >(
8835 xidl_typeobject::runtime::TypeEquivalence::Minimal
8836 ),
8837 name: "element_flags",
8838 },
8839 xidl_typeobject::runtime::StructMemberDesc {
8840 member_id: 2u32,
8841 member_flags: 0u32,
8842 type_id: xidl_typeobject::runtime::type_identifier_for::<TypeIdentifier>(
8843 xidl_typeobject::runtime::TypeEquivalence::Minimal,
8844 ),
8845 name: "type",
8846 },
8847 ],
8848 )
8849 }
8850
8851 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
8852 xidl_typeobject::runtime::build_complete_struct(
8853 "DDS::XTypes::CommonCollectionElement",
8854 0u32,
8855 xidl_typeobject::runtime::type_identifier_none(),
8856 vec![
8857 xidl_typeobject::runtime::StructMemberDesc {
8858 member_id: 1u32,
8859 member_flags: 0u32,
8860 type_id: xidl_typeobject::runtime::type_identifier_for::<
8861 CollectionElementFlag,
8862 >(
8863 xidl_typeobject::runtime::TypeEquivalence::Complete
8864 ),
8865 name: "element_flags",
8866 },
8867 xidl_typeobject::runtime::StructMemberDesc {
8868 member_id: 2u32,
8869 member_flags: 0u32,
8870 type_id: xidl_typeobject::runtime::type_identifier_for::<TypeIdentifier>(
8871 xidl_typeobject::runtime::TypeEquivalence::Complete,
8872 ),
8873 name: "type",
8874 },
8875 ],
8876 )
8877 }
8878 }
8879 pub struct CompleteCollectionElement {
8880 pub common: Box<CommonCollectionElement>,
8881
8882 pub detail: Box<CompleteElementDetail>,
8883 }
8884
8885 impl CompleteCollectionElement {
8886 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
8887 }
8888
8889 impl xidl_xcdr::XcdrSerialize for CompleteCollectionElement {
8890 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
8891 Self::SERIALIZE_KIND
8892 }
8893
8894 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
8895 &self,
8896 serializer: &mut S,
8897 ) -> xidl_xcdr::error::XcdrResult<()> {
8898 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
8899
8900 serializer.begin_field(xidl_xcdr::FieldId(1u32), false, 0)?;
8901
8902 xidl_xcdr::XcdrSerialize::serialize_with(&self.common, serializer)?;
8903 serializer.end_field()?;
8904
8905 serializer.begin_field(xidl_xcdr::FieldId(2u32), false, 0)?;
8906
8907 xidl_xcdr::XcdrSerialize::serialize_with(&self.detail, serializer)?;
8908 serializer.end_field()?;
8909
8910 serializer.end_struct()?;
8911 Ok(())
8912 }
8913 }
8914
8915 impl xidl_xcdr::XcdrDeserialize for CompleteCollectionElement {
8916 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
8917 deserializer: &mut D,
8918 ) -> xidl_xcdr::error::XcdrResult<Self> {
8919 let common = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
8920
8921 let detail = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
8922
8923 Ok(Self { common, detail })
8924 }
8925 }
8926
8927 impl xidl_typeobject::XidlTypeObject for CompleteCollectionElement {
8928 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
8929 xidl_typeobject::runtime::build_minimal_struct(
8930 0u32,
8931 xidl_typeobject::runtime::type_identifier_none(),
8932 vec![
8933 xidl_typeobject::runtime::StructMemberDesc {
8934 member_id: 1u32,
8935 member_flags: 0u32,
8936 type_id: xidl_typeobject::runtime::type_identifier_for::<
8937 CommonCollectionElement,
8938 >(
8939 xidl_typeobject::runtime::TypeEquivalence::Minimal
8940 ),
8941 name: "common",
8942 },
8943 xidl_typeobject::runtime::StructMemberDesc {
8944 member_id: 2u32,
8945 member_flags: 0u32,
8946 type_id: xidl_typeobject::runtime::type_identifier_for::<
8947 CompleteElementDetail,
8948 >(
8949 xidl_typeobject::runtime::TypeEquivalence::Minimal
8950 ),
8951 name: "detail",
8952 },
8953 ],
8954 )
8955 }
8956
8957 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
8958 xidl_typeobject::runtime::build_complete_struct(
8959 "DDS::XTypes::CompleteCollectionElement",
8960 0u32,
8961 xidl_typeobject::runtime::type_identifier_none(),
8962 vec![
8963 xidl_typeobject::runtime::StructMemberDesc {
8964 member_id: 1u32,
8965 member_flags: 0u32,
8966 type_id: xidl_typeobject::runtime::type_identifier_for::<
8967 CommonCollectionElement,
8968 >(
8969 xidl_typeobject::runtime::TypeEquivalence::Complete
8970 ),
8971 name: "common",
8972 },
8973 xidl_typeobject::runtime::StructMemberDesc {
8974 member_id: 2u32,
8975 member_flags: 0u32,
8976 type_id: xidl_typeobject::runtime::type_identifier_for::<
8977 CompleteElementDetail,
8978 >(
8979 xidl_typeobject::runtime::TypeEquivalence::Complete
8980 ),
8981 name: "detail",
8982 },
8983 ],
8984 )
8985 }
8986 }
8987 pub struct MinimalCollectionElement {
8988 pub common: Box<CommonCollectionElement>,
8989 }
8990
8991 impl MinimalCollectionElement {
8992 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
8993 }
8994
8995 impl xidl_xcdr::XcdrSerialize for MinimalCollectionElement {
8996 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
8997 Self::SERIALIZE_KIND
8998 }
8999
9000 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
9001 &self,
9002 serializer: &mut S,
9003 ) -> xidl_xcdr::error::XcdrResult<()> {
9004 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
9005
9006 serializer.begin_field(xidl_xcdr::FieldId(1u32), false, 0)?;
9007
9008 xidl_xcdr::XcdrSerialize::serialize_with(&self.common, serializer)?;
9009 serializer.end_field()?;
9010
9011 serializer.end_struct()?;
9012 Ok(())
9013 }
9014 }
9015
9016 impl xidl_xcdr::XcdrDeserialize for MinimalCollectionElement {
9017 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
9018 deserializer: &mut D,
9019 ) -> xidl_xcdr::error::XcdrResult<Self> {
9020 let common = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
9021
9022 Ok(Self { common })
9023 }
9024 }
9025
9026 impl xidl_typeobject::XidlTypeObject for MinimalCollectionElement {
9027 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
9028 xidl_typeobject::runtime::build_minimal_struct(
9029 0u32,
9030 xidl_typeobject::runtime::type_identifier_none(),
9031 vec![xidl_typeobject::runtime::StructMemberDesc {
9032 member_id: 1u32,
9033 member_flags: 0u32,
9034 type_id: xidl_typeobject::runtime::type_identifier_for::<
9035 CommonCollectionElement,
9036 >(
9037 xidl_typeobject::runtime::TypeEquivalence::Minimal
9038 ),
9039 name: "common",
9040 }],
9041 )
9042 }
9043
9044 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
9045 xidl_typeobject::runtime::build_complete_struct(
9046 "DDS::XTypes::MinimalCollectionElement",
9047 0u32,
9048 xidl_typeobject::runtime::type_identifier_none(),
9049 vec![xidl_typeobject::runtime::StructMemberDesc {
9050 member_id: 1u32,
9051 member_flags: 0u32,
9052 type_id: xidl_typeobject::runtime::type_identifier_for::<
9053 CommonCollectionElement,
9054 >(
9055 xidl_typeobject::runtime::TypeEquivalence::Complete
9056 ),
9057 name: "common",
9058 }],
9059 )
9060 }
9061 }
9062 pub struct CommonCollectionHeader {
9063 pub bound: Box<LBound>,
9064 }
9065
9066 impl CommonCollectionHeader {
9067 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
9068 }
9069
9070 impl xidl_xcdr::XcdrSerialize for CommonCollectionHeader {
9071 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
9072 Self::SERIALIZE_KIND
9073 }
9074
9075 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
9076 &self,
9077 serializer: &mut S,
9078 ) -> xidl_xcdr::error::XcdrResult<()> {
9079 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
9080
9081 serializer.begin_field(xidl_xcdr::FieldId(1u32), false, 0)?;
9082
9083 xidl_xcdr::XcdrSerialize::serialize_with(&self.bound, serializer)?;
9084 serializer.end_field()?;
9085
9086 serializer.end_struct()?;
9087 Ok(())
9088 }
9089 }
9090
9091 impl xidl_xcdr::XcdrDeserialize for CommonCollectionHeader {
9092 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
9093 deserializer: &mut D,
9094 ) -> xidl_xcdr::error::XcdrResult<Self> {
9095 let bound = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
9096
9097 Ok(Self { bound })
9098 }
9099 }
9100
9101 impl xidl_typeobject::XidlTypeObject for CommonCollectionHeader {
9102 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
9103 xidl_typeobject::runtime::build_minimal_struct(
9104 0u32,
9105 xidl_typeobject::runtime::type_identifier_none(),
9106 vec![xidl_typeobject::runtime::StructMemberDesc {
9107 member_id: 1u32,
9108 member_flags: 0u32,
9109 type_id: xidl_typeobject::runtime::type_identifier_for::<LBound>(
9110 xidl_typeobject::runtime::TypeEquivalence::Minimal,
9111 ),
9112 name: "bound",
9113 }],
9114 )
9115 }
9116
9117 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
9118 xidl_typeobject::runtime::build_complete_struct(
9119 "DDS::XTypes::CommonCollectionHeader",
9120 0u32,
9121 xidl_typeobject::runtime::type_identifier_none(),
9122 vec![xidl_typeobject::runtime::StructMemberDesc {
9123 member_id: 1u32,
9124 member_flags: 0u32,
9125 type_id: xidl_typeobject::runtime::type_identifier_for::<LBound>(
9126 xidl_typeobject::runtime::TypeEquivalence::Complete,
9127 ),
9128 name: "bound",
9129 }],
9130 )
9131 }
9132 }
9133 pub struct CompleteCollectionHeader {
9134 pub common: Box<CommonCollectionHeader>,
9135
9136 pub detail: Box<CompleteTypeDetail>,
9137 }
9138
9139 impl CompleteCollectionHeader {
9140 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
9141 }
9142
9143 impl xidl_xcdr::XcdrSerialize for CompleteCollectionHeader {
9144 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
9145 Self::SERIALIZE_KIND
9146 }
9147
9148 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
9149 &self,
9150 serializer: &mut S,
9151 ) -> xidl_xcdr::error::XcdrResult<()> {
9152 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
9153
9154 serializer.begin_field(xidl_xcdr::FieldId(1u32), false, 0)?;
9155
9156 xidl_xcdr::XcdrSerialize::serialize_with(&self.common, serializer)?;
9157 serializer.end_field()?;
9158
9159 serializer.begin_field(xidl_xcdr::FieldId(2u32), false, 0)?;
9160
9161 xidl_xcdr::XcdrSerialize::serialize_with(&self.detail, serializer)?;
9162 serializer.end_field()?;
9163
9164 serializer.end_struct()?;
9165 Ok(())
9166 }
9167 }
9168
9169 impl xidl_xcdr::XcdrDeserialize for CompleteCollectionHeader {
9170 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
9171 deserializer: &mut D,
9172 ) -> xidl_xcdr::error::XcdrResult<Self> {
9173 let common = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
9174
9175 let detail = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
9176
9177 Ok(Self { common, detail })
9178 }
9179 }
9180
9181 impl xidl_typeobject::XidlTypeObject for CompleteCollectionHeader {
9182 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
9183 xidl_typeobject::runtime::build_minimal_struct(
9184 0u32,
9185 xidl_typeobject::runtime::type_identifier_none(),
9186 vec![
9187 xidl_typeobject::runtime::StructMemberDesc {
9188 member_id: 1u32,
9189 member_flags: 0u32,
9190 type_id: xidl_typeobject::runtime::type_identifier_for::<
9191 CommonCollectionHeader,
9192 >(
9193 xidl_typeobject::runtime::TypeEquivalence::Minimal
9194 ),
9195 name: "common",
9196 },
9197 xidl_typeobject::runtime::StructMemberDesc {
9198 member_id: 2u32,
9199 member_flags: 0u32,
9200 type_id: xidl_typeobject::runtime::type_identifier_for::<
9201 CompleteTypeDetail,
9202 >(
9203 xidl_typeobject::runtime::TypeEquivalence::Minimal
9204 ),
9205 name: "detail",
9206 },
9207 ],
9208 )
9209 }
9210
9211 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
9212 xidl_typeobject::runtime::build_complete_struct(
9213 "DDS::XTypes::CompleteCollectionHeader",
9214 0u32,
9215 xidl_typeobject::runtime::type_identifier_none(),
9216 vec![
9217 xidl_typeobject::runtime::StructMemberDesc {
9218 member_id: 1u32,
9219 member_flags: 0u32,
9220 type_id: xidl_typeobject::runtime::type_identifier_for::<
9221 CommonCollectionHeader,
9222 >(
9223 xidl_typeobject::runtime::TypeEquivalence::Complete
9224 ),
9225 name: "common",
9226 },
9227 xidl_typeobject::runtime::StructMemberDesc {
9228 member_id: 2u32,
9229 member_flags: 0u32,
9230 type_id: xidl_typeobject::runtime::type_identifier_for::<
9231 CompleteTypeDetail,
9232 >(
9233 xidl_typeobject::runtime::TypeEquivalence::Complete
9234 ),
9235 name: "detail",
9236 },
9237 ],
9238 )
9239 }
9240 }
9241 pub struct MinimalCollectionHeader {
9242 pub common: Box<CommonCollectionHeader>,
9243 }
9244
9245 impl MinimalCollectionHeader {
9246 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
9247 }
9248
9249 impl xidl_xcdr::XcdrSerialize for MinimalCollectionHeader {
9250 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
9251 Self::SERIALIZE_KIND
9252 }
9253
9254 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
9255 &self,
9256 serializer: &mut S,
9257 ) -> xidl_xcdr::error::XcdrResult<()> {
9258 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
9259
9260 serializer.begin_field(xidl_xcdr::FieldId(1u32), false, 0)?;
9261
9262 xidl_xcdr::XcdrSerialize::serialize_with(&self.common, serializer)?;
9263 serializer.end_field()?;
9264
9265 serializer.end_struct()?;
9266 Ok(())
9267 }
9268 }
9269
9270 impl xidl_xcdr::XcdrDeserialize for MinimalCollectionHeader {
9271 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
9272 deserializer: &mut D,
9273 ) -> xidl_xcdr::error::XcdrResult<Self> {
9274 let common = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
9275
9276 Ok(Self { common })
9277 }
9278 }
9279
9280 impl xidl_typeobject::XidlTypeObject for MinimalCollectionHeader {
9281 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
9282 xidl_typeobject::runtime::build_minimal_struct(
9283 0u32,
9284 xidl_typeobject::runtime::type_identifier_none(),
9285 vec![xidl_typeobject::runtime::StructMemberDesc {
9286 member_id: 1u32,
9287 member_flags: 0u32,
9288 type_id: xidl_typeobject::runtime::type_identifier_for::<
9289 CommonCollectionHeader,
9290 >(
9291 xidl_typeobject::runtime::TypeEquivalence::Minimal
9292 ),
9293 name: "common",
9294 }],
9295 )
9296 }
9297
9298 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
9299 xidl_typeobject::runtime::build_complete_struct(
9300 "DDS::XTypes::MinimalCollectionHeader",
9301 0u32,
9302 xidl_typeobject::runtime::type_identifier_none(),
9303 vec![xidl_typeobject::runtime::StructMemberDesc {
9304 member_id: 1u32,
9305 member_flags: 0u32,
9306 type_id: xidl_typeobject::runtime::type_identifier_for::<
9307 CommonCollectionHeader,
9308 >(
9309 xidl_typeobject::runtime::TypeEquivalence::Complete
9310 ),
9311 name: "common",
9312 }],
9313 )
9314 }
9315 }
9316 pub struct CompleteSequenceType {
9317 pub collection_flag: Box<CollectionTypeFlag>,
9318
9319 pub header: Box<CompleteCollectionHeader>,
9320
9321 pub element: Box<CompleteCollectionElement>,
9322 }
9323
9324 impl CompleteSequenceType {
9325 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
9326 }
9327
9328 impl xidl_xcdr::XcdrSerialize for CompleteSequenceType {
9329 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
9330 Self::SERIALIZE_KIND
9331 }
9332
9333 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
9334 &self,
9335 serializer: &mut S,
9336 ) -> xidl_xcdr::error::XcdrResult<()> {
9337 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
9338
9339 serializer.begin_field(xidl_xcdr::FieldId(1u32), false, 0)?;
9340
9341 xidl_xcdr::XcdrSerialize::serialize_with(&self.collection_flag, serializer)?;
9342 serializer.end_field()?;
9343
9344 serializer.begin_field(xidl_xcdr::FieldId(2u32), false, 0)?;
9345
9346 xidl_xcdr::XcdrSerialize::serialize_with(&self.header, serializer)?;
9347 serializer.end_field()?;
9348
9349 serializer.begin_field(xidl_xcdr::FieldId(3u32), false, 0)?;
9350
9351 xidl_xcdr::XcdrSerialize::serialize_with(&self.element, serializer)?;
9352 serializer.end_field()?;
9353
9354 serializer.end_struct()?;
9355 Ok(())
9356 }
9357 }
9358
9359 impl xidl_xcdr::XcdrDeserialize for CompleteSequenceType {
9360 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
9361 deserializer: &mut D,
9362 ) -> xidl_xcdr::error::XcdrResult<Self> {
9363 let collection_flag = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
9364
9365 let header = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
9366
9367 let element = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
9368
9369 Ok(Self {
9370 collection_flag,
9371
9372 header,
9373
9374 element,
9375 })
9376 }
9377 }
9378
9379 impl xidl_typeobject::XidlTypeObject for CompleteSequenceType {
9380 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
9381 xidl_typeobject::runtime::build_minimal_struct(
9382 0u32,
9383 xidl_typeobject::runtime::type_identifier_none(),
9384 vec![
9385 xidl_typeobject::runtime::StructMemberDesc {
9386 member_id: 1u32,
9387 member_flags: 0u32,
9388 type_id: xidl_typeobject::runtime::type_identifier_for::<
9389 CollectionTypeFlag,
9390 >(
9391 xidl_typeobject::runtime::TypeEquivalence::Minimal
9392 ),
9393 name: "collection_flag",
9394 },
9395 xidl_typeobject::runtime::StructMemberDesc {
9396 member_id: 2u32,
9397 member_flags: 0u32,
9398 type_id: xidl_typeobject::runtime::type_identifier_for::<
9399 CompleteCollectionHeader,
9400 >(
9401 xidl_typeobject::runtime::TypeEquivalence::Minimal
9402 ),
9403 name: "header",
9404 },
9405 xidl_typeobject::runtime::StructMemberDesc {
9406 member_id: 3u32,
9407 member_flags: 0u32,
9408 type_id: xidl_typeobject::runtime::type_identifier_for::<
9409 CompleteCollectionElement,
9410 >(
9411 xidl_typeobject::runtime::TypeEquivalence::Minimal
9412 ),
9413 name: "element",
9414 },
9415 ],
9416 )
9417 }
9418
9419 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
9420 xidl_typeobject::runtime::build_complete_struct(
9421 "DDS::XTypes::CompleteSequenceType",
9422 0u32,
9423 xidl_typeobject::runtime::type_identifier_none(),
9424 vec![
9425 xidl_typeobject::runtime::StructMemberDesc {
9426 member_id: 1u32,
9427 member_flags: 0u32,
9428 type_id: xidl_typeobject::runtime::type_identifier_for::<
9429 CollectionTypeFlag,
9430 >(
9431 xidl_typeobject::runtime::TypeEquivalence::Complete
9432 ),
9433 name: "collection_flag",
9434 },
9435 xidl_typeobject::runtime::StructMemberDesc {
9436 member_id: 2u32,
9437 member_flags: 0u32,
9438 type_id: xidl_typeobject::runtime::type_identifier_for::<
9439 CompleteCollectionHeader,
9440 >(
9441 xidl_typeobject::runtime::TypeEquivalence::Complete
9442 ),
9443 name: "header",
9444 },
9445 xidl_typeobject::runtime::StructMemberDesc {
9446 member_id: 3u32,
9447 member_flags: 0u32,
9448 type_id: xidl_typeobject::runtime::type_identifier_for::<
9449 CompleteCollectionElement,
9450 >(
9451 xidl_typeobject::runtime::TypeEquivalence::Complete
9452 ),
9453 name: "element",
9454 },
9455 ],
9456 )
9457 }
9458 }
9459 pub struct MinimalSequenceType {
9460 pub collection_flag: Box<CollectionTypeFlag>,
9461
9462 pub header: Box<MinimalCollectionHeader>,
9463
9464 pub element: Box<MinimalCollectionElement>,
9465 }
9466
9467 impl MinimalSequenceType {
9468 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
9469 }
9470
9471 impl xidl_xcdr::XcdrSerialize for MinimalSequenceType {
9472 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
9473 Self::SERIALIZE_KIND
9474 }
9475
9476 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
9477 &self,
9478 serializer: &mut S,
9479 ) -> xidl_xcdr::error::XcdrResult<()> {
9480 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
9481
9482 serializer.begin_field(xidl_xcdr::FieldId(1u32), false, 0)?;
9483
9484 xidl_xcdr::XcdrSerialize::serialize_with(&self.collection_flag, serializer)?;
9485 serializer.end_field()?;
9486
9487 serializer.begin_field(xidl_xcdr::FieldId(2u32), false, 0)?;
9488
9489 xidl_xcdr::XcdrSerialize::serialize_with(&self.header, serializer)?;
9490 serializer.end_field()?;
9491
9492 serializer.begin_field(xidl_xcdr::FieldId(3u32), false, 0)?;
9493
9494 xidl_xcdr::XcdrSerialize::serialize_with(&self.element, serializer)?;
9495 serializer.end_field()?;
9496
9497 serializer.end_struct()?;
9498 Ok(())
9499 }
9500 }
9501
9502 impl xidl_xcdr::XcdrDeserialize for MinimalSequenceType {
9503 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
9504 deserializer: &mut D,
9505 ) -> xidl_xcdr::error::XcdrResult<Self> {
9506 let collection_flag = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
9507
9508 let header = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
9509
9510 let element = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
9511
9512 Ok(Self {
9513 collection_flag,
9514
9515 header,
9516
9517 element,
9518 })
9519 }
9520 }
9521
9522 impl xidl_typeobject::XidlTypeObject for MinimalSequenceType {
9523 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
9524 xidl_typeobject::runtime::build_minimal_struct(
9525 0u32,
9526 xidl_typeobject::runtime::type_identifier_none(),
9527 vec![
9528 xidl_typeobject::runtime::StructMemberDesc {
9529 member_id: 1u32,
9530 member_flags: 0u32,
9531 type_id: xidl_typeobject::runtime::type_identifier_for::<
9532 CollectionTypeFlag,
9533 >(
9534 xidl_typeobject::runtime::TypeEquivalence::Minimal
9535 ),
9536 name: "collection_flag",
9537 },
9538 xidl_typeobject::runtime::StructMemberDesc {
9539 member_id: 2u32,
9540 member_flags: 0u32,
9541 type_id: xidl_typeobject::runtime::type_identifier_for::<
9542 MinimalCollectionHeader,
9543 >(
9544 xidl_typeobject::runtime::TypeEquivalence::Minimal
9545 ),
9546 name: "header",
9547 },
9548 xidl_typeobject::runtime::StructMemberDesc {
9549 member_id: 3u32,
9550 member_flags: 0u32,
9551 type_id: xidl_typeobject::runtime::type_identifier_for::<
9552 MinimalCollectionElement,
9553 >(
9554 xidl_typeobject::runtime::TypeEquivalence::Minimal
9555 ),
9556 name: "element",
9557 },
9558 ],
9559 )
9560 }
9561
9562 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
9563 xidl_typeobject::runtime::build_complete_struct(
9564 "DDS::XTypes::MinimalSequenceType",
9565 0u32,
9566 xidl_typeobject::runtime::type_identifier_none(),
9567 vec![
9568 xidl_typeobject::runtime::StructMemberDesc {
9569 member_id: 1u32,
9570 member_flags: 0u32,
9571 type_id: xidl_typeobject::runtime::type_identifier_for::<
9572 CollectionTypeFlag,
9573 >(
9574 xidl_typeobject::runtime::TypeEquivalence::Complete
9575 ),
9576 name: "collection_flag",
9577 },
9578 xidl_typeobject::runtime::StructMemberDesc {
9579 member_id: 2u32,
9580 member_flags: 0u32,
9581 type_id: xidl_typeobject::runtime::type_identifier_for::<
9582 MinimalCollectionHeader,
9583 >(
9584 xidl_typeobject::runtime::TypeEquivalence::Complete
9585 ),
9586 name: "header",
9587 },
9588 xidl_typeobject::runtime::StructMemberDesc {
9589 member_id: 3u32,
9590 member_flags: 0u32,
9591 type_id: xidl_typeobject::runtime::type_identifier_for::<
9592 MinimalCollectionElement,
9593 >(
9594 xidl_typeobject::runtime::TypeEquivalence::Complete
9595 ),
9596 name: "element",
9597 },
9598 ],
9599 )
9600 }
9601 }
9602 pub struct CommonArrayHeader {
9603 pub bound_seq: Box<LBoundSeq>,
9604 }
9605
9606 impl CommonArrayHeader {
9607 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
9608 }
9609
9610 impl xidl_xcdr::XcdrSerialize for CommonArrayHeader {
9611 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
9612 Self::SERIALIZE_KIND
9613 }
9614
9615 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
9616 &self,
9617 serializer: &mut S,
9618 ) -> xidl_xcdr::error::XcdrResult<()> {
9619 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
9620
9621 serializer.begin_field(xidl_xcdr::FieldId(1u32), false, 0)?;
9622
9623 xidl_xcdr::XcdrSerialize::serialize_with(&self.bound_seq, serializer)?;
9624 serializer.end_field()?;
9625
9626 serializer.end_struct()?;
9627 Ok(())
9628 }
9629 }
9630
9631 impl xidl_xcdr::XcdrDeserialize for CommonArrayHeader {
9632 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
9633 deserializer: &mut D,
9634 ) -> xidl_xcdr::error::XcdrResult<Self> {
9635 let bound_seq = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
9636
9637 Ok(Self { bound_seq })
9638 }
9639 }
9640
9641 impl xidl_typeobject::XidlTypeObject for CommonArrayHeader {
9642 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
9643 xidl_typeobject::runtime::build_minimal_struct(
9644 0u32,
9645 xidl_typeobject::runtime::type_identifier_none(),
9646 vec![xidl_typeobject::runtime::StructMemberDesc {
9647 member_id: 1u32,
9648 member_flags: 0u32,
9649 type_id: xidl_typeobject::runtime::type_identifier_for::<LBoundSeq>(
9650 xidl_typeobject::runtime::TypeEquivalence::Minimal,
9651 ),
9652 name: "bound_seq",
9653 }],
9654 )
9655 }
9656
9657 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
9658 xidl_typeobject::runtime::build_complete_struct(
9659 "DDS::XTypes::CommonArrayHeader",
9660 0u32,
9661 xidl_typeobject::runtime::type_identifier_none(),
9662 vec![xidl_typeobject::runtime::StructMemberDesc {
9663 member_id: 1u32,
9664 member_flags: 0u32,
9665 type_id: xidl_typeobject::runtime::type_identifier_for::<LBoundSeq>(
9666 xidl_typeobject::runtime::TypeEquivalence::Complete,
9667 ),
9668 name: "bound_seq",
9669 }],
9670 )
9671 }
9672 }
9673 pub struct CompleteArrayHeader {
9674 pub common: Box<CommonArrayHeader>,
9675
9676 pub detail: Box<CompleteTypeDetail>,
9677 }
9678
9679 impl CompleteArrayHeader {
9680 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
9681 }
9682
9683 impl xidl_xcdr::XcdrSerialize for CompleteArrayHeader {
9684 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
9685 Self::SERIALIZE_KIND
9686 }
9687
9688 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
9689 &self,
9690 serializer: &mut S,
9691 ) -> xidl_xcdr::error::XcdrResult<()> {
9692 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
9693
9694 serializer.begin_field(xidl_xcdr::FieldId(1u32), false, 0)?;
9695
9696 xidl_xcdr::XcdrSerialize::serialize_with(&self.common, serializer)?;
9697 serializer.end_field()?;
9698
9699 serializer.begin_field(xidl_xcdr::FieldId(2u32), false, 0)?;
9700
9701 xidl_xcdr::XcdrSerialize::serialize_with(&self.detail, serializer)?;
9702 serializer.end_field()?;
9703
9704 serializer.end_struct()?;
9705 Ok(())
9706 }
9707 }
9708
9709 impl xidl_xcdr::XcdrDeserialize for CompleteArrayHeader {
9710 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
9711 deserializer: &mut D,
9712 ) -> xidl_xcdr::error::XcdrResult<Self> {
9713 let common = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
9714
9715 let detail = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
9716
9717 Ok(Self { common, detail })
9718 }
9719 }
9720
9721 impl xidl_typeobject::XidlTypeObject for CompleteArrayHeader {
9722 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
9723 xidl_typeobject::runtime::build_minimal_struct(
9724 0u32,
9725 xidl_typeobject::runtime::type_identifier_none(),
9726 vec![
9727 xidl_typeobject::runtime::StructMemberDesc {
9728 member_id: 1u32,
9729 member_flags: 0u32,
9730 type_id: xidl_typeobject::runtime::type_identifier_for::<
9731 CommonArrayHeader,
9732 >(
9733 xidl_typeobject::runtime::TypeEquivalence::Minimal
9734 ),
9735 name: "common",
9736 },
9737 xidl_typeobject::runtime::StructMemberDesc {
9738 member_id: 2u32,
9739 member_flags: 0u32,
9740 type_id: xidl_typeobject::runtime::type_identifier_for::<
9741 CompleteTypeDetail,
9742 >(
9743 xidl_typeobject::runtime::TypeEquivalence::Minimal
9744 ),
9745 name: "detail",
9746 },
9747 ],
9748 )
9749 }
9750
9751 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
9752 xidl_typeobject::runtime::build_complete_struct(
9753 "DDS::XTypes::CompleteArrayHeader",
9754 0u32,
9755 xidl_typeobject::runtime::type_identifier_none(),
9756 vec![
9757 xidl_typeobject::runtime::StructMemberDesc {
9758 member_id: 1u32,
9759 member_flags: 0u32,
9760 type_id: xidl_typeobject::runtime::type_identifier_for::<
9761 CommonArrayHeader,
9762 >(
9763 xidl_typeobject::runtime::TypeEquivalence::Complete
9764 ),
9765 name: "common",
9766 },
9767 xidl_typeobject::runtime::StructMemberDesc {
9768 member_id: 2u32,
9769 member_flags: 0u32,
9770 type_id: xidl_typeobject::runtime::type_identifier_for::<
9771 CompleteTypeDetail,
9772 >(
9773 xidl_typeobject::runtime::TypeEquivalence::Complete
9774 ),
9775 name: "detail",
9776 },
9777 ],
9778 )
9779 }
9780 }
9781 pub struct MinimalArrayHeader {
9782 pub common: Box<CommonArrayHeader>,
9783 }
9784
9785 impl MinimalArrayHeader {
9786 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
9787 }
9788
9789 impl xidl_xcdr::XcdrSerialize for MinimalArrayHeader {
9790 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
9791 Self::SERIALIZE_KIND
9792 }
9793
9794 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
9795 &self,
9796 serializer: &mut S,
9797 ) -> xidl_xcdr::error::XcdrResult<()> {
9798 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
9799
9800 serializer.begin_field(xidl_xcdr::FieldId(1u32), false, 0)?;
9801
9802 xidl_xcdr::XcdrSerialize::serialize_with(&self.common, serializer)?;
9803 serializer.end_field()?;
9804
9805 serializer.end_struct()?;
9806 Ok(())
9807 }
9808 }
9809
9810 impl xidl_xcdr::XcdrDeserialize for MinimalArrayHeader {
9811 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
9812 deserializer: &mut D,
9813 ) -> xidl_xcdr::error::XcdrResult<Self> {
9814 let common = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
9815
9816 Ok(Self { common })
9817 }
9818 }
9819
9820 impl xidl_typeobject::XidlTypeObject for MinimalArrayHeader {
9821 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
9822 xidl_typeobject::runtime::build_minimal_struct(
9823 0u32,
9824 xidl_typeobject::runtime::type_identifier_none(),
9825 vec![xidl_typeobject::runtime::StructMemberDesc {
9826 member_id: 1u32,
9827 member_flags: 0u32,
9828 type_id: xidl_typeobject::runtime::type_identifier_for::<CommonArrayHeader>(
9829 xidl_typeobject::runtime::TypeEquivalence::Minimal,
9830 ),
9831 name: "common",
9832 }],
9833 )
9834 }
9835
9836 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
9837 xidl_typeobject::runtime::build_complete_struct(
9838 "DDS::XTypes::MinimalArrayHeader",
9839 0u32,
9840 xidl_typeobject::runtime::type_identifier_none(),
9841 vec![xidl_typeobject::runtime::StructMemberDesc {
9842 member_id: 1u32,
9843 member_flags: 0u32,
9844 type_id: xidl_typeobject::runtime::type_identifier_for::<CommonArrayHeader>(
9845 xidl_typeobject::runtime::TypeEquivalence::Complete,
9846 ),
9847 name: "common",
9848 }],
9849 )
9850 }
9851 }
9852 pub struct CompleteArrayType {
9853 pub collection_flag: Box<CollectionTypeFlag>,
9854
9855 pub header: Box<CompleteArrayHeader>,
9856
9857 pub element: Box<CompleteCollectionElement>,
9858 }
9859
9860 impl CompleteArrayType {
9861 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
9862 }
9863
9864 impl xidl_xcdr::XcdrSerialize for CompleteArrayType {
9865 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
9866 Self::SERIALIZE_KIND
9867 }
9868
9869 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
9870 &self,
9871 serializer: &mut S,
9872 ) -> xidl_xcdr::error::XcdrResult<()> {
9873 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
9874
9875 serializer.begin_field(xidl_xcdr::FieldId(1u32), false, 0)?;
9876
9877 xidl_xcdr::XcdrSerialize::serialize_with(&self.collection_flag, serializer)?;
9878 serializer.end_field()?;
9879
9880 serializer.begin_field(xidl_xcdr::FieldId(2u32), false, 0)?;
9881
9882 xidl_xcdr::XcdrSerialize::serialize_with(&self.header, serializer)?;
9883 serializer.end_field()?;
9884
9885 serializer.begin_field(xidl_xcdr::FieldId(3u32), false, 0)?;
9886
9887 xidl_xcdr::XcdrSerialize::serialize_with(&self.element, serializer)?;
9888 serializer.end_field()?;
9889
9890 serializer.end_struct()?;
9891 Ok(())
9892 }
9893 }
9894
9895 impl xidl_xcdr::XcdrDeserialize for CompleteArrayType {
9896 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
9897 deserializer: &mut D,
9898 ) -> xidl_xcdr::error::XcdrResult<Self> {
9899 let collection_flag = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
9900
9901 let header = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
9902
9903 let element = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
9904
9905 Ok(Self {
9906 collection_flag,
9907
9908 header,
9909
9910 element,
9911 })
9912 }
9913 }
9914
9915 impl xidl_typeobject::XidlTypeObject for CompleteArrayType {
9916 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
9917 xidl_typeobject::runtime::build_minimal_struct(
9918 0u32,
9919 xidl_typeobject::runtime::type_identifier_none(),
9920 vec![
9921 xidl_typeobject::runtime::StructMemberDesc {
9922 member_id: 1u32,
9923 member_flags: 0u32,
9924 type_id: xidl_typeobject::runtime::type_identifier_for::<
9925 CollectionTypeFlag,
9926 >(
9927 xidl_typeobject::runtime::TypeEquivalence::Minimal
9928 ),
9929 name: "collection_flag",
9930 },
9931 xidl_typeobject::runtime::StructMemberDesc {
9932 member_id: 2u32,
9933 member_flags: 0u32,
9934 type_id: xidl_typeobject::runtime::type_identifier_for::<
9935 CompleteArrayHeader,
9936 >(
9937 xidl_typeobject::runtime::TypeEquivalence::Minimal
9938 ),
9939 name: "header",
9940 },
9941 xidl_typeobject::runtime::StructMemberDesc {
9942 member_id: 3u32,
9943 member_flags: 0u32,
9944 type_id: xidl_typeobject::runtime::type_identifier_for::<
9945 CompleteCollectionElement,
9946 >(
9947 xidl_typeobject::runtime::TypeEquivalence::Minimal
9948 ),
9949 name: "element",
9950 },
9951 ],
9952 )
9953 }
9954
9955 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
9956 xidl_typeobject::runtime::build_complete_struct(
9957 "DDS::XTypes::CompleteArrayType",
9958 0u32,
9959 xidl_typeobject::runtime::type_identifier_none(),
9960 vec![
9961 xidl_typeobject::runtime::StructMemberDesc {
9962 member_id: 1u32,
9963 member_flags: 0u32,
9964 type_id: xidl_typeobject::runtime::type_identifier_for::<
9965 CollectionTypeFlag,
9966 >(
9967 xidl_typeobject::runtime::TypeEquivalence::Complete
9968 ),
9969 name: "collection_flag",
9970 },
9971 xidl_typeobject::runtime::StructMemberDesc {
9972 member_id: 2u32,
9973 member_flags: 0u32,
9974 type_id: xidl_typeobject::runtime::type_identifier_for::<
9975 CompleteArrayHeader,
9976 >(
9977 xidl_typeobject::runtime::TypeEquivalence::Complete
9978 ),
9979 name: "header",
9980 },
9981 xidl_typeobject::runtime::StructMemberDesc {
9982 member_id: 3u32,
9983 member_flags: 0u32,
9984 type_id: xidl_typeobject::runtime::type_identifier_for::<
9985 CompleteCollectionElement,
9986 >(
9987 xidl_typeobject::runtime::TypeEquivalence::Complete
9988 ),
9989 name: "element",
9990 },
9991 ],
9992 )
9993 }
9994 }
9995 pub struct MinimalArrayType {
9996 pub collection_flag: Box<CollectionTypeFlag>,
9997
9998 pub header: Box<MinimalArrayHeader>,
9999
10000 pub element: Box<MinimalCollectionElement>,
10001 }
10002
10003 impl MinimalArrayType {
10004 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
10005 }
10006
10007 impl xidl_xcdr::XcdrSerialize for MinimalArrayType {
10008 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
10009 Self::SERIALIZE_KIND
10010 }
10011
10012 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
10013 &self,
10014 serializer: &mut S,
10015 ) -> xidl_xcdr::error::XcdrResult<()> {
10016 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
10017
10018 serializer.begin_field(xidl_xcdr::FieldId(1u32), false, 0)?;
10019
10020 xidl_xcdr::XcdrSerialize::serialize_with(&self.collection_flag, serializer)?;
10021 serializer.end_field()?;
10022
10023 serializer.begin_field(xidl_xcdr::FieldId(2u32), false, 0)?;
10024
10025 xidl_xcdr::XcdrSerialize::serialize_with(&self.header, serializer)?;
10026 serializer.end_field()?;
10027
10028 serializer.begin_field(xidl_xcdr::FieldId(3u32), false, 0)?;
10029
10030 xidl_xcdr::XcdrSerialize::serialize_with(&self.element, serializer)?;
10031 serializer.end_field()?;
10032
10033 serializer.end_struct()?;
10034 Ok(())
10035 }
10036 }
10037
10038 impl xidl_xcdr::XcdrDeserialize for MinimalArrayType {
10039 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
10040 deserializer: &mut D,
10041 ) -> xidl_xcdr::error::XcdrResult<Self> {
10042 let collection_flag = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
10043
10044 let header = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
10045
10046 let element = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
10047
10048 Ok(Self {
10049 collection_flag,
10050
10051 header,
10052
10053 element,
10054 })
10055 }
10056 }
10057
10058 impl xidl_typeobject::XidlTypeObject for MinimalArrayType {
10059 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
10060 xidl_typeobject::runtime::build_minimal_struct(
10061 0u32,
10062 xidl_typeobject::runtime::type_identifier_none(),
10063 vec![
10064 xidl_typeobject::runtime::StructMemberDesc {
10065 member_id: 1u32,
10066 member_flags: 0u32,
10067 type_id: xidl_typeobject::runtime::type_identifier_for::<
10068 CollectionTypeFlag,
10069 >(
10070 xidl_typeobject::runtime::TypeEquivalence::Minimal
10071 ),
10072 name: "collection_flag",
10073 },
10074 xidl_typeobject::runtime::StructMemberDesc {
10075 member_id: 2u32,
10076 member_flags: 0u32,
10077 type_id: xidl_typeobject::runtime::type_identifier_for::<
10078 MinimalArrayHeader,
10079 >(
10080 xidl_typeobject::runtime::TypeEquivalence::Minimal
10081 ),
10082 name: "header",
10083 },
10084 xidl_typeobject::runtime::StructMemberDesc {
10085 member_id: 3u32,
10086 member_flags: 0u32,
10087 type_id: xidl_typeobject::runtime::type_identifier_for::<
10088 MinimalCollectionElement,
10089 >(
10090 xidl_typeobject::runtime::TypeEquivalence::Minimal
10091 ),
10092 name: "element",
10093 },
10094 ],
10095 )
10096 }
10097
10098 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
10099 xidl_typeobject::runtime::build_complete_struct(
10100 "DDS::XTypes::MinimalArrayType",
10101 0u32,
10102 xidl_typeobject::runtime::type_identifier_none(),
10103 vec![
10104 xidl_typeobject::runtime::StructMemberDesc {
10105 member_id: 1u32,
10106 member_flags: 0u32,
10107 type_id: xidl_typeobject::runtime::type_identifier_for::<
10108 CollectionTypeFlag,
10109 >(
10110 xidl_typeobject::runtime::TypeEquivalence::Complete
10111 ),
10112 name: "collection_flag",
10113 },
10114 xidl_typeobject::runtime::StructMemberDesc {
10115 member_id: 2u32,
10116 member_flags: 0u32,
10117 type_id: xidl_typeobject::runtime::type_identifier_for::<
10118 MinimalArrayHeader,
10119 >(
10120 xidl_typeobject::runtime::TypeEquivalence::Complete
10121 ),
10122 name: "header",
10123 },
10124 xidl_typeobject::runtime::StructMemberDesc {
10125 member_id: 3u32,
10126 member_flags: 0u32,
10127 type_id: xidl_typeobject::runtime::type_identifier_for::<
10128 MinimalCollectionElement,
10129 >(
10130 xidl_typeobject::runtime::TypeEquivalence::Complete
10131 ),
10132 name: "element",
10133 },
10134 ],
10135 )
10136 }
10137 }
10138 pub struct CompleteMapType {
10139 pub collection_flag: Box<CollectionTypeFlag>,
10140
10141 pub header: Box<CompleteCollectionHeader>,
10142
10143 pub key: Box<CompleteCollectionElement>,
10144
10145 pub element: Box<CompleteCollectionElement>,
10146 }
10147
10148 impl CompleteMapType {
10149 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
10150 }
10151
10152 impl xidl_xcdr::XcdrSerialize for CompleteMapType {
10153 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
10154 Self::SERIALIZE_KIND
10155 }
10156
10157 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
10158 &self,
10159 serializer: &mut S,
10160 ) -> xidl_xcdr::error::XcdrResult<()> {
10161 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
10162
10163 serializer.begin_field(xidl_xcdr::FieldId(1u32), false, 0)?;
10164
10165 xidl_xcdr::XcdrSerialize::serialize_with(&self.collection_flag, serializer)?;
10166 serializer.end_field()?;
10167
10168 serializer.begin_field(xidl_xcdr::FieldId(2u32), false, 0)?;
10169
10170 xidl_xcdr::XcdrSerialize::serialize_with(&self.header, serializer)?;
10171 serializer.end_field()?;
10172
10173 serializer.begin_field(xidl_xcdr::FieldId(3u32), false, 0)?;
10174
10175 xidl_xcdr::XcdrSerialize::serialize_with(&self.key, serializer)?;
10176 serializer.end_field()?;
10177
10178 serializer.begin_field(xidl_xcdr::FieldId(4u32), false, 0)?;
10179
10180 xidl_xcdr::XcdrSerialize::serialize_with(&self.element, serializer)?;
10181 serializer.end_field()?;
10182
10183 serializer.end_struct()?;
10184 Ok(())
10185 }
10186 }
10187
10188 impl xidl_xcdr::XcdrDeserialize for CompleteMapType {
10189 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
10190 deserializer: &mut D,
10191 ) -> xidl_xcdr::error::XcdrResult<Self> {
10192 let collection_flag = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
10193
10194 let header = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
10195
10196 let key = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
10197
10198 let element = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
10199
10200 Ok(Self {
10201 collection_flag,
10202
10203 header,
10204
10205 key,
10206
10207 element,
10208 })
10209 }
10210 }
10211
10212 impl xidl_typeobject::XidlTypeObject for CompleteMapType {
10213 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
10214 xidl_typeobject::runtime::build_minimal_struct(
10215 0u32,
10216 xidl_typeobject::runtime::type_identifier_none(),
10217 vec![
10218 xidl_typeobject::runtime::StructMemberDesc {
10219 member_id: 1u32,
10220 member_flags: 0u32,
10221 type_id: xidl_typeobject::runtime::type_identifier_for::<
10222 CollectionTypeFlag,
10223 >(
10224 xidl_typeobject::runtime::TypeEquivalence::Minimal
10225 ),
10226 name: "collection_flag",
10227 },
10228 xidl_typeobject::runtime::StructMemberDesc {
10229 member_id: 2u32,
10230 member_flags: 0u32,
10231 type_id: xidl_typeobject::runtime::type_identifier_for::<
10232 CompleteCollectionHeader,
10233 >(
10234 xidl_typeobject::runtime::TypeEquivalence::Minimal
10235 ),
10236 name: "header",
10237 },
10238 xidl_typeobject::runtime::StructMemberDesc {
10239 member_id: 3u32,
10240 member_flags: 0u32,
10241 type_id: xidl_typeobject::runtime::type_identifier_for::<
10242 CompleteCollectionElement,
10243 >(
10244 xidl_typeobject::runtime::TypeEquivalence::Minimal
10245 ),
10246 name: "key",
10247 },
10248 xidl_typeobject::runtime::StructMemberDesc {
10249 member_id: 4u32,
10250 member_flags: 0u32,
10251 type_id: xidl_typeobject::runtime::type_identifier_for::<
10252 CompleteCollectionElement,
10253 >(
10254 xidl_typeobject::runtime::TypeEquivalence::Minimal
10255 ),
10256 name: "element",
10257 },
10258 ],
10259 )
10260 }
10261
10262 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
10263 xidl_typeobject::runtime::build_complete_struct(
10264 "DDS::XTypes::CompleteMapType",
10265 0u32,
10266 xidl_typeobject::runtime::type_identifier_none(),
10267 vec![
10268 xidl_typeobject::runtime::StructMemberDesc {
10269 member_id: 1u32,
10270 member_flags: 0u32,
10271 type_id: xidl_typeobject::runtime::type_identifier_for::<
10272 CollectionTypeFlag,
10273 >(
10274 xidl_typeobject::runtime::TypeEquivalence::Complete
10275 ),
10276 name: "collection_flag",
10277 },
10278 xidl_typeobject::runtime::StructMemberDesc {
10279 member_id: 2u32,
10280 member_flags: 0u32,
10281 type_id: xidl_typeobject::runtime::type_identifier_for::<
10282 CompleteCollectionHeader,
10283 >(
10284 xidl_typeobject::runtime::TypeEquivalence::Complete
10285 ),
10286 name: "header",
10287 },
10288 xidl_typeobject::runtime::StructMemberDesc {
10289 member_id: 3u32,
10290 member_flags: 0u32,
10291 type_id: xidl_typeobject::runtime::type_identifier_for::<
10292 CompleteCollectionElement,
10293 >(
10294 xidl_typeobject::runtime::TypeEquivalence::Complete
10295 ),
10296 name: "key",
10297 },
10298 xidl_typeobject::runtime::StructMemberDesc {
10299 member_id: 4u32,
10300 member_flags: 0u32,
10301 type_id: xidl_typeobject::runtime::type_identifier_for::<
10302 CompleteCollectionElement,
10303 >(
10304 xidl_typeobject::runtime::TypeEquivalence::Complete
10305 ),
10306 name: "element",
10307 },
10308 ],
10309 )
10310 }
10311 }
10312 pub struct MinimalMapType {
10313 pub collection_flag: Box<CollectionTypeFlag>,
10314
10315 pub header: Box<MinimalCollectionHeader>,
10316
10317 pub key: Box<MinimalCollectionElement>,
10318
10319 pub element: Box<MinimalCollectionElement>,
10320 }
10321
10322 impl MinimalMapType {
10323 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
10324 }
10325
10326 impl xidl_xcdr::XcdrSerialize for MinimalMapType {
10327 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
10328 Self::SERIALIZE_KIND
10329 }
10330
10331 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
10332 &self,
10333 serializer: &mut S,
10334 ) -> xidl_xcdr::error::XcdrResult<()> {
10335 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
10336
10337 serializer.begin_field(xidl_xcdr::FieldId(1u32), false, 0)?;
10338
10339 xidl_xcdr::XcdrSerialize::serialize_with(&self.collection_flag, serializer)?;
10340 serializer.end_field()?;
10341
10342 serializer.begin_field(xidl_xcdr::FieldId(2u32), false, 0)?;
10343
10344 xidl_xcdr::XcdrSerialize::serialize_with(&self.header, serializer)?;
10345 serializer.end_field()?;
10346
10347 serializer.begin_field(xidl_xcdr::FieldId(3u32), false, 0)?;
10348
10349 xidl_xcdr::XcdrSerialize::serialize_with(&self.key, serializer)?;
10350 serializer.end_field()?;
10351
10352 serializer.begin_field(xidl_xcdr::FieldId(4u32), false, 0)?;
10353
10354 xidl_xcdr::XcdrSerialize::serialize_with(&self.element, serializer)?;
10355 serializer.end_field()?;
10356
10357 serializer.end_struct()?;
10358 Ok(())
10359 }
10360 }
10361
10362 impl xidl_xcdr::XcdrDeserialize for MinimalMapType {
10363 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
10364 deserializer: &mut D,
10365 ) -> xidl_xcdr::error::XcdrResult<Self> {
10366 let collection_flag = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
10367
10368 let header = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
10369
10370 let key = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
10371
10372 let element = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
10373
10374 Ok(Self {
10375 collection_flag,
10376
10377 header,
10378
10379 key,
10380
10381 element,
10382 })
10383 }
10384 }
10385
10386 impl xidl_typeobject::XidlTypeObject for MinimalMapType {
10387 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
10388 xidl_typeobject::runtime::build_minimal_struct(
10389 0u32,
10390 xidl_typeobject::runtime::type_identifier_none(),
10391 vec![
10392 xidl_typeobject::runtime::StructMemberDesc {
10393 member_id: 1u32,
10394 member_flags: 0u32,
10395 type_id: xidl_typeobject::runtime::type_identifier_for::<
10396 CollectionTypeFlag,
10397 >(
10398 xidl_typeobject::runtime::TypeEquivalence::Minimal
10399 ),
10400 name: "collection_flag",
10401 },
10402 xidl_typeobject::runtime::StructMemberDesc {
10403 member_id: 2u32,
10404 member_flags: 0u32,
10405 type_id: xidl_typeobject::runtime::type_identifier_for::<
10406 MinimalCollectionHeader,
10407 >(
10408 xidl_typeobject::runtime::TypeEquivalence::Minimal
10409 ),
10410 name: "header",
10411 },
10412 xidl_typeobject::runtime::StructMemberDesc {
10413 member_id: 3u32,
10414 member_flags: 0u32,
10415 type_id: xidl_typeobject::runtime::type_identifier_for::<
10416 MinimalCollectionElement,
10417 >(
10418 xidl_typeobject::runtime::TypeEquivalence::Minimal
10419 ),
10420 name: "key",
10421 },
10422 xidl_typeobject::runtime::StructMemberDesc {
10423 member_id: 4u32,
10424 member_flags: 0u32,
10425 type_id: xidl_typeobject::runtime::type_identifier_for::<
10426 MinimalCollectionElement,
10427 >(
10428 xidl_typeobject::runtime::TypeEquivalence::Minimal
10429 ),
10430 name: "element",
10431 },
10432 ],
10433 )
10434 }
10435
10436 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
10437 xidl_typeobject::runtime::build_complete_struct(
10438 "DDS::XTypes::MinimalMapType",
10439 0u32,
10440 xidl_typeobject::runtime::type_identifier_none(),
10441 vec![
10442 xidl_typeobject::runtime::StructMemberDesc {
10443 member_id: 1u32,
10444 member_flags: 0u32,
10445 type_id: xidl_typeobject::runtime::type_identifier_for::<
10446 CollectionTypeFlag,
10447 >(
10448 xidl_typeobject::runtime::TypeEquivalence::Complete
10449 ),
10450 name: "collection_flag",
10451 },
10452 xidl_typeobject::runtime::StructMemberDesc {
10453 member_id: 2u32,
10454 member_flags: 0u32,
10455 type_id: xidl_typeobject::runtime::type_identifier_for::<
10456 MinimalCollectionHeader,
10457 >(
10458 xidl_typeobject::runtime::TypeEquivalence::Complete
10459 ),
10460 name: "header",
10461 },
10462 xidl_typeobject::runtime::StructMemberDesc {
10463 member_id: 3u32,
10464 member_flags: 0u32,
10465 type_id: xidl_typeobject::runtime::type_identifier_for::<
10466 MinimalCollectionElement,
10467 >(
10468 xidl_typeobject::runtime::TypeEquivalence::Complete
10469 ),
10470 name: "key",
10471 },
10472 xidl_typeobject::runtime::StructMemberDesc {
10473 member_id: 4u32,
10474 member_flags: 0u32,
10475 type_id: xidl_typeobject::runtime::type_identifier_for::<
10476 MinimalCollectionElement,
10477 >(
10478 xidl_typeobject::runtime::TypeEquivalence::Complete
10479 ),
10480 name: "element",
10481 },
10482 ],
10483 )
10484 }
10485 }
10486 pub type BitBound = u16;
10487 pub struct CommonEnumeratedLiteral {
10488 pub value: i32,
10489
10490 pub flags: Box<EnumeratedLiteralFlag>,
10491 }
10492
10493 impl CommonEnumeratedLiteral {
10494 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
10495 }
10496
10497 impl xidl_xcdr::XcdrSerialize for CommonEnumeratedLiteral {
10498 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
10499 Self::SERIALIZE_KIND
10500 }
10501
10502 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
10503 &self,
10504 serializer: &mut S,
10505 ) -> xidl_xcdr::error::XcdrResult<()> {
10506 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
10507
10508 serializer.begin_field(xidl_xcdr::FieldId(1u32), false, 0)?;
10509
10510 xidl_xcdr::XcdrSerialize::serialize_with(&self.value, serializer)?;
10511 serializer.end_field()?;
10512
10513 serializer.begin_field(xidl_xcdr::FieldId(2u32), false, 0)?;
10514
10515 xidl_xcdr::XcdrSerialize::serialize_with(&self.flags, serializer)?;
10516 serializer.end_field()?;
10517
10518 serializer.end_struct()?;
10519 Ok(())
10520 }
10521 }
10522
10523 impl xidl_xcdr::XcdrDeserialize for CommonEnumeratedLiteral {
10524 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
10525 deserializer: &mut D,
10526 ) -> xidl_xcdr::error::XcdrResult<Self> {
10527 let value = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
10528
10529 let flags = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
10530
10531 Ok(Self { value, flags })
10532 }
10533 }
10534
10535 impl xidl_typeobject::XidlTypeObject for CommonEnumeratedLiteral {
10536 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
10537 xidl_typeobject::runtime::build_minimal_struct(
10538 0u32,
10539 xidl_typeobject::runtime::type_identifier_none(),
10540 vec![
10541 xidl_typeobject::runtime::StructMemberDesc {
10542 member_id: 1u32,
10543 member_flags: 0u32,
10544 type_id: xidl_typeobject::runtime::type_identifier_primitive(
10545 xidl_typeobject::DDS::XTypes::TK_INT32,
10546 ),
10547 name: "value",
10548 },
10549 xidl_typeobject::runtime::StructMemberDesc {
10550 member_id: 2u32,
10551 member_flags: 0u32,
10552 type_id: xidl_typeobject::runtime::type_identifier_for::<
10553 EnumeratedLiteralFlag,
10554 >(
10555 xidl_typeobject::runtime::TypeEquivalence::Minimal
10556 ),
10557 name: "flags",
10558 },
10559 ],
10560 )
10561 }
10562
10563 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
10564 xidl_typeobject::runtime::build_complete_struct(
10565 "DDS::XTypes::CommonEnumeratedLiteral",
10566 0u32,
10567 xidl_typeobject::runtime::type_identifier_none(),
10568 vec![
10569 xidl_typeobject::runtime::StructMemberDesc {
10570 member_id: 1u32,
10571 member_flags: 0u32,
10572 type_id: xidl_typeobject::runtime::type_identifier_primitive(
10573 xidl_typeobject::DDS::XTypes::TK_INT32,
10574 ),
10575 name: "value",
10576 },
10577 xidl_typeobject::runtime::StructMemberDesc {
10578 member_id: 2u32,
10579 member_flags: 0u32,
10580 type_id: xidl_typeobject::runtime::type_identifier_for::<
10581 EnumeratedLiteralFlag,
10582 >(
10583 xidl_typeobject::runtime::TypeEquivalence::Complete
10584 ),
10585 name: "flags",
10586 },
10587 ],
10588 )
10589 }
10590 }
10591 pub struct CompleteEnumeratedLiteral {
10592 pub common: Box<CommonEnumeratedLiteral>,
10593
10594 pub detail: Box<CompleteMemberDetail>,
10595 }
10596
10597 impl CompleteEnumeratedLiteral {
10598 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
10599 }
10600
10601 impl xidl_xcdr::XcdrSerialize for CompleteEnumeratedLiteral {
10602 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
10603 Self::SERIALIZE_KIND
10604 }
10605
10606 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
10607 &self,
10608 serializer: &mut S,
10609 ) -> xidl_xcdr::error::XcdrResult<()> {
10610 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
10611
10612 serializer.begin_field(xidl_xcdr::FieldId(1u32), false, 0)?;
10613
10614 xidl_xcdr::XcdrSerialize::serialize_with(&self.common, serializer)?;
10615 serializer.end_field()?;
10616
10617 serializer.begin_field(xidl_xcdr::FieldId(2u32), false, 0)?;
10618
10619 xidl_xcdr::XcdrSerialize::serialize_with(&self.detail, serializer)?;
10620 serializer.end_field()?;
10621
10622 serializer.end_struct()?;
10623 Ok(())
10624 }
10625 }
10626
10627 impl xidl_xcdr::XcdrDeserialize for CompleteEnumeratedLiteral {
10628 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
10629 deserializer: &mut D,
10630 ) -> xidl_xcdr::error::XcdrResult<Self> {
10631 let common = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
10632
10633 let detail = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
10634
10635 Ok(Self { common, detail })
10636 }
10637 }
10638
10639 impl xidl_typeobject::XidlTypeObject for CompleteEnumeratedLiteral {
10640 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
10641 xidl_typeobject::runtime::build_minimal_struct(
10642 0u32,
10643 xidl_typeobject::runtime::type_identifier_none(),
10644 vec![
10645 xidl_typeobject::runtime::StructMemberDesc {
10646 member_id: 1u32,
10647 member_flags: 0u32,
10648 type_id: xidl_typeobject::runtime::type_identifier_for::<
10649 CommonEnumeratedLiteral,
10650 >(
10651 xidl_typeobject::runtime::TypeEquivalence::Minimal
10652 ),
10653 name: "common",
10654 },
10655 xidl_typeobject::runtime::StructMemberDesc {
10656 member_id: 2u32,
10657 member_flags: 0u32,
10658 type_id: xidl_typeobject::runtime::type_identifier_for::<
10659 CompleteMemberDetail,
10660 >(
10661 xidl_typeobject::runtime::TypeEquivalence::Minimal
10662 ),
10663 name: "detail",
10664 },
10665 ],
10666 )
10667 }
10668
10669 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
10670 xidl_typeobject::runtime::build_complete_struct(
10671 "DDS::XTypes::CompleteEnumeratedLiteral",
10672 0u32,
10673 xidl_typeobject::runtime::type_identifier_none(),
10674 vec![
10675 xidl_typeobject::runtime::StructMemberDesc {
10676 member_id: 1u32,
10677 member_flags: 0u32,
10678 type_id: xidl_typeobject::runtime::type_identifier_for::<
10679 CommonEnumeratedLiteral,
10680 >(
10681 xidl_typeobject::runtime::TypeEquivalence::Complete
10682 ),
10683 name: "common",
10684 },
10685 xidl_typeobject::runtime::StructMemberDesc {
10686 member_id: 2u32,
10687 member_flags: 0u32,
10688 type_id: xidl_typeobject::runtime::type_identifier_for::<
10689 CompleteMemberDetail,
10690 >(
10691 xidl_typeobject::runtime::TypeEquivalence::Complete
10692 ),
10693 name: "detail",
10694 },
10695 ],
10696 )
10697 }
10698 }
10699 pub type CompleteEnumeratedLiteralSeq = Vec<CompleteEnumeratedLiteral>;
10700 pub struct MinimalEnumeratedLiteral {
10701 pub common: Box<CommonEnumeratedLiteral>,
10702
10703 pub detail: Box<MinimalMemberDetail>,
10704 }
10705
10706 impl MinimalEnumeratedLiteral {
10707 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
10708 }
10709
10710 impl xidl_xcdr::XcdrSerialize for MinimalEnumeratedLiteral {
10711 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
10712 Self::SERIALIZE_KIND
10713 }
10714
10715 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
10716 &self,
10717 serializer: &mut S,
10718 ) -> xidl_xcdr::error::XcdrResult<()> {
10719 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
10720
10721 serializer.begin_field(xidl_xcdr::FieldId(1u32), false, 0)?;
10722
10723 xidl_xcdr::XcdrSerialize::serialize_with(&self.common, serializer)?;
10724 serializer.end_field()?;
10725
10726 serializer.begin_field(xidl_xcdr::FieldId(2u32), false, 0)?;
10727
10728 xidl_xcdr::XcdrSerialize::serialize_with(&self.detail, serializer)?;
10729 serializer.end_field()?;
10730
10731 serializer.end_struct()?;
10732 Ok(())
10733 }
10734 }
10735
10736 impl xidl_xcdr::XcdrDeserialize for MinimalEnumeratedLiteral {
10737 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
10738 deserializer: &mut D,
10739 ) -> xidl_xcdr::error::XcdrResult<Self> {
10740 let common = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
10741
10742 let detail = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
10743
10744 Ok(Self { common, detail })
10745 }
10746 }
10747
10748 impl xidl_typeobject::XidlTypeObject for MinimalEnumeratedLiteral {
10749 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
10750 xidl_typeobject::runtime::build_minimal_struct(
10751 0u32,
10752 xidl_typeobject::runtime::type_identifier_none(),
10753 vec![
10754 xidl_typeobject::runtime::StructMemberDesc {
10755 member_id: 1u32,
10756 member_flags: 0u32,
10757 type_id: xidl_typeobject::runtime::type_identifier_for::<
10758 CommonEnumeratedLiteral,
10759 >(
10760 xidl_typeobject::runtime::TypeEquivalence::Minimal
10761 ),
10762 name: "common",
10763 },
10764 xidl_typeobject::runtime::StructMemberDesc {
10765 member_id: 2u32,
10766 member_flags: 0u32,
10767 type_id: xidl_typeobject::runtime::type_identifier_for::<
10768 MinimalMemberDetail,
10769 >(
10770 xidl_typeobject::runtime::TypeEquivalence::Minimal
10771 ),
10772 name: "detail",
10773 },
10774 ],
10775 )
10776 }
10777
10778 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
10779 xidl_typeobject::runtime::build_complete_struct(
10780 "DDS::XTypes::MinimalEnumeratedLiteral",
10781 0u32,
10782 xidl_typeobject::runtime::type_identifier_none(),
10783 vec![
10784 xidl_typeobject::runtime::StructMemberDesc {
10785 member_id: 1u32,
10786 member_flags: 0u32,
10787 type_id: xidl_typeobject::runtime::type_identifier_for::<
10788 CommonEnumeratedLiteral,
10789 >(
10790 xidl_typeobject::runtime::TypeEquivalence::Complete
10791 ),
10792 name: "common",
10793 },
10794 xidl_typeobject::runtime::StructMemberDesc {
10795 member_id: 2u32,
10796 member_flags: 0u32,
10797 type_id: xidl_typeobject::runtime::type_identifier_for::<
10798 MinimalMemberDetail,
10799 >(
10800 xidl_typeobject::runtime::TypeEquivalence::Complete
10801 ),
10802 name: "detail",
10803 },
10804 ],
10805 )
10806 }
10807 }
10808 pub type MinimalEnumeratedLiteralSeq = Vec<MinimalEnumeratedLiteral>;
10809 pub struct CommonEnumeratedHeader {
10810 pub bit_bound: Box<BitBound>,
10811 }
10812
10813 impl CommonEnumeratedHeader {
10814 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
10815 }
10816
10817 impl xidl_xcdr::XcdrSerialize for CommonEnumeratedHeader {
10818 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
10819 Self::SERIALIZE_KIND
10820 }
10821
10822 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
10823 &self,
10824 serializer: &mut S,
10825 ) -> xidl_xcdr::error::XcdrResult<()> {
10826 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
10827
10828 serializer.begin_field(xidl_xcdr::FieldId(1u32), false, 0)?;
10829
10830 xidl_xcdr::XcdrSerialize::serialize_with(&self.bit_bound, serializer)?;
10831 serializer.end_field()?;
10832
10833 serializer.end_struct()?;
10834 Ok(())
10835 }
10836 }
10837
10838 impl xidl_xcdr::XcdrDeserialize for CommonEnumeratedHeader {
10839 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
10840 deserializer: &mut D,
10841 ) -> xidl_xcdr::error::XcdrResult<Self> {
10842 let bit_bound = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
10843
10844 Ok(Self { bit_bound })
10845 }
10846 }
10847
10848 impl xidl_typeobject::XidlTypeObject for CommonEnumeratedHeader {
10849 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
10850 xidl_typeobject::runtime::build_minimal_struct(
10851 0u32,
10852 xidl_typeobject::runtime::type_identifier_none(),
10853 vec![xidl_typeobject::runtime::StructMemberDesc {
10854 member_id: 1u32,
10855 member_flags: 0u32,
10856 type_id: xidl_typeobject::runtime::type_identifier_for::<BitBound>(
10857 xidl_typeobject::runtime::TypeEquivalence::Minimal,
10858 ),
10859 name: "bit_bound",
10860 }],
10861 )
10862 }
10863
10864 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
10865 xidl_typeobject::runtime::build_complete_struct(
10866 "DDS::XTypes::CommonEnumeratedHeader",
10867 0u32,
10868 xidl_typeobject::runtime::type_identifier_none(),
10869 vec![xidl_typeobject::runtime::StructMemberDesc {
10870 member_id: 1u32,
10871 member_flags: 0u32,
10872 type_id: xidl_typeobject::runtime::type_identifier_for::<BitBound>(
10873 xidl_typeobject::runtime::TypeEquivalence::Complete,
10874 ),
10875 name: "bit_bound",
10876 }],
10877 )
10878 }
10879 }
10880 pub struct CompleteEnumeratedHeader {
10881 pub common: Box<CommonEnumeratedHeader>,
10882
10883 pub detail: Box<CompleteTypeDetail>,
10884 }
10885
10886 impl CompleteEnumeratedHeader {
10887 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
10888 }
10889
10890 impl xidl_xcdr::XcdrSerialize for CompleteEnumeratedHeader {
10891 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
10892 Self::SERIALIZE_KIND
10893 }
10894
10895 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
10896 &self,
10897 serializer: &mut S,
10898 ) -> xidl_xcdr::error::XcdrResult<()> {
10899 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
10900
10901 serializer.begin_field(xidl_xcdr::FieldId(1u32), false, 0)?;
10902
10903 xidl_xcdr::XcdrSerialize::serialize_with(&self.common, serializer)?;
10904 serializer.end_field()?;
10905
10906 serializer.begin_field(xidl_xcdr::FieldId(2u32), false, 0)?;
10907
10908 xidl_xcdr::XcdrSerialize::serialize_with(&self.detail, serializer)?;
10909 serializer.end_field()?;
10910
10911 serializer.end_struct()?;
10912 Ok(())
10913 }
10914 }
10915
10916 impl xidl_xcdr::XcdrDeserialize for CompleteEnumeratedHeader {
10917 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
10918 deserializer: &mut D,
10919 ) -> xidl_xcdr::error::XcdrResult<Self> {
10920 let common = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
10921
10922 let detail = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
10923
10924 Ok(Self { common, detail })
10925 }
10926 }
10927
10928 impl xidl_typeobject::XidlTypeObject for CompleteEnumeratedHeader {
10929 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
10930 xidl_typeobject::runtime::build_minimal_struct(
10931 0u32,
10932 xidl_typeobject::runtime::type_identifier_none(),
10933 vec![
10934 xidl_typeobject::runtime::StructMemberDesc {
10935 member_id: 1u32,
10936 member_flags: 0u32,
10937 type_id: xidl_typeobject::runtime::type_identifier_for::<
10938 CommonEnumeratedHeader,
10939 >(
10940 xidl_typeobject::runtime::TypeEquivalence::Minimal
10941 ),
10942 name: "common",
10943 },
10944 xidl_typeobject::runtime::StructMemberDesc {
10945 member_id: 2u32,
10946 member_flags: 0u32,
10947 type_id: xidl_typeobject::runtime::type_identifier_for::<
10948 CompleteTypeDetail,
10949 >(
10950 xidl_typeobject::runtime::TypeEquivalence::Minimal
10951 ),
10952 name: "detail",
10953 },
10954 ],
10955 )
10956 }
10957
10958 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
10959 xidl_typeobject::runtime::build_complete_struct(
10960 "DDS::XTypes::CompleteEnumeratedHeader",
10961 0u32,
10962 xidl_typeobject::runtime::type_identifier_none(),
10963 vec![
10964 xidl_typeobject::runtime::StructMemberDesc {
10965 member_id: 1u32,
10966 member_flags: 0u32,
10967 type_id: xidl_typeobject::runtime::type_identifier_for::<
10968 CommonEnumeratedHeader,
10969 >(
10970 xidl_typeobject::runtime::TypeEquivalence::Complete
10971 ),
10972 name: "common",
10973 },
10974 xidl_typeobject::runtime::StructMemberDesc {
10975 member_id: 2u32,
10976 member_flags: 0u32,
10977 type_id: xidl_typeobject::runtime::type_identifier_for::<
10978 CompleteTypeDetail,
10979 >(
10980 xidl_typeobject::runtime::TypeEquivalence::Complete
10981 ),
10982 name: "detail",
10983 },
10984 ],
10985 )
10986 }
10987 }
10988 pub struct MinimalEnumeratedHeader {
10989 pub common: Box<CommonEnumeratedHeader>,
10990 }
10991
10992 impl MinimalEnumeratedHeader {
10993 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
10994 }
10995
10996 impl xidl_xcdr::XcdrSerialize for MinimalEnumeratedHeader {
10997 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
10998 Self::SERIALIZE_KIND
10999 }
11000
11001 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
11002 &self,
11003 serializer: &mut S,
11004 ) -> xidl_xcdr::error::XcdrResult<()> {
11005 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
11006
11007 serializer.begin_field(xidl_xcdr::FieldId(1u32), false, 0)?;
11008
11009 xidl_xcdr::XcdrSerialize::serialize_with(&self.common, serializer)?;
11010 serializer.end_field()?;
11011
11012 serializer.end_struct()?;
11013 Ok(())
11014 }
11015 }
11016
11017 impl xidl_xcdr::XcdrDeserialize for MinimalEnumeratedHeader {
11018 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
11019 deserializer: &mut D,
11020 ) -> xidl_xcdr::error::XcdrResult<Self> {
11021 let common = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
11022
11023 Ok(Self { common })
11024 }
11025 }
11026
11027 impl xidl_typeobject::XidlTypeObject for MinimalEnumeratedHeader {
11028 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
11029 xidl_typeobject::runtime::build_minimal_struct(
11030 0u32,
11031 xidl_typeobject::runtime::type_identifier_none(),
11032 vec![xidl_typeobject::runtime::StructMemberDesc {
11033 member_id: 1u32,
11034 member_flags: 0u32,
11035 type_id: xidl_typeobject::runtime::type_identifier_for::<
11036 CommonEnumeratedHeader,
11037 >(
11038 xidl_typeobject::runtime::TypeEquivalence::Minimal
11039 ),
11040 name: "common",
11041 }],
11042 )
11043 }
11044
11045 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
11046 xidl_typeobject::runtime::build_complete_struct(
11047 "DDS::XTypes::MinimalEnumeratedHeader",
11048 0u32,
11049 xidl_typeobject::runtime::type_identifier_none(),
11050 vec![xidl_typeobject::runtime::StructMemberDesc {
11051 member_id: 1u32,
11052 member_flags: 0u32,
11053 type_id: xidl_typeobject::runtime::type_identifier_for::<
11054 CommonEnumeratedHeader,
11055 >(
11056 xidl_typeobject::runtime::TypeEquivalence::Complete
11057 ),
11058 name: "common",
11059 }],
11060 )
11061 }
11062 }
11063 pub struct CompleteEnumeratedType {
11064 pub enum_flags: Box<EnumTypeFlag>,
11065
11066 pub header: Box<CompleteEnumeratedHeader>,
11067
11068 pub literal_seq: Box<CompleteEnumeratedLiteralSeq>,
11069 }
11070
11071 impl CompleteEnumeratedType {
11072 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
11073 }
11074
11075 impl xidl_xcdr::XcdrSerialize for CompleteEnumeratedType {
11076 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
11077 Self::SERIALIZE_KIND
11078 }
11079
11080 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
11081 &self,
11082 serializer: &mut S,
11083 ) -> xidl_xcdr::error::XcdrResult<()> {
11084 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
11085
11086 serializer.begin_field(xidl_xcdr::FieldId(1u32), false, 0)?;
11087
11088 xidl_xcdr::XcdrSerialize::serialize_with(&self.enum_flags, serializer)?;
11089 serializer.end_field()?;
11090
11091 serializer.begin_field(xidl_xcdr::FieldId(2u32), false, 0)?;
11092
11093 xidl_xcdr::XcdrSerialize::serialize_with(&self.header, serializer)?;
11094 serializer.end_field()?;
11095
11096 serializer.begin_field(xidl_xcdr::FieldId(3u32), false, 0)?;
11097
11098 xidl_xcdr::XcdrSerialize::serialize_with(&self.literal_seq, serializer)?;
11099 serializer.end_field()?;
11100
11101 serializer.end_struct()?;
11102 Ok(())
11103 }
11104 }
11105
11106 impl xidl_xcdr::XcdrDeserialize for CompleteEnumeratedType {
11107 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
11108 deserializer: &mut D,
11109 ) -> xidl_xcdr::error::XcdrResult<Self> {
11110 let enum_flags = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
11111
11112 let header = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
11113
11114 let literal_seq = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
11115
11116 Ok(Self {
11117 enum_flags,
11118
11119 header,
11120
11121 literal_seq,
11122 })
11123 }
11124 }
11125
11126 impl xidl_typeobject::XidlTypeObject for CompleteEnumeratedType {
11127 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
11128 xidl_typeobject::runtime::build_minimal_struct(
11129 0u32,
11130 xidl_typeobject::runtime::type_identifier_none(),
11131 vec![
11132 xidl_typeobject::runtime::StructMemberDesc {
11133 member_id: 1u32,
11134 member_flags: 0u32,
11135 type_id: xidl_typeobject::runtime::type_identifier_for::<EnumTypeFlag>(
11136 xidl_typeobject::runtime::TypeEquivalence::Minimal,
11137 ),
11138 name: "enum_flags",
11139 },
11140 xidl_typeobject::runtime::StructMemberDesc {
11141 member_id: 2u32,
11142 member_flags: 0u32,
11143 type_id: xidl_typeobject::runtime::type_identifier_for::<
11144 CompleteEnumeratedHeader,
11145 >(
11146 xidl_typeobject::runtime::TypeEquivalence::Minimal
11147 ),
11148 name: "header",
11149 },
11150 xidl_typeobject::runtime::StructMemberDesc {
11151 member_id: 3u32,
11152 member_flags: 0u32,
11153 type_id: xidl_typeobject::runtime::type_identifier_for::<
11154 CompleteEnumeratedLiteralSeq,
11155 >(
11156 xidl_typeobject::runtime::TypeEquivalence::Minimal
11157 ),
11158 name: "literal_seq",
11159 },
11160 ],
11161 )
11162 }
11163
11164 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
11165 xidl_typeobject::runtime::build_complete_struct(
11166 "DDS::XTypes::CompleteEnumeratedType",
11167 0u32,
11168 xidl_typeobject::runtime::type_identifier_none(),
11169 vec![
11170 xidl_typeobject::runtime::StructMemberDesc {
11171 member_id: 1u32,
11172 member_flags: 0u32,
11173 type_id: xidl_typeobject::runtime::type_identifier_for::<EnumTypeFlag>(
11174 xidl_typeobject::runtime::TypeEquivalence::Complete,
11175 ),
11176 name: "enum_flags",
11177 },
11178 xidl_typeobject::runtime::StructMemberDesc {
11179 member_id: 2u32,
11180 member_flags: 0u32,
11181 type_id: xidl_typeobject::runtime::type_identifier_for::<
11182 CompleteEnumeratedHeader,
11183 >(
11184 xidl_typeobject::runtime::TypeEquivalence::Complete
11185 ),
11186 name: "header",
11187 },
11188 xidl_typeobject::runtime::StructMemberDesc {
11189 member_id: 3u32,
11190 member_flags: 0u32,
11191 type_id: xidl_typeobject::runtime::type_identifier_for::<
11192 CompleteEnumeratedLiteralSeq,
11193 >(
11194 xidl_typeobject::runtime::TypeEquivalence::Complete
11195 ),
11196 name: "literal_seq",
11197 },
11198 ],
11199 )
11200 }
11201 }
11202 pub struct MinimalEnumeratedType {
11203 pub enum_flags: Box<EnumTypeFlag>,
11204
11205 pub header: Box<MinimalEnumeratedHeader>,
11206
11207 pub literal_seq: Box<MinimalEnumeratedLiteralSeq>,
11208 }
11209
11210 impl MinimalEnumeratedType {
11211 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
11212 }
11213
11214 impl xidl_xcdr::XcdrSerialize for MinimalEnumeratedType {
11215 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
11216 Self::SERIALIZE_KIND
11217 }
11218
11219 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
11220 &self,
11221 serializer: &mut S,
11222 ) -> xidl_xcdr::error::XcdrResult<()> {
11223 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
11224
11225 serializer.begin_field(xidl_xcdr::FieldId(1u32), false, 0)?;
11226
11227 xidl_xcdr::XcdrSerialize::serialize_with(&self.enum_flags, serializer)?;
11228 serializer.end_field()?;
11229
11230 serializer.begin_field(xidl_xcdr::FieldId(2u32), false, 0)?;
11231
11232 xidl_xcdr::XcdrSerialize::serialize_with(&self.header, serializer)?;
11233 serializer.end_field()?;
11234
11235 serializer.begin_field(xidl_xcdr::FieldId(3u32), false, 0)?;
11236
11237 xidl_xcdr::XcdrSerialize::serialize_with(&self.literal_seq, serializer)?;
11238 serializer.end_field()?;
11239
11240 serializer.end_struct()?;
11241 Ok(())
11242 }
11243 }
11244
11245 impl xidl_xcdr::XcdrDeserialize for MinimalEnumeratedType {
11246 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
11247 deserializer: &mut D,
11248 ) -> xidl_xcdr::error::XcdrResult<Self> {
11249 let enum_flags = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
11250
11251 let header = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
11252
11253 let literal_seq = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
11254
11255 Ok(Self {
11256 enum_flags,
11257
11258 header,
11259
11260 literal_seq,
11261 })
11262 }
11263 }
11264
11265 impl xidl_typeobject::XidlTypeObject for MinimalEnumeratedType {
11266 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
11267 xidl_typeobject::runtime::build_minimal_struct(
11268 0u32,
11269 xidl_typeobject::runtime::type_identifier_none(),
11270 vec![
11271 xidl_typeobject::runtime::StructMemberDesc {
11272 member_id: 1u32,
11273 member_flags: 0u32,
11274 type_id: xidl_typeobject::runtime::type_identifier_for::<EnumTypeFlag>(
11275 xidl_typeobject::runtime::TypeEquivalence::Minimal,
11276 ),
11277 name: "enum_flags",
11278 },
11279 xidl_typeobject::runtime::StructMemberDesc {
11280 member_id: 2u32,
11281 member_flags: 0u32,
11282 type_id: xidl_typeobject::runtime::type_identifier_for::<
11283 MinimalEnumeratedHeader,
11284 >(
11285 xidl_typeobject::runtime::TypeEquivalence::Minimal
11286 ),
11287 name: "header",
11288 },
11289 xidl_typeobject::runtime::StructMemberDesc {
11290 member_id: 3u32,
11291 member_flags: 0u32,
11292 type_id: xidl_typeobject::runtime::type_identifier_for::<
11293 MinimalEnumeratedLiteralSeq,
11294 >(
11295 xidl_typeobject::runtime::TypeEquivalence::Minimal
11296 ),
11297 name: "literal_seq",
11298 },
11299 ],
11300 )
11301 }
11302
11303 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
11304 xidl_typeobject::runtime::build_complete_struct(
11305 "DDS::XTypes::MinimalEnumeratedType",
11306 0u32,
11307 xidl_typeobject::runtime::type_identifier_none(),
11308 vec![
11309 xidl_typeobject::runtime::StructMemberDesc {
11310 member_id: 1u32,
11311 member_flags: 0u32,
11312 type_id: xidl_typeobject::runtime::type_identifier_for::<EnumTypeFlag>(
11313 xidl_typeobject::runtime::TypeEquivalence::Complete,
11314 ),
11315 name: "enum_flags",
11316 },
11317 xidl_typeobject::runtime::StructMemberDesc {
11318 member_id: 2u32,
11319 member_flags: 0u32,
11320 type_id: xidl_typeobject::runtime::type_identifier_for::<
11321 MinimalEnumeratedHeader,
11322 >(
11323 xidl_typeobject::runtime::TypeEquivalence::Complete
11324 ),
11325 name: "header",
11326 },
11327 xidl_typeobject::runtime::StructMemberDesc {
11328 member_id: 3u32,
11329 member_flags: 0u32,
11330 type_id: xidl_typeobject::runtime::type_identifier_for::<
11331 MinimalEnumeratedLiteralSeq,
11332 >(
11333 xidl_typeobject::runtime::TypeEquivalence::Complete
11334 ),
11335 name: "literal_seq",
11336 },
11337 ],
11338 )
11339 }
11340 }
11341 pub struct CommonBitflag {
11342 pub position: u16,
11343
11344 pub flags: Box<BitflagFlag>,
11345 }
11346
11347 impl CommonBitflag {
11348 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
11349 }
11350
11351 impl xidl_xcdr::XcdrSerialize for CommonBitflag {
11352 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
11353 Self::SERIALIZE_KIND
11354 }
11355
11356 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
11357 &self,
11358 serializer: &mut S,
11359 ) -> xidl_xcdr::error::XcdrResult<()> {
11360 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
11361
11362 serializer.begin_field(xidl_xcdr::FieldId(1u32), false, 0)?;
11363
11364 xidl_xcdr::XcdrSerialize::serialize_with(&self.position, serializer)?;
11365 serializer.end_field()?;
11366
11367 serializer.begin_field(xidl_xcdr::FieldId(2u32), false, 0)?;
11368
11369 xidl_xcdr::XcdrSerialize::serialize_with(&self.flags, serializer)?;
11370 serializer.end_field()?;
11371
11372 serializer.end_struct()?;
11373 Ok(())
11374 }
11375 }
11376
11377 impl xidl_xcdr::XcdrDeserialize for CommonBitflag {
11378 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
11379 deserializer: &mut D,
11380 ) -> xidl_xcdr::error::XcdrResult<Self> {
11381 let position = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
11382
11383 let flags = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
11384
11385 Ok(Self { position, flags })
11386 }
11387 }
11388
11389 impl xidl_typeobject::XidlTypeObject for CommonBitflag {
11390 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
11391 xidl_typeobject::runtime::build_minimal_struct(
11392 0u32,
11393 xidl_typeobject::runtime::type_identifier_none(),
11394 vec![
11395 xidl_typeobject::runtime::StructMemberDesc {
11396 member_id: 1u32,
11397 member_flags: 0u32,
11398 type_id: xidl_typeobject::runtime::type_identifier_primitive(
11399 xidl_typeobject::DDS::XTypes::TK_UINT16,
11400 ),
11401 name: "position",
11402 },
11403 xidl_typeobject::runtime::StructMemberDesc {
11404 member_id: 2u32,
11405 member_flags: 0u32,
11406 type_id: xidl_typeobject::runtime::type_identifier_for::<BitflagFlag>(
11407 xidl_typeobject::runtime::TypeEquivalence::Minimal,
11408 ),
11409 name: "flags",
11410 },
11411 ],
11412 )
11413 }
11414
11415 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
11416 xidl_typeobject::runtime::build_complete_struct(
11417 "DDS::XTypes::CommonBitflag",
11418 0u32,
11419 xidl_typeobject::runtime::type_identifier_none(),
11420 vec![
11421 xidl_typeobject::runtime::StructMemberDesc {
11422 member_id: 1u32,
11423 member_flags: 0u32,
11424 type_id: xidl_typeobject::runtime::type_identifier_primitive(
11425 xidl_typeobject::DDS::XTypes::TK_UINT16,
11426 ),
11427 name: "position",
11428 },
11429 xidl_typeobject::runtime::StructMemberDesc {
11430 member_id: 2u32,
11431 member_flags: 0u32,
11432 type_id: xidl_typeobject::runtime::type_identifier_for::<BitflagFlag>(
11433 xidl_typeobject::runtime::TypeEquivalence::Complete,
11434 ),
11435 name: "flags",
11436 },
11437 ],
11438 )
11439 }
11440 }
11441 pub struct CompleteBitflag {
11442 pub common: Box<CommonBitflag>,
11443
11444 pub detail: Box<CompleteMemberDetail>,
11445 }
11446
11447 impl CompleteBitflag {
11448 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
11449 }
11450
11451 impl xidl_xcdr::XcdrSerialize for CompleteBitflag {
11452 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
11453 Self::SERIALIZE_KIND
11454 }
11455
11456 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
11457 &self,
11458 serializer: &mut S,
11459 ) -> xidl_xcdr::error::XcdrResult<()> {
11460 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
11461
11462 serializer.begin_field(xidl_xcdr::FieldId(1u32), false, 0)?;
11463
11464 xidl_xcdr::XcdrSerialize::serialize_with(&self.common, serializer)?;
11465 serializer.end_field()?;
11466
11467 serializer.begin_field(xidl_xcdr::FieldId(2u32), false, 0)?;
11468
11469 xidl_xcdr::XcdrSerialize::serialize_with(&self.detail, serializer)?;
11470 serializer.end_field()?;
11471
11472 serializer.end_struct()?;
11473 Ok(())
11474 }
11475 }
11476
11477 impl xidl_xcdr::XcdrDeserialize for CompleteBitflag {
11478 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
11479 deserializer: &mut D,
11480 ) -> xidl_xcdr::error::XcdrResult<Self> {
11481 let common = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
11482
11483 let detail = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
11484
11485 Ok(Self { common, detail })
11486 }
11487 }
11488
11489 impl xidl_typeobject::XidlTypeObject for CompleteBitflag {
11490 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
11491 xidl_typeobject::runtime::build_minimal_struct(
11492 0u32,
11493 xidl_typeobject::runtime::type_identifier_none(),
11494 vec![
11495 xidl_typeobject::runtime::StructMemberDesc {
11496 member_id: 1u32,
11497 member_flags: 0u32,
11498 type_id: xidl_typeobject::runtime::type_identifier_for::<CommonBitflag>(
11499 xidl_typeobject::runtime::TypeEquivalence::Minimal,
11500 ),
11501 name: "common",
11502 },
11503 xidl_typeobject::runtime::StructMemberDesc {
11504 member_id: 2u32,
11505 member_flags: 0u32,
11506 type_id: xidl_typeobject::runtime::type_identifier_for::<
11507 CompleteMemberDetail,
11508 >(
11509 xidl_typeobject::runtime::TypeEquivalence::Minimal
11510 ),
11511 name: "detail",
11512 },
11513 ],
11514 )
11515 }
11516
11517 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
11518 xidl_typeobject::runtime::build_complete_struct(
11519 "DDS::XTypes::CompleteBitflag",
11520 0u32,
11521 xidl_typeobject::runtime::type_identifier_none(),
11522 vec![
11523 xidl_typeobject::runtime::StructMemberDesc {
11524 member_id: 1u32,
11525 member_flags: 0u32,
11526 type_id: xidl_typeobject::runtime::type_identifier_for::<CommonBitflag>(
11527 xidl_typeobject::runtime::TypeEquivalence::Complete,
11528 ),
11529 name: "common",
11530 },
11531 xidl_typeobject::runtime::StructMemberDesc {
11532 member_id: 2u32,
11533 member_flags: 0u32,
11534 type_id: xidl_typeobject::runtime::type_identifier_for::<
11535 CompleteMemberDetail,
11536 >(
11537 xidl_typeobject::runtime::TypeEquivalence::Complete
11538 ),
11539 name: "detail",
11540 },
11541 ],
11542 )
11543 }
11544 }
11545 pub type CompleteBitflagSeq = Vec<CompleteBitflag>;
11546 pub struct MinimalBitflag {
11547 pub common: Box<CommonBitflag>,
11548
11549 pub detail: Box<MinimalMemberDetail>,
11550 }
11551
11552 impl MinimalBitflag {
11553 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
11554 }
11555
11556 impl xidl_xcdr::XcdrSerialize for MinimalBitflag {
11557 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
11558 Self::SERIALIZE_KIND
11559 }
11560
11561 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
11562 &self,
11563 serializer: &mut S,
11564 ) -> xidl_xcdr::error::XcdrResult<()> {
11565 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
11566
11567 serializer.begin_field(xidl_xcdr::FieldId(1u32), false, 0)?;
11568
11569 xidl_xcdr::XcdrSerialize::serialize_with(&self.common, serializer)?;
11570 serializer.end_field()?;
11571
11572 serializer.begin_field(xidl_xcdr::FieldId(2u32), false, 0)?;
11573
11574 xidl_xcdr::XcdrSerialize::serialize_with(&self.detail, serializer)?;
11575 serializer.end_field()?;
11576
11577 serializer.end_struct()?;
11578 Ok(())
11579 }
11580 }
11581
11582 impl xidl_xcdr::XcdrDeserialize for MinimalBitflag {
11583 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
11584 deserializer: &mut D,
11585 ) -> xidl_xcdr::error::XcdrResult<Self> {
11586 let common = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
11587
11588 let detail = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
11589
11590 Ok(Self { common, detail })
11591 }
11592 }
11593
11594 impl xidl_typeobject::XidlTypeObject for MinimalBitflag {
11595 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
11596 xidl_typeobject::runtime::build_minimal_struct(
11597 0u32,
11598 xidl_typeobject::runtime::type_identifier_none(),
11599 vec![
11600 xidl_typeobject::runtime::StructMemberDesc {
11601 member_id: 1u32,
11602 member_flags: 0u32,
11603 type_id: xidl_typeobject::runtime::type_identifier_for::<CommonBitflag>(
11604 xidl_typeobject::runtime::TypeEquivalence::Minimal,
11605 ),
11606 name: "common",
11607 },
11608 xidl_typeobject::runtime::StructMemberDesc {
11609 member_id: 2u32,
11610 member_flags: 0u32,
11611 type_id: xidl_typeobject::runtime::type_identifier_for::<
11612 MinimalMemberDetail,
11613 >(
11614 xidl_typeobject::runtime::TypeEquivalence::Minimal
11615 ),
11616 name: "detail",
11617 },
11618 ],
11619 )
11620 }
11621
11622 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
11623 xidl_typeobject::runtime::build_complete_struct(
11624 "DDS::XTypes::MinimalBitflag",
11625 0u32,
11626 xidl_typeobject::runtime::type_identifier_none(),
11627 vec![
11628 xidl_typeobject::runtime::StructMemberDesc {
11629 member_id: 1u32,
11630 member_flags: 0u32,
11631 type_id: xidl_typeobject::runtime::type_identifier_for::<CommonBitflag>(
11632 xidl_typeobject::runtime::TypeEquivalence::Complete,
11633 ),
11634 name: "common",
11635 },
11636 xidl_typeobject::runtime::StructMemberDesc {
11637 member_id: 2u32,
11638 member_flags: 0u32,
11639 type_id: xidl_typeobject::runtime::type_identifier_for::<
11640 MinimalMemberDetail,
11641 >(
11642 xidl_typeobject::runtime::TypeEquivalence::Complete
11643 ),
11644 name: "detail",
11645 },
11646 ],
11647 )
11648 }
11649 }
11650 pub type MinimalBitflagSeq = Vec<MinimalBitflag>;
11651 pub struct CommonBitmaskHeader {
11652 pub bit_bound: Box<BitBound>,
11653 }
11654
11655 impl CommonBitmaskHeader {
11656 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
11657 }
11658
11659 impl xidl_xcdr::XcdrSerialize for CommonBitmaskHeader {
11660 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
11661 Self::SERIALIZE_KIND
11662 }
11663
11664 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
11665 &self,
11666 serializer: &mut S,
11667 ) -> xidl_xcdr::error::XcdrResult<()> {
11668 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
11669
11670 serializer.begin_field(xidl_xcdr::FieldId(1u32), false, 0)?;
11671
11672 xidl_xcdr::XcdrSerialize::serialize_with(&self.bit_bound, serializer)?;
11673 serializer.end_field()?;
11674
11675 serializer.end_struct()?;
11676 Ok(())
11677 }
11678 }
11679
11680 impl xidl_xcdr::XcdrDeserialize for CommonBitmaskHeader {
11681 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
11682 deserializer: &mut D,
11683 ) -> xidl_xcdr::error::XcdrResult<Self> {
11684 let bit_bound = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
11685
11686 Ok(Self { bit_bound })
11687 }
11688 }
11689
11690 impl xidl_typeobject::XidlTypeObject for CommonBitmaskHeader {
11691 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
11692 xidl_typeobject::runtime::build_minimal_struct(
11693 0u32,
11694 xidl_typeobject::runtime::type_identifier_none(),
11695 vec![xidl_typeobject::runtime::StructMemberDesc {
11696 member_id: 1u32,
11697 member_flags: 0u32,
11698 type_id: xidl_typeobject::runtime::type_identifier_for::<BitBound>(
11699 xidl_typeobject::runtime::TypeEquivalence::Minimal,
11700 ),
11701 name: "bit_bound",
11702 }],
11703 )
11704 }
11705
11706 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
11707 xidl_typeobject::runtime::build_complete_struct(
11708 "DDS::XTypes::CommonBitmaskHeader",
11709 0u32,
11710 xidl_typeobject::runtime::type_identifier_none(),
11711 vec![xidl_typeobject::runtime::StructMemberDesc {
11712 member_id: 1u32,
11713 member_flags: 0u32,
11714 type_id: xidl_typeobject::runtime::type_identifier_for::<BitBound>(
11715 xidl_typeobject::runtime::TypeEquivalence::Complete,
11716 ),
11717 name: "bit_bound",
11718 }],
11719 )
11720 }
11721 }
11722 pub type CompleteBitmaskHeader = CompleteEnumeratedHeader;
11723 pub type MinimalBitmaskHeader = MinimalEnumeratedHeader;
11724 pub struct CompleteBitmaskType {
11725 pub bitmask_flags: Box<BitmaskTypeFlag>,
11726
11727 pub header: Box<CompleteBitmaskHeader>,
11728
11729 pub flag_seq: Box<CompleteBitflagSeq>,
11730 }
11731
11732 impl CompleteBitmaskType {
11733 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
11734 }
11735
11736 impl xidl_xcdr::XcdrSerialize for CompleteBitmaskType {
11737 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
11738 Self::SERIALIZE_KIND
11739 }
11740
11741 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
11742 &self,
11743 serializer: &mut S,
11744 ) -> xidl_xcdr::error::XcdrResult<()> {
11745 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
11746
11747 serializer.begin_field(xidl_xcdr::FieldId(1u32), false, 0)?;
11748
11749 xidl_xcdr::XcdrSerialize::serialize_with(&self.bitmask_flags, serializer)?;
11750 serializer.end_field()?;
11751
11752 serializer.begin_field(xidl_xcdr::FieldId(2u32), false, 0)?;
11753
11754 xidl_xcdr::XcdrSerialize::serialize_with(&self.header, serializer)?;
11755 serializer.end_field()?;
11756
11757 serializer.begin_field(xidl_xcdr::FieldId(3u32), false, 0)?;
11758
11759 xidl_xcdr::XcdrSerialize::serialize_with(&self.flag_seq, serializer)?;
11760 serializer.end_field()?;
11761
11762 serializer.end_struct()?;
11763 Ok(())
11764 }
11765 }
11766
11767 impl xidl_xcdr::XcdrDeserialize for CompleteBitmaskType {
11768 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
11769 deserializer: &mut D,
11770 ) -> xidl_xcdr::error::XcdrResult<Self> {
11771 let bitmask_flags = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
11772
11773 let header = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
11774
11775 let flag_seq = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
11776
11777 Ok(Self {
11778 bitmask_flags,
11779
11780 header,
11781
11782 flag_seq,
11783 })
11784 }
11785 }
11786
11787 impl xidl_typeobject::XidlTypeObject for CompleteBitmaskType {
11788 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
11789 xidl_typeobject::runtime::build_minimal_struct(
11790 0u32,
11791 xidl_typeobject::runtime::type_identifier_none(),
11792 vec![
11793 xidl_typeobject::runtime::StructMemberDesc {
11794 member_id: 1u32,
11795 member_flags: 0u32,
11796 type_id: xidl_typeobject::runtime::type_identifier_for::<BitmaskTypeFlag>(
11797 xidl_typeobject::runtime::TypeEquivalence::Minimal,
11798 ),
11799 name: "bitmask_flags",
11800 },
11801 xidl_typeobject::runtime::StructMemberDesc {
11802 member_id: 2u32,
11803 member_flags: 0u32,
11804 type_id: xidl_typeobject::runtime::type_identifier_for::<
11805 CompleteBitmaskHeader,
11806 >(
11807 xidl_typeobject::runtime::TypeEquivalence::Minimal
11808 ),
11809 name: "header",
11810 },
11811 xidl_typeobject::runtime::StructMemberDesc {
11812 member_id: 3u32,
11813 member_flags: 0u32,
11814 type_id: xidl_typeobject::runtime::type_identifier_for::<
11815 CompleteBitflagSeq,
11816 >(
11817 xidl_typeobject::runtime::TypeEquivalence::Minimal
11818 ),
11819 name: "flag_seq",
11820 },
11821 ],
11822 )
11823 }
11824
11825 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
11826 xidl_typeobject::runtime::build_complete_struct(
11827 "DDS::XTypes::CompleteBitmaskType",
11828 0u32,
11829 xidl_typeobject::runtime::type_identifier_none(),
11830 vec![
11831 xidl_typeobject::runtime::StructMemberDesc {
11832 member_id: 1u32,
11833 member_flags: 0u32,
11834 type_id: xidl_typeobject::runtime::type_identifier_for::<BitmaskTypeFlag>(
11835 xidl_typeobject::runtime::TypeEquivalence::Complete,
11836 ),
11837 name: "bitmask_flags",
11838 },
11839 xidl_typeobject::runtime::StructMemberDesc {
11840 member_id: 2u32,
11841 member_flags: 0u32,
11842 type_id: xidl_typeobject::runtime::type_identifier_for::<
11843 CompleteBitmaskHeader,
11844 >(
11845 xidl_typeobject::runtime::TypeEquivalence::Complete
11846 ),
11847 name: "header",
11848 },
11849 xidl_typeobject::runtime::StructMemberDesc {
11850 member_id: 3u32,
11851 member_flags: 0u32,
11852 type_id: xidl_typeobject::runtime::type_identifier_for::<
11853 CompleteBitflagSeq,
11854 >(
11855 xidl_typeobject::runtime::TypeEquivalence::Complete
11856 ),
11857 name: "flag_seq",
11858 },
11859 ],
11860 )
11861 }
11862 }
11863 pub struct MinimalBitmaskType {
11864 pub bitmask_flags: Box<BitmaskTypeFlag>,
11865
11866 pub header: Box<MinimalBitmaskHeader>,
11867
11868 pub flag_seq: Box<MinimalBitflagSeq>,
11869 }
11870
11871 impl MinimalBitmaskType {
11872 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
11873 }
11874
11875 impl xidl_xcdr::XcdrSerialize for MinimalBitmaskType {
11876 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
11877 Self::SERIALIZE_KIND
11878 }
11879
11880 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
11881 &self,
11882 serializer: &mut S,
11883 ) -> xidl_xcdr::error::XcdrResult<()> {
11884 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
11885
11886 serializer.begin_field(xidl_xcdr::FieldId(1u32), false, 0)?;
11887
11888 xidl_xcdr::XcdrSerialize::serialize_with(&self.bitmask_flags, serializer)?;
11889 serializer.end_field()?;
11890
11891 serializer.begin_field(xidl_xcdr::FieldId(2u32), false, 0)?;
11892
11893 xidl_xcdr::XcdrSerialize::serialize_with(&self.header, serializer)?;
11894 serializer.end_field()?;
11895
11896 serializer.begin_field(xidl_xcdr::FieldId(3u32), false, 0)?;
11897
11898 xidl_xcdr::XcdrSerialize::serialize_with(&self.flag_seq, serializer)?;
11899 serializer.end_field()?;
11900
11901 serializer.end_struct()?;
11902 Ok(())
11903 }
11904 }
11905
11906 impl xidl_xcdr::XcdrDeserialize for MinimalBitmaskType {
11907 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
11908 deserializer: &mut D,
11909 ) -> xidl_xcdr::error::XcdrResult<Self> {
11910 let bitmask_flags = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
11911
11912 let header = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
11913
11914 let flag_seq = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
11915
11916 Ok(Self {
11917 bitmask_flags,
11918
11919 header,
11920
11921 flag_seq,
11922 })
11923 }
11924 }
11925
11926 impl xidl_typeobject::XidlTypeObject for MinimalBitmaskType {
11927 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
11928 xidl_typeobject::runtime::build_minimal_struct(
11929 0u32,
11930 xidl_typeobject::runtime::type_identifier_none(),
11931 vec![
11932 xidl_typeobject::runtime::StructMemberDesc {
11933 member_id: 1u32,
11934 member_flags: 0u32,
11935 type_id: xidl_typeobject::runtime::type_identifier_for::<BitmaskTypeFlag>(
11936 xidl_typeobject::runtime::TypeEquivalence::Minimal,
11937 ),
11938 name: "bitmask_flags",
11939 },
11940 xidl_typeobject::runtime::StructMemberDesc {
11941 member_id: 2u32,
11942 member_flags: 0u32,
11943 type_id: xidl_typeobject::runtime::type_identifier_for::<
11944 MinimalBitmaskHeader,
11945 >(
11946 xidl_typeobject::runtime::TypeEquivalence::Minimal
11947 ),
11948 name: "header",
11949 },
11950 xidl_typeobject::runtime::StructMemberDesc {
11951 member_id: 3u32,
11952 member_flags: 0u32,
11953 type_id: xidl_typeobject::runtime::type_identifier_for::<
11954 MinimalBitflagSeq,
11955 >(
11956 xidl_typeobject::runtime::TypeEquivalence::Minimal
11957 ),
11958 name: "flag_seq",
11959 },
11960 ],
11961 )
11962 }
11963
11964 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
11965 xidl_typeobject::runtime::build_complete_struct(
11966 "DDS::XTypes::MinimalBitmaskType",
11967 0u32,
11968 xidl_typeobject::runtime::type_identifier_none(),
11969 vec![
11970 xidl_typeobject::runtime::StructMemberDesc {
11971 member_id: 1u32,
11972 member_flags: 0u32,
11973 type_id: xidl_typeobject::runtime::type_identifier_for::<BitmaskTypeFlag>(
11974 xidl_typeobject::runtime::TypeEquivalence::Complete,
11975 ),
11976 name: "bitmask_flags",
11977 },
11978 xidl_typeobject::runtime::StructMemberDesc {
11979 member_id: 2u32,
11980 member_flags: 0u32,
11981 type_id: xidl_typeobject::runtime::type_identifier_for::<
11982 MinimalBitmaskHeader,
11983 >(
11984 xidl_typeobject::runtime::TypeEquivalence::Complete
11985 ),
11986 name: "header",
11987 },
11988 xidl_typeobject::runtime::StructMemberDesc {
11989 member_id: 3u32,
11990 member_flags: 0u32,
11991 type_id: xidl_typeobject::runtime::type_identifier_for::<
11992 MinimalBitflagSeq,
11993 >(
11994 xidl_typeobject::runtime::TypeEquivalence::Complete
11995 ),
11996 name: "flag_seq",
11997 },
11998 ],
11999 )
12000 }
12001 }
12002 pub struct CommonBitfield {
12003 pub position: u16,
12004
12005 pub flags: Box<BitsetMemberFlag>,
12006
12007 pub bitcount: u8,
12008
12009 pub holder_type: Box<TypeKind>,
12010 }
12011
12012 impl CommonBitfield {
12013 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
12014 }
12015
12016 impl xidl_xcdr::XcdrSerialize for CommonBitfield {
12017 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
12018 Self::SERIALIZE_KIND
12019 }
12020
12021 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
12022 &self,
12023 serializer: &mut S,
12024 ) -> xidl_xcdr::error::XcdrResult<()> {
12025 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
12026
12027 serializer.begin_field(xidl_xcdr::FieldId(1u32), false, 0)?;
12028
12029 xidl_xcdr::XcdrSerialize::serialize_with(&self.position, serializer)?;
12030 serializer.end_field()?;
12031
12032 serializer.begin_field(xidl_xcdr::FieldId(2u32), false, 0)?;
12033
12034 xidl_xcdr::XcdrSerialize::serialize_with(&self.flags, serializer)?;
12035 serializer.end_field()?;
12036
12037 serializer.begin_field(xidl_xcdr::FieldId(3u32), false, 0)?;
12038
12039 xidl_xcdr::XcdrSerialize::serialize_with(&self.bitcount, serializer)?;
12040 serializer.end_field()?;
12041
12042 serializer.begin_field(xidl_xcdr::FieldId(4u32), false, 0)?;
12043
12044 xidl_xcdr::XcdrSerialize::serialize_with(&self.holder_type, serializer)?;
12045 serializer.end_field()?;
12046
12047 serializer.end_struct()?;
12048 Ok(())
12049 }
12050 }
12051
12052 impl xidl_xcdr::XcdrDeserialize for CommonBitfield {
12053 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
12054 deserializer: &mut D,
12055 ) -> xidl_xcdr::error::XcdrResult<Self> {
12056 let position = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
12057
12058 let flags = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
12059
12060 let bitcount = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
12061
12062 let holder_type = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
12063
12064 Ok(Self {
12065 position,
12066
12067 flags,
12068
12069 bitcount,
12070
12071 holder_type,
12072 })
12073 }
12074 }
12075
12076 impl xidl_typeobject::XidlTypeObject for CommonBitfield {
12077 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
12078 xidl_typeobject::runtime::build_minimal_struct(
12079 0u32,
12080 xidl_typeobject::runtime::type_identifier_none(),
12081 vec![
12082 xidl_typeobject::runtime::StructMemberDesc {
12083 member_id: 1u32,
12084 member_flags: 0u32,
12085 type_id: xidl_typeobject::runtime::type_identifier_primitive(
12086 xidl_typeobject::DDS::XTypes::TK_UINT16,
12087 ),
12088 name: "position",
12089 },
12090 xidl_typeobject::runtime::StructMemberDesc {
12091 member_id: 2u32,
12092 member_flags: 0u32,
12093 type_id: xidl_typeobject::runtime::type_identifier_for::<
12094 BitsetMemberFlag,
12095 >(
12096 xidl_typeobject::runtime::TypeEquivalence::Minimal
12097 ),
12098 name: "flags",
12099 },
12100 xidl_typeobject::runtime::StructMemberDesc {
12101 member_id: 3u32,
12102 member_flags: 0u32,
12103 type_id: xidl_typeobject::runtime::type_identifier_primitive(
12104 xidl_typeobject::DDS::XTypes::TK_BYTE,
12105 ),
12106 name: "bitcount",
12107 },
12108 xidl_typeobject::runtime::StructMemberDesc {
12109 member_id: 4u32,
12110 member_flags: 0u32,
12111 type_id: xidl_typeobject::runtime::type_identifier_for::<TypeKind>(
12112 xidl_typeobject::runtime::TypeEquivalence::Minimal,
12113 ),
12114 name: "holder_type",
12115 },
12116 ],
12117 )
12118 }
12119
12120 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
12121 xidl_typeobject::runtime::build_complete_struct(
12122 "DDS::XTypes::CommonBitfield",
12123 0u32,
12124 xidl_typeobject::runtime::type_identifier_none(),
12125 vec![
12126 xidl_typeobject::runtime::StructMemberDesc {
12127 member_id: 1u32,
12128 member_flags: 0u32,
12129 type_id: xidl_typeobject::runtime::type_identifier_primitive(
12130 xidl_typeobject::DDS::XTypes::TK_UINT16,
12131 ),
12132 name: "position",
12133 },
12134 xidl_typeobject::runtime::StructMemberDesc {
12135 member_id: 2u32,
12136 member_flags: 0u32,
12137 type_id: xidl_typeobject::runtime::type_identifier_for::<
12138 BitsetMemberFlag,
12139 >(
12140 xidl_typeobject::runtime::TypeEquivalence::Complete
12141 ),
12142 name: "flags",
12143 },
12144 xidl_typeobject::runtime::StructMemberDesc {
12145 member_id: 3u32,
12146 member_flags: 0u32,
12147 type_id: xidl_typeobject::runtime::type_identifier_primitive(
12148 xidl_typeobject::DDS::XTypes::TK_BYTE,
12149 ),
12150 name: "bitcount",
12151 },
12152 xidl_typeobject::runtime::StructMemberDesc {
12153 member_id: 4u32,
12154 member_flags: 0u32,
12155 type_id: xidl_typeobject::runtime::type_identifier_for::<TypeKind>(
12156 xidl_typeobject::runtime::TypeEquivalence::Complete,
12157 ),
12158 name: "holder_type",
12159 },
12160 ],
12161 )
12162 }
12163 }
12164 pub struct CompleteBitfield {
12165 pub common: Box<CommonBitfield>,
12166
12167 pub detail: Box<CompleteMemberDetail>,
12168 }
12169
12170 impl CompleteBitfield {
12171 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
12172 }
12173
12174 impl xidl_xcdr::XcdrSerialize for CompleteBitfield {
12175 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
12176 Self::SERIALIZE_KIND
12177 }
12178
12179 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
12180 &self,
12181 serializer: &mut S,
12182 ) -> xidl_xcdr::error::XcdrResult<()> {
12183 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
12184
12185 serializer.begin_field(xidl_xcdr::FieldId(1u32), false, 0)?;
12186
12187 xidl_xcdr::XcdrSerialize::serialize_with(&self.common, serializer)?;
12188 serializer.end_field()?;
12189
12190 serializer.begin_field(xidl_xcdr::FieldId(2u32), false, 0)?;
12191
12192 xidl_xcdr::XcdrSerialize::serialize_with(&self.detail, serializer)?;
12193 serializer.end_field()?;
12194
12195 serializer.end_struct()?;
12196 Ok(())
12197 }
12198 }
12199
12200 impl xidl_xcdr::XcdrDeserialize for CompleteBitfield {
12201 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
12202 deserializer: &mut D,
12203 ) -> xidl_xcdr::error::XcdrResult<Self> {
12204 let common = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
12205
12206 let detail = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
12207
12208 Ok(Self { common, detail })
12209 }
12210 }
12211
12212 impl xidl_typeobject::XidlTypeObject for CompleteBitfield {
12213 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
12214 xidl_typeobject::runtime::build_minimal_struct(
12215 0u32,
12216 xidl_typeobject::runtime::type_identifier_none(),
12217 vec![
12218 xidl_typeobject::runtime::StructMemberDesc {
12219 member_id: 1u32,
12220 member_flags: 0u32,
12221 type_id: xidl_typeobject::runtime::type_identifier_for::<CommonBitfield>(
12222 xidl_typeobject::runtime::TypeEquivalence::Minimal,
12223 ),
12224 name: "common",
12225 },
12226 xidl_typeobject::runtime::StructMemberDesc {
12227 member_id: 2u32,
12228 member_flags: 0u32,
12229 type_id: xidl_typeobject::runtime::type_identifier_for::<
12230 CompleteMemberDetail,
12231 >(
12232 xidl_typeobject::runtime::TypeEquivalence::Minimal
12233 ),
12234 name: "detail",
12235 },
12236 ],
12237 )
12238 }
12239
12240 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
12241 xidl_typeobject::runtime::build_complete_struct(
12242 "DDS::XTypes::CompleteBitfield",
12243 0u32,
12244 xidl_typeobject::runtime::type_identifier_none(),
12245 vec![
12246 xidl_typeobject::runtime::StructMemberDesc {
12247 member_id: 1u32,
12248 member_flags: 0u32,
12249 type_id: xidl_typeobject::runtime::type_identifier_for::<CommonBitfield>(
12250 xidl_typeobject::runtime::TypeEquivalence::Complete,
12251 ),
12252 name: "common",
12253 },
12254 xidl_typeobject::runtime::StructMemberDesc {
12255 member_id: 2u32,
12256 member_flags: 0u32,
12257 type_id: xidl_typeobject::runtime::type_identifier_for::<
12258 CompleteMemberDetail,
12259 >(
12260 xidl_typeobject::runtime::TypeEquivalence::Complete
12261 ),
12262 name: "detail",
12263 },
12264 ],
12265 )
12266 }
12267 }
12268 pub type CompleteBitfieldSeq = Vec<CompleteBitfield>;
12269 pub struct MinimalBitfield {
12270 pub common: Box<CommonBitfield>,
12271
12272 pub name_hash: Box<NameHash>,
12273 }
12274
12275 impl MinimalBitfield {
12276 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
12277 }
12278
12279 impl xidl_xcdr::XcdrSerialize for MinimalBitfield {
12280 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
12281 Self::SERIALIZE_KIND
12282 }
12283
12284 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
12285 &self,
12286 serializer: &mut S,
12287 ) -> xidl_xcdr::error::XcdrResult<()> {
12288 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
12289
12290 serializer.begin_field(xidl_xcdr::FieldId(1u32), false, 0)?;
12291
12292 xidl_xcdr::XcdrSerialize::serialize_with(&self.common, serializer)?;
12293 serializer.end_field()?;
12294
12295 serializer.begin_field(xidl_xcdr::FieldId(2u32), false, 0)?;
12296
12297 xidl_xcdr::XcdrSerialize::serialize_with(&self.name_hash, serializer)?;
12298 serializer.end_field()?;
12299
12300 serializer.end_struct()?;
12301 Ok(())
12302 }
12303 }
12304
12305 impl xidl_xcdr::XcdrDeserialize for MinimalBitfield {
12306 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
12307 deserializer: &mut D,
12308 ) -> xidl_xcdr::error::XcdrResult<Self> {
12309 let common = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
12310
12311 let name_hash = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
12312
12313 Ok(Self { common, name_hash })
12314 }
12315 }
12316
12317 impl xidl_typeobject::XidlTypeObject for MinimalBitfield {
12318 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
12319 xidl_typeobject::runtime::build_minimal_struct(
12320 0u32,
12321 xidl_typeobject::runtime::type_identifier_none(),
12322 vec![
12323 xidl_typeobject::runtime::StructMemberDesc {
12324 member_id: 1u32,
12325 member_flags: 0u32,
12326 type_id: xidl_typeobject::runtime::type_identifier_for::<CommonBitfield>(
12327 xidl_typeobject::runtime::TypeEquivalence::Minimal,
12328 ),
12329 name: "common",
12330 },
12331 xidl_typeobject::runtime::StructMemberDesc {
12332 member_id: 2u32,
12333 member_flags: 0u32,
12334 type_id: xidl_typeobject::runtime::type_identifier_for::<NameHash>(
12335 xidl_typeobject::runtime::TypeEquivalence::Minimal,
12336 ),
12337 name: "name_hash",
12338 },
12339 ],
12340 )
12341 }
12342
12343 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
12344 xidl_typeobject::runtime::build_complete_struct(
12345 "DDS::XTypes::MinimalBitfield",
12346 0u32,
12347 xidl_typeobject::runtime::type_identifier_none(),
12348 vec![
12349 xidl_typeobject::runtime::StructMemberDesc {
12350 member_id: 1u32,
12351 member_flags: 0u32,
12352 type_id: xidl_typeobject::runtime::type_identifier_for::<CommonBitfield>(
12353 xidl_typeobject::runtime::TypeEquivalence::Complete,
12354 ),
12355 name: "common",
12356 },
12357 xidl_typeobject::runtime::StructMemberDesc {
12358 member_id: 2u32,
12359 member_flags: 0u32,
12360 type_id: xidl_typeobject::runtime::type_identifier_for::<NameHash>(
12361 xidl_typeobject::runtime::TypeEquivalence::Complete,
12362 ),
12363 name: "name_hash",
12364 },
12365 ],
12366 )
12367 }
12368 }
12369 pub type MinimalBitfieldSeq = Vec<MinimalBitfield>;
12370 pub struct CompleteBitsetHeader {
12371 pub detail: Box<CompleteTypeDetail>,
12372 }
12373
12374 impl CompleteBitsetHeader {
12375 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
12376 }
12377
12378 impl xidl_xcdr::XcdrSerialize for CompleteBitsetHeader {
12379 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
12380 Self::SERIALIZE_KIND
12381 }
12382
12383 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
12384 &self,
12385 serializer: &mut S,
12386 ) -> xidl_xcdr::error::XcdrResult<()> {
12387 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
12388
12389 serializer.begin_field(xidl_xcdr::FieldId(1u32), false, 0)?;
12390
12391 xidl_xcdr::XcdrSerialize::serialize_with(&self.detail, serializer)?;
12392 serializer.end_field()?;
12393
12394 serializer.end_struct()?;
12395 Ok(())
12396 }
12397 }
12398
12399 impl xidl_xcdr::XcdrDeserialize for CompleteBitsetHeader {
12400 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
12401 deserializer: &mut D,
12402 ) -> xidl_xcdr::error::XcdrResult<Self> {
12403 let detail = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
12404
12405 Ok(Self { detail })
12406 }
12407 }
12408
12409 impl xidl_typeobject::XidlTypeObject for CompleteBitsetHeader {
12410 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
12411 xidl_typeobject::runtime::build_minimal_struct(
12412 0u32,
12413 xidl_typeobject::runtime::type_identifier_none(),
12414 vec![xidl_typeobject::runtime::StructMemberDesc {
12415 member_id: 1u32,
12416 member_flags: 0u32,
12417 type_id: xidl_typeobject::runtime::type_identifier_for::<CompleteTypeDetail>(
12418 xidl_typeobject::runtime::TypeEquivalence::Minimal,
12419 ),
12420 name: "detail",
12421 }],
12422 )
12423 }
12424
12425 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
12426 xidl_typeobject::runtime::build_complete_struct(
12427 "DDS::XTypes::CompleteBitsetHeader",
12428 0u32,
12429 xidl_typeobject::runtime::type_identifier_none(),
12430 vec![xidl_typeobject::runtime::StructMemberDesc {
12431 member_id: 1u32,
12432 member_flags: 0u32,
12433 type_id: xidl_typeobject::runtime::type_identifier_for::<CompleteTypeDetail>(
12434 xidl_typeobject::runtime::TypeEquivalence::Complete,
12435 ),
12436 name: "detail",
12437 }],
12438 )
12439 }
12440 }
12441 pub struct MinimalBitsetHeader {}
12442
12443 impl MinimalBitsetHeader {
12444 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
12445 }
12446
12447 impl xidl_xcdr::XcdrSerialize for MinimalBitsetHeader {
12448 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
12449 Self::SERIALIZE_KIND
12450 }
12451
12452 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
12453 &self,
12454 serializer: &mut S,
12455 ) -> xidl_xcdr::error::XcdrResult<()> {
12456 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
12457
12458 serializer.end_struct()?;
12459 Ok(())
12460 }
12461 }
12462
12463 impl xidl_xcdr::XcdrDeserialize for MinimalBitsetHeader {
12464 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
12465 deserializer: &mut D,
12466 ) -> xidl_xcdr::error::XcdrResult<Self> {
12467 Ok(Self {})
12468 }
12469 }
12470
12471 impl xidl_typeobject::XidlTypeObject for MinimalBitsetHeader {
12472 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
12473 xidl_typeobject::runtime::build_minimal_struct(
12474 0u32,
12475 xidl_typeobject::runtime::type_identifier_none(),
12476 vec![],
12477 )
12478 }
12479
12480 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
12481 xidl_typeobject::runtime::build_complete_struct(
12482 "DDS::XTypes::MinimalBitsetHeader",
12483 0u32,
12484 xidl_typeobject::runtime::type_identifier_none(),
12485 vec![],
12486 )
12487 }
12488 }
12489 pub struct CompleteBitsetType {
12490 pub bitset_flags: Box<BitsetTypeFlag>,
12491
12492 pub header: Box<CompleteBitsetHeader>,
12493
12494 pub field_seq: Box<CompleteBitfieldSeq>,
12495 }
12496
12497 impl CompleteBitsetType {
12498 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
12499 }
12500
12501 impl xidl_xcdr::XcdrSerialize for CompleteBitsetType {
12502 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
12503 Self::SERIALIZE_KIND
12504 }
12505
12506 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
12507 &self,
12508 serializer: &mut S,
12509 ) -> xidl_xcdr::error::XcdrResult<()> {
12510 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
12511
12512 serializer.begin_field(xidl_xcdr::FieldId(1u32), false, 0)?;
12513
12514 xidl_xcdr::XcdrSerialize::serialize_with(&self.bitset_flags, serializer)?;
12515 serializer.end_field()?;
12516
12517 serializer.begin_field(xidl_xcdr::FieldId(2u32), false, 0)?;
12518
12519 xidl_xcdr::XcdrSerialize::serialize_with(&self.header, serializer)?;
12520 serializer.end_field()?;
12521
12522 serializer.begin_field(xidl_xcdr::FieldId(3u32), false, 0)?;
12523
12524 xidl_xcdr::XcdrSerialize::serialize_with(&self.field_seq, serializer)?;
12525 serializer.end_field()?;
12526
12527 serializer.end_struct()?;
12528 Ok(())
12529 }
12530 }
12531
12532 impl xidl_xcdr::XcdrDeserialize for CompleteBitsetType {
12533 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
12534 deserializer: &mut D,
12535 ) -> xidl_xcdr::error::XcdrResult<Self> {
12536 let bitset_flags = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
12537
12538 let header = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
12539
12540 let field_seq = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
12541
12542 Ok(Self {
12543 bitset_flags,
12544
12545 header,
12546
12547 field_seq,
12548 })
12549 }
12550 }
12551
12552 impl xidl_typeobject::XidlTypeObject for CompleteBitsetType {
12553 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
12554 xidl_typeobject::runtime::build_minimal_struct(
12555 0u32,
12556 xidl_typeobject::runtime::type_identifier_none(),
12557 vec![
12558 xidl_typeobject::runtime::StructMemberDesc {
12559 member_id: 1u32,
12560 member_flags: 0u32,
12561 type_id: xidl_typeobject::runtime::type_identifier_for::<BitsetTypeFlag>(
12562 xidl_typeobject::runtime::TypeEquivalence::Minimal,
12563 ),
12564 name: "bitset_flags",
12565 },
12566 xidl_typeobject::runtime::StructMemberDesc {
12567 member_id: 2u32,
12568 member_flags: 0u32,
12569 type_id: xidl_typeobject::runtime::type_identifier_for::<
12570 CompleteBitsetHeader,
12571 >(
12572 xidl_typeobject::runtime::TypeEquivalence::Minimal
12573 ),
12574 name: "header",
12575 },
12576 xidl_typeobject::runtime::StructMemberDesc {
12577 member_id: 3u32,
12578 member_flags: 0u32,
12579 type_id: xidl_typeobject::runtime::type_identifier_for::<
12580 CompleteBitfieldSeq,
12581 >(
12582 xidl_typeobject::runtime::TypeEquivalence::Minimal
12583 ),
12584 name: "field_seq",
12585 },
12586 ],
12587 )
12588 }
12589
12590 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
12591 xidl_typeobject::runtime::build_complete_struct(
12592 "DDS::XTypes::CompleteBitsetType",
12593 0u32,
12594 xidl_typeobject::runtime::type_identifier_none(),
12595 vec![
12596 xidl_typeobject::runtime::StructMemberDesc {
12597 member_id: 1u32,
12598 member_flags: 0u32,
12599 type_id: xidl_typeobject::runtime::type_identifier_for::<BitsetTypeFlag>(
12600 xidl_typeobject::runtime::TypeEquivalence::Complete,
12601 ),
12602 name: "bitset_flags",
12603 },
12604 xidl_typeobject::runtime::StructMemberDesc {
12605 member_id: 2u32,
12606 member_flags: 0u32,
12607 type_id: xidl_typeobject::runtime::type_identifier_for::<
12608 CompleteBitsetHeader,
12609 >(
12610 xidl_typeobject::runtime::TypeEquivalence::Complete
12611 ),
12612 name: "header",
12613 },
12614 xidl_typeobject::runtime::StructMemberDesc {
12615 member_id: 3u32,
12616 member_flags: 0u32,
12617 type_id: xidl_typeobject::runtime::type_identifier_for::<
12618 CompleteBitfieldSeq,
12619 >(
12620 xidl_typeobject::runtime::TypeEquivalence::Complete
12621 ),
12622 name: "field_seq",
12623 },
12624 ],
12625 )
12626 }
12627 }
12628 pub struct MinimalBitsetType {
12629 pub bitset_flags: Box<BitsetTypeFlag>,
12630
12631 pub header: Box<MinimalBitsetHeader>,
12632
12633 pub field_seq: Box<MinimalBitfieldSeq>,
12634 }
12635
12636 impl MinimalBitsetType {
12637 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
12638 }
12639
12640 impl xidl_xcdr::XcdrSerialize for MinimalBitsetType {
12641 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
12642 Self::SERIALIZE_KIND
12643 }
12644
12645 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
12646 &self,
12647 serializer: &mut S,
12648 ) -> xidl_xcdr::error::XcdrResult<()> {
12649 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
12650
12651 serializer.begin_field(xidl_xcdr::FieldId(1u32), false, 0)?;
12652
12653 xidl_xcdr::XcdrSerialize::serialize_with(&self.bitset_flags, serializer)?;
12654 serializer.end_field()?;
12655
12656 serializer.begin_field(xidl_xcdr::FieldId(2u32), false, 0)?;
12657
12658 xidl_xcdr::XcdrSerialize::serialize_with(&self.header, serializer)?;
12659 serializer.end_field()?;
12660
12661 serializer.begin_field(xidl_xcdr::FieldId(3u32), false, 0)?;
12662
12663 xidl_xcdr::XcdrSerialize::serialize_with(&self.field_seq, serializer)?;
12664 serializer.end_field()?;
12665
12666 serializer.end_struct()?;
12667 Ok(())
12668 }
12669 }
12670
12671 impl xidl_xcdr::XcdrDeserialize for MinimalBitsetType {
12672 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
12673 deserializer: &mut D,
12674 ) -> xidl_xcdr::error::XcdrResult<Self> {
12675 let bitset_flags = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
12676
12677 let header = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
12678
12679 let field_seq = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
12680
12681 Ok(Self {
12682 bitset_flags,
12683
12684 header,
12685
12686 field_seq,
12687 })
12688 }
12689 }
12690
12691 impl xidl_typeobject::XidlTypeObject for MinimalBitsetType {
12692 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
12693 xidl_typeobject::runtime::build_minimal_struct(
12694 0u32,
12695 xidl_typeobject::runtime::type_identifier_none(),
12696 vec![
12697 xidl_typeobject::runtime::StructMemberDesc {
12698 member_id: 1u32,
12699 member_flags: 0u32,
12700 type_id: xidl_typeobject::runtime::type_identifier_for::<BitsetTypeFlag>(
12701 xidl_typeobject::runtime::TypeEquivalence::Minimal,
12702 ),
12703 name: "bitset_flags",
12704 },
12705 xidl_typeobject::runtime::StructMemberDesc {
12706 member_id: 2u32,
12707 member_flags: 0u32,
12708 type_id: xidl_typeobject::runtime::type_identifier_for::<
12709 MinimalBitsetHeader,
12710 >(
12711 xidl_typeobject::runtime::TypeEquivalence::Minimal
12712 ),
12713 name: "header",
12714 },
12715 xidl_typeobject::runtime::StructMemberDesc {
12716 member_id: 3u32,
12717 member_flags: 0u32,
12718 type_id: xidl_typeobject::runtime::type_identifier_for::<
12719 MinimalBitfieldSeq,
12720 >(
12721 xidl_typeobject::runtime::TypeEquivalence::Minimal
12722 ),
12723 name: "field_seq",
12724 },
12725 ],
12726 )
12727 }
12728
12729 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
12730 xidl_typeobject::runtime::build_complete_struct(
12731 "DDS::XTypes::MinimalBitsetType",
12732 0u32,
12733 xidl_typeobject::runtime::type_identifier_none(),
12734 vec![
12735 xidl_typeobject::runtime::StructMemberDesc {
12736 member_id: 1u32,
12737 member_flags: 0u32,
12738 type_id: xidl_typeobject::runtime::type_identifier_for::<BitsetTypeFlag>(
12739 xidl_typeobject::runtime::TypeEquivalence::Complete,
12740 ),
12741 name: "bitset_flags",
12742 },
12743 xidl_typeobject::runtime::StructMemberDesc {
12744 member_id: 2u32,
12745 member_flags: 0u32,
12746 type_id: xidl_typeobject::runtime::type_identifier_for::<
12747 MinimalBitsetHeader,
12748 >(
12749 xidl_typeobject::runtime::TypeEquivalence::Complete
12750 ),
12751 name: "header",
12752 },
12753 xidl_typeobject::runtime::StructMemberDesc {
12754 member_id: 3u32,
12755 member_flags: 0u32,
12756 type_id: xidl_typeobject::runtime::type_identifier_for::<
12757 MinimalBitfieldSeq,
12758 >(
12759 xidl_typeobject::runtime::TypeEquivalence::Complete
12760 ),
12761 name: "field_seq",
12762 },
12763 ],
12764 )
12765 }
12766 }
12767 pub struct CompleteExtendedType {}
12768
12769 impl CompleteExtendedType {
12770 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
12771 }
12772
12773 impl xidl_xcdr::XcdrSerialize for CompleteExtendedType {
12774 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
12775 Self::SERIALIZE_KIND
12776 }
12777
12778 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
12779 &self,
12780 serializer: &mut S,
12781 ) -> xidl_xcdr::error::XcdrResult<()> {
12782 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
12783
12784 serializer.end_struct()?;
12785 Ok(())
12786 }
12787 }
12788
12789 impl xidl_xcdr::XcdrDeserialize for CompleteExtendedType {
12790 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
12791 deserializer: &mut D,
12792 ) -> xidl_xcdr::error::XcdrResult<Self> {
12793 Ok(Self {})
12794 }
12795 }
12796
12797 impl xidl_typeobject::XidlTypeObject for CompleteExtendedType {
12798 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
12799 xidl_typeobject::runtime::build_minimal_struct(
12800 0u32,
12801 xidl_typeobject::runtime::type_identifier_none(),
12802 vec![],
12803 )
12804 }
12805
12806 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
12807 xidl_typeobject::runtime::build_complete_struct(
12808 "DDS::XTypes::CompleteExtendedType",
12809 0u32,
12810 xidl_typeobject::runtime::type_identifier_none(),
12811 vec![],
12812 )
12813 }
12814 }
12815 pub struct CompleteTypeObject {
12816 pub _d: u8,
12817
12818 pub alias_type: Option<Box<CompleteAliasType>>,
12819
12820 pub annotation_type: Option<Box<CompleteAnnotationType>>,
12821
12822 pub struct_type: Option<Box<CompleteStructType>>,
12823
12824 pub union_type: Option<Box<CompleteUnionType>>,
12825
12826 pub bitset_type: Option<Box<CompleteBitsetType>>,
12827
12828 pub sequence_type: Option<Box<CompleteSequenceType>>,
12829
12830 pub array_type: Option<Box<CompleteArrayType>>,
12831
12832 pub map_type: Option<Box<CompleteMapType>>,
12833
12834 pub enumerated_type: Option<Box<CompleteEnumeratedType>>,
12835
12836 pub bitmask_type: Option<Box<CompleteBitmaskType>>,
12837
12838 pub extended_type: Option<Box<CompleteExtendedType>>,
12839 }
12840
12841 impl CompleteTypeObject {
12842 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
12843
12844 pub fn new_alias_type(value: Box<CompleteAliasType>) -> Self {
12845 Self {
12846 _d: TK_ALIAS,
12847 alias_type: Some(value),
12848
12849 annotation_type: None,
12850
12851 struct_type: None,
12852
12853 union_type: None,
12854
12855 bitset_type: None,
12856
12857 sequence_type: None,
12858
12859 array_type: None,
12860
12861 map_type: None,
12862
12863 enumerated_type: None,
12864
12865 bitmask_type: None,
12866
12867 extended_type: None,
12868 }
12869 }
12870
12871 pub fn is_alias_type(&self) -> bool {
12872 matches!(self._d, TK_ALIAS)
12873 }
12874
12875 pub fn new_annotation_type(value: Box<CompleteAnnotationType>) -> Self {
12876 Self {
12877 _d: TK_ANNOTATION,
12878 annotation_type: Some(value),
12879
12880 alias_type: None,
12881
12882 struct_type: None,
12883
12884 union_type: None,
12885
12886 bitset_type: None,
12887
12888 sequence_type: None,
12889
12890 array_type: None,
12891
12892 map_type: None,
12893
12894 enumerated_type: None,
12895
12896 bitmask_type: None,
12897
12898 extended_type: None,
12899 }
12900 }
12901
12902 pub fn is_annotation_type(&self) -> bool {
12903 matches!(self._d, TK_ANNOTATION)
12904 }
12905
12906 pub fn new_struct_type(value: Box<CompleteStructType>) -> Self {
12907 Self {
12908 _d: TK_STRUCTURE,
12909 struct_type: Some(value),
12910
12911 alias_type: None,
12912
12913 annotation_type: None,
12914
12915 union_type: None,
12916
12917 bitset_type: None,
12918
12919 sequence_type: None,
12920
12921 array_type: None,
12922
12923 map_type: None,
12924
12925 enumerated_type: None,
12926
12927 bitmask_type: None,
12928
12929 extended_type: None,
12930 }
12931 }
12932
12933 pub fn is_struct_type(&self) -> bool {
12934 matches!(self._d, TK_STRUCTURE)
12935 }
12936
12937 pub fn new_union_type(value: Box<CompleteUnionType>) -> Self {
12938 Self {
12939 _d: TK_UNION,
12940 union_type: Some(value),
12941
12942 alias_type: None,
12943
12944 annotation_type: None,
12945
12946 struct_type: None,
12947
12948 bitset_type: None,
12949
12950 sequence_type: None,
12951
12952 array_type: None,
12953
12954 map_type: None,
12955
12956 enumerated_type: None,
12957
12958 bitmask_type: None,
12959
12960 extended_type: None,
12961 }
12962 }
12963
12964 pub fn is_union_type(&self) -> bool {
12965 matches!(self._d, TK_UNION)
12966 }
12967
12968 pub fn new_bitset_type(value: Box<CompleteBitsetType>) -> Self {
12969 Self {
12970 _d: TK_BITSET,
12971 bitset_type: Some(value),
12972
12973 alias_type: None,
12974
12975 annotation_type: None,
12976
12977 struct_type: None,
12978
12979 union_type: None,
12980
12981 sequence_type: None,
12982
12983 array_type: None,
12984
12985 map_type: None,
12986
12987 enumerated_type: None,
12988
12989 bitmask_type: None,
12990
12991 extended_type: None,
12992 }
12993 }
12994
12995 pub fn is_bitset_type(&self) -> bool {
12996 matches!(self._d, TK_BITSET)
12997 }
12998
12999 pub fn new_sequence_type(value: Box<CompleteSequenceType>) -> Self {
13000 Self {
13001 _d: TK_SEQUENCE,
13002 sequence_type: Some(value),
13003
13004 alias_type: None,
13005
13006 annotation_type: None,
13007
13008 struct_type: None,
13009
13010 union_type: None,
13011
13012 bitset_type: None,
13013
13014 array_type: None,
13015
13016 map_type: None,
13017
13018 enumerated_type: None,
13019
13020 bitmask_type: None,
13021
13022 extended_type: None,
13023 }
13024 }
13025
13026 pub fn is_sequence_type(&self) -> bool {
13027 matches!(self._d, TK_SEQUENCE)
13028 }
13029
13030 pub fn new_array_type(value: Box<CompleteArrayType>) -> Self {
13031 Self {
13032 _d: TK_ARRAY,
13033 array_type: Some(value),
13034
13035 alias_type: None,
13036
13037 annotation_type: None,
13038
13039 struct_type: None,
13040
13041 union_type: None,
13042
13043 bitset_type: None,
13044
13045 sequence_type: None,
13046
13047 map_type: None,
13048
13049 enumerated_type: None,
13050
13051 bitmask_type: None,
13052
13053 extended_type: None,
13054 }
13055 }
13056
13057 pub fn is_array_type(&self) -> bool {
13058 matches!(self._d, TK_ARRAY)
13059 }
13060
13061 pub fn new_map_type(value: Box<CompleteMapType>) -> Self {
13062 Self {
13063 _d: TK_MAP,
13064 map_type: Some(value),
13065
13066 alias_type: None,
13067
13068 annotation_type: None,
13069
13070 struct_type: None,
13071
13072 union_type: None,
13073
13074 bitset_type: None,
13075
13076 sequence_type: None,
13077
13078 array_type: None,
13079
13080 enumerated_type: None,
13081
13082 bitmask_type: None,
13083
13084 extended_type: None,
13085 }
13086 }
13087
13088 pub fn is_map_type(&self) -> bool {
13089 matches!(self._d, TK_MAP)
13090 }
13091
13092 pub fn new_enumerated_type(value: Box<CompleteEnumeratedType>) -> Self {
13093 Self {
13094 _d: TK_ENUM,
13095 enumerated_type: Some(value),
13096
13097 alias_type: None,
13098
13099 annotation_type: None,
13100
13101 struct_type: None,
13102
13103 union_type: None,
13104
13105 bitset_type: None,
13106
13107 sequence_type: None,
13108
13109 array_type: None,
13110
13111 map_type: None,
13112
13113 bitmask_type: None,
13114
13115 extended_type: None,
13116 }
13117 }
13118
13119 pub fn is_enumerated_type(&self) -> bool {
13120 matches!(self._d, TK_ENUM)
13121 }
13122
13123 pub fn new_bitmask_type(value: Box<CompleteBitmaskType>) -> Self {
13124 Self {
13125 _d: TK_BITMASK,
13126 bitmask_type: Some(value),
13127
13128 alias_type: None,
13129
13130 annotation_type: None,
13131
13132 struct_type: None,
13133
13134 union_type: None,
13135
13136 bitset_type: None,
13137
13138 sequence_type: None,
13139
13140 array_type: None,
13141
13142 map_type: None,
13143
13144 enumerated_type: None,
13145
13146 extended_type: None,
13147 }
13148 }
13149
13150 pub fn is_bitmask_type(&self) -> bool {
13151 matches!(self._d, TK_BITMASK)
13152 }
13153
13154 pub fn new_extended_type(value: Box<CompleteExtendedType>) -> Self {
13155 Self {
13156 _d: u8::default(),
13157 extended_type: Some(value),
13158
13159 alias_type: None,
13160
13161 annotation_type: None,
13162
13163 struct_type: None,
13164
13165 union_type: None,
13166
13167 bitset_type: None,
13168
13169 sequence_type: None,
13170
13171 array_type: None,
13172
13173 map_type: None,
13174
13175 enumerated_type: None,
13176
13177 bitmask_type: None,
13178 }
13179 }
13180
13181 pub fn is_extended_type(&self) -> bool {
13182 matches!(self._d, _)
13183 }
13184
13185 pub fn tag(&self) -> &u8 {
13186 &self._d
13187 }
13188 }
13189
13190 impl xidl_xcdr::XcdrSerialize for CompleteTypeObject {
13191 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
13192 Self::SERIALIZE_KIND
13193 }
13194
13195 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
13196 &self,
13197 serializer: &mut S,
13198 ) -> xidl_xcdr::error::XcdrResult<()> {
13199 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
13200 serializer.begin_field(xidl_xcdr::FieldId(0), false, 0)?;
13201 xidl_xcdr::XcdrSerialize::serialize_with(&self._d, serializer)?;
13202 serializer.end_field()?;
13203 match self._d {
13204 TK_ALIAS => {
13205 let value = self.alias_type.as_ref().ok_or_else(|| {
13206 xidl_xcdr::error::XcdrError::Message(
13207 "union member is not set for discriminator".to_string(),
13208 )
13209 })?;
13210 serializer.begin_field(xidl_xcdr::FieldId(1u32), false, 0)?;
13211 xidl_xcdr::XcdrSerialize::serialize_with(value, serializer)?;
13212 serializer.end_field()?;
13213 }
13214
13215 TK_ANNOTATION => {
13216 let value = self.annotation_type.as_ref().ok_or_else(|| {
13217 xidl_xcdr::error::XcdrError::Message(
13218 "union member is not set for discriminator".to_string(),
13219 )
13220 })?;
13221 serializer.begin_field(xidl_xcdr::FieldId(2u32), false, 0)?;
13222 xidl_xcdr::XcdrSerialize::serialize_with(value, serializer)?;
13223 serializer.end_field()?;
13224 }
13225
13226 TK_STRUCTURE => {
13227 let value = self.struct_type.as_ref().ok_or_else(|| {
13228 xidl_xcdr::error::XcdrError::Message(
13229 "union member is not set for discriminator".to_string(),
13230 )
13231 })?;
13232 serializer.begin_field(xidl_xcdr::FieldId(3u32), false, 0)?;
13233 xidl_xcdr::XcdrSerialize::serialize_with(value, serializer)?;
13234 serializer.end_field()?;
13235 }
13236
13237 TK_UNION => {
13238 let value = self.union_type.as_ref().ok_or_else(|| {
13239 xidl_xcdr::error::XcdrError::Message(
13240 "union member is not set for discriminator".to_string(),
13241 )
13242 })?;
13243 serializer.begin_field(xidl_xcdr::FieldId(4u32), false, 0)?;
13244 xidl_xcdr::XcdrSerialize::serialize_with(value, serializer)?;
13245 serializer.end_field()?;
13246 }
13247
13248 TK_BITSET => {
13249 let value = self.bitset_type.as_ref().ok_or_else(|| {
13250 xidl_xcdr::error::XcdrError::Message(
13251 "union member is not set for discriminator".to_string(),
13252 )
13253 })?;
13254 serializer.begin_field(xidl_xcdr::FieldId(5u32), false, 0)?;
13255 xidl_xcdr::XcdrSerialize::serialize_with(value, serializer)?;
13256 serializer.end_field()?;
13257 }
13258
13259 TK_SEQUENCE => {
13260 let value = self.sequence_type.as_ref().ok_or_else(|| {
13261 xidl_xcdr::error::XcdrError::Message(
13262 "union member is not set for discriminator".to_string(),
13263 )
13264 })?;
13265 serializer.begin_field(xidl_xcdr::FieldId(6u32), false, 0)?;
13266 xidl_xcdr::XcdrSerialize::serialize_with(value, serializer)?;
13267 serializer.end_field()?;
13268 }
13269
13270 TK_ARRAY => {
13271 let value = self.array_type.as_ref().ok_or_else(|| {
13272 xidl_xcdr::error::XcdrError::Message(
13273 "union member is not set for discriminator".to_string(),
13274 )
13275 })?;
13276 serializer.begin_field(xidl_xcdr::FieldId(7u32), false, 0)?;
13277 xidl_xcdr::XcdrSerialize::serialize_with(value, serializer)?;
13278 serializer.end_field()?;
13279 }
13280
13281 TK_MAP => {
13282 let value = self.map_type.as_ref().ok_or_else(|| {
13283 xidl_xcdr::error::XcdrError::Message(
13284 "union member is not set for discriminator".to_string(),
13285 )
13286 })?;
13287 serializer.begin_field(xidl_xcdr::FieldId(8u32), false, 0)?;
13288 xidl_xcdr::XcdrSerialize::serialize_with(value, serializer)?;
13289 serializer.end_field()?;
13290 }
13291
13292 TK_ENUM => {
13293 let value = self.enumerated_type.as_ref().ok_or_else(|| {
13294 xidl_xcdr::error::XcdrError::Message(
13295 "union member is not set for discriminator".to_string(),
13296 )
13297 })?;
13298 serializer.begin_field(xidl_xcdr::FieldId(9u32), false, 0)?;
13299 xidl_xcdr::XcdrSerialize::serialize_with(value, serializer)?;
13300 serializer.end_field()?;
13301 }
13302
13303 TK_BITMASK => {
13304 let value = self.bitmask_type.as_ref().ok_or_else(|| {
13305 xidl_xcdr::error::XcdrError::Message(
13306 "union member is not set for discriminator".to_string(),
13307 )
13308 })?;
13309 serializer.begin_field(xidl_xcdr::FieldId(10u32), false, 0)?;
13310 xidl_xcdr::XcdrSerialize::serialize_with(value, serializer)?;
13311 serializer.end_field()?;
13312 }
13313
13314 _ => {
13315 let value = self.extended_type.as_ref().ok_or_else(|| {
13316 xidl_xcdr::error::XcdrError::Message(
13317 "union member is not set for discriminator".to_string(),
13318 )
13319 })?;
13320 serializer.begin_field(xidl_xcdr::FieldId(11u32), false, 0)?;
13321 xidl_xcdr::XcdrSerialize::serialize_with(value, serializer)?;
13322 serializer.end_field()?;
13323 }
13324 }
13325 serializer.end_struct()?;
13326 Ok(())
13327 }
13328 }
13329
13330 impl xidl_xcdr::XcdrDeserialize for CompleteTypeObject {
13331 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
13332 deserializer: &mut D,
13333 ) -> xidl_xcdr::error::XcdrResult<Self> {
13334 let _d = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
13335 let mut out = Self {
13336 _d,
13337
13338 alias_type: None,
13339
13340 annotation_type: None,
13341
13342 struct_type: None,
13343
13344 union_type: None,
13345
13346 bitset_type: None,
13347
13348 sequence_type: None,
13349
13350 array_type: None,
13351
13352 map_type: None,
13353
13354 enumerated_type: None,
13355
13356 bitmask_type: None,
13357
13358 extended_type: None,
13359 };
13360 match out._d {
13361 TK_ALIAS => {
13362 out.alias_type =
13363 Some(xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?);
13364 }
13365
13366 TK_ANNOTATION => {
13367 out.annotation_type =
13368 Some(xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?);
13369 }
13370
13371 TK_STRUCTURE => {
13372 out.struct_type =
13373 Some(xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?);
13374 }
13375
13376 TK_UNION => {
13377 out.union_type =
13378 Some(xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?);
13379 }
13380
13381 TK_BITSET => {
13382 out.bitset_type =
13383 Some(xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?);
13384 }
13385
13386 TK_SEQUENCE => {
13387 out.sequence_type =
13388 Some(xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?);
13389 }
13390
13391 TK_ARRAY => {
13392 out.array_type =
13393 Some(xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?);
13394 }
13395
13396 TK_MAP => {
13397 out.map_type = Some(xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?);
13398 }
13399
13400 TK_ENUM => {
13401 out.enumerated_type =
13402 Some(xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?);
13403 }
13404
13405 TK_BITMASK => {
13406 out.bitmask_type =
13407 Some(xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?);
13408 }
13409
13410 _ => {
13411 out.extended_type =
13412 Some(xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?);
13413 }
13414 }
13415 Ok(out)
13416 }
13417 }
13418
13419 impl xidl_typeobject::XidlTypeObject for CompleteTypeObject {
13420 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
13421 xidl_typeobject::runtime::build_minimal_union(
13422 0u32,
13423 xidl_typeobject::runtime::type_identifier_primitive(
13424 xidl_typeobject::DDS::XTypes::TK_BYTE,
13425 ),
13426 vec![
13427 xidl_typeobject::runtime::UnionMemberDesc {
13428 member_id: 7u32,
13429 member_flags: 0u32,
13430 type_id: xidl_typeobject::runtime::type_identifier_for::<
13431 CompleteArrayType,
13432 >(
13433 xidl_typeobject::runtime::TypeEquivalence::Minimal
13434 ),
13435 name: "array_type",
13436 labels: vec![0i32],
13437 },
13438 xidl_typeobject::runtime::UnionMemberDesc {
13439 member_id: 4u32,
13440 member_flags: 0u32,
13441 type_id: xidl_typeobject::runtime::type_identifier_for::<
13442 CompleteUnionType,
13443 >(
13444 xidl_typeobject::runtime::TypeEquivalence::Minimal
13445 ),
13446 name: "union_type",
13447 labels: vec![0i32],
13448 },
13449 xidl_typeobject::runtime::UnionMemberDesc {
13450 member_id: 3u32,
13451 member_flags: 0u32,
13452 type_id: xidl_typeobject::runtime::type_identifier_for::<
13453 CompleteStructType,
13454 >(
13455 xidl_typeobject::runtime::TypeEquivalence::Minimal
13456 ),
13457 name: "struct_type",
13458 labels: vec![0i32],
13459 },
13460 xidl_typeobject::runtime::UnionMemberDesc {
13461 member_id: 11u32,
13462 member_flags: 64u32,
13463 type_id: xidl_typeobject::runtime::type_identifier_for::<
13464 CompleteExtendedType,
13465 >(
13466 xidl_typeobject::runtime::TypeEquivalence::Minimal
13467 ),
13468 name: "extended_type",
13469 labels: vec![],
13470 },
13471 xidl_typeobject::runtime::UnionMemberDesc {
13472 member_id: 6u32,
13473 member_flags: 0u32,
13474 type_id: xidl_typeobject::runtime::type_identifier_for::<
13475 CompleteSequenceType,
13476 >(
13477 xidl_typeobject::runtime::TypeEquivalence::Minimal
13478 ),
13479 name: "sequence_type",
13480 labels: vec![0i32],
13481 },
13482 xidl_typeobject::runtime::UnionMemberDesc {
13483 member_id: 10u32,
13484 member_flags: 0u32,
13485 type_id: xidl_typeobject::runtime::type_identifier_for::<
13486 CompleteBitmaskType,
13487 >(
13488 xidl_typeobject::runtime::TypeEquivalence::Minimal
13489 ),
13490 name: "bitmask_type",
13491 labels: vec![0i32],
13492 },
13493 xidl_typeobject::runtime::UnionMemberDesc {
13494 member_id: 8u32,
13495 member_flags: 0u32,
13496 type_id: xidl_typeobject::runtime::type_identifier_for::<CompleteMapType>(
13497 xidl_typeobject::runtime::TypeEquivalence::Minimal,
13498 ),
13499 name: "map_type",
13500 labels: vec![0i32],
13501 },
13502 xidl_typeobject::runtime::UnionMemberDesc {
13503 member_id: 2u32,
13504 member_flags: 0u32,
13505 type_id: xidl_typeobject::runtime::type_identifier_for::<
13506 CompleteAnnotationType,
13507 >(
13508 xidl_typeobject::runtime::TypeEquivalence::Minimal
13509 ),
13510 name: "annotation_type",
13511 labels: vec![0i32],
13512 },
13513 xidl_typeobject::runtime::UnionMemberDesc {
13514 member_id: 9u32,
13515 member_flags: 0u32,
13516 type_id: xidl_typeobject::runtime::type_identifier_for::<
13517 CompleteEnumeratedType,
13518 >(
13519 xidl_typeobject::runtime::TypeEquivalence::Minimal
13520 ),
13521 name: "enumerated_type",
13522 labels: vec![0i32],
13523 },
13524 xidl_typeobject::runtime::UnionMemberDesc {
13525 member_id: 1u32,
13526 member_flags: 0u32,
13527 type_id: xidl_typeobject::runtime::type_identifier_for::<
13528 CompleteAliasType,
13529 >(
13530 xidl_typeobject::runtime::TypeEquivalence::Minimal
13531 ),
13532 name: "alias_type",
13533 labels: vec![0i32],
13534 },
13535 xidl_typeobject::runtime::UnionMemberDesc {
13536 member_id: 5u32,
13537 member_flags: 0u32,
13538 type_id: xidl_typeobject::runtime::type_identifier_for::<
13539 CompleteBitsetType,
13540 >(
13541 xidl_typeobject::runtime::TypeEquivalence::Minimal
13542 ),
13543 name: "bitset_type",
13544 labels: vec![0i32],
13545 },
13546 ],
13547 )
13548 }
13549
13550 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
13551 xidl_typeobject::runtime::build_complete_union(
13552 "DDS::XTypes::CompleteTypeObject",
13553 0u32,
13554 xidl_typeobject::runtime::type_identifier_primitive(
13555 xidl_typeobject::DDS::XTypes::TK_BYTE,
13556 ),
13557 vec![
13558 xidl_typeobject::runtime::UnionMemberDesc {
13559 member_id: 7u32,
13560 member_flags: 0u32,
13561 type_id: xidl_typeobject::runtime::type_identifier_for::<
13562 CompleteArrayType,
13563 >(
13564 xidl_typeobject::runtime::TypeEquivalence::Complete
13565 ),
13566 name: "array_type",
13567 labels: vec![0i32],
13568 },
13569 xidl_typeobject::runtime::UnionMemberDesc {
13570 member_id: 4u32,
13571 member_flags: 0u32,
13572 type_id: xidl_typeobject::runtime::type_identifier_for::<
13573 CompleteUnionType,
13574 >(
13575 xidl_typeobject::runtime::TypeEquivalence::Complete
13576 ),
13577 name: "union_type",
13578 labels: vec![0i32],
13579 },
13580 xidl_typeobject::runtime::UnionMemberDesc {
13581 member_id: 3u32,
13582 member_flags: 0u32,
13583 type_id: xidl_typeobject::runtime::type_identifier_for::<
13584 CompleteStructType,
13585 >(
13586 xidl_typeobject::runtime::TypeEquivalence::Complete
13587 ),
13588 name: "struct_type",
13589 labels: vec![0i32],
13590 },
13591 xidl_typeobject::runtime::UnionMemberDesc {
13592 member_id: 11u32,
13593 member_flags: 64u32,
13594 type_id: xidl_typeobject::runtime::type_identifier_for::<
13595 CompleteExtendedType,
13596 >(
13597 xidl_typeobject::runtime::TypeEquivalence::Complete
13598 ),
13599 name: "extended_type",
13600 labels: vec![],
13601 },
13602 xidl_typeobject::runtime::UnionMemberDesc {
13603 member_id: 6u32,
13604 member_flags: 0u32,
13605 type_id: xidl_typeobject::runtime::type_identifier_for::<
13606 CompleteSequenceType,
13607 >(
13608 xidl_typeobject::runtime::TypeEquivalence::Complete
13609 ),
13610 name: "sequence_type",
13611 labels: vec![0i32],
13612 },
13613 xidl_typeobject::runtime::UnionMemberDesc {
13614 member_id: 10u32,
13615 member_flags: 0u32,
13616 type_id: xidl_typeobject::runtime::type_identifier_for::<
13617 CompleteBitmaskType,
13618 >(
13619 xidl_typeobject::runtime::TypeEquivalence::Complete
13620 ),
13621 name: "bitmask_type",
13622 labels: vec![0i32],
13623 },
13624 xidl_typeobject::runtime::UnionMemberDesc {
13625 member_id: 8u32,
13626 member_flags: 0u32,
13627 type_id: xidl_typeobject::runtime::type_identifier_for::<CompleteMapType>(
13628 xidl_typeobject::runtime::TypeEquivalence::Complete,
13629 ),
13630 name: "map_type",
13631 labels: vec![0i32],
13632 },
13633 xidl_typeobject::runtime::UnionMemberDesc {
13634 member_id: 2u32,
13635 member_flags: 0u32,
13636 type_id: xidl_typeobject::runtime::type_identifier_for::<
13637 CompleteAnnotationType,
13638 >(
13639 xidl_typeobject::runtime::TypeEquivalence::Complete
13640 ),
13641 name: "annotation_type",
13642 labels: vec![0i32],
13643 },
13644 xidl_typeobject::runtime::UnionMemberDesc {
13645 member_id: 9u32,
13646 member_flags: 0u32,
13647 type_id: xidl_typeobject::runtime::type_identifier_for::<
13648 CompleteEnumeratedType,
13649 >(
13650 xidl_typeobject::runtime::TypeEquivalence::Complete
13651 ),
13652 name: "enumerated_type",
13653 labels: vec![0i32],
13654 },
13655 xidl_typeobject::runtime::UnionMemberDesc {
13656 member_id: 1u32,
13657 member_flags: 0u32,
13658 type_id: xidl_typeobject::runtime::type_identifier_for::<
13659 CompleteAliasType,
13660 >(
13661 xidl_typeobject::runtime::TypeEquivalence::Complete
13662 ),
13663 name: "alias_type",
13664 labels: vec![0i32],
13665 },
13666 xidl_typeobject::runtime::UnionMemberDesc {
13667 member_id: 5u32,
13668 member_flags: 0u32,
13669 type_id: xidl_typeobject::runtime::type_identifier_for::<
13670 CompleteBitsetType,
13671 >(
13672 xidl_typeobject::runtime::TypeEquivalence::Complete
13673 ),
13674 name: "bitset_type",
13675 labels: vec![0i32],
13676 },
13677 ],
13678 )
13679 }
13680 }
13681 pub struct MinimalExtendedType {}
13682
13683 impl MinimalExtendedType {
13684 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
13685 }
13686
13687 impl xidl_xcdr::XcdrSerialize for MinimalExtendedType {
13688 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
13689 Self::SERIALIZE_KIND
13690 }
13691
13692 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
13693 &self,
13694 serializer: &mut S,
13695 ) -> xidl_xcdr::error::XcdrResult<()> {
13696 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
13697
13698 serializer.end_struct()?;
13699 Ok(())
13700 }
13701 }
13702
13703 impl xidl_xcdr::XcdrDeserialize for MinimalExtendedType {
13704 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
13705 deserializer: &mut D,
13706 ) -> xidl_xcdr::error::XcdrResult<Self> {
13707 Ok(Self {})
13708 }
13709 }
13710
13711 impl xidl_typeobject::XidlTypeObject for MinimalExtendedType {
13712 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
13713 xidl_typeobject::runtime::build_minimal_struct(
13714 0u32,
13715 xidl_typeobject::runtime::type_identifier_none(),
13716 vec![],
13717 )
13718 }
13719
13720 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
13721 xidl_typeobject::runtime::build_complete_struct(
13722 "DDS::XTypes::MinimalExtendedType",
13723 0u32,
13724 xidl_typeobject::runtime::type_identifier_none(),
13725 vec![],
13726 )
13727 }
13728 }
13729 pub struct MinimalTypeObject {
13730 pub _d: u8,
13731
13732 pub alias_type: Option<Box<MinimalAliasType>>,
13733
13734 pub annotation_type: Option<Box<MinimalAnnotationType>>,
13735
13736 pub struct_type: Option<Box<MinimalStructType>>,
13737
13738 pub union_type: Option<Box<MinimalUnionType>>,
13739
13740 pub bitset_type: Option<Box<MinimalBitsetType>>,
13741
13742 pub sequence_type: Option<Box<MinimalSequenceType>>,
13743
13744 pub array_type: Option<Box<MinimalArrayType>>,
13745
13746 pub map_type: Option<Box<MinimalMapType>>,
13747
13748 pub enumerated_type: Option<Box<MinimalEnumeratedType>>,
13749
13750 pub bitmask_type: Option<Box<MinimalBitmaskType>>,
13751
13752 pub extended_type: Option<Box<MinimalExtendedType>>,
13753 }
13754
13755 impl MinimalTypeObject {
13756 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
13757
13758 pub fn new_alias_type(value: Box<MinimalAliasType>) -> Self {
13759 Self {
13760 _d: TK_ALIAS,
13761 alias_type: Some(value),
13762
13763 annotation_type: None,
13764
13765 struct_type: None,
13766
13767 union_type: None,
13768
13769 bitset_type: None,
13770
13771 sequence_type: None,
13772
13773 array_type: None,
13774
13775 map_type: None,
13776
13777 enumerated_type: None,
13778
13779 bitmask_type: None,
13780
13781 extended_type: None,
13782 }
13783 }
13784
13785 pub fn is_alias_type(&self) -> bool {
13786 matches!(self._d, TK_ALIAS)
13787 }
13788
13789 pub fn new_annotation_type(value: Box<MinimalAnnotationType>) -> Self {
13790 Self {
13791 _d: TK_ANNOTATION,
13792 annotation_type: Some(value),
13793
13794 alias_type: None,
13795
13796 struct_type: None,
13797
13798 union_type: None,
13799
13800 bitset_type: None,
13801
13802 sequence_type: None,
13803
13804 array_type: None,
13805
13806 map_type: None,
13807
13808 enumerated_type: None,
13809
13810 bitmask_type: None,
13811
13812 extended_type: None,
13813 }
13814 }
13815
13816 pub fn is_annotation_type(&self) -> bool {
13817 matches!(self._d, TK_ANNOTATION)
13818 }
13819
13820 pub fn new_struct_type(value: Box<MinimalStructType>) -> Self {
13821 Self {
13822 _d: TK_STRUCTURE,
13823 struct_type: Some(value),
13824
13825 alias_type: None,
13826
13827 annotation_type: None,
13828
13829 union_type: None,
13830
13831 bitset_type: None,
13832
13833 sequence_type: None,
13834
13835 array_type: None,
13836
13837 map_type: None,
13838
13839 enumerated_type: None,
13840
13841 bitmask_type: None,
13842
13843 extended_type: None,
13844 }
13845 }
13846
13847 pub fn is_struct_type(&self) -> bool {
13848 matches!(self._d, TK_STRUCTURE)
13849 }
13850
13851 pub fn new_union_type(value: Box<MinimalUnionType>) -> Self {
13852 Self {
13853 _d: TK_UNION,
13854 union_type: Some(value),
13855
13856 alias_type: None,
13857
13858 annotation_type: None,
13859
13860 struct_type: None,
13861
13862 bitset_type: None,
13863
13864 sequence_type: None,
13865
13866 array_type: None,
13867
13868 map_type: None,
13869
13870 enumerated_type: None,
13871
13872 bitmask_type: None,
13873
13874 extended_type: None,
13875 }
13876 }
13877
13878 pub fn is_union_type(&self) -> bool {
13879 matches!(self._d, TK_UNION)
13880 }
13881
13882 pub fn new_bitset_type(value: Box<MinimalBitsetType>) -> Self {
13883 Self {
13884 _d: TK_BITSET,
13885 bitset_type: Some(value),
13886
13887 alias_type: None,
13888
13889 annotation_type: None,
13890
13891 struct_type: None,
13892
13893 union_type: None,
13894
13895 sequence_type: None,
13896
13897 array_type: None,
13898
13899 map_type: None,
13900
13901 enumerated_type: None,
13902
13903 bitmask_type: None,
13904
13905 extended_type: None,
13906 }
13907 }
13908
13909 pub fn is_bitset_type(&self) -> bool {
13910 matches!(self._d, TK_BITSET)
13911 }
13912
13913 pub fn new_sequence_type(value: Box<MinimalSequenceType>) -> Self {
13914 Self {
13915 _d: TK_SEQUENCE,
13916 sequence_type: Some(value),
13917
13918 alias_type: None,
13919
13920 annotation_type: None,
13921
13922 struct_type: None,
13923
13924 union_type: None,
13925
13926 bitset_type: None,
13927
13928 array_type: None,
13929
13930 map_type: None,
13931
13932 enumerated_type: None,
13933
13934 bitmask_type: None,
13935
13936 extended_type: None,
13937 }
13938 }
13939
13940 pub fn is_sequence_type(&self) -> bool {
13941 matches!(self._d, TK_SEQUENCE)
13942 }
13943
13944 pub fn new_array_type(value: Box<MinimalArrayType>) -> Self {
13945 Self {
13946 _d: TK_ARRAY,
13947 array_type: Some(value),
13948
13949 alias_type: None,
13950
13951 annotation_type: None,
13952
13953 struct_type: None,
13954
13955 union_type: None,
13956
13957 bitset_type: None,
13958
13959 sequence_type: None,
13960
13961 map_type: None,
13962
13963 enumerated_type: None,
13964
13965 bitmask_type: None,
13966
13967 extended_type: None,
13968 }
13969 }
13970
13971 pub fn is_array_type(&self) -> bool {
13972 matches!(self._d, TK_ARRAY)
13973 }
13974
13975 pub fn new_map_type(value: Box<MinimalMapType>) -> Self {
13976 Self {
13977 _d: TK_MAP,
13978 map_type: Some(value),
13979
13980 alias_type: None,
13981
13982 annotation_type: None,
13983
13984 struct_type: None,
13985
13986 union_type: None,
13987
13988 bitset_type: None,
13989
13990 sequence_type: None,
13991
13992 array_type: None,
13993
13994 enumerated_type: None,
13995
13996 bitmask_type: None,
13997
13998 extended_type: None,
13999 }
14000 }
14001
14002 pub fn is_map_type(&self) -> bool {
14003 matches!(self._d, TK_MAP)
14004 }
14005
14006 pub fn new_enumerated_type(value: Box<MinimalEnumeratedType>) -> Self {
14007 Self {
14008 _d: TK_ENUM,
14009 enumerated_type: Some(value),
14010
14011 alias_type: None,
14012
14013 annotation_type: None,
14014
14015 struct_type: None,
14016
14017 union_type: None,
14018
14019 bitset_type: None,
14020
14021 sequence_type: None,
14022
14023 array_type: None,
14024
14025 map_type: None,
14026
14027 bitmask_type: None,
14028
14029 extended_type: None,
14030 }
14031 }
14032
14033 pub fn is_enumerated_type(&self) -> bool {
14034 matches!(self._d, TK_ENUM)
14035 }
14036
14037 pub fn new_bitmask_type(value: Box<MinimalBitmaskType>) -> Self {
14038 Self {
14039 _d: TK_BITMASK,
14040 bitmask_type: Some(value),
14041
14042 alias_type: None,
14043
14044 annotation_type: None,
14045
14046 struct_type: None,
14047
14048 union_type: None,
14049
14050 bitset_type: None,
14051
14052 sequence_type: None,
14053
14054 array_type: None,
14055
14056 map_type: None,
14057
14058 enumerated_type: None,
14059
14060 extended_type: None,
14061 }
14062 }
14063
14064 pub fn is_bitmask_type(&self) -> bool {
14065 matches!(self._d, TK_BITMASK)
14066 }
14067
14068 pub fn new_extended_type(value: Box<MinimalExtendedType>) -> Self {
14069 Self {
14070 _d: u8::default(),
14071 extended_type: Some(value),
14072
14073 alias_type: None,
14074
14075 annotation_type: None,
14076
14077 struct_type: None,
14078
14079 union_type: None,
14080
14081 bitset_type: None,
14082
14083 sequence_type: None,
14084
14085 array_type: None,
14086
14087 map_type: None,
14088
14089 enumerated_type: None,
14090
14091 bitmask_type: None,
14092 }
14093 }
14094
14095 pub fn is_extended_type(&self) -> bool {
14096 matches!(self._d, _)
14097 }
14098
14099 pub fn tag(&self) -> &u8 {
14100 &self._d
14101 }
14102 }
14103
14104 impl xidl_xcdr::XcdrSerialize for MinimalTypeObject {
14105 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
14106 Self::SERIALIZE_KIND
14107 }
14108
14109 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
14110 &self,
14111 serializer: &mut S,
14112 ) -> xidl_xcdr::error::XcdrResult<()> {
14113 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
14114 serializer.begin_field(xidl_xcdr::FieldId(0), false, 0)?;
14115 xidl_xcdr::XcdrSerialize::serialize_with(&self._d, serializer)?;
14116 serializer.end_field()?;
14117 match self._d {
14118 TK_ALIAS => {
14119 let value = self.alias_type.as_ref().ok_or_else(|| {
14120 xidl_xcdr::error::XcdrError::Message(
14121 "union member is not set for discriminator".to_string(),
14122 )
14123 })?;
14124 serializer.begin_field(xidl_xcdr::FieldId(1u32), false, 0)?;
14125 xidl_xcdr::XcdrSerialize::serialize_with(value, serializer)?;
14126 serializer.end_field()?;
14127 }
14128
14129 TK_ANNOTATION => {
14130 let value = self.annotation_type.as_ref().ok_or_else(|| {
14131 xidl_xcdr::error::XcdrError::Message(
14132 "union member is not set for discriminator".to_string(),
14133 )
14134 })?;
14135 serializer.begin_field(xidl_xcdr::FieldId(2u32), false, 0)?;
14136 xidl_xcdr::XcdrSerialize::serialize_with(value, serializer)?;
14137 serializer.end_field()?;
14138 }
14139
14140 TK_STRUCTURE => {
14141 let value = self.struct_type.as_ref().ok_or_else(|| {
14142 xidl_xcdr::error::XcdrError::Message(
14143 "union member is not set for discriminator".to_string(),
14144 )
14145 })?;
14146 serializer.begin_field(xidl_xcdr::FieldId(3u32), false, 0)?;
14147 xidl_xcdr::XcdrSerialize::serialize_with(value, serializer)?;
14148 serializer.end_field()?;
14149 }
14150
14151 TK_UNION => {
14152 let value = self.union_type.as_ref().ok_or_else(|| {
14153 xidl_xcdr::error::XcdrError::Message(
14154 "union member is not set for discriminator".to_string(),
14155 )
14156 })?;
14157 serializer.begin_field(xidl_xcdr::FieldId(4u32), false, 0)?;
14158 xidl_xcdr::XcdrSerialize::serialize_with(value, serializer)?;
14159 serializer.end_field()?;
14160 }
14161
14162 TK_BITSET => {
14163 let value = self.bitset_type.as_ref().ok_or_else(|| {
14164 xidl_xcdr::error::XcdrError::Message(
14165 "union member is not set for discriminator".to_string(),
14166 )
14167 })?;
14168 serializer.begin_field(xidl_xcdr::FieldId(5u32), false, 0)?;
14169 xidl_xcdr::XcdrSerialize::serialize_with(value, serializer)?;
14170 serializer.end_field()?;
14171 }
14172
14173 TK_SEQUENCE => {
14174 let value = self.sequence_type.as_ref().ok_or_else(|| {
14175 xidl_xcdr::error::XcdrError::Message(
14176 "union member is not set for discriminator".to_string(),
14177 )
14178 })?;
14179 serializer.begin_field(xidl_xcdr::FieldId(6u32), false, 0)?;
14180 xidl_xcdr::XcdrSerialize::serialize_with(value, serializer)?;
14181 serializer.end_field()?;
14182 }
14183
14184 TK_ARRAY => {
14185 let value = self.array_type.as_ref().ok_or_else(|| {
14186 xidl_xcdr::error::XcdrError::Message(
14187 "union member is not set for discriminator".to_string(),
14188 )
14189 })?;
14190 serializer.begin_field(xidl_xcdr::FieldId(7u32), false, 0)?;
14191 xidl_xcdr::XcdrSerialize::serialize_with(value, serializer)?;
14192 serializer.end_field()?;
14193 }
14194
14195 TK_MAP => {
14196 let value = self.map_type.as_ref().ok_or_else(|| {
14197 xidl_xcdr::error::XcdrError::Message(
14198 "union member is not set for discriminator".to_string(),
14199 )
14200 })?;
14201 serializer.begin_field(xidl_xcdr::FieldId(8u32), false, 0)?;
14202 xidl_xcdr::XcdrSerialize::serialize_with(value, serializer)?;
14203 serializer.end_field()?;
14204 }
14205
14206 TK_ENUM => {
14207 let value = self.enumerated_type.as_ref().ok_or_else(|| {
14208 xidl_xcdr::error::XcdrError::Message(
14209 "union member is not set for discriminator".to_string(),
14210 )
14211 })?;
14212 serializer.begin_field(xidl_xcdr::FieldId(9u32), false, 0)?;
14213 xidl_xcdr::XcdrSerialize::serialize_with(value, serializer)?;
14214 serializer.end_field()?;
14215 }
14216
14217 TK_BITMASK => {
14218 let value = self.bitmask_type.as_ref().ok_or_else(|| {
14219 xidl_xcdr::error::XcdrError::Message(
14220 "union member is not set for discriminator".to_string(),
14221 )
14222 })?;
14223 serializer.begin_field(xidl_xcdr::FieldId(10u32), false, 0)?;
14224 xidl_xcdr::XcdrSerialize::serialize_with(value, serializer)?;
14225 serializer.end_field()?;
14226 }
14227
14228 _ => {
14229 let value = self.extended_type.as_ref().ok_or_else(|| {
14230 xidl_xcdr::error::XcdrError::Message(
14231 "union member is not set for discriminator".to_string(),
14232 )
14233 })?;
14234 serializer.begin_field(xidl_xcdr::FieldId(11u32), false, 0)?;
14235 xidl_xcdr::XcdrSerialize::serialize_with(value, serializer)?;
14236 serializer.end_field()?;
14237 }
14238 }
14239 serializer.end_struct()?;
14240 Ok(())
14241 }
14242 }
14243
14244 impl xidl_xcdr::XcdrDeserialize for MinimalTypeObject {
14245 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
14246 deserializer: &mut D,
14247 ) -> xidl_xcdr::error::XcdrResult<Self> {
14248 let _d = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
14249 let mut out = Self {
14250 _d,
14251
14252 alias_type: None,
14253
14254 annotation_type: None,
14255
14256 struct_type: None,
14257
14258 union_type: None,
14259
14260 bitset_type: None,
14261
14262 sequence_type: None,
14263
14264 array_type: None,
14265
14266 map_type: None,
14267
14268 enumerated_type: None,
14269
14270 bitmask_type: None,
14271
14272 extended_type: None,
14273 };
14274 match out._d {
14275 TK_ALIAS => {
14276 out.alias_type =
14277 Some(xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?);
14278 }
14279
14280 TK_ANNOTATION => {
14281 out.annotation_type =
14282 Some(xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?);
14283 }
14284
14285 TK_STRUCTURE => {
14286 out.struct_type =
14287 Some(xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?);
14288 }
14289
14290 TK_UNION => {
14291 out.union_type =
14292 Some(xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?);
14293 }
14294
14295 TK_BITSET => {
14296 out.bitset_type =
14297 Some(xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?);
14298 }
14299
14300 TK_SEQUENCE => {
14301 out.sequence_type =
14302 Some(xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?);
14303 }
14304
14305 TK_ARRAY => {
14306 out.array_type =
14307 Some(xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?);
14308 }
14309
14310 TK_MAP => {
14311 out.map_type = Some(xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?);
14312 }
14313
14314 TK_ENUM => {
14315 out.enumerated_type =
14316 Some(xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?);
14317 }
14318
14319 TK_BITMASK => {
14320 out.bitmask_type =
14321 Some(xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?);
14322 }
14323
14324 _ => {
14325 out.extended_type =
14326 Some(xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?);
14327 }
14328 }
14329 Ok(out)
14330 }
14331 }
14332
14333 impl xidl_typeobject::XidlTypeObject for MinimalTypeObject {
14334 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
14335 xidl_typeobject::runtime::build_minimal_union(
14336 0u32,
14337 xidl_typeobject::runtime::type_identifier_primitive(
14338 xidl_typeobject::DDS::XTypes::TK_BYTE,
14339 ),
14340 vec![
14341 xidl_typeobject::runtime::UnionMemberDesc {
14342 member_id: 10u32,
14343 member_flags: 0u32,
14344 type_id: xidl_typeobject::runtime::type_identifier_for::<
14345 MinimalBitmaskType,
14346 >(
14347 xidl_typeobject::runtime::TypeEquivalence::Minimal
14348 ),
14349 name: "bitmask_type",
14350 labels: vec![0i32],
14351 },
14352 xidl_typeobject::runtime::UnionMemberDesc {
14353 member_id: 9u32,
14354 member_flags: 0u32,
14355 type_id: xidl_typeobject::runtime::type_identifier_for::<
14356 MinimalEnumeratedType,
14357 >(
14358 xidl_typeobject::runtime::TypeEquivalence::Minimal
14359 ),
14360 name: "enumerated_type",
14361 labels: vec![0i32],
14362 },
14363 xidl_typeobject::runtime::UnionMemberDesc {
14364 member_id: 1u32,
14365 member_flags: 0u32,
14366 type_id: xidl_typeobject::runtime::type_identifier_for::<
14367 MinimalAliasType,
14368 >(
14369 xidl_typeobject::runtime::TypeEquivalence::Minimal
14370 ),
14371 name: "alias_type",
14372 labels: vec![0i32],
14373 },
14374 xidl_typeobject::runtime::UnionMemberDesc {
14375 member_id: 4u32,
14376 member_flags: 0u32,
14377 type_id: xidl_typeobject::runtime::type_identifier_for::<
14378 MinimalUnionType,
14379 >(
14380 xidl_typeobject::runtime::TypeEquivalence::Minimal
14381 ),
14382 name: "union_type",
14383 labels: vec![0i32],
14384 },
14385 xidl_typeobject::runtime::UnionMemberDesc {
14386 member_id: 2u32,
14387 member_flags: 0u32,
14388 type_id: xidl_typeobject::runtime::type_identifier_for::<
14389 MinimalAnnotationType,
14390 >(
14391 xidl_typeobject::runtime::TypeEquivalence::Minimal
14392 ),
14393 name: "annotation_type",
14394 labels: vec![0i32],
14395 },
14396 xidl_typeobject::runtime::UnionMemberDesc {
14397 member_id: 11u32,
14398 member_flags: 64u32,
14399 type_id: xidl_typeobject::runtime::type_identifier_for::<
14400 MinimalExtendedType,
14401 >(
14402 xidl_typeobject::runtime::TypeEquivalence::Minimal
14403 ),
14404 name: "extended_type",
14405 labels: vec![],
14406 },
14407 xidl_typeobject::runtime::UnionMemberDesc {
14408 member_id: 8u32,
14409 member_flags: 0u32,
14410 type_id: xidl_typeobject::runtime::type_identifier_for::<MinimalMapType>(
14411 xidl_typeobject::runtime::TypeEquivalence::Minimal,
14412 ),
14413 name: "map_type",
14414 labels: vec![0i32],
14415 },
14416 xidl_typeobject::runtime::UnionMemberDesc {
14417 member_id: 7u32,
14418 member_flags: 0u32,
14419 type_id: xidl_typeobject::runtime::type_identifier_for::<
14420 MinimalArrayType,
14421 >(
14422 xidl_typeobject::runtime::TypeEquivalence::Minimal
14423 ),
14424 name: "array_type",
14425 labels: vec![0i32],
14426 },
14427 xidl_typeobject::runtime::UnionMemberDesc {
14428 member_id: 6u32,
14429 member_flags: 0u32,
14430 type_id: xidl_typeobject::runtime::type_identifier_for::<
14431 MinimalSequenceType,
14432 >(
14433 xidl_typeobject::runtime::TypeEquivalence::Minimal
14434 ),
14435 name: "sequence_type",
14436 labels: vec![0i32],
14437 },
14438 xidl_typeobject::runtime::UnionMemberDesc {
14439 member_id: 5u32,
14440 member_flags: 0u32,
14441 type_id: xidl_typeobject::runtime::type_identifier_for::<
14442 MinimalBitsetType,
14443 >(
14444 xidl_typeobject::runtime::TypeEquivalence::Minimal
14445 ),
14446 name: "bitset_type",
14447 labels: vec![0i32],
14448 },
14449 xidl_typeobject::runtime::UnionMemberDesc {
14450 member_id: 3u32,
14451 member_flags: 0u32,
14452 type_id: xidl_typeobject::runtime::type_identifier_for::<
14453 MinimalStructType,
14454 >(
14455 xidl_typeobject::runtime::TypeEquivalence::Minimal
14456 ),
14457 name: "struct_type",
14458 labels: vec![0i32],
14459 },
14460 ],
14461 )
14462 }
14463
14464 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
14465 xidl_typeobject::runtime::build_complete_union(
14466 "DDS::XTypes::MinimalTypeObject",
14467 0u32,
14468 xidl_typeobject::runtime::type_identifier_primitive(
14469 xidl_typeobject::DDS::XTypes::TK_BYTE,
14470 ),
14471 vec![
14472 xidl_typeobject::runtime::UnionMemberDesc {
14473 member_id: 10u32,
14474 member_flags: 0u32,
14475 type_id: xidl_typeobject::runtime::type_identifier_for::<
14476 MinimalBitmaskType,
14477 >(
14478 xidl_typeobject::runtime::TypeEquivalence::Complete
14479 ),
14480 name: "bitmask_type",
14481 labels: vec![0i32],
14482 },
14483 xidl_typeobject::runtime::UnionMemberDesc {
14484 member_id: 9u32,
14485 member_flags: 0u32,
14486 type_id: xidl_typeobject::runtime::type_identifier_for::<
14487 MinimalEnumeratedType,
14488 >(
14489 xidl_typeobject::runtime::TypeEquivalence::Complete
14490 ),
14491 name: "enumerated_type",
14492 labels: vec![0i32],
14493 },
14494 xidl_typeobject::runtime::UnionMemberDesc {
14495 member_id: 1u32,
14496 member_flags: 0u32,
14497 type_id: xidl_typeobject::runtime::type_identifier_for::<
14498 MinimalAliasType,
14499 >(
14500 xidl_typeobject::runtime::TypeEquivalence::Complete
14501 ),
14502 name: "alias_type",
14503 labels: vec![0i32],
14504 },
14505 xidl_typeobject::runtime::UnionMemberDesc {
14506 member_id: 4u32,
14507 member_flags: 0u32,
14508 type_id: xidl_typeobject::runtime::type_identifier_for::<
14509 MinimalUnionType,
14510 >(
14511 xidl_typeobject::runtime::TypeEquivalence::Complete
14512 ),
14513 name: "union_type",
14514 labels: vec![0i32],
14515 },
14516 xidl_typeobject::runtime::UnionMemberDesc {
14517 member_id: 2u32,
14518 member_flags: 0u32,
14519 type_id: xidl_typeobject::runtime::type_identifier_for::<
14520 MinimalAnnotationType,
14521 >(
14522 xidl_typeobject::runtime::TypeEquivalence::Complete
14523 ),
14524 name: "annotation_type",
14525 labels: vec![0i32],
14526 },
14527 xidl_typeobject::runtime::UnionMemberDesc {
14528 member_id: 11u32,
14529 member_flags: 64u32,
14530 type_id: xidl_typeobject::runtime::type_identifier_for::<
14531 MinimalExtendedType,
14532 >(
14533 xidl_typeobject::runtime::TypeEquivalence::Complete
14534 ),
14535 name: "extended_type",
14536 labels: vec![],
14537 },
14538 xidl_typeobject::runtime::UnionMemberDesc {
14539 member_id: 8u32,
14540 member_flags: 0u32,
14541 type_id: xidl_typeobject::runtime::type_identifier_for::<MinimalMapType>(
14542 xidl_typeobject::runtime::TypeEquivalence::Complete,
14543 ),
14544 name: "map_type",
14545 labels: vec![0i32],
14546 },
14547 xidl_typeobject::runtime::UnionMemberDesc {
14548 member_id: 7u32,
14549 member_flags: 0u32,
14550 type_id: xidl_typeobject::runtime::type_identifier_for::<
14551 MinimalArrayType,
14552 >(
14553 xidl_typeobject::runtime::TypeEquivalence::Complete
14554 ),
14555 name: "array_type",
14556 labels: vec![0i32],
14557 },
14558 xidl_typeobject::runtime::UnionMemberDesc {
14559 member_id: 6u32,
14560 member_flags: 0u32,
14561 type_id: xidl_typeobject::runtime::type_identifier_for::<
14562 MinimalSequenceType,
14563 >(
14564 xidl_typeobject::runtime::TypeEquivalence::Complete
14565 ),
14566 name: "sequence_type",
14567 labels: vec![0i32],
14568 },
14569 xidl_typeobject::runtime::UnionMemberDesc {
14570 member_id: 5u32,
14571 member_flags: 0u32,
14572 type_id: xidl_typeobject::runtime::type_identifier_for::<
14573 MinimalBitsetType,
14574 >(
14575 xidl_typeobject::runtime::TypeEquivalence::Complete
14576 ),
14577 name: "bitset_type",
14578 labels: vec![0i32],
14579 },
14580 xidl_typeobject::runtime::UnionMemberDesc {
14581 member_id: 3u32,
14582 member_flags: 0u32,
14583 type_id: xidl_typeobject::runtime::type_identifier_for::<
14584 MinimalStructType,
14585 >(
14586 xidl_typeobject::runtime::TypeEquivalence::Complete
14587 ),
14588 name: "struct_type",
14589 labels: vec![0i32],
14590 },
14591 ],
14592 )
14593 }
14594 }
14595 pub struct TypeObject {
14596 pub _d: u8,
14597
14598 pub complete: Option<Box<CompleteTypeObject>>,
14599
14600 pub minimal: Option<Box<MinimalTypeObject>>,
14601 }
14602
14603 impl TypeObject {
14604 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
14605
14606 pub fn new_complete(value: Box<CompleteTypeObject>) -> Self {
14607 Self {
14608 _d: EK_COMPLETE,
14609 complete: Some(value),
14610
14611 minimal: None,
14612 }
14613 }
14614
14615 pub fn is_complete(&self) -> bool {
14616 matches!(self._d, EK_COMPLETE)
14617 }
14618
14619 pub fn new_minimal(value: Box<MinimalTypeObject>) -> Self {
14620 Self {
14621 _d: EK_MINIMAL,
14622 minimal: Some(value),
14623
14624 complete: None,
14625 }
14626 }
14627
14628 pub fn is_minimal(&self) -> bool {
14629 matches!(self._d, EK_MINIMAL)
14630 }
14631
14632 pub fn tag(&self) -> &u8 {
14633 &self._d
14634 }
14635 }
14636
14637 impl xidl_xcdr::XcdrSerialize for TypeObject {
14638 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
14639 Self::SERIALIZE_KIND
14640 }
14641
14642 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
14643 &self,
14644 serializer: &mut S,
14645 ) -> xidl_xcdr::error::XcdrResult<()> {
14646 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
14647 serializer.begin_field(xidl_xcdr::FieldId(0), false, 0)?;
14648 xidl_xcdr::XcdrSerialize::serialize_with(&self._d, serializer)?;
14649 serializer.end_field()?;
14650 match self._d {
14651 EK_COMPLETE => {
14652 let value = self.complete.as_ref().ok_or_else(|| {
14653 xidl_xcdr::error::XcdrError::Message(
14654 "union member is not set for discriminator".to_string(),
14655 )
14656 })?;
14657 serializer.begin_field(xidl_xcdr::FieldId(1u32), false, 0)?;
14658 xidl_xcdr::XcdrSerialize::serialize_with(value, serializer)?;
14659 serializer.end_field()?;
14660 }
14661
14662 EK_MINIMAL => {
14663 let value = self.minimal.as_ref().ok_or_else(|| {
14664 xidl_xcdr::error::XcdrError::Message(
14665 "union member is not set for discriminator".to_string(),
14666 )
14667 })?;
14668 serializer.begin_field(xidl_xcdr::FieldId(2u32), false, 0)?;
14669 xidl_xcdr::XcdrSerialize::serialize_with(value, serializer)?;
14670 serializer.end_field()?;
14671 }
14672
14673 _ => {}
14674 }
14675 serializer.end_struct()?;
14676 Ok(())
14677 }
14678 }
14679
14680 impl xidl_xcdr::XcdrDeserialize for TypeObject {
14681 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
14682 deserializer: &mut D,
14683 ) -> xidl_xcdr::error::XcdrResult<Self> {
14684 let _d = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
14685 let mut out = Self {
14686 _d,
14687
14688 complete: None,
14689
14690 minimal: None,
14691 };
14692 match out._d {
14693 EK_COMPLETE => {
14694 out.complete = Some(xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?);
14695 }
14696
14697 EK_MINIMAL => {
14698 out.minimal = Some(xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?);
14699 }
14700
14701 _ => {}
14702 }
14703 Ok(out)
14704 }
14705 }
14706
14707 impl xidl_typeobject::XidlTypeObject for TypeObject {
14708 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
14709 xidl_typeobject::runtime::build_minimal_union(
14710 0u32,
14711 xidl_typeobject::runtime::type_identifier_primitive(
14712 xidl_typeobject::DDS::XTypes::TK_BYTE,
14713 ),
14714 vec![
14715 xidl_typeobject::runtime::UnionMemberDesc {
14716 member_id: 1u32,
14717 member_flags: 0u32,
14718 type_id: xidl_typeobject::runtime::type_identifier_for::<
14719 CompleteTypeObject,
14720 >(
14721 xidl_typeobject::runtime::TypeEquivalence::Minimal
14722 ),
14723 name: "complete",
14724 labels: vec![0i32],
14725 },
14726 xidl_typeobject::runtime::UnionMemberDesc {
14727 member_id: 2u32,
14728 member_flags: 0u32,
14729 type_id: xidl_typeobject::runtime::type_identifier_for::<
14730 MinimalTypeObject,
14731 >(
14732 xidl_typeobject::runtime::TypeEquivalence::Minimal
14733 ),
14734 name: "minimal",
14735 labels: vec![0i32],
14736 },
14737 ],
14738 )
14739 }
14740
14741 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
14742 xidl_typeobject::runtime::build_complete_union(
14743 "DDS::XTypes::TypeObject",
14744 0u32,
14745 xidl_typeobject::runtime::type_identifier_primitive(
14746 xidl_typeobject::DDS::XTypes::TK_BYTE,
14747 ),
14748 vec![
14749 xidl_typeobject::runtime::UnionMemberDesc {
14750 member_id: 1u32,
14751 member_flags: 0u32,
14752 type_id: xidl_typeobject::runtime::type_identifier_for::<
14753 CompleteTypeObject,
14754 >(
14755 xidl_typeobject::runtime::TypeEquivalence::Complete
14756 ),
14757 name: "complete",
14758 labels: vec![0i32],
14759 },
14760 xidl_typeobject::runtime::UnionMemberDesc {
14761 member_id: 2u32,
14762 member_flags: 0u32,
14763 type_id: xidl_typeobject::runtime::type_identifier_for::<
14764 MinimalTypeObject,
14765 >(
14766 xidl_typeobject::runtime::TypeEquivalence::Complete
14767 ),
14768 name: "minimal",
14769 labels: vec![0i32],
14770 },
14771 ],
14772 )
14773 }
14774 }
14775 pub type TypeObjectSeq = Vec<TypeObject>;
14776 pub type StronglyConnectedComponent = TypeObjectSeq;
14777 pub struct TypeIdentifierTypeObjectPair {
14778 pub type_identifier: Box<TypeIdentifier>,
14779
14780 pub type_object: Box<TypeObject>,
14781 }
14782
14783 impl TypeIdentifierTypeObjectPair {
14784 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
14785 }
14786
14787 impl xidl_xcdr::XcdrSerialize for TypeIdentifierTypeObjectPair {
14788 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
14789 Self::SERIALIZE_KIND
14790 }
14791
14792 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
14793 &self,
14794 serializer: &mut S,
14795 ) -> xidl_xcdr::error::XcdrResult<()> {
14796 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
14797
14798 serializer.begin_field(xidl_xcdr::FieldId(1u32), false, 0)?;
14799
14800 xidl_xcdr::XcdrSerialize::serialize_with(&self.type_identifier, serializer)?;
14801 serializer.end_field()?;
14802
14803 serializer.begin_field(xidl_xcdr::FieldId(2u32), false, 0)?;
14804
14805 xidl_xcdr::XcdrSerialize::serialize_with(&self.type_object, serializer)?;
14806 serializer.end_field()?;
14807
14808 serializer.end_struct()?;
14809 Ok(())
14810 }
14811 }
14812
14813 impl xidl_xcdr::XcdrDeserialize for TypeIdentifierTypeObjectPair {
14814 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
14815 deserializer: &mut D,
14816 ) -> xidl_xcdr::error::XcdrResult<Self> {
14817 let type_identifier = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
14818
14819 let type_object = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
14820
14821 Ok(Self {
14822 type_identifier,
14823
14824 type_object,
14825 })
14826 }
14827 }
14828
14829 impl xidl_typeobject::XidlTypeObject for TypeIdentifierTypeObjectPair {
14830 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
14831 xidl_typeobject::runtime::build_minimal_struct(
14832 0u32,
14833 xidl_typeobject::runtime::type_identifier_none(),
14834 vec![
14835 xidl_typeobject::runtime::StructMemberDesc {
14836 member_id: 1u32,
14837 member_flags: 0u32,
14838 type_id: xidl_typeobject::runtime::type_identifier_for::<TypeIdentifier>(
14839 xidl_typeobject::runtime::TypeEquivalence::Minimal,
14840 ),
14841 name: "type_identifier",
14842 },
14843 xidl_typeobject::runtime::StructMemberDesc {
14844 member_id: 2u32,
14845 member_flags: 0u32,
14846 type_id: xidl_typeobject::runtime::type_identifier_for::<TypeObject>(
14847 xidl_typeobject::runtime::TypeEquivalence::Minimal,
14848 ),
14849 name: "type_object",
14850 },
14851 ],
14852 )
14853 }
14854
14855 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
14856 xidl_typeobject::runtime::build_complete_struct(
14857 "DDS::XTypes::TypeIdentifierTypeObjectPair",
14858 0u32,
14859 xidl_typeobject::runtime::type_identifier_none(),
14860 vec![
14861 xidl_typeobject::runtime::StructMemberDesc {
14862 member_id: 1u32,
14863 member_flags: 0u32,
14864 type_id: xidl_typeobject::runtime::type_identifier_for::<TypeIdentifier>(
14865 xidl_typeobject::runtime::TypeEquivalence::Complete,
14866 ),
14867 name: "type_identifier",
14868 },
14869 xidl_typeobject::runtime::StructMemberDesc {
14870 member_id: 2u32,
14871 member_flags: 0u32,
14872 type_id: xidl_typeobject::runtime::type_identifier_for::<TypeObject>(
14873 xidl_typeobject::runtime::TypeEquivalence::Complete,
14874 ),
14875 name: "type_object",
14876 },
14877 ],
14878 )
14879 }
14880 }
14881 pub type TypeIdentifierTypeObjectPairSeq = Vec<TypeIdentifierTypeObjectPair>;
14882 pub struct TypeIdentifierPair {
14883 pub type_identifier1: Box<TypeIdentifier>,
14884
14885 pub type_identifier2: Box<TypeIdentifier>,
14886 }
14887
14888 impl TypeIdentifierPair {
14889 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
14890 }
14891
14892 impl xidl_xcdr::XcdrSerialize for TypeIdentifierPair {
14893 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
14894 Self::SERIALIZE_KIND
14895 }
14896
14897 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
14898 &self,
14899 serializer: &mut S,
14900 ) -> xidl_xcdr::error::XcdrResult<()> {
14901 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
14902
14903 serializer.begin_field(xidl_xcdr::FieldId(1u32), false, 0)?;
14904
14905 xidl_xcdr::XcdrSerialize::serialize_with(&self.type_identifier1, serializer)?;
14906 serializer.end_field()?;
14907
14908 serializer.begin_field(xidl_xcdr::FieldId(2u32), false, 0)?;
14909
14910 xidl_xcdr::XcdrSerialize::serialize_with(&self.type_identifier2, serializer)?;
14911 serializer.end_field()?;
14912
14913 serializer.end_struct()?;
14914 Ok(())
14915 }
14916 }
14917
14918 impl xidl_xcdr::XcdrDeserialize for TypeIdentifierPair {
14919 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
14920 deserializer: &mut D,
14921 ) -> xidl_xcdr::error::XcdrResult<Self> {
14922 let type_identifier1 = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
14923
14924 let type_identifier2 = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
14925
14926 Ok(Self {
14927 type_identifier1,
14928
14929 type_identifier2,
14930 })
14931 }
14932 }
14933
14934 impl xidl_typeobject::XidlTypeObject for TypeIdentifierPair {
14935 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
14936 xidl_typeobject::runtime::build_minimal_struct(
14937 0u32,
14938 xidl_typeobject::runtime::type_identifier_none(),
14939 vec![
14940 xidl_typeobject::runtime::StructMemberDesc {
14941 member_id: 1u32,
14942 member_flags: 0u32,
14943 type_id: xidl_typeobject::runtime::type_identifier_for::<TypeIdentifier>(
14944 xidl_typeobject::runtime::TypeEquivalence::Minimal,
14945 ),
14946 name: "type_identifier1",
14947 },
14948 xidl_typeobject::runtime::StructMemberDesc {
14949 member_id: 2u32,
14950 member_flags: 0u32,
14951 type_id: xidl_typeobject::runtime::type_identifier_for::<TypeIdentifier>(
14952 xidl_typeobject::runtime::TypeEquivalence::Minimal,
14953 ),
14954 name: "type_identifier2",
14955 },
14956 ],
14957 )
14958 }
14959
14960 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
14961 xidl_typeobject::runtime::build_complete_struct(
14962 "DDS::XTypes::TypeIdentifierPair",
14963 0u32,
14964 xidl_typeobject::runtime::type_identifier_none(),
14965 vec![
14966 xidl_typeobject::runtime::StructMemberDesc {
14967 member_id: 1u32,
14968 member_flags: 0u32,
14969 type_id: xidl_typeobject::runtime::type_identifier_for::<TypeIdentifier>(
14970 xidl_typeobject::runtime::TypeEquivalence::Complete,
14971 ),
14972 name: "type_identifier1",
14973 },
14974 xidl_typeobject::runtime::StructMemberDesc {
14975 member_id: 2u32,
14976 member_flags: 0u32,
14977 type_id: xidl_typeobject::runtime::type_identifier_for::<TypeIdentifier>(
14978 xidl_typeobject::runtime::TypeEquivalence::Complete,
14979 ),
14980 name: "type_identifier2",
14981 },
14982 ],
14983 )
14984 }
14985 }
14986 pub type TypeIdentifierPairSeq = Vec<TypeIdentifierPair>;
14987 pub struct TypeIdentifierWithSize {
14988 pub type_id: Box<TypeIdentifier>,
14989
14990 pub typeobject_serialized_size: u32,
14991 }
14992
14993 impl TypeIdentifierWithSize {
14994 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
14995 }
14996
14997 impl xidl_xcdr::XcdrSerialize for TypeIdentifierWithSize {
14998 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
14999 Self::SERIALIZE_KIND
15000 }
15001
15002 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
15003 &self,
15004 serializer: &mut S,
15005 ) -> xidl_xcdr::error::XcdrResult<()> {
15006 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
15007
15008 serializer.begin_field(xidl_xcdr::FieldId(1u32), false, 0)?;
15009
15010 xidl_xcdr::XcdrSerialize::serialize_with(&self.type_id, serializer)?;
15011 serializer.end_field()?;
15012
15013 serializer.begin_field(xidl_xcdr::FieldId(2u32), false, 0)?;
15014
15015 xidl_xcdr::XcdrSerialize::serialize_with(
15016 &self.typeobject_serialized_size,
15017 serializer,
15018 )?;
15019 serializer.end_field()?;
15020
15021 serializer.end_struct()?;
15022 Ok(())
15023 }
15024 }
15025
15026 impl xidl_xcdr::XcdrDeserialize for TypeIdentifierWithSize {
15027 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
15028 deserializer: &mut D,
15029 ) -> xidl_xcdr::error::XcdrResult<Self> {
15030 let type_id = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
15031
15032 let typeobject_serialized_size =
15033 xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
15034
15035 Ok(Self {
15036 type_id,
15037
15038 typeobject_serialized_size,
15039 })
15040 }
15041 }
15042
15043 impl xidl_typeobject::XidlTypeObject for TypeIdentifierWithSize {
15044 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
15045 xidl_typeobject::runtime::build_minimal_struct(
15046 0u32,
15047 xidl_typeobject::runtime::type_identifier_none(),
15048 vec![
15049 xidl_typeobject::runtime::StructMemberDesc {
15050 member_id: 1u32,
15051 member_flags: 0u32,
15052 type_id: xidl_typeobject::runtime::type_identifier_for::<TypeIdentifier>(
15053 xidl_typeobject::runtime::TypeEquivalence::Minimal,
15054 ),
15055 name: "type_id",
15056 },
15057 xidl_typeobject::runtime::StructMemberDesc {
15058 member_id: 2u32,
15059 member_flags: 0u32,
15060 type_id: xidl_typeobject::runtime::type_identifier_primitive(
15061 xidl_typeobject::DDS::XTypes::TK_UINT32,
15062 ),
15063 name: "typeobject_serialized_size",
15064 },
15065 ],
15066 )
15067 }
15068
15069 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
15070 xidl_typeobject::runtime::build_complete_struct(
15071 "DDS::XTypes::TypeIdentifierWithSize",
15072 0u32,
15073 xidl_typeobject::runtime::type_identifier_none(),
15074 vec![
15075 xidl_typeobject::runtime::StructMemberDesc {
15076 member_id: 1u32,
15077 member_flags: 0u32,
15078 type_id: xidl_typeobject::runtime::type_identifier_for::<TypeIdentifier>(
15079 xidl_typeobject::runtime::TypeEquivalence::Complete,
15080 ),
15081 name: "type_id",
15082 },
15083 xidl_typeobject::runtime::StructMemberDesc {
15084 member_id: 2u32,
15085 member_flags: 0u32,
15086 type_id: xidl_typeobject::runtime::type_identifier_primitive(
15087 xidl_typeobject::DDS::XTypes::TK_UINT32,
15088 ),
15089 name: "typeobject_serialized_size",
15090 },
15091 ],
15092 )
15093 }
15094 }
15095 pub type TypeIdentifierWithSizeSeq = Vec<TypeIdentifierWithSize>;
15096 pub struct TypeIdentifierWithDependencies {
15097 pub typeid_with_size: Box<TypeIdentifierWithSize>,
15098
15099 pub dependent_typeid_count: i32,
15100
15101 pub dependent_typeids: Vec<TypeIdentifierWithSize>,
15102 }
15103
15104 impl TypeIdentifierWithDependencies {
15105 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
15106 }
15107
15108 impl xidl_xcdr::XcdrSerialize for TypeIdentifierWithDependencies {
15109 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
15110 Self::SERIALIZE_KIND
15111 }
15112
15113 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
15114 &self,
15115 serializer: &mut S,
15116 ) -> xidl_xcdr::error::XcdrResult<()> {
15117 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
15118
15119 serializer.begin_field(xidl_xcdr::FieldId(1u32), false, 0)?;
15120
15121 xidl_xcdr::XcdrSerialize::serialize_with(&self.typeid_with_size, serializer)?;
15122 serializer.end_field()?;
15123
15124 serializer.begin_field(xidl_xcdr::FieldId(2u32), false, 0)?;
15125
15126 xidl_xcdr::XcdrSerialize::serialize_with(&self.dependent_typeid_count, serializer)?;
15127 serializer.end_field()?;
15128
15129 serializer.begin_field(xidl_xcdr::FieldId(3u32), false, 0)?;
15130
15131 xidl_xcdr::XcdrSerialize::serialize_with(&self.dependent_typeids, serializer)?;
15132 serializer.end_field()?;
15133
15134 serializer.end_struct()?;
15135 Ok(())
15136 }
15137 }
15138
15139 impl xidl_xcdr::XcdrDeserialize for TypeIdentifierWithDependencies {
15140 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
15141 deserializer: &mut D,
15142 ) -> xidl_xcdr::error::XcdrResult<Self> {
15143 let typeid_with_size = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
15144
15145 let dependent_typeid_count = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
15146
15147 let dependent_typeids = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
15148
15149 Ok(Self {
15150 typeid_with_size,
15151
15152 dependent_typeid_count,
15153
15154 dependent_typeids,
15155 })
15156 }
15157 }
15158
15159 impl xidl_typeobject::XidlTypeObject for TypeIdentifierWithDependencies {
15160 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
15161 xidl_typeobject::runtime::build_minimal_struct(
15162 0u32,
15163 xidl_typeobject::runtime::type_identifier_none(),
15164 vec![
15165 xidl_typeobject::runtime::StructMemberDesc {
15166 member_id: 1u32,
15167 member_flags: 0u32,
15168 type_id: xidl_typeobject::runtime::type_identifier_for::<
15169 TypeIdentifierWithSize,
15170 >(
15171 xidl_typeobject::runtime::TypeEquivalence::Minimal
15172 ),
15173 name: "typeid_with_size",
15174 },
15175 xidl_typeobject::runtime::StructMemberDesc {
15176 member_id: 2u32,
15177 member_flags: 0u32,
15178 type_id: xidl_typeobject::runtime::type_identifier_primitive(
15179 xidl_typeobject::DDS::XTypes::TK_INT32,
15180 ),
15181 name: "dependent_typeid_count",
15182 },
15183 xidl_typeobject::runtime::StructMemberDesc {
15184 member_id: 3u32,
15185 member_flags: 0u32,
15186 type_id: xidl_typeobject::runtime::type_identifier_sequence(
15187 xidl_typeobject::runtime::type_identifier_for::<
15188 TypeIdentifierWithSize,
15189 >(
15190 xidl_typeobject::runtime::TypeEquivalence::Minimal
15191 ),
15192 0u32,
15193 xidl_typeobject::runtime::TypeEquivalence::Minimal,
15194 ),
15195 name: "dependent_typeids",
15196 },
15197 ],
15198 )
15199 }
15200
15201 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
15202 xidl_typeobject::runtime::build_complete_struct(
15203 "DDS::XTypes::TypeIdentifierWithDependencies",
15204 0u32,
15205 xidl_typeobject::runtime::type_identifier_none(),
15206 vec![
15207 xidl_typeobject::runtime::StructMemberDesc {
15208 member_id: 1u32,
15209 member_flags: 0u32,
15210 type_id: xidl_typeobject::runtime::type_identifier_for::<
15211 TypeIdentifierWithSize,
15212 >(
15213 xidl_typeobject::runtime::TypeEquivalence::Complete
15214 ),
15215 name: "typeid_with_size",
15216 },
15217 xidl_typeobject::runtime::StructMemberDesc {
15218 member_id: 2u32,
15219 member_flags: 0u32,
15220 type_id: xidl_typeobject::runtime::type_identifier_primitive(
15221 xidl_typeobject::DDS::XTypes::TK_INT32,
15222 ),
15223 name: "dependent_typeid_count",
15224 },
15225 xidl_typeobject::runtime::StructMemberDesc {
15226 member_id: 3u32,
15227 member_flags: 0u32,
15228 type_id: xidl_typeobject::runtime::type_identifier_sequence(
15229 xidl_typeobject::runtime::type_identifier_for::<
15230 TypeIdentifierWithSize,
15231 >(
15232 xidl_typeobject::runtime::TypeEquivalence::Complete
15233 ),
15234 0u32,
15235 xidl_typeobject::runtime::TypeEquivalence::Complete,
15236 ),
15237 name: "dependent_typeids",
15238 },
15239 ],
15240 )
15241 }
15242 }
15243 pub type TypeIdentifierWithDependenciesSeq = Vec<TypeIdentifierWithDependencies>;
15244 pub struct TypeInformation {
15245 pub minimal: Box<TypeIdentifierWithDependencies>,
15246
15247 pub complete: Box<TypeIdentifierWithDependencies>,
15248 }
15249
15250 impl TypeInformation {
15251 pub const SERIALIZE_KIND: xidl_xcdr::SerializeKind = xidl_xcdr::SerializeKind::Cdr;
15252 }
15253
15254 impl xidl_xcdr::XcdrSerialize for TypeInformation {
15255 fn serialize_kind(&self) -> xidl_xcdr::SerializeKind {
15256 Self::SERIALIZE_KIND
15257 }
15258
15259 fn serialize_with<S: xidl_xcdr::XcdrSerializer + ?Sized>(
15260 &self,
15261 serializer: &mut S,
15262 ) -> xidl_xcdr::error::XcdrResult<()> {
15263 serializer.begin_struct_with_kind(Self::SERIALIZE_KIND)?;
15264
15265 serializer.begin_field(xidl_xcdr::FieldId(1u32), false, 0)?;
15266
15267 xidl_xcdr::XcdrSerialize::serialize_with(&self.minimal, serializer)?;
15268 serializer.end_field()?;
15269
15270 serializer.begin_field(xidl_xcdr::FieldId(2u32), false, 0)?;
15271
15272 xidl_xcdr::XcdrSerialize::serialize_with(&self.complete, serializer)?;
15273 serializer.end_field()?;
15274
15275 serializer.end_struct()?;
15276 Ok(())
15277 }
15278 }
15279
15280 impl xidl_xcdr::XcdrDeserialize for TypeInformation {
15281 fn deserialize<D: xidl_xcdr::XcdrDeserializer + ?Sized>(
15282 deserializer: &mut D,
15283 ) -> xidl_xcdr::error::XcdrResult<Self> {
15284 let minimal = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
15285
15286 let complete = xidl_xcdr::XcdrDeserialize::deserialize(deserializer)?;
15287
15288 Ok(Self { minimal, complete })
15289 }
15290 }
15291
15292 impl xidl_typeobject::XidlTypeObject for TypeInformation {
15293 fn minimal_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
15294 xidl_typeobject::runtime::build_minimal_struct(
15295 0u32,
15296 xidl_typeobject::runtime::type_identifier_none(),
15297 vec![
15298 xidl_typeobject::runtime::StructMemberDesc {
15299 member_id: 1u32,
15300 member_flags: 0u32,
15301 type_id: xidl_typeobject::runtime::type_identifier_for::<
15302 TypeIdentifierWithDependencies,
15303 >(
15304 xidl_typeobject::runtime::TypeEquivalence::Minimal
15305 ),
15306 name: "minimal",
15307 },
15308 xidl_typeobject::runtime::StructMemberDesc {
15309 member_id: 2u32,
15310 member_flags: 0u32,
15311 type_id: xidl_typeobject::runtime::type_identifier_for::<
15312 TypeIdentifierWithDependencies,
15313 >(
15314 xidl_typeobject::runtime::TypeEquivalence::Minimal
15315 ),
15316 name: "complete",
15317 },
15318 ],
15319 )
15320 }
15321
15322 fn complete_type_object() -> xidl_typeobject::DDS::XTypes::TypeObject {
15323 xidl_typeobject::runtime::build_complete_struct(
15324 "DDS::XTypes::TypeInformation",
15325 0u32,
15326 xidl_typeobject::runtime::type_identifier_none(),
15327 vec![
15328 xidl_typeobject::runtime::StructMemberDesc {
15329 member_id: 1u32,
15330 member_flags: 0u32,
15331 type_id: xidl_typeobject::runtime::type_identifier_for::<
15332 TypeIdentifierWithDependencies,
15333 >(
15334 xidl_typeobject::runtime::TypeEquivalence::Complete
15335 ),
15336 name: "minimal",
15337 },
15338 xidl_typeobject::runtime::StructMemberDesc {
15339 member_id: 2u32,
15340 member_flags: 0u32,
15341 type_id: xidl_typeobject::runtime::type_identifier_for::<
15342 TypeIdentifierWithDependencies,
15343 >(
15344 xidl_typeobject::runtime::TypeEquivalence::Complete
15345 ),
15346 name: "complete",
15347 },
15348 ],
15349 )
15350 }
15351 }
15352 pub type TypeInformationSeq = Vec<TypeInformation>;
15353 }
15354}