filename = "(none)";
        descriptors = Collections.emptyMap();
        isModuleHierarchy = false;
    }

    /**
     * Finds module information in the given JAR file, output directory, or test output directory.
     * If no module is found, or if module information cannot be extracted, then this constructor
     * builds an empty map.
     *

            } else if (file.getPath().startsWith(File.separator)) {
                // drive-relative Windows path, don't align with project directory but with drive root
                result = file.getAbsolutePath();
            } else {
                // an ordinary relative path, align with project directory
                result = basedir.resolve(path).normalize().toString();
            }
        }

        return result;
    }

import java.nio.file.attribute.BasicFileAttributes;
import java.text.MessageFormat;
import java.util.concurrent.atomic.AtomicLong;

public interface DirectorySnapshotterStatistics {
    /**
     * The number of visited directory trees.
     */
    long getVisitedHierarchyCount();

    /**
     * The number of visited directories.
     */
    long getVisitedDirectoryCount();

    /**
     * The number of visited files.
     */

     * be able to accept <code>relative</code> parameter values that
     * <ul>
     * <li>use either / or \ file path separator,</li>
     * <li>have .. parent directory references,</li>
     * <li>point either at file or directory.</li>
     * </ul>
     *
     * @param relative is the path of the requested source relative to this source
     * @return related source or <code>null</code> if no such source
     */

 */

package org.gradle.process.internal.worker.child;

import java.io.File;

public interface WorkerDirectoryProvider {
    /**
     * Returns a File object representing the working directory for workers.
     */
    File getWorkingDirectory();

/**
 * ModelProcessor
 */
public interface ModelProcessor {

    /**
     * Returns the file containing the pom to be parsed or null if a pom can not be found
     * at the given file or in the given directory.
     */
    @Nullable
    Path locateExistingPom(@Nonnull Path project);

    /**
     * Reads the model from the specified byte stream. The stream will be automatically closed before the method
     * returns.

    /**
     * Updates the cached state at the location with the snapshot.
     */
    void record(FileSystemLocationSnapshot snapshot);

    /**
     * Move a file or directory on the actual file system atomically, and update the cached state without having to re-snapshot content in the new location.
     */
    void moveAtomically(String sourceLocation, String targetLocation) throws IOException;

        generateJavadocs(project, layout, tasks, extension);
    }

    private void generateJavadocs(Project project, ProjectLayout layout, TaskContainer tasks, GradleDocumentationExtension extension) {
        // TODO: Staging directory should be a part of the Javadocs extension
        // TODO: Pull out more of this configuration into the extension if it makes sense
        // TODO: in a typical project, this may need to be the regular javadoc task vs javadocAll

    public DirectoryBuildCache(PersistentCache persistentCache, FileAccessTracker fileAccessTracker, String failedFileSuffix) {
        this.persistentCache = persistentCache;
        // Create temporary files in the cache directory to ensure they are on the same file system,
        // and thus can always be moved into the cache proper atomically
        this.tempFileStore = new DefaultBuildCacheTempFileStore((prefix, suffix) -> {
            try {

                Path rootDirectory;
                try {
                    rootDirectory = request.getSession().getRootDirectory();
                } catch (IllegalStateException e) {
                    // if no root directory, bail out
                    return;
                }
                List<Path> toLoad = new ArrayList<>();
                Path root = defaultModelBuilder.getModelProcessor().locateExistingPom(rootDirectory);