3. Generator

The Ecore Metamodel Generator

The creation process is divided in two steps to avoid problems with cyclic data type references. First, all packages and types are created, including their inheritance and realization relations. Then, in a second step, all operations, references and attributes are created. This step also created the data type package hierarchy, which contains all EDataType instances.

The Generator in the package eme.generator consists out of eight different generator classes and a subpackage eme.generator.saving:

• EcoreMetamodelGenerator is the main generator class, it manages the whole generation process and handles the other generator classes. To create an Ecore metamodel from an intermediate model, use this class exclusively, it manages the calls to all other generators. Creating a metamodel can be achieved with the method generateMetamodelFrom(). The main generator class also manages the saving strategy. Initially the saving strategy is set according to the properties class, but it can be changed during the runtime with the method call changeSavingStrategy(). A metamodel is saved (if previously generated) with the method saveMetamodel()

• EPackageGenerator is the class that generates packages of the metamodel (EPackage objects) from the intermediate model. The functionality of the class is tied to its instance of an intermediate model. Because this, it is important to create a new EObjectGenerator for each intermediate model. The class offers the method generate() for the creation of a metamodel, which is of type EPackage. The method automatically creates Ecore objects for all the contained elements (subpackages, classes, methods etc.) of the intermediate model.

• EClassifierGenerator is used by the EPackageGenerator to generate the content of the packages. It offers two methods: generateEClassifer() generates an EClassifier from an ExtractedType. If the type already generated, it simply returns the EClassifier of the type. completeEClassifiers() finishes the EClassifier generation by adding methods and attributes to the classes. Also it sorts the external types.

• EOperationGenerator is used by the EClassifierGenerator to generate the methods of the classifiers. It offers only one method: addOperations(). That method takes an ExtractedType and an EClass as parameters. It then generates EOperation objects for every method of the ExtractedType and adds them to the EClass.

• EDataTypeGenerator is used by the classes EClassifierGenerator and EOperationGenerator to manage data types. The class stores a map that maps data type names to the data types themselves. It also creates and stores new data types. It offers the methods generate(), generateGeneric(), addGenericArguments(), addTypeParameters() and isTypeParameter(). generate() creates an EClassifier from an ExtractedDataType. There are three possibilities what that EClassifier can be in that context:

  1. The EClassifier is an already created classifier (class, interface or enumeration).
  2. The EClassifier is a basic EDataType which has an Ecore equivalent (e.g. int, java.lang.Integer or java.lang.Object).
  3. The EClassifier is an external data type without an Ecore equivalent and is created and stored as new EDataType which is contained in the root package.

  The method generateGeneric creates a generic type parameter, which is an EGenericType, from an ExtractedDataType. The type parameter can be used as generic argument for methods and attributes. This has to be used instead of generate() to create a data type, if a data type is a type parameter. The method isTypeParameter() checks whether an ExtractedDataType is a type parameter of an EClassifier. If this is the case, one has to use the method generateGeneric() instead of generate() for the data type creation.

  The method addGenericArguments() adds all generic arguments with their own generic arguments from an ExtractedDataType to an EGenericType. This method is separated from the method generate(), because generic type arguments are added to the EGenericType instead of the EType of an ETypedElement, even if the data type is not an EGenericType. The method addTypeParameters() creates all type parameters of an ExtractedType and adds them to an EClassifier.

  To use the EDataTypeGenerator one has to call the constructor with three parameters. The first one is the intermediate model. The second is the list of created EClassifier objects of the EobjectGenerator. This is needed to check whether a data type is an already created EClass. The third parameter is the ExternalTypeHierarchy object, which is needed to manage the containment of external types.

• ExternalTypeHierarchy builds the external data type package hierarchy in the root package. It adds a data type package to the root package and contains every external EDataType in a package hierarchy in the data type package to avoid name collisions. An external data type can be added with the method add(EDataType dataType), which automatically manages the package creation. The method sort() sorts the content of the external type package hierarchy alphabetically.

• SelectionHelper contains the check methods. These methods check for a specific model element whether it may be generated. This depends on whether the element is selected or not and whether the properties allow the generation of such elements. Whenever an element may must not be generated, the SelectionHelper stores that information. The method generateReport() then allows to produce a report about what kind of elements were not generated and how many of them were not generated. The report distinguishes between Packages, Interfaces, Classes, Enumerations, Constructors, Methods and Attributes.

• EMFProjectGenerator can be used by saving strategies to create an empty EMF project in for the Eclipse IDE.

• The subpackage eme.generator.saving is explained in the next chapter.