Direkt zum InhaltDirekt zur SucheDirekt zur Navigation
▼ Zielgruppen ▼

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

EODL projects


The provision of efficient techniques and of tool support for the development and engineering of distributed systems is a key enabling factor for the further evolution of Information Technology. Telecommunication systems as special distributed systems consisting of components which are distributed across networks and have to cope with concurrency, autonomy, synchronisation, and communication aspects. The development of highly efficient and scalable systems is a complex and complicated task, where tools have to support all phases of the development process – from requirements capturing over design and implementation to integration, test and deployment. Code generation out of object oriented design models leads to reusable, executable components. Such components integrate runtime environment and middleware platform technology dependent aspects with the enterprise specific object oriented design model. Each software component has a physical representation (e.g. binary file), which has to be available for execution on a special node of a distributed system.

Techniques for the development of distributed systems contribute significantly to a reduction of the time to market distributed applications and telecommunication services. An appropriate treatment of all kinds of communication aspects lies in the very nature of the targeted application domain. These aspects span from transactional requirements on object interactions over quality of service issues to security policies. Taking into account the broad acceptance of object middleware technology, middleware platforms provide an ideal implementation environment for such designs. Technologies, among them are plain CORBA, CORBA Components and other distributed processing platforms.


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.



With etoc 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.


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 etoc_0.1.zip (http://www.informatik.hu-berlin.de/~kvoigt/etoc/etoc_0.1.zip).

The source code will be made available soon.


The API of etoc can be found here (http://www.informatik.hu-berlin.de/~kvoigt/etoc/doc).


Paper (http://www.informatik.hu-berlin.de/~schuetze/SDLForum2005.pdf) for the SDL Forum 2005.



Qedo is a concrete implementation of the CORBA Component Model (CCM).


Programmers used to use independent computers to solve problems. Today interlaced computers are mostly used to solve problems. There are two kinds of computer networks: homogeneous and heterogeneous networks. Heterogeneous networks include computers with different architectures and different operating systems. One intends to make procedure calls at objects within the network. Therefore they need a protocol. That is possible with CORBA. CORBA is a technology which enables the realization of distributed, object-oriented applications. This technology is based on CORBA objects, which make their services available by interfaces. CORBA objects may be used irrespective of the platform and programming language. There is a special language which describes the interfaces: the Interface Definition Language (IDL).

CORBA Component Model (CCM)

The CORBA Component Model is based on CORBA and is standardized by the OMG. A component possesses contractually specified interfaces and only explicit context dependencies. It can be installed independently of other components and be used by others for compositions. Thus, a component is a unit which is independently installable, which encapsulates its internal structure and which can be subject of a composition.

Qedo - implementation

Qedo (Quality of Service Enabled Distributed Objects) is a concrete implementation of the CORBA Component Model. OMG standards are only accepted, if there is at least one implementation of this standard. Therefore, it was necessary to implement the concepts of the standard and to examine these for correctness and appropriateness. Qedo is a C++-implementation of the CORBA Component Model. All components of the run time environment and the tools are object-oriented written in C++. It works with Windows and Linux. Under Windows the Microsoft-C++-Compiler is supported. Under Linux the GNU-C++-Compiler.


eODL (http://www.itu.int/itudoc/itu-t/aap/sg17aap/history/z130/z130.html)

CIDL (http://www.omg.org/cgi-bin/doc?formal/02-06-70)

MDR (http://mdr.netbeans.org)

ANTLR (http://www.antlr.org)

JMI (http://java.sun.com/products/jmi/index.jsp)

CORBA (http://www.omg.org/corba/)