}

        Set<String> foundAdocFiles = new HashSet<>();
        try (Stream<Path> pathStream = Files.walk(Paths.get(directoryPath))) {
            pathStream.filter(Files::isRegularFile)
                .filter(p -> p.toString().endsWith(".adoc"))
                .map(p -> p.getFileName().toString())
                .forEach(foundAdocFiles::add);
        }

                if (Files.isRegularFile(consumer)) {
                    return consumer.toFile();
                }
            }
        }
        Path target = getArtifactPath(artifact);
        return Files.isRegularFile(target) ? target.toFile() : null;
    }

    /**

        result.add(cliOptions);
        // atFile option
        if (cliOptions.atFile().isPresent()) {
            Path file = context.cwd.resolve(cliOptions.atFile().orElseThrow());
            if (Files.isRegularFile(file)) {
                result.add(parseMavenAtFileOptions(file));
            } else {
                throw new IllegalArgumentException("Specified file does not exists (" + file + ")");
            }
        }

                        installationToolchainsFile != null && Files.isRegularFile(installationToolchainsFile)
                                ? Sources.fromPath(installationToolchainsFile)
                                : null)
                .userToolchainsSource(
                        userToolchainsFile != null && Files.isRegularFile(userToolchainsFile)
                                ? Sources.fromPath(userToolchainsFile)

            }
        });
    }

    protected void failIfFileNotExists(LocalContext context, String fileName, String message) {
        Path path = context.cwd.resolve(fileName);
        if (!Files.isRegularFile(path)) {
            context.parsingFailed = true;
            context.parserRequest.logger().error(message + ": " + path);
        }
    }

    protected InvokerRequest getInvokerRequest(LocalContext context) {

        if (context.options().altUserSettings().isPresent()) {
            userSettingsFile =
                    context.cwd.resolve(context.options().altUserSettings().get());

            if (!Files.isRegularFile(userSettingsFile)) {
                throw new FileNotFoundException("The specified user settings file does not exist: " + userSettingsFile);
            }
        } else {
            String userSettingsFileStr =

            ArtifactRepository repository,
            LinkedHashMap<String, Set<String>> candidates) {
        if (metadata != null && metadata.getPath() != null && Files.isRegularFile(metadata.getPath())) {
            try {
                Map<String, ?> options = Collections.singletonMap(MetadataReader.IS_STRICT, Boolean.FALSE);

                Metadata pluginGroupMetadata =

    fun zip(destZip: File, srcDir: File) {
        val srcPath = srcDir.toPath()
        Files.walk(srcPath).use { paths ->
            zip(
                destZip,
                paths.filter { Files.isRegularFile(it, LinkOption.NOFOLLOW_LINKS) }
                    .map { srcPath.relativize(it).toString() to it.toFile() }
                    .toList()
            )
        }
    }

    private

                    try {
                        final Path path = Paths.get(LaServletContextUtil.getServletContext().getRealPath(key));
                        if (Files.isRegularFile(path)) {
                            return Files.getLastModifiedTime(path).toMillis();
                        }
                    } catch (final Exception e) {

                Path path = topDirectory.resolve(stripLeadingAndTrailingQuotes(arg));
                if (Files.isDirectory(path)) {
                    topDirectory = path;
                } else if (Files.isRegularFile(path)) {
                    topDirectory = path.getParent();
                    if (!Files.isDirectory(topDirectory)) {
                        System.err.println("Directory " + topDirectory