Issues for Extensible and Dynamic Topic Types for DDS Finalization Task Force 1.0 mailing list

List of issues (green=resolved, yellow=pending Board vote, red=unresolved)

List options: All ; Open Issues only; or Closed Issues only

Issue 15418: DynamicData interface of the Language Binding section
Issue 15688: Can’t initialize TypeId from TypeKind
Issue 15689: Identifiers TypeId and Module collide with IDL keywords
Issue 15690: Definition of built-in IDL annotation @Shared is missing
Issue 15691: Unclear member names when programming language doesn’t support typedef
Issue 15692: Definition of type “Parameters” inadvertently missing
Issue 15693: Extensibility kinds of new QoS policies are not specified in a consistent way
Issue 15694: Updated QoS definitions should be provided
Issue 15695: Missing definitions of TypeSupport specializations for built-in types
Issue 15696: Incorrect FooDataWriter overloads for built-in types
Issue 15697: Consolidate IDL built-in annotations in machine-readable file
Issue 15698: Allow IDL compatibility pragma declarations to nest
Issue 15699: XML representations should define namespaces
Issue 15700: Mutable structures with an empty intersection should not be considered assignable
Issue 15701: Typographical errors
Issue 15702: Allow more flexible type consistency enforcement
Issue 15703: Don’t require CORBA namespace for primitive types in Plain Language Binding
Issue 15704: Provide formal grammar for new IDL Type Representation constructs
Issue 15705: Provide minimal backwards-compatible conformance point
Issue 15706: Reduce size of DynamicData API
Issue 15707: Improve support for shared data
Issue 15946: All IDL should use local interfaces
Issue 15969: Anonymous types should not be used in IDL examples and the TypeObject representation IDL
Issue 15976: Restrictions on MAP key element type not (clearly) documented/specified
Issue 15981: C++ mapping MAP type needs member access semantics specification
Issue 16007: DDS-XTypes @Key annotation Issue
Issue 16097: Different applications in the same domain may associate the same Topic with different types
Issue 16236: Annex D (“DDS Built-in Topic Data Types”) is out of sync with IDL file
Issue 16237: No way to get or set length of collection-typed DynamicData objects
Issue 16238: Type signature fields in built-in topic data shouldn't use unbounded strings
Issue 16239: Typographical errors
Issue 16240: Changing a DynamicType object is ambiguous
Issue 16241: Difficult to apply automation to statically defined types
Issue 16242: New QoS policies don’t indicate whether they can be changed
Issue 16243: Optional, must_understand members of non-mutable aggregation types cannot be accurately represented in CDR
Issue 16271: Incorrect default extensibility kind value in XSD file
Issue 16364: Ambiguous description of serializing discovery types
Issue 16365: Inconsistent bit set/integer equivalency
Issue 16366: Incorrect union assignability rules
Issue 16367: Definition of “strongly assignable” is incomplete
Issue 16368: Object assignability rules should be more resilient
Issue 16559: Inconsistent extensibility kind for enumerations
Issue 16561: New DDS-XTypes issue: inability to consume data using new base class
Issue 16720: Introduce the notional value "null" that may be used in a content-filter expression
Issue 17018: Rendering of UML diagrams in each of the figures is of poor graphical quality
Issue 17019: Truncation of text in Figure 3
Issue 17020: Non-standard UML notation on figures
Issue 17021: Conflicting data types applied to several Attributes, Operations and Parameters in UML notation
Issue 17022: Invalid data types applied to AnnotationDescriptor::value, DynamicData::descriptor, DynamicData::value
Issue 17023: Circular reference in definition of specialized Primitive Types
Issue 17090: Inconsistent generated code for DynamicType::descriptor
Issue 17293: Built-in annotations should be in DDS namespace
Issue 17294: Extended PID is not clear enough what the 2 value lengths mean
Issue 17295: Reserved parameter IDs in 7.4.1.2.1 are wrong
Issue 17296: Section 7.4.1.2.2 "Member ID-to-Parameter ID Mapping" is underspecified
Issue 17297: Extended parameters should be aligned the same as non-extended ones

Issue 15418: DynamicData interface of the Language Binding section (dds-xtypes-ftf)

First, thank you for this specification. It provides a systematic and comprehensive definition of the runtime type system which is  important in the context of  the next version of Experimental Physics and Industrial Control System (http://www.aps.anl.gov/epics/). Moreover, from my perspective, the conceptual idea of the dynamic container is more generic than DDS and EPICS and addresses other technologies, like AMQP. In this regard, I have several suggestions for the DynamicData interface of the Language Binding section, particularly, to scale down the number  of methods from 270 to 30 and to replace the 'out' arguments with return values. 


At this time, we are working on the prototype of this variant based on the consolidation of several approaches, including DDS Dynamic Data, Google's Protocol Buffers, etc. Certainly, for us, it would be ideal to have some common solution. According to the Beta 1 procedure, OMG will accumulate comments by November 29. But, probably, it can be discussed earlier, for example,  at the coming OMG technical meeting. Please advise. 

In the IDL definitions for the specification section Representing Types with TypeObject, the type TypeKind is declared to be an enumeration. The type TypeId is declared to be a typedef to long. Certain well-known TypeId values are initialized using TypeKind values. However, this causes compilation errors from some IDL compilers, which do not allow enumerated values to be assigned to integral constants. 
Resolution:
Change TypeKind from an enumeration to a typedef to short.

In the IDL definitions for the specification section Representing Types with TypeObject:
•	The type “TypeId” collides with the IDL keyword “typeid.”
•	The type “Module” and its member “module” collide with the IDL keyword “module.”
These collisions cause IDL compilation errors. 
Resolution:
Escape the identifiers TypeId and Module by preceding them with underscores. Per the IDL specification, this lexical change does not impact the generated code.
Rename the type member “module” to “mod” to prevent collisions either with the IDL keyword or with the name of the enclosing type.
Revised Text:
Replace the type identifier “TypeId” in the IDL file with “_TypeId” everywhere it occurs.
Replace the type identifier “Module” in the IDL file with “_Module” everywhere it occurs.
Replace the member identifier “module” (in the type “Module”) in the IDL file with “mod.”

The Type System defines a type member attribute shared, which indicates that a member should be stored by reference instead of by value to enable the use of external stores—for example, for large data members. This attribute appears in the TypeObject IDL definitions as a built-in annotation @Shared. However, this built-in annotation is never formally defined. (Possibly, it was deleted accidentally in a previous revision of the specification document.)
Resolution:
Add a section defining this built-in annotation to section 7.3.1.3, Built-in Annotations.

Summary:
In the IDL definitions for the specification section Representing Types with TypeObject, some members of type MemberId are named simply member, and some members of type TypeId are named simply type. The fact that the integral types of these members represent IDs is clear to readers of the IDL or to readers of generated code in languages that support typedef (such as C), because the type name is explicit. However, in Java and other programming languages that do not support typedef, the types of these members degrades to simply int (or another built-in integral type). This type obscures the meanings of the members.
Resolution:
Name the members in question more explicitly: member_id and type_id.
Revised Text:
Rename the following type members in the IDL file:
•	AnnotationUsageMember::member ? AnnotationUsageMember::member_id 
•	AnnotationUsage::type ? AnnotationUsage::type_id 
•	TypeProperty::id ? TypeProperty::type_id
•	MemberProperty::id ? MemberProperty::member_id
•	MemberProperty::type ? MemberProperty::type_id

The IDL definition of the type AnnotationDescriptor from the section Representing Types with TypeObject depends on a typedef “Parameters,” which is an alias to a string-to-string map. This type definition was present in earlier revisions of the IDL file but was inadvertently deleted in the adopted revision.
Resolution:
Restore the missing type definition.
Revised Text:
Add the following definition immediately before AnnotationDescriptor in the IDL file:
typedef map<ObjectName, ObjectName> Parameters;

The IDL file augments the DDS-standard QoS policies with meta-data defined by this specification in a way that is consistent with the serialization of those policies as defined by the DDS-RTPS specification. Specifically, it defines each policy to be “nested” (meaning that it is intended to be propagated only when contained within another type) to have an extensibility kind of EXTENSIBLE (meaning that members can be appended to the end of the type, but that members cannot be inserted in the middle or reordered).
In contrast, the two new QoS policies introduced by the specification—DataRepresentationQosPolicy and TypeConsistencyEnforcementQosPolicy—are defined to be nested, but their extensibility kinds are not specified. Per this specification, the kind EXTENSIBLE will be inferred by default but could be overridden by implementations. In order to be clear and avoid potential interoperability problems, these types should explicitly specify the extensibility kind EXTENSIBLE, just as all other policies do.
Resolution:
Add the built-in annotation @Extensibility(EXTENSIBLE_EXTENSIBILITY) to the definitions of DataRepresentationQosPolicy and TypeConsistencyEnforcementQosPolicy in the IDL file.

The specification dictates that the new QoS policies DataRepresentationQosPolicy and TypeConsistencyEnforcementQosPolicy apply to Topics, DataReaders, and DataWriters. These additions are reflected in the IDL file by the inclusion of corresponding members in the built-in topic data types TopicBuiltinTopicData, SubscriptionBuiltinTopicData, and PublicationBuiltinTopicData. Corresponding additions to TopicQos, DataReaderQos, and DataWriterQos are therefore implied, but updated definitions of those types are not provided in the IDL file.
Resolution:
Add the missing type definitions to the IDL file.
The type extensibility kinds of the QoS structures should be MUTABLE to be consistent with the built-in topic data types, which are also containers of QoS policies and which have that extensibility kind.

The IDL file contains specializations of all of the type-specific interfaces for the new built-in types: “Foo”DataWriter and “Foo”DataReader. However, the FooTypeSupport definitions are not included. These specializations require no method overloads; however, they should be included for the sake of clarity and completeness.
Resolution:
Add the missing type definitions.

The IDL file contains specializations of all of the type-specific interfaces for the new built-in types: “Foo”DataWriter and “Foo”DataReader. Some of these specializations contain additional “overloads” of DDS-standard types-specific methods for the sake of convenience. However, some of these overloads are not correct:
•	KeyedStringDataWriter::unregister_instance_w_key does not need to take both a string key and an instance handle. The purpose of this method is to unregister based on the key, so the handle should be removed. (Users wishing to unregister based on an instance handle can use the typical unregister_instance method specified by DDS.)
•	KeyedStringDataWriter::unregister_instance_w_key_w_timestamp does not need to take both a string key and an instance handle. The purpose of this method is to unregister based on the key, so the handle should be removed. (Users wishing to unregister based on an instance handle can use the typical unregister_instance_w_timestamp method specified by DDS.)
•	KeyedStringDataWriter::dispose_w_key does not need to take both a string key and an instance handle. The purpose of this method is to dispose based on the key, so the handle should be removed. (Users wishing to dispose based on an instance handle can use the typical dispose method specified by DDS.)
•	KeyedStringDataWriter::dispose_w_key_w_timestamp does not need to take both a string key and an instance handle. The purpose of this method is to dispose based on the key, so the handle should be removed. (Users wishing to dispose based on an instance handle can use the typical dispose_w_timestamp method specified by DDS.)
•	BytesDataWriter::write_string_w_bytes should be named BytesDataWriter::write_w_bytes (copy-paste error).
•	BytesDataWriter::write_string_w_bytes_w_timestamp should be named BytesDataWriter::write_w_bytes_w_timestamp (copy-paste error).
•	KeyedBytesDataWriter::unregister_instance_w_key does not need to take both a string key and an instance handle. The purpose of this method is to unregister based on the key, so the handle should be removed. (Users wishing to unregister based on an instance handle can use the typical unregister_instance method specified by DDS.)
•	KeyedBytesDataWriter::unregister_instance_w_key_w_timestamp does not need to take both a string key and an instance handle. The purpose of this method is to unregister based on the key, so the handle should be removed. (Users wishing to unregister based on an instance handle can use the typical unregister_instance_w_timestamp method specified by DDS.)
•	KeyedBytesDataWriter::write_bytes_w_key doesn’t actually include the key among its arguments. It should.
•	KeyedBytesDataWriter::write_bytes_w_key_w_timestamp doesn’t actually include the key among its arguments. It should.
•	KeyedBytesDataWriter::dispose_w_key does not need to take both a string key and an instance handle. The purpose of this method is to dispose based on the key, so the handle should be removed. (Users wishing to dispose based on an instance handle can use the typical dispose method specified by DDS.)
•	KeyedBytesDataWriter::dispose_w_key_w_timestamp does not need to take both a string key and an instance handle. The purpose of this method is to dispose based on the key, so the handle should be removed. (Users wishing to dispose based on an instance handle can use the typical dispose_w_timestamp method specified by DDS.)
Resolution:
Correct the method signatures as described in the summary above.

The specification provides equivalent definitions for the built-in annotations defined by the IDL Type Representations. However, it only includes these in the specification document, not in the IDL file.
Resolution:
Add these definitions to the IDL file. Add this content as an additional annex in the specification document. 

Section 7.3.1.1.2, Forward Compatibility with Respect to Compilers, defines a pragma declaration that IDL file authors can use to delimit portions of their IDL files that require certain versions of this specification. Especially since IDL files can include one another, it would be helpful if such pragma declarations were allowed to nest within one another.
Resolution:
Allow pragma declarations to nest.
•	Any version number specified by a nested pragma overrides the enclosing version number, if any.
•	Any unclosed declaration shall be considered to continue until the end of the input.
In addition, the pragma “end” declaration shall—like the “begin” declaration—allow a version number to be specified to clarify the nesting relationship.

Currently, the XML Type Representation and XML Data Representation do not define XML namespaces. This omission prevents XML documents of these types from being used in certain contexts, such as within XML catalogs or SOAP messages.
Resolution:
1.	Specify the XML namespace for the XML Type Representation. This namespace shall be formed by appending the OMG document number of the specification to the OMG HTTP domain in the following way: http://www.omg.org/<TF or TC>/<year>/<month>/<document ordinal>/<section_name>. For example, the namespace for the beta 1 specification would be: http://www.omg.org/ptc/2010/05/12/XML_Type_Representation.
2.	Allow the association of a target namespace with the XSD Type Representation of a set of types, such that documents conforming to such type definitions may be properly validated against that namespace. This target namespace will be implied by the fully qualified name of each non-nested type, such that all DDS types, regardless of which Type Representation was used to define them, implicitly define a target namespace that can be used to validate XML Data Representation documentsThis mechanism will be specific to the XSD Type Representation; the concept of a target XML namespace will not be promoted into the Type System (or, by extension, into other Type Representations). (This implied target namespace will be a URN, not a URL; it will not be possible to dereference it.)
2.3.	Allow applications the choice of whether to include XML namespaces on the network. Split the XML Data Representation into two dialects: XML_VALID and XML_WELL_FORMED. The former will include explicit namespace declarations and properly qualify all element and attribute names. The latter will, for the sake of compactness, omit namespace information.

The type assignability rules for structure types (section 7.2.4.5, Aggregation Types) allow mutable types to be assigned in either direction, so long as there are no name, ID, or type conflicts among the types’ members. Unfortunately, these rules permit a degenerate case: two mutable types having no key members and no members in common will have no conflicts, and therefore will be considered assignable. However, readers will always observe every sample to have all default/empty contents.
Resolution:
Add an additional rule to the assignability determination to require that at least one member is in common.

The specification contains the following typographical errors:
•	Section 7.6.1.3.1, TypeConsistencyEnforcementQosPolicy: Conceptual Model, bullet EXACT_NAME: “…they’re structural definitions…” should be “…their structural definitions….”
Resolution:
Fix the errors as described above.
Revised Text:
Revisions are described in the summary above

Summary:
Section 7.6.1.3.1, TypeConsistencyEnforcementQosPolicy: Conceptual Model, identifies the type consistency enforcement kinds. This QoS policy is request-offer (RxO); readers and writers must match exactly in order to communicate. However, this requirement for an exact match is not required by implementations and is too restrictive for users.

A primary use case for the DDS-XTypes specification is the independent evolution of components and subsystems. One important subset of this use case is the initial introduction of a Service implementation compliant with this specification: a reader or writer may support the Type Consistency Enforcement policy while its matched peer does not. Therefore, the following invariants must hold:
1.	Reader and writer must reach the same conclusion about whether communication is possible. Note that a non-DDS-XTypes-compliant implementation will enforce type consistency on the basis of exact name equality.
2.	The reader must be able to parse correctly the serialized data it receives from the writer. Note that a non-DDS-XTypes-compliant reader implementation may not be able to skip information that it does not understand nor to infer information it did not receive. A non-DDS-XTypes-compliant writer implementation may not be able to determine structural compatibility with its matched readers at all.
3.	Upgrading the DDS implementation without modifying application code must not cause communication to cease. The default QoS of a DDS-XTypes-compliant implementation—as well as the QoS that it infers from a non-compliant peer—must not result in a QoS incompatibility or type inconsistency that would not otherwise have occurred.
4.	Upgrading the DDS implementation without modifying application code MAY cause communication to begin. It could be that two applications have types that are not quite the same; however, they may be close enough to allow communication under this specification.
The following table matches compliant and non-compliant readers and writers and indicates desirable and permissible behaviors in each case. The notation “X” indicates an implementation compliant with DDS-XTypes. The notation “–“ indicates an implementation that is not compliant with DDS-XTypes. The first marking indicates whether the middleware has been upgraded; the second indicates whether the application code/configuration has been upgraded. “Equal” means exact structural type equality. “Assignable” means type assignability but not necessarily strict equality. “None” means no structural type checking at all.
	XX Reader	X– Reader	– – Reader
XX Writer	Assignable is the desired default, although either party might override this behavior to Equal or None.	Assignable is the desired default, although the writer might override this behavior to Equal or None.	Equal is the desired default, because the reader cannot respond flexibly. The writer might theoretically elect to change this to None, although this would be unsafe, because the writer might push incompatible data to the reader with no assurance that the reader is prepared to handle it.
X– Writer	Assignable is the desired default, although the reader might override this behavior to Equal or None.	Assignable is the desired default, although it is likely the same as Equal, if the endpoints were already communicating.	Equal is the desired default, because the reader cannot respond flexibly.
– – Writer	Assignable is the desired default, but it can be enforced only on the reader side , which might override it to Equal or None. The writer will perform no checking in any case.	Assignable is the desired default, but it can be enforced only on the reader side. It is likely the same as Equal, if the endpoints were already communicating.	None is the existing behavior; neither party can be configured to do anything else. However, the implied contract is Equal.

The Plain Language Binding relies on the IDL-to-C and IDL-to-C++ language mappings to generate programming APIs for these languages. Unfortunately, these mappings prefix all primitive type names with “CORBA,” which is incorrect and confusing for DDS users. For example:
•	DDS Int32 will become CORBA_Long in C.
•	DDS Float64 will become CORBA::Double in C++.
Resolution:
Update the Plain Language Binding for primitive types in C and C++ to place them in a conceptual “DDS” module instead of the current “CORBA” module. At the same time, rename them to be consistent with their names in the DDS type system—for example, “Int32” instead of “Long.” (The Plain Language Binding already makes several extensions to the IDL-to-C/C++ mapping specifications. This change would constitute one more.)
These new primitive types must be compatible in size and representationwith the definitions in the Type System; these definitions will be provided in a table within the Plain Language Binding section. (As a side effect, they will also be compatible with to their CORBA-module counterparts, such that applications using both DDS and CORBA can assign from one to the other without type casts or loss of information.)

The IDL Type Representation defines syntax for Type System concepts that were previously not expressible in IDL, such as annotations, maps, etc. This syntax is currently defined in prose and with examples. The specification should additionally provide a formal EBNF grammar.
Resolution:
Add EBNF grammar constructs to the relevant sections of the specification document.

One of the reasons for the development of the DDS-XTypes specification was the prior lack of explicitness and formality in the DDS type system and in its representations. DDS-XTypes addresses this need—and simultaneously extends both the type system and its representations. It would help the discourse about DDS systems, and the modeling of DDS systems, if a subset of DDS-XTypes were defined that identified only those parts of DDS and/or DDS-RTPS that were in broad use before the existence of DDS-XTypes.
This subset would include the following:
•	A subset of the Type System:
o	The full set of primitive types
o	Strings of narrow or wide characters
o	Sequences
o	Aliases
o	Structures without inheritance and with “final” extensibility
o	Enumerations
o	Unions
•	The IDL Type Representation of the above
•	The CDR Data Representation of the above
•	The Plain Language Binding for the above

The DynamicData class, part of the Dynamic Language Binding, has a huge API consisting of many dozens of methods. This large size makes the API harder to understand and reuse.

The Type System currently allows a type designer to specify that the storage for a type member may be located outside of the type itself. (This is an important capability when, for example, objects of the member’s type are very large.) However, it provides insufficient flexibility when such objects are stored in collections: the entire collection may be stored externally, but the collection members must be stored contiguously.
Resolution:
Enhance the Type System to allow collection elements to be shared, not just members of aggregation types. In the IDL Type Representation, this shall be expressed syntactically by the application of the built-in @Shared annotation to the collection member type.

All IDL should be using local interfaces, not regular interfaces, please add the keyword local to all interfaces

The only non-local interfaces in the DDS-XTypes API are specializations of “generic” interfaces defined by the DDS specification. It is not appropriate to change these to local interfaces until the corresponding change is made in the DDS specification itself. An issue has already been filed for the DDS RTF to make this change.
Disposition:	Deferred

IDL Anonymous type declarations should not be used in IDL examples and the 'dds_xtypes.idl' file as this form of type declaration has been deprecated by the latest CORBA specs and will cause compatibility problems with modern CORBA IDL compilers.

This issue arrived after the comment deadline and should be taken up by the next FTF/RTF.
Disposition:	Deferred

Allthough the specification of the MAP_TYPE in paragraph 7.2.2.3.4 refers to restrictions for key element type this is not formalized in either the specification for the IDL representation for maps or the C++ language mapping.


It should be clearly noted (for the IDL representation in bnf) that the key element type is restricted to integer and string types only.


The current IDL representation specs for map leave all options open for defining the key element type.
Although the specs in paragraph 7.2.2.3.4 describe the use of other element types as 'behaviour undefined' this is not clear enough as the chosen C++ representation simply will not work when f.i STRUCT or UNION types are chosen as key element type.

[Rick] To avoid forcing implementers to define hashing and/or total ordering for all types, we only require vendors to support keys of string and integer types: they are trivial to order and/or hash.
At the same time, it is not desirable to prevent vendors from supporting keys of other types. For example, platforms like Java and .Net provide object hashing as a uniform operation, so there is no reason why vendors focusing on those platforms should not be able to leverage that capability to the benefit of their customers.
Implementations that strictly adhere to the standard should simply issue a compile error upon seeing a construct that is unspecified and unsupported. Perhaps we just need to make this clearer in section 7.2.2.3.4.
[Martin] Yes […]. I would prefer a clear explanation that supporting the use of complex types like STRUCT, UNION etc. will require non-trivial support for non-default ordering/hashing options.
Also I would prefer a clear statement like 'when an IDL compiler implementation does not support <these kind of types as keys> it should issue a compile error'.
BTW, rehashing this I realized that […] the default instantiation of the less<> template for the standard mapping of string types (char* and CORBA::WChar*) is of little or no use for actual applications. […T]he map is actually indexed by the hashed pointer value of the strings instead of (what he will expect) by the string content.
So, I feel the spec should either state that for string keys the C++ mapping is required to provide a “Compare” specialization or put them in the same category as STRUCT, UNION etc.

The C++ mapping for the new MAP type needs a precise specification of member (or key) access semantics and memory management rules like the CORBA C++ mapping describes for the SEQUENCE type on pages 36-42 (par. 4.15) of the C++ language mapping, version 1.2, formal/2008-01-09.

[Rick] I don’t understand what the specification is missing. If using the equivalent IDL, the IDL-to-C++ mapping defines the semantics. And if using std::map, that container defines its own semantics.
The spec says in 7.5.1.3.1: “An IDL map type shall be transformed into an instantiation of the std::map template such that the Key parameter is the C++ type corresponding to the IDL key element type and the T parameter is the C++ type corresponding to the IDL value element type."
For example, IDL map<long, string>: the mapping for long in C++ is in 7.5.1.1.2: DDS::Int32, CORBA::Long, or int32_t are all legal options. The mapping for string is not overridden; the previously defined language binding remains in force: "This mapping reuses the OMG-standard IDL-to-language mappings..." at the beginning of 7.5.1.
[Martin] This certainly clears things up for me.

The @key annotation is currently defined as:


@Annotation
local interface Key {
attribute boolean value default true;
};


Now suppose I have the following topic type:


struct ATopicType {
string a; @Key @ID(20)
long b;
long c;  @Key @ID(10)
};


What is the key (a,b) or (b,a)? What if there were no annotations?  


The order of the key should be formally defined by the spec as this has an impact, among other things, on the computation of the keyhash. 


The rule could be as simple as taking the key element in the same order of the attribute ID. The other option is to extend the key to support a value, yet I think the first alternative is more orthogonal.

[Rick] The specification today deliberately does not consider member order and member ID to be the same thing. The only relationship between them is that the order is used to infer the ID in case the ID is not otherwise specified. Per the spec today, the key above is always (a, c) regardless of whether an ID annotation is there.
My understanding of this issue is that the spec currently defines key assignability of mutable types based on IDs and key type assignability, independent of order. Therefore, if the order of the key fields changes in a mutable type, the specification says the types should remain assignable. (If the type is not mutable, changing the order of any fields, keys or not, will prevent assignability.) However, because of the way the key hash is calculated, they will not in fact be interoperable, because the key hashes will change. 
Therefore, we must either specify that key fields cannot be reordered, or we must define some canonical ordering of key fields to be used when calculating the key hash.

Based on the DDS-XTypes specification, different applications in the same domain may associate the same  Topic with different types. As a result through discovery it should be possible to find all such definitions. However this is not currently possible with the DDS v1.2 specification and the DDS-XTypes does not provide an extension for this API.

It is not feasible to prevent more than one type from existing for the same topic:
•	Within a given version of a system, different endpoints may publish and subscribe to different types within a polymorphic inheritance hierarchy.
•	As a system evolves, new components may be integrated that use updated versions of previously existing data types.
This is an issue not only within a single domain (i.e. a discovery issue), but also within a single participant in that domain (i.e. a local entity management issue). If it is legal for variants of a topic to be associated with multiple related types (it is), then more than one of those variants should be able to exist locally within the same participant. We should address the local and remote aspects of this issue at the same time.

The equivalent_type_name and base_type_name fields from TopicBuiltinTopicData, PublicationBuiltinTopicData, and SubscriptionBuiltinTopicData are described in the prose of the specification and are reflected in the IDL file. However, they missing from the annex; they need to be added.

Any annex that contains a copy of a machine-readable file should be considered a convenience for the reader, so that s/he can see everything in a single file. We should fix this issue, and avoid future similar issues, by simply replacing the annex content in bulk with the analogous content from the appropriate machine-readable file.
This issue resolution should be implemented and voted on in the last round before the FTF report is submitted to ensure that it contains all relevant changes.

A DynamicData object may encapsulate the state of an object of a collection type—a sequence, array, string, or map. In such a case, it is necessary to be able to get and set the length of the collection.

Discussion:

We need to add an accessor for the current length. This accessor can also be useful for other object of other types; for example, it can return the number of members in a structure.

However, it is not appropriate to add a mutator for the length directly:

·      If the length of a collection is increased, that implies the addition of new elements. But the values of these new elements will not be meaningful.

·      If the length of a collection is decreased, that implies the removal of existing elements. But that may not be meaningful (what does it mean to remove a non-optional member of a structure?) of useful (why would you want to clear the fifth element of a bit set just because of what its index is?).

·      The lengths of some types cannot legally be changed at all—for example, array types.

Therefore, it is better to allow elements to be added and removed, where appropriate, and thereby modify the length implicitly.

Proposed Resolution:

Add an operation get_length to the DynamicData class.

·      If the object is of a collection type, return the number of elements currently in the collection. In the case of an array type, this value will always be equal to the bound.

·      If the object is of a bit set type, return the number of named flags that are currently set in the bit set.

·      If the object is of a structure or annotation type, return the number of members in the object. This value may be different than the number of members in the corresponding DynamicType—for example, some optional members may be omitted; see the existing DynamicData documentation.

·      If the object is of a union type, return the number of members in the object. This value will always be two: the discriminator and the current member corresponding to it.

·      If the object is of a primitive or enumeration type, it is atomic: return one.

·      If the object is of an alias type, return the value appropriate for the alias’s base type. 

Expand the contracts of the existing set_<type>_value operations to allow them to append new elements to resizable collections—strings, sequences, and maps. (This behavior is aligned with the existing contract of the clear operations, which states that cleared elements of resizable collections shall be removed.) Obtain the member ID associated with the new value as follows:

·      For a string or sequence type, use get_member_id_at_index to obtain an ID for the index one greater than the current length.

·      For a map type, use get_member_id_by_name to obtain an ID for the new map key.

Proposed Revised Text:

TO DO

We need to add an accessor for the current length. This accessor can also be useful for other object of other types; for example, it can return the number of members in a structure.
However, it is not appropriate to add a mutator for the length directly:
•	If the length of a collection is increased, that implies the addition of new elements. But the values of these new elements will not be meaningful.
•	If the length of a collection is decreased, that implies the removal of existing elements. But that may not be meaningful (what does it mean to remove a non-optional member of a structure?) of useful (why would you want to clear the fifth element of a bit set just because of what its index is?).
•	The lengths of some types cannot legally be changed at all—for example, array types.
Therefore, it is better to allow elements to be added and removed, where appropriate, and thereby modify the length implicitly

The type_name members of TopicBuiltinTopicData, PublicationBuiltinTopicData, and SubscriptionBuiltinTopicData are bounded at 256 characters. The equivalent_type_name and base_type_name members store sequences of type names, but the strings in those sequences are unbounded. The flexibility to store strings of any length is unnecessary, because no string can appear there that doesn’t also appear in a type_name somewhere, and is therefore of 256 characters or less.

This issue is minor in that it does not impact correctness. However, it does impact clarity to a small extent and can impact the efficiency of some implementations.

Proposed Resolution:

Define a typedef “TypeName”, a string bounded at 256 characters. (See also issue #15969.)

Define a typedef “TypeNameSeq”, an unbounded sequence of TypeName elements.

Change the type of the equivalent_type_name and base_type_name members from StringSeq to TypeNameSeq.

Proposed Revised Text:

TO DO

The specification contains the following identified typographical errors:

·      The third bullet in section 2.2, “Network Interoperability Conformance”, which begins with “Data Representation…”, is lacking an opening parenthesis at the start of the second sentence. The closing parenthesis is already present.

Proposed Resolution:

See the trivial corrections described above.

Proposed Revised Text:

See the trivial corrections described above

The current DynamicType API allows a type definition to be changed. Such a change can be ambiguous at best and dangerous at worst.

·      Suppose that the type already types (DynamicData) objects. Should all of those objects refer to the old version of the type or the new version? If the new version, how shall we address the situation where the new type is inconsistent with the existing data contents?

·      Suppose that the type has already been registered with some domain participant. Does the registered type name refer to the old version of the type or the new version? What shall be done about samples that may already have been published or received using the old version?

·      Can DynamicTypeFactory cache and reuse identical types that are requested more than once? Ideally yes, but the ability to change a type makes the state management necessary to support this behavior very complicated.

It would be safer, clearer, and more efficient if DynamicType objects were immutable once created. That implies that either the factory must take sufficient inputs to fully create a type in one step, or we must employ a builder or similar pattern.

Discussion:

A builder pattern would give the application more flexibility in how to create new types. It would also nicely encompass the current load_type operations as well as hypothetical PSM-specific operations, such the creation of a DynamicType from a Java Class object.

Proposed Resolution:

TO DO

Proposed Revised Text:

TO DO

A builder pattern would give the application more flexibility in how to create new types. It would also nicely encompass the current load_type operations as well as hypothetical PSM-specific operations, such the creation of a DynamicType from a Java Class object.

Application code (i.e. business logic) generally depends statically on particular types and their members. Therefore, it is appropriate to define these types statically (e.g. in IDL) and generate code for them in order to take advantage of static type safety and improved performance.

In contrast, infrastructure code (i.e. logic that is independent of particular applications) generally must not depend on application-specific types, because such dependencies prevent that code from being reused.

These two kinds of code can exist within a single component. For example:

·      The properties of application-specific types might be checked against a common set of rules to ensure that they meet organizational or program-specific guidelines.

·      Certain design patterns may call for arbitrary application-specific types to be augmented in uniform ways.

·      Type-specific application activities, such as reading and/or writing data, might be logged or recorded.

The straightforward way to handle these scenarios would be to:

1.    Convert a generated type definition into a DynamicType object.

2.    Convert an object of a generated type into a DynamicData object.

3.    Pass these two dynamic objects to the infrastructure code and allow it to operate on them.

Unfortunately, the specification does not provide such a capability. Instead, applications have to manually construct DynamicType and DynamicData objects member by member. This code is not only verbose but also brittle, because if the static type definition changes (e.g. during development or across versions), it can grow out of sync with the hand-written code that manipulates that definition.

Discussion:

We need three new conversions:

1.    TypeSupport à DynamicType

2.    DynamicData à sample object

3. Sample object à DynamicData

These operations could either be added to the TypeSupport interface or to a “type builder” interface. The former approach is preferred, because the generic type parameter of the TypeSupport in the C++ and Java PSMs allows a degree of type safety that way.

Proposed Resolution:

Introduce three new TypeSupport operations:

1.    get_type: Get a DynamicType object corresponding to the TypeSupport’s data type.

2.    create_sample: Create a sample of the TypeSupport’s data type from an input DynamicData object. If the DynamicType of the DynamicData is not compatible with the TypeSupport’s data type, raise an error.

3.    create_dynamic_sample: Create a DynamicData object from an input sample of the TypeSupport’s data type.

Proposed Revised Text:

TO DO

We need three new conversions:
1.	TypeSupport ? DynamicType
2.	DynamicData ? sample object
3.	Sample object ? DynamicData
These operations could either be added to the TypeSupport interface or to a “type builder” interface. The former approach is preferred, because the generic type parameter of the TypeSupport in the C++ and Java PSMs allows a degree of type safety that way.

Source:

RTI (Mr. Alejandro de Campos, alejandro@rti.com)

Summary:

Each DDS QoS policy must define a couple of attributes: whether or not the policy has request-offer (RxO) semantics and whether or not it can be changed after an entity is enabled. The two new QoS policies defined by DDS-XTypes—TypeConsistencyEnforcementQosPolicy and DataRepresentationQosPolicy—define the first part but not the second.

Discussion:

Because of their potential interactions with historical data, neither of these policies should be changeable after an entity is enabled.

Proposed Resolution:

State in the introduction to each policy that its value cannot be changed after an entity is enabled.

Proposed Revised Text:

TO DO

Because of their potential interactions with historical data, neither of these policies should be changeable after an entity is enabled.

Members of a structure or union type have a small number of metadata attributes, among them:

·      optional: indicates that the member may or may not take a value in a particular sample

·      must_understand: indicates that a consumer of the data must discard the sample if it encounters such a field in it

The type-level assignability rules detect mismatches respecting non-optional must_understand members. (Such members will always take a value, and therefore there is no possibility of data exchange between the producer and consumer.) However, must_understand members that are optional must be detected on a sample-by-sample basis: any sample that does not contain the offending member can be exchanged, but those that do cannot.

The XML Data Representation allows the encoding of the must_understand attribute within each sample, as does the parameterized encapsulation variants of the Extended CDR Data Representation. However, the traditional, non-parameterized encapsulation variants—used by final and extensible structures and unions—do not permit this attribute to be expressed. As a result, consumers will not be able to detect when it should have been present, and may therefore present incorrect data to applications.

Discussion:

The traditional CDR encapsulations prefix each optional member with a 32-bit “header” that indicates the presence and size of the member. In contrast, the parameterized CDR encapsulations prefix each member with a 32-bit parameter header that indicates the presence, size, ID, and metadata flags of the member, including must_understand. Therefore, we can reuse the parameter header structure we already have to solve this problem, instead of using just a 32-bit size, with no increase in overhead.

Proposed Resolution:

Reorganize the Extended CDR Data Representation section such that it first defines the parameter header structure and the member-ID-to-parameter-ID mapping. Second it shall define the traditional encapsulation variants, and finally it shall define the (fully) parameterized encapsulation variants.

Within the middle section—traditional CDR—update section 7.4.1.1.5.2, “Optional Members.” Remove the description of a 32-bit size, and in its place describe the use of a parameter header. Note that either the four-byte header defined by DDS-RTPS or the 12-byte extended header defined by DDS-XTypes may be used.

Proposed Revised Text:

TO DO

The traditional CDR encapsulations prefix each optional member with a 32-bit “header” that indicates the presence and size of the member. In contrast, the parameterized CDR encapsulations prefix each member with a 32-bit parameter header that indicates the presence, size, ID, and metadata flags of the member, including must_understand. Therefore, we can reuse the parameter header structure we already have to solve this problem, instead of using just a 32-bit size, with no increase in overhead.

OMG Issue No: ?????

Title:       Incorrect default extensibility kind value in XSD file

Source:

RTI (Mr. Alejandro de Campos, alejandro@rti.com)

Summary:

The declaration of the complex type structOrUnionTypeDecl in the XSD file contains the following attribute declaration:

<xs:attribute name="extensibility"

              type="extensibilityKind"

              use="optional"

              default="false"/>

However, “false” is not a valid value for the extensibilityKind type.

Proposed Resolution:

Change the default value to “extensible”.

Proposed Revised Text:

Replace the following attribute declaration within the complex type structOrUnionTypeDecl:

<xs:attribute name="extensibility"

              type="extensibilityKind"

              use="optional"

              default="false"/>

…with this one:

<xs:attribute name="extensibility"

              type="extensibilityKind"

              use="optional"

              default="extensible"/>

The definition of PID_LIST_END in Table 27 in section 7.4.1.2.1, Interpretation of Parameter ID Values, reads:

RTPS specifies that the PID value 1 shall be used to terminate parameter lists within the DDS built-in topic data types. Rather than reserving this parameter ID for all types, thereby complicating the member ID-to-parameter ID mapping rules for all producers and consumers of this Data Representation, Simple Discovery types only shall be subject to a special case: member ID 1 shall not be used, and either parameter ID 0x3F02 or parameter ID 1 shall terminate the parameter list.

The meaning of “Simple Discovery types” is not clear. It should not apply to all mutable types that might ever be used as part of the Simple Discovery process. It is intended only to maintain backward compatibility with types defined in DDS-RTPS.

Proposed Resolution:

See the Proposed Revised Text below.

Proposed Revised Text:

Append an additional sentence: “These types consist of the built-in topic data types, and those other types that contain them as members, as defined by [RTPS].”

A bit set with bit bound <= 8 is mapped to a byte in some places (page 78 and 40) and to an unsigned short in others (page 88). (Page numbers refer to beta 2.)

Proposed Resolution:

A bit set with bit bound <= 8 should be serialized as a single byte.

Proposed Revised Text:

In the table in section 7.5.1.2.2, BitSet Types, replace these rows:

Bit Set Bound
 Unsigned Integer Equivalent
 
1–16
 unsigned short
 

…with the following:

Bit Set Bound
 Primitive Equivalent
 
1–8
 octet
 
9–16
 unsigned short
 

 

The type assignability rules for unions have a number of problems (see the UNION_TYPE row of the table in section 7.2.4.5, Aggregation Types):

·      The second and third bullets in the list of rules are redundant.

·      According to the fourth bullet (assignability of default members), a union with a default label may not even be assignable to itself.

·      The rules do not account for member IDs and names, which can be significant when deserializing objects in some data representations.

·      The rules do not account for the fact that the discriminator may or may not be a key.

·      The rules do not account for extensibility kind.

·      The rules are under-specified with respect to malformed samples. Specifically, the discriminator may select a particular member X of the union, but the implementation may discover in its place a different member Y. (This situation will be detectable only with certain data representations.)

Proposed Resolution:

Apply the followin rules:

·      Apply the member ID, name, and type matching rules for structures to unions as well.

·      Every discriminator value in T2 must select the “same” member in T1—or no member at all. This can be checked in three steps:

1.    Every discriminator value in a non-default label of T2 selects the same member in T1 or none at all.

2.    Every discriminator value in a non-default label of T1 selects the same member in T2 or none at all.

3.    If both T1 and T2 have a default label, the corresponding members must be assignable.

·      Either both types must have a key or neither.

·      The extensibility kinds must match.

·      Specify explicitly that an object of a union with a mismatch between its discriminator and non-discriminator members is considered malformed. The impact is unspecified, although implementations may consider the object unassignable.

Proposed Revised Text:

Replace the center column of the UNION_TYPE row of the table in section 7.2.4.5, Aggregation Types, with the following:

UNION_TYPE if and only if it is possible to unambiguously identify the appropriate T1 member based on the T2 discriminator value and to transform both the discriminator and the other member correctly. Specifically:

·      T1.discriminator.id == T2.discriminator.id and T1.discriminator.type is-assignable-from T2.discriminator.type.

·      Either the discriminators of both T1 and T2 are keys or neither are keys.

·      Any members in T1 and T2 that have the same name also have the same ID and any members with the same ID also have the same name.

·      For each member “m1” in T1, if there is a member m2 in T2 with the same member ID then m1.type is-assignable-from m2.type.

·      T1.extensibility == T2.extensibility.

·      A discriminator value appearing in a non-default label of T2 selects a member m2. If the same discriminator value selects a member m1 of T1, then m1.id == m2.id.

·      A discriminator value appearing in a non-default label of T1 selects a member m1. If the same discriminator value selects a member m2 of T2, then m1.id == m2.id.

·      If both T1 and T2 have a default label, then the IDs of the members selected by those labels must be equal.

AND if T1 is final, the number of members in T1 is equal to the number of members in T2.

Remove the footnote that is linked to the old contents of that table cell.

Append the following paragraphs to the right-hand column of the same table row:

If either member of the union is unassignable, then the T2 object is unassignable to T1.

If the discriminator value of a union object and its non-discriminator member do not agree with one another, the object is considered malformed. In such a case, the behavior is unspecified. In particular, the implementation may or may not be able to detect this error. If it can, it should consider the object unassignable.

See also the following issues, which also deal with assignability.
•	Issue #16367 addresses the concept of “strong assignability”.
•	Issue #16368 proposes making object-level assignability rules more flexible.

The definition of the term “strongly assignable” in section 7.2.4, Type Compatibility: “is-assignable-from” relationship, states:

If types T1 and T2 are both mutable and T1 is-assignable-from T2, then T1 is said to be “strongly” assignable from T2.

The purpose of this concept is to distinguish cases where it is possible to delimit adjacent objects. This is necessary, for example, when deserializing arrays, to avoid a situation where extra members in an array element could throw off the deserialization of subsequent elements.

This definition is overly restrictive and can even prevent arrays of non-mutable elements from being assignable to themselves.

Proposed Resolution:

Amend the definition to consider any type strongly assignable to itself.

Proposed Revised Text:

The definition of the term “strongly assignable” in section 7.2.4, Type Compatibility: “is-assignable-from” relationship, states:

If types T1 and T2 are both mutable and T1 is-assignable-from T2, then T1 is said to be “strongly” assignable from T2.

Append the following sentence:

Any type is also considered (trivially) strongly assignable from itself, regardless of its extensibility kind.

Note that:
•	Objects of mutable types can always be reliably delimited, because the parameterized CDR representation they use contains an explicit termination sentinel. This is why the original definition of “strongly assignable” is the way that it is.
•	Objects of final and extensible types can nevertheless be delimited if they are top-level objects, not contained within any other—the enclosing encapsulation (e.g. an RTPS packet) identifies the length of its contents. The distinction between “assignable” and “strongly assignable” captures this property.
•	Objects of final and extensible types can nevertheless be delimited if they occur as members of mutable structures. This freedom is already captured by the existing structure assignability rules.
See also the following issues, which also deal with assignability.
•	Issue #16366 addresses the assignability of unions specifically.
•	Issue #16368 proposes making object-level assignability rules more flexible.

Source:

RTI (Mr. Alejandro de Campos, alejandro@rti.com)

Summary:

A small object-level assignability problem within a complex sample can result in an entire sample being discarded. For example, a string whose length is greater than the bound of a string it’s being assigned into must be discarded. A sequence with an unassignable member must be discarded. A structure with an unassignable member must be discarded. As a result, a small issue deep within a structure could cause a whole sample to be discarded. For example, an issue within a TypeObject could result in an entire built-in topic data sample being discarded and consequently a loss of discovery information.

Discussion:

If we attempt to prevent any possible semantic problem that could arise from partial samples, we will have to keep the existing draconian rules, which can have bigger impacts, as described above. Therefore, the rules should seek to be more lenient and allow type-aware code “above” the assignability algorithm to detect semantic problems.

Proposed Resolution:

The following are the cases identified in the specification in which individual objects may be unassignable:

·      Strings that are too long: No change. Strings are a basic type, and truncation can generally not be easily detected by applications.

·      Arrays with unassignable elements: No change. In CDR, arrays have no length or other means of delimiting elements, so it is not possible to “truncate” them.

·      Sequences that are too long or contain unassignable elements: Discard only the offending elements, “left-shifting” subsequent elements and reducing the length as necessary.

·      Maps that are too long or contain unassignable elements: No change. Map entries are not logically ordered, so elements may not be discarded in a stable fashion.

·      Enumeration with unrecognized value: No change.

·      Union whose discriminator does not select a value in the destination type: No change—otherwise, the union would be malformed.

·      Structure with a “must understand” member not present in the destination type: No change—otherwise, the union would be malformed.

Add the following new rules:

·      Structure with an unassignable non-optional member: The entire structure is considered unassignable. (This behavior was previously underspecified.)

·      Structure with an unassignable option member: The member takes no value. The rest of the structure can theoretically be retained.

The consensus of the task force is that the built-in assignability rules should be rigorous and robust to avoid introducing semantic problems that applications will have to work around. However, this issue is not rejected, as there are still ambiguities and weaknesses to resolve in this area.
See also the following issues, which also deal with assignability.
•	Issue #16366 addresses the assignability of unions specifically.
•	Issue #16367 addresses the concept of “strong assignability”.

The specification of the extensibility kind for enumeration types is inconsistent. Figure 10 in section 7.2.2.3.1, "Enumeration Types", indicates that the extensibility_kind of all enumeration types is FINAL. However, Table 11 in section 7.2.3, "Type Extensibility and Mutability", says, "Enumeration types may be final, extensible, or mutable on a type-by-type basis."


Proposed Resolution:

The assignability rules for enumerations already address different extensibility kinds, so we can preserve the more general statement from 7.2.3. Fix Figure 10.

 have a new issue to file against the DDS-XTypes spec that was pointed out to me by Reinier Torenbeek.


Declared compatibility of types (i.e. type signature) includes base types but not derived types. Unfortunately, that means that a consumer using a base class unknown to an existing producer will not be able to consume data from that producer, because neither party will declare the relationship between the types.


For example: I publish Dog, which extends Animal. In version 2, a new intermediate class Mammal is introduced. However, a new consumer of Mammal won't match with a legacy producer of Dog, because both the Dog and Mammal endpoints declare that their types extend Animal, and neither one asserts that Dog should now extend Mammal.


Proposed Resolution:


Remove the type signature concept and go back to registering simple names. In its place, introduce a new QoS policy that lists assertions about which types extend which others. Consider making these assertions transitive. As today, the operative set of assertions when matching producers and consumers should be the union between the producer's and the consumer's sets.

The specification introduces the concept of optional members into DDS data types. However, it does not address how comparisons of these members should work in content-filtering expressions. For example, if a content-filtered topic indicates that all samples are of interest where "x != 5", but x is not present in the sample at all, does the sample pass the filter or not?


Proposed resolution: Introduce the notional value "null" that may be used in a content-filter expression. The null value is not equal to any value in the domain of any data type. (That is, x != null for any non-null value of x.) A member's value in a given sample shall be considered to be equal to null if that member is not present in the given sample. Its value shall not be considered equal to null if it is present.

The same applies to other new constructs in the type system: we need to specify how to refer to them in a content-filter expression. These include not only optional members of structures but also maps and bit sets.

The gradient shading rendered in each of the elements on a low-color image results in elements rendered as follows:

 
 
The diagrams should be rendered either by using a higher-color format (such as png), or without the gradient rendering enabled.
 
NB: To turn off the gradient shading in Enterprise Architect, go to the "Tools->Options" dialog. Under the "Diagram->Appearance" group:
1) Deselect the "Show Gradient Fill for Paper Color" option
2) Set the "Gradient Fill Direction for an Element" to "<none>"

To turn off the gradient shading in Enterprise Architect, go to the "Tools->Options" dialog. Under the "Diagram->Appearance" group:
1)	Deselect the "Show Gradient Fill for Paper Color" option
2)	Set the "Gradient Fill Direction for an Element" to "<none>"

The first rectangular symbol in Figure 3 contains truncated text - Type Representation
 

The following figures exhibit non-standard notation for specialized elements:
Figure 4
Figure 9
Figure 11
Figure 14
Figure 16
Figure 17
Figure 20
 
The textual notation showing generalized elements on specialized ones needs to either be hidden, or have the generalized element explicitly shown on the diagram (with generalization relationship between the elements showing).
 
NB: To hide the generalized element names on specialized ones in Enterprise Architect, double-click on a blank area of the diagram to open the Diagram Properties Dialog. On the "Diagram" tab deselect the "Show additional Parents" option.
 

To hide the generalized element names on specialized ones in Enterprise Architect, double-click on a blank area of the diagram to open the Diagram Properties Dialog. On the "Diagram" tab deselect the "Show additional Parents" option.
Note that Figures 6–8, 10, 12, 13, 15, and 38 exhibit the same problem as well.

The following figures exhibit inconsistent application of data types to attributes, operations and parameters:
Figure 4
Figure 9
Figure 10
Figure 13
Figure 14
Figure 16
Figure 26
Figure 30 
Figure 33 
Figure 36 
Figure 37
Figure 38
Figure 39
 
Certain attributes/parameters have 'int' or 'string' applied which conflict the data types defined within the aforementioned model, and the PrimitiveTypes defined in UML. What is the intent with these? Which set of primitive data types are intended for application here (IDL? Java, C++, UML, XTypes?)
 
For example, the 'Enumeration' class in Figure 10 defines a 'bit-bound' property of type int. 
 

The above-mentioned attributes (Figures 28 and 37) have types defined in the form "xxx --> yyy" which has no meaning in UML. Please clarify and correct.

Note that figure 26, “Dynamic Data and Dynamic Type”, displays the properties of the DynamicData class and hence also needs to be updated.

 The specialized Primitive Types defined for Int, UInt, Float, Boolean, etc... each define a property 'value' that is typed by the property's owner thus resulting in a circular reference in the model.
 
Figure 6
Figure 7
Figure 8
 
Each of these are specializations of the PrimitiveType abstract class. Changing the UML instance of the PrimitiveType definition to a UML:PrimitiveType will automatically convey the semantic that an instance of the specialized PrimitiveType is the value itself.
 
NB: To do this in Enterprise Architect recreate the PrimitiveType abstract definition as an instance of the 'Primitive' element found in the 'Class' toolbox.
 

To do this in Enterprise Architect, recreate the PrimitiveType abstract definition as an instance of the 'Primitive' element found in the 'Class' toolbox.
Unfortunately, PrimitiveType and the classes that specialize it cannot be changed to specialize UML::PrimitiveType, because a primitive cannot extend a class or even specialize an interface. Therefore, these types would be effectively removed from the Type classifier hierarchy, which would break other parts of the model.

DynamicType has a property "descriptor" of type (read-only) TypeDescriptor. This property is mapped to IDL as a readonly attribute. When code is generated for this attribute in C or C++, the corresponding getter is not consistent with the other getters in the same class, either in terms of its style or in terms of its memory management. (The other getters are all defined explicitly as methods in IDL.)



Proposed Resolution:
Remove this member and add an explicit getter method:


    DDS::ReturnCode_t get_descriptor(
            inout TypeDescriptor descriptor);


This method overwrites a user-provided object, just like get_member_by_name and get_annotation.

The same issue applies to DynamicTypeBuilder (see the resolution to issue #16240) and DynamicTypeMember.

Found by: Rick Warren, RTI (rick.warren@rti.com)
Severity: Minor


Problem:
The IDL Type Representation uses so-called "built-in annotations" to attach metadata to type definitions. The hypothetical module in which these annotations are defined is unclear. On the one hand, all (other) types defined by the specification are in the DDS:: module. However, in the case of the built-in annotations, no module is specified.


Proposed Resolution:
Clearly indicate that all built-in annotations are notionally in the DDS:: module

Found by: Fernando Crespo, RTI (fernando@rti.com)
Severity: Support Text


Problem:
Section 7.4.1.2.1, "Interpretation of Parameter ID Values", says the following directly beneath Table 27, "Reserved parameter ID values":


    "The length of this parameter shall be at least eight bytes: the first 
    four bytes of the parameter data shall be interpreted as a set of four 
    reserved bit flags followed by the 28-bit member ID; the second four
    bytes shall be interpreted as a 32-bit unsigned data length measured
    from the end of that field until the start of the next 16-bit parameter 
    ID. If the 16-bit length is greater than eight, the additional contents 
    are undefined and are reserved for future use by OMG specifications."


The meaning is that the "data value" of the (shorter) parameter is in fact itself a longer parameter ID header, and the length indicated in the former header is in fact the length of that (longer) header only. The actual data value follows both headers, and its length (i.e. until the next parameter header) is given in the longer parameter header. Thus the total length of the parameter following the shorter header is the sum of the two lengths. The values of the flag fields are unspecified, as of the 1.0 specification, and reserved for future OMG specifications.


Proposed Resolution:
Update the description to more clearly reflect the data layout and add a figure to show it graphically.

Found by: Fernando Crespo, RTI (fernando@rti.com)
Severity: Significant


Problem:
Table 27, "Reserved parameter ID values", in section 7.4.1.2.1, "Interpretation of Parameter ID Values", gives the 14-bit numeric IDs for the reserved parameters. However, it does not specify the corresponding values of the FLAG_IMPL_EXTENSION and FLAG_MUST_UNDERSTAND flags. The implication is that either flag may be set independently on an occurrence-by-occurrence basis, but that would be a bad idea: first of all, if FLAG_IMPL_EXTENSION is set, the specification should assume nothing about the contents of the parameter. And second of all, most parameters have a value of FLAG_MUST_UNDERSTAND that could reasonably be specified up front.


For example, and in particular, with respect to PID_EXTENDED, the text currently says: "The setting of the FLAG_MUST_UNDERSTAND bit in the 16-bit parameter ID shall be interpreted to apply to the extended parameter as well, not just to the 12 bytes of the PID_EXTENDED parameter itself." In other words, the flag is set based on the the must_understand attribute of a given member. This behavior is inappropriate, given that non-XTypes-conformant DDS implementations may receive extended parameters within discovery data: such implementations, if they do not see FLAG_MUST_UNDERSTAND set, will erroneously interpret the first four bytes of the (extended) data value as a parameter header, effectively corrupting the input data stream.


Proposed Resolution:
1. Clearly indicate that any parameter with FLAG_IMPL_EXTENSION set is outside of the scope of the specification. For a parameter to be recognized as one of the well-known values in the table, this bit must be set to zero.


2. Add a column to table 27 for the FLAG_MUST_UNDERSTAND flag. Set the value of this flag as follows:
    * PID_EXTENDED: Yes. This will force non-XTypes-conformant implementations 
      to discard data containing extended headers rather than parsing it 
      incorrectly.
    * PID_LIST_END: Yes. This will force implementations to either recognize 
      the end of the list or to discard the data. It will avoid a situation 
      where an implementation might "skip" the end of the list and start 
      parsing out of bounds.
    * PID_IGNORE: No. The whole point is to ignore this parameter.


3. When writing data, the Service shall conform to the setting of FLAG_MUST_UNDERSTAND indicated above. When reading data, the Service should be robust to the opposite setting as well and accept the parameter nevertheless.


4. Within the four-bit set of flags that has already been reserved within the extended parameter header, use the most-significant bit to indicate vendor-specific extensions and the second-most-significant-bit to represent the value of the must_understand value of a data member. These flags are parallel to the flags in the short parameter header and restore the flexibility lost by specifying up front the value of the corresponding flags in that header.


5. Do not leave the contents of the other flags in the extended parameter header with junk contents; if a given flag's value is not specified by some (other) OMG specification, it should be set to zero.

Found by: Fernando Crespo, RTI (fernando@rti.com)
Severity: Support Text


Problem:
The mapping of type member IDs to DDS-RTPS parameter IDs described in section 7.4.1.2.2, "Member ID-to-Parameter ID Mapping", will never result in FLAG_IMPL_EXTENSION being set. However, this is not stated explicitly.


Proposed Resolution:
Explicitly state that RTPS parameters corresponding to members of user-defined data types should never set FLAG_IMPL_EXTENSION.


RTPS parameters corresponding to members of RTPS discovery-defined data types may or may not have FLAG_IMPL_EXTENSION set as defined by RTPS itself; the contract is unchanged. The mechanism by which an implementation generates that flag's value is unspecified.

Found by: Fernando Crespo, RTI (fernando@rti.com)
Severity: Support Text


Problem:
The section on the parameterized CDR Data Representation (DDS-XTypes 7.4.1.2) contains a reference to the DDS-RTPS specification for the definition of the parameter list data structure. However, it does not specifically refer to the instructions in DDS-RTPS on how to handle alignment within such a structure. This omission may confuse some implementers, especially with respect to extended parameters, which should follow the same alignment rules as RTPS-traditional "short" parameters.


Proposed Resolution:
Add the following paragraph to the end of section 7.4.1.2.1, "Interpretation of Parameter ID Values":


    "The alignment rules for extended parameters shall be the same as
    those for non-extended parameters, which are defined in [RTPS]
    Section 9.4.2.11."