https://ant.apache.org/: master POM (The Apache Software Foundation) 
/*
 *  Licensed to the Apache Software Foundation (ASF) under one or more
 *  contributor license agreements.  See the NOTICE file distributed with
 *  this work for additional information regarding copyright ownership.
 *  The ASF licenses this file to You under the Apache License, Version 2.0
 *  (the "License"); you may not use this file except in compliance with
 *  the License.  You may obtain a copy of the License at
 *
 *      https://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 *
 */

package org.apache.tools.ant.types.selectors;

import java.io.File;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

import org.apache.tools.ant.AntClassLoader;
import org.apache.tools.ant.BuildException;
import org.apache.tools.ant.Project;
import org.apache.tools.ant.types.Parameter;
import org.apache.tools.ant.types.Path;
import org.apache.tools.ant.types.Reference;


Selector that selects files by forwarding the request on to other classes.

Since:1.5
/**
 * Selector that selects files by forwarding the request on to other classes.
 *
 * @since 1.5
 */
public class ExtendSelector extends BaseSelector {

    private String classname = null;
    private FileSelector dynselector = null;
    private List<Parameter> parameters =
        Collections.synchronizedList(new ArrayList<>());
    private Path classpath = null;

    
Sets the classname of the custom selector.

Params:
  • classname – is the class which implements this selector
/**
     * Sets the classname of the custom selector.
     *
     * @param classname is the class which implements this selector
     */
    public void setClassname(String classname) {
        this.classname = classname;
    }

    
Instantiates the identified custom selector class.

/**
     * Instantiates the identified custom selector class.
     */
    public void selectorCreate() {
        if (classname != null && !classname.isEmpty()) {
            try {
                Class<?> c;
                if (classpath == null) {
                    c = Class.forName(classname);
                } else {
                    // Memory-Leak in line below
                    AntClassLoader al
                            = getProject().createClassLoader(classpath);
                    c = Class.forName(classname, true, al);
                }
                dynselector = c.asSubclass(FileSelector.class).newInstance();
                final Project p = getProject();
                if (p != null) {
                    p.setProjectReference(dynselector);
                }
            } catch (ClassNotFoundException cnfexcept) {
                setError("Selector " + classname
                    + " not initialized, no such class");
            } catch (InstantiationException iexcept) {
                setError("Selector " + classname
                    + " not initialized, could not create class");
            } catch (IllegalAccessException iaexcept) {
                setError("Selector " + classname
                    + " not initialized, class not accessible");
            }
        } else {
            setError("There is no classname specified");
        }
    }

    
Create new parameters to pass to custom selector.

Params:
  • p – The new Parameter object
/**
     * Create new parameters to pass to custom selector.
     *
     * @param p The new Parameter object
     */
    public void addParam(Parameter p) {
        parameters.add(p);
    }

    
Set the classpath to load the classname specified using an attribute.

Params:
  • classpath – the classpath to use
/**
     * Set the classpath to load the classname specified using an attribute.
     * @param classpath the classpath to use
     */
    public final void setClasspath(Path classpath) {
        if (isReference()) {
            throw tooManyAttributes();
        }
        if (this.classpath == null) {
            this.classpath = classpath;
        } else {
            this.classpath.append(classpath);
        }
    }

    
Specify the classpath to use to load the Selector (nested element).

Returns:a classpath to be configured
/**
     * Specify the classpath to use to load the Selector (nested element).
     * @return a classpath to be configured
     */
    public final Path createClasspath() {
        if (isReference()) {
            throw noChildrenAllowed();
        }
        if (this.classpath == null) {
            this.classpath = new Path(getProject());
        }
        return this.classpath.createPath();
    }

    
Get the classpath

Returns:the classpath
/**
     * Get the classpath
     * @return the classpath
     */
    public final Path getClasspath() {
        return classpath;
    }

    
Set the classpath to use for loading a custom selector by using
a reference.

Params:
  • r – a reference to the classpath
/**
     * Set the classpath to use for loading a custom selector by using
     * a reference.
     * @param r a reference to the classpath
     */
    public void setClasspathref(Reference r) {
        if (isReference()) {
            throw tooManyAttributes();
        }
        createClasspath().setRefid(r);
    }

    
These are errors specific to ExtendSelector only. If there are
errors in the custom selector, it should throw a BuildException
when isSelected() is called.

/**
     * These are errors specific to ExtendSelector only. If there are
     * errors in the custom selector, it should throw a BuildException
     * when isSelected() is called.
     */
    public void verifySettings() {
        // Creation is done here rather than in isSelected() because some
        // containers may do a validation pass before running isSelected(),
        // but we need to check for the existence of the created class.
        if (dynselector == null) {
            selectorCreate();
        }
        if (classname == null || classname.length() < 1) {
            setError("The classname attribute is required");
        } else if (dynselector == null) {
            setError("Internal Error: The custom selector was not created");
        } else if (!(dynselector instanceof ExtendFileSelector)
                    && !parameters.isEmpty()) {
            setError(
                "Cannot set parameters on custom selector that does not implement ExtendFileSelector");
        }
    }

    
Allows the custom selector to choose whether to select a file. This
is also where the Parameters are passed to the custom selector,
since we know we must have them all by now. And since we must know
both classpath and classname, creating the class is deferred to here
as well.

Params:
  • basedir – The the base directory.
  • filename – The name of the file to check.
  • file – A File object for this filename.
Throws:
Returns:whether the file should be selected or not.
/**
     * Allows the custom selector to choose whether to select a file. This
     * is also where the Parameters are passed to the custom selector,
     * since we know we must have them all by now. And since we must know
     * both classpath and classname, creating the class is deferred to here
     * as well.
     * @param basedir The the base directory.
     * @param filename The name of the file to check.
     * @param file A File object for this filename.
     * @return whether the file should be selected or not.
     * @exception BuildException if an error occurs.
     */
    public boolean isSelected(File basedir, String filename, File file)
            throws BuildException {
        validate();
        if (!parameters.isEmpty() && dynselector instanceof ExtendFileSelector) {
            // We know that dynselector must be non-null if no error message
            ((ExtendFileSelector) dynselector).setParameters(
                parameters.toArray(new Parameter[parameters.size()]));
        }
        return dynselector.isSelected(basedir, filename, file);
    }

}