openArchitectureWare - About
Overview
openArchitectureWare (oAW) is a suite of tools and components assisting with model driven software development built upon a modular MDA/MDD generator framework implemented in Java(TM) supporting arbitrary import (design) formats, meta models, and output (code) formats. Supportive tools (such as editors and model browsers) are based on the Eclipse platform.
openArchitectureWare is a "tool for building MDSD/MDA tools". At the core there is a workflow engine allowing the definition of transformation workflows as well as a number of prebuilt workflow components that can be used for reading and instantiating models, checking them for constraint violations, transforming them into other models and then finally, for generating code.
Core features
The following is a comprehensive list of the current features of openArchitectureWare.
- The workflow engine precisely control the generator's workflow basedon on an XML workflow definition.
- With a suitable instantiator, oAW can read any model. Currently, we provide out-of-the-box support
for EMF , various UML tools (MagicDraw, Poseidon, Enterprise Architect, Rose, XDE, Innovator, ...),
textual models (using JavaCC or antlr parsers as frontends), XML, Visio as well as
pure::variants variant configuration models.
- Explicit support for the Eclipse UML2 metamodel
- Can generate any kind of output based on a powerful template language called Xpand
that supports template polymorphism, template aspects and many other advanced features necessary
for building non-trivial code generators such as template polymorhpism, aspect-orientation on
template level, optional typing of model elements, and sorting and filtering of element sets.
- Explicit domain metamodel: the metamodel of the problem domain is represented as Java classes.
Metamodels can either be built using Eclipse EMF or by using oAW's own metamodel generator that
creates those Java classes from metamodels rendered in UML. The generator already comes with
the most important UML metaclasses, which can be reused to build UML profiles.
- Various ways of checking model constraints: a semi-declarative checking using Java APIs, a
proprietary declarative constraints checking language as well as optional OCL integration
based on the Kent OCL framework.
- Support for multiple models: you can read several models as part of one generator run.
These models can use different concrete syntaxes (one could be UML, the other XML and a
third one Visio). The generator then "weaves" these models together to form a comprehensive,
all-encompassing model in the generator. Constraints can be checked over model boundaries;
references among models can be established.
- Model-to-model transformations can be implemented using the Wombat language, a this textual,
functional transformation language. There are two very important properties of this language:
first, it has a very concise and powerful syntax. Second, it can transform between the various
metametamodels, i.e. you can e.g. transform a model defined with the oAW-classic metametamodel
into an EMF model! Alternatively you can integrate third party transformation languages such
as ATL. An Adapter is provided.
- The Recipe Framework allows to define validation rules for artefacts created outside of the
generator (such as manually written subclasses). During code generation, those rules
can be instantiated; later, the Eclipse IDE will read these checks and verify them.
This will help to guide developers beyond the modelling/generation stage.
- Complete modular design: You can enhance or extend any of the framework components
as you see fit
IDE Features
openArchitectureWare comes with a number of Eclipse Plugins that help make development more efficient.
Here are a couple of screenshots.
The following one shows the Xpand template editor. In addition to syntax highlighting,
it provides metamodel-aware code completion facilities as well as static error checking.
You can also define metamodel extensions, i.e. properties on metaclasses that are available in
the template language. They are defined externally to the metamodel implementation classes.
A model structure view helps you view and understand models that have been parsed from UML or
other sources. For EMF based models this is not necessary since the EMF-supplied editors
provide the exact same functionality.
The checks verified by the recipe framework can be redered nicely in an Eclipse view. Changing
something in the manually written source code will update the checks in real time.
