# Types

## Type Definitions

Users can define types in type models stored in files with extension '.types' or in interface signature models.

A type model may import other type models by the following file import statement:

    import "myTypes.types"

The import mechanism works transitively: when a type model is imported, the models imported by it are also imported.

It is also possible to import namespaces:

    import myproject.types.*

File imports and namespace imports cannot be used together (see the Help page on namespaces).

Predefined types: bool, int, real, string, bulkdata.

Values of type real can also support the exponential notation with e. A value of type real has the syntax:

    3.2
    2.0e-5

Values of type bulkdata are uninterpreted byte arrays.

A value of type bulkdata has the syntax:

    Bulkdata<$optional_size$>

Examples:

Bulkdata<1000>
Bulkdata<>

Basic types Users can define their own basic types:

       type unit
       type uint
       type wstring
       type Pixel
       type Time
       type Command

User-defined basic types are uninterpreted, their set of values is unknown. It is possible to relate a basic type to one of the predefined types int, string, and real. In this way values of the predefined type can be used for the basic type:

`type unit base on int`

Enumeration types An example:

    enum Mode {
        updating
        working
        sleeping
    }

Refer to an element of an enumeration type by

    Mode::working

Optionally, enumeration literals may be assigned with non-negative integers:

    enum Mode {
        updating = 1 //if not explicitly given, the first literal assumes value 0
        working  //if not given, the value will increment the previous one, i.e. 2
        sleeping = 4 //user may give a value greater than the increment of the previous value
    }

Vector Types

Vector types are defined by giving a base type and a number of dimensions. For each dimension, an optional size can also be given.

vector Image = Pixel [ 10 ] [ 20 ]
vector Requests = Command []

Literal values of vector types have the syntax: <VectorType>[element1, element2, …​]. For example:

    <int[]>[] //example of empty vector of integers
    <int[]>[1, 2]
    <string[][]>[<string[]>["John", "Smith"], <string[]>["John", "Doe"]]

Record Types

    record Status {
        Image image1
        Pixel [10 ] [ 20 ] image2
        Time time
    }

In this example, the field image2 illustrates the possibility to use vector types inline, i.e. without giving an explicit name like in the case of type Image.

It is also possible for one record type to extend another:

    record Person {
        string name
        string address
    }

    record Student extends Person{
        string university
    }

Instances of record types have the syntax: TypeName{field1 = value1, field2 = value2, …​}. For example:

    Person{name = "John", age = 25}

Map Types

Map types are defined by giving the key and value types of the map. The key type must be a basic type or enumeration.

    aMapType = map<int, int>

Map types can also be used inline (without giving a name).

Instances of map types have the syntax: <type>{key1 → value1, key2 → value2, …​}. For example:

    <aMapType>{} //example of an empty map
    <map<int, int>>{1 -> 0, 2 -> 0}

Limitations for maps:

- Maps are not supported in simulation and test generation tasks. They can be used in behavior specifications (interfaces and component functional constraints) and are supported in monitoring tasks.

- Maps cannot be used as parameter and return types of events in signatures.

## Types Usage

Types are used in variable declarations and in event parameter declarations. Types are given either by name or as inline vector or map declarations (similar to C-family of languages).

Examples:

    variables
    int i //variable of the predefined type int
    Mode m //variable of enumeration type named Mode
    Image img //variable of named vector type

    int[] intVector //variable of inlined vector type

## Default Values

Every type has a default value. It is usually used to automatically initialize variables that are not explicitly given a value. Below are the default values for each type.

Default values:

- int: 0

- real: 0.0

- bool: true

- string: ""

- enums: the first enumeration literal

- records: a record with the default values for the field types

- vector: an empty vector

- map: an empty map