Fast RTPS  Version 2.14.1
Fast RTPS
Loading...
Searching...
No Matches
dds-xtypes_typeobject.idl
1/* dds-xtypes_typeobject.idl */
2
3// The types in this file shall be serialized with XCDR encoding version 2
4module DDS {
5 module XTypes {
6
7 // ---------- Equivalence Kinds ------------------
8 typedef octet EquivalenceKind;
9 const octet EK_MINIMAL = 0xF1; // 0x1111 0001
10 const octet EK_COMPLETE = 0xF2; // 0x1111 0010
11 const octet EK_BOTH = 0xF3; // 0x1111 0011
12
13 // ---------- TypeKinds (begin) ------------------
14 typedef octet TypeKind; // Primitive TKs
15
16 const octet TK_NONE = 0x00;
17 const octet TK_BOOLEAN = 0x01;
18 const octet TK_BYTE = 0x02;
19 const octet TK_INT16 = 0x03;
20 const octet TK_INT32 = 0x04;
21 const octet TK_INT64 = 0x05;
22 const octet TK_UINT16 = 0x06;
23 const octet TK_UINT32 = 0x07;
24 const octet TK_UINT64 = 0x08;
25 const octet TK_FLOAT32 = 0x09;
26 const octet TK_FLOAT64 = 0x0A;
27 const octet TK_FLOAT128 = 0x0B;
28 const octet TK_CHAR8 = 0x10;
29 const octet TK_CHAR16 = 0x11;
30
31 // String TKs
32 const octet TK_STRING8 = 0x20;
33 const octet TK_STRING16 = 0x21;
34
35
36 // Constructed/Named types
37 const octet TK_ALIAS = 0x30;
38
39 // Enumerated TKs
40 const octet TK_ENUM = 0x40;
41 const octet TK_BITMASK = 0x41;
42
43 // Structured TKs
44 const octet TK_ANNOTATION = 0x50;
45 const octet TK_STRUCTURE = 0x51;
46 const octet TK_UNION = 0x52;
47 const octet TK_BITSET = 0x53;
48
49 // Collection TKs
50 const octet TK_SEQUENCE = 0x60;
51 const octet TK_ARRAY = 0x61;
52 const octet TK_MAP = 0x62;
53
54 // ---------- TypeKinds (end) ------------------
55
56 // ---------- Extra TypeIdentifiers (begin) -----------
57 typedef octet TypeIdentiferKind;
58 const octet TI_STRING8_SMALL = 0x70;
59 const octet TI_STRING8_LARGE = 0x71;
60 const octet TI_STRING16_SMALL = 0x72;
61 const octet TI_STRING16_LARGE = 0x73;
62
63 const octet TI_PLAIN_SEQUENCE_SMALL = 0x80;
64 const octet TI_PLAIN_SEQUENCE_LARGE = 0x81;
65 const octet TI_PLAIN_ARRAY_SMALL = 0x90;
66 const octet TI_PLAIN_ARRAY_LARGE = 0x91;
67 const octet TI_PLAIN_MAP_SMALL = 0xA0;
68 const octet TI_PLAIN_MAP_LARGE = 0xA1;
69
71
72 // ---------- Extra TypeIdentifiers (end) -------------
73
74 // The name of some element (e.g. type, type member, module)
75 // Valid characters are alphanumeric plus the "_" cannot start with digit
76
77 const long MEMBER_NAME_MAX_LENGTH = 256; typedef string<MEMBER_NAME_MAX_LENGTH> MemberName;
78
79 // Qualified type name includes the name of containing modules
80 // using "::" as separator. No leading "::". E.g. "MyModule::MyType"
81 const long TYPE_NAME_MAX_LENGTH = 256;
82 typedef string<TYPE_NAME_MAX_LENGTH> QualifiedTypeName;
83
84 // Every type has an ID. Those of the primitive types are pre-defined.
85 typedef octet PrimitiveTypeId;
86
87 // First 14 bytes of MD5 of the serialized TypeObject using XCDR
88 // version 2 with Little Endian encoding
89 typedef octet EquivalenceHash[14];
90
91 // First 4 bytes of MD5 of of a member name converted to bytes
92 // using UTF-8 encoding and without a 'nul' terminator.
93 // Example: the member name "color" has NameHash {0x70, 0xDD, 0xA5, 0xDF}
94
95 typedef octet NameHash[4];
96
97 // Long Bound of a collection type
98 typedef unsigned long LBound;
99 typedef sequence<LBound> LBoundSeq;
101
102 // Short Bound of a collection type
103 typedef octet SBound;
104 typedef sequence<SBound> SBoundSeq;
106
107 @extensibility(FINAL) @nested
108 union TypeObjectHashId switch (octet) {
109 case EK_COMPLETE:
110 case EK_MINIMAL:
111 EquivalenceHash hash;
112 };
113
114 // Flags that apply to struct/union/collection/enum/bitmask/bitset
115 // members/elements and DO affect type assignability
116 // Depending on the flag it may not apply to members of all types
117
118 // When not all, the applicable member types are listed
120 bitmask MemberFlag {
121 @position(0) TRY_CONSTRUCT1, // T1 | 00 = INVALID, 01 = DISCARD
122 @position(1) TRY_CONSTRUCT2, // T2 | 10 = USE_DEFAULT, 11 = TRIM
123 @position(2) IS_EXTERNAL, // X StructMember, UnionMember,
124 // CollectionElement
125 @position(3) IS_OPTIONAL, // O StructMember
126 @position(4) IS_MUST_UNDERSTAND, // M StructMember
127 @position(5) IS_KEY, // K StructMember, UnionDiscriminator
128 @position(6) IS_DEFAULT // D UnionMember, EnumerationLiteral
129 };
130
131 typedef MemberFlag CollectionElementFlag; // T1, T2, X
132 typedef MemberFlag StructMemberFlag; // T1, T2, O, M, K, X
133 typedef MemberFlag UnionMemberFlag; // T1, T2, D, X
134 typedef MemberFlag UnionDiscriminatorFlag; // T1, T2, K
135 typedef MemberFlag EnumeratedLiteralFlag; // D
136 typedef MemberFlag AnnotationParameterFlag; // Unused. No flags apply
137 typedef MemberFlag AliasMemberFlag; // Unused. No flags apply
138 typedef MemberFlag BitflagFlag; // Unused. No flags apply
139 typedef MemberFlag BitsetMemberFlag; // Unused. No flags apply
140
141 // Mask used to remove the flags that do no affect assignability
142 // Selects T1, T2, O, M, K, D
143 const unsigned short MemberFlagMinimalMask = 0x003f;
144
145 // Flags that apply to type declarationa and DO affect assignability
146 // Depending on the flag it may not apply to all types
147 // When not all, the applicable types are listed
148 @bit_bound(16) bitmask TypeFlag {
149 @position(0) IS_FINAL, // F |
150 @position(1) IS_APPENDABLE, // A |- Struct, Union
151 @position(2) IS_MUTABLE, // M | (exactly one flag)
152 @position(3) IS_NESTED, // N Struct, Union
153 @position(4) IS_AUTOID_HASH // H Struct
154 };
155
156 typedef TypeFlag StructTypeFlag; // All flags apply
157 typedef TypeFlag UnionTypeFlag; // All flags apply
158 typedef TypeFlag CollectionTypeFlag; // Unused. No flags apply
159 typedef TypeFlag AnnotationTypeFlag; // Unused. No flags apply
160 typedef TypeFlag AliasTypeFlag; // Unused. No flags apply
161 typedef TypeFlag EnumTypeFlag; // Unused. No flags apply
162 typedef TypeFlag BitmaskTypeFlag; // Unused. No flags apply
163 typedef TypeFlag BitsetTypeFlag; // Unused. No flags apply
164
165 // Mask used to remove the flags that do no affect assignability
166 const unsigned short TypeFlagMinimalMask = 0x0007; // Selects M, A, F
167
168 // Forward declaration
169 union TypeIdentifier;
170
171 // 1 Byte
172 @extensibility(FINAL) @nested
173 struct StringSTypeDefn {
174 SBound bound;
175 };
176
177 // 4 Bytes
178 @extensibility(FINAL) @nested
179 struct StringLTypeDefn {
180 LBound bound;
181 };
182
183 @extensibility(FINAL) @nested
184 struct PlainCollectionHeader {
185 EquivalenceKind equiv_kind;
186 CollectionElementFlag element_flags;
187 };
188
189 @extensibility(FINAL) @nested
190 struct PlainSequenceSElemDefn {
191 PlainCollectionHeader header;
192 SBound bound;
193 @external TypeIdentifier element_identifier;
194 };
195
196 @extensibility(FINAL) @nested
197 struct PlainSequenceLElemDefn {
198 PlainCollectionHeader header;
199 LBound bound;
200 @external TypeIdentifier element_identifier;
201 };
202
203 @extensibility(FINAL) @nested
204 struct PlainArraySElemDefn {
205 PlainCollectionHeader header;
206 SBoundSeq array_bound_seq;
207 @external TypeIdentifier element_identifier;
208 };
209
210 @extensibility(FINAL) @nested
211 struct PlainArrayLElemDefn {
212 PlainCollectionHeader header;
213 LBoundSeq array_bound_seq;
214 @external TypeIdentifier element_identifier;
215 };
216
217 @extensibility(FINAL) @nested
218 struct PlainMapSTypeDefn {
219 PlainCollectionHeader header;
220 SBound bound;
221 @external TypeIdentifier element_identifier;
222 CollectionElementFlag key_flags;
223 @external TypeIdentifier key_identifier;
224 };
225
226 @extensibility(FINAL) @nested
227 struct PlainMapLTypeDefn {
228 PlainCollectionHeader header;
229 LBound bound;
230 @external TypeIdentifier element_identifier;
231 CollectionElementFlag key_flags;
232 @external TypeIdentifier key_identifier;
233 };
234
235 // Used for Types that have cyclic depencencies with other types
236 @extensibility(APPENDABLE) @nested
237 struct StronglyConnectedComponentId {
238 TypeObjectHashId sc_component_id; // Hash StronglyConnectedComponent
239 long scc_length; // StronglyConnectedComponent.length
240 long scc_index ; // identify type in Strongly Connected Comp.
241 };
242
243 // Future extensibility
244 @extensibility(MUTABLE) @nested
245 struct ExtendedTypeDefn {
246 // Empty. Available for future extension
247 };
248
249
250 // The TypeIdentifier uniquely identifies a type (a set of equivalent
251 // types according to an equivalence relationship: COMPLETE, MNIMAL).
252 //
253 // In some cases (primitive types, strings, plain types) the identifier
254 // is a explicit description of the type.
255 // In other cases the Identifier is a Hash of the type description
256 //
257 // In the case of primitive types and strings the implied equivalence
258 // relation is the identity.
259 //
260 // For Plain Types and Hash-defined TypeIdentifiers there are three
261 // possibilities: MINIMAL, COMPLETE, and COMMON:
262 // - MINIMAL indicates the TypeIdentifier identifies equivalent types
263 // according to the MINIMAL equivalence relation
264 // - COMPLETE indicates the TypeIdentifier identifies equivalent types
265 // according to the COMPLETE equivalence relation
266 // - COMMON indicates the TypeIdentifier identifies equivalent types
267 // according to both the MINIMAL and the COMMON equivalence relation.
268 // This means the TypeIdentifier is the same for both relationships
269 //
270
271 @extensibility(FINAL) @nested
272 union TypeIdentifier switch (octet) {
273 // ============ Primitive types - use TypeKind ====================
274 // All primitive types fall here.
275 // Commented-out because Unions cannot have cases with no member.
276 /* case TK_NONE:
277 case TK_BOOLEAN:
278 case TK_BYTE_TYPE:
279 case TK_INT16_TYPE:
280 case TK_INT32_TYPE:
281 case TK_INT64_TYPE:
282 case TK_UINT16_TYPE:
283 case TK_UINT32_TYPE:
284 case TK_UINT64_TYPE:
285 case TK_FLOAT32_TYPE:
286 case TK_FLOAT64_TYPE:
287 case TK_FLOAT128_TYPE:
288 case TK_CHAR8_TYPE:
289 case TK_CHAR16_TYPE:
290 // No Value
291 */
292
293 // ============ Strings - use TypeIdentifierKind ===================
294 case TI_STRING8_SMALL:
295 case TI_STRING16_SMALL:
296 StringSTypeDefn string_sdefn;
297
298 case TI_STRING8_LARGE:
299 case TI_STRING16_LARGE:
300 StringLTypeDefn string_ldefn;
301
302 // ============ Plain collectios - use TypeIdentifierKind =========
303 case TI_PLAIN_SEQUENCE_SMALL:
304 PlainSequenceSElemDefn seq_sdefn;
305 case TI_PLAIN_SEQUENCE_LARGE:
306 PlainSequenceLElemDefn seq_ldefn;
307
308 case TI_PLAIN_ARRAY_SMALL:
309 PlainArraySElemDefn array_sdefn;
310 case TI_PLAIN_ARRAY_LARGE:
311 PlainArrayLElemDefn array_ldefn;
312
313 case TI_PLAIN_MAP_SMALL:
314 PlainMapSTypeDefn map_sdefn;
315 case TI_PLAIN_MAP_LARGE:
316 PlainMapLTypeDefn map_ldefn;
317
318 // ============ Types that are mutually dependent on each other ===
319 case TI_STRONGLY_CONNECTED_COMPONENT:
320 StronglyConnectedComponentId sc_component_id;
321
322 // ============ The remaining cases - use EquivalenceKind =========
323 case EK_COMPLETE:
324 case EK_MINIMAL:
325 EquivalenceHash equivalence_hash;
326
327 // =================== Future extensibility ============
328 // Future extensions
329 default: ExtendedTypeDefn extended_defn;
330 };
331 typedef sequence<TypeIdentifier> TypeIdentifierSeq;
332
333
334 // --- Annotation usage: ----------------------------------------------
335
336 // ID of a type member
337 typedef unsigned long MemberId;
338 const unsigned long ANNOTATION_STR_VALUE_MAX_LEN = 128;
339 const unsigned long ANNOTATION_OCTETSEC_VALUE_MAX_LEN = 128;
340
341 @extensibility(MUTABLE) @nested
342 struct ExtendedAnnotationParameterValue {
343 // Empty. Available for future extension
344 };
345
346 /* Literal value of an annotation member: either the default value in its
347 * definition or the value applied in its usage.
348 */
349
350 @extensibility(FINAL) @nested
351 union AnnotationParameterValue switch (octet) {
352 case TK_BOOLEAN:
353 boolean boolean_value;
354 case TK_BYTE:
355 octet byte_value;
356 case TK_INT16:
357 short int16_value;
358 case TK_UINT16:
359 unsigned short uint_16_value;
360 case TK_INT32:
361 long int32_value;
362 case TK_UINT32:
363 unsigned long uint32_value;
364 case TK_INT64:
365 long long int64_value;
366 case TK_UINT64:
367 unsigned long long uint64_value;
368 case TK_FLOAT32:
369 float float32_value;
370 case TK_FLOAT64:
371 double float64_value;
372 case TK_FLOAT128:
373 long double float128_value;
374 case TK_CHAR8:
375 char char_value;
376 case TK_CHAR16:
377 wchar wchar_value;
378 case TK_ENUM:
379 long enumerated_value;
380 case TK_STRING8:
381 string<ANNOTATION_STR_VALUE_MAX_LEN> string8_value;
382 case TK_STRING16:
383 wstring<ANNOTATION_STR_VALUE_MAX_LEN> string16_value;
384 default:
385 ExtendedAnnotationParameterValue extended_value;
386 };
387
388 // The application of an annotation to some type or type member
389 @extensibility(APPENDABLE) @nested
390 struct AppliedAnnotationParameter {
391 NameHash paramname_hash;
392 AnnotationParameterValue value;
393 };
394
395 // Sorted by AppliedAnnotationParameter.paramname_hash
396 typedef
397 sequence<AppliedAnnotationParameter> AppliedAnnotationParameterSeq;
398
399 @extensibility(APPENDABLE) @nested
400 struct AppliedAnnotation {
401 TypeIdentifier annotation_typeid;
402 @optional AppliedAnnotationParameterSeq param_seq;
403 };
404
405 // Sorted by AppliedAnnotation.annotation_typeid
406 typedef sequence<AppliedAnnotation> AppliedAnnotationSeq;
407
408 // @verbatim(placement="<placement>", language="<lang>", text="<text>")
409 @extensibility(FINAL) @nested
410 struct AppliedVerbatimAnnotation {
411 string<32> placement;
412 string<32> language;
413 string text;
414 };
415
416 // --- Aggregate types: -----------------------------------------------
417 @extensibility(APPENDABLE) @nested
418 struct AppliedBuiltinMemberAnnotations {
419 @optional string unit; // @unit("<unit>")
420 @optional AnnotationParameterValue min; // @min , @range
421 @optional AnnotationParameterValue max; // @max , @range
422 @optional string hash_id; // @hash_id("<membername>")
423 };
424
425 @extensibility(FINAL) @nested
426 struct CommonStructMember {
427 MemberId member_id;
428 StructMemberFlag member_flags;
429 TypeIdentifier member_type_id;
430 };
431
432 // COMPLETE Details for a member of an aggregate type
433 @extensibility(FINAL) @nested
434 struct CompleteMemberDetail {
435 MemberName name;
436 @optional AppliedBuiltinMemberAnnotations ann_builtin;
437 @optional AppliedAnnotationSeq ann_custom;
438 };
439
440 // MINIMAL Details for a member of an aggregate type
441 @extensibility(FINAL) @nested struct MinimalMemberDetail {
442 NameHash name_hash;
443 };
444
445 // Member of an aggregate type
446 @extensibility(APPENDABLE) @nested
447 struct CompleteStructMember {
448 CommonStructMember common;
449 CompleteMemberDetail detail;
450 };
451
452 // Ordered by the member_index
453 typedef sequence<CompleteStructMember> CompleteStructMemberSeq;
454
455 // Member of an aggregate type
456 @extensibility(APPENDABLE) @nested
457 struct MinimalStructMember {
458 CommonStructMember common;
459 MinimalMemberDetail detail;
460 };
461
462 // Ordered by common.member_id
463 typedef sequence<MinimalStructMember> MinimalStructMemberSeq;
464
465 @extensibility(APPENDABLE) @nested
466 struct AppliedBuiltinTypeAnnotations {
467 @optional AppliedVerbatimAnnotation verbatim; // @verbatim(...)
468 };
469
470 @extensibility(FINAL) @nested
471 struct MinimalTypeDetail {
472 // Empty. Available for future extension
473 };
474
475 @extensibility(FINAL) @nested
476 struct CompleteTypeDetail {
477 @optional AppliedBuiltinTypeAnnotations ann_builtin;
478 @optional AppliedAnnotationSeq ann_custom;
479 QualifiedTypeName type_name;
480 };
481
482 @extensibility(APPENDABLE) @nested
483 struct CompleteStructHeader {
484 TypeIdentifier base_type;
485 CompleteTypeDetail detail;
486 };
487
488 @extensibility(APPENDABLE) @nested
489 struct MinimalStructHeader {
490 TypeIdentifier base_type;
491 MinimalTypeDetail detail;
492 };
493
494 @extensibility(FINAL) @nested
495 struct CompleteStructType {
496 StructTypeFlag struct_flags;
497 CompleteStructHeader header;
498 CompleteStructMemberSeq member_seq;
499 };
500
501 @extensibility(FINAL) @nested
502 struct MinimalStructType {
503 StructTypeFlag struct_flags;
504 MinimalStructHeader header;
505 MinimalStructMemberSeq member_seq;
506 };
507
508 // --- Union: ---------------------------------------------------------
509
510 // Case labels that apply to a member of a union type
511 // Ordered by their values
512 typedef sequence<long> UnionCaseLabelSeq;
513
514 @extensibility(FINAL) @nested
515 struct CommonUnionMember {
516 MemberId member_id;
517 UnionMemberFlag member_flags;
518 TypeIdentifier type_id;
519 UnionCaseLabelSeq label_seq;
520 };
521
522 // Member of a union type
523 @extensibility(APPENDABLE) @nested
524 struct CompleteUnionMember {
525 CommonUnionMember common;
526 CompleteMemberDetail detail;
527 };
528
529 // Ordered by member_index
530 typedef sequence<CompleteUnionMember> CompleteUnionMemberSeq;
531
532 // Member of a union type
533 @extensibility(APPENDABLE) @nested
534 struct MinimalUnionMember {
535 CommonUnionMember common;
536 MinimalMemberDetail detail;
537 };
538
539 // Ordered by MinimalUnionMember.common.member_id
540 typedef sequence<MinimalUnionMember> MinimalUnionMemberSeq;
541
542 @extensibility(FINAL) @nested
543 struct CommonDiscriminatorMember {
544 UnionDiscriminatorFlag member_flags;
545 TypeIdentifier type_id;
546 };
547
548 // Member of a union type
549 @extensibility(APPENDABLE) @nested
550 struct CompleteDiscriminatorMember {
551 CommonDiscriminatorMember common;
552 @optional AppliedBuiltinTypeAnnotations ann_builtin;
553 @optional AppliedAnnotationSeq ann_custom;
554 };
555
556 // Member of a union type
557 @extensibility(APPENDABLE) @nested
558 struct MinimalDiscriminatorMember {
559 CommonDiscriminatorMember common;
560 };
561
562 @extensibility(APPENDABLE) @nested
563 struct CompleteUnionHeader {
564 CompleteTypeDetail detail;
565 };
566
567 @extensibility(APPENDABLE) @nested
568 struct MinimalUnionHeader {
569 MinimalTypeDetail detail;
570 };
571
572 @extensibility(FINAL) @nested
573 struct CompleteUnionType {
574 UnionTypeFlag union_flags;
575 CompleteUnionHeader header;
576 CompleteDiscriminatorMember discriminator;
577 CompleteUnionMemberSeq member_seq;
578 };
579
580 @extensibility(FINAL) @nested
581 struct MinimalUnionType {
582 UnionTypeFlag union_flags;
583 MinimalUnionHeader header;
584 MinimalDiscriminatorMember discriminator;
585 MinimalUnionMemberSeq member_seq;
586 };
587
588 // --- Annotation: ---------------------------------------------------
589 @extensibility(FINAL) @nested
590 struct CommonAnnotationParameter {
591 AnnotationParameterFlag member_flags;
592 TypeIdentifier member_type_id;
593 };
594
595 // Member of an annotation type
596 @extensibility(APPENDABLE) @nested
597 struct CompleteAnnotationParameter {
598 CommonAnnotationParameter common;
599 MemberName name;
600 AnnotationParameterValue default_value;
601 };
602
603 // Ordered by CompleteAnnotationParameter.name
604 typedef sequence<CompleteAnnotationParameter> CompleteAnnotationParameterSeq;
605
606 @extensibility(APPENDABLE) @nested
607 struct MinimalAnnotationParameter {
608 CommonAnnotationParameter common;
609 NameHash name_hash;
610 AnnotationParameterValue default_value;
611 };
612
613 // Ordered by MinimalAnnotationParameter.name_hash
614 typedef sequence<MinimalAnnotationParameter> MinimalAnnotationParameterSeq;
615
616 @extensibility(APPENDABLE) @nested
617 struct CompleteAnnotationHeader {
618 QualifiedTypeName annotation_name;
619 };
620
621 @extensibility(APPENDABLE) @nested
622 struct MinimalAnnotationHeader {
623 // Empty. Available for future extension
624 };
625
626 @extensibility(FINAL) @nested
627 struct CompleteAnnotationType {
628 AnnotationTypeFlag annotation_flag;
629 CompleteAnnotationHeader header;
630 CompleteAnnotationParameterSeq member_seq;
631 };
632
633 @extensibility(FINAL) @nested
634 struct MinimalAnnotationType {
635 AnnotationTypeFlag annotation_flag;
636 MinimalAnnotationHeader header;
638 };
639
640 // --- Alias: ---------------------------------------------------------
641 @extensibility(FINAL) @nested
642 struct CommonAliasBody {
643 AliasMemberFlag related_flags;
644 TypeIdentifier related_type;
645 };
646
647 @extensibility(APPENDABLE) @nested
648 struct CompleteAliasBody {
649 CommonAliasBody common;
650 @optional AppliedBuiltinMemberAnnotations ann_builtin;
651 @optional AppliedAnnotationSeq ann_custom;
652 };
653
654 @extensibility(APPENDABLE) @nested
655 struct MinimalAliasBody {
656 CommonAliasBody common;
657 };
658
659 @extensibility(APPENDABLE) @nested
660 struct CompleteAliasHeader {
661 CompleteTypeDetail detail;
662 };
663
664 @extensibility(APPENDABLE) @nested
665 struct MinimalAliasHeader {
666 // Empty. Available for future extension
667 };
668
669 @extensibility(FINAL) @nested
670 struct CompleteAliasType {
671 AliasTypeFlag alias_flags;
672 CompleteAliasHeader header;
673 CompleteAliasBody body;
674 };
675
676 @extensibility(FINAL) @nested
677 struct MinimalAliasType {
678 AliasTypeFlag alias_flags;
679 MinimalAliasHeader header;
680 MinimalAliasBody body;
681 };
682
683 // --- Collections: ---------------------------------------------------
684 @extensibility(FINAL) @nested
685 struct CompleteElementDetail {
686 @optional AppliedBuiltinMemberAnnotations ann_builtin;
687 @optional AppliedAnnotationSeq ann_custom;
688 };
689
690 @extensibility(FINAL) @nested
691 struct CommonCollectionElement {
692 CollectionElementFlag element_flags;
693 TypeIdentifier type;
694 };
695
696 @extensibility(APPENDABLE) @nested
697 struct CompleteCollectionElement {
698 CommonCollectionElement common;
699 CompleteElementDetail detail;
700 };
701
702 @extensibility(APPENDABLE) @nested
703 struct MinimalCollectionElement {
704 CommonCollectionElement common;
705 };
706
707 @extensibility(FINAL) @nested
708 struct CommonCollectionHeader {
709 LBound bound;
710 };
711
712 @extensibility(APPENDABLE) @nested
713 struct CompleteCollectionHeader {
714 CommonCollectionHeader common;
715 @optional CompleteTypeDetail detail; // not present for anonymous
716 };
717
718 @extensibility(APPENDABLE) @nested
719 struct MinimalCollectionHeader {
720 CommonCollectionHeader common;
721 };
722
723 // --- Sequence: -----------------------------------------------------
724 @extensibility(FINAL) @nested
725 struct CompleteSequenceType {
726 CollectionTypeFlag collection_flag;
727 CompleteCollectionHeader header;
728 CompleteCollectionElement element;
729 };
730
731
732 @extensibility(FINAL) @nested
733 struct MinimalSequenceType {
734 CollectionTypeFlag collection_flag;
735 MinimalCollectionHeader header;
736 MinimalCollectionElement element;
737 };
738
739 // --- Array: -----------------------------------------------------
740 @extensibility(FINAL) @nested
741 struct CommonArrayHeader {
742 LBoundSeq bound_seq;
743 };
744
745 @extensibility(APPENDABLE) @nested
746 struct CompleteArrayHeader {
747 CommonArrayHeader common;
748 CompleteTypeDetail detail;
749 };
750
751 @extensibility(APPENDABLE) @nested
752 struct MinimalArrayHeader {
753 CommonArrayHeader common;
754 };
755
756 @extensibility(APPENDABLE) @nested
757 struct CompleteArrayType {
758 CollectionTypeFlag collection_flag;
759 CompleteArrayHeader header;
760 CompleteCollectionElement element;
761 };
762
763 @extensibility(FINAL) @nested
764 struct MinimalArrayType {
765 CollectionTypeFlag collection_flag;
766 MinimalArrayHeader header;
767 MinimalCollectionElement element;
768 };
769
770 // --- Map: -----------------------------------------------------
771 @extensibility(FINAL) @nested
772 struct CompleteMapType {
773 CollectionTypeFlag collection_flag;
774 CompleteCollectionHeader header;
775 CompleteCollectionElement key;
776 CompleteCollectionElement element;
777 };
778
779 @extensibility(FINAL) @nested
780 struct MinimalMapType {
781 CollectionTypeFlag collection_flag;
782 MinimalCollectionHeader header;
783 MinimalCollectionElement key;
784 MinimalCollectionElement element;
785 };
786
787 // --- Enumeration: ---------------------------------------------------
788 typedef unsigned short BitBound;
789
790 // Constant in an enumerated type
791 @extensibility(APPENDABLE) @nested
792 struct CommonEnumeratedLiteral {
793 long value;
795 };
796
797 // Constant in an enumerated type
798 @extensibility(APPENDABLE) @nested
799 struct CompleteEnumeratedLiteral {
800 CommonEnumeratedLiteral common;
801 CompleteMemberDetail detail;
802 };
803
804 // Ordered by EnumeratedLiteral.common.value
805 typedef sequence<CompleteEnumeratedLiteral> CompleteEnumeratedLiteralSeq;
806
807 // Constant in an enumerated type
808 @extensibility(APPENDABLE) @nested
809 struct MinimalEnumeratedLiteral {
810 CommonEnumeratedLiteral common;
811 MinimalMemberDetail detail;
812 };
813
814 // Ordered by EnumeratedLiteral.common.value
815 typedef sequence<MinimalEnumeratedLiteral> MinimalEnumeratedLiteralSeq;
816
817 @extensibility(FINAL) @nested
818 struct CommonEnumeratedHeader {
820 };
821
822 @extensibility(APPENDABLE) @nested
823 struct CompleteEnumeratedHeader {
824 CommonEnumeratedHeader common;
825 CompleteTypeDetail detail;
826 };
827
828 @extensibility(APPENDABLE) @nested
829 struct MinimalEnumeratedHeader {
830 CommonEnumeratedHeader common;
831 };
832
833 // Enumerated type
834 @extensibility(FINAL) @nested
835 struct CompleteEnumeratedType {
836 EnumTypeFlag enum_flags; // unused
837 CompleteEnumeratedHeader header;
839 };
840
841 // Enumerated type
842 @extensibility(FINAL) @nested
843 struct MinimalEnumeratedType {
844 EnumTypeFlag enum_flags; // unused
845 MinimalEnumeratedHeader header;
846 MinimalEnumeratedLiteralSeq literal_seq;
847 };
848
849 // --- Bitmask: -------------------------------------------------------
850 // Bit in a bit mask
851 @extensibility(FINAL) @nested
852 struct CommonBitflag {
853 unsigned short position;
854 BitflagFlag flags;
855 };
856
857 @extensibility(APPENDABLE) @nested
858 struct CompleteBitflag {
859 CommonBitflag common;
860 CompleteMemberDetail detail;
861 };
862
863 // Ordered by Bitflag.position
864 typedef sequence<CompleteBitflag> CompleteBitflagSeq;
865
866 @extensibility(APPENDABLE) @nested
867 struct MinimalBitflag {
868 CommonBitflag common;
869 MinimalMemberDetail detail;
870 };
871
872 // Ordered by Bitflag.position
873 typedef sequence<MinimalBitflag> MinimalBitflagSeq;
874
875 @extensibility(FINAL) @nested
876 struct CommonBitmaskHeader {
878 };
879
880 typedef CompleteEnumeratedHeader CompleteBitmaskHeader;
881
882 typedef MinimalEnumeratedHeader MinimalBitmaskHeader;
883
884 @extensibility(APPENDABLE) @nested
885 struct CompleteBitmaskType {
886 BitmaskTypeFlag bitmask_flags; // unused
888 CompleteBitflagSeq flag_seq;
889 };
890
891 @extensibility(APPENDABLE) @nested
892 struct MinimalBitmaskType {
893 BitmaskTypeFlag bitmask_flags; // unused
894 MinimalBitmaskHeader header;
895 MinimalBitflagSeq flag_seq;
896 };
897
898 // --- Bitset: ---------------------------------------------------------
899 @extensibility(FINAL) @nested
900 struct CommonBitfield {
901 unsigned short position;
902 BitsetMemberFlag flags;
903 octet bitcount;
904 TypeKind holder_type; // Must be primitive integer type
905 };
906
907 @extensibility(APPENDABLE) @nested
908 struct CompleteBitfield {
909 CommonBitfield common;
910 CompleteMemberDetail detail;
911 };
912
913 // Ordered by Bitfield.position
914 typedef sequence<CompleteBitfield> CompleteBitfieldSeq;
915
916 @extensibility(APPENDABLE) @nested
917 struct MinimalBitfield {
918 CommonBitfield common;
919 NameHash name_hash;
920 };
921
922 // Ordered by Bitfield.position
923 typedef sequence<MinimalBitfield> MinimalBitfieldSeq;
924
925 @extensibility(APPENDABLE) @nested
926 struct CompleteBitsetHeader {
927 CompleteTypeDetail detail;
928 };
929
930 @extensibility(APPENDABLE) @nested
931 struct MinimalBitsetHeader {
932 // Empty. Available for future extension
933 };
934
935 @extensibility(APPENDABLE) @nested
936 struct CompleteBitsetType {
937 BitsetTypeFlag bitset_flags; // unused
938 CompleteBitsetHeader header;
939 CompleteBitfieldSeq field_seq;
940 };
941
942 @extensibility(APPENDABLE) @nested
943 struct MinimalBitsetType {
944 BitsetTypeFlag bitset_flags; // unused
945 MinimalBitsetHeader header;
946 MinimalBitfieldSeq field_seq;
947 };
948
949 // --- Type Object: --------------------------------------------------
950 // The types associated with each case selection must have extensibility
951 // kind APPENDABLE or MUTABLE so that they can be extended in the future
952
953 @extensibility(MUTABLE) @nested
954 struct CompleteExtendedType {
955 // Empty. Available for future extension
956 };
957
958 @extensibility(FINAL) @nested
959 union CompleteTypeObject switch (octet) {
960 case TK_ALIAS:
961 CompleteAliasType alias_type;
962 case TK_ANNOTATION:
963 CompleteAnnotationType annotation_type;
964 case TK_STRUCTURE:
965 CompleteStructType struct_type;
966 case TK_UNION:
967 CompleteUnionType union_type;
968 case TK_BITSET:
969 CompleteBitsetType bitset_type;
970 case TK_SEQUENCE:
971 CompleteSequenceType sequence_type;
972 case TK_ARRAY:
973 CompleteArrayType array_type;
974 case TK_MAP:
975 CompleteMapType map_type;
976 case TK_ENUM:
977 CompleteEnumeratedType enumerated_type;
978 case TK_BITMASK:
979 CompleteBitmaskType bitmask_type;
980
981 // =================== Future extensibility ============
982 default:
983 CompleteExtendedType extended_type;
984 };
985
986 @extensibility(MUTABLE) @nested
987 struct MinimalExtendedType {
988 // Empty. Available for future extension
989 };
990
991
992 @extensibility(FINAL) @nested
993 union MinimalTypeObject switch (octet) {
994 case TK_ALIAS:
995 MinimalAliasType alias_type;
996 case TK_ANNOTATION:
997 MinimalAnnotationType annotation_type;
998 case TK_STRUCTURE:
999 MinimalStructType struct_type;
1000 case TK_UNION:
1001 MinimalUnionType union_type;
1002 case TK_BITSET:
1003 MinimalBitsetType bitset_type;
1004 case TK_SEQUENCE:
1005 MinimalSequenceType sequence_type;
1006 case TK_ARRAY:
1007 MinimalArrayType array_type;
1008 case TK_MAP:
1009 MinimalMapType map_type;
1010 case TK_ENUM:
1011 MinimalEnumeratedType enumerated_type;
1012 case TK_BITMASK:
1013 MinimalBitmaskType bitmask_type;
1014
1015 // =================== Future extensibility ============
1016 default:
1017 MinimalExtendedType extended_type;
1018 };
1019
1020 @extensibility(APPENDABLE) @nested
1021 union TypeObject switch (octet) { // EquivalenceKind
1022 case EK_COMPLETE:
1023 CompleteTypeObject complete;
1024 case EK_MINIMAL:
1025 MinimalTypeObject minimal;
1026 };
1027 typedef sequence<TypeObject> TypeObjectSeq;
1028
1029 // Set of TypeObjects representing a strong component: Equivalence class
1030 // for the Strong Connectivity relationship (mutual reachability between
1031 // types).
1032 // Ordered by fully qualified typename lexicographic order
1034
1035 @extensibility(FINAL) @nested
1036 struct TypeIdentifierTypeObjectPair {
1037 TypeIdentifier type_identifier;
1038 TypeObject type_object;
1039 };
1040 typedef
1041 sequence<TypeIdentifierTypeObjectPair> TypeIdentifierTypeObjectPairSeq;
1042
1043 @extensibility(FINAL) @nested
1044 struct TypeIdentifierPair {
1045 TypeIdentifier type_identifier1;
1046 TypeIdentifier type_identifier2;
1047 };
1048 typedef sequence<TypeIdentifierPair> TypeIdentifierPairSeq;
1049
1050 @extensibility(APPENDABLE) @nested
1051 struct TypeIdentifierWithSize {
1052 DDS::Xtypes::TypeIdentifier type_id;
1053 unsigned long typeobject_serialized_size;
1054 };
1055 typedef sequence<TypeIdentifierWithSize> TypeIdentfierWithSizeSeq;
1056
1057 @extensibility(APPENDABLE) @nested
1058 struct TypeIdentifierWithDependencies {
1059 TypeIdentifierWithSize typeid_with_size;
1060 // The total additional types related to minimal_type
1061 long dependent_typeid_count;
1062 sequence<TypeIdentifierWithSize> dependent_typeids;
1063 };
1064 typedef sequence<TypeIdentifierWithDependencies> TypeIdentifierWithDependenciesSeq;
1065
1066 // This appears in the builtin DDS topics PublicationBuiltinTopicData
1067 // and SubscriptionBuiltinTopicData
1068
1069 @extensibility(MUTABLE) @nested
1070 struct TypeInformation {
1071 @id(0x1001) TypeIdentifierWithDependencies minimal;
1072 @id(0x1002) TypeIdentifierWithDependencies complete;
1073 };
1074 typedef sequence<TypeInformation> TypeInformationSeq;
1075
1076 }; // end of module XTypes
1077}; // end module DDS
const octet TK_FLOAT32
Definition dds-xtypes_typeobject.idl:25
MemberFlag BitsetMemberFlag
Definition dds-xtypes_typeobject.idl:139
sequence< MinimalAnnotationParameter > MinimalAnnotationParameterSeq
Definition dds-xtypes_typeobject.idl:614
TypeFlag BitsetTypeFlag
Definition dds-xtypes_typeobject.idl:163
const octet TI_STRONGLY_CONNECTED_COMPONENT
Definition dds-xtypes_typeobject.idl:70
const octet TK_BYTE
Definition dds-xtypes_typeobject.idl:18
TypeFlag StructTypeFlag
Definition dds-xtypes_typeobject.idl:156
const octet TK_UINT64
Definition dds-xtypes_typeobject.idl:24
octet PrimitiveTypeId
Definition dds-xtypes_typeobject.idl:85
const long TYPE_NAME_MAX_LENGTH
Definition dds-xtypes_typeobject.idl:81
sequence< long > UnionCaseLabelSeq
Definition dds-xtypes_typeobject.idl:512
const octet TK_BITSET
Definition dds-xtypes_typeobject.idl:47
sequence< MinimalBitflag > MinimalBitflagSeq
Definition dds-xtypes_typeobject.idl:873
string< MEMBER_NAME_MAX_LENGTH > MemberName
Definition dds-xtypes_typeobject.idl:77
TypeObjectSeq StronglyConnectedComponent
Definition dds-xtypes_typeobject.idl:1033
octet EquivalenceKind
Definition dds-xtypes_typeobject.idl:8
sequence< TypeIdentifierPair > TypeIdentifierPairSeq
Definition dds-xtypes_typeobject.idl:1048
const octet TK_UNION
Definition dds-xtypes_typeobject.idl:46
sequence< MinimalEnumeratedLiteral > MinimalEnumeratedLiteralSeq
Definition dds-xtypes_typeobject.idl:815
TypeFlag AliasTypeFlag
Definition dds-xtypes_typeobject.idl:160
unsigned short BitBound
Definition dds-xtypes_typeobject.idl:788
MinimalEnumeratedHeader MinimalBitmaskHeader
Definition dds-xtypes_typeobject.idl:882
const octet TK_FLOAT64
Definition dds-xtypes_typeobject.idl:26
MemberFlag BitflagFlag
Definition dds-xtypes_typeobject.idl:138
sequence< TypeIdentifier > TypeIdentifierSeq
Definition dds-xtypes_typeobject.idl:331
MemberFlag StructMemberFlag
Definition dds-xtypes_typeobject.idl:132
const octet TK_STRING16
Definition dds-xtypes_typeobject.idl:33
sequence< AppliedAnnotation > AppliedAnnotationSeq
Definition dds-xtypes_typeobject.idl:406
octet SBound
Definition dds-xtypes_typeobject.idl:103
sequence< CompleteAnnotationParameter > CompleteAnnotationParameterSeq
Definition dds-xtypes_typeobject.idl:604
const unsigned short MemberFlagMinimalMask
Definition dds-xtypes_typeobject.idl:143
TypeFlag CollectionTypeFlag
Definition dds-xtypes_typeobject.idl:158
sequence< MinimalUnionMember > MinimalUnionMemberSeq
Definition dds-xtypes_typeobject.idl:540
octet TypeIdentiferKind
Definition dds-xtypes_typeobject.idl:57
sequence< TypeInformation > TypeInformationSeq
Definition dds-xtypes_typeobject.idl:1074
const octet TK_INT32
Definition dds-xtypes_typeobject.idl:20
const octet TI_PLAIN_SEQUENCE_SMALL
Definition dds-xtypes_typeobject.idl:63
const octet TK_ANNOTATION
Definition dds-xtypes_typeobject.idl:44
const long MEMBER_NAME_MAX_LENGTH
Definition dds-xtypes_typeobject.idl:77
MemberFlag EnumeratedLiteralFlag
Definition dds-xtypes_typeobject.idl:135
unsigned long MemberId
Definition dds-xtypes_typeobject.idl:337
const octet TK_MAP
Definition dds-xtypes_typeobject.idl:52
const octet EK_COMPLETE
Definition dds-xtypes_typeobject.idl:10
string< TYPE_NAME_MAX_LENGTH > QualifiedTypeName
Definition dds-xtypes_typeobject.idl:82
const unsigned short TypeFlagMinimalMask
Definition dds-xtypes_typeobject.idl:166
sequence< TypeIdentifierWithSize > TypeIdentfierWithSizeSeq
Definition dds-xtypes_typeobject.idl:1055
const octet TI_STRING8_SMALL
Definition dds-xtypes_typeobject.idl:58
const octet TK_UINT16
Definition dds-xtypes_typeobject.idl:22
CompleteEnumeratedHeader CompleteBitmaskHeader
Definition dds-xtypes_typeobject.idl:880
sequence< TypeIdentifierWithDependencies > TypeIdentifierWithDependenciesSeq
Definition dds-xtypes_typeobject.idl:1064
sequence< SBound > SBoundSeq
Definition dds-xtypes_typeobject.idl:104
octet NameHash[4]
Definition dds-xtypes_typeobject.idl:95
octet EquivalenceHash[14]
Definition dds-xtypes_typeobject.idl:89
const octet TI_STRING16_LARGE
Definition dds-xtypes_typeobject.idl:61
const octet TK_CHAR8
Definition dds-xtypes_typeobject.idl:28
TypeFlag AnnotationTypeFlag
Definition dds-xtypes_typeobject.idl:159
sequence< CompleteUnionMember > CompleteUnionMemberSeq
Definition dds-xtypes_typeobject.idl:530
TypeFlag UnionTypeFlag
Definition dds-xtypes_typeobject.idl:157
const octet EK_BOTH
Definition dds-xtypes_typeobject.idl:11
TypeFlag EnumTypeFlag
Definition dds-xtypes_typeobject.idl:161
const octet TK_CHAR16
Definition dds-xtypes_typeobject.idl:29
const octet TI_STRING16_SMALL
Definition dds-xtypes_typeobject.idl:60
const octet EK_MINIMAL
Definition dds-xtypes_typeobject.idl:9
sequence< LBound > LBoundSeq
Definition dds-xtypes_typeobject.idl:99
sequence< MinimalStructMember > MinimalStructMemberSeq
Definition dds-xtypes_typeobject.idl:463
const octet TK_ALIAS
Definition dds-xtypes_typeobject.idl:37
const octet TK_INT16
Definition dds-xtypes_typeobject.idl:19
MemberFlag UnionMemberFlag
Definition dds-xtypes_typeobject.idl:133
const octet TK_BOOLEAN
Definition dds-xtypes_typeobject.idl:17
const octet TK_FLOAT128
Definition dds-xtypes_typeobject.idl:27
const octet TI_PLAIN_ARRAY_LARGE
Definition dds-xtypes_typeobject.idl:66
sequence< AppliedAnnotationParameter > AppliedAnnotationParameterSeq
Definition dds-xtypes_typeobject.idl:397
const octet TI_PLAIN_ARRAY_SMALL
Definition dds-xtypes_typeobject.idl:65
sequence< CompleteBitfield > CompleteBitfieldSeq
Definition dds-xtypes_typeobject.idl:914
const octet TI_PLAIN_MAP_LARGE
Definition dds-xtypes_typeobject.idl:68
const octet TK_BITMASK
Definition dds-xtypes_typeobject.idl:41
const LBound INVALID_LBOUND
Definition dds-xtypes_typeobject.idl:100
const SBound INVALID_SBOUND
Definition dds-xtypes_typeobject.idl:105
TypeFlag BitmaskTypeFlag
Definition dds-xtypes_typeobject.idl:162
const unsigned long ANNOTATION_STR_VALUE_MAX_LEN
Definition dds-xtypes_typeobject.idl:338
const octet TI_PLAIN_MAP_SMALL
Definition dds-xtypes_typeobject.idl:67
const octet TK_ENUM
Definition dds-xtypes_typeobject.idl:40
const unsigned long ANNOTATION_OCTETSEC_VALUE_MAX_LEN
Definition dds-xtypes_typeobject.idl:339
const octet TI_PLAIN_SEQUENCE_LARGE
Definition dds-xtypes_typeobject.idl:64
sequence< CompleteStructMember > CompleteStructMemberSeq
Definition dds-xtypes_typeobject.idl:453
sequence< MinimalBitfield > MinimalBitfieldSeq
Definition dds-xtypes_typeobject.idl:923
const octet TK_STRUCTURE
Definition dds-xtypes_typeobject.idl:45
const octet TK_ARRAY
Definition dds-xtypes_typeobject.idl:51
const octet TK_SEQUENCE
Definition dds-xtypes_typeobject.idl:50
MemberFlag AliasMemberFlag
Definition dds-xtypes_typeobject.idl:137
MemberFlag AnnotationParameterFlag
Definition dds-xtypes_typeobject.idl:136
const octet TI_STRING8_LARGE
Definition dds-xtypes_typeobject.idl:59
MemberFlag UnionDiscriminatorFlag
Definition dds-xtypes_typeobject.idl:134
const octet TK_INT64
Definition dds-xtypes_typeobject.idl:21
const octet TK_NONE
Definition dds-xtypes_typeobject.idl:16
sequence< CompleteEnumeratedLiteral > CompleteEnumeratedLiteralSeq
Definition dds-xtypes_typeobject.idl:805
sequence< TypeIdentifierTypeObjectPair > TypeIdentifierTypeObjectPairSeq
Definition dds-xtypes_typeobject.idl:1041
const octet TK_STRING8
Definition dds-xtypes_typeobject.idl:32
const octet TK_UINT32
Definition dds-xtypes_typeobject.idl:23
octet TypeKind
Definition dds-xtypes_typeobject.idl:14
sequence< CompleteBitflag > CompleteBitflagSeq
Definition dds-xtypes_typeobject.idl:864
MemberFlag CollectionElementFlag
Definition dds-xtypes_typeobject.idl:131
unsigned long LBound
Definition dds-xtypes_typeobject.idl:98
sequence< TypeObject > TypeObjectSeq
Definition dds-xtypes_typeobject.idl:1027
Definition dds-builtin_types.idl:1
bit_bound(16) enum TypeConsistencyKind
Definition dds-xtypes_discovery.idl:183
std::vector< AppliedAnnotation > AppliedAnnotationSeq
Definition AnnotationParameterValue.h:1150
Definition BuiltinAnnotationsTypeObject.h:73
Definition BuiltinAnnotationsTypeObject.h:156