| Fast DDS Version 3.3.0 Fast DDS

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