Extensible and Dynamic Topic Types for DDS Avatar
  1. OMG Specification

Extensible and Dynamic Topic Types for DDS — All Issues

  • Acronym: DDS-XTypes
  • Issues Count: 56
  • Description: All Issues
Open Closed All
All Issues

Issues Summary

Key Issue Reported Fixed Disposition Status
DDSXTY13-1 Inconsistencies and missing items DDS-XTypes 1.1 DDS-XTypes 1.3 Resolved closed
DDSXTY12-145 Users should have more control over when and how types match DDS-XTypes 1.1 DDS-XTypes 1.2 Resolved closed
DDSXTY12-147 Computing the TypeObject and TypeId for recursive types DDS-XTypes 1.1 DDS-XTypes 1.2 Duplicate or Merged closed
DDSXTY12-149 UML Model is not consistent with document and missing types DDS-XTypes 1.1 DDS-XTypes 1.2 Resolved closed
DDSXTY12-148 Fix a Number of Issues in Final Document DDS-XTypes 1.1 DDS-XTypes 1.2 Resolved closed
DDSXTY12-142 XTypes impacts on IDL and language mappings; optional conformance DDS-XTypes 1.1 DDS-XTypes 1.2 Resolved closed
DDSXTY12-18 Improving Extensible Types DDS-XTypes 1.1 DDS-XTypes 1.2 Resolved closed
DDSXTY12-15 Type Consistency Enforcement Policy does not allow to properly control type projection/widening DDS-XTypes 1.1 DDS-XTypes 1.2 Duplicate or Merged closed
DDSXTY12-143 Enumerations should be represented as a Byte if the bit bound is small enough DDS-XTypes 1.1 DDS-XTypes 1.2 Resolved closed
DDSXTY12-131 Add a @non-serialized annotation DDS-XTypes 1.1 DDS-XTypes 1.2 Resolved closed
DDSXTY12-100 TypeObject IDL and its propagation suffers from significant problems DDS-XTypes 1.1 DDS-XTypes 1.2 Resolved closed
DDSXTY12-127 Consider expanding TypeId 16 octets rather than 8 DDS-XTypes 1.1 DDS-XTypes 1.2 Duplicate or Merged closed
DDSXTY12-119 The current assignability rules are complex and too restrictive DDS-XTypes 1.1 DDS-XTypes 1.2 Resolved closed
DDSXTY12-19 Proposed type-naming scheme is far from Robust DDS-XTypes 1.1 DDS-XTypes 1.2 Duplicate or Merged closed
DDSXTY12-113 The encoding of strings and wide strings should be standardized DDS-XTypes 1.1 DDS-XTypes 1.2 Resolved closed
DDSXTY12-118 Misleading formulation DDS-XTypes 1.1 DDS-XTypes 1.2 Resolved closed
DDSXTY12-38 ths XSD has many errors DDS-XTypes 1.1 DDS-XTypes 1.2 Resolved closed
DDSXTY12-28 Mapping of Map type underspecified for C DDS-XTypes 1.1 DDS-XTypes 1.2 Resolved closed
DDSXTY12-27 C++ shared member representation breaks safety mechanisms of the struct containing it DDS-XTypes 1.1 DDS-XTypes 1.2 Resolved closed
DDSXTY12-9 Contradictions in the assignability for collection types DDS-XTypes 1.1 DDS-XTypes 1.2 Duplicate or Merged closed
DDSXTY12-12 Mapping of optional arrays in C/C++ DDS-XTypes 1.1 DDS-XTypes 1.2 Resolved closed
DDSXTY12-112 Unify name used for Aggregate and Enumerated types DDS-XTypes 1.1 DDS-XTypes 1.2 Resolved closed
DDSXTY12-36 IDL annotation syntax fails to specify scoping rules for annotation type names DDS-XTypes 1.1 DDS-XTypes 1.2 Duplicate or Merged closed
DDSXTY12-10 Deserialization issues with Extensible types DDS-XTypes 1.1 DDS-XTypes 1.2 Resolved closed
DDSXTY12-5 Issues with UNIONS assignability rules DDS-XTypes 1.1 DDS-XTypes 1.2 Duplicate or Merged closed
DDSXTY12-20 Applicable key types not clearly specified DDS-XTypes 1.1 DDS-XTypes 1.2 Resolved closed
DDSXTY12-29 DataRepresentationQosPolicy is making the application responsible for transport DDS-XTypes 1.1 DDS-XTypes 1.2 Closed; No Change closed
DDSXTY12-17 A @Version annotation shall be added DDS-XTypes 1.1 DDS-XTypes 1.2 Resolved closed
DDSXTY12-16 Key order should be defined using the @Key annotation DDS-XTypes 1.1 DDS-XTypes 1.2 Closed; No Change closed
DDSXTY12-14 Allow empty structures DDS-XTypes 1.1 DDS-XTypes 1.2 Closed; Out Of Scope closed
DDSXTY12-23 member ID algorithm flawed DDS-XTypes 1.1 DDS-XTypes 1.2 Resolved closed
DDSXTY12-35 IDL annotation syntax does specify how to use Any member type DDS-XTypes 1.1 DDS-XTypes 1.2 Resolved closed
DDSXTY12-34 Annotation member default declaration not compatible with Legacy IDL DDS-XTypes 1.1 DDS-XTypes 1.2 Duplicate or Merged closed
DDSXTY12-33 Builtin topics not backward compatible DDS-XTypes 1.1 DDS-XTypes 1.2 Resolved closed
DDSXTY12-48 Expose assignability options for ignoring member names and sequence lengths DDS-XTypes 1.1 DDS-XTypes 1.2 Resolved closed
DDSXTY12-47 Keyhash computation not well-defined for mutable types DDS-XTypes 1.1 DDS-XTypes 1.2 Resolved closed
DDSXTY12-46 specify language-specific bindings may exist DDS-XTypes 1.1 DDS-XTypes 1.2 Resolved closed
DDSXTY12-37 One sentence split in two bullets DDS-XTypes 1.1 DDS-XTypes 1.2 Resolved closed
DDSXTY12-6 Spec should allow any value for the Optional flag in TypeObject union members DDS-XTypes 1.1 DDS-XTypes 1.2 Duplicate or Merged closed
DDSXTY12-13 Optional flag in TypeObject union members DDS-XTypes 1.1 DDS-XTypes 1.2 Duplicate or Merged closed
DDSXTY12-11 Optional flag in TypeObject union members DDS-XTypes 1.1 DDS-XTypes 1.2 Resolved closed
DDSXTY12-4 The description for union types are not complete DDS-XTypes 1.1 DDS-XTypes 1.2 Duplicate or Merged closed
DDSXTY12-32 lookup_topicdescription semantics make it unusable DDS-XTypes 1.1 DDS-XTypes 1.2 Resolved closed
DDSXTY12-30 Multiplicity mismatch between TypeName and TypeObject DDS-XTypes 1.1 DDS-XTypes 1.2 Resolved closed
DDSXTY12-21 Shareable members underspecified DDS-XTypes 1.1 DDS-XTypes 1.2 Resolved closed
DDSXTY12-8 Circular dependencies across types should be allowed DDS-XTypes 1.1 DDS-XTypes 1.2 Duplicate or Merged closed
DDSXTY12-7 TypeId calculation errors/corrections DDS-XTypes 1.1 DDS-XTypes 1.2 Resolved closed
DDSXTY12-26 XML type description not orthogonal and not consistent DDS-XTypes 1.1 DDS-XTypes 1.2 Resolved closed
DDSXTY12-25 Type system severely underspecified DDS-XTypes 1.1 DDS-XTypes 1.2 Duplicate or Merged closed
DDSXTY12-24 TypeObject semantics underspecified and inconsistent DDS-XTypes 1.1 DDS-XTypes 1.2 Resolved closed
DDSXTY12-22 Definition of "strongly assignable" seems to be used inconsitently DDS-XTypes 1.1 DDS-XTypes 1.2 Resolved closed
DDSXTY12-3 TypeId union is missing NO_TYPE from the possible values of the discriminator DDS-XTypes 1.1 DDS-XTypes 1.2 Duplicate or Merged closed
DDSXTY12-2 Send TypeId independently of the TypeObject DDS-XTypes 1.1 DDS-XTypes 1.2 Resolved closed
DDSXTY12-31 Topic incosisstency only considered for incompatible types, not for incompatible qos DDS-XTypes 1.1 DDS-XTypes 1.2 Closed; No Change closed
DDSXTY12-1 Specification document cleanup DDS-XTypes 1.1 DDS-XTypes 1.2 Resolved closed
DDSXTY12-158 Inconsistencies and missing items DDS-XTypes 1.1 DDS-XTypes 1.2 Deferred closed

Issues Descriptions

Inconsistencies and missing items

  • Key: DDSXTY13-1
  • Status: closed  
  • Source: Real-Time Innovations ( Dr. Gerardo Pardo-Castellote, Ph.D.)
  • Summary:

    In Section 7.2.3, Table 12 in the rows for "Collection Types", "String Types", and "Primitive Types" should add that "For these types the extensibility kind has no effect in the type matching."

    In Section 7.2.3, Table 12 the row for "Bitmask" says it is always final. This seems limiting, should be like Enum and allow "final" or "appendable"

    In figure 11, 12 and the XSD it shows extensiblity_kind=FINAL for enumerations. This is wrong and inconsistent with 7.2.3.

    The XSD does nor allow setting the "extensibilty" for the "enumDecl". It should.

    In the submission document, Table 21 "IDL Built-in Annotations" does not list where the annotation @hashid can be applied.
    Also, the @id annotation is can be applied to both Structure members and union members (except union discriminator), so it should be moved to the second row on the table.

    In section 7.3.4.4 'Minimal TypeObject' the last paragraph starts with "The complete TypeObject" it should start with "The minimal TypeObject"

    In Annex B in the IDL comment for AppliedBuiltinMemberAnnotations refers to “@hash_id” as opposed to “@hashid”, which is the actual annotation name. Every reference to “@hash_id” should be modified to refer to "@hashid."

    Typo in section 7.2.3 (Type Extensibility and Mutability) it says "APENDABLE" instead of "APPENDABLE"

    Typo in XSD says "include2" instead of "include"

  • Reported: DDS-XTypes 1.1 — Thu, 16 Mar 2017 00:38 GMT
  • Disposition: Resolved — DDS-XTypes 1.3
  • Disposition Summary:

    Perform the corrections listed in the issue description

    Perform the corrections listed in the issue description

  • Updated: Tue, 8 Oct 2019 17:55 GMT

Users should have more control over when and how types match

  • Status: closed  
  • Source: Real-Time Innovations ( Dr. Gerardo Pardo-Castellote, Ph.D.)
  • Summary:

    The type assignability rules aim to make evolving types simple and intuitive. However, there are many cases in which the rules may not match a user's needs. For example, it may or may not be desirable for the member names to be taken into account during type assignability or it may be useful to disallow types from matching solely based on the type name in the absence of type information.

    Therefore we are proposing that the following behaviors are added to the TypeConsistencyEnforcementQosPolicy:

    1. Provide a way to specify to only match readers/writers that you have the TypeObject so that you can ensure type compatibility.
    2. Provide a way to ignore member names, sequence bounds and string bounds
    3. Provide a way to prevent type widening

    And that the following builtin annotation be added:
    @hash id("old_member_name")
    When using auto member ids, the member id is assigned to be the 4-byte hash of the member name. If a user wants to change the name of the member in another version of the type, the member id will change. This annotation will solve that situation by allowing the user to obtain the hash of the old member name as the member id for the member with a different name in the new version.

  • Reported: DDS-XTypes 1.1 — Thu, 22 Dec 2016 19:26 GMT
  • Disposition: Resolved — DDS-XTypes 1.2
  • Disposition Summary:

    Add new fields to the TypeConsistencyEnforcementQosPolicy and new @hash_id annotation

    Allow users to have more control over type evolution and the type assignability rules by adding fields to the TypeConsistencyEnforcementQosPolicy and a @hash_id annotation

  • Updated: Thu, 22 Jun 2017 16:42 GMT

Computing the TypeObject and TypeId for recursive types

  • Status: closed  
  • Source: Real-Time Innovations ( Dr. Gerardo Pardo-Castellote, Ph.D.)
  • Summary:

    A recursive type is one that refers to itself either directly or indirectly. These types are useful to represent dynamic data structures such as trees. For example:

    struct Node;
    struct Node {
        long data;
        @external @optional Node left_child;
        @external @optional Node right_child:
    };
    

    The children are marked @external so that the generated code in languages like C and C++ that can hold object by value uses a reference and therefore does not complain about "incompletely defined symbols"

    The children are marked @optional so that the recursive type can be terminated.

    There is no fundamental problem in supporting these types in the XTYPES type system. Except that the algorithm used to create the TypeObject and compute the TypeId would fail because the type object of an aggregate type requires knowledge of the TypeIdentifiers (and hence TypeObjects) of all the member types and the recursion creates a cyclic-dependency on this.

    Even if this not resolved in RTF 2.2 we need a plan so that we do not break interoperability in the future.

  • Reported: DDS-XTypes 1.1 — Tue, 10 Jan 2017 15:14 GMT
  • Disposition: Duplicate or Merged — DDS-XTypes 1.2
  • Disposition Summary:

    This is addressed by DDSXTY12-100

    Issue DDSXTY12-100 modifies the definition of TypeObject and updates the algorithm to compute TypeIdentifiers from the TypeObjects.

    The updated algorithm can handle mutually dependent types and "recursive" types. Therefore this issue is being merged into DDSXTY12-100.

  • Updated: Thu, 22 Jun 2017 16:42 GMT

UML Model is not consistent with document and missing types

  • Status: closed  
  • Source: Real-Time Innovations ( Dr. Gerardo Pardo-Castellote, Ph.D.)
  • Summary:

    This changes are needed to align the XTYPES model with IDL4. Specifically with regards to annotations.

    In IDL4 it is possible to annotate type declarations, members, and elements in a collection as in:

    @MyAnnotation(3)
    struct MyStruct {
        @MemberAnnotation  long l_member;
        sequence< @ElementAnnotation long, 55>   seq_member;
    };
    

    Union discriminators can also be annotated and so can members, but not the case literals:

    @MyAnnotation(3)
    union MyUnion switch ( DiscriminatorAnnotation(44)  long)  {
        case 1:
           @MemberAnnotation  long  l_member;
        default:
            sequence< @ElementAnnotation long, 55>   seq_member;
    };
    

    It is also possible to annotate enumeration, bitmask and bitset members.

    @MyAnnotation(3)
    bitmask MyBitmask{
        @position(2)  flag1;
    };
    

    Annotation are also permitted in the “related type” for a typedef:

    typedef  @max(23) long  MyLong;
    typedef  sequence<@external long>  LongPtrSeq;
    

    Another issue is that in the new XTYPES we are no longer requiring that all types are named. So that the inheritance of Type from NamedElement is not what we want.

    Currently we use NamedElement model both the name of a type as well as the name of a member (structure, union), name of a bitflag, module, and enum literal.

    Those are things we want to annotate. But we also want to annotate element of a collection as well as the discriminator of unions which have no name.

  • Reported: DDS-XTypes 1.1 — Fri, 20 Jan 2017 10:49 GMT
  • Disposition: Resolved — DDS-XTypes 1.2
  • Disposition Summary:

    Update UML Model to align it with IDL4

    This changes are needed to align the XTYPES model with IDL4. Specifically with regards to annotations.

    In IDL4 it is possible to annotate type declarations, members, and elements in a collection as in:

    @MyAnnotation(3)
    struct MyStruct {
        @MemberAnnotation  long l_member;
        sequence< @ElementAnnotation long, 55>   seq_member;
    };
    

    Union discriminators can also be annotated and so can members, but not the case literals:

    @MyAnnotation(3)
    union MyUnion switch ( DiscriminatorAnnotation(44)  long)  {
        case 1:
           @MemberAnnotation  long  l_member;
        default:
            sequence< @ElementAnnotation long, 55>   seq_member;
    };
    

    It is also possible to annotate enumeration, bitmask and bitset members.

    @MyAnnotation(3)
    bitmask MyBitmask{
        @position(2)  flag1;
    };
    

    Annotation are also permitted in the “related type” for a typedef:

    typedef  @max(23) long  MyLong;
    typedef  sequence<@external long>  LongPtrSeq;
    

    Another issue is that in the new XTYPES we are no longer requiring that all types are named. So that the inheritance of Type from NamedElement is not what we want.

    Currently we use NamedElement model both the name of a type as well as the name of a member (structure, union), name of a bitflag, module, and enum literal.

    Those are things we want to annotate. But we also want to annotate element of a collection as well as the discriminator of unions which have no name.

    Modifications to the UML model

    The UML model needs an AppliedAnnotation class that models the application of annotations to some other classifier.

    Also NamedElement should not be modeled as a “base class” but rather as something that certain classifiers have. So it should be a “has-a” relationship. That would allow some types (e.g. anonymous types) to not have a name.

    String should not inherit from Collection. There should be a StringType that is specialized by String8 and String16. StringType would be a direct child of Type, peer to PrimitiveType.

    There should be a EnumeratedType peer of PrimitiveType. It should have Enumeration and Bitmask as specializations.

    Bitset should be added as another specialization of Aggregation.

    In addition:

    • Create an association between Aggregation and NamedElement. This has cardinality “1”. Every Aggregation type has a name.
    • Create an association between Collection and NamedElement. This has cardinality “0..1”. Collection types can be named or anonymous.
    • Create an association between Alias and NamedElement. This has cardinality “1”. Alias types always have a name.
    • Add an association between ConstructedType and NamedElement. It should have to be “0..1” to capture the possibility for anonymous collections.
    • Module, EnumerationLiteral, Bitflag, Member, and Bitfield would also have a “has-a” relation to NamedElement with cardinality “1”.
    • Model the annotations on collection element and union discriminator.
    • Union Discriminator requires a separate class. Currently it is modeled as a “member” but that is odd (e.g. it is unnamed, has hard-coded memberID) better to model it separately.
    • Change NamedElement to ScopedIdentifier.

    Enhance model for Annotations
    Currently Annotation specializes Aggregation type. This is wrong in several ways.
    Al constructed types can be annotated. But Annotations cannot have annotations.
    It does make sense to talk about the extensibility kind of an annotation. Nor about the type compatibility/assignability.

    Many associations to type (e.g. a structure member has a type) do not make sense if the “type” is an annotation.

    The only thing from Type is that they can have a type object.

    Annotations should not be modeled as types. They should not specialize “Type” they should be their own thing. Basically we define a AnnotationDeclaration an AppliedAnnotation (and AnnotationParameter). This can follow the TypeObject model.

    Then section 7.2.2.3.6 “Annotation Types” can be moved to a higher level. Say 7.2.2.6 after :”Try Construct Behavior”

    Also in the XTYPES it says (in section 7.2.2.3.6) that annotations can inherit from other annotations. However the IDL grammar 7.4.15 does not support annotation inheritance so we should get rid of that in the XTYPES.

  • Updated: Thu, 22 Jun 2017 16:42 GMT
  • Attachments:

Fix a Number of Issues in Final Document


XTypes impacts on IDL and language mappings; optional conformance

  • Status: closed  
  • Source: Object Computing, Inc. - OCI ( Mr. Adam Mitz)
  • Summary:

    Since XTypes changes how IDL and language mappings work, determine if an XTypes implementation can still be conformant (perhaps using optional conformance) if certain features are not implemented – for example external/shareable types.

    There are many OMG specs listed in section 3 "Normative References." XTypes should be explicit about which of these are required dependencies, which are optional, and which sections of those specs are important for XTypes.

  • Reported: DDS-XTypes 1.1 — Fri, 18 Nov 2016 16:27 GMT
  • Disposition: Resolved — DDS-XTypes 1.2
  • Disposition Summary:

    *Update the conformance section *

    Update the conformance chapter to reflect and include the new sections in the spec

  • Updated: Thu, 22 Jun 2017 16:42 GMT

Improving Extensible Types

  • Legacy Issue Number: 18146
  • Status: closed  
  • Source: ZettaScale Technology ( Angelo Corsaro, PhD.)
  • Summary:

    Extensible Types do not support monotonic extensions of nested struct types. Adding support for monotonic extensibility of nested structures is straight-forward and requires only a very small change to the existing specification.

    Our suggestion is to allow for monotonic extensibility at any level in the type structure and accommodate this by serializing a length parameter before any nested structure.

    No @Id should be serialized since it is likely that user won't specify IDs when using Extensible types and relying on Ids could break the whole scheme.

    Note that this no longer needs to address DDSXTY12-15 as that issue is already addressed by the resolution DDSXTY12-145

  • Reported: DDS-XTypes 1.1 — Mon, 8 Oct 2012 04:00 GMT
  • Disposition: Resolved — DDS-XTypes 1.2
  • Disposition Summary:

    Improving Extensible Types

    In DDS-XTYPES 1.1 there are 3 extensibility kinds: Final, Extensible, Mutable. And two encoding formats: PLAIN_CDR and PL_CDR.

    In DDS-XTYPES 1.2 we are adding 2 encoding formats: DELIMITED_CDR and ENHANCED_PL_CDR.

    For simplicity and backwards compatibility DDS-XTYPES 1.2 keeps the same 3 extensibility kinds. But uses the name "APPENDABLE" instead of "EXTENSIBLE". "EXTENSIBLE can still be accepted in the IDL for compatibility. When serializing data the Encoding format is determined by “Extensibility Kind” and the encoding version:

    Extensibility Kind in the IDL Encoding Version Extensibility Kind in the TypeObject Encoding format on the wire
    FINAL 1 FINAL=0 PLAIN_CDR
    FINAL 2 FINAL=0 PLAIN_CDR2
    APPENDABLE 1 APPENDABLE=1 PLAIN_CDR
    APPENDABLE 2 APPENDABLE=1 DELIMITED_CDR
    MUTABLE 1 MUTABLE=2 PL_CDR
    MUTABLE 2 MUTABLE=2 ENHANCED_PL_CDR
  • Updated: Thu, 22 Jun 2017 16:42 GMT
  • Attachments:

Type Consistency Enforcement Policy does not allow to properly control type projection/widening

  • Legacy Issue Number: 19405
  • Status: closed  
  • Source: ZettaScale Technology ( Angelo Corsaro, PhD.)
  • Summary:

    The X-Types specification suffers a of inconsistency with respect to how it treats type widening for extensible and mutable types. Specifically widening is always supported for mutable types and never for extensible types.

    That means that given two types X, and Y with Y <: X (read as Y subtype of X) then we have the following cases:

    1. If X and Y are mutable and the TypeConsistencyEnforcementQosPolicy is set to ALLOW_TYPE_COERCION then:
    i. a DR[X] will match a DW[Y] and in this case Y will be
    projected on X.

    ii. a DR[Y] will match a DR[X] and in this case X will be
    widened to Y – by initializing missing attributes
    with default constructors.

    2. If X and Y are extensible and the TypeConsistencyEnforcementQosPolicy is set to ALLOW_TYPE_COERCION then the only possible case is for a DR[X] to match a DW[Y] through a projection of Y on X.

    The inconsistency resulting from the non-uniform treatment of extensible types is not only unjustified but also creates practical issues.

    The fixes that we propose to the specification are the following.

    • Extend the the TypeConsistencyEnforcementQosPolicy to control both type widening as well as projection. Notice that although projection is safe (in most of the case) type widening may not be safe for some applications.

    Thus the the TypeConsistencyEnforcementQosPolicy should be extended to provide the following options:

    1. ALLOW_TYPE_PROJECTION to enable only type
    projection regardless of wether a topic is mutable or
    extensible.

    2. ALLOW_TYPE_WIDENING to enable only type widening

    The conjunction of the previous options should allow for a type to support both projection as well as widening. Otherwise, but this option is less desirable, a third option named ALLOW_TYPE_PROJECTION_AND_WIDENING may be added.

    3. Rename DISALLOW_TYPE_COERCION into
    DISALLOW_TYPE_CONVERSION.

    • Clarify the assignable-from to make it more explicit that type widening is also supported by extensible types.
  • Reported: DDS-XTypes 1.1 — Fri, 2 May 2014 04:00 GMT
  • Disposition: Duplicate or Merged — DDS-XTypes 1.2
  • Disposition Summary:

    Merged with DDSXTY12-18

    This issue is addressed by the same mechanism proposed to address DDSXTY12-18 and therefore it is being merged with it.

    Even if it had been merged with DDSXTY12-18 it was eventually handled by DDSXTY12-145 which was resolved before DDSXTY12-18

  • Updated: Thu, 22 Jun 2017 16:42 GMT

Enumerations should be represented as a Byte if the bit bound is small enough

  • Status: closed  
  • Source: Real-Time Innovations ( Dr. Gerardo Pardo-Castellote, Ph.D.)
  • Summary:

    Currently enumerations can only be represented using Int16 or Int32. But we see no reason why they couldn't be represented with a Byte if the bit bound is 8 or less.

  • Reported: DDS-XTypes 1.1 — Thu, 22 Dec 2016 16:55 GMT
  • Disposition: Resolved — DDS-XTypes 1.2
  • Disposition Summary:

    Allow Enumerations to be represented by a Byte if the Bit Bound is 8 or less

    Allow Enumerations to be represented by a Byte if the bit bound is 8 or less. Currently, if the bit bound is 1-16 the representation is Int16.

  • Updated: Thu, 22 Jun 2017 16:42 GMT

Add a @non-serialized annotation

  • Status: closed  
  • Source: Real-Time Innovations ( Dr. Gerardo Pardo-Castellote, Ph.D.)
  • Summary:

    Section 7.4.1.3 "Extension to RTPS Standard DCPSParticipants Builtin Topic" of the DDS-Security 1.0 specification defines a @non-serialized annotation. This is used to indicate that a member of an aggregate type should not be serialized.

    This annotation should be moved to XTYPES since it is not specific to DDS-Security and may be needed for other data-types.

  • Reported: DDS-XTypes 1.1 — Tue, 4 Oct 2016 11:43 GMT
  • Disposition: Resolved — DDS-XTypes 1.2
  • Disposition Summary:

    Add a @non_serialized annotation

    A @non_serialized annotation is currently defined in the DDS-SECURITY specification. It is not specific to security though, so we are moving it to the XTYPES specification.

  • Updated: Thu, 22 Jun 2017 16:42 GMT

TypeObject IDL and its propagation suffers from significant problems

  • Status: closed  
  • Source: Real-Time Innovations ( Dr. Gerardo Pardo-Castellote, Ph.D.)
  • Summary:

    The TypeObject IDL in Annex B has some significant problems:

    • The TypeObject of a type embeds its TypeId. However to compute the TypeId one needs to serialize the TypeObject and hash the result. This recursion makes it impossible to create. The work around of first setting the TypeId=0, then computing a "adjusted" TypeObject, serialize and hash it, and use the hash of the "adjusted" TypeObject as its TypeId has been suggested but it is clunky to say the least.
    • Even with the workaround mentioned above the TypeObject format cannot handle recursive types. That is types that refer to themselves which are legal in IDL. For example, there is no way to compute the TypeId of the "child" member f IntTree without having the TypeObject for IntTree which creates an infinite recursion.
    typedef IntTree;
    struct IntTree {
        long  value;
        sequence<IntTree> children;
    };
    
    • There TypeObject IDL uses extensibility(MUTABLE) for many types. This allows multiple equivalent serializations for the TypeObject as members of a mutable type can be serialized in any order. Also there is a choice between serializing them using so called short parameters or "extended" parameters, and also they can be serialized in big endian or little endian. All this means that the TypeId which is a hash computed on the serialized TypeObject can be different depending on how/where it is computed. This is undesirable as the TypeSystem uses the equality of TypeId to detect when types are identical.
    • The TypeObject contains a very detailed representation of the type which is equivalent to the IDL and XML. This is propagated via discovery in the PublicationBuiltinTopic data. This information can be very large (100's of KB) which slows discovery and pushes information to every participant even if they have no interest on that Type, or already know it. Moreover, even when it is used the only need is to check type assignability and that does not require a lot of the information that is propagated with the type
    • The TypeObject is missing the new annotations and types introduced in IDL4.

    In view of this the TypeObject IDL should be refactored in a way that addresses the above problems. Moreover the specification should provide a more efficient way to propagate types that does not involve pushing the TypeObject in the discovery builtin topic data.

  • Reported: DDS-XTypes 1.1 — Wed, 29 Jun 2016 21:11 GMT
  • Disposition: Resolved — DDS-XTypes 1.2
  • Disposition Summary:

    Refactor the TypeObject IDL definition and provide a more efficient propagation mechanism

    This resolution includes:

    • A new TypeObject IDL
    • The computation of TypeId for mutually-dependent (recursive) types
    • The propagation of TypeObject (using the request/reply builtin objects)
    • The naming anonymous types.
  • Updated: Thu, 22 Jun 2017 16:42 GMT
  • Attachments:

Consider expanding TypeId 16 octets rather than 8

  • Status: closed  
  • Source: Real-Time Innovations ( Dr. Gerardo Pardo-Castellote, Ph.D.)
  • Summary:

    Currently the TypeId is 8 octets.
    The TypeId distinguishes identifies a Type and needs to have a low probability of collision relative to the size of the set (collection of types) that can potentially apply to the scope.

    A hash of 64 bits provides reasonably low probability of collision (e.g. < 1 in 10 million) when the set of possible values has a size smaller than 2 million. This was more than enough when we consider the "collection of types" to just be the types that can be associated with a particular Topic on a particular Domain.

    However if we consider the problem of identifying Types across Topics within a Domain, or across domains, or even across applications that evolve over time (e.g. keep a database of TypeId that is built over time) then 64 bits may not be enough...

    We should consider whether to make it 16 bytes now. If these use cases can become important then now would be the time to make the change...

  • Reported: DDS-XTypes 1.1 — Wed, 28 Sep 2016 22:13 GMT
  • Disposition: Duplicate or Merged — DDS-XTypes 1.2
  • Disposition Summary:

    The size of the TypeID is being increased so hashes are 14 bytes.

    This issue is being merged with DDSXTY12-100 because the resolution of that issue is already increasing the sizes of the hashes in the TypeID to 14 bytes.

  • Updated: Thu, 22 Jun 2017 16:42 GMT

The current assignability rules are complex and too restrictive

  • Status: closed  
  • Source: Real-Time Innovations ( Dr. Gerardo Pardo-Castellote, Ph.D.)
  • Summary:

    The existing type compatibility rules create situations where DataWriters are not able to communicate with DataReaders because of type differences that could be easily accommodated by the type system.

    The assignability rules for strings are sequences are following the meta-rule: “If type T1 can have an object O1 that is not assignable to type T2, then type T1 is considered un-assignable to T2”. For example according to Table 13 string<256> is unnasignable to string<32> and sequence<long, 256> is unnasignable to sequence<long, 32>.

    Feedback from users indicates that this is undesirable. For example a type may have been designed containing a string<256> but never used to send strings longer than 30 characters. Then in a later version the type is modified to string<32> in order to reduce the max length to the actual size needed to conserve memory resources. This would make the new version of the type incompatible with deployed systems even if all the strings ever sent fit in the string<32> type.

    Type assignability rules are also complex because they are defined as an asymmetric relationship: T1 is-assignable-to T2. rather than a symmetric one. Another complexity comes from the need to define of "strong assignability" which captures the case where T1 is-assignable-to T2 and the end of the T1 object can be determined by T2. This is needed when the T1 appears nested inside another type or in a sequence.

    The main reason to define this asymmetric rule was caused by the previous point of having types like string<10> assignable to string<100> but not the other way around. If we change these assignability rules for strings/sequences then the need for the asymmetric is-assignable-to relationship goes away and can be replaced by a symmetric "is-compatible-with"

    The "strong assignability" is an artifact of the way extensible types are serialized. If they were serialized wrapped with a "length" around them as with the APPEND extensibility we would not need this concept.

  • Reported: DDS-XTypes 1.1 — Sat, 6 Aug 2016 19:47 GMT
  • Disposition: Resolved — DDS-XTypes 1.2
  • Disposition Summary:

    Increase flexibility of assignability rules

    Introduce new rules to increase the set of types that are assignable and avoid discarding data as soon as an object that does not "fit" into a target type.

    • Change compatibility of sequences and strings so that the types are compatible regardless of the length. Object initialization requires SOURCE.length <= TARGET_TYPE.length if not the object cannot initialize an object of the TARGET type. This affects Table 13.
    • Introduce a @TryConstruct annotation that can be used to indicate that an unassignable member does not cause the complete object to be dropped. Instead, the member is set to its default value.
    • Allow the use of @DefaultLiteral annotation on enum to allow selecting a default value for an enumeration other than the first or one with smallest member ID.
    • Change compatibility of unions and structures to take into consideration the @TryConstruct annotation.
    • Introduce some clarifying examples

    More details can be found in the attached document: TypeCompatibilityProposal_v3.docx

  • Updated: Thu, 22 Jun 2017 16:42 GMT
  • Attachments:

Proposed type-naming scheme is far from Robust

  • Legacy Issue Number: 18292
  • Status: closed  
  • Source: ZettaScale Technology ( Mr. Erik Hendriks)
  • Summary:

    The naming scheme proposed in section 7.2.2.3.4 is far from Robust, since the prefixes used to identify a collection may clash with the names of a user defined type. For example: what is a user has created a type called sequence_10, and he creates a sequence of 10 elements from this? The resulting typename would then become sequence_10_sequence_10, for which the parser will assume it is now a 2-dimensional sequence without element type.

    To make robust type names, we should use special characters that are not allowed in the definition of user-defined type names, e.g. sequence<10, sequence_10> or something similar.

  • Reported: DDS-XTypes 1.1 — Wed, 12 Dec 2012 05:00 GMT
  • Disposition: Duplicate or Merged — DDS-XTypes 1.2
  • Disposition Summary:

    After applying the resolution of Issue 100 this is no longer a problem

    The problem arises from the fact that TypeObject of every type had to have a name for every types, those names had to be unique and match across implementations .

    However DDSXTY12-100 modified the TypeObject and now anonymous collection types no longer need a name.

    The issue is merged with DDSXTY12-100 so that as part of that resolution the section that talks about naming the anonymous types can be removed as it is no longer needed.

  • Updated: Thu, 22 Jun 2017 16:42 GMT
  • Attachments:

The encoding of strings and wide strings should be standardized

  • Status: closed  
  • Source: Real-Time Innovations ( Dr. Gerardo Pardo-Castellote, Ph.D.)
  • Summary:

    Currently, strings and wide strings are treated as mere arrays of chars and wide chars respectively, regardless of their character encoding configuration. This can lead to interoperability issues between systems that assume different encoding configurations implicitly.

    Java and C# languages use UTF-16 encoding, which forces any user who wishes to interoperate their C/C+ application with a Java/.Net application to manually make sure that their strings are encoded in the UTF-16 encoding. There is no API to convert between DDS_Wchar (4 bytes) and a platform’s wchar_t. By default the conversion is done by casting wchar_t to DDS_Wchar, and the fundamental problem is that when casting, after converting back to wchar_t the right character may not be retrieved if the publisher was using a different encoding than the subscriber.

    The proposal is to standardize the wire encoding for char and wide char. For chars we propose using UTF-8 and for wide chars we propose UTF-32 encoding. Along with this change, we should provide conversion APIs to in C/C++ to convert between wchar_t and DDS_Wchar to avoid issues between platforms. For Java and C# the middleware knows the wire encoding (UTF-32) and the native encoding (UTF-16) so the conversion can be done automatically for the user.

    We need to think about how to maintain backwards compatibility with applications that may be using other wire encodings today.

  • Reported: DDS-XTypes 1.1 — Wed, 13 Jul 2016 20:55 GMT
  • Disposition: Resolved — DDS-XTypes 1.2
  • Disposition Summary:

    *Change the standard encoding of strings *

    See the discussion and attached documents in DDSXTY12-113 for rationale behind the decisions to:

    • Not specify an encoding for characters
    • Encode strings using UTF-8
    • Encode wide characters and strings using UTF-16
    • Change the type of WChar to Char16 from Char32.
  • Updated: Thu, 22 Jun 2017 16:42 GMT
  • Attachments:

Misleading formulation

  • Status: closed  
  • Source: Siemens ( Pieter Van Vlierberghe)
  • Summary:

    Table 7.4 contains the following misleading statement:
    "It merely provides an alternative name by which to refer to another
    type."
    The point is that alias types are NOT introducing a new type, so "another type" is actually about the same type.

  • Reported: DDS-XTypes 1.1 — Mon, 25 Jul 2016 08:57 GMT
  • Disposition: Resolved — DDS-XTypes 1.2
  • Disposition Summary:

    Correct misleading statement

    See issue description on DDSXTY12-118.

  • Updated: Thu, 22 Jun 2017 16:42 GMT

ths XSD has many errors

  • Legacy Issue Number: 18781
  • Status: closed  
  • Source: THALES ( Hugues Vincent)
  • Summary:

    Checked with Xerces, the XSD file has many errors which come from the lack of use of namespace.
    Lines: 37, 57, 60, 108, 111, 114, 136, 139, 143, 146, 241, 248, 267, 270, 277, 294, 370, 373, 435, 439, 442, 445, 448, 465, 495, 520, 523, 557, 560, 578, 581, 640
    Xerces error (for the first one: "filename"): "E [Xerces] src-resolve.4.1: Error resolving component 'fileName'. It was detected that 'fileName' has no namespace, but components with no target namespace are not referenceable from schema document 'http://www.omg.org/spec/DDS-XTypes/20120202/dds-xtypes_type_definition.xsd'. If 'fileName' is intended to have a namespace, perhaps a prefix needs to be provided. If it is intended that 'fileName' has no namespace, then an 'import' without a "namespace" attribute should be added to 'http://www.omg.org/spec/DDS-XTypes/20120202/dds-xtypes_type_definition.xsd'."
    W3C reference:
    http://www.w3.org/TR/xmlschema11-1/#src-resolve

  • Reported: DDS-XTypes 1.1 — Mon, 17 Jun 2013 04:00 GMT
  • Disposition: Resolved — DDS-XTypes 1.2
  • Disposition Summary:

    Fixing Namespace in XSD files

    The original XSD schemas had multiple problems related to namespaces.

    To address these issues and make it simpler for other specifications to refer to the types define in the schema included in the specification, we are applying the so-called Chameleon Namespace Design, dividing the original schema into two different XSD files:

    1. dds_types.xsd, which can be used by applications to validate the types defined in an XML file. This file sets targetNamespace="http://www.omg.org/dds/".
    2. dds_types_definition.xsd, which includes all the type definitions without specifying a targetNamespace.

    Accompanying these two XSD files we include a non-normative XML file that demonstrate how to load dds_types.xsd with the right namespace to define a set of data types.

  • Updated: Thu, 22 Jun 2017 16:42 GMT
  • Attachments:

Mapping of Map type underspecified for C

  • Legacy Issue Number: 18304
  • Status: closed  
  • Source: ZettaScale Technology ( Mr. Erik Hendriks)
  • Summary:

    Section 7.5.1.3.1 is referring to a C-mapping defined above. However, no C-mapping is mentioned so far, or it should refer to section 7.5.1.3.3
    Section 7.5.1.3.3 seems to suggest the C-mapping should be done as in section 7.4.1.1.4, which is a sequence of name-value pair structs. I can't imagine that this is a serious mapping proposal, but if it is is should be clearly specified as such

  • Reported: DDS-XTypes 1.1 — Wed, 12 Dec 2012 05:00 GMT
  • Disposition: Resolved — DDS-XTypes 1.2
  • Disposition Summary:

    Clearly define a C mapping for Map types

    The C mapping for map types is not well-defined and needs to be added.

  • Updated: Thu, 22 Jun 2017 16:42 GMT

C++ shared member representation breaks safety mechanisms of the struct containing it

  • Legacy Issue Number: 18303
  • Status: closed  
  • Source: ZettaScale Technology ( Mr. Erik Hendriks)
  • Summary:

    By clearly stating that a shared member must map onto a plain pointer, not a _var type or other smart pointer you are breaking the safety mechanisms that the C++ struct had inherently built into it, since on destruction or re-assignment the shared pointer may now leak away. The whole point of using _var types or other smart types was to prevent this from happening. I see no good reason why to make this one exception for shared pointers, which will make it much harder to predict the struct's behaviour.

  • Reported: DDS-XTypes 1.1 — Wed, 12 Dec 2012 05:00 GMT
  • Disposition: Resolved — DDS-XTypes 1.2
  • Disposition Summary:

    Define the language binding for shared members in C and C++

    Shared members are currently mapped to plain pointers in C and C++. This mapping prevents safety mechanisms, such as shared pointers in C++, from being used to automatically handle the memory management of these members. We are redefining the language mapping to add in these safety mechanisms and to allow the memory to be handled differently on the sending and receiving sides of an application.

  • Updated: Thu, 22 Jun 2017 16:42 GMT
  • Attachments:
    • External.hpp.docx 9 kB (application/vnd.openxmlformats-officedocument.wordprocessingml.document)

Contradictions in the assignability for collection types

  • Key: DDSXTY12-9
  • Legacy Issue Number: 19269
  • Status: closed  
  • Source: Real-Time Innovations ( Sumant Tambe)
  • Summary:

    The OMG approved more-restrictive assignability rules (OMG Issue No 16368). However, some examples in the current spec (Version 1.0, February 2012, OMG Document number ptc/2012-03-26) remain unchanged and contradict those new rules.
    For example, on page 39, we say that a sequence of 10 integers is assignable from a sequence of 20 integers, although some objects may not be. This is no longer true according to the new rules--the destination sequence bound must be greater or equal than that of the source sequence (see Table 13 on page 40).

  • Reported: DDS-XTypes 1.1 — Wed, 26 Feb 2014 05:00 GMT
  • Disposition: Duplicate or Merged — DDS-XTypes 1.2
  • Disposition Summary:

    Merged with DDSXTY12-119

    This issue has been subsumed by DDSXTY12-119. Therefore it should be merged into it.

  • Updated: Thu, 22 Jun 2017 16:42 GMT

Mapping of optional arrays in C/C++

  • Legacy Issue Number: 19272
  • Status: closed  
  • Source: Real-Time Innovations ( Sumant Tambe)
  • Summary:

    Spec does not specify the C/C++ mapping of optional arrays.

  • Reported: DDS-XTypes 1.1 — Wed, 26 Feb 2014 05:00 GMT
  • Disposition: Resolved — DDS-XTypes 1.2
  • Disposition Summary:

    Add an example of how to declare an optional array for C and C++

    Optional members already map to pointers in C and C++, but the syntax of declaring a pointer to an array of objects rather than an array of pointers to that type of object is tricky. We would therefore like to provide an example of how to do this.

  • Updated: Thu, 22 Jun 2017 16:42 GMT

Unify name used for Aggregate and Enumerated types


IDL annotation syntax fails to specify scoping rules for annotation type names

  • Legacy Issue Number: 19145
  • Status: closed  
  • Source: Remedy IT ( Martin Corino)
  • Summary:

    There is no clear specification of whether annotation types are part of the same naming scope as other IDL declared types or not.
    The Type System Model described in chapter 7.2.2 seems to indicate they are all declared in a single naming scope as an annotation member could have "any enumeration type". In IDL this would require them to have the same naming scope as IDL declared enum types.
    As a consequence it would mean that annotation type names could clash with type names used by 'regular' local interface definitions.
    It would also seem to indicate that annotation application syntax would have to support scoped naming like "@Test::MyAnnotation()".
    Clear specifications for all these considerations are missing from the spec.

  • Reported: DDS-XTypes 1.1 — Sun, 15 Dec 2013 05:00 GMT
  • Disposition: Duplicate or Merged — DDS-XTypes 1.2
  • Disposition Summary:

    Combine with DDSXTY12-34

    This problem is partly caused by the use of "interfaces" to define annotations.
    However annotation names should never conflict with any other types (interfaces or otherwise) as their use is proceeded by the character "@".
    IDL4 new syntax for declaring annotations makes it more obvious by using the keyword "@annotation" to define annotations.
    Since legacy IDL compilers are no expected to parse the annotation declarations it seems that this issue will only affect the new compilers.

    IDL4 does declare scopes for applying annotations, but all the builtin annotations (which include the XTYPES ones) are defined in the global scope.

    Therefore this issue should be solved the same way as XTYPE12-34 ideally aligning the syntax with that of IDL4.

  • Updated: Thu, 22 Jun 2017 16:42 GMT

Deserialization issues with Extensible types

  • Legacy Issue Number: 19270
  • Status: closed  
  • Source: Real-Time Innovations ( Sumant Tambe)
  • Summary:

    Spec: DDS-XTYPES
    Document Number: ptc/2013-12-18
    Revision Data: 2013-12-18
    Version 1.2
    Nature: Enhancement
    Severity: Significant
    Title: Deserialization issues with Extensible types

    Problem description

    The XTypes specification uses "traditional" CDR to represent extensible types on the wire.

    The usage of "traditional" CDR encapsulation poses a problem in some scenarios where a DataReader with an extensible type "A" receives samples coming from a DataWriter with an extensible type "B" and where type "B" contains a subset of the members in type "A" (base to derive relationship). For example:

    struct TypeB  {
       char member1;
    };
    struct TypeA {
      char member1;
      short member2;
    };
    

    At first sight, the usage of traditional CDR is enough to deal with the scenario described above:

    The deserialize operation for type "A" will deserialize member1. After that, the function will try to deserialize member2 but it will find that there are no more bytes in the input stream. In the absence of a value for member2, the deserialize function will initialize this member with its default value 0.

    So far so good.

    The problem is that the previous algorithm works fine only when the number of bytes in the input stream (serialized sample published by the DataWriter) is exactly equal to the number of bytes produced by the serialization function for Type "B". In our example, this number is 1. Unfortunately, in some scenarios, including our example, the number of bytes in the input stream will include some padding bytes that are added to guarantee that the RTPS DATA sub-message containing the sample published by the DataWriter has a size divisible by 4.

    The PSM in the RTPS specification requires that each sub-message is aligned in a 32-bit boundary with respect to the start of the RTPS message.

    In our example, the deserialization function for Type "A" will receive a stream with 4-bytes (1 for the char in member1 and 3 bytes for padding). Because of that, the previous algorithm may end up initializing member2 with padding bytes. Since padding bytes may have a value different than 0 the member2 value will not necessarily be equal to zero.

    Affected types

    The previous issue may occur when all the following conditions are met:

    • The top-level types used by DataReader and DataWriter are extensible.
    • The DataReader type is assignable from the DataWriter type and it contains more fields at the end (see example above).
    • The last primitive member on the DataWriter type is: char, octet, boolean, short, unsigned short, or string. Other types are not a problem because they require 4-byte alignment and the middleware will not have to add padding bytes at the end of the DATA message.
    • The first primitive member on the DataReader type after the last primitive member on the DataWriter type is: char, octet, boolean, short, unsigned short. Other types are not a problem because they require 4-byte alignment. The deserialization function will not use the padding bytes at the end of the DataWriter's sample to initialize the contents of the first primitive member on the DataReader type.

    For example:

    struct TypeB {
      char member1;
    };
    struct TypeA {
      char member1;
      short member2;
    };
    

    The previous two types will be problematic.

    struct TypeB {
      long member1;
    };
    struct TypeA {
      long member1;
      short member2;
    };
    

    The previous two types will be OK.

    struct TypeB {
     string member1;
    };
    struct TypeA {
      string member1;
      short member2;
    };
    

    The previous two types may be problematic or not depending on the value of member1.

    struct TypeC {
     char member1;
    };
    struct TypeB {
      TypeC member1;
    };
    struct TypeA {
      TypeC member1;
      short member2;
    };
    

    The previous two types will be problematic since the first primitive member of TypeB (including nested types) is a char.

    Are Mutable Types Affected?

    This problem does not affect mutable types directly. However, it may affect mutable types when they contain members of extensible types.
    For example:

    struct TypeB {
      char member1;
    };
    struct TypeBMutable {
      TypeB member1;
    }; //@Extensibility MUTABLE_EXTENSIBILITY
    struct TypeA {
      char member1;
      short member2;
    };
    struct TypeAMutable {
      TypeA member1;
    }; //@Extensibility MUTABLE_EXTENSIBILITY
    

    Mutable members are encapsulated using parametrized CDR representation.

    Each member, within a mutable type is simply a CDR-encapsulated block of data. Preceding each one is a parameter header consisting of a two-byte parameter ID followed by a two-byte parameter length. One parameter follows another until a list-terminating sentinel is reached. Parameter headers must be aligned to a 4-byte boundary. If the serialized length of a member value is not divisible by 4, the implementation will add some padding bytes.

    The problem is that the length field of a mutable member represents the data length measured from the end of that field until the start of the next parameter ID (this is part of the XTypes specification). Therefore, the deserialize function for the member type may receive as input a stream containing the padding bytes.

    IN Implementation Changes

    To reduce the number of scenarios in which we run into the problem we will initialize the padding bytes to zero. This includes the padding bytes at the end of the serialized sample, and the padding bytes at the end of a mutable member serialization.

    By doing this the following scenario would not be an issue anymore

    struct TypeB {
      char member1;
    };
    struct TypeA {
      char member1;
      short member2;
    };
    

    In the previous example the deserialize function would use padding bytes to initialize member2. However, since these padding bytes have a zero value, the value assigned to member2 would be the right value.

    With the previous fix we would have issues only when the first primitive member on the DataReader type is char, octet, boolean, short, unsigned short and in addition it is the discriminator of a union.

    For example:

    struct TypeB {
      char member1;
    };
    union UnionA switch (short) {
      case 0:
         long member1;
      default:
         long member2;
    };
    struct TypeA {
      char member1;
      UnionA member2;
    };
    

    To detect the previous problem, we will change the type compatibility algorithm so that it reports an error when the issue occurs.

    Potential Changes to the XTypes Specification

    Resolving the extensibility problem described above for all the scenarios will likely require changes to the XTypes specification.

    For the top-level types, we propose to use two bits from the options bytes following the encapsulation identifier to identify the padding.
    For example:

    struct TypeB {
      char member1;
    };
    

    In the previous example a sample for Type B would be encapsulated as follows:

    CDR_BE x x x x x x x x x x x x x x 1 1
    member1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

    Notice that the value '11' in the options indicates the number of padding bytes.

    For mutable members we propose to change the interpretation of the length field to not include the padding bytes to the next header.
    For example:

    struct TypeB {
      char member1;
    };
    struct TypeBMutable {
      TypeB member1; //@ID 1
    }; //@Extensibility MUTABLE_EXTENSIBILITY
    

    In the previous example TypeBMutable would be encapsulated as follows:

    CDR_BE x x x x x x x x x x x x x x 0 0
    ID 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1
    member1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
    PID_LIST_END 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

    Notice that the length field for the member with ID 1 is set to 1 instead of 4

    Forward compatibility

    The changes described in the previous section should not affect backward compatibility with previous XTYPES compatible versions.

    Let's assume two XTYPE versions:

    • One DDS compliant with XTPES 1.1 and already deployed
    • A future DDS compliant with XTPES 1.2 incorporating the changes to the XTypes spec described in the previous section

    TOP-LEVEL Types:

    • XTYPES 1.1 DataReaders should ignore the option bits set by the XTYPES 1.2 DataWriters
    • XTYPES 1.2 DataWriters receiving samples from XTYPES 1.1 DataReaders will assume that there are no padding bytes

    MUTABLE Members

    • XTYPES 1.1 DataReaders will receive members with a header where the data length is smaller than expected. This should not be a problem because the DataReader will always align the beginning of the next parameter to a 4-byte boundary. Therefore, the padding bytes will be skipped by the align operation.
    • XTYPES 1.2 DataReaders will receive members with a header where data length includes padding. That should be fine as well. The align operation to go to the beginning of the next parameter will be a NOOP.
  • Reported: DDS-XTypes 1.1 — Wed, 26 Feb 2014 05:00 GMT
  • Disposition: Resolved — DDS-XTypes 1.2
  • Disposition Summary:

    Fix the deserialization issues related to padding

    Modify the XTYPES specification to use the option bits that follow the encapsulation options to encode the number of padding bytes. Follow what is stated in the issue description. In addition padding bytes should be set to zero.

    Clarify/state that the lengths for both short and long member IDs encode the exact length of the serialized member without accounting for padding bytes.

  • Updated: Thu, 22 Jun 2017 16:42 GMT
  • Attachments:

Issues with UNIONS assignability rules

  • Key: DDSXTY12-5
  • Legacy Issue Number: 19265
  • Status: closed  
  • Source: Real-Time Innovations ( Sumant Tambe)
  • Summary:

    The IDL specification (pre-XTypes) allows the declaration and usage of unions that do not cover all possible discriminator values. For example:

    union Z switch(boolean)
    { 
      case TRUE: 
        short s; 
    };
    

    In the previous union, it is possible to set the discriminator to FALSE. When that occurs, the union's value is composed solely of the discriminator value FALSE.
    The new XTypes specification has several issues concerning unions like the one before:
    It is not clear that you can set the discriminator to a value that is not associated with an union member. For example, can you set the discriminator to FALSE in the union Z?.
    The assignability rules may break assignability of a union object to itself. For example, with the previous UNION, if a received sample has a discriminator value of FALSE, it will be dropped according to the following rule in the Behavior column in table 15:
    If the discriminator value does not select a member in T1 then the T2 object is unassignable to T1.

  • Reported: DDS-XTypes 1.1 — Wed, 26 Feb 2014 05:00 GMT
  • Disposition: Duplicate or Merged — DDS-XTypes 1.2
  • Disposition Summary:

    Duplicates DDSXTY12-119

    This issue is being merged into the a broader issue (DDSXTY12-119) that seeks to make the assignability rules simpler and less restrictive. The resolution of DDSXTY12-119 issue includes changes to the Union assignability rules which addressed the concerns DDSXTY12-5 raises.

  • Updated: Thu, 22 Jun 2017 16:42 GMT

Applicable key types not clearly specified

  • Legacy Issue Number: 18293
  • Status: closed  
  • Source: ZettaScale Technology ( Mr. Erik Hendriks)
  • Summary:

    In section 7.2.2.3.5.6 it is stated that every member of a struct can act as key. If that is indeed the case, then keys could be set on attributes of type sequence or union for which the resulting behaviour is not clearly specified. (For example, how to compare a key from a sequence of length 1 to a key of a sequence of length 2? How to compare unions that have the same discriminator but different branch values? How to compare unions that have different discriminator values that map onto the same branch?)

    Either setting keys on sequence and union attributes should be prohibited, or the resulting behaviour should clearly be specified.

  • Reported: DDS-XTypes 1.1 — Wed, 12 Dec 2012 05:00 GMT
  • Disposition: Resolved — DDS-XTypes 1.2
  • Disposition Summary:

    Specify members of type Union, Array and Sequence can be keys

    Unions types can either be keyed or not. If keyed, the only union attribute that can form part of the key is the discriminator as it is the only attribute guaranteed to always be there.

    To indicate a union has a key the discriminator is annotated with the @key. See 7.3.1.2.2 (the switch in the union can have annotations).

    If the Union had not declared a key (its discriminator as key). Then it is unkeyed. And when used as a member and marked as key the whole value (discriminator included) would form the key.

    Allow BitSet, Arrays and Sequence member to be used as keys. Those are simple. But not maps. These could be added later if the need arises.

  • Updated: Thu, 22 Jun 2017 16:42 GMT

DataRepresentationQosPolicy is making the application responsible for transport

  • Legacy Issue Number: 18306
  • Status: closed  
  • Source: ZettaScale Technology ( Mr. Erik Hendriks)
  • Summary:

    Using a QosPolicy like DataRepresentationQosPolicy is breaking the abstraction between application and transport. This is fine if the application is managing its own transport, but not if the transport is implemented by some external service. We see no reason why this policy should be implemented as part of the XTypes specification as cleary it has no relationship to type extensibility.

  • Reported: DDS-XTypes 1.1 — Wed, 12 Dec 2012 05:00 GMT
  • Disposition: Closed; No Change — DDS-XTypes 1.2
  • Disposition Summary:

    Issue was withdrawn by the originating company

    Upon discussion during RTF the issue was withdrawn by the originating company.

  • Updated: Thu, 22 Jun 2017 16:42 GMT

A @Version annotation shall be added

  • Legacy Issue Number: 18145
  • Status: closed  
  • Source: ZettaScale Technology ( Angelo Corsaro, PhD.)
  • Summary:

    The X-Types specification does not provide any way of attaching version information to topic types. This is unfortunate as this information is quite essential to help debug running systems by identifying which version of the information model each element is working with.

    As a consequence a new annotation @Version should be added for topic types. A possible definition of this annotation is shown below:

    @Annotation
    local interface Version

    { attribute unsigned long major; attribute unsigned long minor; attribute unsigned long patch_level; }

    ;

  • Reported: DDS-XTypes 1.1 — Mon, 8 Oct 2012 04:00 GMT
  • Disposition: Resolved — DDS-XTypes 1.2
  • Disposition Summary:

    Add a @Version annotation

    The RTF discussed what the purpose of the @version annotation was and it was determined the value comes from situations were there is a single authority/governance body that controls the type system.

    In this situation, having some "version" annotation that can distinguish intentional changes/evolutions of a type versus some error can be a useful "system integration" aid. The idea is that each time someone modifies a type in a system it would tag it with some "application meaningful" (it could be a version number like major.minor.revision, or a date, or some other label). Then duding deployment when compatibility of types between DataWriter and DataReaders is examined this additional tag is available.

    Type compatibility is determined using the "assignability rules" this done independent of the version number/tag. In addition to this:

    • If the tags are different (or absent in one side) then there no additional things to do.
    • If the tags are the same but the types are not identical, then this could trigger some warning/errors coming via DDS status/listeners. The fact that the same version tag was used indicated the application was trying to use the same version of the types for that writer/reader. The fact that they did not match indicates that there was some process error and somehow the two applications ended up with different types.

    There was agreement in the RTF that this was a useful feature, but leaving the version as an "unstructured" string. Without adding version numbers, dates, etc. It just needs to be checked for equality and it is up to the people defining the type system to create their own convention.

    The RTF discussed whether it made change to have a different behavior at the DDS level. The most "obvious" one suggested was to force "mismatched type" error for types that were assignable/compatible but not identical if their version tag was the same. Idea is similar to the compiler option of "error on warnings". Make it harder for people to deploy systems with this type of inconsistency. At the same time it was agreed that most of the benefit of this feature could be obtained using a tool that would monitor the types and detect that inconsistency. And this would not require a forceful change in matching behavior.

    The RTF agreed to add the @version annotation and describe the intended use, but not force any implementation behaviors. It would be up to vendors to provide tools around this or support a "error" behavior on those types with identical version and non-identical structure... If in the future the vendors determine that the "fail" behavior is important to support and must be made interoperable then it can easily be added without breaking deployed system

  • Updated: Thu, 22 Jun 2017 16:42 GMT

Key order should be defined using the @Key annotation

  • Legacy Issue Number: 18144
  • Status: closed  
  • Source: ZettaScale Technology ( Angelo Corsaro, PhD.)
  • Summary:

    The X-Types specification had left under-defined mechanism to be used for specifying the order of key attributes.

    The solution adopted by the FTF was to simply use the member ID to define such an order, but this is not optimal.

    We strongly suggest to define @Key annotation as follows:

    @Annotation
    local interface Key

    { attribute unsigned long value; attribute boolean value default true; }

    ;

    Where the value attribute is used to define a total order among the key attributes.

  • Reported: DDS-XTypes 1.1 — Mon, 8 Oct 2012 04:00 GMT
  • Disposition: Closed; No Change — DDS-XTypes 1.2
  • Disposition Summary:

    No change as it could be done as a vendor extension without affecting portability/interoperability

    Ordering of the keys for the purpose of sorting is something that can be handled internally by each vendor since there are no APIs in DDS that specify an order relative to the key order (e.g. the read_next_instance() specifies an order "by instance handle" which is not explicitly mapped to keys).
    In other words, a vendor could add an annotation e.g. @key_order to define the order and use that to optimize how samples are stored in the cache but it would not affect portability or interoperability.

    Making it part of the key definition itself would render types as incompatible as a result of something that seems more like a local optimization of a cache in a specific application which would not affect applications in other nodes.

  • Updated: Thu, 22 Jun 2017 16:42 GMT

Allow empty structures

  • Legacy Issue Number: 19274
  • Status: closed  
  • Source: Real-Time Innovations ( Sumant Tambe)
  • Summary:

    Allow empty structures as part of the XTypes spec. XTYPES spec it does not require structures to have any members. It is not explicit about this but it does say they
    can have any number of members (including zero). The IDL syntax. XTYPES uses IDL as one of the ways to express types so if the IDL grammar specifies made empty structures
    illegal we would have an inconsistency between what the X-TYPES type-system says and what the IDL grammar supports...
    Looking at the IDL syntax in the X-Types it defines:
    <struct_type> ::= <struct_header> “

    {” <member_list> “}

    The <member_list> refers to the production on the IDL spec (X-TYPES
    only lists the new productions or the ones that are modified from
    IDL), the <struct_type> is modified in XTYPES to support inheritance,
    hence its appearance in the XTYPES duc but the <member_list> is
    unchanged.

    In IDL 3.5 <member_list> is defined as:

    <member_list>::=<member>+

    Which does seem to indicate that empty structures are not supported.

  • Reported: DDS-XTypes 1.1 — Wed, 26 Feb 2014 05:00 GMT
  • Disposition: Closed; Out Of Scope — DDS-XTypes 1.2
  • Disposition Summary:

    The change should be applied to IDL 3.5/IDL4

    Supporting empty structures is desired to facilitate the mapping from other data-models that may support them in that sense the type system in XTYPES is already doing the right thing and it is IDL the one that needs to change...

    Given that the plan is to remove the IDL syntax extensions from XTYPES and have XTTPES reference IDL4+ instead. It is best to close this issue here with "NoChange" and instead file an issue with IDL4 to add support for empty structures.

  • Updated: Thu, 22 Jun 2017 16:42 GMT

member ID algorithm flawed

  • Legacy Issue Number: 18298
  • Status: closed  
  • Source: ZettaScale Technology ( Mr. Erik Hendriks)
  • Summary:

    In section 7.3.1.3.1 is is stated that when explicitly assigning memberID's to some attributes (but not to all attributes), that:

    "In such cases, implicit values are assigned in a progression starting from the most-recently specified ID (or an implicit value of zero for the first constant, if there is no previous specified value) and adding one with each successive member."

    This algorithm could result in the same memberId being assigned multiple times. Consider the following example:

    struct A

    { long x; //@id 2 long y; //@id 1 long z; }

    ;

  • Reported: DDS-XTypes 1.1 — Wed, 12 Dec 2012 05:00 GMT
  • Disposition: Resolved — DDS-XTypes 1.2
  • Disposition Summary:

    Add clarifying text to section 7.3.1.3.1

    The main part of this issue is addressed in DDSXTY12-18. Therefore, the only thing we need to do here is clarify the member ID rules.

  • Updated: Thu, 22 Jun 2017 16:42 GMT

IDL annotation syntax does specify how to use Any member type

  • Legacy Issue Number: 19144
  • Status: closed  
  • Source: Remedy IT ( Martin Corino)
  • Summary:

    According to the Type System model in chapter 7.2.2. the Any type is allowed as an annotation member type.
    The IDL syntax does however not specifiy if and how that type could ever be used in IDL.
    Since standard IDL has now way to declare an Any value it seems logical that the IDL syntax should specify the Any type off limits for annotation types declared in IDL.

  • Reported: DDS-XTypes 1.1 — Sun, 15 Dec 2013 05:00 GMT
  • Disposition: Resolved — DDS-XTypes 1.2
  • Disposition Summary:

    Clarify the IDL type "Any" is not part of the DDS-XTYPES type system

    This issues seems is the result of a confusion in the interpretation of the word "Any" when it is used in Section 7.2.2.3.6 (Annotation Types). That section says that the members of annotation types are restricted to certain types.
    These are:

    • Any Primitive type
    • Any String type of Char8 or Char32 elements
    • Any enumerated type

    In the above the word "Any" is used as an adjective and not to mean the type represented by the IDL "Any" keyword.

    To avoid this ambiguity the issue resolution will reword the bullet points removing the word "Any".

  • Updated: Thu, 22 Jun 2017 16:42 GMT

Annotation member default declaration not compatible with Legacy IDL

  • Legacy Issue Number: 19143
  • Status: closed  
  • Source: Remedy IT ( Martin Corino)
  • Summary:

    The DDS XTypes IDL Type representation spec defines an "alternative" annotation declaration for use with legacy IDL. This alternative syntax is however not compatible with legacy IDL compilers because it does not take into account that legacy attribute declarations do not support the 'default' value declaration used in the annotation syntax.
    To be compatible it should be specified that for the legacy syntax the attribute default declaration is not allowed.

  • Reported: DDS-XTypes 1.1 — Sun, 15 Dec 2013 05:00 GMT
  • Disposition: Duplicate or Merged — DDS-XTypes 1.2
  • Disposition Summary:

    Merge with DDSXTY12-122

    DDSXTY12-34 is to be addressed as part of the broader issue of aligning the XTypes specification with the IDL4 Specification (DDSXTY12-122).

  • Updated: Thu, 22 Jun 2017 16:42 GMT

Builtin topics not backward compatible

  • Legacy Issue Number: 18310
  • Status: closed  
  • Source: ZettaScale Technology ( Mr. Erik Hendriks)
  • Summary:

    Builtin topics are not backward compatible with the DDS1.2 spec (not even according to the rules of the Extensible types spec itself).

    As an example, the BuiltinTopicKey_t array has been extended from 3 elements to 4 elements. This breaks compatibility with respect to non-xTypes compliant versions of a DDS product, and it is not cleared up why the keyfield suddenly required this extra element.

  • Reported: DDS-XTypes 1.1 — Wed, 12 Dec 2012 05:00 GMT
  • Disposition: Resolved — DDS-XTypes 1.2
  • Disposition Summary:

    Modify definition of BuiltinTopicKey_t to align it with RTPS spec

    In appendix D modify the BuiltinTopicKey_t to be wire-representation compatible with the RTPS spec.

  • Updated: Thu, 22 Jun 2017 16:42 GMT

Expose assignability options for ignoring member names and sequence lengths

  • Status: closed  
  • Source: Real-Time Innovations ( Sumant Tambe)
  • Summary:

    The XTypes spec is too restrictive because it does not allow ignoring member names and sequence length in type compatibility. The spec should provide such flexibility. TypeEnforcementQoSPolicy should be extended to allow more flexibility.

  • Reported: DDS-XTypes 1.1 — Fri, 9 Oct 2015 20:59 GMT
  • Disposition: Resolved — DDS-XTypes 1.2
  • Disposition Summary:

    Include support for ignoring member names

    Ignoring member names in type consistency enforcement is a desirable QoS policy. Extended the TypeConsistencyEnforcementPolicy with a boolean condition. Updated section 7.6.2.3.2 and Annex D.

  • Updated: Thu, 22 Jun 2017 16:42 GMT

Keyhash computation not well-defined for mutable types

  • Status: closed  
  • Source: Real-Time Innovations ( Sumant Tambe)
  • Summary:

    Keyhash computation is not specified precisely enough. For instance, for mutable types it is not clear whether to use short/long parameter IDs and for PID_SENTINEL whether to set must-understand bit = 1/0? As a result, the keyhash for the same key may be different from different vendors.

  • Reported: DDS-XTypes 1.1 — Fri, 9 Oct 2015 20:53 GMT
  • Disposition: Resolved — DDS-XTypes 1.2
  • Disposition Summary:

    Update keyhash computation for mutable types

    Removed ambiguities from keyhash computation algorithm for mutable types. Specifically the following ambiguities existed.

    1. Whether to use short/long parameter encapsulation
    2. What's the value of must-understand bit in PID_SENTINEL.

    Both ambiguities are avoided using the revised algorithm.

  • Updated: Thu, 22 Jun 2017 16:42 GMT

specify language-specific bindings may exist

  • Status: closed  
  • Source: Real-Time Innovations ( Sumant Tambe)
  • Summary:

    Include a sentence in section 7.5 Language Binding that language-specific PSMs might overrule some or all of the language binding rules specified below.

  • Reported: DDS-XTypes 1.1 — Thu, 10 Sep 2015 21:56 GMT
  • Disposition: Resolved — DDS-XTypes 1.2
  • Disposition Summary:

    Added clarification

    Added clarification in section 7.5 first paragraph.

  • Updated: Thu, 22 Jun 2017 16:42 GMT

One sentence split in two bullets

  • Legacy Issue Number: 19587
  • Status: closed  
  • Source: Remedy IT ( Johnny Willemsen)
  • Summary:

    As part of section 7.2.2.3.7.1 the last two bullets should be one, so change

    • The string “*” (an asterisk) shall indicate that
    • text applies to all programming languages.

    to

    • The string “*” (an asterisk) shall indicate that text applies to all programming languages.

  • Reported: DDS-XTypes 1.1 — Tue, 26 Aug 2014 04:00 GMT
  • Disposition: Resolved — DDS-XTypes 1.2
  • Disposition Summary:

    *Incorporated editorial changes *

    Editorial change in Section 7.2.2.3.7.1 bullet #4

  • Updated: Thu, 22 Jun 2017 16:42 GMT

Spec should allow any value for the Optional flag in TypeObject union members

  • Key: DDSXTY12-6
  • Legacy Issue Number: 19266
  • Status: closed  
  • Source: Real-Time Innovations ( Sumant Tambe)
  • Summary:

    By definition, union members are always optional. The spec should allow implementations to decide whether union members include the optional flag as part of the TypeObject member flags. In any case, implementations should ignore that flag for equality and type-compatibility purposes.

  • Reported: DDS-XTypes 1.1 — Wed, 26 Feb 2014 05:00 GMT
  • Disposition: Duplicate or Merged — DDS-XTypes 1.2
  • Disposition Summary:

    Duplicates DDSXTY12-11

    Duplicates DDSXTY12-11

  • Updated: Thu, 22 Jun 2017 16:42 GMT

Optional flag in TypeObject union members

  • Legacy Issue Number: 19273
  • Status: closed  
  • Source: Real-Time Innovations ( Sumant Tambe)
  • Summary:

    By definition, union members are always optional. The spec should allow implementations to decide whether union members include the optional flag as part of the TypeObject member flags. In any case, implementations should ignore that flag for equality and type-compatibility purposes

  • Reported: DDS-XTypes 1.1 — Wed, 26 Feb 2014 05:00 GMT
  • Disposition: Duplicate or Merged — DDS-XTypes 1.2
  • Disposition Summary:

    Duplicates DDSXTY12-11

    Duplicates DDSXTY12-11

  • Updated: Thu, 22 Jun 2017 16:42 GMT

Optional flag in TypeObject union members

  • Legacy Issue Number: 19271
  • Status: closed  
  • Source: Real-Time Innovations ( Sumant Tambe)
  • Summary:

    By definition, union members are always optional. The spec should allow implementations to decide whether union members include the optional flag as part of the TypeObject member flags. In any case, implementations should ignore that flag for equality and type-compatibility purposes.

  • Reported: DDS-XTypes 1.1 — Wed, 26 Feb 2014 05:00 GMT
  • Disposition: Resolved — DDS-XTypes 1.2
  • Disposition Summary:

    Indicate the TypeObject union sets the member's isOptional flag to false.

    Union members shall have the IS_OPTIONAL set to 0 since the semantic is that if a member is selected then it has to be present.

    In the future we may want to support the @optional annotation on the union member to indicate that the selected member could be omitted. This is currently not supported in the IDL syntax. However if this were to change in the future, the future version of XTYPES could support it by setting the IS_OPTIONAL flag to 1 for those members.

    Furthermore indicate only the discriminator member can be declared as a key member for the union.

  • Updated: Thu, 22 Jun 2017 16:42 GMT

The description for union types are not complete

  • Key: DDSXTY12-4
  • Legacy Issue Number: 19264
  • Status: closed  
  • Source: Real-Time Innovations ( Sumant Tambe)
  • Summary:

    For Union Types the xTypes spec does not handle the following two cases:
    What is the criteria to select a value for the discriminator when a default case is specified?
    What happens if a default case label is specified when the set of case labels completely covers all the possible values for the discriminator.
    Note: This information is stated in section 1.9 (Mapping for Union) of the IDL to Java spec.
    If the branch corresponds to the default case label, then the simple modifier for that
    branch sets the discriminant to the first available default value starting from a 0 index
    of the discriminant type.
    It is illegal to specify a union with a default case label if the set of case labels
    completely covers the possible values for the discriminant*. It is the responsibility of
    the Java code generator (e.g., the IDL complier, or other tool) to detect this situation
    and refuse to generate illegal code.
    Proposal to determine what is the default value for a union discriminator:
    If there is no default case value, the default discriminator value is the lowest value associated with any union member. If the discriminator type is an enumeration, the value is the enumerator with the lowest ordinal.
    if there is default case value:
    For integer, boolean, byte, char, wchar: The default discriminator value is the first available value starting from a 0 value of the discriminant type.
    For enumerations: The default discriminator value is the first enumerator in the order declared in the enumeration that is not associated with any case value.

  • Reported: DDS-XTypes 1.1 — Thu, 27 Feb 2014 05:00 GMT
  • Disposition: Duplicate or Merged — DDS-XTypes 1.2
  • Disposition Summary:

    Duplicates DDSXTY-12-5

    Duplicates DDSXTY-12-5

  • Updated: Thu, 22 Jun 2017 16:42 GMT

lookup_topicdescription semantics make it unusable

  • Legacy Issue Number: 18309
  • Status: closed  
  • Source: ZettaScale Technology ( Mr. Erik Hendriks)
  • Summary:

    Section 7.6.3.2 specifies that lookup_topicdescription returns 1 matching representation. On multiple matches, an arbitrary representation is returned.

    This is not helpful in any way for an application trying to access a certain representation. Either its signature should be changed to return a sequence of topic representations, or it should cyclically go over each representation and return 1 at a time, so that subsequent invocations may return different representations.

  • Reported: DDS-XTypes 1.1 — Wed, 12 Dec 2012 05:00 GMT
  • Disposition: Resolved — DDS-XTypes 1.2
  • Disposition Summary:

    Clarified semantics of lookup_topicdescription

    Added clarifications in section 7.6.3.2. and enhanced PIM-to-PSM mapping for this operation as described in the revised text.

  • Updated: Thu, 22 Jun 2017 16:42 GMT

Multiplicity mismatch between TypeName and TypeObject

  • Legacy Issue Number: 18307
  • Status: closed  
  • Source: ZettaScale Technology ( Mr. Erik Hendriks)
  • Summary:

    The builtin topics have 2 ways to identify the type to which they apply: a string called type_name and a TypeObject alled type. The string can only relate to 1 type, while the TypeObject could refer to more than 1 type.

    If the type_name is not uniquely identifying a type, then what is the use of having a type_name in the builtin topics for Reader and Writer? The topic_name already refers to a DCPSTopic sample that has a similar type_name.

    Furthermore, in the spec it is assumed that Readers/Writers just make the TypeObject refer to just 1 type, while the Topic could make it refer to more than one. This is not orthogonal, so wouldn't it be better to make a TypeObject refer to 1 type and give the DCPSTopic a sequence of TypeObjects instead?

  • Reported: DDS-XTypes 1.1 — Wed, 12 Dec 2012 05:00 GMT
  • Disposition: Resolved — DDS-XTypes 1.2
  • Disposition Summary:

    ChangeType object to refer to a single TypeId

    Modify Annex B to correct the multiplicity of the TypeId. The TypeObject struct (Annex B) shall be updated to include just a single typeid instead of a sequence of typeids.

    The TopicBuiltinTopicData, PublicationBuiltinTopicData, and SubscriptionBuiltinTopicData already includes an optional TypeObject member. The specification shall include a guideline/warning that absent TypeObject it is not possible to ensure type compatibility

  • Updated: Thu, 22 Jun 2017 16:42 GMT

Shareable members underspecified

  • Legacy Issue Number: 18295
  • Status: closed  
  • Source: ZettaScale Technology ( Mr. Erik Hendriks)
  • Summary:

    There are some questions regarding shared members that should clearly be addressed in this section:

    • Are shareable members always implemented as pointers in the way optional members are?
    • If so, can a shareable member be NULL?
    • If so, then is a shareable member not by definition also an optional member?
    • What will happen when I pass object graphs, even when the last sentence warns against this? (e.g. marshaling into 1 big blob anyway, passing an error, etc.)
    • May a shareable member be, or contain a key?
  • Reported: DDS-XTypes 1.1 — Wed, 12 Dec 2012 05:00 GMT
  • Disposition: Resolved — DDS-XTypes 1.2
  • Disposition Summary:

    Added clarification for Shareable members

    Updated the description in section 7.3.1.3.4.

  • Updated: Thu, 22 Jun 2017 16:42 GMT

Circular dependencies across types should be allowed

  • Key: DDSXTY12-8
  • Legacy Issue Number: 19268
  • Status: closed  
  • Source: Real-Time Innovations ( Sumant Tambe)
  • Summary:

    The XTypes spec does not make clear whether or not circular dependencies across types are allowed. They should be allowed.

  • Reported: DDS-XTypes 1.1 — Wed, 26 Feb 2014 05:00 GMT
  • Disposition: Duplicate or Merged — DDS-XTypes 1.2
  • Disposition Summary:

    Added clarification for Shareable members

    The necessary clarifications for this issue are added in section 7.3.1.3.4 Shareable Data through a different issue DDSXTY12-21.

    Essentially, circular dependencies are allowed but the m/w is not required to detect or warn against such uses.

  • Updated: Thu, 22 Jun 2017 16:42 GMT

TypeId calculation errors/corrections

  • Key: DDSXTY12-7
  • Legacy Issue Number: 19267
  • Status: closed  
  • Source: Real-Time Innovations ( Sumant Tambe)
  • Summary:

    Section 7.3.4.1.2 Type Hierarchy in the XTypes spec explains how to calculate the TypeId for a given type.
    The description provided contains errors and ambiguities that must be resolved.
    1.- The spec explains that the TypeId of a constructed type is calculated by serializing the type in big-endian CDR data representation. However, the TypeId itself is part of the Type (ArrayType, StructureType). We cannot serialize without the TypeId and we cannot get the TypeId without serializing.
    To resolve this problem I am setting the Type's TypeId to the following value before serializing:
    RTI_CDR_TYPE_OBJECT_NO_TYPE (for the discriminator)
    RTI_CDR_TYPE_OBJECT_NO_TYPE_ID (for the union value)
    2.- The Type (ArrayType, StructureType) also has a member containing the type name (not fully qualified). The value of this member is used to calculate the TypeId. Since the name is not fully qualified, two identical types within different modules will have the same TypeId. The question is whether or not the type name should be used as part of the TypeId calculation.
    If the type name must be used as part of the calculation and it discriminates, then we will have to use the fully qualified name. Otherwise two identical types within different modules would get same TypeId.
    If the type name should not be used as part of the calculation then we can set it to the empty string for TypeId calculation purposes.
    According to the XTypes spec:
    "To allow types to refer to one another unambiguously, a given TypeId value shall uniquely identify a type within the TypeLibrary contained by a TypeObject object and in any other Type Libraries contains recursively therein. It shall have no narrower scope. There is no restriction that a type's definition must occur a TypeId reference to it; there is no concept of a forward declaration in this Type Representation."
    Therefore, two types within the library should not contained the same TypeId.
    3.- Also, the serialization in BigEndian of the TypeObject is not guaranteed to be the same across different DDS vendors since the TypeObject itself is a mutable type and therefore it requires parametrized encapsulation for its members. The choice of extended versus not extended parameter encapsulation may be different across different DDS vendors.

  • Reported: DDS-XTypes 1.1 — Wed, 26 Feb 2014 05:00 GMT
  • Disposition: Resolved — DDS-XTypes 1.2
  • Disposition Summary:

    New TypeID computation algorithm

    The previous algorithm included in the specification is not implementable because it causes inadvertent recursive dependency of type-id on themselves. The new computation of the TypeId has been defined such that all vendors compute the same values for the same types. See section 7.3.4.1.2 in the specification document.

  • Updated: Thu, 22 Jun 2017 16:42 GMT
  • Attachments:

XML type description not orthogonal and not consistent

  • Legacy Issue Number: 18302
  • Status: closed  
  • Source: ZettaScale Technology ( Mr. Erik Hendriks)
  • Summary:

    The XML description of a type seems cumbersome and not orthogonal. I have lots of questions regarding it. Why do we propose 2 separate XML representations (Valid and Well-formed) that both have obvious flaws instead of 1 XML representation that satisfies the requirements of both representations? PrismTech has written an extensive proposal on how represent the types in XML that is both valid, well-formed and orthogonal. I would propose to give that proposal a thought. (Can't attach the document to this ticket, but I will gladly make it available. Angelo also has access to that document

  • Reported: DDS-XTypes 1.1 — Wed, 12 Dec 2012 05:00 GMT
  • Disposition: Resolved — DDS-XTypes 1.2
  • Disposition Summary:

    Clarified both xml data representations

    Resolutions applied: Added the revised text in section 7.4.2.2

  • Updated: Thu, 22 Jun 2017 16:42 GMT

Type system severely underspecified

  • Legacy Issue Number: 18301
  • Status: closed  
  • Source: ZettaScale Technology ( Mr. Erik Hendriks)
  • Summary:

    In section 7.3.4.1.2 it is specified how to calculate the type ID for a given type. However, this algorithm heavily depends on the Type layout presented in Appendix B, which is not further explained. I have lots of questions about this algorithm, and am wondering if alternative mechanisms should not be considered instead.

    1) Where does the hash that identifies the typeID of a constucted type come from?

    It states that it comes from the Big Endian CDR respresentation of the type, which is an IDL representation of the model specified in Appendix B. However, this data model is not further explained, and far from mature and orthogonal. It looks like we created a pretty ad-hoc type system rather than deriving one from a well-designed meta-model with a minimal set of powerful transformation primitives.
    There is a lot of existing documentation on how to set up a proper type-system. I suggest we consult some best-practices instead of re-inventing the wheel here.

    2)The basis of the TypeObject consists of 2 fields, each having their own sequence. How the 2 sequences correlate is not further explained. The only thing that is explained in section 7.6.2.2 is that the the_type member of the TypeObject contains all types associated with the corresponding entity (1 for reader/writer, more for topic). I think it would be better to take this sequence outside TypeObject and give Topic a sequence of TypeObjects instead.

  • Reported: DDS-XTypes 1.1 — Wed, 12 Dec 2012 05:00 GMT
  • Disposition: Duplicate or Merged — DDS-XTypes 1.2
  • Disposition Summary:

    TypeId algorithm proposed

    See RTI's TypeId proposal attached to Issue #7: TypeId calculation errors/corrections. TypeId computation has been unambiguously specified.

  • Updated: Thu, 22 Jun 2017 16:42 GMT

TypeObject semantics underspecified and inconsistent

  • Legacy Issue Number: 18300
  • Status: closed  
  • Source: ZettaScale Technology ( Mr. Erik Hendriks)
  • Summary:

    Section 7.3.4.1 specifies that a TypeObject can include just a single TypeLibrary while in section 7.3.4.1.1 it is claimed that a TypeObject can recursively contain other TypeLibraries.

    Of course this is confusing: which is it?

    Also does a typeID need to be globally unique or just in the TypeLibrary in which it is contained?

    Finally, and even more important, since the TypeObject may recursively refer to other (existing) types by their typeID, it is difficult to communicate the meta-data to a node that has no a-priori knowledge about it. The current TypeObject representation is compact, but only able to check whether two existing representations are compatible. It can't be used to drive meta-data based tooling a logger or a service that connects the DDS to a database.

  • Reported: DDS-XTypes 1.1 — Wed, 12 Dec 2012 05:00 GMT
  • Disposition: Resolved — DDS-XTypes 1.2
  • Disposition Summary:

    Added clarification for TypeLibrary

    Added clarification in section 7.3.4.1 that a single TypeLibrary which may recursively contain more TypeLibrary objects

  • Updated: Thu, 22 Jun 2017 16:42 GMT

Definition of "strongly assignable" seems to be used inconsitently

  • Legacy Issue Number: 18297
  • Status: closed  
  • Source: ZettaScale Technology ( Mr. Erik Hendriks)
  • Summary:

    if strongly assignable according to section 7.2.4 means that both types should be mutable, then why is the union in Table 15 (section 7.2.4.5, fifth bullet in 2nd column) talking about strong assignability for a T1 that is final or extensible?

    • Probably the definition for strongly typed is flawed, and should be about NON-mutable types.

    Generally speaking, the overall wording of the subject regarding strong assignability could is causing more confusion than it is clearing things up, and could use some big improvement.

    Lots of usecases regarding this subject are underspecified, for example:

    • If a type T1 is assignable from a type T2, and T1 has a non-optional member that is not represented in T2, it takes the default (non-configurable) default.
      How can I see the difference between a T1 with a member, that happens to be the default, and a T1 without that member?
      Since 0 is a very common value, it does not seems like a good candidate for default in this case.
  • Reported: DDS-XTypes 1.1 — Wed, 12 Dec 2012 05:00 GMT
  • Disposition: Resolved — DDS-XTypes 1.2
  • Disposition Summary:

    Clarified definition of strongly assignable

    Updated section 7.2.4 with clearer definition of strongly assignable. Also updated union_type in Table 15 section 7.2.4.5 Aggregation Types.

  • Updated: Thu, 22 Jun 2017 16:42 GMT

TypeId union is missing NO_TYPE from the possible values of the discriminator

  • Key: DDSXTY12-3
  • Legacy Issue Number: 19263
  • Status: closed  
  • Source: Real-Time Innovations ( Sumant Tambe)
  • Summary:

    The TypeId union declaration in Annex B is missing the value NO_TYPE as one possible discriminator. In addition, the use cases for the usage of that value are not documented.
    Assuming that we add a TypeId paramater to the endpoint information in addition to the type object. See issue "Send TypeId independently of the TypeObject". In a situation in which no type object or type id paramaters are found, we could indicate that to the user by providing a NO_TYPE TypeId as part of the PublicationBuiltinTopicData or SubscriptionBuiltinTopicData.

  • Reported: DDS-XTypes 1.1 — Wed, 26 Feb 2014 05:00 GMT
  • Disposition: Duplicate or Merged — DDS-XTypes 1.2
  • Disposition Summary:

    Merged with DDSXTY12-7

    Merged with issue DDSXTY12-7, which adds NO_TYPE case in _TypeId union.

  • Updated: Thu, 22 Jun 2017 16:42 GMT

Send TypeId independently of the TypeObject

  • Key: DDSXTY12-2
  • Legacy Issue Number: 19262
  • Status: closed  
  • Source: Real-Time Innovations ( Sumant Tambe)
  • Summary:

    Sending large TypeObjects is often an issue in discovery. Often times, the complete TypeObjects are not necessary as TypeId might just do the trick when exact matches are expected. Therefore, sending just the typeid is a good optimization.

    Therefore, add new discovery parameter in Publication and Subscription BuiltInTopicData to send the TypeId independently of the type object.

    Two use cases:
    1. Even if we cannot find type object at least we can verify typeId
    2. Allow a separate mechanism to get the TypeObject. This will help to reduce bandwidth

  • Reported: DDS-XTypes 1.1 — Wed, 26 Feb 2014 05:00 GMT
  • Disposition: Resolved — DDS-XTypes 1.2
  • Disposition Summary:

    Incorporated new TypeId algorithm

    A new typeid computation algorithm was added in section 7.3.4.1.2. Updated built-in topics with an optional typeid field. See revised text for details.

  • Updated: Thu, 22 Jun 2017 16:42 GMT

Topic incosisstency only considered for incompatible types, not for incompatible qos

  • Legacy Issue Number: 18308
  • Status: closed  
  • Source: ZettaScale Technology ( Mr. Erik Hendriks)
  • Summary:

    What if 2 topics have the same type, but different Qos? Would that still trigger an INCONSISTENT_TOPIC status or not? The spec does not say anything about this.

  • Reported: DDS-XTypes 1.1 — Wed, 12 Dec 2012 05:00 GMT
  • Disposition: Closed; No Change — DDS-XTypes 1.2
  • Disposition Summary:

    Discussed clarifications

    The TF discussed clarifications and no changes are needed.

    Currently, the spec is clear about when inconsistent_topic status is raised. Only type (typeobject when present otherwise typename) is considered before raising the inconsistent topic status. One possibility to incorporate QoS in the mix would be to create yet another kind of status for topics. Right now it has only one. For DR and DW, there’s already inconsistent_requested_qos and inconsistent_offer_qos statuses. May be the new status could be a variant of those. It can’t be any of those however because (1) TopicQoS does not contain all QoS (2) TopicListener is a separate inheritance branch and (3) offered/requested semantics are not knowable at topic level because we don’t know what kind of entity might be created (so we can’t do as good a job as we do for entity’s inconsistent_requested/offered_qos statuses.)

  • Updated: Thu, 22 Jun 2017 16:42 GMT

Specification document cleanup

  • Key: DDSXTY12-1
  • Legacy Issue Number: 19261
  • Status: closed  
  • Source: Real-Time Innovations ( Sumant Tambe)
  • Summary:

    1. Remove references to type signature in XType specification: The concept of type signature has been removed from the XTypes specification. See OMG Issue No: 16561. However there are still references to it in the latest spec.
    List of references:
    Figure 39 - Dynamic Type Support
    Annex D: DDS Built-in Topic Data Types - Remove references to equivalent_type_name and base_type_name from PublicationBuiltinTopicData, SubscriptionBuiltinTopicData and TopicBuiltinTopicData

    2. Replace the definition of the_type within TypeObject from TypeIdSeq to _TypeId:
    In the final version of "OMG Issue No: 16097" the spec allows association of one type to an endpoint to simplify implementations.
    However, the spec kept the member "the_type" as a sequence instead of going back to a single element.

    3. Error in IDL definition of TypeObject: Definition of MapType, SequenceType, and StringType and in Annex B is marked as EXTENSIBLE but it should be MUTABLE.

    4. The "type" member in SubscriptionBuiltinTopicData and PublicationBuiltinTopicData should have "DynamicType" type instead of "TypeObject"

    Proposed Solution: Make the suggested changes.

  • Reported: DDS-XTypes 1.1 — Wed, 26 Feb 2014 05:00 GMT
  • Disposition: Resolved — DDS-XTypes 1.2
  • Disposition Summary:

    Incorporated corrections

    Document cleanup performed removing dangling elements and incorrect IDL structures.

  • Updated: Thu, 22 Jun 2017 16:42 GMT

Inconsistencies and missing items

  • Status: closed  
  • Source: Real-Time Innovations ( Dr. Gerardo Pardo-Castellote, Ph.D.)
  • Summary:

    In Section 7.2.3, Table 12 in the rows for "Collection Types", "Enumerated Types", "String Types", and "Primitive Types" should state that "For these types the extensibility kind has no effect."

    In the submission document, Table 21 "IDL Built-in Annotations" does not list where the annotation @hashid can be applied.
    Also, the @id annotation is can be applied to both Structure members and union members (except union discriminator), so it should be moved to the second row on the table.

    In Annex B in the IDL comment for AppliedBuiltinMemberAnnotations refers to “@hash_id” as opposed to “@hashid”, which is the actual annotation name. Every reference to “@hash_id” should be modified to refer to "@hashid."

  • Reported: DDS-XTypes 1.1 — Thu, 16 Mar 2017 00:38 GMT
  • Disposition: Deferred — DDS-XTypes 1.2
  • Disposition Summary:

    This Issue was not resolved in this Task Force and was automatically deferred to the next Task Force

  • Updated: Thu, 6 Apr 2017 14:10 GMT