override fun execute() {
        try {
            val versionToIncubating = mutableMapOf<Version, MutableSet<IncubatingDescription>>()
            val repositoryRoot = parameters.repositoryRoot.get().asFile.toPath()
            parameters.srcDirs.forEach { srcDir ->
                if (srcDir.exists()) {
                    val collector = CompositeVersionsToIncubatingCollector(
                        listOf(

                    def outputDir = shortName.startsWith('gradle-') ? gradleJars : dependencies
                    def out = new File(outputDir, shortName)
                    Files.copy(zin, out.toPath())
                    zin.closeEntry()
                }
            }
        }
    }

            public
            override fun doExecute(bufferedWriter: BufferedWriter) {
                val packages = Implementation(excludes.get(), includes.get()).collectPackages(classpath.files.map(File::toPath))
                packages.dump(false, object : ErroringAction<String>() {
                    @Throws(Exception::class)
                    override fun doExecute(s: String) {
                        bufferedWriter.write(s)

            }
            return true;
        }

        final File parentFile = outputFile.getParentFile();
        final Path parentPath = parentFile.toPath();
        try {
            Files.createDirectories(parentPath);
        } catch (final IOException e) {
            logger.warn("Failed to create parent directory: {}", parentFile.getAbsolutePath(), e);

        if (!baseDir.exists()) {
            return 0;
        }
        try {
            final FilePurgeVisitor visitor = new FilePurgeVisitor(baseDir.toPath(), imageExtention, expiry);
            Files.walkFileTree(baseDir.toPath(), visitor);
            return visitor.getCount();
        } catch (final Exception e) {
            throw new JobProcessingException(e);
        }
    }

    /**

            public void store(org.codelibs.fess.dict.DictionaryFile<?> file, File tempFile) {
                // Copy tempFile to testFile
                try {
                    java.nio.file.Files.copy(tempFile.toPath(), testFile.toPath(), java.nio.file.StandardCopyOption.REPLACE_EXISTING);
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
        };

                if (!outputFile.exists()) {
                    outputFile.createNewFile();
                }
                // Write some dummy content to simulate actual thumbnail
                Files.write(outputFile.toPath(), ("thumbnail-" + thumbnailId).getBytes());
                return true;
            } catch (IOException e) {
                return false;
            }
        }

        @Override

                // Copy tempFile to the actual file
                try {
                    java.nio.file.Files.copy(tempFile.toPath(), new File(file.getPath()).toPath(),
                            java.nio.file.StandardCopyOption.REPLACE_EXISTING);
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }

    private
    fun File.withUniqueDirectory(prefixPath: String): File =
        Files.createTempDirectory(
            withDirectory(prefixPath.substringBeforeLast("/")).toPath(),
            prefixPath.substringAfterLast("/")
        ).toFile()

    private
    fun File.withDirectory(path: String): File =
        resolve(path).apply {
            mkdirs()
        }

        final Path confPath = getConfPath(names);
        if (Files.exists(confPath)) {
            return confPath;
        }
        return org.codelibs.core.io.ResourceUtil.getResourceAsFile(String.join("/", names)).toPath();
    }

    /**
     * Gets the path to compiled classes directory.
     *
     * @param names the path components to append to the classes directory