public  void addClassPath(Path path) 
{
        this.path = path;
}

Adds the classpath to convert.

 public  void execute() 
{
                                 
        if (name == null) {
          throw new BuildException("Missing 'property' attribute!");
        }
        if (dir == null) {
          throw new BuildException("Missing 'jarfile' attribute!");
        }
        if (getProject().getProperty(name) != null) {
          throw new BuildException("Property '" + name + "' already set!");
        }
        if (path == null) {
            throw new BuildException("Missing nested < classpath >!");
        }
        // Normalize the reference directory (containing the jar)
        final FileUtils fileUtils = FileUtils.getFileUtils();
        dir = fileUtils.normalize(dir.getAbsolutePath());
        // Create as many directory prefixes as parent levels to traverse,
        // in addition to the reference directory itself
        File currDir = dir;
        String[] dirs = new String[maxParentLevels + 1];
        for (int i = 0; i <  maxParentLevels + 1; ++i) {
            dirs[i] = currDir.getAbsolutePath() + File.separatorChar;
            currDir = currDir.getParentFile();
            if (currDir == null) {
                maxParentLevels = i + 1;
                break;
            }
        }
        String[] elements = path.list();
        StringBuffer buffer = new StringBuffer();
        StringBuffer element = new StringBuffer();
        for (int i = 0; i <  elements.length; ++i) {
            // Normalize the current file
            File pathEntry = new File(elements[i]);
            pathEntry = fileUtils.normalize(pathEntry.getAbsolutePath());
            String fullPath = pathEntry.getAbsolutePath();
            // Find the longest prefix shared by the current file
            // and the reference directory.
            String relPath = null;
            for (int j = 0; j < = maxParentLevels; ++j) {
                String dir = dirs[j];
                if (!fullPath.startsWith(dir)) {
                    continue;
                }
                // We have a match! Add as many ../ as parent
                // directory traversed to get the relative path
                element.setLength(0);
                for (int k = 0; k <  j; ++k) {
                    element.append("..");
                    element.append(File.separatorChar);
                }
                element.append(fullPath.substring(dir.length()));
                relPath = element.toString();
                break;
            }
            // No match, so bail out!
            if (relPath == null) {
                throw new BuildException(
                    "No suitable relative path from "
                    + dir + " to " + fullPath);
            }
            // Manifest's ClassPath: attribute always uses forward
            // slashes '/', and is space-separated. Ant will properly
            // format it on 72 columns with proper line continuation
            if (File.separatorChar != '/") {
                relPath = relPath.replace(File.separatorChar, '/");
            }
            if (pathEntry.isDirectory()) {
                relPath = relPath + '/";
            }
            try {
                relPath = Locator.encodeURI(relPath);
            } catch (UnsupportedEncodingException exc) {
                throw new BuildException(exc);
            }
            buffer.append(relPath);
            buffer.append(' ");
        }
        // Finally assign the property with the manifest classpath
        getProject().setNewProperty(name, buffer.toString().trim());
}

Sets a property, which must not already exist, with a space separated list of files and directories relative to the jar file's parent directory.

 public  void setJarFile(File jarfile) 
{
        File parent = jarfile.getParentFile();
        if (!parent.isDirectory()) {
            throw new BuildException("Jar's directory not found: " + parent);
        }
        this.dir = parent;
}

The JAR file to contain the classpath attribute in its manifest.

 public  void setMaxParentLevels(int levels) 
{
        this.maxParentLevels = levels;
}

Sets the maximum parent directory levels allowed when computing a relative path.

 public  void setProperty(String name) 
{
        this.name = name;
}

Sets the property name to hold the classpath value.