HL7 v3 Data Type Meta Model

This is a first draft of a meta model of our data type definitions. If you read this with a HTML browser, you can click on one of the classes in the diagram below to reach the description. All class descriptions are further below in this file.

data type generalization primitive composite collection component parameter

Data Type

A data type may de declared as "internal." An internal type is used in order to define another data type but is not meant to be directly used in messages. A generic data type is a type whose complete specification is defered until it is actually used in one or the other way. The missing pieces must be specified when used. This is what C++ knows as "templates".

Primitive Data Type

A primitive data type has only a textual specification of its semantics. The specification is separate from the inherited description attribute, because it is essential for a primitive data type to have a very careful specification that describes the exact semantics of such a type.

Composite Data Type

A composite data type consists of one or more named and typed components.

Data Type Component

A component is like a variable, i.e. it has a name and a type. The type can be declared to be included by reference instead of by value. This is usefult if you know such a component mentions an instance that is already mentioned elsewhere in the message. In languages such as Java, where objects are always handled through references this does not make a difference.

Most fields are declared as of a specific type. However when building generic types one sometimes wants to leave the type-declaration of a field unspecified. Instead of leaving the type declaration completely unspecified, one can also constrain the alloweable types to certain specific types. When just some types are allowed in a given this case it is likely"

DTM Generalization

A data type may be categorized into possibly many generalizations. For instance, "Integer Number" might be classified as "Ordered Type" and "Discrete Type" and "Quantity". Generalizations are themselves data types. All the rules of inharitance apply here. I.e. when abstract generalized types do not have attributes. A specialized type can add more attributes or make further constraints on inherited attributes.

Collection Data Type

A collection data type is a collection of one or many instances of a particular element type. One particular semantic variation of the collection data type be specified in the collection_type attribute.

The notion of a collection data type should once and forever supersede the traditional notion of "repeatability." This means, the MDF meta model needs to be updated!

Collections are of one of the following types:
SET an unordered collection of unique element type instances.
BAG an unordered collection of element type instances. Instances may occur more than once in the bag.
LIST an ordered collection of element type instances.

Generic Type Parameter

see also [here]

This isn't actually a type, but a parameter of a generic type template. For example, we define a generic type Interval on all types with an order. In C++ this would look like:

template <class T> class Interval { ... enum LimitType limitType; T lowLimit; T highLimit; ... }

Using DTM_Generalization in an unrestricted way, we can define categories of data types and declare the template parameter as one of those general types (e.g., Ordered_type).

Having such a general type it seems possible to declare the generic type Interval without using templates and template parameters:

class Interval { ... enum LimitType limitType; OrderedType lowLimit; OrderedType highLimit; ... } however both declarations are not equivalent. While the first one did not constrain the template parameter T to be of an Ordered_type, the second declartion did not constrain lowLimit and highLimit to actually refer to the same special type.

This meta model allows to make both constraints by using the Generic_type_parameter that can be constrained using the association has_allowed_types.