Use the Generator

This topic describes how to use the QtIVI generator.

Introduction

The Generator is a Python script that can be run manually or using the qmake Integration. This script uses QFace as the autogenerator framework which parses the IDL file, generates the domain model (similar to an Abstract Syntax Tree (AST)) and then feeds it to the generator. Depending on the type of the project to generate, different formats are specified.

Command Line Parameters

To run the generation, use the following command:

$$[QT_HOST_BINS]/ivigenerator/generate.py --format=backend_simulator interface.qface out_dir

The options and parameters are:

Option/ParameterDescription
--reload / --no-reload [optional]Specifies whether the generator should keep track of the changes in the IDL file and update the output on the fly; the default is --no-reload
-f, --formatCan be one of the following values:
  • frontend
  • qmlplugin
  • backend_simulator
  • backend_qtro
  • server_qtro
  • <folder>
-A, --annotations <annotation-file>Merges the given annotation file with annotations already in the QFace file and the implicit annotation file. These files are merged according to the order in which they are passed to the generator. Providing a duplicate key in the YAML file overrides the previously set value. This option can be used multiple times. For more information, see Merge Annotations.
sourcePath or paths to the IDL source files. If there are multiple entries, each one is handled. If a directory path is provided, it's scanned for IDL files.
outputdirThe destination folder for the generated files.
--helpDisplay options and exit.

Currently, based on the --format value, the generator can generate multiple types of projects with a given IDL file:

Project TypeDescription
frontend Generates an API using base classes from qtivicore and the Dynamic Backend System
qmlpluginGenerates a C++ QML Plugin which registers all types from the frontend in QML.
backend_simulator Generates a simulation backend for the API first generated by the frontend option. This backend serves as a mock implementation.
backend_qtro Generates a QtRemoteObjects based backend client for the API first generated by the frontend option. This backend connects to a backend server.
server_qtro Generates a QtRemoteObjects based backend server stub for the API first generated by the frontend option.
folder pathUses templates inside the folder. A YAML file with the same name as the folder should provide a list of template files in the folder. This is useful if you want to write your own templates. For more details, see Generation YAML.

Configure the Generator

The generator's Python script parses the input files and creates a domain model. This domain model is then passed as a context to the Jinja template engine. Use the Generation YAML file to specify which files to generate. Afterwards, you can use an Annotation YAML file to add more information to the IDL file, which is generator specific.

Generation YAML

After the domain model tree is created, this tree is traversed and each leaf of the domain model object tree (module, interface, structure, and so on) is passed to a specific Jinja template defined by the configuration file.

The Generation YAML file defines which template to use to generate which file. Suppose you want to generate a header file for each module in your domain model. But, a module can have multiple interfaces, so, you want to use a different header file for each interface and structure. In this case, the Generation YAML file defines a set of rules to specify which template file to use and how to name them.

This YAML file must have the following structure:

generate_rules:
    module_rules:
        -   dest_file:  "{{module.module_name|lower}}plugin.h"
        template_file:  "plugin.h.tpl"
    interface_rules:
        -   dest_file: '{{interface|lower}}backend.h'
        template_file: 'backend.h.tpl'
    struct_rules:

For every entity, there's a list of templates that must be called, when traversing this entity in the domain model tree. Here, dest_file is a name of the file that needs to be created, as specified in the Jinja template language format. The value of the object property used in the template's name is processed and substituted into the template, thus forming the final name of the file to create. dest_file is the name of the template to use. For the IVI generator, you must specify rules for three kinds of entities: modules, interfaces and structures.

Annotations YAML

Currently, not all aspects of the interface description can be expressed using the IDL itself. For instance, there is no language construct to define a default value for a property or a range of valid values a property can take. Still, this can be achieved via a mechanism called Annotations. Annotations provide freedom and flexibility to express any concepts and constructs.

The code snippet below shows an example of using annotations in the IDL. Here, we define an interface that is zoned, and specify its ID.

@config: {zoned: true, id: "org.qt-project.qtivi.ClimateControl/1.2"}

It does not make sense to place all of the annotations in the main IDL file. For instance, you may need to define some aspects of the auto-test code generation. Such annotations can be put in the YAML file that accompanies the main IDL file, with the same name. During the parse phase QFace automatically picks this file up and merges the annotation specified in this YAML file with those defined in the IDL file.

Since the accompanying YAML file is always picked up automatically, it won't work for annotations that you need for some specific projects, such as when generating a backend plugin. For this use case, you can pass multiple additional annotation YAML files to the generator.

In QtIvi, the following annotations are used to define IDLs:

TagWhereObject typePurpose
@config: {interfaceBuilder: "FunctionName"}
Main IDL fileModuleDeclares a function that is called in the plugin to generate the instances for every interface. The function takes a pointer to the plugin instance and returns a QVector<QIviFeatureInterface *>. Interfaces should be generated in the same order as defined by Plugin::interfaces(). Use this tag to instantiate classes derived from the generated plugin interfaces' classes.
@config: {zoned: true}
Main IDL fileInterfaceTells the generator whether the interface is zoned or not. Use this tag to define whether the backend feature interface is derived from QIviZonedFeatureInterface or QIviFeatureInterface.
@config: {id: "org.qt.project.qtivi.ClimateControl/1.0"}
Main IDL fileInterfaceDefines the interface ID, which is a string used by the QtIvi service manager to glue a frontend interface with its backend implementation. For more information, see Dynamic Backend System.
@config: {getter_name: "isHeaterEnabled"}
Main IDL filePropertyOverrides the default getter method's name. Useful for boolean properties, such as the getter for a property: 'enabled', should be 'isEnabled' instead of the default.
@config: {setter_name: "setHeaterEnabled"}
Main IDL filePropertyOverrides the default setter method's name.
@config: {qml_name: "ClimateControl"}

or

@config: {qml_type: "ClimateControl"}
Main IDL fileModule, InterfaceDefines the name this interface or module should use in QML. For interfaces, it is the name which is used to export the interface to QML. For modules, it defines the URI of the complete module. The last part of the URI is also used for the singleton that exports all enums to QML.

Annotations that are not logically part of the interface description, but rather the ones used to specify additional information, are put in the accompanying YAML file. Here is a list of annotations used to define the various aspects of generating a backend-simulator:

TagWhereObject typePurpose
config_simulator:
    simulationFile: ":/qrc/simulation.qml"
Accompanying YAML fileModuleDefines which simulation QML file the simulation backend should load. The snippet provided loads the QML file from the resource system, which the developer needs to embed.
config_simulator:
    zones: { FrontLeft,
             FrontRight,
             Rear }
Accompanying YAML fileInterfaceDefines a list of zones that the simulation code should support, for the backend simulator.
config_simulator:
default:
    AirflowDirection.Floor |
    AirflowDirection.Dashboard
Accompanying YAML filePropertyDefines the initial values for the property returned by the simulator backend.

For zoned properties, you can map a zone to a default value. The default key of the map is "=".

config_simulator:
default: {
    FrontLeft: 21.0,
    FrontRight: 22.5, =: 0.0
}
config_simulator:
minimum: 10
Accompanying YAML filePropertyDefines the minimum value for integer and real properties; the generated code in the simulator backend validates the value.
config_simulator:
maximum: 10
Accompanying YAML filePropertyDefines the maximum value for integer and real properties; the generated code in the simulator backend validates the value.
config_simulator:
range: [10, 20]
Accompanying YAML filePropertyDefines the range value for integer and real properties; the generated code in the simulator backend validates the value.
config_simulator:
domain: {10, 20, 30}
Accompanying YAML filePropertyDefines the possible values for the property; the generated code in the simulator backend validates the value.

Structure for Generated Projects

In the generator output directory, first, a new subfolder is created and named after the module ID. All the generated files are placed in this folder. The tables below describe the files that are generated for the frontend and backend.

Frontend

Generates a QML-friendly C++ API based on the Dynamic Backend System.

FilenamePurpose
global.hStandard file with global EXPORT defines.
module.h/cppFiles defining a module class used for module global variables and types.
module_enum.qdocincDocumentation for all values of all enums which can be included by qdoc.
modulefactory.h/cppFiles defining a module factory class used for factory methods for all structs.
.priA standard Qt .pri file that contains all the generated files. Use this .pri file to include the generated files into a qmake project.
qml/{{module|qml_type|replace('.', '/')}}/plugins.qmltypesQML code-completion file for use in QtCreator.
backendinterface.h/cppFiles defining the interface need to be implemented by the backend implementation of the feature.
.h/cppFrontend implementation of the feature, ready to be used from QML.
_p.hPrivate part of the frontend implementation.
.h/cppFrontend implementation for the struct, implemented as Q_GADGET.

QML Plugin

Generates a C++ QML Plugin which registers all types from the frontend in QML.

FilenamePurpose
plugin.cppThe C++ QML Plugin class.
.priA standard Qt .pri file that contains all the generated files. Use this .pri file to include the generated files into a qmake project.
plugins.qmltypesQML code-completion file for use in QtCreator.
qmldirQML config file to register the plugin with the QML plugin system.

Backend Simulator

Provides a simulator backend using the QIviSimulationEngine to implement the simulation behavior in QML files.

FilenamePurpose
plugin.h/cppFiles defining implementation of QtIvi backend plugin implementing QIviServiceInterface.
.jsonFile containing identifiers of the exposed feature interfaces needed by the Qt plugin system.
.priA standard Qt .pri file that contains all the generated files. Use this .pri file to include the generated files into a qmake project.
_simulation.qmlQML simulation file that loads the interface specific QML simulation files.
_simulation_data.jsonSimulation data exported from the config_simulator annotations.
.qrcQt Resource file that contains the QML and JSON files.
qml/{{module|qml_type|replace('.', '/')}}/plugins.qmltypesQML code-completion file for use in QtCreator.
qml/{{module|qml_type|replace('.', '/')}}/simulation/plugins.qmltypes"QML code-completion file for use in QtCreator for the simulation API.
backend.h/cppFiles containing the implementation of the simulation backend.
Simulation.qmlInterface-specific QML simulation files.

QtRemoteObjects Backend

The backend_qtro template is only available if qmake finds the QtRemoteObjects module. This remote object backend is a client for connecting to the remote backend server; not the location to implement the actual backend logic.

FilenamePurpose
plugin.h/cppFiles that define the implementation of the QtIvi backend plugin, which implements QIviServiceInterface.
.jsonFile containing identifiers of the exposed feature interfaces needed by the Qt plugin system.
.priA standard Qt .pri file that contains all the generated files. Use this .pri file to include the generated files into a qmake project. Also includes the .rep file to the project and calls the remote object compiler.
backend.h/cppFiles containing the implementation of the remote object backend. Establishes the connection and initializes the remote object replica.
.repThe input file for Qt’s replica compiler to produce the replica class code.
pagingmodel.repThe input file for Qt’s replica compiler to produce the replica class code for all models.

QtRemoteObjects Server

The server_qtro template is only available if qmake finds the QtRemoteObjects module. The code produced only contains the source classes to inherit and the code for establishing the connection. The developer must implement the actual backend logic.

FilenamePurpose
core.h/cppCode for establishing the connection and starting the remoting for the source objects.
.priA standard Qt .pri file that contains all the generated files. Use this .pri file to include the generated files into a qmake project. Also includes the .rep file to the project and calls the remote object compiler.
.repThe input file for the Qt’s replica compiler to produce the source class code.
pagingmodel.repThe input file for Qt’s replica compiler to produce the replica class code for all models.

QtRemoteObjects Simulation Server

The server_qtro_simulator template is only available if qmake finds the QtRemoteObjects module. The code produced contains a fully-implemented server that uses the same implementation as the backend_simulator template, which uses the QIviSimulationEngine to implement the simulation behavior in QML.

FilenamePurpose
_simulation.qmlQML simulation file which loads the interface specific QML simulation files.
_simulation_data.jsonSimulation data exported from the config_simulator annotations.
.qrcQt Resource file which contains the QML and JSON files.
qml/{{module|qml_type|replace('.', '/')}}/plugins.qmltypesQML code-completion file for use in QtCreator.
qml/{{module|qml_type|replace('.', '/')}}/simulation/plugins.qmltypesQML code-completion file for use in QtCreator for the simulation API.
core.h/cppCode for establishing the connection and starting the remoting for the source objects.
main.cppThe main file.
.priA standard Qt .pri file that contains all the generated files. Use this .pri file to include the generated files into a qmake project. Also includes the .rep file to the project and calls the remote object compiler.
.repThe input file for the Qt’s replica compiler to produce the source class code.
adapter.h/cppQtRemoteObjects Adapter classes for the backend implementations.
pagingmodel.repThe input file for Qt’s replica compiler to produce the replica class code for all models.
backend.h/cppFiles that contain the simulation backend implementation.
Simulation.qmlInterface-specific QML simulation files.

© 2020 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.