IfSimulator QML Type

The global object for parsing simulation data inside a QIfSimulationEngine. More...

• List of all members, including inherited members

Properties

• simulationData : object

Methods

• checkSettings(object data, var value, string zone)
• constraint(object data, string zone)
• defaultValue(object data, string zone)
• findData(object data, string interface)
• initializeDefault(object data, QObject*object)
• parseDomainValue(object data, string domain, string zone)

Detailed Description

The IfSimulator global object provides access to the simulation data of a QIfSimulationEngine and provides helper functions for parsing and checking boundaries.

Data Format

The IfSimulator expects its data already in a parsed form. Usually this is done by the QIfSimulationEngine::loadSimulationData() function, which expects the file to be in the JSON format.

Interfaces

Because a simulation QML file can use multiple interfaces, the simulation data supports multiple data sets as well. These are identified by the interface name in a reverse DNS notation:

{
  "QIfClimateControl": {
    ...
  },
  "org.qt-project.QIfWindowControl": {
    ...
  }
}

The findData() method can be used to find the data for a specific interface.

Properties

The settings (e.g. boundaries) for every property of the interface are defined inside a data set.

{
  "QIfClimateControl": {
    "airConditioningEnabled": {
      "default": true
    },
    "steeringWheelHeater": {
      "minimum": 0,
      "default": 0
    },
    "fanSpeed": {
      "range": [0, 5]
    }
  }
}

For the interface named QIfClimateControl, there are settings defined for the properties airConditioningEnabled, steeringWheelHeater and fanSpeed.

The settings object can store multiple constraints which are called domains. The following domains are currently supported:

default Holds the default value the property should have when the frontend is connected.

minimum Every newly set value needs to be bigger than this value

maximum Every newly set value needs to be smaller than this value

range Every newly set value needs to be between the two values in this list

domain Every newly set value needs to be part of this list

unsupported Changing the property is not possible and will show an "unsupported" error message

The value for a specific domain can be loaded using the parseDomainValue() function or using defaultValue() when only the default domain is of interest.

Structures and Enums

As JSON is not typesafe, structures and enums need to be stored in a special format. An enum can be stored like this:

{
  "QIfClimateControl": {
    "recirculationMode": {
      "default": {
        "type": "enum",
        "value": "QtIfVehicleFunctionsModule::RecirculationOff"
      }
    }
  }
}

Structures can be stored in a similar fashion using the name of the structure as type:

{
  "AddressBook": {
    "contactList": {
      "default": [
        {
          "type": "Contact",
          "value": [
            "foo",
            23,
            true
          ]
        },
        {
          "type": "Contact",
          "value": [
            "bar",
            12,
            false
          ]
        }
      ]
    }
  },
  }
}

To correctly initialize the structure with these values, the structure needs to provide a constructor taking a QVariant as argument. For the given contact example this constructor can look like this:

Contact::Contact(const QVariant &variant)
    : Contact()
{
    QVariant value = qtif_convertFromJSON(variant);
    // First try to convert the values to a Map or a List
    // This is needed as it could also store a QStringList or a Hash
    if (value.canConvert(QVariant::Map))
        value.convert(QVariant::Map);
    if (value.canConvert(QVariant::List))
        value.convert(QVariant::List);

    if (value.type() == QVariant::Map) {
        QVariantMap map = value.toMap();
        if (map.contains(QStringLiteral("name")))
            d->m_name = map.value(QStringLiteral("name")).value<QString>();
        if (map.contains(QStringLiteral("age")))
            d->m_age = map.value(QStringLiteral("age")).value<int>();
        if (map.contains(QStringLiteral("isMarried")))
            d->m_isMarried = map.value(QStringLiteral("isMarried")).value<bool>();
    } else if (value.type() == QVariant::List) {
        QVariantList values = value.toList();
        d->m_name = values.value(0).value<QString>();
        d->m_age = values.value(1).value<int>();
        d->m_isMarried = values.value(2).value<bool>();
    }
}

Zones

For zoned interfaces, the supported zones are usually stored as list in the zones property:

{
  "QIfClimateControl": {
    "zones": [
      "FrontLeft",
      "FrontRight",
      "Rear"
    ]
  }
}

For every supported domain it is also possible to provide zone specific values e.g.:

{
  "QIfClimateControl": {
    "targetTemperature": {
      "maximum": 30.0,
      "default": {
        "FrontLeft": 21.0,
        "FrontRight": 22.5,
        "=": 0.0
      }
    }
  }
}

This defines that the maximum value for the targetTemperature property is 30, the default value is zone specific and is 21.5 for the FrontLeft zone, while it is 22.5 for the FrontRight zone. The unzoned targetTemperature temperature is initialized with 0.0.

Property Documentation

Method Documentation