Humboldt-Universität zu Berlin - Mathematisch-Naturwissenschaftliche Fakultät - Systemanalyse




The development of software systems in general and software components in particular becomes a more and more challenging task. The key solution for handling the complexity in the development process is the modeling of software systems and the transformation into implementation.

We demonstrate an application of OMG's Model Driven Architecture (MDA) in the context of component development, where different languages such as eODL, SDL, CIDL and C++ are involved.

The application of model transformation is based on eODL as a platform independent modeling (PIM) language. We used type based mapping rules to define the transformation. We show the concrete implementation of these rules based on MOF repositories as model storage and the usage of Java to perform the transformation actions. The Java technology Meta Data Repository (MDR) builds the base for an on-demand MOF repository creation in our approach. The handling of syntax based language is considered for integration purposes.


ITU-eODL is used for component-oriented development of distributed systems from the perspective of four different but related views: the computational, implementation, deployment and target environment view. Each view is connected with a specific modelling goal expressed by dedicated abstraction concepts. Computational object types with (operational, stream, signal) interfaces and ports are the main computational view concepts which describe distributed software components abstractly in terms of their potential interfaces. Artefacts as abstraction of concrete programming language contexts and their relations to interfaces form the implementation view. The deployment view describes software entities (software components) in binary representation and the computational entities realized by them. The target environment view provides modelling concepts of physical network onto which the deployment of the software components shall be made. All concepts of the views are related to each other. These relations form an essential base for techniques and tools that support the software development process from design via implementation and integration to deployment.


The OMG Component Implementation Defintion Language (CIDL) is a language used to describe the structure and state of component implementations. Component-enable ORB products generate implementation skeletons from CIDL definitions. Component builders extend these skeletons to create complete implementations.


etoc consists of three different stages: the input handling, the transformation itself and the output handling.

input handling

The eODL Parser and the Z130Injector provide the interface to eODL syntax based input.


etoc provides the transformation from eODL to CIDL itself.

output handling

The CCMModelWalker generates syntax based output (CIDL syntax).

As you can see in the figure it is also possible to use direct input (eODL XMI, Z.130 extent) and to generate direct output (CIDL extent, CIDL XMI). Both are syntax independent.

User guide

There are two possible kinds of using etoc, which comes as a jar-File and can be obtained from this site, first it can be used as a command-line tool second as a library for programming or tool integration.

Using etoc as a command-line utility allows you to transform an eODL model in XMI representation as well as in eODL syntax into a CIDL model in XMI representation or in CIDL syntax. To seperate between the possibilities of input and output two parameters can be specified one for the input and one for the output file. Besides these two parameters you can also define a parameter to switch the transformation of the implementational view on or off. The default value defines the transformation from eODL syntax to CIDL syntax without handling of the implementational view. This can be seen in the following example, note that for runnig etoc you need JAVA VM 1.5.

java -jar etoc.jar example.eodl

The definition of the parameter -transformImpl enables the implementational support of etoc.

java -jar etoc.jar -transformImpl example.eodl

The transformation from a XMI file is done by using the parameter -i with the value xmi if no output parameter is defined the default case is used, that means CIDL syntax.

java -jar etoc.jar -i xmi example.xmi

To achieve an output in XMI the paramter -o with the value xmi has to be specified.

java -jar etoc.jar -o xmi example.eodl

Acccording to the input file name an output file in the directory of etoc.jar is generated with the <input file name>.idl. Using the XMI output ability the filename is <input file name>.idl.xmi, because of seperation between the XMI input and output file.

For the usage of etoc as a library please refer to the API section.


The download of etoc is made available as a zip file containing etoc in jar format and three folders: example, lib and metamodel. The example directory contains an eODL example of the dining philosophers in syntax format (dining_philosophers.eodl) and the resulting transformed model (dining_philosophers.idl). All required libraries of MDR, ANTLR and JMI for running etoc are within the lib folder. The metamodel directory contains both metamodel (CIDL and eODL) in XMI format.

Download (

The source code will be made available soon.


The API of etoc can be found here (


Paper ( for the SDL Forum 2005.


eODL (





CCM Metamodell (XMI) (

eODL Metamodell (XMI)