QtModeling

Qt Modeling

The Qt Modeling add-on module aims at providing basic model-driven features, such as the definition, storage, and manipulation of MOF/UML-based models as well as supporting new user-defined languages.

Rationale

Qt Modeling Framework rationale has been driven by the following desired properties:

• We should support automatic code generation as much as possible. Only 8.17% of UML 2.4.1 meta-model properties are declared as ‘derived’ (and not derived unions), which prevent automatic code generation. For those properties, the specification [omg.org] provide the guidelines for implementation but maybe some of them could be automatically derived from their OCL [omg.org] specifications. QtMof and QtUml libraries already provides a mapping from UML to Qt5 by first generating a more Qt-ish representation of a UML model (XQuery-based xmi to qtxmi conversion [qt.gitorious.org]) and then generating source code from a couple of well-design templates [qt.gitorious.org]. Such infrastructure has successfully been used to generate the initial skeletons of QtMof and QtUml and can also be used to convert user-defined UML models into Qt5 source code. As a consequence, we hopefully end up with a faithful implementation of OMG’s standardized meta-models.
• We should leverage the development of meta-model-agnostic tools [qt.gitorious.org] for editing, analysing, and converting any MOF-based model. By having no compile-time commitments with any specific MOF-based meta-model, such tool would be also able to handle other MOF-based meta-models (such as CWM [omg.org]) or even user-defined meta-models.
  QtMof and QtUml should provide a powerful modeling notation for early analysis of MOF-based models. A number of preset scripts for checking well-formed rules should be available and specific scripts may be defined by the user. OCL is a potential candidate as script language, but XQuery or even QtScript can also be considered. That would make possible, for example, analysis of conformance to architectural styles/patterns, continuously integrated models, and so on.
• A flexible mechanism for mapping of models into middleware/framework-specific artifacts should also be provided. A uml2qt mapping is already in place, but new ones should be easily defined.
• High adherence to OMG standards. That includes avoiding unjustified proprietary extensions. We should consider Diagram Definition [omg.org] specification when exporting/importing diagrams. UML 2.5 [omg.org] is on beta stage. QVT [omg.org] could also be supported in the future.

Current Status

The following features are already supported in Qt Modeling:

• UML 2.4.1 meta-model implementation
• MOF 2.4.1 meta-model implementation
• QtUmlEditor: model-agnostic (plugin-based) editor with full capabilities for model creation and XMI serialization
• Programmatic model manipulation via QtScript

Roadmap

Expected features (probably not in first Qt Modeling release) include:

• Refactoring for wrappedobjects-free implementation of meta-models
• OCL parser
• QML-based (extensible plugin-based) concrete syntax
• Enhanced code-generation architecture

Basic Usage

To link against the Qt Uml module, add this line to the project file:
Include the required headers:
And then you can programmatically create your models:
Maybe do some XMI serialization:

Projects using Qt Modeling

Qt Modeling has been motivated by and constitutes the basic model-driven platform for the DuSE-MT [duse.sf.net] project. DuSE is a flexible and extensible approach for architectural design spaces based on MOF [omg.org] (Meta Object Facility) and UML [omg.org] (Unified Modeling Language) technologies. DuSE defines a model-based meta-architecture which includes: i) a self-adaptation design space representation; ii) changes to be enacted in target system’s original model when navigating through the design space; iii) OCL rules which define valid variation points in each dimension; and iv) a set of metrics to guide architects during design trade-off analysis.

DuSE is a research project and an open source initiative carried out at Federal University of Bahia [ufba.br] (UFBa) and Federal Institute of Education, Science and Technology of Bahia [ifba.edu.br] (IFBa). The developers of DuSE are contributors of KDE / Qt Project and members of the Distributed Systems Laboratory [lasid.ufba.br] (LaSiD), a research center created in 1995 and that has performing researchs in the fields of Distributed Systems, Fault Tolerance, Real-Time, Mobile Agents, and Mechatronic Systems.

DuSE-MT [dusearchitects.files.wordpress.com]

DuSE-MT integrates DuSE’s design spaces meta-model, algorithms, and mechanisms into an extensible and user-friendly supporting tool. DuSE-MT defines a flexible architecture which enables the use of connector plugins for system identification in a range of platforms. Each connector plugin enables the probing of target systems developed for that specific platform, gathering input/output relationships between system’s controlled/measured parameters and allowing off-line and on-line system identification.

Contribute !

All contributions are pretty welcome as usual. All development is done through Gerrit [wiki.qt.io]. Therefore, those wishing to be involved in the development process must have a Qt developer account. More information about the registration process and development can be found here [wiki.qt.io].

For those of you who want just trying it out, simply clone the Qt Modeling repository:
and run the usual qmake/make recipe from a Qt5 installation.