Importing a Java method

> >

Besides importing other ToolDef scripts or its tools, the ToolDef language also allows to import other functionality. As the ToolDef language is implemented in Java, importing other functionality takes the form of importing static Java methods. You can import Java methods under the following conditions:

It must import static Java methods.
The parameter types and return types of imported methods must only use Java data types that are supported by the Tooldef language:
- The Java types boolean, int, long, double, Boolean, Integer, Long, Double, String and Object are supported.
- The Java types of the methods can have type parameters, like T in List<T>. Supported commonly used parameterized types are List<T>, Set<T> and Map<T, U>. If specified, the type of the type parameters T and U must again be Java types that are supported. The wildcard type ? can be used to import methods with unknown or irrelevant types, but the values cannot be used then since they become Object.
- Finally, arrays with supported element types are supported as well. These are converted to lists.

Importing from the classpath

Importing a method that exists in a class available from the classpath is done by giving the absolute name of the method. Note that unlike the ToolDef imports, the Java method imports do not use strings. It uses bare names, without double quotes around them.

As an example, you can convert a number to its notation in the binary numeral system using the java.lang.Integer.toBinaryString method. Using this Java method in a ToolDef script is done as follows:

import java.lang.Integer.toBinaryString;

outln("%s", toBinaryString(123));

In the example, the value 123 is converted. Running the script produces 1111011, which is the 123 value in the binary number system.

Imported methods can be renamed in a similar manner as renaming imported tools or ToolDef scripts. For example:

import java.lang.Integer.toBinaryString as toBin;

This import makes the same method available, except its name in the ToolDef script is now toBin. Using this import is done with for example toBin(123).

Importing from an Eclipse Plugin

The ESCET toolkit consists of many Eclipse plugins. Other software available on the Eclipse platform also uses plugins. Being able to access methods of such plugins is therefore also useful.

ToolDef supports usage of static methods from Eclipse plugins. These imports work in the same way as import of ToolDef tools, except they first state the name of the plugin to access. For example, the ESCET toolkit has a makeInitialUppercase method to change the initial character of a string to upper case, in ESCET’s org.eclipse.escet.common.java plugin. To import that method into ToolDef, you use the following import:

import org.eclipse.escet.common.java:org.eclipse.escet.common.java.Strings.makeInitialUppercase as toInitialUpper;

The line may seem confusing at first sight, but that is due to the convention to give a plugin the same name as the name of its outermost Java package. The org.eclipse.escet.common.java before the colon is the name of the plugin that contains the static method. Within this plugin, the second name org.eclipse.escet.common.java.Strings.makeInitialUppercase is the absolute name of the static makeInitialUppercase method that should be imported. The as toInitialUpper part renames the selected method in ToolDef to toInitialUpper. If you omit the last part, the method becomes available in ToolDef as makeInitialUppercase instead.

After the import, the imported method can be used. For example, after the import the ToolDef statement toInitialUpper("it works!") returns the string "It works!".