import org.gradle.api.internal.file.FileCollectionStructureVisitor;
import org.gradle.internal.DisplayName;
import org.gradle.internal.component.external.model.ImmutableCapabilities;

/**
 * A visitor over the contents of a {@link ResolvedArtifactSet}. A {@link ResolvedArtifactSet} may contain zero or more sets of files, each set containing zero or more artifacts.
 */
public interface ArtifactVisitor {
    /**

     *
     * @return the display name
     */
    String getDisplayName();

    /**
     * Appends diagnostic information about the contents of this collection to the given formatter.
     */
    TreeFormatter describeContents(TreeFormatter formatter);

    /**

            /**
             * Creates a set that selects the artifacts from this set that match the given criteria.
             * Implementations are lazy, so that the selection happens only when the contents are queried.
             *
             * @param dependencySpec Select only those artifacts reachable from first level dependencies that match the given spec.
             */

import java.io.IOException;

/**
 * A lossy attribute container serializer. It's lossy because it doesn't preserve the attribute
 * types: it will serialize the contents as strings, and read them as strings, only for reporting
 * purposes.
 */
@ServiceScope(Scope.BuildSession.class)

        } else if (isFileInfo(value)) {
            return invokeMethod(value, "getPath", String.class);
        } else {
            return value.toString();
        }
    }

    /**
     * Returns the contents of a {@code FileInfo} or null if the value is not a {@code FileInfo}.
     */
    @Nullable
    private static byte[] getContentsOrNull(@Nullable Object value) throws Exception {
        if (isFileInfo(value)) {

   */
  public static <T extends @Nullable Object> T[] newArray(T[] reference, int length) {
    return Platform.newArray(reference, length);
  }

  /**
   * Returns a new array that contains the concatenated contents of two arrays.
   *
   * @param first the first array of elements to concatenate
   * @param second the second array of elements to concatenate
   * @param type the component type of the returned array
   */

     */
    TaskInputFilePropertyBuilder withNormalizer(Class<? extends FileNormalizer> normalizer);

    /**
     * Ignore directories during up-to-date checks and build cache key calculations.  When this is set, only the contents of directories
     * will be considered, but not the directories themselves.  Changes to empty directories, and directories that
     * contain only empty directories, will be ignored.
     *
     * @since 6.8
     */

import javax.annotation.CheckReturnValue;
import java.io.File;
import java.util.Collection;
import java.util.List;

/**
 * <p>
 * Responsible for updating the file watchers based on changes to the contents of the virtual file system,
 * and changes to the file system hierarchies we are allowed to watch.</p>
 *
 * <p>
 * The following terms are worth distinguishing between:
 * </p>
 *
 * <dl>

        }
    }

    @Nonnull
    private TestFile fromFile(URL resource) throws URISyntaxException {
        return new TestFile(resource.toURI());
    }

    /**
     * Extracts the contents of the jar file containing the given resource so that an (unzipped) file pointing to the
     * requested resources within the resource jar can be returned.
     *

import java.io.Serializable;
import java.util.Map;
import javax.annotation.CheckForNull;
import org.checkerframework.checker.nullness.qual.NonNull;

/**
 * A {@link ClassToInstanceMap} whose contents will never change, with many other important
 * properties detailed at {@link ImmutableCollection}.
 *
 * @author Kevin Bourrillion
 * @since 2.0
 */
@Immutable(containerOf = "B")
@GwtIncompatible