Key SDL-2000 feature: Types

• types define the properties of a genericagent (system, block, process), service, (composite) state, object or value type, or procedure or signal or interface (note: these last 3 are “types”). Types can be reused.

• Class symbols can be used to refer to the definition of the type showing some of its attribute and behaviour properties.

• Associations can exist between types.

Kind shown by icon or stereotype.

• inherits specializes a type to a sub-type:
  - by actuals for parameters of the type;
  
  - or, adding properties in the sub-type;
  - or, redefining a virtual type or transition,
  and can be shown by a relation symbol.

• virtual or redefined types or transitions in a type can be redefined in sub-types.

• atleast can constrain parameters used for redefinition.

• abstract and parameterized types must be specialized before use.

agents etc. can be based on types.

Previous slide

Next slide

Back to first slide

View graphic version

The ITU-T SDL+ methodology of 1996 suggested OMT object notation be used to model classes, before turning these into SDL-92 types. Since the OMT notation became part of UML, and the notation has also been adopted within SDL-2000 so that these models become part of the SDL notation.

A type defines properties that instances of the type have, and that can be inherited by other types. Types can also be aggregations of other types.

A class symbol can be used as a references to a type together with revealing some attributes (such as variables) and behaviour properties (such as operators or signals) of the type. It can be indicated if an attribute or behaviour property is local (-) or exported(+) and whether it is private to the type, protected so that it can be used in the type and within sub-types, or public (useable where the type is visible).

The relationship between types can be shown by associations and inheritance symbols.

A type can have context parameters, in which case other types can be derived from the type by binding these to actual parameters when the type is used. All context parameters of a type have to be bound before an instance can be made from it.

When a type inherits the properties of another type, additional properties can be added but existing properties cannot be changed except for transitions and enclosed types that are marked as virtual. In a sub-type a virtual transition or virtual type can be redefined, in which case it can be changed again in a sub-type of the sub-type, or finalized to prevent further changes.

Both context parameters and virtual types can be constrained to be of a certain type. In this case the actual parameter or redefined type must be of the specified type or a sub-type of the specified type.

An abstract type cannot be directly the base for an instance, but must first be inherited.

The syntax and rules for types apply consistently, so that inheritance and compatibility are treated in the same way (for example ) for blocks as for data.