Home
The Ecore metamodel extraction was originally developed as a part of a bachelor's thesis. The thesis is accessible at KITopen. This wiki contains three kinds of information: How to use the project, how to work with the source code of the project and general information about the architecture and the internal processes. The Ecore metamodel extraction is used in the project JavaCodeEcorification.
The project can be used in two different ways. One can use the project as an Eclipse Plugin through the MainHandler class or address the main class 'EcoreMetamodelExtraction' directly.
-
When using it as a plugin, projects can be selected for the extraction via the package explorer context menu or the EME button at the toolbar. The extraction is executed with the constraints of the user properties file. To use the project this way, run the project as Eclipse Application. The extracted Ecore metamodel is saved according to the selected saving strategy.
-
When working with the class
EcoreMetamodelExtractiondirectly, it offers two simple methods to work with. The methodgetProperties()grants access to the instance of the classExtractionProperties, which allows configuring the extraction process programmatically (see Properties). This can also be done by editing the properties file before running the program. With the methodextract()the metamodel extraction is started for a givenIProject.
For demo purposes, the repository EME-TestProject can be used. It is a simple Java project containing code that allows testing the extraction of the different supported features. See the project README for installation hints.
This project is a reverse engineering tool for Ecore metamodels. It allows extracting Ecore metamodels from any arbitrary Java code. At the core of the approach is a mapping from elements of the implicit Java metamodel, which the Java Language Specification defines, to elements of the Ecore meta-metamodel. Both models are very similar in many ways, but they are not identical. That means the Ecore meta-metamodel cannot be used to represent Java code perfectly. As a result, some features of the Java language can only be extracted under certain conditions, while other features cannot be extracted at all. For a more detailed description of the differences see the page Model Differences.
This program extracts packages with their hierarchy, interfaces, classes, enumerations with their enumerals, inheritance and realization relations, attributes, methods with their parameters, return types and throws declarations, generic types with their type parameters, generic arguments, and wildcard types.
To further understand how the project extracts Ecore metamodels from Java code, you have to look at the extraction table. It depicts the mapping between different elements of the language Java and their relating Ecore elements. The left column contains the Java elements. The right column contains the Ecore elements which are generated from the extracted features. The middle column shows another set of elements. These are the relating elements of the intermediate model. The intermediate model is an internal model which is used for the extraction. That means we internally map from Java elements to intermediate model elements and intermediate model elements to Ecore elements.
| Java Model (implicit) | Intermediate Model | Ecore Meta-Metamodel |
|---|---|---|
| Package | ExtractedPackage | EPackage |
| Type | ExtractedType | EClassifier |
| Class | ExtractedClass | EClass |
| Interface | ExtractedInterface | EClass |
| Enum | ExtractedEnumeration | EEnum |
| Enumeral | ExtractedEnumeral | EEnumLiteral |
| Field | ExtractedField | EStructuralFeature (EAttribute / EReference) |
| Method | ExtractedMethod | EOperation |
| Method Parameter | ExtractedParameter | EParameter |
| Method Return Type | ExtractedDataType | EClassifier / EGenericType |
| Method Throws Declaration | ExtractedDataType | EClassifier / EGenericType |
| Generic Type Parameter | ExtractedTypeParameter | ETypeParameter |
| Generic Type Argument | ExtractedDataType | EGenericType |
| Generic Type Bound | ExtractedDataType | EGenericType |
| Super Type Reference | ExtractedDataType | EClass & EGenericType |
Even though the project consists out of ten packages, the general architecture can be broken down into three parts: The project extractor, the intermediate model, and the metamodel generator. The extractor analyzes a Java project using the JDT API and extracts all the information the implicit model of the Java code contains. With this information, the extractor then builds an intermediate model. The generator then uses the intermediate model to build an Ecore metamodel. The Ecore metamodel is built like a tree structure out of EObjects, with a root package as a container of all the elements of the metamodel. The generator also can save the generated Ecore metamodel as an Ecore file. For this process, there are several different saving strategies available.
The whole extraction process is depicted in the following diagram:
The projects main package eme contains five subpackages: eme.extractor, eme.model, eme.generator, eme.properties and eme.handlers. The packages eme.extractor, eme.model and eme.generator contain the three key components which were explained before. The eme.properties package contains the classes for the management of the properties file. The package eme.handler contains the main handler, which allows using the project as a plugin for the Eclipse IDE and offers a simple dialog for choosing an input project.
To understand the different parts of the project, see the following pages: