Laura Kassovic <******@****.***> 1701107622 -0800

import java.util.Collections;

public class AntFileCollectionMatchingTaskBuilder implements AntBuilderAware {

    private final Iterable<DirectoryTree> fileTrees;

    public AntFileCollectionMatchingTaskBuilder(Iterable<DirectoryTree> fileTrees) {
        this.fileTrees = fileTrees;
    }

    @Override
    public Object addToAntBuilder(final Object node, final String childNodeName) {

    private final Collection<? extends FileTreeInternal> fileTrees;

    public DefaultCompositeFileTree(TaskDependencyFactory taskDependencyFactory, Factory<PatternSet> patternSetFactory, List<? extends FileTreeInternal> fileTrees) {
        super(taskDependencyFactory, patternSetFactory);
        this.fileTrees = fileTrees;
    }

    @Override

                // TODO - add some convenient way to visit the files of the tree without collecting them into a set
                files.addAll(fileTree.getFiles());
            }

            @Override
            public void visitFileTree(File root, PatternSet patterns, FileTreeInternal fileTree) {
                addTreeContents(fileTree);
            }

            @Override

        and:
        configurationCache.assertStateLoaded()

        where:
        [pattern, fileTree] << [fileTreeOperators(), fileTrees()].combinations()
        isZip = fileTree.toString().startsWith('zip')
    }

    private List<String> fileTrees() {
        [
            "fileTree(dir: 'src', include: '**/*.*')",
            "zipTree('src.zip')",
        ]
    }

class DefaultCompositeFileTreeTest extends WorkspaceTest {

    private DefaultCompositeFileTree newCompositeFileTree(List<? extends FileTreeInternal> fileTrees) {
        new DefaultCompositeFileTree(TestFiles.taskDependencyFactory(), TestFiles.patternSetFactory, fileTrees)
    }

    def "can be empty"() {
        when:
        def ft = newCompositeFileTree([])

        then:
        ft.files.isEmpty()
    }

            return fileTrees.get(0);
        } else {
            return new DefaultCompositeFileTree(taskDependencyFactory, patternSetFactory, ImmutableList.copyOf(fileTrees));
        }
    }

    @Override
    public FileTreeInternal treeOf(MinimalFileTree tree) {
        return new FileTreeAdapter(tree, listener, taskDependencyFactory, patternSetFactory);
    }

    @Override

    override suspend fun ReadContext.decode(): FileTreeInternal? =
        decodePreservingIdentity { id ->
            val specs = readNonNull<List<FileTreeSpec>>()
            val fileTrees = specs.map(::fromSpec)
            val tree = fileCollectionFactory.treeOf(fileTrees)
            isolate.identities.putInstance(id, tree)
            tree
        }

    private
    fun rootSpecOf(value: FileTreeInternal): List<FileTreeSpec> {

     *
     * <p>The tree is not live. The provided list is queried on construction and discarded.
     */
    FileTreeInternal treeOf(List<? extends FileTreeInternal> fileTrees);

    FileTreeInternal treeOf(MinimalFileTree tree);

    static FileTreeInternal emptyTree() {
        return EmptyFileTree.INSTANCE;
    }

    static FileTreeInternal emptyTree(String displayName) {

* iterate over them (depth first)
* filter them (using link:{javadocPath}/org/gradle/api/file/FileTree.html#matching-org.gradle.api.Action-[FileTree.matching(org.gradle.api.Action)] and Ant-style patterns)
* merge them

You can also traverse file trees using the link:{javadocPath}/org/gradle/api/file/FileTree.html#visit-org.gradle.api.Action-[FileTree.visit(org.gradle.api.Action)] method.
All of these techniques are demonstrated in the following example: