Table of Contents

1. Ant description
2. OpenCCM available targets
3. Build process structure
   1. File structure
   2. Build process structure
4. OpenCCM available tasks
   1. List of tasks
   2. Cleaning CORBA files
   3. Checking Java files
   4. Generating Java empty interfaces
   5. Generating JAR archives from a package
   6. Merging multiple archives into a single one
   7. Compiling an OMG IDL2 file
   8. Generating an XML parser from a DTD file
   9. Compiling an XML parser
   10. Using the launcher from Ant
   11. Starting the OpenCCM Interface Repository
   12. Feeding an OMG IDL 3.0 file into the OpenCCM Interface Repository
   13. Generating equivalent OMG IDL 2.4 mapping from the OpenCCM Interface Repository
   14. Generating the Java OpenCCM skeletons from the OpenCCM Interface Repository
   15. Generating all the Java implementation templates from the OpenCCM Interface Repository
   16. Compiling an OMG CIDL file and generating associated files
   17. Generates all Java OpenCCM templates associated to a CIDL file for the CIF
   18. Compiles an OMG PSDL file and generates associated Java mapping
   19. Stopping the OpenCCM Interface Repository
5. How to integrate a piece of code?
   1. Integrating source code into an existing package
   2. Integrating source code into a new package
   3. Defining a new module

Ant description

Apache Ant is a Java-based build tool. In theory, it is kind of like make, without make's wrinkles.

Makefiles are inherently evil as well. Anybody who has worked on them for any time has run into the dreaded tab problem. "Is my command not executing because I have a space in front of my tab?!!". Tools like Jam took care of this to a great degree, but still have yet another format to use and remember.

Ant is different. Instead of a model where it is extended with shell-based commands, Ant is extended using Java classes. Instead of writing shell commands, the configuration files are XML-based, calling out a target tree where various tasks get executed. Each task is run by an object that implements a particular Task interface.

Granted, this removes some of the expressive power that is inherent in being able to construct a shell command such as `find . -name foo -exec rm {}`, but it gives you the ability to be cross-platform - to work anywhere and everywhere. And hey, if you really need to execute a shell command, Ant has an <exec> task that allows different commands to be executed based on the OS it is executing on.

OpenCCM available targets

Currently, OpenCCM supports the following main targets:

Build process structure

File structure

The build process is composed of the files which are stored in the <OpenCCM directory>/src/ant directory. The process is splitted into as modules as files described below:

Each XML file is associated to a property file which contains the definition of properties required for the OpenCCM build process. The build.user file contains the template for build.properties file which would be completed by OpenCCM users.

Build process structure

The build process has been divided into modules and callbacks. Modules group packages related to the same domain. Callbacks are specific entry points which are defined and called by the main build.xml file during the compilation process. The existing callbacks are:

The definition of callbacks is quite stable, so please don't define other terms and use these callbacks in priority.

OpenCCM available tasks

List of tasks

Cleaning CORBA files

The task_clean_corba_unused task supports the following arguments:

Checking Java files

The task_java_available task supports the following arguments:

Generating Java empty interfaces

The task_java_gen task supports the following arguments:

Generating JAR archives from a package

The task_package task supports the following arguments:

Merging multiple archives into a single one

The task_package_merge task supports the following arguments:

Compiling an OMG IDL2 file

The task_idl2java task supports the following arguments:

Generating an XML parser from a DTD file

The task_dtd2java task supports the following arguments:

Compiling an XML parser

The task_dtd_compile task supports the following arguments:

Using the launcher from Ant

The task_launcher task supports the following arguments:

Starting the OpenCCM Interface Repository

The task_IR3_start task supports the following arguments:

Feeding an OMG IDL 3.0 file into the OpenCCM Interface Repository

The task_IR3_feed task supports the following arguments:

Generating equivalent OMG IDL 2.4 mapping from the OpenCCM Interface Repository

The task_IR3_IDL2 task supports the following arguments:

Generating the Java OpenCCM skeletons from the OpenCCM Interface Repository

The task_IR3_java task supports the following arguments:

Generating all the Java implementation templates from the OpenCCM Interface Repository

The task_IR3_jimpl task supports the following arguments:

Compiling an OMG CIDL file and generating associated files

The task_CIDL_CIF task supports the following arguments:

Generates all Java OpenCCM templates associated to a CIDL file for the CIF

The task_CIF_jimpl task supports the following arguments:

Compiles an OMG PSDL file and generates associated Java mapping

The task_PSDL_JAVA task supports the following arguments:

Feeding an XMI 1.1 UML 1.4 document into the OpenCCM Interface Repository

The task_XMI2IR task supports the following arguments:

Stopping the OpenCCM Interface Repository

The task_IR3_stop task supports the following arguments:

Starting the MOF Repository

The task_mof_start task supports the following arguments:

Stopping the MOF Repository

The task_mof_stop task supports the following arguments:

How to integrate a new piece of code?

Integrating source code into an existing package

If you want to compile a piece of source code which is related to an existing package of OpenCCM, you just have to put your class(es) into the appropriate directory.

No modification of the build process is required in order to take into account your contribution.

Integrating source code into a new package

If you want to compile a new package, you have to follow these steps:

1. Create the directory tree associated to the new package.
2. Put your contribution in the directory.
3. Find the module where the package could take place.
4. Edit the related property file:
   • Edit the name of the package.
   • Edit the name of the archive.
5. Edit the related XML file:
   • Add new entries in the callbacks (init, compile_api, compile_lib, build).
   • Create the task associated to the new entries.

Defining a new module

You have to extend the build process:

1. Find a module name
2. Create the <module_name>.properties file
3. Create the <module_name>.xml file
4. Edit the <module_name>.xml file:
   • Create the required callbacks (init, compile_api, compile_lib and build).
   • Load the associated property file.
5. Edit the build.xml file:
   • Include the new module declaration in the header of the file.
   • Import the content of the XML file.
   • Add the new targets you define through callbacks in the compilation chain.
6. Follow the steps defined in the previous section to compile your packages.