XTCE14 — Separate dynamic type properties from parameter and argument instances

In XTCE (1.3 and below), dynamic properties of data types, such as the length of an array, can depend on references to parameters or arguments. This couples the type definition to a particular usage context and limits the reusability and composability of the type.

A type definition should describe the structure and properties of the data it represents, independently of the context in which it is instantiated. References to parameters or arguments, on the other hand, belong to the context in which the type is used.

The current approach introduces several limitations:

• Limited type reusability. A type whose dynamic length depends on a particular parameter or argument cannot be reused naturally in contexts where the length is determined by a different value.
• Separation of concerns. The type definition mixes intrinsic type properties with references to objects in the surrounding data model.
• Aggregate composition. It is not possible to express an aggregate member whose array length is determined by another member of the same aggregate when the existing reference mechanism cannot resolve that dependency in the aggregate's context.
• Extensibility. Similar issues may arise for other dynamically determined type properties, suggesting that the solution should address the underlying model rather than arrays alone.
  These limitations make it harder to define reusable data types and to describe composite data structures whose members depend on one another.

Proposed solution
Introduce a mechanism for defining dynamic properties at the type level, independently of the parameter or argument instances that supply their values.

A type definition would declare which properties are dynamic. When the type is instantiated, the dynamic properties would be bound to expressions or references that are meaningful in the context of that particular instance.

For example, an array type could declare its length as a dynamic property without referencing a specific parameter or argument.

When the type is used, its length could then be bound to:

• A telemetry parameter when the array is instantiated as a parameter.
• A command argument when the array is instantiated as an argument.
• Another member of the same aggregate when the array is instantiated as an aggregate member.
  The mechanism should be generic enough to support other dynamically determined type properties where appropriate, rather than being limited to array dimensions.