Fast RTPS  Version 2.8.0
Fast RTPS
dds-xtypes_typeobject.idl
1 /* dds-xtypes_typeobject.idl */
2 
3 // The types in this file shall be serialized with XCDR encoding version 2
4 module 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 
70  const octet TI_STRONGLY_CONNECTED_COMPONENT = 0xB0;
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;
794  EnumeratedLiteralFlag flags;
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;
838  CompleteEnumeratedLiteralSeq literal_seq;
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
887  CompleteBitmaskHeader header;
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:611
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:154
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:506
const octet TK_BITSET
Definition: dds-xtypes_typeobject.idl:47
sequence< MinimalBitflag > MinimalBitflagSeq
Definition: dds-xtypes_typeobject.idl:870
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:1047
const octet TK_UNION
Definition: dds-xtypes_typeobject.idl:46
sequence< MinimalEnumeratedLiteral > MinimalEnumeratedLiteralSeq
Definition: dds-xtypes_typeobject.idl:812
TypeFlag AliasTypeFlag
Definition: dds-xtypes_typeobject.idl:160
unsigned short BitBound
Definition: dds-xtypes_typeobject.idl:785
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:330
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:403
octet SBound
Definition: dds-xtypes_typeobject.idl:103
sequence< CompleteAnnotationParameter > CompleteAnnotationParameterSeq
Definition: dds-xtypes_typeobject.idl:601
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:537
octet TypeIdentiferKind
Definition: dds-xtypes_typeobject.idl:57
sequence< TypeInformation > TypeInformationSeq
Definition: dds-xtypes_typeobject.idl:1073
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:1054
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:878
sequence< TypeIdentifierWithDependencies > TypeIdentifierWithDependenciesSeq
Definition: dds-xtypes_typeobject.idl:1063
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:527
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:460
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:393
const octet TI_PLAIN_ARRAY_SMALL
Definition: dds-xtypes_typeobject.idl:65
sequence< CompleteBitfield > CompleteBitfieldSeq
Definition: dds-xtypes_typeobject.idl:911
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:450
sequence< MinimalBitfield > MinimalBitfieldSeq
Definition: dds-xtypes_typeobject.idl:920
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:802
sequence< TypeIdentifierTypeObjectPair > TypeIdentifierTypeObjectPairSeq
Definition: dds-xtypes_typeobject.idl:1039
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:861
MemberFlag CollectionElementFlag
Definition: dds-xtypes_typeobject.idl:129
unsigned long LBound
Definition: dds-xtypes_typeobject.idl:98
sequence< TypeObject > TypeObjectSeq
Definition: dds-xtypes_typeobject.idl:1026
Definition: dds-builtin_types.idl:1
bit_bound(16) enum TypeConsistencyKind
Definition: dds-xtypes_discovery.idl:183
std::vector< AppliedAnnotation > AppliedAnnotationSeq
Definition: AnnotationParameterValue.h:1124
Definition: BuiltinAnnotationsTypeObject.h:73
Definition: BuiltinAnnotationsTypeObject.h:156