Etoc
| Inhaltsverzeichnis |
Introduction
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
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.
CIDL
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.
Architecture
etoc consists of three different stages: the input handling, the transformation itself and the output handling.
input handlingThe eODL Parser and the Z130Injector provide the interface to eODL syntax based input.
transformation
etoc provides the transformation from eODL to CIDL itself.
output handlingThe 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.
Download
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.
API
The API of etoc can be found here (http://www.informatik.hu-berlin.de/~kvoigt/etoc/doc).
Publication
Paper (http://www.informatik.hu-berlin.de/~schuetze/SDLForum2005.pdf) for the SDL Forum 2005.
Resources
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)
CCM Metamodell (XMI) (https://www.informatik.hu-berlin.de/forschung/gebiete/sam/Forschung%20und%20Projekte/aktuelle-forschung-und-projekte/softwarekomponenten-entwicklung/eodl-projects/etoc/ccm_metamodelv2.xml)