6 Data Types

Like in other programming languages, in the Rule Language different data types are defined which are described below.

6.1 Collection Data Types

The following collection data types are allowed in the IDM. Please note that only scalar types are permitted for the addressing as well as for the addressed single values. Therefore a structure of multidimensional lists is not possible.

Table 21-1: Data types for collections

Similar to predefined vector and matrix attributes like .content[], .userdata[] etc. an expansion of collections directly after their last element is possible and allowed.

However, it is not possible to use these collection data types for user-defined attributes. User-defined and predefined attributes do not have a unique assignment (attributes exist on an object in both a scalar and a field variant) and allow for unindexed access to the default value.

6.1.1 Syntax of Expressions

<list> = [ <data type> ] '[' [ <expression> { ',' <expression> } ] ']'
<hash list> = [ <data type> ] '[' [ <expression> '=>' <expression>
    { ',' <expression> '=>' <expression> } ] ']'

Examples

[1, .xleft, 17+4, Wi.Pb]
["CBS" => 2, itoa(7) => 7]
matrix[ [1,1]=>"first name", [1,2]=>"last name", [1,3]=>"telephone no." ]

6.1.2 List Size and Default Values

In principle, each collection data type has a current size, which results from the values set. There are no value gaps in this currently valid indexing range, only unset values (see also the descriptions of itemcount(), countof()).

In order to achieve consistency with the previous static local variables, the data types hash, list and matrix allow for a default value.

This is displayed at unset value positions within the currently valid indexing range up to the current size. For hash data types, if the default value is set, it is returned for all possible indexings.

The sequence of access to the default values for an unset value at the position <row>,<col> in a matrix M is M[<row>,<col>] → M[0,<col>] → M[<row>,0] → M[0,0].

The access sequence to the default value for an unset value at <index> in a list L is L[<Index>] → L[0].

6.1.3 Access and Assignment of Collections

The indexed values (items) of a collection are accessed via the [] operation, just as known for local variables or predefined and user-defined attributes.

Without the [] operation, the entire value is fetched or set.

Attention

It should be noted that accessing a user-defined or predefined attribute without the [] index fetches or sets the default value or scalar attribute. To fetch or set all values of an attribute, the functions getvector() or setvector() should be used.

Examples

variable list Primes := [2,3,5,7,11,13];
variable vector[integer] Numbers;
variable hash Months := [1=>"Jan", 2=>"Feb", 3=>"Mar"];

print Primes[1];
Months[4] := "Apr";
Numbers := Primes;
Primes[0] := -1;
Primes := [17, 19, 23];

Output of collections via print or sprintf() is also possible. However, no default values are output. For the data types hash and matrix the output is including the index.

Specific Features of refvec

It should also be noted that the refvec data type is handled in a special way because it ensures uniqueness of the values and does not store null values.

With an indexed assignment of an already existing object ID, the object ID at this position is replaced and afterward uniqueness is ensured, which may also result in a shift of the already existing object ID to another position and a reduction of the refvec list.

In case of an indexed assignment of a null, the object ID is deleted from the refvec list and the following object IDs advance, which in turn results in a reduction of the refvec list.

6.1.4 Automatic Conversion

In assignments or parameter calls, collections are automatically converted to the required list type. All values without index are copied in their natural order, including the default values if possible, e.g. [0] for a list variable will be passed on if the target type also has a default value.

Exception

When assigning a hash with index data type to a matrix, the index will be taken over. With the reverse assignment of a matrix to a hash, the index will also be transferred. To prevent this, the built-in function values() should be used.

6.1.5 Performance

In general, it should be considered that the use of collections (entire values) within expressions initially requires the values to be copied, but then in reading operations only references of this list are used, i.e. without further copying. This ensures the necessary performance when working with collections. Passing on to application functions or manipulation by built-in functions, however, requires another copy action, possibly with a code page conversion of string values.

For this reason, it should be kept in mind that complex expressions that process collections may well temporarily lead to large amounts of data. Coding and splitting of expressions should take into account the maximum list sizes.

6.1.6 Local and Global Variable

The collection data types are available for local and global variables. It is also possible to initialize a global collection with constant values.

Until now, local, static variables could also be an array or an associative array, which only could be initialized in a very limited way. Collection data types are now allowed for both local and local static variables. The initialization expression is no longer restricted.

Attention Behavior Change

The existing notation of arrays and associative arrays for static local variables is still allowed and mapped to the data types list or hash. The static initialization via .<identifier>[<index>] := <value>; after the variable part is no longer possible to ensure consistency with other local variables! The initial value sets the entire value of the variable, not just the default value!

Example

dialog D

variable hash Prices := [ "iMac" => 1300, "Samsung Tab" => 300 ];
variable vector[string] Weekdays := ["Mon","Tue","Wed"];

on dialog start
{
  variable string Stations[integer] := [1=>"ABC", 2=>"CBS"];
  variable hash Stations2 := [3=>"NBC", 4=>"HBO"];
  static variable list AllStations := join(Stations,Stations2);
  /* No longer allowed:
   * variable string Stations[integer] := "UNKNOWN";
   * .Stations[1] := "ABC";
   * or
   * static variable integer AssArray[string] := -1;
   * Instead possible:
   * static variable integer AssArray[string] := [nothing=>-1];
   */
  exit();
}

6.1.7 Relational Operators

For collections, only the relational operators = and <> are allowed.

Equality prevails under the following conditions:

1. The data type must be the same.
2. All contained values or index/value pairs must be equal, including the default values.
3. The number of values contained and their positions must be the same.

Comparison between a string and a text ID is done on a string basis.

When using relational operators, particular attention should be paid to the data type.

Example

dialog D
window Wi {
  listbox Lb {
    .content[1] "Sat";
    .content[2] "Sun";
  }
}
on dialog start {
  variable list WeekendDays := ["Sat", "Sun"];
  variable hash DayNumber := ["Sat"=>6,"Sun"=>7];
  variable list Days;

  print WeekendDays = getvector(Lb, .content);
  print vector["Sat","Sun"] = getvector(Lb, .content);
  print values(WeekendDays) = values(getvector(Lb, .content));
  print WeekendDays = keys(DayNumber);
  Days := WeekendDays;
  WeekendDays[0] := "??";
  print Days=WeekendDays;
  exit();
}

Output

false => Different data types (list<>vector)
true
true
true
false => WeekendDays has a default value, but Days does not!

6.1.8 Uninitialized variables

As before, the IDM behaves differently when accessing uninitialized values. If an uninitialized local or static variable is accessed, nothing is returned. When accessing an uninitialized global variable ( equivalent to a variable object) or a user-defined attribute, access is denied with a cannot get value error.