Modellgetriebenes Software-Engineering für C++ (MDE4CPP)

Das Model-Driven Engineering (MDE) ist ein allgemeiner Technischer-Ansatz der Modelle als wesentliche Grundlage zur Darstellung bzw. Analyse eines Sachverhalts sowie zur Lösung eines bestimmten Problems verwendet. Die Modelle werden dabei im kompletten Produkt- bzw. Projektzyklus verwendet und bilden die Grundlage zur generativen Erzeugung verschiedener benötigter Artefakte. Das Model-Driven (Software) Development (MDD) bildet einen Schwerpunkt der MDE zur modellgetriebenen und generativen Soft- und Hardwareentwicklung. Die Model-Driven Architecture (MDA) ist der MDD Ansatz der Object Management Group (OMG), der das Ziel verfolgt, die Lücke zwischen Modell und Quelltext zu schließen und den Automatisierungsgrad der Entwicklung zu erhöhen. Dies erfolgt durch eine automatische Generierung von Quellcode aus Domänenspezifischen Modellen, die auf definierten Domänenspezifischen Sprachen (DSL) beruhen. Im Ergebnis sollen die Fehlerquellen während der Entwicklung reduziert werden und die Software schneller, effizienter, kostengünstiger und qualitativ hochwertiger erstellt werden.

Dieser weit verbreitete und erfolgreiche Ansatz wird in verschiedenen Projekten und bei der Entwicklung verschiedener Produkten verwendet. Vorreiter dieser Entwicklung sind Java-basierte Tools und Toolchains wie das Eclipse Modeling Project (EMP). Für andere Sprachen stehen jedoch nur wenige, proprietäre oder rudimentäre Lösungen zur Verfügung. Ein Hauptgrund hierfür liegt darin, dass die benötigten Grundlagen, ein kompilierbares (Meta-) Metamodell, inklusive der notwendigen Reflection für andere Sprachen fehlt.

Das Ziel dieses Projektes ist es die Grundlage für das MDE für die Programmiersprache C++ zu legen.

Bestandteile des MDE4CPP-Projekts

Das MDE4CPP-Prjekt besteht aus mehreren Teilprojekten, deren gemeinsames Ziel es ist ausschließlich auf Grundlage von verschiedenen Modellen und unter Verwendung verschiedener Generatoren, vollständig lauffähige Applikationen zu generieren. Zu dem Projekt gehören folgende Teilprojekte:

  • ecore4CPP: Ein Projekt zur Erstellung von Domänenspezifischen Sprachen und Anwendungen unter Verwendung von ecore Modellen bzw. Metamodellen
  • UML4CPP: Ein Projekt zur Erstellung von Domänenspezifischen Sprachen und Anwendungen unter Verwendung von UML-Modellen bzw. UML-Metamodellen
  • fUML4CPP: Ein Projekt zur Generierung lauffähiger Applikationen bzw. zur Simulation von Abläufen auf Grundlage von UML-Aktivitätsdiagrammen
  • PSCS4CPP: Erweiterung der UML4CPP und fUML4CPP um lauffähige Applikationen iklusive der Semantik der Kompositionsstrukturdiagramme zu erzeugen.
  • OCL4CPP: Möglichkeit zur Erweiterung aller MDE4CPP-Projekte um Randbedingungen innerhalb der Modelle, innerhalb von Programmen oder zur Laufzeit, mittels OCL-Ausdrücken du definieren. (aktuell im Devlopment-Branch)
  • PSSM4CPP: Ein in Entwicklung befindliches Projekt zur Generierung lauffähiger Applikationen bzw. zur Simulation von Abläufen auf Grundlage von UML-Zustandsdiagrammen
  • UML-Designer (TU-Ilmenau-Fork): Fork des Obeo - UML-Designers (http://www.umldesigner.org). Ein mittels des Eclips Sirius projekts erstellter UML-Editor. Erweitert um UML Modelle für die MDE4CPP Bestandteile modellieren zu können.

Modellgetriebene Entwicklung mit Ecore für C++ (Ecore4CPP)

Grundlage dieses Teilprojektes ist es lauffähige Applikationen auf Grundlage von Ecore-Modellen zu erstellen. Grundlegendes Metamodel ist das ecore-Metamodell, das aus dem Eclipse-Modeling Framework. Mit Hilfe des ecore4CPP generators und einem C++Compiler wird aus dem ecore.ecore Modell eine ecore Bibliothek (binary und C++ Headerfiles). Das Metamodell dient ensprechend des Reflection-Pattern als Meta-Ebene für alle weiteren Anwendungen der ecore Modelle. Für alle weiteren Modelle (UML4CPP, fUML4CPP) dient das ecore-Metamodell als Beschreibungsebene (Metaebene). Desweiteren kann man das ecore4CPP-Projekte folgendermaßen anwenden:

  • ecore-basierte Applikationen erstellen (mittels C++ Programm EPackage, EClass, EAttribut usw. zur Laufzeit anlegen).
  • Die zur Laufzeit erstellten Modelle speichern und laden (xmi-konform).
  • Die gespeicherten Modelle mit anderen ecore-Tools (z.B.: Eclipse-EcoreTools) öffnen und bearbeiten.
  • Auf Grundlage eines irgrndwie erstellten ecore-Modells eine ecore-Bibliothek (Binary+Header) erstellen. Zum Beispiel: erstellen eines Familien-Metamodells; Generierung einer Familien-Bibliothek.
  • Durch Anreicherung von Operationen eines ecore-Modells mit C++ Quellcode und Definition einer Main-Operation (incl. Quellcode), Generierung einer Lauffähigen Applikation. Zum Beispiel: Programm zur Familienverwaltung.
  • Erstellung von Modellen auf Grundlage der generierten ecore-Modelle zur Laufzeit (z.B.: eine Familiendatenbank).
  • Speichern und laden von Modellen in Eclipse-EMF kompatiblen XMI-Dateien (z.B.: eine Familiendatenbank ans .xmi-Datei).
  • Laden und Editieren der gespeicherten Modell-Dateien mittels Eclipse-EMF generierten Editoren.

Weitere Informationen, eine Installationsanleitung, Beispiele und Tutorials finden Sie hier.

Modellgetriebene Entwicklung mittels UML für C++ (UML4CPP)

Grundlage dieses Teilprojektes ist es lauffähige Applikationen auf Grundlage von UML-Modellen zu erstellen. Grundlage des Metamodel ist das UML-Metamodell der OMG. Diese ist als uml.ecore-Datei in Eclipse verfügbar. Mit Hilfe des ecore4CPP generators und einem C++Compiler wird aus dem uml.ecore Modell eine UML Bibliothek (binary und C++ Headerfiles). Das UML-Metamodell dient ensprechend des Reflection-Pattern als Meta-Ebene für alle weiteren Anwendungen von UML-Modellen. Da das UML-Metamodell selbst auf ecore beruht, wird die UML entsprechend des Reflection-Pattern mithilfe des ecore-Metamodell zur Laufzeit beschrieben.

Desweiteren kann man das UML4CPP-Projekte folgendermaßen anwenden:

  • UML-basierte Applikationen erstellen (mittels C++ Programm alle Modellelemente der UML anlegen. z.B.: Package, Class, Attribut, Action, Activity, State, Interaction, Use-Case, usw. zur Laufzeit anlegen).
  • Die zur Laufzeit erstellten UML Modelle speichern und laden (XMI-konform als .uml-Modelle).
  • Die gespeicherten Modelle mit anderen UML-Tools (z.B.: UML-Designer oder Papurus) öffnen und bearbeiten.
  • Auf Grundlage eines erstellten UML-Modells eine Modell-Bibliothek (Binary+Header) erstellen. Zum Beispiel: erstellen eines Familien-UML-Metamodells; Generierung einer Familien-Bibliothek.
  • Durch Anreicherung von Operationen eines UML-Modells mit C++ Quellcode und Definition einer Main-Operation (incl. Quellcode), Generierung einer lauffähigen Applikation. Zum Beispiel: Programm zur Familienverwaltung.
  • Erstellung von Modellen auf Grundlage des generierten UML-Modells zur Laufzeit (z.B.: eine Familiendatenbank).
  • Speichern und laden von UML-Modellen in Eclipse-EMF kompatiblen XMI-Dateien (z.B.: speichern der Familiendatenbank als .xmi).
  • Laden und Editieren der gespeicherten Modell-Dateien mittels Eclipse-EMF generierten DSL-Editoren
  • Erstellung von Aktivitätsdiagramm, die mit der fUML-ausgeführt werden kann.
  • Erstellung von Kompositionsstrukturen, die zur Laufzeit entsprechend der Semantik der PSCS erstellt werden.
  • Grundlage zur Definition von OCL-Ausdrücken, die zur Laufzeit validiert werden können.
  • Erstellung von Zustandsdiagrammen, die zukünftig mit der PSSM-ausgeführt werden kann.

Weitere Informationen, eine Installationsanleitung, Beispiele und Tutorials finden Sie hier.

Modellgetriebene Entwicklung ausführbarer Aktivitätsdiagramme in C++ (fUML4CPP)

Grundlage dieses Teilprojektes ist es lauffähige Applikationen auf Grundlage von UML-Aktivitätsdiagrmmen zu erstellen. Die Grundlage ist das fUML-Metamodell der OMG. Die .xmi-Datei der Spezifikation wurde in eine fuml.ecore-Datei transformiert. Die Semantik, also die Java implementierungen der Operationen, wurde durch C++ Implementierungen ersetzt. Mit Hilfe des ecore4CPP generators und einem C++Compiler wird aus dem fUML.ecore Modell eine fUML Bibliothek (binary und C++ Headerfiles). Da das fUML-Metamodell auf ecore beruht, wird die fUML entsprechend des Reflection-Pattern mithilfe des ecore-Metamodell zur Laufzeit beschrieben. Mit Hilfe eines UML-Werkzeugs kann man UML-Anwendungsmodelle erstellen, die Aktivitätsdiagramme enthalten. Mit Hilfe der UML4CPP kann das erstellte UML-Anwendungsmodell eine Anwendungs-Bibliothek erstellt werden. Mit Hilfe des integrierten fUML-Generators werden die executions für die Ausführung der Aktionen bzw. Aktivitäten erstellt. Es wird der Locus als Ausführungsumgebung generiert. Anschließend kann das generierte Aktivitätsdiagramm ausgeführt werden.
Weitere Informationen, eine Installationsanleitung, Beispiele und Tutorials finden Sie hier.

Erstellung korrekter Kompositionsstrukturen mit C++ (PSCS4CPP)

Die Erstellung korrekter Kompositionsstrukturen und somit die Erstellung korrekter Exempalrkonstellationen entspechend der Semanik der PSCS ist Gegenstand dieses Teilprojektes. Die Grundlage ist das PSCS-Metamodell der OMG. Die .xmi-Datei der Spezifikation wurde in eine pscs.ecore-Datei transformiert. Die Semantik wurde in C++ implementiert. Mit Hilfe des ecore4CPP generators und einem C++Compiler wird aus dem pscs.ecore Modell eine PSCS Bibliothek (binary und C++ Headerfiles). Da das PSCS-Metamodell auf ecore beruht, wird die PSCS entsprechend des Reflection-Pattern mithilfe des ecore-Metamodell zur Laufzeit beschrieben. Mit Hilfe eines UML-Werkzeugs kann man UML-Anwendungsmodelle erstellen, in denen Kompositionsstrukturen (Kompositionen, Parts usw.) enthalten sind. Mit Hilfe der UML4CPP kann das erstellte UML-Anwendungsmodell eine Anwendungs-Bibliothek oder eine ausführbare Applikation erstellt werden bei der die Kompositionsstrukturen zur Laufzeit korrekt erstellt werden. Dieses Projekt enthält eine Umfangreiche Testsuite entsprechend der in der PSCS-Spezifikation definierten Testfälle.
Weitere Informationen, eine Installationsanleitung, Beispiele und Tutorials finden Sie hier.

Definition von Randbedingungen für Modelle in C++ (OCL4CPP)

Dieses Teilprojekt reichert alle anderen Projekte mit der Fähigkeit an, Modellabfragen mittels OCL zu spezifizieren und diese zur Laufzeit validieren zu können. Die Grundlage ist die Object Constraint Language (OCL) der OMG.  Die definierte Grammatik der OCL wird mittels ANTLR in C++ realisiert. Ausgehend von der MOF-Spezifikation der OCL wurde in eine ocl.ecore-Datei mit den notwendigen Typen und operationen zur Verarbeitung von OCL Ausdrücken realisiert. Mit Hilfe des ecore4CPP generators und einem C++Compiler und aus der erstellten Grammatik wird eine OCL Bibliothek (binary und C++ Headerfiles) zur Valisierung von OCL-Ausdrücken erstellt. Dies kann verwendet werden um:

  • OCL-Ausdrücke in C++ zu definieren und zur Laufzeit überprüfen zu lassen.
  • Modellabfragen in OCL als Stringeingaben zur Laufzeit ausführen zu können.
  •  Modellabfragen in Modelle integrieren zu können, die zur Laufzeit entsprechend validiert werden. Hierzu gehören:
    • ecore Modellabfragen
    • UML-Constraints in Klassen- und Aktivitätsdiagrammen

Auch zu diesem Projekt ist eine umfangreiche Tests und Beispiele verfügbar. Weitere Informationen, Beispiele und Tutorials finden Sie hier

Modellgetriebene Entwicklung von DSL's und DSL-Editoren für C++ - UML-Designer4MDE4CPP

Zur Erstellung der notwendigen Modelle für MDE4CPP kan prinzipiell jedes Modellierungswerkzeug, dass xmi-Konforme ecore bzw. uml-Diagramme als Speicherformat besitzt verwendet werden. Für die Modellierung spezieller Askekte der Aktivitätsdiagramme wurde ein Fork vom Obeo-UMLDesigner angelegt und um MDE4CPP spezifische Aspekte erweitert (self Pin, Opaque Behavior mit C++, ExpensionRegion/-Node, spezielle UML:Actions: wir Create-, Destroy und Opaque-Action).

Download und Installation

Hier finden Sie Informationen zum Download und zur Installation des MDE4CPP Projektes. Es werden die Installationsvoraussetzungen (C++ Comiler, Java, Eclipse, gradle usw. ) beschrieben. Es wird eine Kunrzinstallationsaneitung sowie Links zu den ausführlichen Installationsanleitungen angeboten. Ebenso können Sie Informationen zur Lizenz und zur übermittlung von von Beiträgen zum MDE4CPP Projekt erfahren. Schließlich finden Sie hier den Link zum Download bzw. zur github-Seite.